@formatjs/ecma402-abstract 1.0.3 → 1.2.2

package/lib/src/NumberFormat/format_to_parts.js

@@ -0,0 +1,421 @@
+import { ToRawFixed } from './ToRawFixed';
+import * as digitMapping from './digit-mapping.json';
+// This is from: unicode-12.1.0/General_Category/Symbol/regex.js
+// IE11 does not support unicode flag, otherwise this is just /\p{S}/u.
+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\u2B98-\u2BFF\u2CE5-\u2CEA\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uFB29\uFBB2-\uFBC1\uFDFC\uFDFD\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD]|\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9B\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838[\uDD4F\uDEFF]|\uD83B[\uDCAC\uDCB0\uDD2E\uDEF0\uDEF1]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD10-\uDD6C\uDD70-\uDDAC\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFF]|\uD83D[\uDC00-\uDED5\uDEE0-\uDEEC\uDEF0-\uDEFA\uDF00-\uDF73\uDF80-\uDFD8\uDFE0-\uDFEB]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDD00-\uDD0B\uDD0D-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDE53\uDE60-\uDE6D\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95]/;
+// /^\p{S}/u
+var CARET_S_UNICODE_REGEX = new RegExp("^" + S_UNICODE_REGEX.source);
+// /\p{S}$/u
+var S_DOLLAR_UNICODE_REGEX = new RegExp(S_UNICODE_REGEX.source + "$");
+var CLDR_NUMBER_PATTERN = /[#0](?:[\.,][#0]+)*/g;
+export default function formatToParts(numberResult, data, pl, options) {
+    var sign = numberResult.sign, exponent = numberResult.exponent, magnitude = numberResult.magnitude;
+    var notation = options.notation, style = options.style, numberingSystem = options.numberingSystem;
+    var defaultNumberingSystem = data.numbers.nu[0];
+    // #region Part 1: partition and interpolate the CLDR number pattern.
+    // ----------------------------------------------------------
+    var compactNumberPattern = null;
+    if (notation === 'compact' && magnitude) {
+        compactNumberPattern = getCompactDisplayPattern(numberResult, pl, data, style, options.compactDisplay, options.currencyDisplay, numberingSystem);
+    }
+    // This is used multiple times
+    var nonNameCurrencyPart;
+    if (style === 'currency' && options.currencyDisplay !== 'name') {
+        var byCurrencyDisplay = data.currencies[options.currency];
+        if (byCurrencyDisplay) {
+            switch (options.currencyDisplay) {
+                case 'code':
+                    nonNameCurrencyPart = options.currency;
+                    break;
+                case 'symbol':
+                    nonNameCurrencyPart = byCurrencyDisplay.symbol;
+                    break;
+                default:
+                    nonNameCurrencyPart = byCurrencyDisplay.narrow;
+                    break;
+            }
+        }
+        else {
+            // Fallback for unknown currency
+            nonNameCurrencyPart = options.currency;
+        }
+    }
+    var numberPattern;
+    if (!compactNumberPattern) {
+        // Note: if the style is unit, or is currency and the currency display is name,
+        // its unit parts will be interpolated in part 2. So here we can fallback to decimal.
+        if (style === 'decimal' ||
+            style === 'unit' ||
+            (style === 'currency' && options.currencyDisplay === 'name')) {
+            // Shortcut for decimal
+            var decimalData = data.numbers.decimal[numberingSystem] ||
+                data.numbers.decimal[defaultNumberingSystem];
+            numberPattern = getPatternForSign(decimalData.standard, sign);
+        }
+        else if (style === 'currency') {
+            var currencyData = data.numbers.currency[numberingSystem] ||
+                data.numbers.currency[defaultNumberingSystem];
+            // We replace number pattern part with `0` for easier postprocessing.
+            numberPattern = getPatternForSign(currencyData[options.currencySign], sign);
+        }
+        else {
+            // percent
+            var percentPattern = data.numbers.percent[numberingSystem] ||
+                data.numbers.percent[defaultNumberingSystem];
+            numberPattern = getPatternForSign(percentPattern, sign);
+        }
+    }
+    else {
+        numberPattern = compactNumberPattern;
+    }
+    // Extract the decimal number pattern string. It looks like "#,##0,00", which will later be
+    // used to infer decimal group sizes.
+    var decimalNumberPattern = CLDR_NUMBER_PATTERN.exec(numberPattern)[0];
+    // Now we start to substitute patterns
+    // 1. replace strings like `0` and `#,##0.00` with `{0}`
+    // 2. unquote characters (invariant: the quoted characters does not contain the special tokens)
+    numberPattern = numberPattern
+        .replace(CLDR_NUMBER_PATTERN, '{0}')
+        .replace(/'(.)'/g, '$1');
+    // Handle currency spacing (both compact and non-compact).
+    if (style === 'currency' && options.currencyDisplay !== 'name') {
+        var currencyData = data.numbers.currency[numberingSystem] ||
+            data.numbers.currency[defaultNumberingSystem];
+        // See `currencySpacing` substitution rule in TR-35.
+        // Here we always assume the currencyMatch is "[:^S:]" and surroundingMatch is "[:digit:]".
+        //
+        // Example 1: for pattern "#,##0.00¤" with symbol "US$", we replace "¤" with the symbol,
+        // but insert an extra non-break space before the symbol, because "[:^S:]" matches "U" in
+        // "US$" and "[:digit:]" matches the latn numbering system digits.
+        //
+        // Example 2: for pattern "¤#,##0.00" with symbol "US$", there is no spacing between symbol
+        // and number, because `$` does not match "[:^S:]".
+        //
+        // Implementation note: here we do the best effort to infer the insertion.
+        // We also assume that `beforeInsertBetween` and `afterInsertBetween` will never be `;`.
+        var afterCurrency = currencyData.currencySpacing.afterInsertBetween;
+        if (afterCurrency && !S_DOLLAR_UNICODE_REGEX.test(nonNameCurrencyPart)) {
+            numberPattern = numberPattern.replace('¤{0}', "\u00A4" + afterCurrency + "{0}");
+        }
+        var beforeCurrency = currencyData.currencySpacing.beforeInsertBetween;
+        if (beforeCurrency && !CARET_S_UNICODE_REGEX.test(nonNameCurrencyPart)) {
+            numberPattern = numberPattern.replace('{0}¤', "{0}" + beforeCurrency + "\u00A4");
+        }
+    }
+    // The following tokens are special: `{0}`, `¤`, `%`, `-`, `+`, `{c:...}.
+    var numberPatternParts = numberPattern.split(/({c:[^}]+}|\{0\}|[¤%\-\+])/g);
+    var numberParts = [];
+    var symbols = data.numbers.symbols[numberingSystem] ||
+        data.numbers.symbols[defaultNumberingSystem];
+    for (var _i = 0, numberPatternParts_1 = numberPatternParts; _i < numberPatternParts_1.length; _i++) {
+        var part = numberPatternParts_1[_i];
+        if (!part) {
+            continue;
+        }
+        switch (part) {
+            case '{0}': {
+                // We only need to handle scientific and engineering notation here.
+                numberParts.push.apply(numberParts, paritionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, 
+                // If compact number pattern exists, do not insert group separators.
+                !compactNumberPattern && options.useGrouping, decimalNumberPattern));
+                break;
+            }
+            case '-':
+                numberParts.push({ type: 'minusSign', value: symbols.minusSign });
+                break;
+            case '+':
+                numberParts.push({ type: 'plusSign', value: symbols.plusSign });
+                break;
+            case '%':
+                numberParts.push({ type: 'percentSign', value: symbols.percentSign });
+                break;
+            case '¤':
+                // Computed above when handling currency spacing.
+                numberParts.push({ type: 'currency', value: nonNameCurrencyPart });
+                break;
+            default:
+                if (/^\{c:/.test(part)) {
+                    numberParts.push({
+                        type: 'compact',
+                        value: part.substring(3, part.length - 1),
+                    });
+                }
+                else {
+                    // literal
+                    numberParts.push({ type: 'literal', value: part });
+                }
+                break;
+        }
+    }
+    // #endregion
+    // #region Part 2: interpolate unit pattern if necessary.
+    // ----------------------------------------------
+    switch (style) {
+        case 'currency': {
+            // `currencyDisplay: 'name'` has similar pattern handling as units.
+            if (options.currencyDisplay === 'name') {
+                var unitPattern = (data.numbers.currency[numberingSystem] ||
+                    data.numbers.currency[defaultNumberingSystem]).unitPattern;
+                // Select plural
+                var unitName = void 0;
+                var currencyNameData = data.currencies[options.currency];
+                if (currencyNameData) {
+                    unitName = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), currencyNameData.displayName);
+                }
+                else {
+                    // Fallback for unknown currency
+                    unitName = options.currency;
+                }
+                // Do {0} and {1} substitution
+                var unitPatternParts = unitPattern.split(/(\{[01]\})/g);
+                var result = [];
+                for (var _a = 0, unitPatternParts_1 = unitPatternParts; _a < unitPatternParts_1.length; _a++) {
+                    var part = unitPatternParts_1[_a];
+                    switch (part) {
+                        case '{0}':
+                            result.push.apply(result, numberParts);
+                            break;
+                        case '{1}':
+                            result.push({ type: 'currency', value: unitName });
+                            break;
+                        default:
+                            if (part) {
+                                result.push({ type: 'literal', value: part });
+                            }
+                            break;
+                    }
+                }
+                return result;
+            }
+            else {
+                return numberParts;
+            }
+        }
+        case 'unit': {
+            var unit = options.unit, unitDisplay = options.unitDisplay;
+            var unitData = data.units.simple[unit];
+            var unitPattern = void 0;
+            if (unitData) {
+                // Simple unit pattern
+                unitPattern = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), data.units.simple[unit][unitDisplay]);
+            }
+            else {
+                // See: http://unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
+                // If cannot find unit in the simple pattern, it must be "per" compound pattern.
+                // Implementation note: we are not following TR-35 here because we need to format to parts!
+                var _b = unit.split('-per-'), numeratorUnit = _b[0], denominatorUnit = _b[1];
+                unitData = data.units.simple[numeratorUnit];
+                var numeratorUnitPattern = selectPlural(pl, numberResult.roundedNumber * Math.pow(10, exponent), data.units.simple[numeratorUnit][unitDisplay]);
+                var perUnitPattern = data.units.simple[denominatorUnit].perUnit[unitDisplay];
+                if (perUnitPattern) {
+                    // perUnitPattern exists, combine it with numeratorUnitPattern
+                    unitPattern = perUnitPattern.replace('{0}', numeratorUnitPattern);
+                }
+                else {
+                    // get compoundUnit pattern (e.g. "{0} per {1}"), repalce {0} with numerator pattern and {1} with
+                    // the denominator pattern in singular form.
+                    var perPattern = data.units.compound.per[unitDisplay];
+                    var denominatorPattern = selectPlural(pl, 1, data.units.simple[denominatorUnit][unitDisplay]);
+                    unitPattern = unitPattern = perPattern
+                        .replace('{0}', numeratorUnitPattern)
+                        .replace('{1}', denominatorPattern.replace('{0}', ''));
+                }
+            }
+            var result = [];
+            // We need spacing around "{0}" because they are not treated as "unit" parts, but "literal".
+            for (var _c = 0, _d = unitPattern.split(/(\s*\{0\}\s*)/); _c < _d.length; _c++) {
+                var part = _d[_c];
+                var interpolateMatch = /^(\s*)\{0\}(\s*)$/.exec(part);
+                if (interpolateMatch) {
+                    // Space before "{0}"
+                    if (interpolateMatch[1]) {
+                        result.push({ type: 'literal', value: interpolateMatch[1] });
+                    }
+                    // "{0}" itself
+                    result.push.apply(result, numberParts);
+                    // Space after "{0}"
+                    if (interpolateMatch[2]) {
+                        result.push({ type: 'literal', value: interpolateMatch[2] });
+                    }
+                }
+                else if (part) {
+                    result.push({ type: 'unit', value: part });
+                }
+            }
+            return result;
+        }
+        default:
+            return numberParts;
+    }
+    // #endregion
+}
+// A subset of https://tc39.es/ecma402/#sec-partitionnotationsubpattern
+// Plus the exponent parts handling.
+function paritionNumberIntoParts(symbols, numberResult, notation, exponent, numberingSystem, useGrouping, 
+/**
+ * This is the decimal number pattern without signs or symbols.
+ * It is used to infer the group size when `useGrouping` is true.
+ *
+ * A typical value looks like "#,##0.00" (primary group size is 3).
+ * Some locales like Hindi has secondary group size of 2 (e.g. "#,##,##0.00").
+ */
+decimalNumberPattern) {
+    var result = [];
+    // eslint-disable-next-line prefer-const
+    var n = numberResult.formattedString, x = numberResult.roundedNumber;
+    if (isNaN(x)) {
+        return [{ type: 'nan', value: n }];
+    }
+    else if (!isFinite(x)) {
+        return [{ type: 'infinity', value: n }];
+    }
+    var digitReplacementTable = digitMapping[numberingSystem];
+    if (digitReplacementTable) {
+        n = n.replace(/\d/g, function (digit) { return digitReplacementTable[+digit] || digit; });
+    }
+    // TODO: Else use an implementation dependent algorithm to map n to the appropriate
+    // representation of n in the given numbering system.
+    var decimalSepIndex = n.indexOf('.');
+    var integer;
+    var fraction;
+    if (decimalSepIndex > 0) {
+        integer = n.slice(0, decimalSepIndex);
+        fraction = n.slice(decimalSepIndex + 1);
+    }
+    else {
+        integer = n;
+    }
+    // #region Grouping integer digits
+    // The weird compact and x >= 10000 check is to ensure consistency with Node.js and Chrome.
+    // Note that `de` does not have compact form for thousands, but Node.js does not insert grouping separator
+    // unless the rounded number is greater than 10000:
+    //   NumberFormat('de', {notation: 'compact', compactDisplay: 'short'}).format(1234) //=> "1234"
+    //   NumberFormat('de').format(1234) //=> "1.234"
+    if (useGrouping && (notation !== 'compact' || x >= 10000)) {
+        var groupSepSymbol = symbols.group;
+        var groups = [];
+        // > There may be two different grouping sizes: The primary grouping size used for the least
+        // > significant integer group, and the secondary grouping size used for more significant groups.
+        // > If a pattern contains multiple grouping separators, the interval between the last one and the
+        // > end of the integer defines the primary grouping size, and the interval between the last two
+        // > defines the secondary grouping size. All others are ignored.
+        var integerNumberPattern = decimalNumberPattern.split('.')[0];
+        var patternGroups = integerNumberPattern.split(',');
+        var primaryGroupingSize = 3;
+        var secondaryGroupingSize = 3;
+        if (patternGroups.length > 1) {
+            primaryGroupingSize = patternGroups[patternGroups.length - 1].length;
+        }
+        if (patternGroups.length > 2) {
+            secondaryGroupingSize = patternGroups[patternGroups.length - 2].length;
+        }
+        var i = integer.length - primaryGroupingSize;
+        if (i > 0) {
+            // Slice the least significant integer group
+            groups.push(integer.slice(i, i + primaryGroupingSize));
+            // Then iteratively push the more signicant groups
+            // TODO: handle surrogate pairs in some numbering system digits
+            for (i -= secondaryGroupingSize; i > 0; i -= secondaryGroupingSize) {
+                groups.push(integer.slice(i, i + secondaryGroupingSize));
+            }
+            groups.push(integer.slice(0, i + secondaryGroupingSize));
+        }
+        else {
+            groups.push(integer);
+        }
+        while (groups.length > 0) {
+            var integerGroup = groups.pop();
+            result.push({ type: 'integer', value: integerGroup });
+            if (groups.length > 0) {
+                result.push({ type: 'group', value: groupSepSymbol });
+            }
+        }
+    }
+    else {
+        result.push({ type: 'integer', value: integer });
+    }
+    // #endregion
+    if (fraction !== undefined) {
+        result.push({ type: 'decimal', value: symbols.decimal }, { type: 'fraction', value: fraction });
+    }
+    if ((notation === 'scientific' || notation === 'engineering') &&
+        isFinite(x)) {
+        result.push({ type: 'exponentSeparator', value: symbols.exponential });
+        if (exponent < 0) {
+            result.push({ type: 'exponentMinusSign', value: symbols.minusSign });
+            exponent = -exponent;
+        }
+        var exponentResult = ToRawFixed(exponent, 0, 0);
+        result.push({
+            type: 'exponentInteger',
+            value: exponentResult.formattedString,
+        });
+    }
+    return result;
+}
+function getPatternForSign(pattern, sign) {
+    if (pattern.indexOf(';') < 0) {
+        pattern = pattern + ";-" + pattern;
+    }
+    var _a = pattern.split(';'), zeroPattern = _a[0], negativePattern = _a[1];
+    switch (sign) {
+        case 0:
+            return zeroPattern;
+        case -1:
+            return negativePattern;
+        default:
+            return negativePattern.indexOf('-') >= 0
+                ? negativePattern.replace(/-/g, '+')
+                : "+" + zeroPattern;
+    }
+}
+// Find the CLDR pattern for compact notation based on the magnitude of data and style.
+//
+// Example return value: "¤ {c:laki}000;¤{c:laki} -0" (`sw` locale):
+// - Notice the `{c:...}` token that wraps the compact literal.
+// - The consecutive zeros are normalized to single zero to match CLDR_NUMBER_PATTERN.
+//
+// Returning null means the compact display pattern cannot be found.
+function getCompactDisplayPattern(numberResult, pl, data, style, compactDisplay, currencyDisplay, numberingSystem) {
+    var _a;
+    var roundedNumber = numberResult.roundedNumber, sign = numberResult.sign, magnitude = numberResult.magnitude;
+    var magnitudeKey = String(Math.pow(10, magnitude));
+    var defaultNumberingSystem = data.numbers.nu[0];
+    var pattern;
+    if (style === 'currency' && currencyDisplay !== 'name') {
+        var byNumberingSystem = data.numbers.currency;
+        var currencyData = byNumberingSystem[numberingSystem] ||
+            byNumberingSystem[defaultNumberingSystem];
+        // NOTE: compact notation ignores currencySign!
+        var compactPluralRules = (_a = currencyData.short) === null || _a === void 0 ? void 0 : _a[magnitudeKey];
+        if (!compactPluralRules) {
+            return null;
+        }
+        pattern = selectPlural(pl, roundedNumber, compactPluralRules);
+    }
+    else {
+        var byNumberingSystem = data.numbers.decimal;
+        var byCompactDisplay = byNumberingSystem[numberingSystem] ||
+            byNumberingSystem[defaultNumberingSystem];
+        var compactPlaralRule = byCompactDisplay[compactDisplay][magnitudeKey];
+        if (!compactPlaralRule) {
+            return null;
+        }
+        pattern = selectPlural(pl, roundedNumber, compactPlaralRule);
+    }
+    // See https://unicode.org/reports/tr35/tr35-numbers.html#Compact_Number_Formats
+    // > If the value is precisely “0”, either explicit or defaulted, then the normal number format
+    // > pattern for that sort of object is supplied.
+    if (pattern === '0') {
+        return null;
+    }
+    pattern = getPatternForSign(pattern, sign)
+        // Extract compact literal from the pattern
+        .replace(/([^\s;\-\+\d¤]+)/g, '{c:$1}')
+        // We replace one or more zeros with a single zero so it matches `CLDR_NUMBER_PATTERN`.
+        .replace(/0+/, '0');
+    return pattern;
+}
+function selectPlural(pl, x, rules) {
+    return rules[pl.select(x)] || rules.other;
+}

