{"version":3,"file":"intl-unified-numberformat.min.js","sources":["../../../intl-utils/lib/invariant.js","../../../intl-utils/lib/polyfill-utils.js","../../../intl-utils/lib/get-canonical-locales.js","../../../intl-utils/lib/resolve-locale.js","../../../intl-utils/lib/units.js","../../../intl-utils/lib/number-types.js","../../lib/utils.js","../../lib/data.js","../../lib/core.js"],"sourcesContent":["export function invariant(condition, message, Err) {\n    if (Err === void 0) { Err = Error; }\n    if (!condition) {\n        throw new Err(message);\n    }\n}\n//# sourceMappingURL=invariant.js.map","import aliases from './aliases';\nimport parentLocales from './parentLocales';\nimport { invariant } from './invariant';\n/**\n * https://tc39.es/ecma262/#sec-toobject\n * @param arg\n */\nexport function toObject(arg) {\n    if (arg == null) {\n        throw new TypeError('undefined/null cannot be converted to object');\n    }\n    return Object(arg);\n}\n/**\n * https://tc39.es/ecma262/#sec-tostring\n */\nexport function toString(o) {\n    // Only symbol is irregular...\n    if (typeof o === 'symbol') {\n        throw TypeError('Cannot convert a Symbol value to a string');\n    }\n    return String(o);\n}\n/**\n * https://tc39.es/ecma402/#sec-getoption\n * @param opts\n * @param prop\n * @param type\n * @param values\n * @param fallback\n */\nexport function getOption(opts, prop, type, values, fallback) {\n    // const descriptor = Object.getOwnPropertyDescriptor(opts, prop);\n    var value = opts[prop];\n    if (value !== undefined) {\n        if (type !== 'boolean' && type !== 'string') {\n            throw new TypeError('invalid type');\n        }\n        if (type === 'boolean') {\n            value = Boolean(value);\n        }\n        if (type === 'string') {\n            value = toString(value);\n        }\n        if (values !== undefined && !values.filter(function (val) { return val == value; }).length) {\n            throw new RangeError(value + \" is not within \" + values.join(', '));\n        }\n        return value;\n    }\n    return fallback;\n}\n/**\n * https://tc39.es/ecma402/#sec-defaultnumberoption\n * @param val\n * @param min\n * @param max\n * @param fallback\n */\nexport function defaultNumberOption(val, min, max, fallback) {\n    if (val !== undefined) {\n        val = Number(val);\n        if (isNaN(val) || val < min || val > max) {\n            throw new RangeError(val + \" is outside of range [\" + min + \", \" + max + \"]\");\n        }\n        return Math.floor(val);\n    }\n    return fallback;\n}\n/**\n * https://tc39.es/ecma402/#sec-getnumberoption\n * @param options\n * @param property\n * @param min\n * @param max\n * @param fallback\n */\nexport function getNumberOption(options, property, minimum, maximum, fallback) {\n    var val = options[property];\n    return defaultNumberOption(val, minimum, maximum, fallback);\n}\nexport function getAliasesByLang(lang) {\n    return Object.keys(aliases).reduce(function (all, locale) {\n        if (locale.split('-')[0] === lang) {\n            all[locale] = aliases[locale];\n        }\n        return all;\n    }, {});\n}\nexport function getParentLocalesByLang(lang) {\n    return Object.keys(parentLocales).reduce(function (all, locale) {\n        if (locale.split('-')[0] === lang) {\n            all[locale] = parentLocales[locale];\n        }\n        return all;\n    }, {});\n}\nexport function setInternalSlot(map, pl, field, value) {\n    if (!map.get(pl)) {\n        map.set(pl, Object.create(null));\n    }\n    var slots = map.get(pl);\n    slots[field] = value;\n}\nexport function setMultiInternalSlots(map, pl, props) {\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\n        var k = _a[_i];\n        setInternalSlot(map, pl, k, props[k]);\n    }\n}\nexport function getInternalSlot(map, pl, field) {\n    return getMultiInternalSlots(map, pl, field)[field];\n}\nexport function getMultiInternalSlots(map, pl) {\n    var fields = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        fields[_i - 2] = arguments[_i];\n    }\n    var slots = map.get(pl);\n    if (!slots) {\n        throw new TypeError(pl + \" InternalSlot has not been initialized\");\n    }\n    return fields.reduce(function (all, f) {\n        all[f] = slots[f];\n        return all;\n    }, Object.create(null));\n}\nexport function isLiteralPart(patternPart) {\n    return patternPart.type === 'literal';\n}\nexport function partitionPattern(pattern) {\n    var result = [];\n    var beginIndex = pattern.indexOf('{');\n    var endIndex = 0;\n    var nextIndex = 0;\n    var length = pattern.length;\n    while (beginIndex < pattern.length && beginIndex > -1) {\n        endIndex = pattern.indexOf('}', beginIndex);\n        invariant(endIndex > beginIndex, \"Invalid pattern \" + pattern);\n        if (beginIndex > nextIndex) {\n            result.push({\n                type: 'literal',\n                value: pattern.substring(nextIndex, beginIndex),\n            });\n        }\n        result.push({\n            type: pattern.substring(beginIndex + 1, endIndex),\n            value: undefined,\n        });\n        nextIndex = endIndex + 1;\n        beginIndex = pattern.indexOf('{', nextIndex);\n    }\n    if (nextIndex < length) {\n        result.push({\n            type: 'literal',\n            value: pattern.substring(nextIndex, length),\n        });\n    }\n    return result;\n}\n/**\n * https://tc39.es/ecma402/#sec-setnfdigitoptions\n * https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_diff_out.html#sec-setnfdigitoptions\n * @param intlObj\n * @param opts\n * @param mnfdDefault\n * @param mxfdDefault\n */\nexport function setNumberFormatDigitOptions(internalSlotMap, intlObj, opts, mnfdDefault, mxfdDefault) {\n    var mnid = getNumberOption(opts, 'minimumIntegerDigits', 1, 21, 1);\n    var mnfd = opts.minimumFractionDigits;\n    var mxfd = opts.maximumFractionDigits;\n    var mnsd = opts.minimumSignificantDigits;\n    var mxsd = opts.maximumSignificantDigits;\n    setInternalSlot(internalSlotMap, intlObj, 'minimumIntegerDigits', mnid);\n    if (mnsd !== undefined || mxsd !== undefined) {\n        setInternalSlot(internalSlotMap, intlObj, 'roundingType', 'significantDigits');\n        mnsd = defaultNumberOption(mnsd, 1, 21, 1);\n        mxsd = defaultNumberOption(mxsd, mnsd, 21, 21);\n        setInternalSlot(internalSlotMap, intlObj, 'minimumSignificantDigits', mnsd);\n        setInternalSlot(internalSlotMap, intlObj, 'maximumSignificantDigits', mxsd);\n    }\n    else if (mnfd !== undefined || mxfd !== undefined) {\n        setInternalSlot(internalSlotMap, intlObj, 'roundingType', 'fractionDigits');\n        mnfd = defaultNumberOption(mnfd, 0, 20, mnfdDefault);\n        var mxfdActualDefault = Math.max(mnfd, mxfdDefault);\n        mxfd = defaultNumberOption(mxfd, mnfd, 20, mxfdActualDefault);\n        setInternalSlot(internalSlotMap, intlObj, 'minimumFractionDigits', mnfd);\n        setInternalSlot(internalSlotMap, intlObj, 'maximumFractionDigits', mxfd);\n    }\n    else if (getInternalSlot(internalSlotMap, intlObj, 'notation') === 'compact') {\n        setInternalSlot(internalSlotMap, intlObj, 'roundingType', 'compactRounding');\n    }\n    else {\n        setInternalSlot(internalSlotMap, intlObj, 'roundingType', 'fractionDigits');\n        setInternalSlot(internalSlotMap, intlObj, 'minimumFractionDigits', mnfdDefault);\n        setInternalSlot(internalSlotMap, intlObj, 'maximumFractionDigits', mxfdDefault);\n    }\n}\nexport function objectIs(x, y) {\n    if (Object.is) {\n        return Object.is(x, y);\n    }\n    // SameValue algorithm\n    if (x === y) {\n        // Steps 1-5, 7-10\n        // Steps 6.b-6.e: +0 != -0\n        return x !== 0 || 1 / x === 1 / y;\n    }\n    // Step 6.a: NaN == NaN\n    return x !== x && y !== y;\n}\nvar NOT_A_Z_REGEX = /[^A-Z]/;\n/**\n * This follows https://tc39.es/ecma402/#sec-case-sensitivity-and-case-mapping\n * @param str string to convert\n */\nfunction toUpperCase(str) {\n    return str.replace(/([a-z])/g, function (_, c) { return c.toUpperCase(); });\n}\n/**\n * https://tc39.es/proposal-unified-intl-numberformat/section6/locales-currencies-tz_proposed_out.html#sec-iswellformedcurrencycode\n * @param currency\n */\nexport function isWellFormedCurrencyCode(currency) {\n    currency = toUpperCase(currency);\n    if (currency.length !== 3) {\n        return false;\n    }\n    if (NOT_A_Z_REGEX.test(currency)) {\n        return false;\n    }\n    return true;\n}\n//# sourceMappingURL=polyfill-utils.js.map","/**\n * IE11-safe version of getCanonicalLocales since it's ES2016\n * @param locales locales\n */\nexport function getCanonicalLocales(locales) {\n    // IE11\n    var getCanonicalLocales = Intl.getCanonicalLocales;\n    if (typeof getCanonicalLocales === 'function') {\n        return getCanonicalLocales(locales);\n    }\n    // NOTE: we must NOT call `supportedLocalesOf` of a formatjs polyfill, or their implementation\n    // will even eventually call this method recursively. Here we use `Intl.DateTimeFormat` since it\n    // is not polyfilled by `@formatjs`.\n    // TODO: Fix TypeScript type def for this bc undefined is just fine\n    return Intl.DateTimeFormat.supportedLocalesOf(locales);\n}\n//# sourceMappingURL=get-canonical-locales.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { getCanonicalLocales } from './get-canonical-locales';\nimport { invariant } from './invariant';\nimport { toObject, getOption } from './polyfill-utils';\nexport function createResolveLocale(getDefaultLocale) {\n    var lookupMatcher = createLookupMatcher(getDefaultLocale);\n    var bestFitMatcher = createBestFitMatcher(getDefaultLocale);\n    /**\n     * https://tc39.es/ecma402/#sec-resolvelocale\n     */\n    return function resolveLocale(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData) {\n        var matcher = options.localeMatcher;\n        var r;\n        if (matcher === 'lookup') {\n            r = lookupMatcher(availableLocales, requestedLocales);\n        }\n        else {\n            r = bestFitMatcher(availableLocales, requestedLocales);\n        }\n        var foundLocale = r.locale;\n        var result = { locale: '', dataLocale: foundLocale };\n        var supportedExtension = '-u';\n        for (var _i = 0, relevantExtensionKeys_1 = relevantExtensionKeys; _i < relevantExtensionKeys_1.length; _i++) {\n            var key = relevantExtensionKeys_1[_i];\n            var foundLocaleData = localeData[foundLocale];\n            invariant(typeof foundLocaleData === 'object' && foundLocaleData !== null, \"locale data \" + key + \" must be an object\");\n            var keyLocaleData = foundLocaleData[key];\n            invariant(Array.isArray(keyLocaleData), \"keyLocaleData for \" + key + \" must be an array\");\n            var value = keyLocaleData[0];\n            invariant(typeof value === 'string' || value === null, 'value must be string or null');\n            var supportedExtensionAddition = '';\n            if (r.extension) {\n                var requestedValue = unicodeExtensionValue(r.extension, key);\n                if (requestedValue !== undefined) {\n                    if (requestedValue !== '') {\n                        if (~keyLocaleData.indexOf(requestedValue)) {\n                            value = requestedValue;\n                            supportedExtensionAddition = \"-\" + key + \"-\" + value;\n                        }\n                    }\n                    else if (~requestedValue.indexOf('true')) {\n                        value = 'true';\n                        supportedExtensionAddition = \"-\" + key;\n                    }\n                }\n            }\n            if (key in options) {\n                var optionsValue = options[key];\n                invariant(typeof optionsValue === 'string' ||\n                    typeof optionsValue === 'undefined' ||\n                    optionsValue === null, 'optionsValue must be String, Undefined or Null');\n                if (~keyLocaleData.indexOf(optionsValue)) {\n                    if (optionsValue !== value) {\n                        value = optionsValue;\n                        supportedExtensionAddition = '';\n                    }\n                }\n            }\n            result[key] = value;\n            supportedExtension += supportedExtensionAddition;\n        }\n        if (supportedExtension.length > 2) {\n            var privateIndex = foundLocale.indexOf('-x-');\n            if (privateIndex === -1) {\n                foundLocale = foundLocale + supportedExtension;\n            }\n            else {\n                var preExtension = foundLocale.slice(0, privateIndex);\n                var postExtension = foundLocale.slice(privateIndex, foundLocale.length);\n                foundLocale = preExtension + supportedExtension + postExtension;\n            }\n            foundLocale = getCanonicalLocales(foundLocale)[0];\n        }\n        result.locale = foundLocale;\n        return result;\n    };\n}\n/**\n * https://tc39.es/ecma402/#sec-unicodeextensionvalue\n * @param extension\n * @param key\n */\nfunction unicodeExtensionValue(extension, key) {\n    invariant(key.length === 2, 'key must have 2 elements');\n    var size = extension.length;\n    var searchValue = \"-\" + key + \"-\";\n    var pos = extension.indexOf(searchValue);\n    if (pos !== -1) {\n        var start = pos + 4;\n        var end = start;\n        var k = start;\n        var done = false;\n        while (!done) {\n            var e = extension.indexOf('-', k);\n            var len = void 0;\n            if (e === -1) {\n                len = size - k;\n            }\n            else {\n                len = e - k;\n            }\n            if (len === 2) {\n                done = true;\n            }\n            else if (e === -1) {\n                end = size;\n                done = true;\n            }\n            else {\n                end = e;\n                k = e + 1;\n            }\n        }\n        return extension.slice(start, end);\n    }\n    searchValue = \"-\" + key;\n    pos = extension.indexOf(searchValue);\n    if (pos !== -1 && pos + 3 === size) {\n        return '';\n    }\n    return undefined;\n}\nvar UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;\n/**\n * https://tc39.es/ecma402/#sec-bestavailablelocale\n * @param availableLocales\n * @param locale\n */\nfunction bestAvailableLocale(availableLocales, locale) {\n    var candidate = locale;\n    while (true) {\n        if (~availableLocales.indexOf(candidate)) {\n            return candidate;\n        }\n        var pos = candidate.lastIndexOf('-');\n        if (!~pos) {\n            return undefined;\n        }\n        if (pos >= 2 && candidate[pos - 2] === '-') {\n            pos -= 2;\n        }\n        candidate = candidate.slice(0, pos);\n    }\n}\nfunction createLookupMatcher(getDefaultLocale) {\n    /**\n     * https://tc39.es/ecma402/#sec-lookupmatcher\n     */\n    return function lookupMatcher(availableLocales, requestedLocales) {\n        var result = { locale: '' };\n        for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {\n            var locale = requestedLocales_1[_i];\n            var noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');\n            var availableLocale = bestAvailableLocale(availableLocales, noExtensionLocale);\n            if (availableLocale) {\n                result.locale = availableLocale;\n                if (locale !== noExtensionLocale) {\n                    result.extension = locale.slice(noExtensionLocale.length + 1, locale.length);\n                }\n                return result;\n            }\n        }\n        result.locale = getDefaultLocale();\n        return result;\n    };\n}\nfunction createBestFitMatcher(getDefaultLocale) {\n    return function bestFitMatcher(availableLocales, requestedLocales) {\n        var result = { locale: '' };\n        for (var _i = 0, requestedLocales_2 = requestedLocales; _i < requestedLocales_2.length; _i++) {\n            var locale = requestedLocales_2[_i];\n            var noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');\n            var availableLocale = bestAvailableLocale(availableLocales, noExtensionLocale);\n            if (availableLocale) {\n                result.locale = availableLocale;\n                if (locale !== noExtensionLocale) {\n                    result.extension = locale.slice(noExtensionLocale.length + 1, locale.length);\n                }\n                return result;\n            }\n        }\n        result.locale = getDefaultLocale();\n        return result;\n    };\n}\nexport function getLocaleHierarchy(locale, aliases, parentLocales) {\n    var results = [locale];\n    if (aliases[locale]) {\n        locale = aliases[locale];\n        results.push(locale);\n    }\n    var parentLocale = parentLocales[locale];\n    if (parentLocale) {\n        results.push(parentLocale);\n    }\n    var localeParts = locale.split('-');\n    for (var i = localeParts.length; i > 1; i--) {\n        results.push(localeParts.slice(0, i - 1).join('-'));\n    }\n    return results;\n}\nfunction lookupSupportedLocales(availableLocales, requestedLocales) {\n    var subset = [];\n    for (var _i = 0, requestedLocales_3 = requestedLocales; _i < requestedLocales_3.length; _i++) {\n        var locale = requestedLocales_3[_i];\n        var noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, '');\n        var availableLocale = bestAvailableLocale(availableLocales, noExtensionLocale);\n        if (availableLocale) {\n            subset.push(availableLocale);\n        }\n    }\n    return subset;\n}\nexport function supportedLocales(availableLocales, requestedLocales, options) {\n    var matcher = 'best fit';\n    if (options !== undefined) {\n        options = toObject(options);\n        matcher = getOption(options, 'localeMatcher', 'string', ['lookup', 'best fit'], 'best fit');\n    }\n    if (matcher === 'best fit') {\n        return lookupSupportedLocales(availableLocales, requestedLocales);\n    }\n    return lookupSupportedLocales(availableLocales, requestedLocales);\n}\nvar MissingLocaleDataError = /** @class */ (function (_super) {\n    __extends(MissingLocaleDataError, _super);\n    function MissingLocaleDataError() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = 'MISSING_LOCALE_DATA';\n        return _this;\n    }\n    return MissingLocaleDataError;\n}(Error));\nexport function isMissingLocaleDataError(e) {\n    return e.type === 'MISSING_LOCALE_DATA';\n}\nexport function unpackData(locale, localeData, \n/** By default shallow merge the dictionaries. */\nreducer) {\n    if (reducer === void 0) { reducer = function (all, d) { return (__assign(__assign({}, all), d)); }; }\n    var localeHierarchy = getLocaleHierarchy(locale, localeData.aliases, localeData.parentLocales);\n    var dataToMerge = localeHierarchy\n        .map(function (l) { return localeData.data[l]; })\n        .filter(Boolean);\n    if (!dataToMerge.length) {\n        throw new MissingLocaleDataError(\"Missing locale data for \\\"\" + locale + \"\\\", lookup hierarchy: \" + localeHierarchy.join(', '));\n    }\n    dataToMerge.reverse();\n    return dataToMerge.reduce(reducer, {});\n}\n//# sourceMappingURL=resolve-locale.js.map","// https://tc39.es/proposal-unified-intl-numberformat/section6/locales-currencies-tz_diff_out.html#sec-issanctionedsimpleunitidentifier\nexport var SANCTIONED_UNITS = [\n    'angle-degree',\n    'area-acre',\n    'area-hectare',\n    'concentr-percent',\n    'digital-bit',\n    'digital-byte',\n    'digital-gigabit',\n    'digital-gigabyte',\n    'digital-kilobit',\n    'digital-kilobyte',\n    'digital-megabit',\n    'digital-megabyte',\n    'digital-petabyte',\n    'digital-terabit',\n    'digital-terabyte',\n    'duration-day',\n    'duration-hour',\n    'duration-millisecond',\n    'duration-minute',\n    'duration-month',\n    'duration-second',\n    'duration-week',\n    'duration-year',\n    'length-centimeter',\n    'length-foot',\n    'length-inch',\n    'length-kilometer',\n    'length-meter',\n    'length-mile-scandinavian',\n    'length-mile',\n    'length-millimeter',\n    'length-yard',\n    'mass-gram',\n    'mass-kilogram',\n    'mass-ounce',\n    'mass-pound',\n    'mass-stone',\n    'temperature-celsius',\n    'temperature-fahrenheit',\n    'volume-fluid-ounce',\n    'volume-gallon',\n    'volume-liter',\n    'volume-milliliter',\n];\n// In CLDR, the unit name always follows the form `namespace-unit` pattern.\n// For example: `digital-bit` instead of `bit`. This function removes the namespace prefix.\nexport function removeUnitNamespace(unit) {\n    return unit.replace(/^(.*?)-/, '');\n}\n//# sourceMappingURL=units.js.map","export var InternalSlotToken;\n(function (InternalSlotToken) {\n    // To prevent collision with {0} in CLDR\n    InternalSlotToken[\"compactName\"] = \"compactName\";\n    InternalSlotToken[\"compactSymbol\"] = \"compactSymbol\";\n    InternalSlotToken[\"currencyCode\"] = \"currencyCode\";\n    InternalSlotToken[\"currencyName\"] = \"currencyName\";\n    InternalSlotToken[\"currencyNarrowSymbol\"] = \"currencyNarrowSymbol\";\n    InternalSlotToken[\"currencySymbol\"] = \"currencySymbol\";\n    InternalSlotToken[\"minusSign\"] = \"minusSign\";\n    InternalSlotToken[\"number\"] = \"number\";\n    InternalSlotToken[\"percentSign\"] = \"percentSign\";\n    InternalSlotToken[\"plusSign\"] = \"plusSign\";\n    InternalSlotToken[\"scientificExponent\"] = \"scientificExponent\";\n    InternalSlotToken[\"scientificSeparator\"] = \"scientificSeparator\";\n    InternalSlotToken[\"unitName\"] = \"unitName\";\n    InternalSlotToken[\"unitNarrowSymbol\"] = \"unitNarrowSymbol\";\n    InternalSlotToken[\"unitSymbol\"] = \"unitSymbol\";\n})(InternalSlotToken || (InternalSlotToken = {}));\n//# sourceMappingURL=number-types.js.map","/**\n * Cannot do Math.log(x) / Math.log(10) bc if IEEE floating point issue\n * @param x number\n */\nexport function getMagnitude(x) {\n    // Cannot count string length via Number.toString because it may use scientific notation\n    // for very small or very large numbers.\n    return Math.floor(Math.log(x) * Math.LOG10E);\n}\n// TODO: dedup with intl-pluralrules\n// https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_proposed_out.html#sec-torawfixed\nexport function toRawFixed(x, minFraction, maxFraction) {\n    var f = maxFraction;\n    var n;\n    {\n        var exactSolve = x * Math.pow(10, f);\n        var roundDown = Math.floor(exactSolve);\n        var roundUp = Math.ceil(exactSolve);\n        n = exactSolve - roundDown < roundUp - exactSolve ? roundDown : roundUp;\n    }\n    var xFinal = n / Math.pow(10, f);\n    // n is a positive integer, but it is possible to be greater than 1e21.\n    // In such case we will go the slow path.\n    // See also: https://tc39.es/ecma262/#sec-numeric-types-number-tostring\n    var m;\n    if (n < 1e21) {\n        m = n.toString();\n    }\n    else {\n        m = n.toString();\n        var idx1 = m.indexOf('.');\n        var idx2 = m.indexOf('e+');\n        var exponent = parseInt(m.substring(idx2 + 2), 10);\n        m =\n            m.substring(0, idx1) +\n                m.substring(idx1 + 1, idx2) +\n                repeat('0', exponent - (idx2 - idx1 - 1));\n    }\n    var int;\n    if (f !== 0) {\n        var k = m.length;\n        if (k <= f) {\n            var z = repeat('0', f + 1 - k);\n            m = z + m;\n            k = f + 1;\n        }\n        var a = m.slice(0, k - f);\n        var b = m.slice(k - f);\n        m = a + \".\" + b;\n        int = a.length;\n    }\n    else {\n        int = m.length;\n    }\n    var cut = maxFraction - minFraction;\n    while (cut > 0 && m[m.length - 1] === '0') {\n        m = m.slice(0, -1);\n        cut--;\n    }\n    if (m[m.length - 1] === '.') {\n        m = m.slice(0, -1);\n    }\n    return { formattedString: m, roundedNumber: xFinal, integerDigitsCount: int };\n}\n// https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_proposed_out.html#sec-torawprecision\nexport function toRawPrecision(x, minPrecision, maxPrecision) {\n    var p = maxPrecision;\n    var m;\n    var e;\n    var xFinal;\n    if (x === 0) {\n        m = repeat('0', p);\n        e = 0;\n        xFinal = 0;\n    }\n    else {\n        e = getMagnitude(x);\n        var n = void 0;\n        {\n            var magnitude = e - p + 1;\n            var exactSolve = \n            // Preserve floating point precision as much as possible with multiplication.\n            magnitude < 0 ? x * Math.pow(10, -magnitude) : x / Math.pow(10, magnitude);\n            var roundDown = Math.floor(exactSolve);\n            var roundUp = Math.ceil(exactSolve);\n            n = exactSolve - roundDown < roundUp - exactSolve ? roundDown : roundUp;\n        }\n        // See: https://tc39.es/ecma262/#sec-numeric-types-number-tostring\n        // No need to worry about scientific notation because it only happens for values >= 1e21,\n        // which has 22 significant digits. So it will at least be divided by 10 here to bring the\n        // value back into non-scientific-notation range.\n        m = n.toString();\n        xFinal = n * Math.pow(10, (e - p + 1));\n    }\n    var int;\n    if (e >= p - 1) {\n        m = m + repeat('0', e - p + 1);\n        int = e + 1;\n    }\n    else if (e >= 0) {\n        m = m.slice(0, e + 1) + \".\" + m.slice(e + 1);\n        int = e + 1;\n    }\n    else {\n        m = \"0.\" + repeat('0', -e - 1) + m;\n        int = 1;\n    }\n    if (m.indexOf('.') >= 0 && maxPrecision > minPrecision) {\n        var cut = maxPrecision - minPrecision;\n        while (cut > 0 && m[m.length - 1] === '0') {\n            m = m.slice(0, -1);\n            cut--;\n        }\n        if (m[m.length - 1] === '.') {\n            m = m.slice(0, -1);\n        }\n    }\n    return { formattedString: m, roundedNumber: xFinal, integerDigitsCount: int };\n}\nexport function repeat(s, times) {\n    if (typeof s.repeat === 'function') {\n        return s.repeat(times);\n    }\n    var arr = new Array(times);\n    for (var i = 0; i < arr.length; i++) {\n        arr[i] = s;\n    }\n    return arr.join('');\n}\n//# sourceMappingURL=utils.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { InternalSlotToken, } from '@formatjs/intl-utils';\nfunction invariant(condition, message, Err) {\n    if (Err === void 0) { Err = Error; }\n    if (!condition) {\n        throw new Err(message);\n    }\n}\n// This is from: unicode-12.1.0/General_Category/Symbol/regex.js\nvar S_UNICODE_REGEX = /[\\$\\+<->\\^`\\|~\\xA2-\\xA6\\xA8\\xA9\\xAC\\xAE-\\xB1\\xB4\\xB8\\xD7\\xF7\\u02C2-\\u02C5\\u02D2-\\u02DF\\u02E5-\\u02EB\\u02ED\\u02EF-\\u02FF\\u0375\\u0384\\u0385\\u03F6\\u0482\\u058D-\\u058F\\u0606-\\u0608\\u060B\\u060E\\u060F\\u06DE\\u06E9\\u06FD\\u06FE\\u07F6\\u07FE\\u07FF\\u09F2\\u09F3\\u09FA\\u09FB\\u0AF1\\u0B70\\u0BF3-\\u0BFA\\u0C7F\\u0D4F\\u0D79\\u0E3F\\u0F01-\\u0F03\\u0F13\\u0F15-\\u0F17\\u0F1A-\\u0F1F\\u0F34\\u0F36\\u0F38\\u0FBE-\\u0FC5\\u0FC7-\\u0FCC\\u0FCE\\u0FCF\\u0FD5-\\u0FD8\\u109E\\u109F\\u1390-\\u1399\\u166D\\u17DB\\u1940\\u19DE-\\u19FF\\u1B61-\\u1B6A\\u1B74-\\u1B7C\\u1FBD\\u1FBF-\\u1FC1\\u1FCD-\\u1FCF\\u1FDD-\\u1FDF\\u1FED-\\u1FEF\\u1FFD\\u1FFE\\u2044\\u2052\\u207A-\\u207C\\u208A-\\u208C\\u20A0-\\u20BF\\u2100\\u2101\\u2103-\\u2106\\u2108\\u2109\\u2114\\u2116-\\u2118\\u211E-\\u2123\\u2125\\u2127\\u2129\\u212E\\u213A\\u213B\\u2140-\\u2144\\u214A-\\u214D\\u214F\\u218A\\u218B\\u2190-\\u2307\\u230C-\\u2328\\u232B-\\u2426\\u2440-\\u244A\\u249C-\\u24E9\\u2500-\\u2767\\u2794-\\u27C4\\u27C7-\\u27E5\\u27F0-\\u2982\\u2999-\\u29D7\\u29DC-\\u29FB\\u29FE-\\u2B73\\u2B76-\\u2B95\\u2B98-\\u2BFF\\u2CE5-\\u2CEA\\u2E80-\\u2E99\\u2E9B-\\u2EF3\\u2F00-\\u2FD5\\u2FF0-\\u2FFB\\u3004\\u3012\\u3013\\u3020\\u3036\\u3037\\u303E\\u303F\\u309B\\u309C\\u3190\\u3191\\u3196-\\u319F\\u31C0-\\u31E3\\u3200-\\u321E\\u322A-\\u3247\\u3250\\u3260-\\u327F\\u328A-\\u32B0\\u32C0-\\u33FF\\u4DC0-\\u4DFF\\uA490-\\uA4C6\\uA700-\\uA716\\uA720\\uA721\\uA789\\uA78A\\uA828-\\uA82B\\uA836-\\uA839\\uAA77-\\uAA79\\uAB5B\\uFB29\\uFBB2-\\uFBC1\\uFDFC\\uFDFD\\uFE62\\uFE64-\\uFE66\\uFE69\\uFF04\\uFF0B\\uFF1C-\\uFF1E\\uFF3E\\uFF40\\uFF5C\\uFF5E\\uFFE0-\\uFFE6\\uFFE8-\\uFFEE\\uFFFC\\uFFFD]|\\uD800[\\uDD37-\\uDD3F\\uDD79-\\uDD89\\uDD8C-\\uDD8E\\uDD90-\\uDD9B\\uDDA0\\uDDD0-\\uDDFC]|\\uD802[\\uDC77\\uDC78\\uDEC8]|\\uD805\\uDF3F|\\uD807[\\uDFD5-\\uDFF1]|\\uD81A[\\uDF3C-\\uDF3F\\uDF45]|\\uD82F\\uDC9C|\\uD834[\\uDC00-\\uDCF5\\uDD00-\\uDD26\\uDD29-\\uDD64\\uDD6A-\\uDD6C\\uDD83\\uDD84\\uDD8C-\\uDDA9\\uDDAE-\\uDDE8\\uDE00-\\uDE41\\uDE45\\uDF00-\\uDF56]|\\uD835[\\uDEC1\\uDEDB\\uDEFB\\uDF15\\uDF35\\uDF4F\\uDF6F\\uDF89\\uDFA9\\uDFC3]|\\uD836[\\uDC00-\\uDDFF\\uDE37-\\uDE3A\\uDE6D-\\uDE74\\uDE76-\\uDE83\\uDE85\\uDE86]|\\uD838[\\uDD4F\\uDEFF]|\\uD83B[\\uDCAC\\uDCB0\\uDD2E\\uDEF0\\uDEF1]|\\uD83C[\\uDC00-\\uDC2B\\uDC30-\\uDC93\\uDCA0-\\uDCAE\\uDCB1-\\uDCBF\\uDCC1-\\uDCCF\\uDCD1-\\uDCF5\\uDD10-\\uDD6C\\uDD70-\\uDDAC\\uDDE6-\\uDE02\\uDE10-\\uDE3B\\uDE40-\\uDE48\\uDE50\\uDE51\\uDE60-\\uDE65\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDED5\\uDEE0-\\uDEEC\\uDEF0-\\uDEFA\\uDF00-\\uDF73\\uDF80-\\uDFD8\\uDFE0-\\uDFEB]|\\uD83E[\\uDC00-\\uDC0B\\uDC10-\\uDC47\\uDC50-\\uDC59\\uDC60-\\uDC87\\uDC90-\\uDCAD\\uDD00-\\uDD0B\\uDD0D-\\uDD71\\uDD73-\\uDD76\\uDD7A-\\uDDA2\\uDDA5-\\uDDAA\\uDDAE-\\uDDCA\\uDDCD-\\uDE53\\uDE60-\\uDE6D\\uDE70-\\uDE73\\uDE78-\\uDE7A\\uDE80-\\uDE82\\uDE90-\\uDE95]/;\n// g flag bc this appears twice in accounting pattern\nvar CURRENCY_SYMBOL_REGEX = /¤/g;\n// Instead of doing just replace '{1}' we use global regex\n// since this can appear more than once (e.g {1} {number} {1})\nvar UNIT_1_REGEX = /\\{1\\}/g;\nvar UNIT_0_REGEX = /\\{0\\}/g;\nfunction extractDecimalFormatILD(data) {\n    if (!data) {\n        return;\n    }\n    return Object.keys(data).reduce(function (all, num) {\n        var pattern = data[num];\n        all[num] = Object.keys(pattern).reduce(function (all, p) {\n            all[p] = (pattern[p] || '')\n                .replace(/[¤0]/g, '') // apostrophe-escaped\n                .replace(/'(.*?)'/g, '$1')\n                .trim();\n            return all;\n        }, {\n            other: pattern.other\n                .replace(/[¤0]/g, '') // apostrophe-escaped\n                .replace(/'(.*?)'/g, '$1')\n                .trim(),\n        });\n        return all;\n    }, Object.create(null));\n}\nfunction extractLDMLPluralRuleMap(m, k) {\n    return Object.keys(m).reduce(function (all, rule) {\n        all[rule] = m[rule][k];\n        return all;\n    }, { other: m.other[k] });\n}\nexport function extractILD(units, currencies, numbers, numberingSystem) {\n    return {\n        decimal: {\n            compactShort: extractDecimalFormatILD(numbers.decimal[numberingSystem].short),\n            compactLong: extractDecimalFormatILD(numbers.decimal[numberingSystem].long),\n        },\n        currency: {\n            compactShort: extractDecimalFormatILD(numbers.currency[numberingSystem].short),\n        },\n        symbols: numbers.symbols[numberingSystem],\n        currencySymbols: Object.keys(currencies).reduce(function (all, code) {\n            all[code] = {\n                currencyName: currencies[code].displayName,\n                currencySymbol: currencies[code].symbol,\n                currencyNarrowSymbol: currencies[code].narrow || currencies[code].symbol,\n            };\n            return all;\n        }, Object.create(null)),\n        unitSymbols: Object.keys(units).reduce(function (all, unit) {\n            all[unit] = {\n                unitSymbol: extractLDMLPluralRuleMap(units[unit].short, 'symbol'),\n                unitNarrowSymbol: extractLDMLPluralRuleMap(units[unit].narrow, 'symbol'),\n                unitName: extractLDMLPluralRuleMap(units[unit].long, 'symbol'),\n            };\n            return all;\n        }, Object.create(null)),\n    };\n}\nfunction serializeSlotTokens(tokens) {\n    if (Array.isArray(tokens))\n        return tokens.map(function (t) { return \"{\" + t + \"}\"; }).join('');\n    return \"{\" + tokens + \"}\";\n}\n// Credit: https://github.com/andyearnshaw/Intl.js/blob/master/scripts/utils/reduce.js\n// Matches CLDR number patterns, e.g. #,##0.00, #,##,##0.00, #,##0.##, 0, etc.\nvar NUMBER_PATTERN = /[#0](?:[\\.,][#0]+)*/g;\nvar SCIENTIFIC_POSITIVE_PATTERN = serializeSlotTokens([\n    InternalSlotToken.number,\n    InternalSlotToken.scientificSeparator,\n    InternalSlotToken.scientificExponent,\n]);\nvar SCIENTIFIC_NEGATIVE_PATTERN = serializeSlotTokens([\n    InternalSlotToken.minusSign,\n    InternalSlotToken.number,\n    InternalSlotToken.scientificSeparator,\n    InternalSlotToken.scientificExponent,\n]);\nvar DUMMY_POSITIVE_PATTERN = serializeSlotTokens([InternalSlotToken.number]);\nvar DUMMY_NEGATIVE_PATTERN = serializeSlotTokens([\n    InternalSlotToken.minusSign,\n    InternalSlotToken.number,\n]);\nvar DUMMY_PATTERN = DUMMY_POSITIVE_PATTERN + ';' + DUMMY_NEGATIVE_PATTERN;\nvar SCIENTIFIC_PATTERN = SCIENTIFIC_POSITIVE_PATTERN + ';' + SCIENTIFIC_NEGATIVE_PATTERN;\n/**\n * Turn compact pattern like `0 trillion` to\n * `0 {compactSymbol};-0 {compactSymbol}`.\n * Negative pattern will not be inserted if there already\n * exist one.\n * TODO: Maybe preprocess this\n * @param pattern decimal long/short pattern\n */\nfunction processDecimalCompactSymbol(pattern, slotToken) {\n    if (slotToken === void 0) { slotToken = InternalSlotToken.compactSymbol; }\n    var compactUnit = pattern.replace(/0+/, '').trim();\n    if (compactUnit) {\n        pattern = pattern.replace(compactUnit, serializeSlotTokens(slotToken));\n    }\n    var negativePattern = pattern.indexOf('-') > -1 ? pattern : pattern.replace(/(0+)/, '-$1');\n    return [\n        pattern.replace(/0+/, '{number}'),\n        negativePattern.replace(/0+/, '{number}'),\n    ];\n}\n/**\n * Turn compact pattern like `¤0 trillion` to\n * `¤0 {compactSymbol};-¤0 {compactSymbol}`\n * Negative pattern will not be inserted if there already\n * exist one.\n * TODO: Maybe preprocess this\n * @param pattern currency long/short pattern\n */\nfunction processCurrencyCompactSymbol(pattern, slotToken) {\n    if (slotToken === void 0) { slotToken = InternalSlotToken.compactSymbol; }\n    var compactUnit = pattern.replace(/[¤0]/g, '').trim();\n    if (compactUnit) {\n        pattern = pattern.replace(compactUnit, serializeSlotTokens(slotToken));\n    }\n    var negativePattern = pattern.indexOf('-') > -1 ? pattern : \"-\" + pattern;\n    return (pattern.replace(/0+/, '{number}') +\n        ';' +\n        negativePattern.replace(/0+/, '{number}'));\n}\nvar INSERT_BEFORE_PATTERN_REGEX = /[^\\s;(-]¤/;\nvar INSERT_AFTER_PATTERN_REGEX = /¤[^\\s);]/;\nfunction shouldInsertBefore(currency, pattern) {\n    // surroundingMatch [:digit:] check\n    return (INSERT_BEFORE_PATTERN_REGEX.test(pattern) &&\n        // [:^S:]\n        !S_UNICODE_REGEX.test(currency[0]));\n}\nfunction shouldInsertAfter(currency, pattern) {\n    return (INSERT_AFTER_PATTERN_REGEX.test(pattern) &&\n        // [:^S:]\n        !S_UNICODE_REGEX.test(currency[currency.length - 1]));\n}\nfunction insertBetween(currency, pattern, insertBetweenChar) {\n    // Check afterCurrency\n    if (shouldInsertAfter(currency, pattern)) {\n        return pattern.replace(CURRENCY_SYMBOL_REGEX, \"\\u00A4\" + insertBetweenChar);\n    }\n    // Check beforeCurrency\n    if (shouldInsertBefore(currency, pattern)) {\n        return pattern.replace(CURRENCY_SYMBOL_REGEX, insertBetweenChar + \"\\u00A4\");\n    }\n    return pattern;\n}\nvar Patterns = /** @class */ (function () {\n    function Patterns(units, currencies, numbers, numberingSystem, unit, currency, currencySign) {\n        this.units = units;\n        this.currencies = currencies;\n        this.numbers = numbers;\n        this.numberingSystem = numberingSystem;\n        this._unit = unit;\n        this._currency = currency;\n        this.currencySign = currencySign;\n    }\n    Object.defineProperty(Patterns.prototype, \"decimal\", {\n        // Style\n        get: function () {\n            if (!this.decimalPatterns) {\n                this.decimalPatterns = new DecimalPatterns(this.numbers, this.numberingSystem);\n            }\n            return this.decimalPatterns;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Patterns.prototype, \"percent\", {\n        get: function () {\n            if (!this.percentPatterns) {\n                this.percentPatterns = new PercentPatterns(this.numbers, this.numberingSystem);\n            }\n            return this.percentPatterns;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Patterns.prototype, \"unit\", {\n        get: function () {\n            if (!this.unitPatterns) {\n                invariant(!!this._unit, 'unit must be supplied');\n                this.unitPatterns = Object.create(null);\n                this.unitPatterns[this._unit] = new UnitPatterns(this.units, this.numbers, this.numberingSystem, this._unit);\n            }\n            return this.unitPatterns;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Patterns.prototype, \"currency\", {\n        get: function () {\n            if (!this.currencyPatterns) {\n                invariant(!!this._currency, 'currency must be supplied');\n                invariant(!!this.currencySign, 'currencySign must be supplied');\n                this.currencyPatterns = Object.create(null);\n                this.currencyPatterns[this._currency] = new CurrencyPatterns(this.currencies, this.numbers, this.numberingSystem, this._currency, this.currencySign);\n            }\n            return this.currencyPatterns;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return Patterns;\n}());\nexport { Patterns };\nfunction processSignPattern(signPattern, fn) {\n    if (!fn) {\n        return signPattern;\n    }\n    return {\n        positivePattern: fn(signPattern.positivePattern),\n        zeroPattern: fn(signPattern.zeroPattern),\n        negativePattern: fn(signPattern.negativePattern),\n    };\n}\n/**\n * Produce positive/negative/zero pattern\n * This also converts {0} into {number}\n * @param patterns\n * @param signDisplay\n */\nfunction produceSignPattern(patterns, signDisplay) {\n    invariant(!!patterns, 'Pattern should have existed');\n    var _a = patterns.split(';'), positivePattern = _a[0], negativePattern = _a[1];\n    invariant(!!negativePattern, \"negativePattern should have existed but got \\\"\" + patterns + \"\\\"\");\n    var noSignPattern = positivePattern.replace('+', '');\n    negativePattern = negativePattern.replace('-', serializeSlotTokens(InternalSlotToken.minusSign));\n    var alwaysPositivePattern = positivePattern;\n    if (negativePattern.indexOf(InternalSlotToken.minusSign) > -1) {\n        alwaysPositivePattern = negativePattern.replace(InternalSlotToken.minusSign, InternalSlotToken.plusSign);\n    }\n    else if (positivePattern.indexOf('+') > -1) {\n        alwaysPositivePattern = positivePattern = positivePattern.replace('+', serializeSlotTokens(InternalSlotToken.plusSign));\n    }\n    else {\n        // In case {0} is in the middle of the pattern\n        alwaysPositivePattern = \"\" + serializeSlotTokens(InternalSlotToken.plusSign) + noSignPattern;\n    }\n    positivePattern = positivePattern.replace('{0}', serializeSlotTokens(InternalSlotToken.number));\n    alwaysPositivePattern = alwaysPositivePattern.replace('{0}', serializeSlotTokens(InternalSlotToken.number));\n    negativePattern = negativePattern.replace('{0}', serializeSlotTokens(InternalSlotToken.number));\n    noSignPattern = noSignPattern.replace('{0}', serializeSlotTokens(InternalSlotToken.number));\n    switch (signDisplay) {\n        case 'always':\n            return {\n                positivePattern: alwaysPositivePattern,\n                zeroPattern: alwaysPositivePattern,\n                negativePattern: negativePattern,\n            };\n        case 'auto':\n            return {\n                positivePattern: positivePattern,\n                zeroPattern: positivePattern,\n                negativePattern: negativePattern,\n            };\n        case 'exceptZero':\n            return {\n                positivePattern: alwaysPositivePattern,\n                zeroPattern: noSignPattern,\n                negativePattern: negativePattern,\n            };\n        case 'never':\n            return {\n                positivePattern: noSignPattern,\n                zeroPattern: noSignPattern,\n                negativePattern: noSignPattern,\n            };\n    }\n}\nvar NotationPatterns = /** @class */ (function () {\n    function NotationPatterns() {\n    }\n    Object.defineProperty(NotationPatterns.prototype, \"compactShort\", {\n        get: function () {\n            this.notation = 'compactShort';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, \"compactLong\", {\n        get: function () {\n            this.notation = 'compactLong';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '1000', {\n        // DecimalFormatNum\n        get: function () {\n            return this.produceCompactSignPattern('1000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '10000', {\n        get: function () {\n            return this.produceCompactSignPattern('10000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '100000', {\n        get: function () {\n            return this.produceCompactSignPattern('100000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '1000000', {\n        get: function () {\n            return this.produceCompactSignPattern('1000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '10000000', {\n        get: function () {\n            return this.produceCompactSignPattern('10000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '100000000', {\n        get: function () {\n            return this.produceCompactSignPattern('100000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '1000000000', {\n        get: function () {\n            return this.produceCompactSignPattern('1000000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '10000000000', {\n        get: function () {\n            return this.produceCompactSignPattern('10000000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '100000000000', {\n        get: function () {\n            return this.produceCompactSignPattern('100000000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '1000000000000', {\n        get: function () {\n            return this.produceCompactSignPattern('1000000000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '10000000000000', {\n        get: function () {\n            return this.produceCompactSignPattern('10000000000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(NotationPatterns.prototype, '100000000000000', {\n        get: function () {\n            return this.produceCompactSignPattern('100000000000000');\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return NotationPatterns;\n}());\nvar DecimalPatterns = /** @class */ (function (_super) {\n    __extends(DecimalPatterns, _super);\n    function DecimalPatterns(numbers, numberingSystem) {\n        var _this = _super.call(this) || this;\n        _this.numbers = numbers;\n        _this.numberingSystem = numberingSystem;\n        return _this;\n    }\n    DecimalPatterns.prototype.produceCompactSignPattern = function (decimalNum) {\n        if (!this.compactSignPattern) {\n            this.compactSignPattern = Object.create(null);\n        }\n        var signPattern = this.compactSignPattern;\n        if (!signPattern[decimalNum]) {\n            invariant(!!this.signDisplay, 'Sign Display should have existed');\n            if (this.notation === 'compactLong') {\n                signPattern[decimalNum] = produceSignPattern(processDecimalCompactSymbol(this.numbers.decimal[this.numberingSystem].long[decimalNum].other, InternalSlotToken.compactName).join(';'), this.signDisplay);\n            }\n            else {\n                signPattern[decimalNum] = produceSignPattern(processDecimalCompactSymbol(this.numbers.decimal[this.numberingSystem].short[decimalNum].other, InternalSlotToken.compactSymbol).join(';'), this.signDisplay);\n            }\n        }\n        return signPattern[decimalNum];\n    };\n    Object.defineProperty(DecimalPatterns.prototype, \"always\", {\n        // Sign Display\n        get: function () {\n            this.signDisplay = 'always';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DecimalPatterns.prototype, \"auto\", {\n        get: function () {\n            this.signDisplay = 'auto';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DecimalPatterns.prototype, \"never\", {\n        get: function () {\n            this.signDisplay = 'never';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DecimalPatterns.prototype, \"exceptZero\", {\n        get: function () {\n            this.signDisplay = 'exceptZero';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DecimalPatterns.prototype, \"standard\", {\n        // Notation\n        get: function () {\n            if (!this.signPattern) {\n                invariant(!!this.signDisplay, 'Sign Display should have existed');\n                this.signPattern = produceSignPattern(DUMMY_PATTERN, this.signDisplay);\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DecimalPatterns.prototype, \"scientific\", {\n        get: function () {\n            if (!this.signPattern) {\n                invariant(!!this.signDisplay, 'Sign Display should have existed');\n                this.signPattern = produceSignPattern(SCIENTIFIC_PATTERN, this.signDisplay);\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return DecimalPatterns;\n}(NotationPatterns));\nvar PercentPatterns = /** @class */ (function (_super) {\n    __extends(PercentPatterns, _super);\n    function PercentPatterns() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    PercentPatterns.prototype.generateStandardOrScientificPattern = function (isScientific) {\n        invariant(!!this.signDisplay, 'Sign Display should have existed');\n        var pattern = this.numbers.percent[this.numberingSystem]\n            .replace(/%/g, serializeSlotTokens(InternalSlotToken.percentSign))\n            .replace(NUMBER_PATTERN, isScientific\n            ? SCIENTIFIC_POSITIVE_PATTERN\n            : serializeSlotTokens(InternalSlotToken.number));\n        var negativePattern;\n        if (pattern.indexOf(';') < 0) {\n            negativePattern = \"\" + serializeSlotTokens(InternalSlotToken.minusSign) + pattern;\n            pattern += ';' + negativePattern;\n        }\n        return produceSignPattern(pattern, this.signDisplay);\n    };\n    Object.defineProperty(PercentPatterns.prototype, \"standard\", {\n        // Notation\n        get: function () {\n            if (!this.signPattern) {\n                this.signPattern = this.generateStandardOrScientificPattern();\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(PercentPatterns.prototype, \"scientific\", {\n        get: function () {\n            if (!this.signPattern) {\n                this.signPattern = this.generateStandardOrScientificPattern(true);\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return PercentPatterns;\n}(DecimalPatterns));\nvar UnitPatterns = /** @class */ (function (_super) {\n    __extends(UnitPatterns, _super);\n    function UnitPatterns(units, numbers, numberingSystem, unit) {\n        var _this = _super.call(this) || this;\n        _this.unit = unit;\n        _this.units = units;\n        _this.numbers = numbers;\n        _this.numberingSystem = numberingSystem;\n        return _this;\n    }\n    UnitPatterns.prototype.generateStandardOrScientificPattern = function (isScientific) {\n        invariant(!!this.signDisplay, 'Sign Display should have existed');\n        invariant(!!this.pattern, 'Pattern must exist');\n        var pattern = this.pattern;\n        var negativePattern;\n        if (pattern.indexOf(';') < 0) {\n            negativePattern = pattern.replace('{0}', '-{0}');\n            pattern += ';' + negativePattern;\n        }\n        pattern = pattern.replace(UNIT_0_REGEX, isScientific\n            ? SCIENTIFIC_POSITIVE_PATTERN\n            : serializeSlotTokens(InternalSlotToken.number));\n        return produceSignPattern(pattern, this.signDisplay);\n    };\n    UnitPatterns.prototype.produceCompactSignPattern = function (decimalNum) {\n        if (!this.compactSignPattern) {\n            this.compactSignPattern = Object.create(null);\n        }\n        var compactSignPatterns = this.compactSignPattern;\n        if (!compactSignPatterns[decimalNum]) {\n            invariant(!!this.pattern, 'Pattern should exist');\n            invariant(!!this.signDisplay, 'Sign Display should exist');\n            var pattern = this.pattern;\n            var compactPattern = void 0;\n            if (this.notation === 'compactShort') {\n                compactPattern = processDecimalCompactSymbol(this.numbers.decimal[this.numberingSystem].short[decimalNum].other, InternalSlotToken.compactSymbol);\n            }\n            else {\n                compactPattern = processDecimalCompactSymbol(this.numbers.decimal[this.numberingSystem].long[decimalNum].other, InternalSlotToken.compactName);\n            }\n            pattern =\n                pattern.replace('{0}', compactPattern[0]) +\n                    ';' +\n                    pattern.replace('{0}', compactPattern[1]);\n            compactSignPatterns[decimalNum] = produceSignPattern(pattern, this.signDisplay);\n        }\n        return compactSignPatterns[decimalNum];\n    };\n    Object.defineProperty(UnitPatterns.prototype, \"narrow\", {\n        // UnitDisplay\n        get: function () {\n            if (!this.pattern) {\n                this.pattern = this.units[this.unit].narrow.other.pattern.replace(UNIT_1_REGEX, serializeSlotTokens(InternalSlotToken.unitNarrowSymbol));\n            }\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"short\", {\n        get: function () {\n            if (!this.pattern) {\n                this.pattern = this.units[this.unit].short.other.pattern.replace(UNIT_1_REGEX, serializeSlotTokens(InternalSlotToken.unitSymbol));\n            }\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"long\", {\n        get: function () {\n            if (!this.pattern) {\n                this.pattern = this.units[this.unit].long.other.pattern.replace(UNIT_1_REGEX, serializeSlotTokens(InternalSlotToken.unitName));\n            }\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"always\", {\n        // Sign Display\n        get: function () {\n            this.signDisplay = 'always';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"auto\", {\n        get: function () {\n            this.signDisplay = 'auto';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"never\", {\n        get: function () {\n            this.signDisplay = 'never';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"exceptZero\", {\n        get: function () {\n            this.signDisplay = 'exceptZero';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"standard\", {\n        // Notation\n        get: function () {\n            if (!this.signPattern) {\n                this.signPattern = this.generateStandardOrScientificPattern();\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(UnitPatterns.prototype, \"scientific\", {\n        get: function () {\n            if (!this.signPattern) {\n                this.signPattern = this.generateStandardOrScientificPattern(true);\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return UnitPatterns;\n}(NotationPatterns));\nfunction resolvePatternForCurrencyCode(resolvedCurrency, data, notation, currencySign, decimalNum) {\n    var shortPattern = data.short;\n    var longPattern = data.long || data.short;\n    var pattern = '';\n    switch (notation) {\n        case 'compactLong': {\n            pattern =\n                (longPattern === null || longPattern === void 0 ? void 0 : longPattern[decimalNum].other) || (shortPattern === null || shortPattern === void 0 ? void 0 : shortPattern[decimalNum].other) ||\n                    data.standard;\n            return processCurrencyCompactSymbol(insertBetween(resolvedCurrency, pattern, data.currencySpacing.beforeInsertBetween), InternalSlotToken.compactName);\n        }\n        case 'compactShort':\n            pattern = (shortPattern === null || shortPattern === void 0 ? void 0 : shortPattern[decimalNum].other) || data.standard;\n            return processCurrencyCompactSymbol(insertBetween(resolvedCurrency, pattern, data.currencySpacing.beforeInsertBetween), InternalSlotToken.compactSymbol);\n        case 'scientific':\n            pattern = currencySign === 'accounting' ? data.accounting : data.standard;\n            pattern = insertBetween(resolvedCurrency, pattern, data.currencySpacing.beforeInsertBetween);\n            if (pattern.indexOf(';') < 0) {\n                pattern += ';' + (\"-\" + pattern);\n            }\n            return pattern.replace(NUMBER_PATTERN, SCIENTIFIC_POSITIVE_PATTERN);\n        case 'standard':\n            pattern = currencySign === 'accounting' ? data.accounting : data.standard;\n            pattern = insertBetween(resolvedCurrency, pattern, data.currencySpacing.beforeInsertBetween);\n            if (pattern.indexOf(';') < 0) {\n                pattern += ';' + (\"-\" + pattern);\n            }\n            return pattern.replace(NUMBER_PATTERN, serializeSlotTokens(InternalSlotToken.number));\n    }\n}\n/**\n * Resolve pattern for currency name\n * TODO: CurrencySign doesn't matter here (accounting or standard).\n * When it comes to using `name`, it's `-1 Australian Dollars`\n * instead of `(1 Australian Dollar)`\n * @param numbers\n * @param numberingSystem\n * @param notation\n * @param decimalNum\n */\nfunction resolvePatternForCurrencyName(numbers, numberingSystem, notation, decimalNum) {\n    var pattern = numbers.currency[numberingSystem].unitPattern.replace(UNIT_1_REGEX, serializeSlotTokens(InternalSlotToken.currencyName));\n    var numberPattern;\n    // currencySign doesn't matter here but notation does\n    switch (notation) {\n        case 'compactLong':\n            numberPattern = processDecimalCompactSymbol(numbers.decimal[numberingSystem].long[decimalNum].other, InternalSlotToken.compactName);\n            break;\n        case 'compactShort':\n            numberPattern = processDecimalCompactSymbol(numbers.decimal[numberingSystem].short[decimalNum].other, InternalSlotToken.compactSymbol);\n            break;\n        case 'scientific':\n            numberPattern = [\n                SCIENTIFIC_POSITIVE_PATTERN,\n                SCIENTIFIC_NEGATIVE_PATTERN,\n            ];\n            break;\n        case 'standard':\n            numberPattern = [DUMMY_POSITIVE_PATTERN, DUMMY_NEGATIVE_PATTERN];\n            break;\n    }\n    return (pattern.replace('{0}', numberPattern[0]) +\n        ';' +\n        pattern.replace('{0}', numberPattern[1]));\n}\nvar CurrencyPatterns = /** @class */ (function () {\n    function CurrencyPatterns(currencies, numbers, numberingSystem, currency, currencySign) {\n        this.currency = currency;\n        this.currencies = currencies;\n        this.numbers = numbers;\n        this.numberingSystem = numberingSystem;\n        this.currencySign = currencySign;\n    }\n    Object.defineProperty(CurrencyPatterns.prototype, \"code\", {\n        // CurrencyDisplay\n        get: function () {\n            this.currencySlotToken = InternalSlotToken.currencyCode;\n            this.resolvedCurrency = this.currency;\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencyPatterns.prototype, \"symbol\", {\n        get: function () {\n            this.currencySlotToken = InternalSlotToken.currencySymbol;\n            this.resolvedCurrency = this.currencies[this.currency].symbol;\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencyPatterns.prototype, \"narrowSymbol\", {\n        get: function () {\n            this.currencySlotToken = InternalSlotToken.currencyNarrowSymbol;\n            this.resolvedCurrency = this.currencies[this.currency].narrow;\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencyPatterns.prototype, \"name\", {\n        get: function () {\n            this.currencySlotToken = InternalSlotToken.currencyName;\n            this.resolvedCurrency = this.currencies[this.currency].displayName.other;\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencyPatterns.prototype, \"accounting\", {\n        // CurrencySign\n        get: function () {\n            this.currencySign = 'accounting';\n            if (!this.signDisplayPatterns) {\n                invariant(!!this.currencySign, 'Currency Sign should have existed');\n                invariant(!!this.currencySlotToken, 'Currency Slot Token should have existed');\n                invariant(!!this.resolvedCurrency, 'Currency should have been resolved');\n                this.signDisplayPatterns = new CurrencySignDisplayPatterns(this.resolvedCurrency, this.numbers, this.numberingSystem, this.currencySign, this.currencySlotToken);\n            }\n            return this.signDisplayPatterns;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencyPatterns.prototype, \"standard\", {\n        get: function () {\n            this.currencySign = 'standard';\n            if (!this.signDisplayPatterns) {\n                invariant(!!this.currencySign, 'Currency Sign should have existed');\n                invariant(!!this.currencySlotToken, 'Currency Display should have existed');\n                invariant(!!this.resolvedCurrency, 'Currency should have been resolved');\n                this.signDisplayPatterns = new CurrencySignDisplayPatterns(this.resolvedCurrency, this.numbers, this.numberingSystem, this.currencySign, this.currencySlotToken);\n            }\n            return this.signDisplayPatterns;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return CurrencyPatterns;\n}());\nvar CurrencySignDisplayPatterns = /** @class */ (function (_super) {\n    __extends(CurrencySignDisplayPatterns, _super);\n    function CurrencySignDisplayPatterns(resolvedCurrency, numbers, numberingSystem, currencySign, currencySlotToken) {\n        var _this = _super.call(this) || this;\n        _this.currency = resolvedCurrency;\n        _this.numbers = numbers;\n        _this.numberingSystem = numberingSystem;\n        _this.currencySign = currencySign;\n        _this.currencySlotToken = currencySlotToken;\n        return _this;\n    }\n    Object.defineProperty(CurrencySignDisplayPatterns.prototype, \"always\", {\n        // Sign Display\n        get: function () {\n            this.signDisplay = 'always';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencySignDisplayPatterns.prototype, \"auto\", {\n        get: function () {\n            this.signDisplay = 'auto';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencySignDisplayPatterns.prototype, \"never\", {\n        get: function () {\n            this.signDisplay = 'never';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencySignDisplayPatterns.prototype, \"exceptZero\", {\n        get: function () {\n            this.signDisplay = 'exceptZero';\n            return this;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencySignDisplayPatterns.prototype, \"standard\", {\n        // Notation\n        // Standard currency sign\n        get: function () {\n            if (!this.signPattern) {\n                invariant(!!this.currencySign, 'Currency sign should exist');\n                invariant(!!this.signDisplay, 'Sign display must exist');\n                var pattern = '';\n                // name -> standard -> standard\n                // name -> accounting -> standard\n                if (this.currencySlotToken === InternalSlotToken.currencyName) {\n                    pattern = resolvePatternForCurrencyName(this.numbers, this.numberingSystem, 'standard', '1000' // dummy\n                    );\n                }\n                // code -> standard -> standard\n                // code -> accounting -> standard\n                // symbol -> standard -> standard\n                // symbol -> accounting -> standard\n                // narrowSymbol -> standard -> standard\n                // narrowSymbol -> accounting -> standard\n                else {\n                    pattern = resolvePatternForCurrencyCode(this.currency, this.numbers.currency[this.numberingSystem], 'standard', this.currencySign, '1000' // dummy\n                    ).replace(CURRENCY_SYMBOL_REGEX, serializeSlotTokens(this.currencySlotToken));\n                }\n                this.signPattern = produceSignPattern(pattern, this.signDisplay);\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CurrencySignDisplayPatterns.prototype, \"scientific\", {\n        get: function () {\n            if (!this.signPattern) {\n                invariant(!!this.currencySign, 'Currency sign should exist');\n                invariant(!!this.signDisplay, 'Sign display must exist');\n                var pattern = '';\n                // name -> standard -> scientific\n                // name -> accounting -> scientific\n                if (this.currencySlotToken === InternalSlotToken.currencyName) {\n                    pattern = resolvePatternForCurrencyName(this.numbers, this.numberingSystem, 'scientific', '1000' // dummy\n                    );\n                }\n                // code -> standard -> scientific\n                // code -> accounting -> scientific\n                // symbol -> standard -> scientific\n                // symbol -> accounting -> scientific\n                // narrowSymbol -> standard -> scientific\n                // narrowSymbol -> accounting -> scientific\n                else {\n                    pattern = resolvePatternForCurrencyCode(this.currency, this.numbers.currency[this.numberingSystem], 'scientific', this.currencySign, '1000' // dummy\n                    ).replace(CURRENCY_SYMBOL_REGEX, serializeSlotTokens(this.currencySlotToken));\n                }\n                this.signPattern = produceSignPattern(pattern, this.signDisplay);\n            }\n            return this.signPattern;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    CurrencySignDisplayPatterns.prototype.produceCompactSignPattern = function (decimalNum) {\n        if (!this.compactSignPattern) {\n            this.compactSignPattern = Object.create(null);\n        }\n        var compactSignPatterns = this.compactSignPattern;\n        if (!compactSignPatterns[decimalNum]) {\n            invariant(!!this.currencySign, 'Currency sign should exist');\n            invariant(!!this.signDisplay, 'Sign display must exist');\n            var pattern = '';\n            // name -> standard -> compact -> compactLong\n            // name -> accounting -> compact -> compactShort\n            if (this.currencySlotToken === InternalSlotToken.currencyName) {\n                pattern = resolvePatternForCurrencyName(this.numbers, this.numberingSystem, this.notation, decimalNum);\n            }\n            else {\n                pattern = resolvePatternForCurrencyCode(this.currency, this.numbers.currency[this.numberingSystem], this.notation, this.currencySign, decimalNum).replace(CURRENCY_SYMBOL_REGEX, serializeSlotTokens(this.currencySlotToken));\n            }\n            compactSignPatterns[decimalNum] = processSignPattern(produceSignPattern(pattern, this.signDisplay), function (pattern) { return pattern.replace(/0+/, '{number}'); });\n        }\n        return compactSignPatterns[decimalNum];\n    };\n    return CurrencySignDisplayPatterns;\n}(NotationPatterns));\n//# sourceMappingURL=data.js.map","var __spreadArrays = (this && this.__spreadArrays) || function () {\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n            r[k] = a[j];\n    return r;\n};\nimport { createResolveLocale, toObject, supportedLocales, getCanonicalLocales, setInternalSlot, setMultiInternalSlots, getMultiInternalSlots, getOption, getInternalSlot, InternalSlotToken, setNumberFormatDigitOptions, SANCTIONED_UNITS, invariant, objectIs, unpackData, partitionPattern, isWellFormedCurrencyCode, } from '@formatjs/intl-utils';\nimport { toRawFixed, toRawPrecision, getMagnitude, repeat, } from './utils';\nimport { extractILD, Patterns } from './data';\nimport * as currencyDigitsData from './currency-digits.json';\nimport * as ILND from './ilnd-numbers.json';\nimport { names as numberingSystemNames } from './numbering-systems.json';\nvar VALID_NUMBERING_SYSTEM_NAMES = Object.create(null);\nfor (var _i = 0, numberingSystemNames_1 = numberingSystemNames; _i < numberingSystemNames_1.length; _i++) {\n    var nu = numberingSystemNames_1[_i];\n    VALID_NUMBERING_SYSTEM_NAMES[nu] = true;\n}\nvar RESOLVED_OPTIONS_KEYS = [\n    'locale',\n    'numberingSystem',\n    'style',\n    'currency',\n    'currencyDisplay',\n    'currencySign',\n    'unit',\n    'unitDisplay',\n    'minimumIntegerDigits',\n    'minimumFractionDigits',\n    'maximumFractionDigits',\n    'minimumSignificantDigits',\n    'maximumSignificantDigits',\n    'useGrouping',\n    'notation',\n    'compactDisplay',\n    'signDisplay',\n];\nvar SHORTENED_SACTION_UNITS = SANCTIONED_UNITS.map(function (unit) {\n    return unit.replace(/^(.*?)-/, '');\n});\n/**\n * This follows https://tc39.es/ecma402/#sec-case-sensitivity-and-case-mapping\n * @param str string to convert\n */\nfunction toLowerCase(str) {\n    return str.replace(/([A-Z])/g, function (_, c) { return c.toLowerCase(); });\n}\n/**\n * https://tc39.es/proposal-unified-intl-numberformat/section6/locales-currencies-tz_proposed_out.html#sec-iswellformedunitidentifier\n * @param unit\n */\nfunction isWellFormedUnitIdentifier(unit) {\n    unit = toLowerCase(unit);\n    if (SHORTENED_SACTION_UNITS.indexOf(unit) > -1) {\n        return true;\n    }\n    var units = unit.split('-per-');\n    if (units.length !== 2) {\n        return false;\n    }\n    if (SHORTENED_SACTION_UNITS.indexOf(units[0]) < 0 ||\n        SHORTENED_SACTION_UNITS.indexOf(units[1]) < 0) {\n        return false;\n    }\n    return true;\n}\n/**\n * Check if a formatting number with unit is supported\n * @public\n * @param unit unit to check\n */\nexport function isUnitSupported(unit) {\n    try {\n        new Intl.NumberFormat(undefined, {\n            style: 'unit',\n            unit: unit,\n        });\n    }\n    catch (e) {\n        return false;\n    }\n    return true;\n}\n/**\n * Chop off the unicode extension from the locale string.\n */\nfunction removeUnicodeExtensionFromLocale(canonicalLocale) {\n    var extensionIndex = canonicalLocale.indexOf('-u-');\n    return extensionIndex >= 0\n        ? canonicalLocale.slice(0, extensionIndex)\n        : canonicalLocale;\n}\nvar __INTERNAL_SLOT_MAP__ = new WeakMap();\nfunction currencyDigits(c) {\n    return c in currencyDigitsData ? currencyDigitsData[c] : 2;\n}\nfunction initializeNumberFormat(nf, locales, opts) {\n    var requestedLocales = getCanonicalLocales(locales);\n    var options = opts === undefined ? Object.create(null) : toObject(opts);\n    var opt = Object.create(null);\n    var matcher = getOption(options, 'localeMatcher', 'string', ['best fit', 'lookup'], 'best fit');\n    opt.localeMatcher = matcher;\n    var numberingSystem = getOption(options, 'numberingSystem', 'string', undefined, undefined);\n    if (numberingSystem !== undefined &&\n        !VALID_NUMBERING_SYSTEM_NAMES[numberingSystem]) {\n        // 8.a. If numberingSystem does not match the Unicode Locale Identifier type nonterminal,\n        // throw a RangeError exception.\n        throw RangeError(\"Invalid numberingSystems: \" + numberingSystem);\n    }\n    opt.nu = numberingSystem;\n    var localeData = UnifiedNumberFormat.localeData;\n    var r = createResolveLocale(UnifiedNumberFormat.getDefaultLocale)(UnifiedNumberFormat.availableLocales, requestedLocales, opt, \n    // [[RelevantExtensionKeys]] slot, which is a constant\n    ['nu'], localeData);\n    var ildData = localeData[removeUnicodeExtensionFromLocale(r.locale)];\n    setMultiInternalSlots(__INTERNAL_SLOT_MAP__, nf, {\n        locale: r.locale,\n        dataLocale: r.dataLocale,\n        numberingSystem: r.nu,\n        ild: extractILD(ildData.units, ildData.currencies, ildData.numbers, r.nu),\n    });\n    // https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_proposed_out.html#sec-setnumberformatunitoptions\n    setNumberFormatUnitOptions(nf, options);\n    var style = getInternalSlot(__INTERNAL_SLOT_MAP__, nf, 'style');\n    // ---\n    var mnfdDefault;\n    var mxfdDefault;\n    if (style === 'currency') {\n        var currency = getInternalSlot(__INTERNAL_SLOT_MAP__, nf, 'currency');\n        var cDigits = currencyDigits(currency);\n        mnfdDefault = cDigits;\n        mxfdDefault = cDigits;\n    }\n    else {\n        mnfdDefault = 0;\n        mxfdDefault = style === 'percent' ? 0 : 3;\n    }\n    var notation = getOption(options, 'notation', 'string', ['standard', 'scientific', 'engineering', 'compact'], 'standard');\n    setInternalSlot(__INTERNAL_SLOT_MAP__, nf, 'notation', notation);\n    setNumberFormatDigitOptions(__INTERNAL_SLOT_MAP__, nf, options, mnfdDefault, mxfdDefault);\n    var compactDisplay = getOption(options, 'compactDisplay', 'string', ['short', 'long'], 'short');\n    if (notation === 'compact') {\n        setInternalSlot(__INTERNAL_SLOT_MAP__, nf, 'compactDisplay', compactDisplay);\n    }\n    var useGrouping = getOption(options, 'useGrouping', 'boolean', undefined, true);\n    setInternalSlot(__INTERNAL_SLOT_MAP__, nf, 'useGrouping', useGrouping);\n    var signDisplay = getOption(options, 'signDisplay', 'string', ['auto', 'never', 'always', 'exceptZero'], 'auto');\n    setInternalSlot(__INTERNAL_SLOT_MAP__, nf, 'signDisplay', signDisplay);\n}\nfunction partitionNumberPattern(numberFormat, x) {\n    var pl = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'pl');\n    var exponent = 0;\n    var ild = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'ild');\n    var n;\n    var formattedX = x;\n    if (isNaN(x)) {\n        n = ild.symbols.nan;\n    }\n    else if (!isFinite(x)) {\n        n = ild.symbols.infinity;\n    }\n    else {\n        if (getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'style') ===\n            'percent') {\n            formattedX *= 100;\n        }\n        exponent = computeExponent(numberFormat, formattedX);\n        formattedX /= Math.pow(10, exponent);\n        var formatNumberResult = formatNumberToString(numberFormat, formattedX);\n        n = formatNumberResult.formattedString;\n        formattedX = formatNumberResult.roundedNumber;\n    }\n    var pattern = getNumberFormatPattern(numberFormat, x, exponent);\n    var patternParts = partitionPattern(pattern);\n    var results = [];\n    // Unspec'ed stuff\n    // This is to deal w/ cases where {number} is in the middle of a unit pattern\n    var unitSymbolChunkIndex = 0;\n    var notation = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'notation');\n    for (var _i = 0, patternParts_1 = patternParts; _i < patternParts_1.length; _i++) {\n        var part = patternParts_1[_i];\n        switch (part.type) {\n            case 'literal':\n                results.push(part);\n                break;\n            case InternalSlotToken.number: {\n                if (isNaN(formattedX)) {\n                    results.push({ type: 'nan', value: n });\n                }\n                else if (formattedX === Infinity || x === -Infinity) {\n                    results.push({ type: 'infinity', value: n });\n                }\n                else {\n                    var _a = getMultiInternalSlots(__INTERNAL_SLOT_MAP__, numberFormat, 'numberingSystem', 'useGrouping', 'notation'), nu = _a.numberingSystem, useGrouping = _a.useGrouping;\n                    if (nu && nu in ILND) {\n                        // Replace digits\n                        var replacementTable = ILND[nu];\n                        var replacedDigits = '';\n                        for (var _b = 0, n_1 = n; _b < n_1.length; _b++) {\n                            var digit = n_1[_b];\n                            // digit can be `.` if it's fractional\n                            replacedDigits += replacementTable[+digit] || digit;\n                        }\n                        n = replacedDigits;\n                    }\n                    var decimalSepIndex = n.indexOf('.');\n                    var integer = void 0;\n                    var fraction = void 0;\n                    if (decimalSepIndex > 0) {\n                        integer = n.slice(0, decimalSepIndex);\n                        fraction = n.slice(decimalSepIndex + 1);\n                    }\n                    else {\n                        integer = n;\n                    }\n                    // For compact, default grouping strategy is min2\n                    if (useGrouping &&\n                        (notation === 'compact' ? integer.length > 4 : true)) {\n                        var groupSepSymbol = ild.symbols.group;\n                        var groups = [];\n                        // Assuming that the group separator is always inserted between every 3 digits.\n                        var i = integer.length - 3;\n                        for (; i > 0; i -= 3) {\n                            groups.push(integer.slice(i, i + 3));\n                        }\n                        groups.push(integer.slice(0, i + 3));\n                        while (groups.length > 0) {\n                            var integerGroup = groups.pop();\n                            results.push({ type: 'integer', value: integerGroup });\n                            if (groups.length > 0) {\n                                results.push({ type: 'group', value: groupSepSymbol });\n                            }\n                        }\n                    }\n                    else {\n                        results.push({ type: 'integer', value: integer });\n                    }\n                    if (fraction !== undefined) {\n                        results.push({ type: 'decimal', value: ild.symbols.decimal }, { type: 'fraction', value: fraction });\n                    }\n                }\n                break;\n            }\n            case InternalSlotToken.plusSign:\n                results.push({\n                    type: 'plusSign',\n                    value: ild.symbols.plusSign,\n                });\n                break;\n            case InternalSlotToken.minusSign:\n                results.push({\n                    type: 'minusSign',\n                    value: ild.symbols.minusSign,\n                });\n                break;\n            case InternalSlotToken.compactSymbol: {\n                var style = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'style');\n                var compactData = void 0;\n                if (style === 'currency') {\n                    compactData = ild.currency.compactShort;\n                }\n                else {\n                    compactData = ild.decimal.compactShort;\n                }\n                if (compactData) {\n                    results.push({\n                        type: 'compact',\n                        value: selectPlural(pl, x, compactData[String(Math.pow(10, exponent))]),\n                    });\n                }\n                break;\n            }\n            case InternalSlotToken.compactName: {\n                var style = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'style');\n                var currencyDisplay = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'currencyDisplay');\n                var compactData = void 0;\n                if (style === 'currency' && currencyDisplay !== 'name') {\n                    compactData = ild.currency.compactLong || ild.currency.compactShort;\n                }\n                else {\n                    compactData = ild.decimal.compactLong || ild.decimal.compactShort;\n                }\n                if (compactData) {\n                    results.push({\n                        type: 'compact',\n                        value: selectPlural(pl, x, compactData[String(Math.pow(10, exponent))]),\n                    });\n                }\n                break;\n            }\n            case InternalSlotToken.scientificSeparator:\n                results.push({\n                    type: 'exponentSeparator',\n                    value: ild.symbols.exponential,\n                });\n                break;\n            case InternalSlotToken.scientificExponent: {\n                if (exponent < 0) {\n                    results.push({\n                        type: 'exponentMinusSign',\n                        value: ild.symbols.minusSign,\n                    });\n                    exponent = -exponent;\n                }\n                var exponentResult = toRawFixed(exponent, 0, 0);\n                results.push({\n                    type: 'exponentInteger',\n                    value: exponentResult.formattedString,\n                });\n                break;\n            }\n            case InternalSlotToken.percentSign:\n                results.push({\n                    type: 'percentSign',\n                    value: ild.symbols.percentSign,\n                });\n                break;\n            case InternalSlotToken.unitSymbol:\n            case InternalSlotToken.unitNarrowSymbol:\n            case InternalSlotToken.unitName: {\n                var style = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'style');\n                if (style === 'unit') {\n                    var unit = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'unit');\n                    var unitSymbols = ild.unitSymbols[unit];\n                    var mu = selectPlural(pl, x, unitSymbols[part.type])[unitSymbolChunkIndex];\n                    results.push({ type: 'unit', value: mu });\n                    unitSymbolChunkIndex++;\n                }\n                break;\n            }\n            case InternalSlotToken.currencyCode: {\n                var currency = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'currency');\n                results.push({ type: 'currency', value: currency });\n                break;\n            }\n            case InternalSlotToken.currencySymbol: {\n                var currency = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'currency');\n                results.push({\n                    type: 'currency',\n                    value: ild.currencySymbols[currency].currencySymbol || currency,\n                });\n                break;\n            }\n            case InternalSlotToken.currencyNarrowSymbol: {\n                var currency = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'currency');\n                results.push({\n                    type: 'currency',\n                    value: ild.currencySymbols[currency].currencyNarrowSymbol || currency,\n                });\n                break;\n            }\n            case InternalSlotToken.currencyName: {\n                var currency = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'currency');\n                var cd = selectPlural(pl, x, ild.currencySymbols[currency].currencyName);\n                results.push({ type: 'currency', value: cd });\n                break;\n            }\n            default:\n                throw Error(\"unrecognized pattern part \\\"\" + part.type + \"\\\" in \\\"\" + pattern + \"\\\"\");\n        }\n    }\n    return results;\n}\nfunction formatNumericToParts(numberFormat, x) {\n    return partitionNumberPattern(numberFormat, x);\n}\nexport var UnifiedNumberFormat = function NumberFormat(locales, options) {\n    // Cannot use `new.target` bc of IE11 & TS transpiles it to something else\n    if (!this || !(this instanceof UnifiedNumberFormat)) {\n        return new UnifiedNumberFormat(locales, options);\n    }\n    initializeNumberFormat(this, locales, options);\n    var ildData = UnifiedNumberFormat.localeData[removeUnicodeExtensionFromLocale(getInternalSlot(__INTERNAL_SLOT_MAP__, this, 'locale'))];\n    setMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, {\n        pl: new Intl.PluralRules(locales, getMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, 'minimumFractionDigits', 'maximumFractionDigits', 'minimumIntegerDigits', 'minimumSignificantDigits', 'maximumSignificantDigits', 'roundingType', 'notation')),\n        patterns: new Patterns(ildData.units, ildData.currencies, ildData.numbers, getInternalSlot(__INTERNAL_SLOT_MAP__, this, 'numberingSystem'), getInternalSlot(__INTERNAL_SLOT_MAP__, this, 'unit'), getInternalSlot(__INTERNAL_SLOT_MAP__, this, 'currency'), getInternalSlot(__INTERNAL_SLOT_MAP__, this, 'currencySign')),\n    });\n};\n/*\n  17 ECMAScript Standard Built-in Objects:\n    Every built-in Function object, including constructors, that is not\n    identified as an anonymous function has a name property whose value\n    is a String.\n\n    Unless otherwise specified, the name property of a built-in Function\n    object, if it exists, has the attributes { [[Writable]]: false,\n    [[Enumerable]]: false, [[Configurable]]: true }.\n*/\nfunction defineProperty(target, name, _a) {\n    var value = _a.value;\n    Object.defineProperty(target, name, {\n        configurable: true,\n        enumerable: false,\n        writable: true,\n        value: value,\n    });\n}\ndefineProperty(UnifiedNumberFormat.prototype, 'formatToParts', {\n    value: function formatToParts(x) {\n        return formatNumericToParts(this, toNumeric(x));\n    },\n});\ndefineProperty(UnifiedNumberFormat.prototype, 'resolvedOptions', {\n    value: function resolvedOptions() {\n        var slots = getMultiInternalSlots.apply(void 0, __spreadArrays([__INTERNAL_SLOT_MAP__,\n            this], RESOLVED_OPTIONS_KEYS));\n        var ro = {};\n        for (var _i = 0, RESOLVED_OPTIONS_KEYS_1 = RESOLVED_OPTIONS_KEYS; _i < RESOLVED_OPTIONS_KEYS_1.length; _i++) {\n            var key = RESOLVED_OPTIONS_KEYS_1[_i];\n            var value = slots[key];\n            if (value !== undefined) {\n                ro[key] = value;\n            }\n        }\n        return ro;\n    },\n});\nvar formatDescriptor = {\n    enumerable: false,\n    configurable: true,\n    get: function () {\n        if (typeof this !== 'object' || !(this instanceof UnifiedNumberFormat)) {\n            throw TypeError('Intl.NumberFormat format property accessor called on imcompatible receiver');\n        }\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        var numberFormat = this;\n        var boundFormat = getInternalSlot(__INTERNAL_SLOT_MAP__, this, 'boundFormat');\n        if (boundFormat === undefined) {\n            // https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_diff_out.html#sec-number-format-functions\n            boundFormat = function (value) {\n                // TODO: check bigint\n                var x = toNumeric(value);\n                return numberFormat\n                    .formatToParts(x)\n                    .map(function (x) { return x.value; })\n                    .join('');\n            };\n            // https://github.com/tc39/test262/blob/master/test/intl402/NumberFormat/prototype/format/format-function-name.js\n            Object.defineProperty(boundFormat, 'name', {\n                configurable: true,\n                enumerable: false,\n                writable: false,\n                value: '',\n            });\n            setInternalSlot(__INTERNAL_SLOT_MAP__, this, 'boundFormat', boundFormat);\n        }\n        return boundFormat;\n    },\n};\n// https://github.com/tc39/test262/blob/master/test/intl402/NumberFormat/prototype/format/name.js\nObject.defineProperty(formatDescriptor.get, 'name', {\n    configurable: true,\n    enumerable: false,\n    writable: false,\n    value: 'get format',\n});\nObject.defineProperty(UnifiedNumberFormat.prototype, 'format', formatDescriptor);\n// Static properties\ndefineProperty(UnifiedNumberFormat, 'supportedLocalesOf', {\n    value: function supportedLocalesOf(locales, options) {\n        return supportedLocales(UnifiedNumberFormat.availableLocales, getCanonicalLocales(locales), options);\n    },\n});\nUnifiedNumberFormat.__addLocaleData = function __addLocaleData() {\n    var data = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        data[_i] = arguments[_i];\n    }\n    for (var _a = 0, data_1 = data; _a < data_1.length; _a++) {\n        var datum = data_1[_a];\n        var availableLocales = Object.keys(__spreadArrays(datum.availableLocales, Object.keys(datum.aliases), Object.keys(datum.parentLocales)).reduce(function (all, k) {\n            all[k] = true;\n            return all;\n        }, {}));\n        for (var _b = 0, availableLocales_1 = availableLocales; _b < availableLocales_1.length; _b++) {\n            var locale = availableLocales_1[_b];\n            try {\n                UnifiedNumberFormat.localeData[locale] = unpackData(locale, datum);\n            }\n            catch (e) {\n                // Ignore if we got no data\n            }\n        }\n    }\n    UnifiedNumberFormat.availableLocales = Object.keys(UnifiedNumberFormat.localeData);\n    if (!UnifiedNumberFormat.__defaultLocale) {\n        UnifiedNumberFormat.__defaultLocale =\n            UnifiedNumberFormat.availableLocales[0];\n    }\n};\nUnifiedNumberFormat.__defaultLocale = 'en';\nUnifiedNumberFormat.localeData = {};\nUnifiedNumberFormat.availableLocales = [];\nUnifiedNumberFormat.getDefaultLocale = function () {\n    return UnifiedNumberFormat.__defaultLocale;\n};\nUnifiedNumberFormat.polyfilled = true;\nfunction setNumberFormatUnitOptions(nf, options) {\n    if (options === void 0) { options = Object.create(null); }\n    // https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_proposed_out.html#sec-setnumberformatunitoptions\n    var style = getOption(options, 'style', 'string', ['decimal', 'percent', 'currency', 'unit'], 'decimal');\n    setInternalSlot(__INTERNAL_SLOT_MAP__, nf, 'style', style);\n    var currency = getOption(options, 'currency', 'string', undefined, undefined);\n    if (currency !== undefined && !isWellFormedCurrencyCode(currency)) {\n        throw RangeError('Malformed currency code');\n    }\n    var currencyDisplay = getOption(options, 'currencyDisplay', 'string', ['code', 'symbol', 'narrowSymbol', 'name'], 'symbol');\n    var currencySign = getOption(options, 'currencySign', 'string', ['standard', 'accounting'], 'standard');\n    var unit = getOption(options, 'unit', 'string', undefined, undefined);\n    if (unit !== undefined && !isWellFormedUnitIdentifier(unit)) {\n        throw RangeError('Invalid unit argument for Intl.NumberFormat()');\n    }\n    var unitDisplay = getOption(options, 'unitDisplay', 'string', ['short', 'narrow', 'long'], 'short');\n    if (style === 'currency') {\n        if (currency === undefined) {\n            throw new TypeError('currency cannot be undefined');\n        }\n        setMultiInternalSlots(__INTERNAL_SLOT_MAP__, nf, {\n            currency: currency.toUpperCase(),\n            currencyDisplay: currencyDisplay,\n            currencySign: currencySign,\n        });\n    }\n    else if (style === 'unit') {\n        if (unit === undefined) {\n            throw new TypeError('unit cannot be undefined');\n        }\n        setMultiInternalSlots(__INTERNAL_SLOT_MAP__, nf, {\n            unit: unit,\n            unitDisplay: unitDisplay,\n        });\n    }\n}\n// Taking the shortcut here and used the native NumberFormat for formatting numbers.\nfunction formatNumberToString(numberFormat, x) {\n    var isNegative = x < 0 || objectIs(x, -0);\n    if (isNegative) {\n        x = -x;\n    }\n    var _a = getMultiInternalSlots(__INTERNAL_SLOT_MAP__, numberFormat, 'roundingType', 'minimumFractionDigits', 'maximumFractionDigits', 'minimumIntegerDigits', 'minimumSignificantDigits', 'maximumSignificantDigits'), roundingType = _a.roundingType, minimumSignificantDigits = _a.minimumSignificantDigits, maximumSignificantDigits = _a.maximumSignificantDigits, minimumFractionDigits = _a.minimumFractionDigits, maximumFractionDigits = _a.maximumFractionDigits, minimumIntegerDigits = _a.minimumIntegerDigits;\n    var result;\n    if (roundingType === 'significantDigits') {\n        result = toRawPrecision(x, minimumSignificantDigits, maximumSignificantDigits);\n    }\n    else if (roundingType === 'fractionDigits') {\n        result = toRawFixed(x, minimumFractionDigits, maximumFractionDigits);\n    }\n    else {\n        invariant(roundingType === 'compactRounding', 'roundingType must be compactRounding');\n        result = toRawPrecision(x, 1, 2);\n        if (result.integerDigitsCount > 1) {\n            result = toRawFixed(x, 0, 0);\n        }\n    }\n    x = result.roundedNumber;\n    var string = result.formattedString;\n    var int = result.integerDigitsCount;\n    var minInteger = minimumIntegerDigits;\n    if (int < minInteger) {\n        var forwardZeros = repeat('0', minInteger - int);\n        string = forwardZeros + string;\n    }\n    if (isNegative) {\n        x = -x;\n    }\n    return { roundedNumber: x, formattedString: string };\n}\n/**\n * The abstract operation ComputeExponent computes an exponent (power of ten) by which to scale x\n * according to the number formatting settings. It handles cases such as 999 rounding up to 1000,\n * requiring a different exponent.\n */\nfunction computeExponent(numberFormat, x) {\n    if (x === 0) {\n        return 0;\n    }\n    if (x < 0) {\n        x = -x;\n    }\n    var magnitude = getMagnitude(x);\n    var exponent = computeExponentForMagnitude(numberFormat, magnitude);\n    x = x / Math.pow(10, exponent); // potential IEEE floating point error\n    var formatNumberResult = formatNumberToString(numberFormat, x);\n    if (formatNumberResult.roundedNumber === 0) {\n        return exponent;\n    }\n    var newMagnitude = getMagnitude(x);\n    if (newMagnitude === magnitude - exponent) {\n        return exponent;\n    }\n    return computeExponentForMagnitude(numberFormat, magnitude + 1);\n}\n/**\n * The abstract operation ComputeExponentForMagnitude computes an exponent by which to scale a\n * number of the given magnitude (power of ten of the most significant digit) according to the\n * locale and the desired notation (scientific, engineering, or compact).\n */\nfunction computeExponentForMagnitude(numberFormat, magnitude) {\n    var _a;\n    var notation = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'notation');\n    var style = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'style');\n    var ild = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'ild');\n    switch (notation) {\n        case 'standard':\n            return 0;\n        case 'scientific':\n            return magnitude;\n        case 'engineering':\n            return Math.floor(magnitude / 3) * 3;\n        case 'compact': {\n            var compactDisplay = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'compactDisplay');\n            var currencyDisplay = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'currencyDisplay');\n            var thresholdMap = void 0;\n            if (style === 'currency' && currencyDisplay !== 'name') {\n                thresholdMap =\n                    (compactDisplay === 'long'\n                        ? ild.currency.compactLong\n                        : ild.currency.compactShort) || ild.currency.compactShort;\n            }\n            else {\n                thresholdMap =\n                    compactDisplay === 'long'\n                        ? ild.decimal.compactLong\n                        : ild.decimal.compactShort;\n            }\n            if (!thresholdMap) {\n                return 0;\n            }\n            var num = String(Math.pow(10, magnitude));\n            var thresholds = Object.keys(thresholdMap); // TODO: this can be pre-processed\n            if (!((_a = thresholdMap[num]) === null || _a === void 0 ? void 0 : _a.other)) {\n                return 0;\n            }\n            if (num < thresholds[0]) {\n                return 0;\n            }\n            if (num > thresholds[thresholds.length - 1]) {\n                return getMagnitude(+thresholds[thresholds.length - 1]);\n            }\n            var i = thresholds.indexOf(num);\n            for (; i > 0 &&\n                thresholdMap[thresholds[i - 1]].other === thresholdMap[num].other; i--)\n                ;\n            return getMagnitude(+thresholds[i]);\n        }\n    }\n}\n/**\n * https://tc39.es/proposal-unified-intl-numberformat/section11/numberformat_proposed_out.html#sec-getnumberformatpattern\n *\n * The abstract operation GetNumberFormatPattern considers the resolved unit-related options in the\n * number format object along with the final scaled and rounded number being formatted and returns a\n * pattern, a String value as described in 1.3.3.\n */\nfunction getNumberFormatPattern(numberFormat, x, exponent) {\n    var _a = getMultiInternalSlots(__INTERNAL_SLOT_MAP__, numberFormat, 'style', 'patterns', 'signDisplay', 'notation'), style = _a.style, slots = _a.patterns;\n    var patterns;\n    switch (style) {\n        case 'percent':\n            patterns = slots.percent;\n            break;\n        case 'unit': {\n            var unitDisplay = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'unitDisplay');\n            var unit = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'unit');\n            patterns = slots.unit[unit][unitDisplay];\n            break;\n        }\n        case 'currency': {\n            var _b = getMultiInternalSlots(__INTERNAL_SLOT_MAP__, numberFormat, 'currency', 'currencyDisplay', 'currencySign'), currency = _b.currency, currencyDisplay = _b.currencyDisplay, currencySign = _b.currencySign;\n            patterns = slots.currency[currency][currencyDisplay][currencySign];\n            break;\n        }\n        case 'decimal':\n            patterns = slots.decimal;\n            break;\n    }\n    var notation = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'notation');\n    var signDisplay = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'signDisplay');\n    var signDisplayPattern = patterns[signDisplay];\n    var signPattern;\n    if (!isNaN(x) && isFinite(x)) {\n        if (notation === 'scientific' || notation === 'engineering') {\n            signPattern = signDisplayPattern.scientific;\n        }\n        else if (exponent !== 0) {\n            invariant(notation === 'compact', 'notation must be compact');\n            var compactDisplay = getInternalSlot(__INTERNAL_SLOT_MAP__, numberFormat, 'compactDisplay');\n            var decimalNum = String(Math.pow(10, exponent));\n            if (compactDisplay === 'short' && exponent > 2 && exponent < 15) {\n                signPattern = signDisplayPattern.compactShort[decimalNum];\n            }\n            else if (exponent > 2 && exponent < 15) {\n                invariant(compactDisplay === 'long', 'compactDisplay must be long');\n                signPattern = signDisplayPattern.compactLong[decimalNum];\n            }\n        }\n    }\n    if (!signPattern) {\n        signPattern = signDisplayPattern.standard;\n    }\n    var pattern;\n    if (signDisplay === 'never') {\n        pattern = signPattern.zeroPattern;\n    }\n    else if (signDisplay === 'auto') {\n        if (objectIs(x, 0) || x > 0 || isNaN(x)) {\n            pattern = signPattern.zeroPattern;\n        }\n        else {\n            pattern = signPattern.negativePattern;\n        }\n    }\n    else if (signDisplay === 'always') {\n        if (objectIs(x, 0) || x > 0 || isNaN(x)) {\n            pattern = signPattern.positivePattern;\n        }\n        else {\n            pattern = signPattern.negativePattern;\n        }\n    }\n    else {\n        invariant(signDisplay === 'exceptZero', 'signDisplay must be exceptZero');\n        if (objectIs(x, 0) || isNaN(x)) {\n            pattern = signPattern.zeroPattern;\n        }\n        else if (x > 0 || objectIs(x, +0)) {\n            pattern = signPattern.positivePattern;\n        }\n        else {\n            pattern = signPattern.negativePattern;\n        }\n    }\n    return pattern;\n}\nfunction selectPlural(pl, x, rules) {\n    return rules[pl.select(x)] || rules.other;\n}\nfunction toNumeric(val) {\n    if (typeof val === 'bigint') {\n        return val;\n    }\n    return toNumber(val);\n}\nfunction toNumber(val) {\n    if (val === undefined) {\n        return NaN;\n    }\n    if (val === null) {\n        return +0;\n    }\n    if (typeof val === 'boolean') {\n        return val ? 1 : +0;\n    }\n    if (typeof val === 'number') {\n        return val;\n    }\n    if (typeof val === 'symbol' || typeof val === 'bigint') {\n        throw new TypeError('Cannot convert symbol/bigint to number');\n    }\n    return Number(val);\n}\ntry {\n    // IE11 does not have Symbol\n    if (typeof Symbol !== 'undefined') {\n        Object.defineProperty(UnifiedNumberFormat.prototype, Symbol.toStringTag, {\n            configurable: true,\n            enumerable: false,\n            writable: false,\n            value: 'Object',\n        });\n    }\n    // https://github.com/tc39/test262/blob/master/test/intl402/NumberFormat/length.js\n    Object.defineProperty(UnifiedNumberFormat.prototype.constructor, 'length', {\n        configurable: true,\n        enumerable: false,\n        writable: false,\n        value: 0,\n    });\n    // https://github.com/tc39/test262/blob/master/test/intl402/NumberFormat/supportedLocalesOf/length.js\n    Object.defineProperty(UnifiedNumberFormat.supportedLocalesOf, 'length', {\n        configurable: true,\n        enumerable: false,\n        writable: false,\n        value: 1,\n    });\n    Object.defineProperty(UnifiedNumberFormat, 'prototype', {\n        configurable: false,\n        enumerable: false,\n        writable: false,\n        value: UnifiedNumberFormat.prototype,\n    });\n}\ncatch (e) {\n    // Meta fix so we're test262-compliant, not important\n}\n//# sourceMappingURL=core.js.map"],"names":["invariant","condition","message","Err","Error","toObject","arg","TypeError","Object","getOption","opts","prop","type","values","fallback","value","undefined","Boolean","o","String","toString","filter","val","length","RangeError","join","defaultNumberOption","min","max","Number","isNaN","Math","floor","setInternalSlot","map","pl","field","get","set","create","setMultiInternalSlots","props","_i","_a","keys","k","getInternalSlot","getMultiInternalSlots","fields","arguments","slots","reduce","all","f","setNumberFormatDigitOptions","internalSlotMap","intlObj","mnfdDefault","mxfdDefault","minimum","maximum","mnid","mnfd","minimumFractionDigits","mxfd","maximumFractionDigits","mnsd","minimumSignificantDigits","mxsd","maximumSignificantDigits","objectIs","x","y","is","NOT_A_Z_REGEX","isWellFormedCurrencyCode","currency","replace","_","c","toUpperCase","test","getCanonicalLocales","locales","Intl","DateTimeFormat","supportedLocalesOf","extendStatics","__extends","d","b","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__","this","constructor","prototype","__assign","assign","t","s","i","n","call","apply","createResolveLocale","getDefaultLocale","lookupMatcher","availableLocales","requestedLocales","result","locale","requestedLocales_1","noExtensionLocale","UNICODE_EXTENSION_SEQUENCE_REGEX","availableLocale","bestAvailableLocale","extension","slice","bestFitMatcher","requestedLocales_2","options","relevantExtensionKeys","localeData","privateIndex","r","localeMatcher","foundLocale","dataLocale","supportedExtension","relevantExtensionKeys_1","key","foundLocaleData","keyLocaleData","isArray","requestedValue","optionsValue","supportedExtensionAddition","unicodeExtensionValue","indexOf","size","searchValue","pos","start","end","done","e","candidate","lastIndexOf","lookupSupportedLocales","subset","requestedLocales_3","push","_super","MissingLocaleDataError","_this","unpackData","reducer","localeHierarchy","aliases","parentLocales","results","parentLocale","localeParts","split","getLocaleHierarchy","dataToMerge","l","data","reverse","InternalSlotToken","getMagnitude","log","LOG10E","toRawFixed","minFraction","maxFraction","idx1","idx2","exponent","m","int","a","exactSolve","pow","roundDown","roundUp","ceil","xFinal","parseInt","substring","repeat","cut","formattedString","roundedNumber","integerDigitsCount","toRawPrecision","minPrecision","maxPrecision","magnitude","times","arr","S_UNICODE_REGEX","CURRENCY_SYMBOL_REGEX","UNIT_1_REGEX","UNIT_0_REGEX","extractDecimalFormatILD","num","pattern","trim","other","extractLDMLPluralRuleMap","rule","serializeSlotTokens","tokens","NUMBER_PATTERN","SCIENTIFIC_POSITIVE_PATTERN","number","scientificSeparator","scientificExponent","SCIENTIFIC_NEGATIVE_PATTERN","minusSign","DUMMY_POSITIVE_PATTERN","DUMMY_NEGATIVE_PATTERN","DUMMY_PATTERN","SCIENTIFIC_PATTERN","processDecimalCompactSymbol","slotToken","compactSymbol","compactUnit","negativePattern","processCurrencyCompactSymbol","INSERT_BEFORE_PATTERN_REGEX","INSERT_AFTER_PATTERN_REGEX","insertBetween","insertBetweenChar","Patterns","defineProperty","decimalPatterns","DecimalPatterns","numbers","numberingSystem","enumerable","configurable","percentPatterns","PercentPatterns","unitPatterns","_unit","UnitPatterns","units","currencyPatterns","_currency","currencySign","CurrencyPatterns","currencies","unit","produceSignPattern","patterns","signDisplay","positivePattern","noSignPattern","alwaysPositivePattern","plusSign","zeroPattern","NotationPatterns","notation","produceCompactSignPattern","decimalNum","compactSignPattern","signPattern","decimal","long","compactName","short","generateStandardOrScientificPattern","isScientific","percent","percentSign","compactPattern","compactSignPatterns","narrow","unitNarrowSymbol","unitSymbol","unitName","resolvePatternForCurrencyCode","resolvedCurrency","shortPattern","longPattern","standard","currencySpacing","beforeInsertBetween","accounting","resolvePatternForCurrencyName","numberPattern","unitPattern","currencyName","currencySlotToken","currencyCode","currencySymbol","symbol","currencyNarrowSymbol","displayName","signDisplayPatterns","CurrencySignDisplayPatterns","fn","__spreadArrays","il","j","jl","VALID_NUMBERING_SYSTEM_NAMES","numberingSystemNames_1","RESOLVED_OPTIONS_KEYS","SHORTENED_SACTION_UNITS","isWellFormedUnitIdentifier","toLowerCase","removeUnicodeExtensionFromLocale","canonicalLocale","extensionIndex","__INTERNAL_SLOT_MAP__","WeakMap","initializeNumberFormat","nf","opt","matcher","nu","UnifiedNumberFormat","ildData","ild","compactShort","compactLong","symbols","currencySymbols","code","unitSymbols","style","currencyDisplay","unitDisplay","setNumberFormatUnitOptions","currencyDigitsData","compactDisplay","useGrouping","partitionNumberPattern","numberFormat","formatNumberResult","formattedX","nan","isFinite","computeExponentForMagnitude","formatNumberToString","computeExponent","infinity","_b","signDisplayPattern","scientific","getNumberFormatPattern","patternParts","beginIndex","endIndex","nextIndex","partitionPattern","unitSymbolChunkIndex","patternParts_1","mu","part","Infinity","ILND","replacementTable","replacedDigits","n_1","digit","decimalSepIndex","integer","fraction","groupSepSymbol","group","groups","integerGroup","pop","compactData","selectPlural","exponential","exponentResult","cd","PluralRules","target","name","writable","toNumeric","ro","RESOLVED_OPTIONS_KEYS_1","formatDescriptor","boundFormat","formatToParts","isNegative","roundingType","minimumIntegerDigits","string","thresholdMap","thresholds","rules","select","NaN","toNumber","__addLocaleData","data_1","datum","availableLocales_1","__defaultLocale","polyfilled","Symbol","toStringTag","NumberFormat"],"mappings":"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"}