{"version":3,"file":"5931.0e281cf29b101b30e623.js","mappings":"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","sources":["webpack:///../node_modules/@formatjs/icu-skeleton-parser/lib/date-time.js","webpack:///../node_modules/@formatjs/icu-skeleton-parser/lib/regex.generated.js","webpack:///../node_modules/@formatjs/icu-skeleton-parser/lib/number.js"],"sourcesContent":["/**\n * https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n * Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js\n * with some tweaks\n */\nvar DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;\n/**\n * Parse Date time skeleton into Intl.DateTimeFormatOptions\n * Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n * @public\n * @param skeleton skeleton string\n */\nexport function parseDateTimeSkeleton(skeleton) {\n    var result = {};\n    skeleton.replace(DATE_TIME_REGEX, function (match) {\n        var len = match.length;\n        switch (match[0]) {\n            // Era\n            case 'G':\n                result.era = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';\n                break;\n            // Year\n            case 'y':\n                result.year = len === 2 ? '2-digit' : 'numeric';\n                break;\n            case 'Y':\n            case 'u':\n            case 'U':\n            case 'r':\n                throw new RangeError('`Y/u/U/r` (year) patterns are not supported, use `y` instead');\n            // Quarter\n            case 'q':\n            case 'Q':\n                throw new RangeError('`q/Q` (quarter) patterns are not supported');\n            // Month\n            case 'M':\n            case 'L':\n                result.month = ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1];\n                break;\n            // Week\n            case 'w':\n            case 'W':\n                throw new RangeError('`w/W` (week) patterns are not supported');\n            case 'd':\n                result.day = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'D':\n            case 'F':\n            case 'g':\n                throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');\n            // Weekday\n            case 'E':\n                result.weekday = len === 4 ? 'short' : len === 5 ? 'narrow' : 'short';\n                break;\n            case 'e':\n                if (len < 4) {\n                    throw new RangeError('`e..eee` (weekday) patterns are not supported');\n                }\n                result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];\n                break;\n            case 'c':\n                if (len < 4) {\n                    throw new RangeError('`c..ccc` (weekday) patterns are not supported');\n                }\n                result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];\n                break;\n            // Period\n            case 'a': // AM, PM\n                result.hour12 = true;\n                break;\n            case 'b': // am, pm, noon, midnight\n            case 'B': // flexible day periods\n                throw new RangeError('`b/B` (period) patterns are not supported, use `a` instead');\n            // Hour\n            case 'h':\n                result.hourCycle = 'h12';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'H':\n                result.hourCycle = 'h23';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'K':\n                result.hourCycle = 'h11';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'k':\n                result.hourCycle = 'h24';\n                result.hour = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'j':\n            case 'J':\n            case 'C':\n                throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');\n            // Minute\n            case 'm':\n                result.minute = ['numeric', '2-digit'][len - 1];\n                break;\n            // Second\n            case 's':\n                result.second = ['numeric', '2-digit'][len - 1];\n                break;\n            case 'S':\n            case 'A':\n                throw new RangeError('`S/A` (second) patterns are not supported, use `s` instead');\n            // Zone\n            case 'z': // 1..3, 4: specific non-location format\n                result.timeZoneName = len < 4 ? 'short' : 'long';\n                break;\n            case 'Z': // 1..3, 4, 5: The ISO8601 varios formats\n            case 'O': // 1, 4: miliseconds in day short, long\n            case 'v': // 1, 4: generic non-location format\n            case 'V': // 1, 2, 3, 4: time zone ID or city\n            case 'X': // 1, 2, 3, 4: The ISO8601 varios formats\n            case 'x': // 1, 2, 3, 4: The ISO8601 varios formats\n                throw new RangeError('`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead');\n        }\n        return '';\n    });\n    return result;\n}\n","// @generated from regex-gen.ts\nexport var WHITE_SPACE_REGEX = /[\\t-\\r \\x85\\u200E\\u200F\\u2028\\u2029]/i;\n","import { __assign } from \"tslib\";\nimport { WHITE_SPACE_REGEX } from './regex.generated';\nexport function parseNumberSkeletonFromString(skeleton) {\n    if (skeleton.length === 0) {\n        throw new Error('Number skeleton cannot be empty');\n    }\n    // Parse the skeleton\n    var stringTokens = skeleton\n        .split(WHITE_SPACE_REGEX)\n        .filter(function (x) { return x.length > 0; });\n    var tokens = [];\n    for (var _i = 0, stringTokens_1 = stringTokens; _i < stringTokens_1.length; _i++) {\n        var stringToken = stringTokens_1[_i];\n        var stemAndOptions = stringToken.split('/');\n        if (stemAndOptions.length === 0) {\n            throw new Error('Invalid number skeleton');\n        }\n        var stem = stemAndOptions[0], options = stemAndOptions.slice(1);\n        for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {\n            var option = options_1[_a];\n            if (option.length === 0) {\n                throw new Error('Invalid number skeleton');\n            }\n        }\n        tokens.push({ stem: stem, options: options });\n    }\n    return tokens;\n}\nfunction icuUnitToEcma(unit) {\n    return unit.replace(/^(.*?)-/, '');\n}\nvar FRACTION_PRECISION_REGEX = /^\\.(?:(0+)(\\*)?|(#+)|(0+)(#+))$/g;\nvar SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\\+|#+)?[rs]?$/g;\nvar INTEGER_WIDTH_REGEX = /(\\*)(0+)|(#+)(0+)|(0+)/g;\nvar CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;\nfunction parseSignificantPrecision(str) {\n    var result = {};\n    if (str[str.length - 1] === 'r') {\n        result.roundingPriority = 'morePrecision';\n    }\n    else if (str[str.length - 1] === 's') {\n        result.roundingPriority = 'lessPrecision';\n    }\n    str.replace(SIGNIFICANT_PRECISION_REGEX, function (_, g1, g2) {\n        // @@@ case\n        if (typeof g2 !== 'string') {\n            result.minimumSignificantDigits = g1.length;\n            result.maximumSignificantDigits = g1.length;\n        }\n        // @@@+ case\n        else if (g2 === '+') {\n            result.minimumSignificantDigits = g1.length;\n        }\n        // .### case\n        else if (g1[0] === '#') {\n            result.maximumSignificantDigits = g1.length;\n        }\n        // .@@## or .@@@ case\n        else {\n            result.minimumSignificantDigits = g1.length;\n            result.maximumSignificantDigits =\n                g1.length + (typeof g2 === 'string' ? g2.length : 0);\n        }\n        return '';\n    });\n    return result;\n}\nfunction parseSign(str) {\n    switch (str) {\n        case 'sign-auto':\n            return {\n                signDisplay: 'auto',\n            };\n        case 'sign-accounting':\n        case '()':\n            return {\n                currencySign: 'accounting',\n            };\n        case 'sign-always':\n        case '+!':\n            return {\n                signDisplay: 'always',\n            };\n        case 'sign-accounting-always':\n        case '()!':\n            return {\n                signDisplay: 'always',\n                currencySign: 'accounting',\n            };\n        case 'sign-except-zero':\n        case '+?':\n            return {\n                signDisplay: 'exceptZero',\n            };\n        case 'sign-accounting-except-zero':\n        case '()?':\n            return {\n                signDisplay: 'exceptZero',\n                currencySign: 'accounting',\n            };\n        case 'sign-never':\n        case '+_':\n            return {\n                signDisplay: 'never',\n            };\n    }\n}\nfunction parseConciseScientificAndEngineeringStem(stem) {\n    // Engineering\n    var result;\n    if (stem[0] === 'E' && stem[1] === 'E') {\n        result = {\n            notation: 'engineering',\n        };\n        stem = stem.slice(2);\n    }\n    else if (stem[0] === 'E') {\n        result = {\n            notation: 'scientific',\n        };\n        stem = stem.slice(1);\n    }\n    if (result) {\n        var signDisplay = stem.slice(0, 2);\n        if (signDisplay === '+!') {\n            result.signDisplay = 'always';\n            stem = stem.slice(2);\n        }\n        else if (signDisplay === '+?') {\n            result.signDisplay = 'exceptZero';\n            stem = stem.slice(2);\n        }\n        if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) {\n            throw new Error('Malformed concise eng/scientific notation');\n        }\n        result.minimumIntegerDigits = stem.length;\n    }\n    return result;\n}\nfunction parseNotationOptions(opt) {\n    var result = {};\n    var signOpts = parseSign(opt);\n    if (signOpts) {\n        return signOpts;\n    }\n    return result;\n}\n/**\n * https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#skeleton-stems-and-options\n */\nexport function parseNumberSkeleton(tokens) {\n    var result = {};\n    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {\n        var token = tokens_1[_i];\n        switch (token.stem) {\n            case 'percent':\n            case '%':\n                result.style = 'percent';\n                continue;\n            case '%x100':\n                result.style = 'percent';\n                result.scale = 100;\n                continue;\n            case 'currency':\n                result.style = 'currency';\n                result.currency = token.options[0];\n                continue;\n            case 'group-off':\n            case ',_':\n                result.useGrouping = false;\n                continue;\n            case 'precision-integer':\n            case '.':\n                result.maximumFractionDigits = 0;\n                continue;\n            case 'measure-unit':\n            case 'unit':\n                result.style = 'unit';\n                result.unit = icuUnitToEcma(token.options[0]);\n                continue;\n            case 'compact-short':\n            case 'K':\n                result.notation = 'compact';\n                result.compactDisplay = 'short';\n                continue;\n            case 'compact-long':\n            case 'KK':\n                result.notation = 'compact';\n                result.compactDisplay = 'long';\n                continue;\n            case 'scientific':\n                result = __assign(__assign(__assign({}, result), { notation: 'scientific' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));\n                continue;\n            case 'engineering':\n                result = __assign(__assign(__assign({}, result), { notation: 'engineering' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));\n                continue;\n            case 'notation-simple':\n                result.notation = 'standard';\n                continue;\n            // https://github.com/unicode-org/icu/blob/master/icu4c/source/i18n/unicode/unumberformatter.h\n            case 'unit-width-narrow':\n                result.currencyDisplay = 'narrowSymbol';\n                result.unitDisplay = 'narrow';\n                continue;\n            case 'unit-width-short':\n                result.currencyDisplay = 'code';\n                result.unitDisplay = 'short';\n                continue;\n            case 'unit-width-full-name':\n                result.currencyDisplay = 'name';\n                result.unitDisplay = 'long';\n                continue;\n            case 'unit-width-iso-code':\n                result.currencyDisplay = 'symbol';\n                continue;\n            case 'scale':\n                result.scale = parseFloat(token.options[0]);\n                continue;\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width\n            case 'integer-width':\n                if (token.options.length > 1) {\n                    throw new RangeError('integer-width stems only accept a single optional option');\n                }\n                token.options[0].replace(INTEGER_WIDTH_REGEX, function (_, g1, g2, g3, g4, g5) {\n                    if (g1) {\n                        result.minimumIntegerDigits = g2.length;\n                    }\n                    else if (g3 && g4) {\n                        throw new Error('We currently do not support maximum integer digits');\n                    }\n                    else if (g5) {\n                        throw new Error('We currently do not support exact integer digits');\n                    }\n                    return '';\n                });\n                continue;\n        }\n        // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#integer-width\n        if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {\n            result.minimumIntegerDigits = token.stem.length;\n            continue;\n        }\n        if (FRACTION_PRECISION_REGEX.test(token.stem)) {\n            // Precision\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#fraction-precision\n            // precision-integer case\n            if (token.options.length > 1) {\n                throw new RangeError('Fraction-precision stems only accept a single optional option');\n            }\n            token.stem.replace(FRACTION_PRECISION_REGEX, function (_, g1, g2, g3, g4, g5) {\n                // .000* case (before ICU67 it was .000+)\n                if (g2 === '*') {\n                    result.minimumFractionDigits = g1.length;\n                }\n                // .### case\n                else if (g3 && g3[0] === '#') {\n                    result.maximumFractionDigits = g3.length;\n                }\n                // .00## case\n                else if (g4 && g5) {\n                    result.minimumFractionDigits = g4.length;\n                    result.maximumFractionDigits = g4.length + g5.length;\n                }\n                else {\n                    result.minimumFractionDigits = g1.length;\n                    result.maximumFractionDigits = g1.length;\n                }\n                return '';\n            });\n            var opt = token.options[0];\n            // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#trailing-zero-display\n            if (opt === 'w') {\n                result = __assign(__assign({}, result), { trailingZeroDisplay: 'stripIfInteger' });\n            }\n            else if (opt) {\n                result = __assign(__assign({}, result), parseSignificantPrecision(opt));\n            }\n            continue;\n        }\n        // https://unicode-org.github.io/icu/userguide/format_parse/numbers/skeletons.html#significant-digits-precision\n        if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {\n            result = __assign(__assign({}, result), parseSignificantPrecision(token.stem));\n            continue;\n        }\n        var signOpts = parseSign(token.stem);\n        if (signOpts) {\n            result = __assign(__assign({}, result), signOpts);\n        }\n        var conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);\n        if (conciseScientificAndEngineeringOpts) {\n            result = __assign(__assign({}, result), conciseScientificAndEngineeringOpts);\n        }\n    }\n    return result;\n}\n"],"names":["DATE_TIME_REGEX","parseDateTimeSkeleton","skeleton","result","replace","match","len","length","era","year","RangeError","month","day","weekday","hour12","hourCycle","hour","minute","second","timeZoneName","WHITE_SPACE_REGEX","parseNumberSkeletonFromString","Error","tokens","_i","stringTokens_1","split","filter","x","stemAndOptions","stem","options","slice","_a","options_1","push","FRACTION_PRECISION_REGEX","SIGNIFICANT_PRECISION_REGEX","INTEGER_WIDTH_REGEX","CONCISE_INTEGER_WIDTH_REGEX","parseSignificantPrecision","str","roundingPriority","_","g1","g2","minimumSignificantDigits","maximumSignificantDigits","parseSign","signDisplay","currencySign","parseConciseScientificAndEngineeringStem","notation","test","minimumIntegerDigits","parseNotationOptions","opt","signOpts","parseNumberSkeleton","tokens_1","token","style","scale","currency","useGrouping","maximumFractionDigits","unit","compactDisplay","reduce","all","currencyDisplay","unitDisplay","parseFloat","g3","g4","g5","minimumFractionDigits","trailingZeroDisplay","conciseScientificAndEngineeringOpts"],"sourceRoot":""}