package/lib/src/PluralRules/GetOperands.d.ts

@@ -0,0 +1,32 @@
+export interface OperandsRecord {
+    /**
+     * Absolute value of the source number (integer and decimals)
+     */
+    Number: number;
+    /**
+     * Number of digits of `number`
+     */
+    IntegerDigits: number;
+    /**
+     * Number of visible fraction digits in [[Number]], with trailing zeroes.
+     */
+    NumberOfFractionDigits: number;
+    /**
+     * Number of visible fraction digits in [[Number]], without trailing zeroes.
+     */
+    NumberOfFractionDigitsWithoutTrailing: number;
+    /**
+     * Number of visible fractional digits in [[Number]], with trailing zeroes.
+     */
+    FractionDigits: number;
+    /**
+     * Number of visible fractional digits in [[Number]], without trailing zeroes.
+     */
+    FractionDigitsWithoutTrailing: number;
+}
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-getoperands
+ * @param s
+ */
+export declare function GetOperands(s: string): OperandsRecord;
+//# sourceMappingURL=GetOperands.d.ts.map

package/lib/src/PluralRules/GetOperands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetOperands.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/PluralRules/GetOperands.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;OAEG;IACH,qCAAqC,EAAE,MAAM,CAAC;IAC9C;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,6BAA6B,EAAE,MAAM,CAAC;CACvC;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,cAAc,CAyCrD"}

