Mini Kabibi Habibi

Current Path : C:/Program Files/Adobe/Adobe Photoshop 2025/Required/UXP/com.adobe.ccx.start/js/
Upload File :
Current File : C:/Program Files/Adobe/Adobe Photoshop 2025/Required/UXP/com.adobe.ccx.start/js/8534.js.map

{"version":3,"file":"8534.js","mappings":"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","sources":["webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/CanonicalizeLocaleList.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/CanonicalizeTimeZoneName.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/262.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/CoerceOptionsToObject.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/DefaultNumberOption.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/GetNumberOption.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/GetOption.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/GetOptionsObject.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/GetStringOrBooleanOption.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/IsSanctionedSimpleUnitIdentifier.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/IsValidTimeZoneName.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/IsWellFormedCurrencyCode.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/IsWellFormedUnitIdentifier.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/ApplyUnsignedRoundingMode.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/CollapseNumberRange.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/ComputeExponentForMagnitude.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/ToRawPrecision.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/ToRawFixed.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/FormatNumericToString.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/ComputeExponent.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/CurrencyDigits.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/FormatApproximately.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/digit-mapping.generated.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/regex.generated.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/format_to_parts.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/PartitionNumberPattern.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/PartitionNumberRangePattern.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/FormatNumericRange.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/FormatNumericRangeToParts.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/FormatNumericToParts.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/GetUnsignedRoundingMode.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/SetNumberFormatUnitOptions.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/SetNumberFormatDigitOptions.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/NumberFormat/InitializeNumberFormat.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/PartitionPattern.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/SupportedLocales.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/types/date-time.js","webpack://UniversalAssetBrowser/../../node_modules/@formatjs/ecma402-abstract/lib/data.js"],"sourcesContent":["/**\n * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist\n * @param locales\n */\nexport function CanonicalizeLocaleList(locales) {\n    // TODO\n    return Intl.getCanonicalLocales(locales);\n}\n","/**\n * https://tc39.es/ecma402/#sec-canonicalizetimezonename\n * @param tz\n */\nexport function CanonicalizeTimeZoneName(tz, _a) {\n    var tzData = _a.tzData, uppercaseLinks = _a.uppercaseLinks;\n    var uppercasedTz = tz.toUpperCase();\n    var uppercasedZones = Object.keys(tzData).reduce(function (all, z) {\n        all[z.toUpperCase()] = z;\n        return all;\n    }, {});\n    var ianaTimeZone = uppercaseLinks[uppercasedTz] || uppercasedZones[uppercasedTz];\n    if (ianaTimeZone === 'Etc/UTC' || ianaTimeZone === 'Etc/GMT') {\n        return 'UTC';\n    }\n    return ianaTimeZone;\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/ecma262/#sec-tonumber\n * @param val\n */\nexport function 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}\n/**\n * https://tc39.es/ecma262/#sec-tointeger\n * @param n\n */\nfunction ToInteger(n) {\n    var number = ToNumber(n);\n    if (isNaN(number) || SameValue(number, -0)) {\n        return 0;\n    }\n    if (isFinite(number)) {\n        return number;\n    }\n    var integer = Math.floor(Math.abs(number));\n    if (number < 0) {\n        integer = -integer;\n    }\n    if (SameValue(integer, -0)) {\n        return 0;\n    }\n    return integer;\n}\n/**\n * https://tc39.es/ecma262/#sec-timeclip\n * @param time\n */\nexport function TimeClip(time) {\n    if (!isFinite(time)) {\n        return NaN;\n    }\n    if (Math.abs(time) > 8.64 * 1e15) {\n        return NaN;\n    }\n    return ToInteger(time);\n}\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://www.ecma-international.org/ecma-262/11.0/index.html#sec-samevalue\n * @param x\n * @param y\n */\nexport function SameValue(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}\n/**\n * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-arraycreate\n * @param len\n */\nexport function ArrayCreate(len) {\n    return new Array(len);\n}\n/**\n * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-hasownproperty\n * @param o\n * @param prop\n */\nexport function HasOwnProperty(o, prop) {\n    return Object.prototype.hasOwnProperty.call(o, prop);\n}\n/**\n * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-type\n * @param x\n */\nexport function Type(x) {\n    if (x === null) {\n        return 'Null';\n    }\n    if (typeof x === 'undefined') {\n        return 'Undefined';\n    }\n    if (typeof x === 'function' || typeof x === 'object') {\n        return 'Object';\n    }\n    if (typeof x === 'number') {\n        return 'Number';\n    }\n    if (typeof x === 'boolean') {\n        return 'Boolean';\n    }\n    if (typeof x === 'string') {\n        return 'String';\n    }\n    if (typeof x === 'symbol') {\n        return 'Symbol';\n    }\n    if (typeof x === 'bigint') {\n        return 'BigInt';\n    }\n}\nvar MS_PER_DAY = 86400000;\n/**\n * https://www.ecma-international.org/ecma-262/11.0/index.html#eqn-modulo\n * @param x\n * @param y\n * @return k of the same sign as y\n */\nfunction mod(x, y) {\n    return x - Math.floor(x / y) * y;\n}\n/**\n * https://tc39.es/ecma262/#eqn-Day\n * @param t\n */\nexport function Day(t) {\n    return Math.floor(t / MS_PER_DAY);\n}\n/**\n * https://tc39.es/ecma262/#sec-week-day\n * @param t\n */\nexport function WeekDay(t) {\n    return mod(Day(t) + 4, 7);\n}\n/**\n * https://tc39.es/ecma262/#sec-year-number\n * @param y\n */\nexport function DayFromYear(y) {\n    return Date.UTC(y, 0) / MS_PER_DAY;\n}\n/**\n * https://tc39.es/ecma262/#sec-year-number\n * @param y\n */\nexport function TimeFromYear(y) {\n    return Date.UTC(y, 0);\n}\n/**\n * https://tc39.es/ecma262/#sec-year-number\n * @param t\n */\nexport function YearFromTime(t) {\n    return new Date(t).getUTCFullYear();\n}\nexport function DaysInYear(y) {\n    if (y % 4 !== 0) {\n        return 365;\n    }\n    if (y % 100 !== 0) {\n        return 366;\n    }\n    if (y % 400 !== 0) {\n        return 365;\n    }\n    return 366;\n}\nexport function DayWithinYear(t) {\n    return Day(t) - DayFromYear(YearFromTime(t));\n}\nexport function InLeapYear(t) {\n    return DaysInYear(YearFromTime(t)) === 365 ? 0 : 1;\n}\n/**\n * https://tc39.es/ecma262/#sec-month-number\n * @param t\n */\nexport function MonthFromTime(t) {\n    var dwy = DayWithinYear(t);\n    var leap = InLeapYear(t);\n    if (dwy >= 0 && dwy < 31) {\n        return 0;\n    }\n    if (dwy < 59 + leap) {\n        return 1;\n    }\n    if (dwy < 90 + leap) {\n        return 2;\n    }\n    if (dwy < 120 + leap) {\n        return 3;\n    }\n    if (dwy < 151 + leap) {\n        return 4;\n    }\n    if (dwy < 181 + leap) {\n        return 5;\n    }\n    if (dwy < 212 + leap) {\n        return 6;\n    }\n    if (dwy < 243 + leap) {\n        return 7;\n    }\n    if (dwy < 273 + leap) {\n        return 8;\n    }\n    if (dwy < 304 + leap) {\n        return 9;\n    }\n    if (dwy < 334 + leap) {\n        return 10;\n    }\n    if (dwy < 365 + leap) {\n        return 11;\n    }\n    throw new Error('Invalid time');\n}\nexport function DateFromTime(t) {\n    var dwy = DayWithinYear(t);\n    var mft = MonthFromTime(t);\n    var leap = InLeapYear(t);\n    if (mft === 0) {\n        return dwy + 1;\n    }\n    if (mft === 1) {\n        return dwy - 30;\n    }\n    if (mft === 2) {\n        return dwy - 58 - leap;\n    }\n    if (mft === 3) {\n        return dwy - 89 - leap;\n    }\n    if (mft === 4) {\n        return dwy - 119 - leap;\n    }\n    if (mft === 5) {\n        return dwy - 150 - leap;\n    }\n    if (mft === 6) {\n        return dwy - 180 - leap;\n    }\n    if (mft === 7) {\n        return dwy - 211 - leap;\n    }\n    if (mft === 8) {\n        return dwy - 242 - leap;\n    }\n    if (mft === 9) {\n        return dwy - 272 - leap;\n    }\n    if (mft === 10) {\n        return dwy - 303 - leap;\n    }\n    if (mft === 11) {\n        return dwy - 333 - leap;\n    }\n    throw new Error('Invalid time');\n}\nvar HOURS_PER_DAY = 24;\nvar MINUTES_PER_HOUR = 60;\nvar SECONDS_PER_MINUTE = 60;\nvar MS_PER_SECOND = 1e3;\nvar MS_PER_MINUTE = MS_PER_SECOND * SECONDS_PER_MINUTE;\nvar MS_PER_HOUR = MS_PER_MINUTE * MINUTES_PER_HOUR;\nexport function HourFromTime(t) {\n    return mod(Math.floor(t / MS_PER_HOUR), HOURS_PER_DAY);\n}\nexport function MinFromTime(t) {\n    return mod(Math.floor(t / MS_PER_MINUTE), MINUTES_PER_HOUR);\n}\nexport function SecFromTime(t) {\n    return mod(Math.floor(t / MS_PER_SECOND), SECONDS_PER_MINUTE);\n}\nfunction IsCallable(fn) {\n    return typeof fn === 'function';\n}\n/**\n * The abstract operation OrdinaryHasInstance implements\n * the default algorithm for determining if an object O\n * inherits from the instance object inheritance path\n * provided by constructor C.\n * @param C class\n * @param O object\n * @param internalSlots internalSlots\n */\nexport function OrdinaryHasInstance(C, O, internalSlots) {\n    if (!IsCallable(C)) {\n        return false;\n    }\n    if (internalSlots === null || internalSlots === void 0 ? void 0 : internalSlots.boundTargetFunction) {\n        var BC = internalSlots === null || internalSlots === void 0 ? void 0 : internalSlots.boundTargetFunction;\n        return O instanceof BC;\n    }\n    if (typeof O !== 'object') {\n        return false;\n    }\n    var P = C.prototype;\n    if (typeof P !== 'object') {\n        throw new TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.');\n    }\n    return Object.prototype.isPrototypeOf.call(P, O);\n}\nexport function msFromTime(t) {\n    return mod(t, MS_PER_SECOND);\n}\n","import { ToObject } from './262';\n/**\n * https://tc39.es/ecma402/#sec-coerceoptionstoobject\n * @param options\n * @returns\n */\nexport function CoerceOptionsToObject(options) {\n    if (typeof options === 'undefined') {\n        return Object.create(null);\n    }\n    return ToObject(options);\n}\n","export 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(\"\".concat(val, \" is outside of range [\").concat(min, \", \").concat(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 */\nimport { DefaultNumberOption } from './DefaultNumberOption';\nexport function GetNumberOption(options, property, minimum, maximum, fallback) {\n    var val = options[property];\n    // @ts-expect-error\n    return DefaultNumberOption(val, minimum, maximum, fallback);\n}\n","import { ToString } from './262';\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    if (typeof opts !== 'object') {\n        throw new TypeError('Options must be an object');\n    }\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(\"\".concat(value, \" is not within \").concat(values.join(', ')));\n        }\n        return value;\n    }\n    return fallback;\n}\n","/**\n * https://tc39.es/ecma402/#sec-getoptionsobject\n * @param options\n * @returns\n */\nexport function GetOptionsObject(options) {\n    if (typeof options === 'undefined') {\n        return Object.create(null);\n    }\n    if (typeof options === 'object') {\n        return options;\n    }\n    throw new TypeError('Options must be an object');\n}\n","/**\n * https://tc39.es/ecma402/#sec-getstringorbooleanoption\n * @param opts\n * @param prop\n * @param values\n * @param trueValue\n * @param falsyValue\n * @param fallback\n */\nimport { ToString } from './262';\nexport function GetStringOrBooleanOption(opts, prop, values, trueValue, falsyValue, fallback) {\n    var value = opts[prop];\n    if (value === undefined) {\n        return fallback;\n    }\n    if (value === true) {\n        return trueValue;\n    }\n    var valueBoolean = Boolean(value);\n    if (valueBoolean === false) {\n        return falsyValue;\n    }\n    value = ToString(value);\n    if (value === 'true' || value === 'false') {\n        return fallback;\n    }\n    if ((values || []).indexOf(value) === -1) {\n        throw new RangeError(\"Invalid value \".concat(value));\n    }\n    return value;\n}\n","/**\n * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers\n */\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.slice(unit.indexOf('-') + 1);\n}\n/**\n * https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers\n */\nexport var SIMPLE_UNITS = SANCTIONED_UNITS.map(removeUnitNamespace);\n/**\n * https://tc39.es/ecma402/#sec-issanctionedsimpleunitidentifier\n */\nexport function IsSanctionedSimpleUnitIdentifier(unitIdentifier) {\n    return SIMPLE_UNITS.indexOf(unitIdentifier) > -1;\n}\n","/**\n * https://tc39.es/ecma402/#sec-isvalidtimezonename\n * @param tz\n * @param implDetails implementation details\n */\nexport function IsValidTimeZoneName(tz, _a) {\n    var tzData = _a.tzData, uppercaseLinks = _a.uppercaseLinks;\n    var uppercasedTz = tz.toUpperCase();\n    var zoneNames = new Set();\n    var linkNames = new Set();\n    Object.keys(tzData)\n        .map(function (z) { return z.toUpperCase(); })\n        .forEach(function (z) { return zoneNames.add(z); });\n    Object.keys(uppercaseLinks).forEach(function (linkName) {\n        linkNames.add(linkName.toUpperCase());\n        zoneNames.add(uppercaseLinks[linkName].toUpperCase());\n    });\n    return zoneNames.has(uppercasedTz) || linkNames.has(uppercasedTz);\n}\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}\nvar NOT_A_Z_REGEX = /[^A-Z]/;\n/**\n * https://tc39.es/ecma402/#sec-iswellformedcurrencycode\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","import { IsSanctionedSimpleUnitIdentifier } from './IsSanctionedSimpleUnitIdentifier';\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/ecma402/#sec-iswellformedunitidentifier\n * @param unit\n */\nexport function IsWellFormedUnitIdentifier(unit) {\n    unit = toLowerCase(unit);\n    if (IsSanctionedSimpleUnitIdentifier(unit)) {\n        return true;\n    }\n    var units = unit.split('-per-');\n    if (units.length !== 2) {\n        return false;\n    }\n    var numerator = units[0], denominator = units[1];\n    if (!IsSanctionedSimpleUnitIdentifier(numerator) ||\n        !IsSanctionedSimpleUnitIdentifier(denominator)) {\n        return false;\n    }\n    return true;\n}\n","export function ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode) {\n    if (x === r1)\n        return r1;\n    if (unsignedRoundingMode === undefined) {\n        throw new Error('unsignedRoundingMode is mandatory');\n    }\n    if (unsignedRoundingMode === 'zero') {\n        return r1;\n    }\n    if (unsignedRoundingMode === 'infinity') {\n        return r2;\n    }\n    var d1 = x - r1;\n    var d2 = r2 - x;\n    if (d1 < d2) {\n        return r1;\n    }\n    if (d2 < d1) {\n        return r2;\n    }\n    if (d1 !== d2) {\n        throw new Error('Unexpected error');\n    }\n    if (unsignedRoundingMode === 'half-zero') {\n        return r1;\n    }\n    if (unsignedRoundingMode === 'half-infinity') {\n        return r2;\n    }\n    if (unsignedRoundingMode !== 'half-even') {\n        throw new Error(\"Unexpected value for unsignedRoundingMode: \".concat(unsignedRoundingMode));\n    }\n    var cardinality = (r1 / (r2 - r1)) % 2;\n    if (cardinality === 0) {\n        return r1;\n    }\n    return r2;\n}\n","/**\n * https://tc39.es/ecma402/#sec-collapsenumberrange\n */\nexport function CollapseNumberRange(result) {\n    return result;\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 */\nexport function ComputeExponentForMagnitude(numberFormat, magnitude, _a) {\n    var getInternalSlots = _a.getInternalSlots;\n    var internalSlots = getInternalSlots(numberFormat);\n    var notation = internalSlots.notation, dataLocaleData = internalSlots.dataLocaleData, numberingSystem = internalSlots.numberingSystem;\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        default: {\n            // Let exponent be an implementation- and locale-dependent (ILD) integer by which to scale a\n            // number of the given magnitude in compact notation for the current locale.\n            var compactDisplay = internalSlots.compactDisplay, style = internalSlots.style, currencyDisplay = internalSlots.currencyDisplay;\n            var thresholdMap = void 0;\n            if (style === 'currency' && currencyDisplay !== 'name') {\n                var currency = dataLocaleData.numbers.currency[numberingSystem] ||\n                    dataLocaleData.numbers.currency[dataLocaleData.numbers.nu[0]];\n                thresholdMap = currency.short;\n            }\n            else {\n                var decimal = dataLocaleData.numbers.decimal[numberingSystem] ||\n                    dataLocaleData.numbers.decimal[dataLocaleData.numbers.nu[0]];\n                thresholdMap = compactDisplay === 'long' ? decimal.long : decimal.short;\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 (num < thresholds[0]) {\n                return 0;\n            }\n            if (num > thresholds[thresholds.length - 1]) {\n                return thresholds[thresholds.length - 1].length - 1;\n            }\n            var i = thresholds.indexOf(num);\n            if (i === -1) {\n                return 0;\n            }\n            // See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats\n            // Special handling if the pattern is precisely `0`.\n            var magnitudeKey = thresholds[i];\n            // TODO: do we need to handle plural here?\n            var compactPattern = thresholdMap[magnitudeKey].other;\n            if (compactPattern === '0') {\n                return 0;\n            }\n            // Example: in zh-TW, `10000000` maps to `0000萬`. So we need to return 8 - 4 = 4 here.\n            return (magnitudeKey.length -\n                thresholdMap[magnitudeKey].other.match(/0+/)[0].length);\n        }\n    }\n}\n","import { repeat, getMagnitude } from '../utils';\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        var xToString = x.toString();\n        // If xToString is formatted as scientific notation, the number is either very small or very\n        // large. If the precision of the formatted string is lower that requested max precision, we\n        // should still infer them from the formatted string, otherwise the formatted result might have\n        // precision loss (e.g. 1e41 will not have 0 in every trailing digits).\n        var xToStringExponentIndex = xToString.indexOf('e');\n        var _a = xToString.split('e'), xToStringMantissa = _a[0], xToStringExponent = _a[1];\n        var xToStringMantissaWithoutDecimalPoint = xToStringMantissa.replace('.', '');\n        if (xToStringExponentIndex >= 0 &&\n            xToStringMantissaWithoutDecimalPoint.length <= p) {\n            e = +xToStringExponent;\n            m =\n                xToStringMantissaWithoutDecimalPoint +\n                    repeat('0', p - xToStringMantissaWithoutDecimalPoint.length);\n            xFinal = x;\n        }\n        else {\n            e = getMagnitude(x);\n            var decimalPlaceOffset = e - p + 1;\n            // n is the integer containing the required precision digits. To derive the formatted string,\n            // we will adjust its decimal place in the logic below.\n            var n = Math.round(adjustDecimalPlace(x, decimalPlaceOffset));\n            // The rounding caused the change of magnitude, so we should increment `e` by 1.\n            if (adjustDecimalPlace(n, p - 1) >= 10) {\n                e = e + 1;\n                // Divide n by 10 to swallow one precision.\n                n = Math.floor(n / 10);\n            }\n            m = n.toString();\n            // Equivalent of n * 10 ** (e - p + 1)\n            xFinal = adjustDecimalPlace(n, p - 1 - e);\n        }\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 = \"\".concat(m.slice(0, e + 1), \".\").concat(m.slice(e + 1));\n        int = e + 1;\n    }\n    else {\n        m = \"0.\".concat(repeat('0', -e - 1)).concat(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    // x / (10 ** magnitude), but try to preserve as much floating point precision as possible.\n    function adjustDecimalPlace(x, magnitude) {\n        return magnitude < 0 ? x * Math.pow(10, -magnitude) : x / Math.pow(10, magnitude);\n    }\n}\n","import { repeat } from '../utils';\n/**\n * TODO: dedup with intl-pluralrules and support BigInt\n * https://tc39.es/ecma402/#sec-torawfixed\n * @param x a finite non-negative Number or BigInt\n * @param minFraction and integer between 0 and 20\n * @param maxFraction and integer between 0 and 20\n */\nexport function ToRawFixed(x, minFraction, maxFraction) {\n    var f = maxFraction;\n    var n = Math.round(x * Math.pow(10, f));\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 _a = m.split('e'), mantissa = _a[0], exponent = _a[1];\n        m = mantissa.replace('.', '');\n        m = m + repeat('0', Math.max(+exponent - m.length + 1, 0));\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 = \"\".concat(a, \".\").concat(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","import { SameValue } from '../262';\nimport { ToRawPrecision } from './ToRawPrecision';\nimport { repeat } from '../utils';\nimport { ToRawFixed } from './ToRawFixed';\n/**\n * https://tc39.es/ecma402/#sec-formatnumberstring\n */\nexport function FormatNumericToString(intlObject, x) {\n    var isNegative = x < 0 || SameValue(x, -0);\n    if (isNegative) {\n        x = -x;\n    }\n    var result;\n    var rourndingType = intlObject.roundingType;\n    switch (rourndingType) {\n        case 'significantDigits':\n            result = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits);\n            break;\n        case 'fractionDigits':\n            result = ToRawFixed(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits);\n            break;\n        default:\n            result = ToRawPrecision(x, 1, 2);\n            if (result.integerDigitsCount > 1) {\n                result = ToRawFixed(x, 0, 0);\n            }\n            break;\n    }\n    x = result.roundedNumber;\n    var string = result.formattedString;\n    var int = result.integerDigitsCount;\n    var minInteger = intlObject.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","import { getMagnitude } from '../utils';\nimport { ComputeExponentForMagnitude } from './ComputeExponentForMagnitude';\nimport { FormatNumericToString } from './FormatNumericToString';\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 *\n * NOT IN SPEC: it returns [exponent, magnitude].\n */\nexport function ComputeExponent(numberFormat, x, _a) {\n    var getInternalSlots = _a.getInternalSlots;\n    if (x === 0) {\n        return [0, 0];\n    }\n    if (x < 0) {\n        x = -x;\n    }\n    var magnitude = getMagnitude(x);\n    var exponent = ComputeExponentForMagnitude(numberFormat, magnitude, {\n        getInternalSlots: getInternalSlots,\n    });\n    // Preserve more precision by doing multiplication when exponent is negative.\n    x = exponent < 0 ? x * Math.pow(10, -exponent) : x / Math.pow(10, exponent);\n    var formatNumberResult = FormatNumericToString(getInternalSlots(numberFormat), x);\n    if (formatNumberResult.roundedNumber === 0) {\n        return [exponent, magnitude];\n    }\n    var newMagnitude = getMagnitude(formatNumberResult.roundedNumber);\n    if (newMagnitude === magnitude - exponent) {\n        return [exponent, magnitude];\n    }\n    return [\n        ComputeExponentForMagnitude(numberFormat, magnitude + 1, {\n            getInternalSlots: getInternalSlots,\n        }),\n        magnitude + 1,\n    ];\n}\n","import { HasOwnProperty } from '../262';\n/**\n * https://tc39.es/ecma402/#sec-currencydigits\n */\nexport function CurrencyDigits(c, _a) {\n    var currencyDigitsData = _a.currencyDigitsData;\n    return HasOwnProperty(currencyDigitsData, c)\n        ? currencyDigitsData[c]\n        : 2;\n}\n","/**\n * https://tc39.es/ecma402/#sec-formatapproximately\n */\nexport function FormatApproximately(numberFormat, result, _a) {\n    var getInternalSlots = _a.getInternalSlots;\n    var internalSlots = getInternalSlots(numberFormat);\n    var symbols = internalSlots.dataLocaleData.numbers.symbols[internalSlots.numberingSystem];\n    var approximatelySign = symbols.approximatelySign;\n    result.push({ type: 'approximatelySign', value: approximatelySign });\n    return result;\n}\n","export var digitMapping = {\n    \"adlm\": [\n        \"šž„\",\n        \"šž„‘\",\n        \"šž„’\",\n        \"šž„“\",\n        \"šž„”\",\n        \"šž„•\",\n        \"šž„–\",\n        \"šž„—\",\n        \"šž„˜\",\n        \"šž„™\"\n    ],\n    \"ahom\": [\n        \"š‘œ°\",\n        \"š‘œ±\",\n        \"š‘œ²\",\n        \"š‘œ³\",\n        \"š‘œ“\",\n        \"š‘œµ\",\n        \"š‘œ¶\",\n        \"š‘œ·\",\n        \"š‘œø\",\n        \"š‘œ¹\"\n    ],\n    \"arab\": [\n        \"Ł \",\n        \"Ł”\",\n        \"Ł¢\",\n        \"Ł£\",\n        \"Ł¤\",\n        \"Ł„\",\n        \"Ł¦\",\n        \"Ł§\",\n        \"ŁØ\",\n        \"Ł©\"\n    ],\n    \"arabext\": [\n        \"Ū°\",\n        \"Ū±\",\n        \"Ū²\",\n        \"Ū³\",\n        \"Ū“\",\n        \"Ūµ\",\n        \"Ū¶\",\n        \"Ū·\",\n        \"Ūø\",\n        \"Ū¹\"\n    ],\n    \"bali\": [\n        \"į­\",\n        \"į­‘\",\n        \"į­’\",\n        \"į­“\",\n        \"į­”\",\n        \"į­•\",\n        \"į­–\",\n        \"į­—\",\n        \"į­˜\",\n        \"į­™\"\n    ],\n    \"beng\": [\n        \"ą§¦\",\n        \"ą§§\",\n        \"ą§Ø\",\n        \"ą§©\",\n        \"ą§Ŗ\",\n        \"ą§«\",\n        \"ą§¬\",\n        \"ą§­\",\n        \"ą§®\",\n        \"ą§Æ\"\n    ],\n    \"bhks\": [\n        \"š‘±\",\n        \"š‘±‘\",\n        \"š‘±’\",\n        \"š‘±“\",\n        \"š‘±”\",\n        \"š‘±•\",\n        \"š‘±–\",\n        \"š‘±—\",\n        \"š‘±˜\",\n        \"š‘±™\"\n    ],\n    \"brah\": [\n        \"š‘¦\",\n        \"š‘§\",\n        \"š‘Ø\",\n        \"š‘©\",\n        \"š‘Ŗ\",\n        \"š‘«\",\n        \"š‘¬\",\n        \"š‘­\",\n        \"š‘®\",\n        \"š‘Æ\"\n    ],\n    \"cakm\": [\n        \"š‘„¶\",\n        \"š‘„·\",\n        \"š‘„ø\",\n        \"š‘„¹\",\n        \"š‘„ŗ\",\n        \"š‘„»\",\n        \"š‘„¼\",\n        \"š‘„½\",\n        \"š‘„¾\",\n        \"š‘„æ\"\n    ],\n    \"cham\": [\n        \"ź©\",\n        \"ź©‘\",\n        \"ź©’\",\n        \"ź©“\",\n        \"ź©”\",\n        \"ź©•\",\n        \"ź©–\",\n        \"ź©—\",\n        \"ź©˜\",\n        \"ź©™\"\n    ],\n    \"deva\": [\n        \"ą„¦\",\n        \"ą„§\",\n        \"ą„Ø\",\n        \"ą„©\",\n        \"ą„Ŗ\",\n        \"ą„«\",\n        \"ą„¬\",\n        \"ą„­\",\n        \"ą„®\",\n        \"ą„Æ\"\n    ],\n    \"diak\": [\n        \"š‘„\",\n        \"š‘„‘\",\n        \"š‘„’\",\n        \"š‘„“\",\n        \"š‘„”\",\n        \"š‘„•\",\n        \"š‘„–\",\n        \"š‘„—\",\n        \"š‘„˜\",\n        \"š‘„™\"\n    ],\n    \"fullwide\": [\n        \"ļ¼\",\n        \"ļ¼‘\",\n        \"ļ¼’\",\n        \"ļ¼“\",\n        \"ļ¼”\",\n        \"ļ¼•\",\n        \"ļ¼–\",\n        \"ļ¼—\",\n        \"ļ¼˜\",\n        \"ļ¼™\"\n    ],\n    \"gong\": [\n        \"š‘¶ \",\n        \"š‘¶”\",\n        \"š‘¶¢\",\n        \"š‘¶£\",\n        \"š‘¶¤\",\n        \"š‘¶„\",\n        \"š‘¶¦\",\n        \"š‘¶§\",\n        \"š‘¶Ø\",\n        \"š‘¶©\"\n    ],\n    \"gonm\": [\n        \"š‘µ\",\n        \"š‘µ‘\",\n        \"š‘µ’\",\n        \"š‘µ“\",\n        \"š‘µ”\",\n        \"š‘µ•\",\n        \"š‘µ–\",\n        \"š‘µ—\",\n        \"š‘µ˜\",\n        \"š‘µ™\"\n    ],\n    \"gujr\": [\n        \"ą«¦\",\n        \"ą«§\",\n        \"ą«Ø\",\n        \"ą«©\",\n        \"ą«Ŗ\",\n        \"ą««\",\n        \"ą«¬\",\n        \"ą«­\",\n        \"ą«®\",\n        \"ą«Æ\"\n    ],\n    \"guru\": [\n        \"ą©¦\",\n        \"ą©§\",\n        \"ą©Ø\",\n        \"ą©©\",\n        \"ą©Ŗ\",\n        \"ą©«\",\n        \"ą©¬\",\n        \"ą©­\",\n        \"ą©®\",\n        \"ą©Æ\"\n    ],\n    \"hanidec\": [\n        \"怇\",\n        \"äø€\",\n        \"äŗŒ\",\n        \"äø‰\",\n        \"四\",\n        \"äŗ”\",\n        \"六\",\n        \"äøƒ\",\n        \"八\",\n        \"九\"\n    ],\n    \"hmng\": [\n        \"š–­\",\n        \"š–­‘\",\n        \"š–­’\",\n        \"š–­“\",\n        \"š–­”\",\n        \"š–­•\",\n        \"š–­–\",\n        \"š–­—\",\n        \"š–­˜\",\n        \"š–­™\"\n    ],\n    \"hmnp\": [\n        \"šž…€\",\n        \"šž…\",\n        \"šž…‚\",\n        \"šž…ƒ\",\n        \"šž…„\",\n        \"šž……\",\n        \"šž…†\",\n        \"šž…‡\",\n        \"šž…ˆ\",\n        \"šž…‰\"\n    ],\n    \"java\": [\n        \"ź§\",\n        \"ź§‘\",\n        \"ź§’\",\n        \"ź§“\",\n        \"ź§”\",\n        \"ź§•\",\n        \"ź§–\",\n        \"ź§—\",\n        \"ź§˜\",\n        \"ź§™\"\n    ],\n    \"kali\": [\n        \"ź¤€\",\n        \"ź¤\",\n        \"ź¤‚\",\n        \"ź¤ƒ\",\n        \"ź¤„\",\n        \"ź¤…\",\n        \"ź¤†\",\n        \"ź¤‡\",\n        \"ź¤ˆ\",\n        \"ź¤‰\"\n    ],\n    \"khmr\": [\n        \"įŸ \",\n        \"įŸ”\",\n        \"įŸ¢\",\n        \"įŸ£\",\n        \"įŸ¤\",\n        \"įŸ„\",\n        \"įŸ¦\",\n        \"įŸ§\",\n        \"įŸØ\",\n        \"įŸ©\"\n    ],\n    \"knda\": [\n        \"ą³¦\",\n        \"ą³§\",\n        \"ą³Ø\",\n        \"ą³©\",\n        \"ą³Ŗ\",\n        \"ą³«\",\n        \"ą³¬\",\n        \"ą³­\",\n        \"ą³®\",\n        \"ą³Æ\"\n    ],\n    \"lana\": [\n        \"įŖ€\",\n        \"įŖ\",\n        \"įŖ‚\",\n        \"įŖƒ\",\n        \"įŖ„\",\n        \"įŖ…\",\n        \"įŖ†\",\n        \"įŖ‡\",\n        \"įŖˆ\",\n        \"įŖ‰\"\n    ],\n    \"lanatham\": [\n        \"įŖ\",\n        \"įŖ‘\",\n        \"įŖ’\",\n        \"įŖ“\",\n        \"įŖ”\",\n        \"įŖ•\",\n        \"įŖ–\",\n        \"įŖ—\",\n        \"įŖ˜\",\n        \"įŖ™\"\n    ],\n    \"laoo\": [\n        \"ą»\",\n        \"ą»‘\",\n        \"ą»’\",\n        \"ą»“\",\n        \"ą»”\",\n        \"ą»•\",\n        \"ą»–\",\n        \"ą»—\",\n        \"ą»˜\",\n        \"ą»™\"\n    ],\n    \"lepc\": [\n        \"įŖ\",\n        \"įŖ‘\",\n        \"įŖ’\",\n        \"įŖ“\",\n        \"įŖ”\",\n        \"įŖ•\",\n        \"įŖ–\",\n        \"įŖ—\",\n        \"įŖ˜\",\n        \"įŖ™\"\n    ],\n    \"limb\": [\n        \"į„†\",\n        \"į„‡\",\n        \"į„ˆ\",\n        \"į„‰\",\n        \"į„Š\",\n        \"į„‹\",\n        \"į„Œ\",\n        \"į„\",\n        \"į„Ž\",\n        \"į„\"\n    ],\n    \"mathbold\": [\n        \"šŸŽ\",\n        \"šŸ\",\n        \"šŸ\",\n        \"šŸ‘\",\n        \"šŸ’\",\n        \"šŸ“\",\n        \"šŸ”\",\n        \"šŸ•\",\n        \"šŸ–\",\n        \"šŸ—\"\n    ],\n    \"mathdbl\": [\n        \"šŸ˜\",\n        \"šŸ™\",\n        \"šŸš\",\n        \"šŸ›\",\n        \"šŸœ\",\n        \"šŸ\",\n        \"šŸž\",\n        \"šŸŸ\",\n        \"šŸ \",\n        \"šŸ”\"\n    ],\n    \"mathmono\": [\n        \"šŸ¶\",\n        \"šŸ·\",\n        \"šŸø\",\n        \"šŸ¹\",\n        \"šŸŗ\",\n        \"šŸ»\",\n        \"šŸ¼\",\n        \"šŸ½\",\n        \"šŸ¾\",\n        \"šŸæ\"\n    ],\n    \"mathsanb\": [\n        \"šŸ¬\",\n        \"šŸ­\",\n        \"šŸ®\",\n        \"šŸÆ\",\n        \"šŸ°\",\n        \"šŸ±\",\n        \"šŸ²\",\n        \"šŸ³\",\n        \"šŸ“\",\n        \"šŸµ\"\n    ],\n    \"mathsans\": [\n        \"šŸ¢\",\n        \"šŸ£\",\n        \"šŸ¤\",\n        \"šŸ„\",\n        \"šŸ¦\",\n        \"šŸ§\",\n        \"šŸØ\",\n        \"šŸ©\",\n        \"šŸŖ\",\n        \"šŸ«\"\n    ],\n    \"mlym\": [\n        \"ąµ¦\",\n        \"ąµ§\",\n        \"ąµØ\",\n        \"ąµ©\",\n        \"ąµŖ\",\n        \"ąµ«\",\n        \"ąµ¬\",\n        \"ąµ­\",\n        \"ąµ®\",\n        \"ąµÆ\"\n    ],\n    \"modi\": [\n        \"š‘™\",\n        \"š‘™‘\",\n        \"š‘™’\",\n        \"š‘™“\",\n        \"š‘™”\",\n        \"š‘™•\",\n        \"š‘™–\",\n        \"š‘™—\",\n        \"š‘™˜\",\n        \"š‘™™\"\n    ],\n    \"mong\": [\n        \"į \",\n        \"į ‘\",\n        \"į ’\",\n        \"į “\",\n        \"į ”\",\n        \"į •\",\n        \"į –\",\n        \"į —\",\n        \"į ˜\",\n        \"į ™\"\n    ],\n    \"mroo\": [\n        \"š–© \",\n        \"š–©”\",\n        \"š–©¢\",\n        \"š–©£\",\n        \"š–©¤\",\n        \"š–©„\",\n        \"š–©¦\",\n        \"š–©§\",\n        \"š–©Ø\",\n        \"š–©©\"\n    ],\n    \"mtei\": [\n        \"źÆ°\",\n        \"źÆ±\",\n        \"źÆ²\",\n        \"źÆ³\",\n        \"źÆ“\",\n        \"źÆµ\",\n        \"źÆ¶\",\n        \"źÆ·\",\n        \"źÆø\",\n        \"źÆ¹\"\n    ],\n    \"mymr\": [\n        \"į€\",\n        \"į\",\n        \"į‚\",\n        \"įƒ\",\n        \"į„\",\n        \"į…\",\n        \"į†\",\n        \"į‡\",\n        \"įˆ\",\n        \"į‰\"\n    ],\n    \"mymrshan\": [\n        \"į‚\",\n        \"į‚‘\",\n        \"į‚’\",\n        \"į‚“\",\n        \"į‚”\",\n        \"į‚•\",\n        \"į‚–\",\n        \"į‚—\",\n        \"į‚˜\",\n        \"į‚™\"\n    ],\n    \"mymrtlng\": [\n        \"ź§°\",\n        \"ź§±\",\n        \"ź§²\",\n        \"ź§³\",\n        \"ź§“\",\n        \"ź§µ\",\n        \"ź§¶\",\n        \"ź§·\",\n        \"ź§ø\",\n        \"ź§¹\"\n    ],\n    \"newa\": [\n        \"š‘‘\",\n        \"š‘‘‘\",\n        \"š‘‘’\",\n        \"š‘‘“\",\n        \"š‘‘”\",\n        \"š‘‘•\",\n        \"š‘‘–\",\n        \"š‘‘—\",\n        \"š‘‘˜\",\n        \"š‘‘™\"\n    ],\n    \"nkoo\": [\n        \"߀\",\n        \"߁\",\n        \"߂\",\n        \"߃\",\n        \"߄\",\n        \"߅\",\n        \"߆\",\n        \"߇\",\n        \"߈\",\n        \"߉\"\n    ],\n    \"olck\": [\n        \"į±\",\n        \"į±‘\",\n        \"į±’\",\n        \"į±“\",\n        \"į±”\",\n        \"į±•\",\n        \"į±–\",\n        \"į±—\",\n        \"į±˜\",\n        \"į±™\"\n    ],\n    \"orya\": [\n        \"ą­¦\",\n        \"ą­§\",\n        \"ą­Ø\",\n        \"ą­©\",\n        \"ą­Ŗ\",\n        \"ą­«\",\n        \"ą­¬\",\n        \"ą­­\",\n        \"ą­®\",\n        \"ą­Æ\"\n    ],\n    \"osma\": [\n        \"š’ \",\n        \"š’”\",\n        \"š’¢\",\n        \"š’£\",\n        \"š’¤\",\n        \"š’„\",\n        \"š’¦\",\n        \"š’§\",\n        \"š’Ø\",\n        \"š’©\"\n    ],\n    \"rohg\": [\n        \"š“°\",\n        \"š“±\",\n        \"š“²\",\n        \"š“³\",\n        \"š““\",\n        \"š“µ\",\n        \"š“¶\",\n        \"š“·\",\n        \"š“ø\",\n        \"š“¹\"\n    ],\n    \"saur\": [\n        \"ź£\",\n        \"ź£‘\",\n        \"ź£’\",\n        \"ź£“\",\n        \"ź£”\",\n        \"ź£•\",\n        \"ź£–\",\n        \"ź£—\",\n        \"ź£˜\",\n        \"ź£™\"\n    ],\n    \"segment\": [\n        \"šŸÆ°\",\n        \"šŸÆ±\",\n        \"šŸÆ²\",\n        \"šŸÆ³\",\n        \"šŸÆ“\",\n        \"šŸÆµ\",\n        \"šŸÆ¶\",\n        \"šŸÆ·\",\n        \"šŸÆø\",\n        \"šŸÆ¹\"\n    ],\n    \"shrd\": [\n        \"š‘‡\",\n        \"š‘‡‘\",\n        \"š‘‡’\",\n        \"š‘‡“\",\n        \"š‘‡”\",\n        \"š‘‡•\",\n        \"š‘‡–\",\n        \"š‘‡—\",\n        \"š‘‡˜\",\n        \"š‘‡™\"\n    ],\n    \"sind\": [\n        \"š‘‹°\",\n        \"š‘‹±\",\n        \"š‘‹²\",\n        \"š‘‹³\",\n        \"š‘‹“\",\n        \"š‘‹µ\",\n        \"š‘‹¶\",\n        \"š‘‹·\",\n        \"š‘‹ø\",\n        \"š‘‹¹\"\n    ],\n    \"sinh\": [\n        \"ą·¦\",\n        \"ą·§\",\n        \"ą·Ø\",\n        \"ą·©\",\n        \"ą·Ŗ\",\n        \"ą·«\",\n        \"ą·¬\",\n        \"ą·­\",\n        \"ą·®\",\n        \"ą·Æ\"\n    ],\n    \"sora\": [\n        \"š‘ƒ°\",\n        \"š‘ƒ±\",\n        \"š‘ƒ²\",\n        \"š‘ƒ³\",\n        \"š‘ƒ“\",\n        \"š‘ƒµ\",\n        \"š‘ƒ¶\",\n        \"š‘ƒ·\",\n        \"š‘ƒø\",\n        \"š‘ƒ¹\"\n    ],\n    \"sund\": [\n        \"į®°\",\n        \"į®±\",\n        \"į®²\",\n        \"į®³\",\n        \"į®“\",\n        \"į®µ\",\n        \"į®¶\",\n        \"į®·\",\n        \"į®ø\",\n        \"į®¹\"\n    ],\n    \"takr\": [\n        \"š‘›€\",\n        \"š‘›\",\n        \"š‘›‚\",\n        \"š‘›ƒ\",\n        \"š‘›„\",\n        \"š‘›…\",\n        \"š‘›†\",\n        \"š‘›‡\",\n        \"š‘›ˆ\",\n        \"š‘›‰\"\n    ],\n    \"talu\": [\n        \"į§\",\n        \"į§‘\",\n        \"į§’\",\n        \"į§“\",\n        \"į§”\",\n        \"į§•\",\n        \"į§–\",\n        \"į§—\",\n        \"į§˜\",\n        \"į§™\"\n    ],\n    \"tamldec\": [\n        \"ąÆ¦\",\n        \"ąÆ§\",\n        \"ąÆØ\",\n        \"ąÆ©\",\n        \"ąÆŖ\",\n        \"ąÆ«\",\n        \"ąÆ¬\",\n        \"ąÆ­\",\n        \"ąÆ®\",\n        \"ąÆÆ\"\n    ],\n    \"telu\": [\n        \"ą±¦\",\n        \"ą±§\",\n        \"ą±Ø\",\n        \"ą±©\",\n        \"ą±Ŗ\",\n        \"ą±«\",\n        \"ą±¬\",\n        \"ą±­\",\n        \"ą±®\",\n        \"ą±Æ\"\n    ],\n    \"thai\": [\n        \"ą¹\",\n        \"ą¹‘\",\n        \"ą¹’\",\n        \"ą¹“\",\n        \"ą¹”\",\n        \"ą¹•\",\n        \"ą¹–\",\n        \"ą¹—\",\n        \"ą¹˜\",\n        \"ą¹™\"\n    ],\n    \"tibt\": [\n        \"ą¼ \",\n        \"ą¼”\",\n        \"ą¼¢\",\n        \"ą¼£\",\n        \"ą¼¤\",\n        \"ą¼„\",\n        \"ą¼¦\",\n        \"ą¼§\",\n        \"ą¼Ø\",\n        \"ą¼©\"\n    ],\n    \"tirh\": [\n        \"š‘“\",\n        \"š‘“‘\",\n        \"š‘“’\",\n        \"š‘““\",\n        \"š‘“”\",\n        \"š‘“•\",\n        \"š‘“–\",\n        \"š‘“—\",\n        \"š‘“˜\",\n        \"š‘“™\"\n    ],\n    \"vaii\": [\n        \"į˜ \",\n        \"į˜”\",\n        \"į˜¢\",\n        \"į˜£\",\n        \"į˜¤\",\n        \"į˜„\",\n        \"į˜¦\",\n        \"į˜§\",\n        \"į˜Ø\",\n        \"į˜©\"\n    ],\n    \"wara\": [\n        \"š‘£ \",\n        \"š‘£”\",\n        \"š‘£¢\",\n        \"š‘££\",\n        \"š‘£¤\",\n        \"š‘£„\",\n        \"š‘£¦\",\n        \"š‘£§\",\n        \"š‘£Ø\",\n        \"š‘£©\"\n    ],\n    \"wcho\": [\n        \"šž‹°\",\n        \"šž‹±\",\n        \"šž‹²\",\n        \"šž‹³\",\n        \"šž‹“\",\n        \"šž‹µ\",\n        \"šž‹¶\",\n        \"šž‹·\",\n        \"šž‹ø\",\n        \"šž‹¹\"\n    ]\n};\n","// @generated from regex-gen.ts\nexport var 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\\u2B97-\\u2BFF\\u2CE5-\\u2CEA\\u2E50\\u2E51\\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\\uAB6A\\uAB6B\\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-\\uDD9C\\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\\uDD0D-\\uDDAD\\uDDE6-\\uDE02\\uDE10-\\uDE3B\\uDE40-\\uDE48\\uDE50\\uDE51\\uDE60-\\uDE65\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDED7\\uDEE0-\\uDEEC\\uDEF0-\\uDEFC\\uDF00-\\uDF73\\uDF80-\\uDFD8\\uDFE0-\\uDFEB]|\\uD83E[\\uDC00-\\uDC0B\\uDC10-\\uDC47\\uDC50-\\uDC59\\uDC60-\\uDC87\\uDC90-\\uDCAD\\uDCB0\\uDCB1\\uDD00-\\uDD78\\uDD7A-\\uDDCB\\uDDCD-\\uDE53\\uDE60-\\uDE6D\\uDE70-\\uDE74\\uDE78-\\uDE7A\\uDE80-\\uDE86\\uDE90-\\uDEA8\\uDEB0-\\uDEB6\\uDEC0-\\uDEC2\\uDED0-\\uDED6\\uDF00-\\uDF92\\uDF94-\\uDFCA]/;\n","import { ToRawFixed } from './ToRawFixed';\nimport { digitMapping } from './digit-mapping.generated';\nimport { S_UNICODE_REGEX } from '../regex.generated';\n// This is from: unicode-12.1.0/General_Category/Symbol/regex.js\n// IE11 does not support unicode flag, otherwise this is just /\\p{S}/u.\n// /^\\p{S}/u\nvar CARET_S_UNICODE_REGEX = new RegExp(\"^\".concat(S_UNICODE_REGEX.source));\n// /\\p{S}$/u\nvar S_DOLLAR_UNICODE_REGEX = new RegExp(\"\".concat(S_UNICODE_REGEX.source, \"$\"));\nvar CLDR_NUMBER_PATTERN = /[#0](?:[\\.,][#0]+)*/g;\nexport default function formatToParts(numberResult, data, pl, options) {\n    var sign = numberResult.sign, exponent = numberResult.exponent, magnitude = numberResult.magnitude;\n    var notation = options.notation, style = options.style, numberingSystem = options.numberingSystem;\n    var defaultNumberingSystem = data.numbers.nu[0];\n    // #region Part 1: partition and interpolate the CLDR number pattern.\n    // ----------------------------------------------------------\n    var compactNumberPattern = null;\n    if (notation === 'compact' && magnitude) {\n        compactNumberPattern = getCompactDisplayPattern(numberResult, pl, data, style, options.compactDisplay, options.currencyDisplay, numberingSystem);\n    }\n    // This is used multiple times\n    var nonNameCurrencyPart;\n    if (style === 'currency' && options.currencyDisplay !== 'name') {\n        var byCurrencyDisplay = data.currencies[options.currency];\n        if (byCurrencyDisplay) {\n            switch (options.currencyDisplay) {\n                case 'code':\n                    nonNameCurrencyPart = options.currency;\n                    break;\n                case 'symbol':\n                    nonNameCurrencyPart = byCurrencyDisplay.symbol;\n                    break;\n                default:\n                    nonNameCurrencyPart = byCurrencyDisplay.narrow;\n                    break;\n            }\n        }\n        else {\n            // Fallback for unknown currency\n            nonNameCurrencyPart = options.currency;\n        }\n    }\n    var numberPattern;\n    if (!compactNumberPattern) {\n        // Note: if the style is unit, or is currency and the currency display is name,\n        // its unit parts will be interpolated in part 2. So here we can fallback to decimal.\n        if (style === 'decimal' ||\n            style === 'unit' ||\n            (style === 'currency' && options.currencyDisplay === 'name')) {\n            // Shortcut for decimal\n            var decimalData = data.numbers.decimal[numberingSystem] ||\n                data.numbers.decimal[defaultNumberingSystem];\n            numberPattern = getPatternForSign(decimalData.standard, sign);\n        }\n        else if (style === 'currency') {\n            var currencyData = data.numbers.currency[numberingSystem] ||\n                data.numbers.currency[defaultNumberingSystem];\n            // We replace number pattern part with `0` for easier postprocessing.\n            numberPattern = getPatternForSign(currencyData[options.currencySign], sign);\n        }\n        else {\n            // percent\n            var percentPattern = data.numbers.percent[numberingSystem] ||\n                data.numbers.percent[defaultNumberingSystem];\n            numberPattern = getPatternForSign(percentPattern, sign);\n        }\n    }\n    else {\n        numberPattern = compactNumberPattern;\n    }\n    // Extract the decimal number pattern string. It looks like \"#,##0,00\", which will later be\n    // used to infer decimal group sizes.\n    var decimalNumberPattern = CLDR_NUMBER_PATTERN.exec(numberPattern)[0];\n    // Now we start to substitute patterns\n    // 1. replace strings like `0` and `#,##0.00` with `{0}`\n    // 2. unquote characters (invariant: the quoted characters does not contain the special tokens)\n    numberPattern = numberPattern\n        .replace(CLDR_NUMBER_PATTERN, '{0}')\n        .replace(/'(.)'/g, '$1');\n    // Handle currency spacing (both compact and non-compact).\n    if (style === 'currency' && options.currencyDisplay !== 'name') {\n        var currencyData = data.numbers.currency[numberingSystem] ||\n            data.numbers.currency[defaultNumberingSystem];\n        // See `currencySpacing` substitution rule in TR-35.\n        // Here we always assume the currencyMatch is \"[:^S:]\" and surroundingMatch is \"[:digit:]\".\n        //\n        // Example 1: for pattern \"#,##0.00Ā¤\" with symbol \"US$\", we replace \"Ā¤\" with the symbol,\n        // but insert an extra non-break space before the symbol, because \"[:^S:]\" matches \"U\" in\n        // \"US$\" and \"[:digit:]\" matches the latn numbering system digits.\n        //\n        // Example 2: for pattern \"Ā¤#,##0.00\" with symbol \"US$\", there is no spacing between symbol\n        // and number, because `$` does not match \"[:^S:]\".\n        //\n        // Implementation note: here we do the best effort to infer the insertion.\n        // We also assume that `beforeInsertBetween` and `afterInsertBetween` will never be `;`.\n        var afterCurrency = currencyData.currencySpacing.afterInsertBetween;\n        if (afterCurrency && !S_DOLLAR_UNICODE_REGEX.test(nonNameCurrencyPart)) {\n            numberPattern = numberPattern.replace('Ā¤{0}', \"\\u00A4\".concat(afterCurrency, \"{0}\"));\n        }\n        var beforeCurrency = currencyData.currencySpacing.beforeInsertBetween;\n        if (beforeCurrency && !CARET_S_UNICODE_REGEX.test(nonNameCurrencyPart)) {\n            numberPattern = numberPattern.replace('{0}Ā¤', \"{0}\".concat(beforeCurrency, \"\\u00A4\"));\n        }\n    }\n    // The following tokens are special: `{0}`, `Ā¤`, `%`, `-`, `+`, `{c:...}.\n    var numberPatternParts = numberPattern.split(/({c:[^}]+}|\\{0\\}|[Ā¤%\\-\\+])/g);\n    var numberParts = [];\n    var symbols = data.numbers.symbols[numberingSystem] ||\n        data.numbers.symbols[defaultNumberingSystem];\n    for (var _i = 0, numberPatternParts_1 = numberPatternParts; _i < numberPatternParts_1.length; _i++) {\n        var part = numberPatternParts_1[_i];\n        if (!part) {\n            continue;\n        }\n        switch (part) {\n            case '{0}': {\n                // We only need to handle scientific and engineering notation here.\n                numberParts.push.apply(numberParts, paritionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, \n                // If compact number pattern exists, do not insert group separators.\n                !compactNumberPattern && Boolean(options.useGrouping), decimalNumberPattern));\n                break;\n            }\n            case '-':\n                numberParts.push({ type: 'minusSign', value: symbols.minusSign });\n                break;\n            case '+':\n                numberParts.push({ type: 'plusSign', value: symbols.plusSign });\n                break;\n            case '%':\n                numberParts.push({ type: 'percentSign', value: symbols.percentSign });\n                break;\n            case 'Ā¤':\n                // Computed above when handling currency spacing.\n                numberParts.push({ type: 'currency', value: nonNameCurrencyPart });\n                break;\n            default:\n                if (/^\\{c:/.test(part)) {\n                    numberParts.push({\n                        type: 'compact',\n                        value: part.substring(3, part.length - 1),\n                    });\n                }\n                else {\n                    // literal\n                    numberParts.push({ type: 'literal', value: part });\n                }\n                break;\n        }\n    }\n    // #endregion\n    // #region Part 2: interpolate unit pattern if necessary.\n    // ----------------------------------------------\n    switch (style) {\n        case 'currency': {\n            // `currencyDisplay: 'name'` has similar pattern handling as units.\n            if (options.currencyDisplay === 'name') {\n                var unitPattern = (data.numbers.currency[numberingSystem] ||\n                    data.numbers.currency[defaultNumberingSystem]).unitPattern;\n                // Select plural\n                var unitName = void 0;\n                var currencyNameData = data.currencies[options.currency];\n                if (currencyNameData) {\n                    unitName = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), currencyNameData.displayName);\n                }\n                else {\n                    // Fallback for unknown currency\n                    unitName = options.currency;\n                }\n                // Do {0} and {1} substitution\n                var unitPatternParts = unitPattern.split(/(\\{[01]\\})/g);\n                var result = [];\n                for (var _a = 0, unitPatternParts_1 = unitPatternParts; _a < unitPatternParts_1.length; _a++) {\n                    var part = unitPatternParts_1[_a];\n                    switch (part) {\n                        case '{0}':\n                            result.push.apply(result, numberParts);\n                            break;\n                        case '{1}':\n                            result.push({ type: 'currency', value: unitName });\n                            break;\n                        default:\n                            if (part) {\n                                result.push({ type: 'literal', value: part });\n                            }\n                            break;\n                    }\n                }\n                return result;\n            }\n            else {\n                return numberParts;\n            }\n        }\n        case 'unit': {\n            var unit = options.unit, unitDisplay = options.unitDisplay;\n            var unitData = data.units.simple[unit];\n            var unitPattern = void 0;\n            if (unitData) {\n                // Simple unit pattern\n                unitPattern = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), data.units.simple[unit][unitDisplay]);\n            }\n            else {\n                // See: http://unicode.org/reports/tr35/tr35-general.html#perUnitPatterns\n                // If cannot find unit in the simple pattern, it must be \"per\" compound pattern.\n                // Implementation note: we are not following TR-35 here because we need to format to parts!\n                var _b = unit.split('-per-'), numeratorUnit = _b[0], denominatorUnit = _b[1];\n                unitData = data.units.simple[numeratorUnit];\n                var numeratorUnitPattern = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), data.units.simple[numeratorUnit][unitDisplay]);\n                var perUnitPattern = data.units.simple[denominatorUnit].perUnit[unitDisplay];\n                if (perUnitPattern) {\n                    // perUnitPattern exists, combine it with numeratorUnitPattern\n                    unitPattern = perUnitPattern.replace('{0}', numeratorUnitPattern);\n                }\n                else {\n                    // get compoundUnit pattern (e.g. \"{0} per {1}\"), repalce {0} with numerator pattern and {1} with\n                    // the denominator pattern in singular form.\n                    var perPattern = data.units.compound.per[unitDisplay];\n                    var denominatorPattern = selectPlural(pl, 1, data.units.simple[denominatorUnit][unitDisplay]);\n                    unitPattern = unitPattern = perPattern\n                        .replace('{0}', numeratorUnitPattern)\n                        .replace('{1}', denominatorPattern.replace('{0}', ''));\n                }\n            }\n            var result = [];\n            // We need spacing around \"{0}\" because they are not treated as \"unit\" parts, but \"literal\".\n            for (var _c = 0, _d = unitPattern.split(/(\\s*\\{0\\}\\s*)/); _c < _d.length; _c++) {\n                var part = _d[_c];\n                var interpolateMatch = /^(\\s*)\\{0\\}(\\s*)$/.exec(part);\n                if (interpolateMatch) {\n                    // Space before \"{0}\"\n                    if (interpolateMatch[1]) {\n                        result.push({ type: 'literal', value: interpolateMatch[1] });\n                    }\n                    // \"{0}\" itself\n                    result.push.apply(result, numberParts);\n                    // Space after \"{0}\"\n                    if (interpolateMatch[2]) {\n                        result.push({ type: 'literal', value: interpolateMatch[2] });\n                    }\n                }\n                else if (part) {\n                    result.push({ type: 'unit', value: part });\n                }\n            }\n            return result;\n        }\n        default:\n            return numberParts;\n    }\n    // #endregion\n}\n// A subset of https://tc39.es/ecma402/#sec-partitionnotationsubpattern\n// Plus the exponent parts handling.\nfunction paritionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, useGrouping, \n/**\n * This is the decimal number pattern without signs or symbols.\n * It is used to infer the group size when `useGrouping` is true.\n *\n * A typical value looks like \"#,##0.00\" (primary group size is 3).\n * Some locales like Hindi has secondary group size of 2 (e.g. \"#,##,##0.00\").\n */\ndecimalNumberPattern) {\n    var result = [];\n    // eslint-disable-next-line prefer-const\n    var n = numberResult.formattedString, x = numberResult.roundedNumber;\n    if (isNaN(x)) {\n        return [{ type: 'nan', value: n }];\n    }\n    else if (!isFinite(x)) {\n        return [{ type: 'infinity', value: n }];\n    }\n    var digitReplacementTable = digitMapping[numberingSystem];\n    if (digitReplacementTable) {\n        n = n.replace(/\\d/g, function (digit) { return digitReplacementTable[+digit] || digit; });\n    }\n    // TODO: Else use an implementation dependent algorithm to map n to the appropriate\n    // representation of n in the given numbering system.\n    var decimalSepIndex = n.indexOf('.');\n    var integer;\n    var fraction;\n    if (decimalSepIndex > 0) {\n        integer = n.slice(0, decimalSepIndex);\n        fraction = n.slice(decimalSepIndex + 1);\n    }\n    else {\n        integer = n;\n    }\n    // #region Grouping integer digits\n    // The weird compact and x >= 10000 check is to ensure consistency with Node.js and Chrome.\n    // Note that `de` does not have compact form for thousands, but Node.js does not insert grouping separator\n    // unless the rounded number is greater than 10000:\n    //   NumberFormat('de', {notation: 'compact', compactDisplay: 'short'}).format(1234) //=> \"1234\"\n    //   NumberFormat('de').format(1234) //=> \"1.234\"\n    if (useGrouping && (notation !== 'compact' || x >= 10000)) {\n        var groupSepSymbol = symbols.group;\n        var groups = [];\n        // > There may be two different grouping sizes: The primary grouping size used for the least\n        // > significant integer group, and the secondary grouping size used for more significant groups.\n        // > If a pattern contains multiple grouping separators, the interval between the last one and the\n        // > end of the integer defines the primary grouping size, and the interval between the last two\n        // > defines the secondary grouping size. All others are ignored.\n        var integerNumberPattern = decimalNumberPattern.split('.')[0];\n        var patternGroups = integerNumberPattern.split(',');\n        var primaryGroupingSize = 3;\n        var secondaryGroupingSize = 3;\n        if (patternGroups.length > 1) {\n            primaryGroupingSize = patternGroups[patternGroups.length - 1].length;\n        }\n        if (patternGroups.length > 2) {\n            secondaryGroupingSize = patternGroups[patternGroups.length - 2].length;\n        }\n        var i = integer.length - primaryGroupingSize;\n        if (i > 0) {\n            // Slice the least significant integer group\n            groups.push(integer.slice(i, i + primaryGroupingSize));\n            // Then iteratively push the more signicant groups\n            // TODO: handle surrogate pairs in some numbering system digits\n            for (i -= secondaryGroupingSize; i > 0; i -= secondaryGroupingSize) {\n                groups.push(integer.slice(i, i + secondaryGroupingSize));\n            }\n            groups.push(integer.slice(0, i + secondaryGroupingSize));\n        }\n        else {\n            groups.push(integer);\n        }\n        while (groups.length > 0) {\n            var integerGroup = groups.pop();\n            result.push({ type: 'integer', value: integerGroup });\n            if (groups.length > 0) {\n                result.push({ type: 'group', value: groupSepSymbol });\n            }\n        }\n    }\n    else {\n        result.push({ type: 'integer', value: integer });\n    }\n    // #endregion\n    if (fraction !== undefined) {\n        result.push({ type: 'decimal', value: symbols.decimal }, { type: 'fraction', value: fraction });\n    }\n    if ((notation === 'scientific' || notation === 'engineering') &&\n        isFinite(x)) {\n        result.push({ type: 'exponentSeparator', value: symbols.exponential });\n        if (exponent < 0) {\n            result.push({ type: 'exponentMinusSign', value: symbols.minusSign });\n            exponent = -exponent;\n        }\n        var exponentResult = ToRawFixed(exponent, 0, 0);\n        result.push({\n            type: 'exponentInteger',\n            value: exponentResult.formattedString,\n        });\n    }\n    return result;\n}\nfunction getPatternForSign(pattern, sign) {\n    if (pattern.indexOf(';') < 0) {\n        pattern = \"\".concat(pattern, \";-\").concat(pattern);\n    }\n    var _a = pattern.split(';'), zeroPattern = _a[0], negativePattern = _a[1];\n    switch (sign) {\n        case 0:\n            return zeroPattern;\n        case -1:\n            return negativePattern;\n        default:\n            return negativePattern.indexOf('-') >= 0\n                ? negativePattern.replace(/-/g, '+')\n                : \"+\".concat(zeroPattern);\n    }\n}\n// Find the CLDR pattern for compact notation based on the magnitude of data and style.\n//\n// Example return value: \"Ā¤Ā {c:laki}000;Ā¤{c:laki}Ā -0\" (`sw` locale):\n// - Notice the `{c:...}` token that wraps the compact literal.\n// - The consecutive zeros are normalized to single zero to match CLDR_NUMBER_PATTERN.\n//\n// Returning null means the compact display pattern cannot be found.\nfunction getCompactDisplayPattern(numberResult, pl, data, style, compactDisplay, currencyDisplay, numberingSystem) {\n    var _a;\n    var roundedNumber = numberResult.roundedNumber, sign = numberResult.sign, magnitude = numberResult.magnitude;\n    var magnitudeKey = String(Math.pow(10, magnitude));\n    var defaultNumberingSystem = data.numbers.nu[0];\n    var pattern;\n    if (style === 'currency' && currencyDisplay !== 'name') {\n        var byNumberingSystem = data.numbers.currency;\n        var currencyData = byNumberingSystem[numberingSystem] ||\n            byNumberingSystem[defaultNumberingSystem];\n        // NOTE: compact notation ignores currencySign!\n        var compactPluralRules = (_a = currencyData.short) === null || _a === void 0 ? void 0 : _a[magnitudeKey];\n        if (!compactPluralRules) {\n            return null;\n        }\n        pattern = selectPlural(pl, roundedNumber, compactPluralRules);\n    }\n    else {\n        var byNumberingSystem = data.numbers.decimal;\n        var byCompactDisplay = byNumberingSystem[numberingSystem] ||\n            byNumberingSystem[defaultNumberingSystem];\n        var compactPlaralRule = byCompactDisplay[compactDisplay][magnitudeKey];\n        if (!compactPlaralRule) {\n            return null;\n        }\n        pattern = selectPlural(pl, roundedNumber, compactPlaralRule);\n    }\n    // See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats\n    // > If the value is precisely ā€œ0ā€, either explicit or defaulted, then the normal number format\n    // > pattern for that sort of object is supplied.\n    if (pattern === '0') {\n        return null;\n    }\n    pattern = getPatternForSign(pattern, sign)\n        // Extract compact literal from the pattern\n        .replace(/([^\\s;\\-\\+\\dĀ¤]+)/g, '{c:$1}')\n        // We replace one or more zeros with a single zero so it matches `CLDR_NUMBER_PATTERN`.\n        .replace(/0+/, '0');\n    return pattern;\n}\nfunction selectPlural(pl, x, rules) {\n    return rules[pl.select(x)] || rules.other;\n}\n","import { FormatNumericToString } from './FormatNumericToString';\nimport { SameValue } from '../262';\nimport { ComputeExponent } from './ComputeExponent';\nimport formatToParts from './format_to_parts';\n/**\n * https://tc39.es/ecma402/#sec-formatnumberstring\n */\nexport function PartitionNumberPattern(numberFormat, x, _a) {\n    var _b;\n    var getInternalSlots = _a.getInternalSlots;\n    var internalSlots = getInternalSlots(numberFormat);\n    var pl = internalSlots.pl, dataLocaleData = internalSlots.dataLocaleData, numberingSystem = internalSlots.numberingSystem;\n    var symbols = dataLocaleData.numbers.symbols[numberingSystem] ||\n        dataLocaleData.numbers.symbols[dataLocaleData.numbers.nu[0]];\n    var magnitude = 0;\n    var exponent = 0;\n    var n;\n    if (isNaN(x)) {\n        n = symbols.nan;\n    }\n    else if (x == Number.POSITIVE_INFINITY || x == Number.NEGATIVE_INFINITY) {\n        n = symbols.infinity;\n    }\n    else {\n        if (!SameValue(x, -0)) {\n            if (!isFinite(x)) {\n                throw new Error('Input must be a mathematical value');\n            }\n            if (internalSlots.style == 'percent') {\n                x *= 100;\n            }\n            ;\n            _b = ComputeExponent(numberFormat, x, {\n                getInternalSlots: getInternalSlots,\n            }), exponent = _b[0], magnitude = _b[1];\n            // Preserve more precision by doing multiplication when exponent is negative.\n            x = exponent < 0 ? x * Math.pow(10, -exponent) : x / Math.pow(10, exponent);\n        }\n        var formatNumberResult = FormatNumericToString(internalSlots, x);\n        n = formatNumberResult.formattedString;\n        x = formatNumberResult.roundedNumber;\n    }\n    // Based on https://tc39.es/ecma402/#sec-getnumberformatpattern\n    // We need to do this before `x` is rounded.\n    var sign;\n    var signDisplay = internalSlots.signDisplay;\n    switch (signDisplay) {\n        case 'never':\n            sign = 0;\n            break;\n        case 'auto':\n            if (SameValue(x, 0) || x > 0 || isNaN(x)) {\n                sign = 0;\n            }\n            else {\n                sign = -1;\n            }\n            break;\n        case 'always':\n            if (SameValue(x, 0) || x > 0 || isNaN(x)) {\n                sign = 1;\n            }\n            else {\n                sign = -1;\n            }\n            break;\n        default:\n            // x === 0 -> x is 0 or x is -0\n            if (x === 0 || isNaN(x)) {\n                sign = 0;\n            }\n            else if (x > 0) {\n                sign = 1;\n            }\n            else {\n                sign = -1;\n            }\n    }\n    return formatToParts({ roundedNumber: x, formattedString: n, exponent: exponent, magnitude: magnitude, sign: sign }, internalSlots.dataLocaleData, pl, internalSlots);\n}\n","import { PartitionNumberPattern } from './PartitionNumberPattern';\nimport { CollapseNumberRange } from './CollapseNumberRange';\nimport { FormatApproximately } from './FormatApproximately';\n/**\n * https://tc39.es/ecma402/#sec-partitionnumberrangepattern\n */\nexport function PartitionNumberRangePattern(numberFormat, x, y, _a) {\n    var getInternalSlots = _a.getInternalSlots;\n    if (isNaN(x) || isNaN(y)) {\n        throw new RangeError('Input must be a number');\n    }\n    var result = [];\n    var xResult = PartitionNumberPattern(numberFormat, x, { getInternalSlots: getInternalSlots });\n    var yResult = PartitionNumberPattern(numberFormat, y, { getInternalSlots: getInternalSlots });\n    if (xResult === yResult) {\n        return FormatApproximately(numberFormat, xResult, { getInternalSlots: getInternalSlots });\n    }\n    for (var _i = 0, xResult_1 = xResult; _i < xResult_1.length; _i++) {\n        var r = xResult_1[_i];\n        r.source = 'startRange';\n    }\n    result = result.concat(xResult);\n    var internalSlots = getInternalSlots(numberFormat);\n    var symbols = internalSlots.dataLocaleData.numbers.symbols[internalSlots.numberingSystem];\n    result.push({ type: 'literal', value: symbols.rangeSign, source: 'shared' });\n    for (var _b = 0, yResult_1 = yResult; _b < yResult_1.length; _b++) {\n        var r = yResult_1[_b];\n        r.source = 'endRange';\n    }\n    result = result.concat(yResult);\n    return CollapseNumberRange(result);\n}\n","import { PartitionNumberRangePattern } from './PartitionNumberRangePattern';\n/**\n * https://tc39.es/ecma402/#sec-formatnumericrange\n */\nexport function FormatNumericRange(numberFormat, x, y, _a) {\n    var getInternalSlots = _a.getInternalSlots;\n    var parts = PartitionNumberRangePattern(numberFormat, x, y, {\n        getInternalSlots: getInternalSlots,\n    });\n    return parts.map(function (part) { return part.value; }).join('');\n}\n","import { PartitionNumberRangePattern } from './PartitionNumberRangePattern';\n/**\n * https://tc39.es/ecma402/#sec-formatnumericrangetoparts\n */\nexport function FormatNumericRangeToParts(numberFormat, x, y, _a) {\n    var getInternalSlots = _a.getInternalSlots;\n    var parts = PartitionNumberRangePattern(numberFormat, x, y, {\n        getInternalSlots: getInternalSlots,\n    });\n    return parts.map(function (part, index) { return ({\n        type: part.type,\n        value: part.value,\n        source: part.source,\n        result: index.toString(),\n    }); });\n}\n","import { PartitionNumberPattern } from './PartitionNumberPattern';\nimport { ArrayCreate } from '../262';\nexport function FormatNumericToParts(nf, x, implDetails) {\n    var parts = PartitionNumberPattern(nf, x, implDetails);\n    var result = ArrayCreate(0);\n    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {\n        var part = parts_1[_i];\n        result.push({\n            type: part.type,\n            value: part.value,\n        });\n    }\n    return result;\n}\n","var negativeMapping = {\n    ceil: 'zero',\n    floor: 'infinity',\n    expand: 'infinity',\n    trunc: 'zero',\n    halfCeil: 'half-zero',\n    halfFloor: 'half-infinity',\n    halfExpand: 'half-infinity',\n    halfTrunc: 'half-zero',\n    halfEven: 'half-even',\n};\nvar positiveMapping = {\n    ceil: 'infinity',\n    floor: 'zero',\n    expand: 'infinity',\n    trunc: 'zero',\n    halfCeil: 'half-infinity',\n    halfFloor: 'half-zero',\n    halfExpand: 'half-infinity',\n    halfTrunc: 'half-zero',\n    halfEven: 'half-even',\n};\nexport function GetUnsignedRoundingMode(roundingMode, isNegative) {\n    if (isNegative) {\n        return negativeMapping[roundingMode];\n    }\n    return positiveMapping[roundingMode];\n}\n","import { GetOption } from '../GetOption';\nimport { IsWellFormedCurrencyCode } from '../IsWellFormedCurrencyCode';\nimport { IsWellFormedUnitIdentifier } from '../IsWellFormedUnitIdentifier';\n/**\n * https://tc39.es/ecma402/#sec-setnumberformatunitoptions\n */\nexport function SetNumberFormatUnitOptions(nf, options, _a) {\n    if (options === void 0) { options = Object.create(null); }\n    var getInternalSlots = _a.getInternalSlots;\n    var internalSlots = getInternalSlots(nf);\n    var style = GetOption(options, 'style', 'string', ['decimal', 'percent', 'currency', 'unit'], 'decimal');\n    internalSlots.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    if (style === 'currency' && currency === undefined) {\n        throw TypeError('currency cannot be undefined');\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    if (style === 'unit' && unit === undefined) {\n        throw TypeError('unit cannot be undefined');\n    }\n    var unitDisplay = GetOption(options, 'unitDisplay', 'string', ['short', 'narrow', 'long'], 'short');\n    if (style === 'currency') {\n        internalSlots.currency = currency.toUpperCase();\n        internalSlots.currencyDisplay = currencyDisplay;\n        internalSlots.currencySign = currencySign;\n    }\n    if (style === 'unit') {\n        internalSlots.unit = unit;\n        internalSlots.unitDisplay = unitDisplay;\n    }\n}\n","import { GetNumberOption } from '../GetNumberOption';\nimport { DefaultNumberOption } from '../DefaultNumberOption';\nimport { GetOption } from '../GetOption';\n/**\n * https://tc39.es/ecma402/#sec-setnfdigitoptions\n */\nexport function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mxfdDefault, notation) {\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    internalSlots.minimumIntegerDigits = mnid;\n    var roundingPriority = GetOption(opts, 'roundingPriority', 'string', ['auto', 'morePrecision', 'lessPrecision'], 'auto');\n    var hasSd = mnsd !== undefined || mxsd !== undefined;\n    var hasFd = mnfd !== undefined || mxfd !== undefined;\n    var needSd = true;\n    var needFd = true;\n    if (roundingPriority === 'auto') {\n        needSd = hasSd;\n        if (hasSd || (!hasFd && notation === 'compact')) {\n            needFd = false;\n        }\n    }\n    if (needSd) {\n        if (hasSd) {\n            mnsd = DefaultNumberOption(mnsd, 1, 21, 1);\n            mxsd = DefaultNumberOption(mxsd, mnsd, 21, 21);\n            internalSlots.minimumSignificantDigits = mnsd;\n            internalSlots.maximumSignificantDigits = mxsd;\n        }\n        else {\n            internalSlots.minimumSignificantDigits = 1;\n            internalSlots.maximumSignificantDigits = 21;\n        }\n    }\n    if (needFd) {\n        if (hasFd) {\n            // @ts-expect-error\n            mnfd = DefaultNumberOption(mnfd, 0, 20, undefined);\n            // @ts-expect-error\n            mxfd = DefaultNumberOption(mxfd, 0, 20, undefined);\n            if (mnfd === undefined) {\n                mnfd = Math.min(mnfdDefault, mxfd);\n            }\n            else if (mxfd === undefined) {\n                mxfd = Math.max(mxfdDefault, mnfd);\n            }\n            else if (mnfd > mxfd) {\n                throw new RangeError(\"Invalid range, \".concat(mnfd, \" > \").concat(mxfd));\n            }\n            internalSlots.minimumFractionDigits = mnfd;\n            internalSlots.maximumFractionDigits = mxfd;\n        }\n        else {\n            internalSlots.minimumFractionDigits = mnfdDefault;\n            internalSlots.maximumFractionDigits = mxfdDefault;\n        }\n    }\n    if (needSd || needFd) {\n        if (roundingPriority === 'morePrecision') {\n            internalSlots.roundingType = 'morePrecision';\n        }\n        else if (roundingPriority === 'lessPrecision') {\n            internalSlots.roundingType = 'lessPrecision';\n        }\n        else if (hasSd) {\n            internalSlots.roundingType = 'significantDigits';\n        }\n        else {\n            internalSlots.roundingType = 'fractionDigits';\n        }\n    }\n    else {\n        internalSlots.roundingType = 'morePrecision';\n        internalSlots.minimumFractionDigits = 0;\n        internalSlots.maximumFractionDigits = 0;\n        internalSlots.minimumSignificantDigits = 1;\n        internalSlots.maximumSignificantDigits = 2;\n    }\n}\n","import { CanonicalizeLocaleList } from '../CanonicalizeLocaleList';\nimport { GetOption } from '../GetOption';\nimport { ResolveLocale } from '@formatjs/intl-localematcher';\nimport { SetNumberFormatUnitOptions } from './SetNumberFormatUnitOptions';\nimport { CurrencyDigits } from './CurrencyDigits';\nimport { SetNumberFormatDigitOptions } from './SetNumberFormatDigitOptions';\nimport { invariant } from '../utils';\nimport { CoerceOptionsToObject } from '../CoerceOptionsToObject';\nimport { GetNumberOption } from '../GetNumberOption';\nimport { GetStringOrBooleanOption } from '../GetStringOrBooleanOption';\nvar VALID_ROUND_INCREMENT_VALUES = [\n    1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000, 2000,\n];\n/**\n * https://tc39.es/ecma402/#sec-initializenumberformat\n */\nexport function InitializeNumberFormat(nf, locales, opts, _a) {\n    var getInternalSlots = _a.getInternalSlots, localeData = _a.localeData, availableLocales = _a.availableLocales, numberingSystemNames = _a.numberingSystemNames, getDefaultLocale = _a.getDefaultLocale, currencyDigitsData = _a.currencyDigitsData;\n    // @ts-ignore\n    var requestedLocales = CanonicalizeLocaleList(locales);\n    var options = CoerceOptionsToObject(opts);\n    var opt = Object.create(null);\n    var matcher = GetOption(options, 'localeMatcher', 'string', ['lookup', 'best fit'], 'best fit');\n    opt.localeMatcher = matcher;\n    var numberingSystem = GetOption(options, 'numberingSystem', 'string', undefined, undefined);\n    if (numberingSystem !== undefined &&\n        numberingSystemNames.indexOf(numberingSystem) < 0) {\n        // 8.a. If numberingSystem does not match the Unicode Locale Identifier type nonterminal,\n        // throw a RangeError exception.\n        throw RangeError(\"Invalid numberingSystems: \".concat(numberingSystem));\n    }\n    opt.nu = numberingSystem;\n    var r = ResolveLocale(availableLocales, requestedLocales, opt, \n    // [[RelevantExtensionKeys]] slot, which is a constant\n    ['nu'], localeData, getDefaultLocale);\n    var dataLocaleData = localeData[r.dataLocale];\n    invariant(!!dataLocaleData, \"Missing locale data for \".concat(r.dataLocale));\n    var internalSlots = getInternalSlots(nf);\n    internalSlots.locale = r.locale;\n    internalSlots.dataLocale = r.dataLocale;\n    internalSlots.numberingSystem = r.nu;\n    internalSlots.dataLocaleData = dataLocaleData;\n    SetNumberFormatUnitOptions(nf, options, { getInternalSlots: getInternalSlots });\n    var style = internalSlots.style;\n    var mnfdDefault;\n    var mxfdDefault;\n    if (style === 'currency') {\n        var currency = internalSlots.currency;\n        var cDigits = CurrencyDigits(currency, { currencyDigitsData: currencyDigitsData });\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    internalSlots.notation = notation;\n    SetNumberFormatDigitOptions(internalSlots, options, mnfdDefault, mxfdDefault, notation);\n    var roundingIncrement = GetNumberOption(options, 'roundingIncrement', 1, 5000, 1);\n    if (VALID_ROUND_INCREMENT_VALUES.indexOf(roundingIncrement) === -1) {\n        throw new RangeError(\"Invalid rounding increment value: \".concat(roundingIncrement, \".\\nValid values are \").concat(VALID_ROUND_INCREMENT_VALUES, \".\"));\n    }\n    if (roundingIncrement !== 1 &&\n        internalSlots.roundingType !== 'fractionDigits') {\n        throw new TypeError(\"For roundingIncrement > 1 only fractionDigits is a valid roundingType\");\n    }\n    if (roundingIncrement !== 1 &&\n        internalSlots.maximumFractionDigits !== internalSlots.minimumFractionDigits) {\n        throw new RangeError('With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.');\n    }\n    internalSlots.roundingIncrement = roundingIncrement;\n    var trailingZeroDisplay = GetOption(options, 'trailingZeroDisplay', 'string', ['auto', 'stripIfInteger'], 'auto');\n    internalSlots.trailingZeroDisplay = trailingZeroDisplay;\n    var compactDisplay = GetOption(options, 'compactDisplay', 'string', ['short', 'long'], 'short');\n    var defaultUseGrouping = 'auto';\n    if (notation === 'compact') {\n        internalSlots.compactDisplay = compactDisplay;\n        defaultUseGrouping = 'min2';\n    }\n    internalSlots.useGrouping = GetStringOrBooleanOption(options, 'useGrouping', ['min2', 'auto', 'always'], 'always', false, defaultUseGrouping);\n    internalSlots.signDisplay = GetOption(options, 'signDisplay', 'string', ['auto', 'never', 'always', 'exceptZero', 'negative'], 'auto');\n    internalSlots.roundingMode = GetOption(options, 'roundingMode', 'string', [\n        'ceil',\n        'floor',\n        'expand',\n        'trunc',\n        'halfCeil',\n        'halfFloor',\n        'halfExpand',\n        'halfTrunc',\n        'halfEven',\n    ], 'halfExpand');\n    return nf;\n}\n","import { invariant } from './utils';\n/**\n * https://tc39.es/ecma402/#sec-partitionpattern\n * @param pattern\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 \".concat(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","import { ToObject } from './262';\nimport { GetOption } from './GetOption';\nimport { LookupSupportedLocales } from '@formatjs/intl-localematcher';\n/**\n * https://tc39.es/ecma402/#sec-supportedlocales\n * @param availableLocales\n * @param requestedLocales\n * @param options\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}\n","export var RangePatternType;\n(function (RangePatternType) {\n    RangePatternType[\"startRange\"] = \"startRange\";\n    RangePatternType[\"shared\"] = \"shared\";\n    RangePatternType[\"endRange\"] = \"endRange\";\n})(RangePatternType || (RangePatternType = {}));\n","import { __extends } from \"tslib\";\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}\n"],"names":["CanonicalizeLocaleList","locales","Intl","getCanonicalLocales","CanonicalizeTimeZoneName","tz","_a","tzData","uppercaseLinks","uppercasedTz","toUpperCase","uppercasedZones","Object","keys","reduce","all","z","ianaTimeZone","ToString","o","TypeError","String","ToNumber","val","undefined","NaN","Number","TimeClip","time","isFinite","Math","abs","n","number","isNaN","SameValue","integer","floor","ToInteger","ToObject","arg","x","y","is","ArrayCreate","len","Array","HasOwnProperty","prop","prototype","hasOwnProperty","call","Type","MS_PER_DAY","mod","Day","t","WeekDay","DayFromYear","Date","UTC","TimeFromYear","YearFromTime","getUTCFullYear","DaysInYear","DayWithinYear","InLeapYear","MonthFromTime","dwy","leap","Error","DateFromTime","mft","HOURS_PER_DAY","MINUTES_PER_HOUR","SECONDS_PER_MINUTE","MS_PER_SECOND","MS_PER_MINUTE","MS_PER_HOUR","HourFromTime","MinFromTime","SecFromTime","OrdinaryHasInstance","C","O","internalSlots","boundTargetFunction","P","isPrototypeOf","msFromTime","CoerceOptionsToObject","options","create","DefaultNumberOption","min","max","fallback","RangeError","concat","GetNumberOption","property","minimum","maximum","GetOption","opts","type","values","value","Boolean","filter","length","join","GetOptionsObject","GetStringOrBooleanOption","trueValue","falsyValue","indexOf","SANCTIONED_UNITS","removeUnitNamespace","unit","slice","SIMPLE_UNITS","map","IsSanctionedSimpleUnitIdentifier","unitIdentifier","IsValidTimeZoneName","zoneNames","Set","linkNames","forEach","add","linkName","has","NOT_A_Z_REGEX","IsWellFormedCurrencyCode","currency","replace","_","c","test","IsWellFormedUnitIdentifier","toLowerCase","units","split","numerator","denominator","ApplyUnsignedRoundingMode","r1","r2","unsignedRoundingMode","d1","d2","CollapseNumberRange","result","ComputeExponentForMagnitude","numberFormat","magnitude","getInternalSlots","notation","dataLocaleData","numberingSystem","compactDisplay","style","currencyDisplay","thresholdMap","numbers","nu","short","decimal","long","num","pow","thresholds","i","magnitudeKey","other","match","ToRawPrecision","minPrecision","maxPrecision","m","e","xFinal","int","p","xToString","toString","xToStringExponentIndex","xToStringMantissa","xToStringExponent","xToStringMantissaWithoutDecimalPoint","decimalPlaceOffset","round","adjustDecimalPlace","cut","formattedString","roundedNumber","integerDigitsCount","ToRawFixed","minFraction","maxFraction","f","mantissa","exponent","k","a","b","FormatNumericToString","intlObject","isNegative","roundingType","minimumSignificantDigits","maximumSignificantDigits","minimumFractionDigits","maximumFractionDigits","string","minInteger","minimumIntegerDigits","ComputeExponent","formatNumberResult","CurrencyDigits","currencyDigitsData","FormatApproximately","approximatelySign","symbols","push","digitMapping","S_UNICODE_REGEX","CARET_S_UNICODE_REGEX","RegExp","source","S_DOLLAR_UNICODE_REGEX","CLDR_NUMBER_PATTERN","formatToParts","numberResult","data","pl","nonNameCurrencyPart","numberPattern","sign","defaultNumberingSystem","compactNumberPattern","pattern","compactPluralRules","byNumberingSystem","selectPlural","compactPlaralRule","getPatternForSign","getCompactDisplayPattern","byCurrencyDisplay","currencies","symbol","narrow","standard","currencyData","currencySign","percent","decimalNumberPattern","exec","afterCurrency","currencySpacing","afterInsertBetween","beforeCurrency","beforeInsertBetween","numberPatternParts","numberParts","_i","numberPatternParts_1","part","apply","paritionNumberIntoParts","useGrouping","minusSign","plusSign","percentSign","substring","unitName","unitPattern","currencyNameData","displayName","unitPatternParts_1","unitDisplay","unitData","simple","_b","numeratorUnit","denominatorUnit","numeratorUnitPattern","perUnitPattern","perUnit","perPattern","compound","per","denominatorPattern","_c","_d","interpolateMatch","digitReplacementTable","digit","fraction","decimalSepIndex","groupSepSymbol","group","groups","patternGroups","primaryGroupingSize","secondaryGroupingSize","integerGroup","pop","exponential","exponentResult","zeroPattern","negativePattern","rules","select","PartitionNumberPattern","nan","POSITIVE_INFINITY","NEGATIVE_INFINITY","infinity","signDisplay","PartitionNumberRangePattern","xResult","yResult","xResult_1","rangeSign","yResult_1","FormatNumericRange","FormatNumericRangeToParts","index","FormatNumericToParts","nf","implDetails","parts","parts_1","negativeMapping","ceil","expand","trunc","halfCeil","halfFloor","halfExpand","halfTrunc","halfEven","positiveMapping","GetUnsignedRoundingMode","roundingMode","SetNumberFormatUnitOptions","SetNumberFormatDigitOptions","mnfdDefault","mxfdDefault","mnid","mnfd","mxfd","mnsd","mxsd","roundingPriority","hasSd","hasFd","needSd","needFd","VALID_ROUND_INCREMENT_VALUES","InitializeNumberFormat","localeData","availableLocales","numberingSystemNames","getDefaultLocale","requestedLocales","opt","matcher","localeMatcher","r","ResolveLocale","dataLocale","locale","cDigits","roundingIncrement","trailingZeroDisplay","defaultUseGrouping","PartitionPattern","beginIndex","endIndex","nextIndex","SupportedLocales","LookupSupportedLocales","RangePatternType","_super","isMissingLocaleDataError","__extends","_this","this","arguments"],"sourceRoot":""}