{"version":3,"file":"npm.formatjs-86e7b507-42ea658799203c8c67cc.chunk.js","mappings":"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c7F,KAAK8G,SACvC9G,KAAK0H,MAEb,EAKA1B,EAAO3F,UAAU8G,KAAO,WACpB,GAAInH,KAAK6G,QACL,OAAO,KAEX,IAAIrC,EAAOxE,KAAK8G,OACZZ,EAASlG,KAAKkG,SACd8I,EAAWhP,KAAKiG,QAAQX,WAAWY,GAAU1B,GAAQ,MAAU,EAAI,IACvE,OAAoB,OAAbwK,QAAkC,IAAbA,EAAsBA,EAAW,IACjE,EACOhJ,CACX,CA/yB2B,GAszB3B,SAASuB,EAAS2B,GACd,OAASA,GAAa,IAAMA,GAAa,KACpCA,GAAa,IAAMA,GAAa,EACzC,CA8BA,SAASrD,EAAcD,GACnB,OAASA,GAAK,GAAUA,GAAK,IACnB,KAANA,GACM,MAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,CACR,CAKA,SAASE,EAAiBF,GACtB,OAASA,GAAK,IAAUA,GAAK,IACnB,KAANA,GACCA,GAAK,IAAUA,GAAK,IACf,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACCA,GAAK,IAAUA,GAAK,IACpBA,GAAK,IAAUA,GAAK,IACpBA,GAAK,IAAUA,GAAK,IACpBA,GAAK,IAAUA,GAAK,IACf,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,KAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACCA,GAAK,KAAUA,GAAK,KACf,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACM,MAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACM,OAANA,GACM,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,KACf,OAANA,GACM,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACpBA,GAAK,MAAUA,GAAK,MACf,OAANA,GACCA,GAAK,MAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACCA,GAAK,OAAUA,GAAK,OACpBA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,OACf,QAANA,GACM,QAANA,GACM,QAANA,GACM,QAANA,GACCA,GAAK,OAAUA,GAAK,KAC7B,CEvvCA,SAASqJ,EAAcC,GACnBA,EAAIC,SAAQ,SAAUC,GAElB,UADOA,EAAGvH,UACN,QAAgBuH,KAAO,QAAgBA,GACvC,IAAK,IAAIpK,KAAKoK,EAAGlQ,eACNkQ,EAAGlQ,QAAQ8F,GAAG6C,SACrBoH,EAAcG,EAAGlQ,QAAQ8F,GAAGrF,YAG3B,QAAgByP,KAAO,QAAiBA,EAAG/E,UAG1C,QAAc+E,KAAO,QAAcA,MACzC,QAAmBA,EAAG/E,cAHf+E,EAAG/E,MAAMxC,UAMX,QAAauH,IAClBH,EAAcG,EAAG/G,SAEzB,GACJ,CACO,SAAS7B,EAAMP,EAASoJ,QACd,IAATA,IAAmBA,EAAO,CAAC,GAC/BA,GAAO,QAAS,CAAE9I,sBAAsB,EAAMD,qBAAqB,GAAQ+I,GAC3E,IAAItI,EAAS,IAAI,EAAOd,EAASoJ,GAAM7I,QACvC,GAAIO,EAAOE,IAAK,CACZ,IAAIG,EAAQkI,YAAYjO,EAAU0F,EAAOE,IAAIyH,OAK7C,MAHAtH,EAAMS,SAAWd,EAAOE,IAAIY,SAE5BT,EAAMmI,gBAAkBxI,EAAOE,IAAIhB,QAC7BmB,CACV,CAIA,OAHe,OAATiI,QAA0B,IAATA,OAAkB,EAASA,EAAKG,kBACnDP,EAAclI,EAAOG,KAElBH,EAAOG,GAClB,C","sources":["webpack://netopia-payments/./node_modules/@formatjs/fast-memoize/lib/index.js","webpack://netopia-payments/./node_modules/@formatjs/icu-messageformat-parser/lib/error.js","webpack://netopia-payments/./node_modules/@formatjs/icu-messageformat-parser/lib/parser.js","webpack://netopia-payments/./node_modules/@formatjs/icu-messageformat-parser/lib/date-time-pattern-generator.js","webpack://netopia-payments/./node_modules/@formatjs/icu-messageformat-parser/lib/index.js"],"sourcesContent":["//\n// Main\n//\nexport function memoize(fn, options) {\n    var cache = options && options.cache ? options.cache : cacheDefault;\n    var serializer = options && options.serializer ? options.serializer : serializerDefault;\n    var strategy = options && options.strategy ? options.strategy : strategyDefault;\n    return strategy(fn, {\n        cache: cache,\n        serializer: serializer,\n    });\n}\n//\n// Strategy\n//\nfunction isPrimitive(value) {\n    return (value == null || typeof value === 'number' || typeof value === 'boolean'); // || typeof value === \"string\" 'unsafe' primitive for our needs\n}\nfunction monadic(fn, cache, serializer, arg) {\n    var cacheKey = isPrimitive(arg) ? arg : serializer(arg);\n    var computedValue = cache.get(cacheKey);\n    if (typeof computedValue === 'undefined') {\n        computedValue = fn.call(this, arg);\n        cache.set(cacheKey, computedValue);\n    }\n    return computedValue;\n}\nfunction variadic(fn, cache, serializer) {\n    var args = Array.prototype.slice.call(arguments, 3);\n    var cacheKey = serializer(args);\n    var computedValue = cache.get(cacheKey);\n    if (typeof computedValue === 'undefined') {\n        computedValue = fn.apply(this, args);\n        cache.set(cacheKey, computedValue);\n    }\n    return computedValue;\n}\nfunction assemble(fn, context, strategy, cache, serialize) {\n    return strategy.bind(context, fn, cache, serialize);\n}\nfunction strategyDefault(fn, options) {\n    var strategy = fn.length === 1 ? monadic : variadic;\n    return assemble(fn, this, strategy, options.cache.create(), options.serializer);\n}\nfunction strategyVariadic(fn, options) {\n    return assemble(fn, this, variadic, options.cache.create(), options.serializer);\n}\nfunction strategyMonadic(fn, options) {\n    return assemble(fn, this, monadic, options.cache.create(), options.serializer);\n}\n//\n// Serializer\n//\nvar serializerDefault = function () {\n    return JSON.stringify(arguments);\n};\n//\n// Cache\n//\nvar ObjectWithoutPrototypeCache = /** @class */ (function () {\n    function ObjectWithoutPrototypeCache() {\n        this.cache = Object.create(null);\n    }\n    ObjectWithoutPrototypeCache.prototype.get = function (key) {\n        return this.cache[key];\n    };\n    ObjectWithoutPrototypeCache.prototype.set = function (key, value) {\n        this.cache[key] = value;\n    };\n    return ObjectWithoutPrototypeCache;\n}());\nvar cacheDefault = {\n    create: function create() {\n        return new ObjectWithoutPrototypeCache();\n    },\n};\nexport var strategies = {\n    variadic: strategyVariadic,\n    monadic: strategyMonadic,\n};\n","export var ErrorKind;\n(function (ErrorKind) {\n    /** Argument is unclosed (e.g. `{0`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_CLOSING_BRACE\"] = 1] = \"EXPECT_ARGUMENT_CLOSING_BRACE\";\n    /** Argument is empty (e.g. `{}`). */\n    ErrorKind[ErrorKind[\"EMPTY_ARGUMENT\"] = 2] = \"EMPTY_ARGUMENT\";\n    /** Argument is malformed (e.g. `{foo!}``) */\n    ErrorKind[ErrorKind[\"MALFORMED_ARGUMENT\"] = 3] = \"MALFORMED_ARGUMENT\";\n    /** Expect an argument type (e.g. `{foo,}`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_TYPE\"] = 4] = \"EXPECT_ARGUMENT_TYPE\";\n    /** Unsupported argument type (e.g. `{foo,foo}`) */\n    ErrorKind[ErrorKind[\"INVALID_ARGUMENT_TYPE\"] = 5] = \"INVALID_ARGUMENT_TYPE\";\n    /** Expect an argument style (e.g. `{foo, number, }`) */\n    ErrorKind[ErrorKind[\"EXPECT_ARGUMENT_STYLE\"] = 6] = \"EXPECT_ARGUMENT_STYLE\";\n    /** The number skeleton is invalid. */\n    ErrorKind[ErrorKind[\"INVALID_NUMBER_SKELETON\"] = 7] = \"INVALID_NUMBER_SKELETON\";\n    /** The date time skeleton is invalid. */\n    ErrorKind[ErrorKind[\"INVALID_DATE_TIME_SKELETON\"] = 8] = \"INVALID_DATE_TIME_SKELETON\";\n    /** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */\n    ErrorKind[ErrorKind[\"EXPECT_NUMBER_SKELETON\"] = 9] = \"EXPECT_NUMBER_SKELETON\";\n    /** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */\n    ErrorKind[ErrorKind[\"EXPECT_DATE_TIME_SKELETON\"] = 10] = \"EXPECT_DATE_TIME_SKELETON\";\n    /** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */\n    ErrorKind[ErrorKind[\"UNCLOSED_QUOTE_IN_ARGUMENT_STYLE\"] = 11] = \"UNCLOSED_QUOTE_IN_ARGUMENT_STYLE\";\n    /** Missing select argument options (e.g. `{foo, select}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_OPTIONS\"] = 12] = \"EXPECT_SELECT_ARGUMENT_OPTIONS\";\n    /** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE\"] = 13] = \"EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE\";\n    /** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */\n    ErrorKind[ErrorKind[\"INVALID_PLURAL_ARGUMENT_OFFSET_VALUE\"] = 14] = \"INVALID_PLURAL_ARGUMENT_OFFSET_VALUE\";\n    /** Expecting a selector in `select` argument (e.g `{foo, select}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_SELECTOR\"] = 15] = \"EXPECT_SELECT_ARGUMENT_SELECTOR\";\n    /** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_SELECTOR\"] = 16] = \"EXPECT_PLURAL_ARGUMENT_SELECTOR\";\n    /** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */\n    ErrorKind[ErrorKind[\"EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\"] = 17] = \"EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\";\n    /**\n     * Expecting a message fragment after the `plural` or `selectordinal` selector\n     * (e.g. `{foo, plural, one}`)\n     */\n    ErrorKind[ErrorKind[\"EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT\"] = 18] = \"EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT\";\n    /** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */\n    ErrorKind[ErrorKind[\"INVALID_PLURAL_ARGUMENT_SELECTOR\"] = 19] = \"INVALID_PLURAL_ARGUMENT_SELECTOR\";\n    /**\n     * Duplicate selectors in `plural` or `selectordinal` argument.\n     * (e.g. {foo, plural, one {#} one {#}})\n     */\n    ErrorKind[ErrorKind[\"DUPLICATE_PLURAL_ARGUMENT_SELECTOR\"] = 20] = \"DUPLICATE_PLURAL_ARGUMENT_SELECTOR\";\n    /** Duplicate selectors in `select` argument.\n     * (e.g. {foo, select, apple {apple} apple {apple}})\n     */\n    ErrorKind[ErrorKind[\"DUPLICATE_SELECT_ARGUMENT_SELECTOR\"] = 21] = \"DUPLICATE_SELECT_ARGUMENT_SELECTOR\";\n    /** Plural or select argument option must have `other` clause. */\n    ErrorKind[ErrorKind[\"MISSING_OTHER_CLAUSE\"] = 22] = \"MISSING_OTHER_CLAUSE\";\n    /** The tag is malformed. (e.g. `<bold!>foo</bold!>) */\n    ErrorKind[ErrorKind[\"INVALID_TAG\"] = 23] = \"INVALID_TAG\";\n    /** The tag name is invalid. (e.g. `<123>foo</123>`) */\n    ErrorKind[ErrorKind[\"INVALID_TAG_NAME\"] = 25] = \"INVALID_TAG_NAME\";\n    /** The closing tag does not match the opening tag. (e.g. `<bold>foo</italic>`) */\n    ErrorKind[ErrorKind[\"UNMATCHED_CLOSING_TAG\"] = 26] = \"UNMATCHED_CLOSING_TAG\";\n    /** The opening tag has unmatched closing tag. (e.g. `<bold>foo`) */\n    ErrorKind[ErrorKind[\"UNCLOSED_TAG\"] = 27] = \"UNCLOSED_TAG\";\n})(ErrorKind || (ErrorKind = {}));\n","var _a;\nimport { __assign } from \"tslib\";\nimport { ErrorKind } from './error';\nimport { SKELETON_TYPE, TYPE, } from './types';\nimport { SPACE_SEPARATOR_REGEX } from './regex.generated';\nimport { parseNumberSkeleton, parseNumberSkeletonFromString, parseDateTimeSkeleton, } from '@formatjs/icu-skeleton-parser';\nimport { getBestPattern } from './date-time-pattern-generator';\nvar SPACE_SEPARATOR_START_REGEX = new RegExp(\"^\".concat(SPACE_SEPARATOR_REGEX.source, \"*\"));\nvar SPACE_SEPARATOR_END_REGEX = new RegExp(\"\".concat(SPACE_SEPARATOR_REGEX.source, \"*$\"));\nfunction createLocation(start, end) {\n    return { start: start, end: end };\n}\n// #region Ponyfills\n// Consolidate these variables up top for easier toggling during debugging\nvar hasNativeStartsWith = !!String.prototype.startsWith && '_a'.startsWith('a', 1);\nvar hasNativeFromCodePoint = !!String.fromCodePoint;\nvar hasNativeFromEntries = !!Object.fromEntries;\nvar hasNativeCodePointAt = !!String.prototype.codePointAt;\nvar hasTrimStart = !!String.prototype.trimStart;\nvar hasTrimEnd = !!String.prototype.trimEnd;\nvar hasNativeIsSafeInteger = !!Number.isSafeInteger;\nvar isSafeInteger = hasNativeIsSafeInteger\n    ? Number.isSafeInteger\n    : function (n) {\n        return (typeof n === 'number' &&\n            isFinite(n) &&\n            Math.floor(n) === n &&\n            Math.abs(n) <= 0x1fffffffffffff);\n    };\n// IE11 does not support y and u.\nvar REGEX_SUPPORTS_U_AND_Y = true;\ntry {\n    var re = RE('([^\\\\p{White_Space}\\\\p{Pattern_Syntax}]*)', 'yu');\n    /**\n     * legacy Edge or Xbox One browser\n     * Unicode flag support: supported\n     * Pattern_Syntax support: not supported\n     * See https://github.com/formatjs/formatjs/issues/2822\n     */\n    REGEX_SUPPORTS_U_AND_Y = ((_a = re.exec('a')) === null || _a === void 0 ? void 0 : _a[0]) === 'a';\n}\ncatch (_) {\n    REGEX_SUPPORTS_U_AND_Y = false;\n}\nvar startsWith = hasNativeStartsWith\n    ? // Native\n        function startsWith(s, search, position) {\n            return s.startsWith(search, position);\n        }\n    : // For IE11\n        function startsWith(s, search, position) {\n            return s.slice(position, position + search.length) === search;\n        };\nvar fromCodePoint = hasNativeFromCodePoint\n    ? String.fromCodePoint\n    : // IE11\n        function fromCodePoint() {\n            var codePoints = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                codePoints[_i] = arguments[_i];\n            }\n            var elements = '';\n            var length = codePoints.length;\n            var i = 0;\n            var code;\n            while (length > i) {\n                code = codePoints[i++];\n                if (code > 0x10ffff)\n                    throw RangeError(code + ' is not a valid code point');\n                elements +=\n                    code < 0x10000\n                        ? String.fromCharCode(code)\n                        : String.fromCharCode(((code -= 0x10000) >> 10) + 0xd800, (code % 0x400) + 0xdc00);\n            }\n            return elements;\n        };\nvar fromEntries = \n// native\nhasNativeFromEntries\n    ? Object.fromEntries\n    : // Ponyfill\n        function fromEntries(entries) {\n            var obj = {};\n            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n                var _a = entries_1[_i], k = _a[0], v = _a[1];\n                obj[k] = v;\n            }\n            return obj;\n        };\nvar codePointAt = hasNativeCodePointAt\n    ? // Native\n        function codePointAt(s, index) {\n            return s.codePointAt(index);\n        }\n    : // IE 11\n        function codePointAt(s, index) {\n            var size = s.length;\n            if (index < 0 || index >= size) {\n                return undefined;\n            }\n            var first = s.charCodeAt(index);\n            var second;\n            return first < 0xd800 ||\n                first > 0xdbff ||\n                index + 1 === size ||\n                (second = s.charCodeAt(index + 1)) < 0xdc00 ||\n                second > 0xdfff\n                ? first\n                : ((first - 0xd800) << 10) + (second - 0xdc00) + 0x10000;\n        };\nvar trimStart = hasTrimStart\n    ? // Native\n        function trimStart(s) {\n            return s.trimStart();\n        }\n    : // Ponyfill\n        function trimStart(s) {\n            return s.replace(SPACE_SEPARATOR_START_REGEX, '');\n        };\nvar trimEnd = hasTrimEnd\n    ? // Native\n        function trimEnd(s) {\n            return s.trimEnd();\n        }\n    : // Ponyfill\n        function trimEnd(s) {\n            return s.replace(SPACE_SEPARATOR_END_REGEX, '');\n        };\n// Prevent minifier to translate new RegExp to literal form that might cause syntax error on IE11.\nfunction RE(s, flag) {\n    return new RegExp(s, flag);\n}\n// #endregion\nvar matchIdentifierAtIndex;\nif (REGEX_SUPPORTS_U_AND_Y) {\n    // Native\n    var IDENTIFIER_PREFIX_RE_1 = RE('([^\\\\p{White_Space}\\\\p{Pattern_Syntax}]*)', 'yu');\n    matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {\n        var _a;\n        IDENTIFIER_PREFIX_RE_1.lastIndex = index;\n        var match = IDENTIFIER_PREFIX_RE_1.exec(s);\n        return (_a = match[1]) !== null && _a !== void 0 ? _a : '';\n    };\n}\nelse {\n    // IE11\n    matchIdentifierAtIndex = function matchIdentifierAtIndex(s, index) {\n        var match = [];\n        while (true) {\n            var c = codePointAt(s, index);\n            if (c === undefined || _isWhiteSpace(c) || _isPatternSyntax(c)) {\n                break;\n            }\n            match.push(c);\n            index += c >= 0x10000 ? 2 : 1;\n        }\n        return fromCodePoint.apply(void 0, match);\n    };\n}\nvar Parser = /** @class */ (function () {\n    function Parser(message, options) {\n        if (options === void 0) { options = {}; }\n        this.message = message;\n        this.position = { offset: 0, line: 1, column: 1 };\n        this.ignoreTag = !!options.ignoreTag;\n        this.locale = options.locale;\n        this.requiresOtherClause = !!options.requiresOtherClause;\n        this.shouldParseSkeletons = !!options.shouldParseSkeletons;\n    }\n    Parser.prototype.parse = function () {\n        if (this.offset() !== 0) {\n            throw Error('parser can only be used once');\n        }\n        return this.parseMessage(0, '', false);\n    };\n    Parser.prototype.parseMessage = function (nestingLevel, parentArgType, expectingCloseTag) {\n        var elements = [];\n        while (!this.isEOF()) {\n            var char = this.char();\n            if (char === 123 /* `{` */) {\n                var result = this.parseArgument(nestingLevel, expectingCloseTag);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n            else if (char === 125 /* `}` */ && nestingLevel > 0) {\n                break;\n            }\n            else if (char === 35 /* `#` */ &&\n                (parentArgType === 'plural' || parentArgType === 'selectordinal')) {\n                var position = this.clonePosition();\n                this.bump();\n                elements.push({\n                    type: TYPE.pound,\n                    location: createLocation(position, this.clonePosition()),\n                });\n            }\n            else if (char === 60 /* `<` */ &&\n                !this.ignoreTag &&\n                this.peek() === 47 // char code for '/'\n            ) {\n                if (expectingCloseTag) {\n                    break;\n                }\n                else {\n                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(this.clonePosition(), this.clonePosition()));\n                }\n            }\n            else if (char === 60 /* `<` */ &&\n                !this.ignoreTag &&\n                _isAlpha(this.peek() || 0)) {\n                var result = this.parseTag(nestingLevel, parentArgType);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n            else {\n                var result = this.parseLiteral(nestingLevel, parentArgType);\n                if (result.err) {\n                    return result;\n                }\n                elements.push(result.val);\n            }\n        }\n        return { val: elements, err: null };\n    };\n    /**\n     * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the\n     * [custom element name][] except that a dash is NOT always mandatory and uppercase letters\n     * are accepted:\n     *\n     * ```\n     * tag ::= \"<\" tagName (whitespace)* \"/>\" | \"<\" tagName (whitespace)* \">\" message \"</\" tagName (whitespace)* \">\"\n     * tagName ::= [a-z] (PENChar)*\n     * PENChar ::=\n     *     \"-\" | \".\" | [0-9] | \"_\" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |\n     *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |\n     *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]\n     * ```\n     *\n     * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name\n     * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do\n     * since other tag-based engines like React allow it\n     */\n    Parser.prototype.parseTag = function (nestingLevel, parentArgType) {\n        var startPosition = this.clonePosition();\n        this.bump(); // `<`\n        var tagName = this.parseTagName();\n        this.bumpSpace();\n        if (this.bumpIf('/>')) {\n            // Self closing tag\n            return {\n                val: {\n                    type: TYPE.literal,\n                    value: \"<\".concat(tagName, \"/>\"),\n                    location: createLocation(startPosition, this.clonePosition()),\n                },\n                err: null,\n            };\n        }\n        else if (this.bumpIf('>')) {\n            var childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);\n            if (childrenResult.err) {\n                return childrenResult;\n            }\n            var children = childrenResult.val;\n            // Expecting a close tag\n            var endTagStartPosition = this.clonePosition();\n            if (this.bumpIf('</')) {\n                if (this.isEOF() || !_isAlpha(this.char())) {\n                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));\n                }\n                var closingTagNameStartPosition = this.clonePosition();\n                var closingTagName = this.parseTagName();\n                if (tagName !== closingTagName) {\n                    return this.error(ErrorKind.UNMATCHED_CLOSING_TAG, createLocation(closingTagNameStartPosition, this.clonePosition()));\n                }\n                this.bumpSpace();\n                if (!this.bumpIf('>')) {\n                    return this.error(ErrorKind.INVALID_TAG, createLocation(endTagStartPosition, this.clonePosition()));\n                }\n                return {\n                    val: {\n                        type: TYPE.tag,\n                        value: tagName,\n                        children: children,\n                        location: createLocation(startPosition, this.clonePosition()),\n                    },\n                    err: null,\n                };\n            }\n            else {\n                return this.error(ErrorKind.UNCLOSED_TAG, createLocation(startPosition, this.clonePosition()));\n            }\n        }\n        else {\n            return this.error(ErrorKind.INVALID_TAG, createLocation(startPosition, this.clonePosition()));\n        }\n    };\n    /**\n     * This method assumes that the caller has peeked ahead for the first tag character.\n     */\n    Parser.prototype.parseTagName = function () {\n        var startOffset = this.offset();\n        this.bump(); // the first tag name character\n        while (!this.isEOF() && _isPotentialElementNameChar(this.char())) {\n            this.bump();\n        }\n        return this.message.slice(startOffset, this.offset());\n    };\n    Parser.prototype.parseLiteral = function (nestingLevel, parentArgType) {\n        var start = this.clonePosition();\n        var value = '';\n        while (true) {\n            var parseQuoteResult = this.tryParseQuote(parentArgType);\n            if (parseQuoteResult) {\n                value += parseQuoteResult;\n                continue;\n            }\n            var parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);\n            if (parseUnquotedResult) {\n                value += parseUnquotedResult;\n                continue;\n            }\n            var parseLeftAngleResult = this.tryParseLeftAngleBracket();\n            if (parseLeftAngleResult) {\n                value += parseLeftAngleResult;\n                continue;\n            }\n            break;\n        }\n        var location = createLocation(start, this.clonePosition());\n        return {\n            val: { type: TYPE.literal, value: value, location: location },\n            err: null,\n        };\n    };\n    Parser.prototype.tryParseLeftAngleBracket = function () {\n        if (!this.isEOF() &&\n            this.char() === 60 /* `<` */ &&\n            (this.ignoreTag ||\n                // If at the opening tag or closing tag position, bail.\n                !_isAlphaOrSlash(this.peek() || 0))) {\n            this.bump(); // `<`\n            return '<';\n        }\n        return null;\n    };\n    /**\n     * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes\n     * a character that requires quoting (that is, \"only where needed\"), and works the same in\n     * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.\n     */\n    Parser.prototype.tryParseQuote = function (parentArgType) {\n        if (this.isEOF() || this.char() !== 39 /* `'` */) {\n            return null;\n        }\n        // Parse escaped char following the apostrophe, or early return if there is no escaped char.\n        // Check if is valid escaped character\n        switch (this.peek()) {\n            case 39 /* `'` */:\n                // double quote, should return as a single quote.\n                this.bump();\n                this.bump();\n                return \"'\";\n            // '{', '<', '>', '}'\n            case 123:\n            case 60:\n            case 62:\n            case 125:\n                break;\n            case 35: // '#'\n                if (parentArgType === 'plural' || parentArgType === 'selectordinal') {\n                    break;\n                }\n                return null;\n            default:\n                return null;\n        }\n        this.bump(); // apostrophe\n        var codePoints = [this.char()]; // escaped char\n        this.bump();\n        // read chars until the optional closing apostrophe is found\n        while (!this.isEOF()) {\n            var ch = this.char();\n            if (ch === 39 /* `'` */) {\n                if (this.peek() === 39 /* `'` */) {\n                    codePoints.push(39);\n                    // Bump one more time because we need to skip 2 characters.\n                    this.bump();\n                }\n                else {\n                    // Optional closing apostrophe.\n                    this.bump();\n                    break;\n                }\n            }\n            else {\n                codePoints.push(ch);\n            }\n            this.bump();\n        }\n        return fromCodePoint.apply(void 0, codePoints);\n    };\n    Parser.prototype.tryParseUnquoted = function (nestingLevel, parentArgType) {\n        if (this.isEOF()) {\n            return null;\n        }\n        var ch = this.char();\n        if (ch === 60 /* `<` */ ||\n            ch === 123 /* `{` */ ||\n            (ch === 35 /* `#` */ &&\n                (parentArgType === 'plural' || parentArgType === 'selectordinal')) ||\n            (ch === 125 /* `}` */ && nestingLevel > 0)) {\n            return null;\n        }\n        else {\n            this.bump();\n            return fromCodePoint(ch);\n        }\n    };\n    Parser.prototype.parseArgument = function (nestingLevel, expectingCloseTag) {\n        var openingBracePosition = this.clonePosition();\n        this.bump(); // `{`\n        this.bumpSpace();\n        if (this.isEOF()) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        if (this.char() === 125 /* `}` */) {\n            this.bump();\n            return this.error(ErrorKind.EMPTY_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        // argument name\n        var value = this.parseIdentifierIfPossible().value;\n        if (!value) {\n            return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        this.bumpSpace();\n        if (this.isEOF()) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        switch (this.char()) {\n            // Simple argument: `{name}`\n            case 125 /* `}` */: {\n                this.bump(); // `}`\n                return {\n                    val: {\n                        type: TYPE.argument,\n                        // value does not include the opening and closing braces.\n                        value: value,\n                        location: createLocation(openingBracePosition, this.clonePosition()),\n                    },\n                    err: null,\n                };\n            }\n            // Argument with options: `{name, format, ...}`\n            case 44 /* `,` */: {\n                this.bump(); // `,`\n                this.bumpSpace();\n                if (this.isEOF()) {\n                    return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n                }\n                return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);\n            }\n            default:\n                return this.error(ErrorKind.MALFORMED_ARGUMENT, createLocation(openingBracePosition, this.clonePosition()));\n        }\n    };\n    /**\n     * Advance the parser until the end of the identifier, if it is currently on\n     * an identifier character. Return an empty string otherwise.\n     */\n    Parser.prototype.parseIdentifierIfPossible = function () {\n        var startingPosition = this.clonePosition();\n        var startOffset = this.offset();\n        var value = matchIdentifierAtIndex(this.message, startOffset);\n        var endOffset = startOffset + value.length;\n        this.bumpTo(endOffset);\n        var endPosition = this.clonePosition();\n        var location = createLocation(startingPosition, endPosition);\n        return { value: value, location: location };\n    };\n    Parser.prototype.parseArgumentOptions = function (nestingLevel, expectingCloseTag, value, openingBracePosition) {\n        var _a;\n        // Parse this range:\n        // {name, type, style}\n        //        ^---^\n        var typeStartPosition = this.clonePosition();\n        var argType = this.parseIdentifierIfPossible().value;\n        var typeEndPosition = this.clonePosition();\n        switch (argType) {\n            case '':\n                // Expecting a style string number, date, time, plural, selectordinal, or select.\n                return this.error(ErrorKind.EXPECT_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));\n            case 'number':\n            case 'date':\n            case 'time': {\n                // Parse this range:\n                // {name, number, style}\n                //              ^-------^\n                this.bumpSpace();\n                var styleAndLocation = null;\n                if (this.bumpIf(',')) {\n                    this.bumpSpace();\n                    var styleStartPosition = this.clonePosition();\n                    var result = this.parseSimpleArgStyleIfPossible();\n                    if (result.err) {\n                        return result;\n                    }\n                    var style = trimEnd(result.val);\n                    if (style.length === 0) {\n                        return this.error(ErrorKind.EXPECT_ARGUMENT_STYLE, createLocation(this.clonePosition(), this.clonePosition()));\n                    }\n                    var styleLocation = createLocation(styleStartPosition, this.clonePosition());\n                    styleAndLocation = { style: style, styleLocation: styleLocation };\n                }\n                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n                if (argCloseResult.err) {\n                    return argCloseResult;\n                }\n                var location_1 = createLocation(openingBracePosition, this.clonePosition());\n                // Extract style or skeleton\n                if (styleAndLocation && startsWith(styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style, '::', 0)) {\n                    // Skeleton starts with `::`.\n                    var skeleton = trimStart(styleAndLocation.style.slice(2));\n                    if (argType === 'number') {\n                        var result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);\n                        if (result.err) {\n                            return result;\n                        }\n                        return {\n                            val: { type: TYPE.number, value: value, location: location_1, style: result.val },\n                            err: null,\n                        };\n                    }\n                    else {\n                        if (skeleton.length === 0) {\n                            return this.error(ErrorKind.EXPECT_DATE_TIME_SKELETON, location_1);\n                        }\n                        var dateTimePattern = skeleton;\n                        // Get \"best match\" pattern only if locale is passed, if not, let it\n                        // pass as-is where `parseDateTimeSkeleton()` will throw an error\n                        // for unsupported patterns.\n                        if (this.locale) {\n                            dateTimePattern = getBestPattern(skeleton, this.locale);\n                        }\n                        var style = {\n                            type: SKELETON_TYPE.dateTime,\n                            pattern: dateTimePattern,\n                            location: styleAndLocation.styleLocation,\n                            parsedOptions: this.shouldParseSkeletons\n                                ? parseDateTimeSkeleton(dateTimePattern)\n                                : {},\n                        };\n                        var type = argType === 'date' ? TYPE.date : TYPE.time;\n                        return {\n                            val: { type: type, value: value, location: location_1, style: style },\n                            err: null,\n                        };\n                    }\n                }\n                // Regular style or no style.\n                return {\n                    val: {\n                        type: argType === 'number'\n                            ? TYPE.number\n                            : argType === 'date'\n                                ? TYPE.date\n                                : TYPE.time,\n                        value: value,\n                        location: location_1,\n                        style: (_a = styleAndLocation === null || styleAndLocation === void 0 ? void 0 : styleAndLocation.style) !== null && _a !== void 0 ? _a : null,\n                    },\n                    err: null,\n                };\n            }\n            case 'plural':\n            case 'selectordinal':\n            case 'select': {\n                // Parse this range:\n                // {name, plural, options}\n                //              ^---------^\n                var typeEndPosition_1 = this.clonePosition();\n                this.bumpSpace();\n                if (!this.bumpIf(',')) {\n                    return this.error(ErrorKind.EXPECT_SELECT_ARGUMENT_OPTIONS, createLocation(typeEndPosition_1, __assign({}, typeEndPosition_1)));\n                }\n                this.bumpSpace();\n                // Parse offset:\n                // {name, plural, offset:1, options}\n                //                ^-----^\n                //\n                // or the first option:\n                //\n                // {name, plural, one {...} other {...}}\n                //                ^--^\n                var identifierAndLocation = this.parseIdentifierIfPossible();\n                var pluralOffset = 0;\n                if (argType !== 'select' && identifierAndLocation.value === 'offset') {\n                    if (!this.bumpIf(':')) {\n                        return this.error(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, createLocation(this.clonePosition(), this.clonePosition()));\n                    }\n                    this.bumpSpace();\n                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE, ErrorKind.INVALID_PLURAL_ARGUMENT_OFFSET_VALUE);\n                    if (result.err) {\n                        return result;\n                    }\n                    // Parse another identifier for option parsing\n                    this.bumpSpace();\n                    identifierAndLocation = this.parseIdentifierIfPossible();\n                    pluralOffset = result.val;\n                }\n                var optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);\n                if (optionsResult.err) {\n                    return optionsResult;\n                }\n                var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n                if (argCloseResult.err) {\n                    return argCloseResult;\n                }\n                var location_2 = createLocation(openingBracePosition, this.clonePosition());\n                if (argType === 'select') {\n                    return {\n                        val: {\n                            type: TYPE.select,\n                            value: value,\n                            options: fromEntries(optionsResult.val),\n                            location: location_2,\n                        },\n                        err: null,\n                    };\n                }\n                else {\n                    return {\n                        val: {\n                            type: TYPE.plural,\n                            value: value,\n                            options: fromEntries(optionsResult.val),\n                            offset: pluralOffset,\n                            pluralType: argType === 'plural' ? 'cardinal' : 'ordinal',\n                            location: location_2,\n                        },\n                        err: null,\n                    };\n                }\n            }\n            default:\n                return this.error(ErrorKind.INVALID_ARGUMENT_TYPE, createLocation(typeStartPosition, typeEndPosition));\n        }\n    };\n    Parser.prototype.tryParseArgumentClose = function (openingBracePosition) {\n        // Parse: {value, number, ::currency/GBP }\n        //\n        if (this.isEOF() || this.char() !== 125 /* `}` */) {\n            return this.error(ErrorKind.EXPECT_ARGUMENT_CLOSING_BRACE, createLocation(openingBracePosition, this.clonePosition()));\n        }\n        this.bump(); // `}`\n        return { val: true, err: null };\n    };\n    /**\n     * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659\n     */\n    Parser.prototype.parseSimpleArgStyleIfPossible = function () {\n        var nestedBraces = 0;\n        var startPosition = this.clonePosition();\n        while (!this.isEOF()) {\n            var ch = this.char();\n            switch (ch) {\n                case 39 /* `'` */: {\n                    // Treat apostrophe as quoting but include it in the style part.\n                    // Find the end of the quoted literal text.\n                    this.bump();\n                    var apostrophePosition = this.clonePosition();\n                    if (!this.bumpUntil(\"'\")) {\n                        return this.error(ErrorKind.UNCLOSED_QUOTE_IN_ARGUMENT_STYLE, createLocation(apostrophePosition, this.clonePosition()));\n                    }\n                    this.bump();\n                    break;\n                }\n                case 123 /* `{` */: {\n                    nestedBraces += 1;\n                    this.bump();\n                    break;\n                }\n                case 125 /* `}` */: {\n                    if (nestedBraces > 0) {\n                        nestedBraces -= 1;\n                    }\n                    else {\n                        return {\n                            val: this.message.slice(startPosition.offset, this.offset()),\n                            err: null,\n                        };\n                    }\n                    break;\n                }\n                default:\n                    this.bump();\n                    break;\n            }\n        }\n        return {\n            val: this.message.slice(startPosition.offset, this.offset()),\n            err: null,\n        };\n    };\n    Parser.prototype.parseNumberSkeletonFromString = function (skeleton, location) {\n        var tokens = [];\n        try {\n            tokens = parseNumberSkeletonFromString(skeleton);\n        }\n        catch (e) {\n            return this.error(ErrorKind.INVALID_NUMBER_SKELETON, location);\n        }\n        return {\n            val: {\n                type: SKELETON_TYPE.number,\n                tokens: tokens,\n                location: location,\n                parsedOptions: this.shouldParseSkeletons\n                    ? parseNumberSkeleton(tokens)\n                    : {},\n            },\n            err: null,\n        };\n    };\n    /**\n     * @param nesting_level The current nesting level of messages.\n     *     This can be positive when parsing message fragment in select or plural argument options.\n     * @param parent_arg_type The parent argument's type.\n     * @param parsed_first_identifier If provided, this is the first identifier-like selector of\n     *     the argument. It is a by-product of a previous parsing attempt.\n     * @param expecting_close_tag If true, this message is directly or indirectly nested inside\n     *     between a pair of opening and closing tags. The nested message will not parse beyond\n     *     the closing tag boundary.\n     */\n    Parser.prototype.tryParsePluralOrSelectOptions = function (nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {\n        var _a;\n        var hasOtherClause = false;\n        var options = [];\n        var parsedSelectors = new Set();\n        var selector = parsedFirstIdentifier.value, selectorLocation = parsedFirstIdentifier.location;\n        // Parse:\n        // one {one apple}\n        // ^--^\n        while (true) {\n            if (selector.length === 0) {\n                var startPosition = this.clonePosition();\n                if (parentArgType !== 'select' && this.bumpIf('=')) {\n                    // Try parse `={number}` selector\n                    var result = this.tryParseDecimalInteger(ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, ErrorKind.INVALID_PLURAL_ARGUMENT_SELECTOR);\n                    if (result.err) {\n                        return result;\n                    }\n                    selectorLocation = createLocation(startPosition, this.clonePosition());\n                    selector = this.message.slice(startPosition.offset, this.offset());\n                }\n                else {\n                    break;\n                }\n            }\n            // Duplicate selector clauses\n            if (parsedSelectors.has(selector)) {\n                return this.error(parentArgType === 'select'\n                    ? ErrorKind.DUPLICATE_SELECT_ARGUMENT_SELECTOR\n                    : ErrorKind.DUPLICATE_PLURAL_ARGUMENT_SELECTOR, selectorLocation);\n            }\n            if (selector === 'other') {\n                hasOtherClause = true;\n            }\n            // Parse:\n            // one {one apple}\n            //     ^----------^\n            this.bumpSpace();\n            var openingBracePosition = this.clonePosition();\n            if (!this.bumpIf('{')) {\n                return this.error(parentArgType === 'select'\n                    ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT\n                    : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT, createLocation(this.clonePosition(), this.clonePosition()));\n            }\n            var fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);\n            if (fragmentResult.err) {\n                return fragmentResult;\n            }\n            var argCloseResult = this.tryParseArgumentClose(openingBracePosition);\n            if (argCloseResult.err) {\n                return argCloseResult;\n            }\n            options.push([\n                selector,\n                {\n                    value: fragmentResult.val,\n                    location: createLocation(openingBracePosition, this.clonePosition()),\n                },\n            ]);\n            // Keep track of the existing selectors\n            parsedSelectors.add(selector);\n            // Prep next selector clause.\n            this.bumpSpace();\n            (_a = this.parseIdentifierIfPossible(), selector = _a.value, selectorLocation = _a.location);\n        }\n        if (options.length === 0) {\n            return this.error(parentArgType === 'select'\n                ? ErrorKind.EXPECT_SELECT_ARGUMENT_SELECTOR\n                : ErrorKind.EXPECT_PLURAL_ARGUMENT_SELECTOR, createLocation(this.clonePosition(), this.clonePosition()));\n        }\n        if (this.requiresOtherClause && !hasOtherClause) {\n            return this.error(ErrorKind.MISSING_OTHER_CLAUSE, createLocation(this.clonePosition(), this.clonePosition()));\n        }\n        return { val: options, err: null };\n    };\n    Parser.prototype.tryParseDecimalInteger = function (expectNumberError, invalidNumberError) {\n        var sign = 1;\n        var startingPosition = this.clonePosition();\n        if (this.bumpIf('+')) {\n        }\n        else if (this.bumpIf('-')) {\n            sign = -1;\n        }\n        var hasDigits = false;\n        var decimal = 0;\n        while (!this.isEOF()) {\n            var ch = this.char();\n            if (ch >= 48 /* `0` */ && ch <= 57 /* `9` */) {\n                hasDigits = true;\n                decimal = decimal * 10 + (ch - 48);\n                this.bump();\n            }\n            else {\n                break;\n            }\n        }\n        var location = createLocation(startingPosition, this.clonePosition());\n        if (!hasDigits) {\n            return this.error(expectNumberError, location);\n        }\n        decimal *= sign;\n        if (!isSafeInteger(decimal)) {\n            return this.error(invalidNumberError, location);\n        }\n        return { val: decimal, err: null };\n    };\n    Parser.prototype.offset = function () {\n        return this.position.offset;\n    };\n    Parser.prototype.isEOF = function () {\n        return this.offset() === this.message.length;\n    };\n    Parser.prototype.clonePosition = function () {\n        // This is much faster than `Object.assign` or spread.\n        return {\n            offset: this.position.offset,\n            line: this.position.line,\n            column: this.position.column,\n        };\n    };\n    /**\n     * Return the code point at the current position of the parser.\n     * Throws if the index is out of bound.\n     */\n    Parser.prototype.char = function () {\n        var offset = this.position.offset;\n        if (offset >= this.message.length) {\n            throw Error('out of bound');\n        }\n        var code = codePointAt(this.message, offset);\n        if (code === undefined) {\n            throw Error(\"Offset \".concat(offset, \" is at invalid UTF-16 code unit boundary\"));\n        }\n        return code;\n    };\n    Parser.prototype.error = function (kind, location) {\n        return {\n            val: null,\n            err: {\n                kind: kind,\n                message: this.message,\n                location: location,\n            },\n        };\n    };\n    /** Bump the parser to the next UTF-16 code unit. */\n    Parser.prototype.bump = function () {\n        if (this.isEOF()) {\n            return;\n        }\n        var code = this.char();\n        if (code === 10 /* '\\n' */) {\n            this.position.line += 1;\n            this.position.column = 1;\n            this.position.offset += 1;\n        }\n        else {\n            this.position.column += 1;\n            // 0 ~ 0x10000 -> unicode BMP, otherwise skip the surrogate pair.\n            this.position.offset += code < 0x10000 ? 1 : 2;\n        }\n    };\n    /**\n     * If the substring starting at the current position of the parser has\n     * the given prefix, then bump the parser to the character immediately\n     * following the prefix and return true. Otherwise, don't bump the parser\n     * and return false.\n     */\n    Parser.prototype.bumpIf = function (prefix) {\n        if (startsWith(this.message, prefix, this.offset())) {\n            for (var i = 0; i < prefix.length; i++) {\n                this.bump();\n            }\n            return true;\n        }\n        return false;\n    };\n    /**\n     * Bump the parser until the pattern character is found and return `true`.\n     * Otherwise bump to the end of the file and return `false`.\n     */\n    Parser.prototype.bumpUntil = function (pattern) {\n        var currentOffset = this.offset();\n        var index = this.message.indexOf(pattern, currentOffset);\n        if (index >= 0) {\n            this.bumpTo(index);\n            return true;\n        }\n        else {\n            this.bumpTo(this.message.length);\n            return false;\n        }\n    };\n    /**\n     * Bump the parser to the target offset.\n     * If target offset is beyond the end of the input, bump the parser to the end of the input.\n     */\n    Parser.prototype.bumpTo = function (targetOffset) {\n        if (this.offset() > targetOffset) {\n            throw Error(\"targetOffset \".concat(targetOffset, \" must be greater than or equal to the current offset \").concat(this.offset()));\n        }\n        targetOffset = Math.min(targetOffset, this.message.length);\n        while (true) {\n            var offset = this.offset();\n            if (offset === targetOffset) {\n                break;\n            }\n            if (offset > targetOffset) {\n                throw Error(\"targetOffset \".concat(targetOffset, \" is at invalid UTF-16 code unit boundary\"));\n            }\n            this.bump();\n            if (this.isEOF()) {\n                break;\n            }\n        }\n    };\n    /** advance the parser through all whitespace to the next non-whitespace code unit. */\n    Parser.prototype.bumpSpace = function () {\n        while (!this.isEOF() && _isWhiteSpace(this.char())) {\n            this.bump();\n        }\n    };\n    /**\n     * Peek at the *next* Unicode codepoint in the input without advancing the parser.\n     * If the input has been exhausted, then this returns null.\n     */\n    Parser.prototype.peek = function () {\n        if (this.isEOF()) {\n            return null;\n        }\n        var code = this.char();\n        var offset = this.offset();\n        var nextCode = this.message.charCodeAt(offset + (code >= 0x10000 ? 2 : 1));\n        return nextCode !== null && nextCode !== void 0 ? nextCode : null;\n    };\n    return Parser;\n}());\nexport { Parser };\n/**\n * This check if codepoint is alphabet (lower & uppercase)\n * @param codepoint\n * @returns\n */\nfunction _isAlpha(codepoint) {\n    return ((codepoint >= 97 && codepoint <= 122) ||\n        (codepoint >= 65 && codepoint <= 90));\n}\nfunction _isAlphaOrSlash(codepoint) {\n    return _isAlpha(codepoint) || codepoint === 47; /* '/' */\n}\n/** See `parseTag` function docs. */\nfunction _isPotentialElementNameChar(c) {\n    return (c === 45 /* '-' */ ||\n        c === 46 /* '.' */ ||\n        (c >= 48 && c <= 57) /* 0..9 */ ||\n        c === 95 /* '_' */ ||\n        (c >= 97 && c <= 122) /** a..z */ ||\n        (c >= 65 && c <= 90) /* A..Z */ ||\n        c == 0xb7 ||\n        (c >= 0xc0 && c <= 0xd6) ||\n        (c >= 0xd8 && c <= 0xf6) ||\n        (c >= 0xf8 && c <= 0x37d) ||\n        (c >= 0x37f && c <= 0x1fff) ||\n        (c >= 0x200c && c <= 0x200d) ||\n        (c >= 0x203f && c <= 0x2040) ||\n        (c >= 0x2070 && c <= 0x218f) ||\n        (c >= 0x2c00 && c <= 0x2fef) ||\n        (c >= 0x3001 && c <= 0xd7ff) ||\n        (c >= 0xf900 && c <= 0xfdcf) ||\n        (c >= 0xfdf0 && c <= 0xfffd) ||\n        (c >= 0x10000 && c <= 0xeffff));\n}\n/**\n * Code point equivalent of regex `\\p{White_Space}`.\n * From: https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt\n */\nfunction _isWhiteSpace(c) {\n    return ((c >= 0x0009 && c <= 0x000d) ||\n        c === 0x0020 ||\n        c === 0x0085 ||\n        (c >= 0x200e && c <= 0x200f) ||\n        c === 0x2028 ||\n        c === 0x2029);\n}\n/**\n * Code point equivalent of regex `\\p{Pattern_Syntax}`.\n * See https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt\n */\nfunction _isPatternSyntax(c) {\n    return ((c >= 0x0021 && c <= 0x0023) ||\n        c === 0x0024 ||\n        (c >= 0x0025 && c <= 0x0027) ||\n        c === 0x0028 ||\n        c === 0x0029 ||\n        c === 0x002a ||\n        c === 0x002b ||\n        c === 0x002c ||\n        c === 0x002d ||\n        (c >= 0x002e && c <= 0x002f) ||\n        (c >= 0x003a && c <= 0x003b) ||\n        (c >= 0x003c && c <= 0x003e) ||\n        (c >= 0x003f && c <= 0x0040) ||\n        c === 0x005b ||\n        c === 0x005c ||\n        c === 0x005d ||\n        c === 0x005e ||\n        c === 0x0060 ||\n        c === 0x007b ||\n        c === 0x007c ||\n        c === 0x007d ||\n        c === 0x007e ||\n        c === 0x00a1 ||\n        (c >= 0x00a2 && c <= 0x00a5) ||\n        c === 0x00a6 ||\n        c === 0x00a7 ||\n        c === 0x00a9 ||\n        c === 0x00ab ||\n        c === 0x00ac ||\n        c === 0x00ae ||\n        c === 0x00b0 ||\n        c === 0x00b1 ||\n        c === 0x00b6 ||\n        c === 0x00bb ||\n        c === 0x00bf ||\n        c === 0x00d7 ||\n        c === 0x00f7 ||\n        (c >= 0x2010 && c <= 0x2015) ||\n        (c >= 0x2016 && c <= 0x2017) ||\n        c === 0x2018 ||\n        c === 0x2019 ||\n        c === 0x201a ||\n        (c >= 0x201b && c <= 0x201c) ||\n        c === 0x201d ||\n        c === 0x201e ||\n        c === 0x201f ||\n        (c >= 0x2020 && c <= 0x2027) ||\n        (c >= 0x2030 && c <= 0x2038) ||\n        c === 0x2039 ||\n        c === 0x203a ||\n        (c >= 0x203b && c <= 0x203e) ||\n        (c >= 0x2041 && c <= 0x2043) ||\n        c === 0x2044 ||\n        c === 0x2045 ||\n        c === 0x2046 ||\n        (c >= 0x2047 && c <= 0x2051) ||\n        c === 0x2052 ||\n        c === 0x2053 ||\n        (c >= 0x2055 && c <= 0x205e) ||\n        (c >= 0x2190 && c <= 0x2194) ||\n        (c >= 0x2195 && c <= 0x2199) ||\n        (c >= 0x219a && c <= 0x219b) ||\n        (c >= 0x219c && c <= 0x219f) ||\n        c === 0x21a0 ||\n        (c >= 0x21a1 && c <= 0x21a2) ||\n        c === 0x21a3 ||\n        (c >= 0x21a4 && c <= 0x21a5) ||\n        c === 0x21a6 ||\n        (c >= 0x21a7 && c <= 0x21ad) ||\n        c === 0x21ae ||\n        (c >= 0x21af && c <= 0x21cd) ||\n        (c >= 0x21ce && c <= 0x21cf) ||\n        (c >= 0x21d0 && c <= 0x21d1) ||\n        c === 0x21d2 ||\n        c === 0x21d3 ||\n        c === 0x21d4 ||\n        (c >= 0x21d5 && c <= 0x21f3) ||\n        (c >= 0x21f4 && c <= 0x22ff) ||\n        (c >= 0x2300 && c <= 0x2307) ||\n        c === 0x2308 ||\n        c === 0x2309 ||\n        c === 0x230a ||\n        c === 0x230b ||\n        (c >= 0x230c && c <= 0x231f) ||\n        (c >= 0x2320 && c <= 0x2321) ||\n        (c >= 0x2322 && c <= 0x2328) ||\n        c === 0x2329 ||\n        c === 0x232a ||\n        (c >= 0x232b && c <= 0x237b) ||\n        c === 0x237c ||\n        (c >= 0x237d && c <= 0x239a) ||\n        (c >= 0x239b && c <= 0x23b3) ||\n        (c >= 0x23b4 && c <= 0x23db) ||\n        (c >= 0x23dc && c <= 0x23e1) ||\n        (c >= 0x23e2 && c <= 0x2426) ||\n        (c >= 0x2427 && c <= 0x243f) ||\n        (c >= 0x2440 && c <= 0x244a) ||\n        (c >= 0x244b && c <= 0x245f) ||\n        (c >= 0x2500 && c <= 0x25b6) ||\n        c === 0x25b7 ||\n        (c >= 0x25b8 && c <= 0x25c0) ||\n        c === 0x25c1 ||\n        (c >= 0x25c2 && c <= 0x25f7) ||\n        (c >= 0x25f8 && c <= 0x25ff) ||\n        (c >= 0x2600 && c <= 0x266e) ||\n        c === 0x266f ||\n        (c >= 0x2670 && c <= 0x2767) ||\n        c === 0x2768 ||\n        c === 0x2769 ||\n        c === 0x276a ||\n        c === 0x276b ||\n        c === 0x276c ||\n        c === 0x276d ||\n        c === 0x276e ||\n        c === 0x276f ||\n        c === 0x2770 ||\n        c === 0x2771 ||\n        c === 0x2772 ||\n        c === 0x2773 ||\n        c === 0x2774 ||\n        c === 0x2775 ||\n        (c >= 0x2794 && c <= 0x27bf) ||\n        (c >= 0x27c0 && c <= 0x27c4) ||\n        c === 0x27c5 ||\n        c === 0x27c6 ||\n        (c >= 0x27c7 && c <= 0x27e5) ||\n        c === 0x27e6 ||\n        c === 0x27e7 ||\n        c === 0x27e8 ||\n        c === 0x27e9 ||\n        c === 0x27ea ||\n        c === 0x27eb ||\n        c === 0x27ec ||\n        c === 0x27ed ||\n        c === 0x27ee ||\n        c === 0x27ef ||\n        (c >= 0x27f0 && c <= 0x27ff) ||\n        (c >= 0x2800 && c <= 0x28ff) ||\n        (c >= 0x2900 && c <= 0x2982) ||\n        c === 0x2983 ||\n        c === 0x2984 ||\n        c === 0x2985 ||\n        c === 0x2986 ||\n        c === 0x2987 ||\n        c === 0x2988 ||\n        c === 0x2989 ||\n        c === 0x298a ||\n        c === 0x298b ||\n        c === 0x298c ||\n        c === 0x298d ||\n        c === 0x298e ||\n        c === 0x298f ||\n        c === 0x2990 ||\n        c === 0x2991 ||\n        c === 0x2992 ||\n        c === 0x2993 ||\n        c === 0x2994 ||\n        c === 0x2995 ||\n        c === 0x2996 ||\n        c === 0x2997 ||\n        c === 0x2998 ||\n        (c >= 0x2999 && c <= 0x29d7) ||\n        c === 0x29d8 ||\n        c === 0x29d9 ||\n        c === 0x29da ||\n        c === 0x29db ||\n        (c >= 0x29dc && c <= 0x29fb) ||\n        c === 0x29fc ||\n        c === 0x29fd ||\n        (c >= 0x29fe && c <= 0x2aff) ||\n        (c >= 0x2b00 && c <= 0x2b2f) ||\n        (c >= 0x2b30 && c <= 0x2b44) ||\n        (c >= 0x2b45 && c <= 0x2b46) ||\n        (c >= 0x2b47 && c <= 0x2b4c) ||\n        (c >= 0x2b4d && c <= 0x2b73) ||\n        (c >= 0x2b74 && c <= 0x2b75) ||\n        (c >= 0x2b76 && c <= 0x2b95) ||\n        c === 0x2b96 ||\n        (c >= 0x2b97 && c <= 0x2bff) ||\n        (c >= 0x2e00 && c <= 0x2e01) ||\n        c === 0x2e02 ||\n        c === 0x2e03 ||\n        c === 0x2e04 ||\n        c === 0x2e05 ||\n        (c >= 0x2e06 && c <= 0x2e08) ||\n        c === 0x2e09 ||\n        c === 0x2e0a ||\n        c === 0x2e0b ||\n        c === 0x2e0c ||\n        c === 0x2e0d ||\n        (c >= 0x2e0e && c <= 0x2e16) ||\n        c === 0x2e17 ||\n        (c >= 0x2e18 && c <= 0x2e19) ||\n        c === 0x2e1a ||\n        c === 0x2e1b ||\n        c === 0x2e1c ||\n        c === 0x2e1d ||\n        (c >= 0x2e1e && c <= 0x2e1f) ||\n        c === 0x2e20 ||\n        c === 0x2e21 ||\n        c === 0x2e22 ||\n        c === 0x2e23 ||\n        c === 0x2e24 ||\n        c === 0x2e25 ||\n        c === 0x2e26 ||\n        c === 0x2e27 ||\n        c === 0x2e28 ||\n        c === 0x2e29 ||\n        (c >= 0x2e2a && c <= 0x2e2e) ||\n        c === 0x2e2f ||\n        (c >= 0x2e30 && c <= 0x2e39) ||\n        (c >= 0x2e3a && c <= 0x2e3b) ||\n        (c >= 0x2e3c && c <= 0x2e3f) ||\n        c === 0x2e40 ||\n        c === 0x2e41 ||\n        c === 0x2e42 ||\n        (c >= 0x2e43 && c <= 0x2e4f) ||\n        (c >= 0x2e50 && c <= 0x2e51) ||\n        c === 0x2e52 ||\n        (c >= 0x2e53 && c <= 0x2e7f) ||\n        (c >= 0x3001 && c <= 0x3003) ||\n        c === 0x3008 ||\n        c === 0x3009 ||\n        c === 0x300a ||\n        c === 0x300b ||\n        c === 0x300c ||\n        c === 0x300d ||\n        c === 0x300e ||\n        c === 0x300f ||\n        c === 0x3010 ||\n        c === 0x3011 ||\n        (c >= 0x3012 && c <= 0x3013) ||\n        c === 0x3014 ||\n        c === 0x3015 ||\n        c === 0x3016 ||\n        c === 0x3017 ||\n        c === 0x3018 ||\n        c === 0x3019 ||\n        c === 0x301a ||\n        c === 0x301b ||\n        c === 0x301c ||\n        c === 0x301d ||\n        (c >= 0x301e && c <= 0x301f) ||\n        c === 0x3020 ||\n        c === 0x3030 ||\n        c === 0xfd3e ||\n        c === 0xfd3f ||\n        (c >= 0xfe45 && c <= 0xfe46));\n}\n","import { timeData } from './time-data.generated';\n/**\n * Returns the best matching date time pattern if a date time skeleton\n * pattern is provided with a locale. Follows the Unicode specification:\n * https://www.unicode.org/reports/tr35/tr35-dates.html#table-mapping-requested-time-skeletons-to-patterns\n * @param skeleton date time skeleton pattern that possibly includes j, J or C\n * @param locale\n */\nexport function getBestPattern(skeleton, locale) {\n    var skeletonCopy = '';\n    for (var patternPos = 0; patternPos < skeleton.length; patternPos++) {\n        var patternChar = skeleton.charAt(patternPos);\n        if (patternChar === 'j') {\n            var extraLength = 0;\n            while (patternPos + 1 < skeleton.length &&\n                skeleton.charAt(patternPos + 1) === patternChar) {\n                extraLength++;\n                patternPos++;\n            }\n            var hourLen = 1 + (extraLength & 1);\n            var dayPeriodLen = extraLength < 2 ? 1 : 3 + (extraLength >> 1);\n            var dayPeriodChar = 'a';\n            var hourChar = getDefaultHourSymbolFromLocale(locale);\n            if (hourChar == 'H' || hourChar == 'k') {\n                dayPeriodLen = 0;\n            }\n            while (dayPeriodLen-- > 0) {\n                skeletonCopy += dayPeriodChar;\n            }\n            while (hourLen-- > 0) {\n                skeletonCopy = hourChar + skeletonCopy;\n            }\n        }\n        else if (patternChar === 'J') {\n            skeletonCopy += 'H';\n        }\n        else {\n            skeletonCopy += patternChar;\n        }\n    }\n    return skeletonCopy;\n}\n/**\n * Maps the [hour cycle type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle)\n * of the given `locale` to the corresponding time pattern.\n * @param locale\n */\nfunction getDefaultHourSymbolFromLocale(locale) {\n    var hourCycle = locale.hourCycle;\n    if (hourCycle === undefined &&\n        // @ts-ignore hourCycle(s) is not identified yet\n        locale.hourCycles &&\n        // @ts-ignore\n        locale.hourCycles.length) {\n        // @ts-ignore\n        hourCycle = locale.hourCycles[0];\n    }\n    if (hourCycle) {\n        switch (hourCycle) {\n            case 'h24':\n                return 'k';\n            case 'h23':\n                return 'H';\n            case 'h12':\n                return 'h';\n            case 'h11':\n                return 'K';\n            default:\n                throw new Error('Invalid hourCycle');\n        }\n    }\n    // TODO: Once hourCycle is fully supported remove the following with data generation\n    var languageTag = locale.language;\n    var regionTag;\n    if (languageTag !== 'root') {\n        regionTag = locale.maximize().region;\n    }\n    var hourCycles = timeData[regionTag || ''] ||\n        timeData[languageTag || ''] ||\n        timeData[\"\".concat(languageTag, \"-001\")] ||\n        timeData['001'];\n    return hourCycles[0];\n}\n","import { __assign } from \"tslib\";\nimport { ErrorKind } from './error';\nimport { Parser } from './parser';\nimport { isDateElement, isDateTimeSkeleton, isNumberElement, isNumberSkeleton, isPluralElement, isSelectElement, isTagElement, isTimeElement, } from './types';\nfunction pruneLocation(els) {\n    els.forEach(function (el) {\n        delete el.location;\n        if (isSelectElement(el) || isPluralElement(el)) {\n            for (var k in el.options) {\n                delete el.options[k].location;\n                pruneLocation(el.options[k].value);\n            }\n        }\n        else if (isNumberElement(el) && isNumberSkeleton(el.style)) {\n            delete el.style.location;\n        }\n        else if ((isDateElement(el) || isTimeElement(el)) &&\n            isDateTimeSkeleton(el.style)) {\n            delete el.style.location;\n        }\n        else if (isTagElement(el)) {\n            pruneLocation(el.children);\n        }\n    });\n}\nexport function parse(message, opts) {\n    if (opts === void 0) { opts = {}; }\n    opts = __assign({ shouldParseSkeletons: true, requiresOtherClause: true }, opts);\n    var result = new Parser(message, opts).parse();\n    if (result.err) {\n        var error = SyntaxError(ErrorKind[result.err.kind]);\n        // @ts-expect-error Assign to error object\n        error.location = result.err.location;\n        // @ts-expect-error Assign to error object\n        error.originalMessage = result.err.message;\n        throw error;\n    }\n    if (!(opts === null || opts === void 0 ? void 0 : opts.captureLocation)) {\n        pruneLocation(result.val);\n    }\n    return result.val;\n}\nexport * from './types';\n// only for testing\nexport var _Parser = Parser;\nexport { isStructurallySame } from './manipulator';\n"],"names":["memoize","fn","options","cache","cacheDefault","serializer","serializerDefault","strategy","strategyDefault","monadic","arg","value","cacheKey","computedValue","get","call","this","set","variadic","args","Array","prototype","slice","arguments","apply","assemble","context","serialize","bind","length","create","JSON","stringify","ObjectWithoutPrototypeCache","Object","key","strategies","ErrorKind","_a","getDefaultHourSymbolFromLocale","locale","hourCycle","undefined","hourCycles","Error","regionTag","languageTag","language","maximize","region","concat","SPACE_SEPARATOR_START_REGEX","RegExp","source","SPACE_SEPARATOR_END_REGEX","createLocation","start","end","hasNativeStartsWith","String","startsWith","hasNativeFromCodePoint","fromCodePoint","hasNativeFromEntries","fromEntries","hasNativeCodePointAt","codePointAt","hasTrimStart","trimStart","hasTrimEnd","trimEnd","isSafeInteger","Number","n","isFinite","Math","floor","abs","REGEX_SUPPORTS_U_AND_Y","RE","exec","_","matchIdentifierAtIndex","s","search","position","codePoints","_i","code","elements","i","RangeError","fromCharCode","entries","obj","entries_1","k","v","index","size","second","first","charCodeAt","replace","flag","IDENTIFIER_PREFIX_RE_1","lastIndex","match","c","_isWhiteSpace","_isPatternSyntax","push","Parser","message","offset","line","column","ignoreTag","requiresOtherClause","shouldParseSkeletons","parse","parseMessage","nestingLevel","parentArgType","expectingCloseTag","isEOF","char","result","parseArgument","err","val","peek","error","UNMATCHED_CLOSING_TAG","clonePosition","_isAlpha","parseTag","parseLiteral","bump","type","pound","location","startPosition","tagName","parseTagName","bumpSpace","bumpIf","literal","childrenResult","children","endTagStartPosition","INVALID_TAG","closingTagNameStartPosition","tag","UNCLOSED_TAG","startOffset","parseQuoteResult","tryParseQuote","parseUnquotedResult","tryParseUnquoted","parseLeftAngleResult","tryParseLeftAngleBracket","codepoint","ch","openingBracePosition","EXPECT_ARGUMENT_CLOSING_BRACE","EMPTY_ARGUMENT","parseIdentifierIfPossible","MALFORMED_ARGUMENT","argument","parseArgumentOptions","startingPosition","endOffset","bumpTo","typeStartPosition","argType","typeEndPosition","EXPECT_ARGUMENT_TYPE","styleAndLocation","styleStartPosition","parseSimpleArgStyleIfPossible","style","EXPECT_ARGUMENT_STYLE","styleLocation","argCloseResult","tryParseArgumentClose","location_1","skeleton","parseNumberSkeletonFromString","number","EXPECT_DATE_TIME_SKELETON","dateTimePattern","skeletonCopy","patternPos","patternChar","charAt","extraLength","hourLen","dayPeriodLen","hourChar","getBestPattern","dateTime","pattern","parsedOptions","date","time","typeEndPosition_1","EXPECT_SELECT_ARGUMENT_OPTIONS","identifierAndLocation","pluralOffset","EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE","tryParseDecimalInteger","INVALID_PLURAL_ARGUMENT_OFFSET_VALUE","optionsResult","tryParsePluralOrSelectOptions","location_2","select","plural","pluralType","INVALID_ARGUMENT_TYPE","nestedBraces","apostrophePosition","bumpUntil","UNCLOSED_QUOTE_IN_ARGUMENT_STYLE","tokens","e","INVALID_NUMBER_SKELETON","expectCloseTag","parsedFirstIdentifier","hasOtherClause","parsedSelectors","Set","selector","selectorLocation","EXPECT_PLURAL_ARGUMENT_SELECTOR","INVALID_PLURAL_ARGUMENT_SELECTOR","has","DUPLICATE_SELECT_ARGUMENT_SELECTOR","DUPLICATE_PLURAL_ARGUMENT_SELECTOR","EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT","EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT","fragmentResult","add","EXPECT_SELECT_ARGUMENT_SELECTOR","MISSING_OTHER_CLAUSE","expectNumberError","invalidNumberError","sign","hasDigits","decimal","kind","prefix","currentOffset","indexOf","targetOffset","min","nextCode","pruneLocation","els","forEach","el","opts","SyntaxError","originalMessage","captureLocation"],"sourceRoot":""}