package/lib/src/PluralRules/GetOperands.js

@@ -0,0 +1,47 @@
+import { invariant } from '../utils';
+import { ToNumber } from '../../262';
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-getoperands
+ * @param s
+ */
+export function GetOperands(s) {
+    invariant(typeof s === 'string', "GetOperands should have been called with a string");
+    var n = ToNumber(s);
+    invariant(isFinite(n), 'n should be finite');
+    var dp = s.indexOf('.');
+    var iv;
+    var f;
+    var v;
+    var fv = '';
+    if (dp === -1) {
+        iv = n;
+        f = 0;
+        v = 0;
+    }
+    else {
+        iv = s.slice(0, dp);
+        fv = s.slice(dp, s.length);
+        f = ToNumber(fv);
+        v = fv.length;
+    }
+    var i = Math.abs(ToNumber(iv));
+    var w;
+    var t;
+    if (f !== 0) {
+        var ft = fv.replace(/0+$/, '');
+        w = ft.length;
+        t = ToNumber(ft);
+    }
+    else {
+        w = 0;
+        t = 0;
+    }
+    return {
+        Number: n,
+        IntegerDigits: i,
+        NumberOfFractionDigits: v,
+        NumberOfFractionDigitsWithoutTrailing: w,
+        FractionDigits: f,
+        FractionDigitsWithoutTrailing: t,
+    };
+}

package/lib/src/PluralRules/InitializePluralRules.d.ts

@@ -0,0 +1,9 @@
+import { PluralRulesInternal, PluralRulesData } from '../../types/plural-rules';
+export declare function InitializePluralRules(pl: Intl.PluralRules, locales: string | string[] | undefined, options: Intl.PluralRulesOptions | undefined, { availableLocales, relevantExtensionKeys, localeData, getDefaultLocale, getInternalSlots, }: {
+    availableLocales: string[];
+    relevantExtensionKeys: string[];
+    localeData: Record<string, PluralRulesData>;
+    getDefaultLocale(): string;
+    getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
+}): Intl.PluralRules;
+//# sourceMappingURL=InitializePluralRules.d.ts.map

package/lib/src/PluralRules/InitializePluralRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializePluralRules.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/PluralRules/InitializePluralRules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAE,eAAe,EAAC,MAAM,0BAA0B,CAAC;AAO9E,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,IAAI,CAAC,WAAW,EACpB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EACtC,OAAO,EAAE,IAAI,CAAC,kBAAkB,GAAG,SAAS,EAC5C,EACE,gBAAgB,EAChB,qBAAqB,EACrB,UAAU,EACV,gBAAgB,EAChB,gBAAgB,GACjB,EAAE;IACD,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC5C,gBAAgB,IAAI,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,GAAG,mBAAmB,CAAC;CAC7D,oBAkCF"}

package/lib/src/PluralRules/InitializePluralRules.js

@@ -0,0 +1,20 @@
+import { CanonicalizeLocaleList } from '../CanonicalizeLocaleList';
+import { ToObject } from '../../262';
+import { GetOption } from '../GetOption';
+import { SetNumberFormatDigitOptions } from '../NumberFormat/SetNumberFormatDigitOptions';
+import { ResolveLocale } from '../ResolveLocale';
+export function InitializePluralRules(pl, locales, options, _a) {
+    var availableLocales = _a.availableLocales, relevantExtensionKeys = _a.relevantExtensionKeys, localeData = _a.localeData, getDefaultLocale = _a.getDefaultLocale, getInternalSlots = _a.getInternalSlots;
+    var requestedLocales = CanonicalizeLocaleList(locales);
+    var opt = Object.create(null);
+    var opts = options === undefined ? Object.create(null) : ToObject(options);
+    var internalSlots = getInternalSlots(pl);
+    internalSlots.initializedPluralRules = true;
+    var matcher = GetOption(opts, 'localeMatcher', 'string', ['best fit', 'lookup'], 'best fit');
+    opt.localeMatcher = matcher;
+    internalSlots.type = GetOption(opts, 'type', 'string', ['cardinal', 'ordinal'], 'cardinal');
+    SetNumberFormatDigitOptions(internalSlots, opts, 0, 3, 'standard');
+    var r = ResolveLocale(availableLocales, requestedLocales, opt, relevantExtensionKeys, localeData, getDefaultLocale);
+    internalSlots.locale = r.locale;
+    return pl;
+}

package/lib/src/PluralRules/ResolvePlural.d.ts

@@ -0,0 +1,13 @@
+import { LDMLPluralRule, PluralRulesInternal } from '../../types/plural-rules';
+import { OperandsRecord } from './GetOperands';
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
+ * @param pl
+ * @param n
+ * @param PluralRuleSelect Has to pass in bc it's implementation-specific
+ */
+export declare function ResolvePlural(pl: Intl.PluralRules, n: number, { getInternalSlots, PluralRuleSelect, }: {
+    getInternalSlots(pl: Intl.PluralRules): PluralRulesInternal;
+    PluralRuleSelect: (locale: string, type: 'cardinal' | 'ordinal', n: number, operands: OperandsRecord) => LDMLPluralRule;
+}): LDMLPluralRule;
+//# sourceMappingURL=ResolvePlural.d.ts.map

package/lib/src/PluralRules/ResolvePlural.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResolvePlural.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/PluralRules/ResolvePlural.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,0BAA0B,CAAC;AAE7E,OAAO,EAAc,cAAc,EAAC,MAAM,eAAe,CAAC;AAE1D;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,IAAI,CAAC,WAAW,EACpB,CAAC,EAAE,MAAM,EACT,EACE,gBAAgB,EAChB,gBAAgB,GACjB,EAAE;IACD,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,GAAG,mBAAmB,CAAC;IAC5D,gBAAgB,EAAE,CAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,cAAc,KACrB,cAAc,CAAC;CACrB,GACA,cAAc,CAgBhB"}

package/lib/src/PluralRules/ResolvePlural.js

@@ -0,0 +1,25 @@
+import { invariant } from '../utils';
+import { Type } from '../../262';
+import { FormatNumericToString } from '../NumberFormat/FormatNumericToString';
+import { GetOperands } from './GetOperands';
+/**
+ * http://ecma-international.org/ecma-402/7.0/index.html#sec-resolveplural
+ * @param pl
+ * @param n
+ * @param PluralRuleSelect Has to pass in bc it's implementation-specific
+ */
+export function ResolvePlural(pl, n, _a) {
+    var getInternalSlots = _a.getInternalSlots, PluralRuleSelect = _a.PluralRuleSelect;
+    var internalSlots = getInternalSlots(pl);
+    invariant(Type(internalSlots) === 'Object', 'pl has to be an object');
+    invariant('initializedPluralRules' in internalSlots, 'pluralrules must be initialized');
+    invariant(Type(n) === 'Number', 'n must be a number');
+    if (!isFinite(n)) {
+        return 'other';
+    }
+    var locale = internalSlots.locale, type = internalSlots.type;
+    var res = FormatNumericToString(internalSlots, n);
+    var s = res.formattedString;
+    var operands = GetOperands(s);
+    return PluralRuleSelect(locale, type, n, operands);
+}

package/lib/src/RelativeTimeFormat/FormatRelativeTime.d.ts

@@ -0,0 +1,5 @@
+import { RelativeTimeFormat, RelativeTimeFormattableUnit, RelativeTimeFormatInternal } from '../../types/relative-time';
+export declare function FormatRelativeTime(rtf: RelativeTimeFormat, value: number, unit: RelativeTimeFormattableUnit, implDetails: {
+    getInternalSlots(rtf: RelativeTimeFormat): RelativeTimeFormatInternal;
+}): string;
+//# sourceMappingURL=FormatRelativeTime.d.ts.map

package/lib/src/RelativeTimeFormat/FormatRelativeTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormatRelativeTime.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/RelativeTimeFormat/FormatRelativeTime.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,0BAA0B,EAC3B,MAAM,2BAA2B,CAAC;AAGnC,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,kBAAkB,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,2BAA2B,EACjC,WAAW,EAAE;IACX,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,GAAG,0BAA0B,CAAC;CACvE,GACA,MAAM,CAOR"}

package/lib/src/RelativeTimeFormat/FormatRelativeTime.js

@@ -0,0 +1,10 @@
+import { PartitionRelativeTimePattern } from './PartitionRelativeTimePattern';
+export function FormatRelativeTime(rtf, value, unit, implDetails) {
+    var parts = PartitionRelativeTimePattern(rtf, value, unit, implDetails);
+    var result = '';
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        result += part.value;
+    }
+    return result;
+}

package/lib/src/RelativeTimeFormat/FormatRelativeTimeToParts.d.ts

@@ -0,0 +1,5 @@
+import { RelativeTimeFormat, RelativeTimeFormattableUnit, RelativeTimePart, RelativeTimeFormatInternal } from '../../types/relative-time';
+export declare function FormatRelativeTimeToParts(rtf: RelativeTimeFormat, value: number, unit: RelativeTimeFormattableUnit, implDetails: {
+    getInternalSlots(rtf: RelativeTimeFormat): RelativeTimeFormatInternal;
+}): RelativeTimePart[];
+//# sourceMappingURL=FormatRelativeTimeToParts.d.ts.map

package/lib/src/RelativeTimeFormat/FormatRelativeTimeToParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormatRelativeTimeToParts.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/RelativeTimeFormat/FormatRelativeTimeToParts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,gBAAgB,EAChB,0BAA0B,EAE3B,MAAM,2BAA2B,CAAC;AAInC,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,kBAAkB,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,2BAA2B,EACjC,WAAW,EAAE;IACX,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,GAAG,0BAA0B,CAAC;CACvE,GACA,gBAAgB,EAAE,CAepB"}

package/lib/src/RelativeTimeFormat/FormatRelativeTimeToParts.js

@@ -0,0 +1,18 @@
+import { PartitionRelativeTimePattern } from './PartitionRelativeTimePattern';
+import { ArrayCreate } from '../../262';
+export function FormatRelativeTimeToParts(rtf, value, unit, implDetails) {
+    var parts = PartitionRelativeTimePattern(rtf, value, unit, implDetails);
+    var result = ArrayCreate(0);
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        var o = {
+            type: part.type,
+            value: part.value,
+        };
+        if ('unit' in part) {
+            o.unit = part.unit;
+        }
+        result.push(o);
+    }
+    return result;
+}

package/lib/src/RelativeTimeFormat/InitializeRelativeTimeFormat.d.ts

@@ -0,0 +1,9 @@
+import { RelativeTimeFormat, IntlRelativeTimeFormatOptions, RelativeTimeFormatInternal, LocaleFieldsData } from '../../types/relative-time';
+export declare function InitializeRelativeTimeFormat(rtf: RelativeTimeFormat, locales: string | string[] | undefined, options: IntlRelativeTimeFormatOptions | undefined, { getInternalSlots, availableLocales, relevantExtensionKeys, localeData, getDefaultLocale, }: {
+    getInternalSlots(rtf: RelativeTimeFormat): RelativeTimeFormatInternal;
+    availableLocales: string[];
+    relevantExtensionKeys: string[];
+    localeData: Record<string, LocaleFieldsData>;
+    getDefaultLocale(): string;
+}): RelativeTimeFormat;
+//# sourceMappingURL=InitializeRelativeTimeFormat.d.ts.map

package/lib/src/RelativeTimeFormat/InitializeRelativeTimeFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializeRelativeTimeFormat.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/ecma402-abstract/src/RelativeTimeFormat/InitializeRelativeTimeFormat.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,6BAA6B,EAC7B,0BAA0B,EAC1B,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAQnC,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,kBAAkB,EACvB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,EACtC,OAAO,EAAE,6BAA6B,GAAG,SAAS,EAClD,EACE,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,UAAU,EACV,gBAAgB,GACjB,EAAE;IACD,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,GAAG,0BAA0B,CAAC;IACtE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,gBAAgB,IAAI,MAAM,CAAC;CAC5B,sBAyDF"}