@telerik/kendo-intl
Version:
A package exporting functions for date and number parsing and formatting
1,642 lines (1,416 loc) • 356 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var defaultData = {
en: {
name: "en",
identity: {
version: {
_number: "$Revision: 12418 $",
_cldrVersion: "29"
},
language: "en"
},
territory: "US",
numbers: {
symbols: {
decimal: ".",
group: ",",
list: ";",
percentSign: "%",
plusSign: "+",
minusSign: "-",
exponential: "E",
superscriptingExponent: "×",
perMille: "‰",
infinity: "∞",
nan: "NaN",
timeSeparator: ":"
},
decimal: {
patterns: [
"n"
],
groupSize: [
3
]
},
scientific: {
patterns: [
"nEn"
],
groupSize: []
},
percent: {
patterns: [
"n%"
],
groupSize: [
3
]
},
currency: {
patterns: [
"$n"
],
groupSize: [
3
],
"unitPattern-count-one": "n $",
"unitPattern-count-other": "n $"
},
currencies: {
BGN: {
displayName: "Bulgarian Lev",
"displayName-count-one": "Bulgarian lev",
"displayName-count-other": "Bulgarian leva",
symbol: "BGN"
},
EUR: {
displayName: "Euro",
"displayName-count-one": "euro",
"displayName-count-other": "euros",
symbol: "€",
"symbol-alt-narrow": "€"
},
USD: {
displayName: "US Dollar",
"displayName-count-one": "US dollar",
"displayName-count-other": "US dollars",
symbol: "$",
"symbol-alt-narrow": "$"
}
},
localeCurrency: "USD",
accounting: {
patterns: [
"$n",
"($n)"
],
groupSize: [
3
]
}
},
calendar: {
gmtFormat: "GMT{0}",
gmtZeroFormat: "GMT",
patterns: {
d: "M/d/y",
D: "EEEE, MMMM d, y",
m: "MMM d",
M: "MMMM d",
y: "MMM y",
Y: "MMMM y",
F: "EEEE, MMMM d, y h:mm:ss a",
g: "M/d/y h:mm a",
G: "M/d/y h:mm:ss a",
t: "h:mm a",
T: "h:mm:ss a",
s: "yyyy'-'MM'-'dd'T'HH':'mm':'ss",
u: "yyyy'-'MM'-'dd HH':'mm':'ss'Z'"
},
dateTimeFormats: {
full: "{1} 'at' {0}",
long: "{1} 'at' {0}",
medium: "{1}, {0}",
short: "{1}, {0}",
availableFormats: {
Bh: "h B",
Bhm: "h:mm B",
Bhms: "h:mm:ss B",
d: "d",
E: "ccc",
EBhm: "E h:mm B",
EBhms: "E h:mm:ss B",
Ed: "d E",
Ehm: "E h:mm a",
EHm: "E HH:mm",
Ehms: "E h:mm:ss a",
EHms: "E HH:mm:ss",
Gy: "y G",
GyMMM: "MMM y G",
GyMMMd: "MMM d, y G",
GyMMMEd: "E, MMM d, y G",
h: "h a",
H: "HH",
hm: "h:mm a",
Hm: "HH:mm",
hms: "h:mm:ss a",
Hms: "HH:mm:ss",
hmsv: "h:mm:ss a v",
Hmsv: "HH:mm:ss v",
hmv: "h:mm a v",
Hmv: "HH:mm v",
M: "L",
Md: "M/d",
MEd: "E, M/d",
MMM: "LLL",
MMMd: "MMM d",
MMMEd: "E, MMM d",
MMMMd: "MMMM d",
"MMMMW-count-one": "'week' W 'of' MMMM",
"MMMMW-count-other": "'week' W 'of' MMMM",
ms: "mm:ss",
y: "y",
yM: "M/y",
yMd: "M/d/y",
yMEd: "E, M/d/y",
yMMM: "MMM y",
yMMMd: "MMM d, y",
yMMMEd: "E, MMM d, y",
yMMMM: "MMMM y",
yQQQ: "QQQ y",
yQQQQ: "QQQQ y",
"yw-count-one": "'week' w 'of' Y",
"yw-count-other": "'week' w 'of' Y"
}
},
timeFormats: {
full: "h:mm:ss a zzzz",
long: "h:mm:ss a z",
medium: "h:mm:ss a",
short: "h:mm a"
},
dateFormats: {
full: "EEEE, MMMM d, y",
long: "MMMM d, y",
medium: "MMM d, y",
short: "M/d/yy"
},
days: {
format: {
abbreviated: [
"Sun",
"Mon",
"Tue",
"Wed",
"Thu",
"Fri",
"Sat"
],
narrow: [
"S",
"M",
"T",
"W",
"T",
"F",
"S"
],
short: [
"Su",
"Mo",
"Tu",
"We",
"Th",
"Fr",
"Sa"
],
wide: [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
]
},
"stand-alone": {
abbreviated: [
"Sun",
"Mon",
"Tue",
"Wed",
"Thu",
"Fri",
"Sat"
],
narrow: [
"S",
"M",
"T",
"W",
"T",
"F",
"S"
],
short: [
"Su",
"Mo",
"Tu",
"We",
"Th",
"Fr",
"Sa"
],
wide: [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
]
}
},
months: {
format: {
abbreviated: [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
],
narrow: [
"J",
"F",
"M",
"A",
"M",
"J",
"J",
"A",
"S",
"O",
"N",
"D"
],
wide: [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
]
},
"stand-alone": {
abbreviated: [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
],
narrow: [
"J",
"F",
"M",
"A",
"M",
"J",
"J",
"A",
"S",
"O",
"N",
"D"
],
wide: [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
]
}
},
quarters: {
format: {
abbreviated: [
"Q1",
"Q2",
"Q3",
"Q4"
],
narrow: [
"1",
"2",
"3",
"4"
],
wide: [
"1st quarter",
"2nd quarter",
"3rd quarter",
"4th quarter"
]
},
"stand-alone": {
abbreviated: [
"Q1",
"Q2",
"Q3",
"Q4"
],
narrow: [
"1",
"2",
"3",
"4"
],
wide: [
"1st quarter",
"2nd quarter",
"3rd quarter",
"4th quarter"
]
}
},
dayPeriods: {
format: {
abbreviated: {
midnight: "midnight",
am: "AM",
"am-alt-variant": "am",
noon: "noon",
pm: "PM",
"pm-alt-variant": "pm",
morning1: "in the morning",
afternoon1: "in the afternoon",
evening1: "in the evening",
night1: "at night"
},
narrow: {
midnight: "mi",
am: "a",
"am-alt-variant": "am",
noon: "n",
pm: "p",
"pm-alt-variant": "pm",
morning1: "in the morning",
afternoon1: "in the afternoon",
evening1: "in the evening",
night1: "at night"
},
wide: {
midnight: "midnight",
am: "AM",
"am-alt-variant": "am",
noon: "noon",
pm: "PM",
"pm-alt-variant": "pm",
morning1: "in the morning",
afternoon1: "in the afternoon",
evening1: "in the evening",
night1: "at night"
}
},
"stand-alone": {
abbreviated: {
midnight: "midnight",
am: "AM",
"am-alt-variant": "am",
noon: "noon",
pm: "PM",
"pm-alt-variant": "pm",
morning1: "morning",
afternoon1: "afternoon",
evening1: "evening",
night1: "night"
},
narrow: {
midnight: "midnight",
am: "AM",
"am-alt-variant": "am",
noon: "noon",
pm: "PM",
"pm-alt-variant": "pm",
morning1: "morning",
afternoon1: "afternoon",
evening1: "evening",
night1: "night"
},
wide: {
midnight: "midnight",
am: "AM",
"am-alt-variant": "am",
noon: "noon",
pm: "PM",
"pm-alt-variant": "pm",
morning1: "morning",
afternoon1: "afternoon",
evening1: "evening",
night1: "night"
}
}
},
eras: {
format: {
wide: {
"0": "Before Christ",
"1": "Anno Domini",
"0-alt-variant": "Before Common Era",
"1-alt-variant": "Common Era"
},
abbreviated: {
"0": "BC",
"1": "AD",
"0-alt-variant": "BCE",
"1-alt-variant": "CE"
},
narrow: {
"0": "B",
"1": "A",
"0-alt-variant": "BCE",
"1-alt-variant": "CE"
}
}
},
dateFields: {
era: {
wide: "era"
},
year: {
wide: "year",
short: "yr.",
narrow: "yr."
},
quarter: {
wide: "quarter",
short: "qtr.",
narrow: "qtr."
},
month: {
wide: "month",
short: "mo.",
narrow: "mo."
},
week: {
wide: "week",
short: "wk.",
narrow: "wk."
},
day: {
wide: "day",
short: "day",
narrow: "day"
},
weekday: {
wide: "day of the week"
},
dayperiod: {
wide: "AM/PM"
},
hour: {
wide: "hour",
short: "hr.",
narrow: "hr."
},
minute: {
wide: "minute",
short: "min.",
narrow: "min."
},
second: {
wide: "second",
short: "sec.",
narrow: "sec."
},
millisecond: {
wide: "millisecond",
short: "ms",
narrow: "ms"
},
zone: {
wide: "time zone"
}
}
}
},
supplemental: {
likelySubtags: {
en: "en-Latn-US"
},
currencyData: {
region: {
US: [
{
USD: {
_from: "1792-01-01"
}
}
]
}
},
weekData: {
firstDay: {
US: "sun"
},
weekendStart: {
"001": "sat"
},
weekendEnd: {
"001": "sun"
}
}
}
};
function isString(value) {
return typeof value === "string";
}
//The error is represented by unique name and corresponding message
//The message can contain placeholders with index, e.g. {0}, {1}
var errorDetails = {
"NoLocale": "Missing locale info for '{0}'",
"NoCurrency": "Cannot determine currency information. Please load the locale currencies data.",
"NoSupplementalCurrency": "Cannot determine currency. Please load the supplemental currencyData.",
"NoCurrencyRegion": "No currency data for region '{0}'",
"NoCurrencyDisplay": "Cannot determine currency display information. Please load the locale currencies data. The default culture does not include the all currencies data.",
"NoGMTInfo": "Cannot determine locale GMT format. Please load the locale timeZoneNames data.",
"NoWeekData": "Cannot determine locale first day of week. Please load the supplemental weekData.",
"NoFirstDay": "Cannot determine locale first day of week. Please load the supplemental weekData. The default culture includes only the 'en-US' first day info.",
"NoValidCurrency": "Cannot determine a default currency for the {0} locale. Please specify explicitly the currency with the format options.",
"NoDateFieldNames": "Cannot determine the locale date field names. Please load the locale dateFields data."
};
var formatRegExp = /\{(\d+)}?\}/g;
var IntlError = function IntlError(ref) {
var name = ref.name;
var message = ref.message;
if (!name || !message) {
throw new Error("{ name: string, message: string } object is required!");
}
this.name = name;
this.message = message;
};
IntlError.prototype.formatMessage = function formatMessage () {
var values = [], len = arguments.length;
while ( len-- ) values[ len ] = arguments[ len ];
var flattenValues = flatten(values);
var formattedMessage = this.message.replace(formatRegExp, function(match, index) {
return flattenValues[parseInt(index, 10)];
});
return ((this.name) + ": " + formattedMessage);
};
IntlError.prototype.error = function error () {
var values = [], len = arguments.length;
while ( len-- ) values[ len ] = arguments[ len ];
return new Error(this.formatMessage(values));
};
var flatten = function(arr) {
return arr.reduce(function (a, b) { return a.concat(b); }, []);
};
var toIntlErrors = function(errors) {
var predicate = function(prev, name) {
prev[name] = new IntlError({ name: name, message: errors[name] });
return prev;
};
return Object.keys(errors).reduce(predicate, {});
};
var errors = toIntlErrors(errorDetails);
function availableLocaleInfo(fullName, suffixes) {
var parts = fullName.split("-");
var language = parts[0];
var script = parts[1];
var territory = parts[2];
return cldr[fullName] || (suffixes.indexOf(territory) !== -1 && cldr[language + "-" + territory]) || (suffixes.indexOf(script) !== -1 && cldr[language + "-" + script]) || cldr[language];
}
function localeFullName(language, suffixes) {
var likelySubtags = cldr.supplemental.likelySubtags;
for (var idx = 0; idx < suffixes.length; idx++) {
var name = likelySubtags[language + "-" + suffixes[idx ]];
if (name) {
return name;
}
}
if (likelySubtags[language]) {
return likelySubtags[language];
}
}
var cldr = defaultData;
function getLocaleInfo(locale) {
var info;
if (isString(locale)) {
info = localeInfo(locale);
} else {
info = locale;
}
return info;
}
function localeInfo(locale) {
if (cldr[locale]) {
return cldr[locale];
}
var likelySubtags = cldr.supplemental.likelySubtags;
if (likelySubtags) {
var parts = locale.split("-");
var language = parts[0];
var suffixes = parts.slice(1);
var fullName = localeFullName(language, suffixes);
var info = fullName ? availableLocaleInfo(fullName, suffixes) : null;
if (info) {
return info;
}
}
throw errors.NoLocale.error(locale);
}
var DECIMAL = "decimal";
var CURRENCY = "currency";
var ACCOUNTING = "accounting";
var PERCENT = "percent";
var SCIENTIFIC = "scientific";
var CURRENCY_PLACEHOLDER = "$";
var PERCENT_PLACEHOLDER = "%";
var NUMBER_PLACEHOLDER = "n";
var LIST_SEPARATOR = ";";
var GROUP_SEPARATOR = ",";
var POINT = ".";
var EMPTY = "";
var DEFAULT_LOCALE = "en";
var LATIN_NUMBER_FORMATS = "Formats-numberSystem-latn";
var LATIN_NUMBER_SYMBOLS = "symbols-numberSystem-latn";
var patternRegExp = /([#,0.]+)/g;
var cldrCurrencyRegExp = /¤/g;
function getPatterns(pattern) {
patternRegExp.lastIndex = 0;
return pattern.replace(cldrCurrencyRegExp, CURRENCY_PLACEHOLDER).replace(patternRegExp, NUMBER_PLACEHOLDER).split(LIST_SEPARATOR);
}
function getGroupSize(pattern) {
patternRegExp.lastIndex = 0;
var numberPatterns = patternRegExp.exec(pattern.split(LIST_SEPARATOR)[0])[0].split(POINT);
var integer = numberPatterns[0];
var groupSize = integer.split(GROUP_SEPARATOR).slice(1).map(function(group) {
return group.length;
}).reverse();
return groupSize;
}
function loadCurrencyUnitPatterns(currencyInfo, currencyFormats) {
for (var field in currencyFormats) {
if (field.startsWith("unitPattern")) {
currencyInfo[field] = currencyFormats[field].replace("{0}", NUMBER_PLACEHOLDER).replace("{1}", CURRENCY_PLACEHOLDER);
}
}
}
function loadNumbersInfo(locale, info) {
var localeInfo$$1 = cldr[locale];
var numbers = localeInfo$$1.numbers = localeInfo$$1.numbers || {};
numbers.symbols = numbers.symbols || {};
for (var field in info) {
if (field === LATIN_NUMBER_SYMBOLS) {
Object.assign(numbers.symbols, info[field]);
} else if (field.includes(LATIN_NUMBER_FORMATS)) {
var style = field.substr(0, field.indexOf(LATIN_NUMBER_FORMATS));
var pattern = info[field].standard;
numbers[style] = {
patterns: getPatterns(pattern)
};
if (style === CURRENCY) {
numbers[style].groupSize = getGroupSize((info[DECIMAL + LATIN_NUMBER_FORMATS] || info[field]).standard);
loadCurrencyUnitPatterns(numbers[style], info[field]);
numbers[ACCOUNTING] = {
patterns: getPatterns(info[field][ACCOUNTING]),
groupSize: numbers[style].groupSize
};
} else {
numbers[style].groupSize = getGroupSize(pattern);
}
} else if (field === "currencies") {
numbers.currencies = info[field];
}
}
}
var predefinedDatePatterns = {
s: "yyyy'-'MM'-'dd'T'HH':'mm':'ss",
u: "yyyy'-'MM'-'dd HH':'mm':'ss'Z'"
};
var YEAR_REGEX = /y+/g;
var SHORT_DATE = [ [ "dateFormats", "short" ] ];
var datePatterns = {
D: [ [ "dateFormats", "full" ] ],
m: [ [ "dateTimeFormats", "availableFormats", "MMMd" ] ],
M: [ [ "dateTimeFormats", "availableFormats", "MMMMd" ] ],
y: [ [ "dateTimeFormats", "availableFormats", "yMMM" ] ],
Y: [ [ "dateTimeFormats", "availableFormats", "yMMMM" ] ],
F: [ [ "dateFormats", "full" ], [ "timeFormats", "medium" ] ],
g: [ [ "dateTimeFormats", "availableFormats", "yMd" ], [ "timeFormats", "short" ] ],
G: [ [ "dateTimeFormats", "availableFormats", "yMd" ], [ "timeFormats", "medium" ] ],
t: [ [ "timeFormats", "short" ] ],
T: [ [ "timeFormats", "medium" ] ]
};
function toArray(obj) {
var result = [];
var names = Object.getOwnPropertyNames(obj);
for (var idx = 0; idx < names.length; idx++) {
var value = obj[names[idx]];
result.push(value);
}
return result;
}
function getCalendarNames(info, isObj) {
var result = {};
for (var formatType in info) {
var names = result[formatType] = {};
for (var format in info[formatType]) {
var formats = info[formatType][format];
names[format] = isObj ? formats : toArray(formats);
}
}
return result;
}
function getEraNames(eras) {
var result = {};
var format = result.format = {};
var eraNameMap = {
eraAbbr: "abbreviated",
eraNames: "wide",
eraNarrow: "narrow"
};
for (var eraFormatName in eras) {
var formatName = eraNameMap[eraFormatName];
format[formatName] = eras[eraFormatName];
}
return result;
}
function loadCalendarNames(locale, calendar) {
var localeCalendar = cldr[locale].calendar;
localeCalendar.days = getCalendarNames(calendar.days);
localeCalendar.months = getCalendarNames(calendar.months);
localeCalendar.quarters = getCalendarNames(calendar.quarters);
localeCalendar.dayPeriods = getCalendarNames(calendar.dayPeriods, true);
localeCalendar.eras = getEraNames(calendar.eras);
}
function loadCalendarDateFields(locale, fields) {
var localeCalendar = cldr[locale].calendar;
var dateFields = {};
for (var field in fields) {
var ref = field.split('-');
var fieldName = ref[0];
var formatType = ref[1]; if ( formatType === void 0 ) formatType = 'wide';
var fieldInfo = dateFields[fieldName] || {};
var displayName = fields[field].displayName;
if (!displayName) { continue; }
fieldInfo[formatType] = displayName;
dateFields[fieldName] = fieldInfo;
}
localeCalendar.dateFields = dateFields;
}
function getPredefinedFormat(paths, calendar) {
var result = [];
for (var pathIdx = 0; pathIdx < paths.length; pathIdx++) {
var fields = paths[ pathIdx ];
var pattern = calendar;
for (var idx = 0; idx < fields.length; idx++) {
pattern = pattern[fields[idx]];
}
result.push(pattern);
}
return result.join(" ");
}
function loadCalendarPatterns(locale, calendar) {
var cldrCalendar = cldr[locale].calendar;
var patterns = cldrCalendar.patterns = {};
patterns.d = getPredefinedFormat(SHORT_DATE, calendar).replace(YEAR_REGEX, 'y');
for (var pattern in datePatterns) {
patterns[pattern] = getPredefinedFormat(datePatterns[pattern], calendar);
}
for (var pattern$1 in predefinedDatePatterns) {
patterns[pattern$1] = predefinedDatePatterns[pattern$1];
}
var dateTimeFormats = calendar.dateTimeFormats;
cldrCalendar.dateTimeFormats = {
full: dateTimeFormats.full,
long: dateTimeFormats.long,
medium: dateTimeFormats.medium,
short: dateTimeFormats.short,
availableFormats: dateTimeFormats.availableFormats
};
cldrCalendar.timeFormats = calendar.timeFormats;
cldrCalendar.dateFormats = calendar.dateFormats;
}
function loadCalendarInfo(locale, info) {
var calendar = cldr[locale].calendar = cldr[locale].calendar || {};
for (var field in info) {
if (field === "timeZoneNames") {
calendar.gmtFormat = info[field].gmtFormat;
calendar.gmtZeroFormat = info[field].gmtZeroFormat;
} else if (field === "calendars" && info[field].gregorian) {
loadCalendarPatterns(locale, info[field].gregorian);
loadCalendarNames(locale, info[field].gregorian);
} else if (field === "fields") {
loadCalendarDateFields(locale, info.fields);
}
}
}
function territoryFromName(name, identity) {
var likelySubtags = cldr.supplemental.likelySubtags;
var parts = name.split("-");
if (likelySubtags) {
var likelyName = likelySubtags[name] || likelySubtags[parts[0]];
if (likelyName) {
parts = likelyName.split("-");
}
}
if (identity) {
for (var idx = parts.length - 1; idx >= 1; idx--) {
var part = parts[idx];
if (part === identity.variant || part === identity.script) {
parts.splice(idx, 1);
}
}
}
var length = parts.length;
if (length > 1) {
var territory = parts[length - 1];
return territory.toUpperCase();
}
}
function localeTerritory(info) {
if (info.territory) {
return info.territory;
}
var name = info.name;
var identity = info.identity;
var territory;
if (identity && identity.territory) {
territory = identity.territory;
} else {
territory = territoryFromName(name, identity);
}
info.territory = territory;
return territory;
}
function loadLocale(locale, info) {
for (var field in info) {
if (field === "numbers") {
loadNumbersInfo(locale, info[field]);
} else if (field === "dates") {
loadCalendarInfo(locale, info[field]);
}
}
}
function load() {
var arguments$1 = arguments;
var length = arguments.length;
for (var idx = 0; idx < length; idx++) {
var entry = arguments$1[idx];
if (entry.main) {
var locale = Object.keys(entry.main)[0];
var info = entry.main[locale];
var localeInfo$$1 = cldr[locale] = cldr[locale] || {};
localeInfo$$1.name = localeInfo$$1.name || locale;
localeInfo$$1.identity = localeInfo$$1.identity || info.identity;
localeTerritory(localeInfo$$1);
loadLocale(locale, info);
} else if (entry.supplemental) {
if (entry.supplemental.weekData) {
cldr.supplemental.weekData = {
firstDay: entry.supplemental.weekData.firstDay,
weekendStart: entry.supplemental.weekData.weekendStart,
weekendEnd: entry.supplemental.weekData.weekendEnd
};
} else if (entry.supplemental.likelySubtags) {
cldr.supplemental.likelySubtags = Object.assign(cldr.supplemental.likelySubtags, entry.supplemental.likelySubtags);
} else if (entry.supplemental.currencyData) {
var currencyData = cldr.supplemental.currencyData;
currencyData.region = Object.assign(currencyData.region || {}, entry.supplemental.currencyData.region);
currencyData.fractions = Object.assign(currencyData.fractions || {}, entry.supplemental.currencyData.fractions);
}
}
}
}
function setData(data) {
var locale = data.name;
var info = cldr[locale] = cldr[locale] || {};
var supplemental = cldr.supplemental = cldr.supplemental || {};
if (data.likelySubtags) {
supplemental.likelySubtags = Object.assign(supplemental.likelySubtags || {}, data.likelySubtags);
}
if (data.currencyData) {
supplemental.currencyData = supplemental.currencyData || {};
supplemental.currencyData.fractions = Object.assign(supplemental.currencyData.fractions || {}, data.currencyData);
}
var numbers = info.numbers;
Object.assign(info, data);
if (numbers && data.numbers) {
info.numbers = Object.assign({}, numbers, data.numbers);
}
}
function dateFieldName(options, locale) {
if ( locale === void 0 ) locale = DEFAULT_LOCALE;
var info = localeInfo(locale);
var dateFields = info.calendar.dateFields;
if (!dateFields) {
throw errors.NoDateFieldNames.error();
}
var fieldNameInfo = dateFields[options.type] || {};
return fieldNameInfo[options.nameType] || fieldNameInfo['wide'];
}
function lowerArray(arr) {
var result = [];
for (var idx = 0; idx < arr.length; idx++) {
result.push(arr[idx].toLowerCase());
}
return result;
}
function lowerObject(obj) {
var result = {};
for (var field in obj) {
result[field] = obj[field].toLowerCase();
}
return result;
}
function cloneLower(obj) {
var result = Array.isArray(obj) ? lowerArray(obj) : lowerObject(obj);
return result;
}
function dateFormatNames(locale, options) {
var type = options.type;
var nameType = options.nameType;
var standAlone = options.standAlone;
var lower = options.lower;
var info = getLocaleInfo(locale);
var formatType = standAlone ? "stand-alone" : "format";
var lowerNameType = (lower ? "lower-" : EMPTY) + nameType;
var formatNames = info.calendar[type][formatType];
var result = formatNames[lowerNameType];
if (!result && lower) {
result = formatNames[lowerNameType] = cloneLower(formatNames[nameType]);
}
return result;
}
function parseRangeDate(value) {
var parts = value.split('-');
var year = parseInt(parts[0], 10);
var month = parseInt(parts[1], 10) - 1;
var day = parseInt(parts[2], 10);
return new Date(year, month, day);
}
/* eslint-disable consistent-return */
var NoCurrency = errors.NoCurrency;
var NoCurrencyDisplay = errors.NoCurrencyDisplay;
var NoSupplementalCurrency = errors.NoSupplementalCurrency;
var NoCurrencyRegion = errors.NoCurrencyRegion;
var NoValidCurrency = errors.NoValidCurrency;
var DEFAULT_CURRENCY_FRACTIONS = 2;
var SYMBOL = "symbol";
var INVALID_CURRENCY_CODE = 'XXX';
var GLOBAL_CURRENCIES = {
'001': 'USD', // 001 refers to world. not sure if it is correct to assume USD but seems better than throw an error
'150': 'EUR' // 150 territory for Europe
};
function getCurrencyInfo(locale, currency, throwIfNoValid) {
var info = getLocaleInfo(locale);
var currencies = info.numbers.currencies;
if (!currencies) {
if (throwIfNoValid) {
throw NoCurrency.error();
}
return;
}
var currencyDisplayInfo = currencies[currency];
if (!currencyDisplayInfo) {
if (throwIfNoValid) {
throw NoCurrencyDisplay.error();
}
return;
}
return currencyDisplayInfo;
}
function lengthComparer(a, b) {
return b.length - a.length;
}
function regionCurrency(regionCurrencies) {
var latestValidUntil, latestValidUntilRange;
var latestStillValid, latestStillValidDate;
for (var idx = 0; idx < regionCurrencies.length; idx++) {
var currency = regionCurrencies[idx];
var code = Object.keys(currency)[0];
var info = currency[code];
if (code !== INVALID_CURRENCY_CODE && info._tender !== 'false' && info._from) {
if (!info._to) {
var stillValidDate = parseRangeDate(info._from);
if (!latestStillValidDate || latestStillValidDate < stillValidDate) {
latestStillValid = code;
latestStillValidDate = stillValidDate;
}
} else if (!latestStillValid) {
var validFrom = parseRangeDate(info._from);
var validTo = parseRangeDate(info._to);
if (!latestValidUntilRange || latestValidUntilRange.to < validTo || latestValidUntilRange.from < validFrom) {
latestValidUntil = code;
latestValidUntilRange = {
from: validFrom,
to: validTo
};
}
}
}
}
return latestStillValid || latestValidUntil;
}
function currencyDisplays(locale, currency, throwIfNoValid) {
if ( throwIfNoValid === void 0 ) throwIfNoValid = true;
var currencyInfo = getCurrencyInfo(locale, currency, throwIfNoValid);
if (!currencyInfo) {
return;
}
if (!currencyInfo.displays) {
var displays = [ currency ];
for (var field in currencyInfo) {
displays.push(currencyInfo[field]);
}
displays.sort(lengthComparer);
currencyInfo.displays = displays;
}
return currencyInfo.displays;
}
function currencyDisplay(locale, options) {
var value = options.value;
var currency = options.currency;
var currencyDisplay = options.currencyDisplay; if ( currencyDisplay === void 0 ) currencyDisplay = SYMBOL;
if (currencyDisplay === "code") {
return currency;
}
var currencyInfo = getCurrencyInfo(locale, currency, true);
var result;
if (currencyDisplay === SYMBOL) {
result = currencyInfo["symbol-alt-narrow"] || currencyInfo[SYMBOL];
} else {
if (typeof value === undefined || value !== 1) {
result = currencyInfo["displayName-count-other"];
} else {
result = currencyInfo["displayName-count-one"];
}
}
return result;
}
function currencyFractionOptions(code) {
var minimumFractionDigits = DEFAULT_CURRENCY_FRACTIONS;
var maximumFractionDigits = DEFAULT_CURRENCY_FRACTIONS;
var fractions = ((cldr.supplemental.currencyData || {}).fractions || {})[code];
if (fractions && fractions._digits) {
maximumFractionDigits = minimumFractionDigits = parseInt(fractions._digits, 10);
}
return {
minimumFractionDigits: minimumFractionDigits,
maximumFractionDigits: maximumFractionDigits
};
}
function territoryCurrencyCode(territory, throwIfNoValid) {
if ( throwIfNoValid === void 0 ) throwIfNoValid = true;
if (GLOBAL_CURRENCIES[territory]) {
return GLOBAL_CURRENCIES[territory];
}
var currencyData = cldr.supplemental.currencyData;
if (!currencyData) {
if (throwIfNoValid) {
throw NoSupplementalCurrency.error();
}
return;
}
var regionCurrencies = currencyData.region[territory];
if (!regionCurrencies) {
if (throwIfNoValid) {
throw NoCurrencyRegion.error(territory);
}
return;
}
var currencyCode = regionCurrency(regionCurrencies);
return currencyCode;
}
function localeCurrency(locale, throwIfNoValid) {
var info = getLocaleInfo(locale);
var numbers = info.numbers;
if (!numbers.localeCurrency) {
var currency = territoryCurrencyCode(localeTerritory(info), throwIfNoValid);
if (!currency && throwIfNoValid) {
throw NoValidCurrency.error(info.name);
}
numbers.localeCurrency = currency;
}
return numbers.localeCurrency;
}
var DAYS_OF_WEEK = [ "sun", "mon", "tue", "wed", "thu", "fri", "sat" ];
var DEFAULT_TERRITORY = '001';
var NoWeekData = errors.NoWeekData;
var NoFirstDay = errors.NoFirstDay;
function firstDay(locale) {
var info = getLocaleInfo(locale);
if (!isNaN(info.firstDay)) {
return info.firstDay;
}
var weekData = cldr.supplemental.weekData;
if (!weekData) {
throw NoWeekData.error();
}
var firstDay = weekData.firstDay[localeTerritory(info)] || weekData.firstDay[DEFAULT_TERRITORY];
if (!firstDay) {
throw NoFirstDay.error();
}
info.firstDay = DAYS_OF_WEEK.indexOf(firstDay);
return info.firstDay;
}
var NoWeekData$1 = errors.NoWeekData;
function weekendRange(locale) {
var info = getLocaleInfo(locale);
if (info.weekendRange) {
return info.weekendRange;
}
var weekData = cldr.supplemental.weekData;
if (!weekData) {
throw NoWeekData$1.error();
}
var territory = localeTerritory(info);
var start = weekData.weekendStart[territory] || weekData.weekendStart[DEFAULT_TERRITORY];
var end = weekData.weekendEnd[territory] || weekData.weekendEnd[DEFAULT_TERRITORY];
info.weekendRange = {
start: DAYS_OF_WEEK.indexOf(start),
end: DAYS_OF_WEEK.indexOf(end)
};
return info.weekendRange;
}
function numberSymbols(locale) {
var info = getLocaleInfo(locale);
return info.numbers.symbols;
}
function isNegativeZero(value) {
return (1 / value === -Infinity);
}
function formatCurrencySymbol(info, options) {
if ( options === void 0 ) options = {};
if (!options.currency) {
options.currency = localeCurrency(info, true);
}
var display = currencyDisplay(info, options);
return display;
}
function groupInteger(number, start, end, options, info) {
var symbols = info.numbers.symbols;
var decimalIndex = number.indexOf(symbols.decimal);
var groupSizes = options.groupSize.slice();
var groupSize = groupSizes.shift();
var integerEnd = decimalIndex !== -1 ? decimalIndex : end + 1;
var integer = number.substring(start, integerEnd);
var result = number;
var integerLength = integer.length;
if (integerLength >= groupSize) {
var idx = integerLength;
var parts = [];
while (idx > -1) {
var value = integer.substring(idx - groupSize, idx);
if (value) {
parts.push(value);
}
idx -= groupSize;
var newGroupSize = groupSizes.shift();
groupSize = newGroupSize !== undefined ? newGroupSize : groupSize;
if (groupSize === 0) {
value = integer.substring(0, idx);
if (value) {
parts.push(value);
}
break;
}
}
integer = parts.reverse().join(symbols.group);
result = number.substring(0, start) + integer + number.substring(integerEnd);
}
return result;
}
function isCurrencyStyle(style) {
return style === CURRENCY || style === ACCOUNTING;
}
function pad(number, digits, right) {
if ( digits === void 0 ) digits = 2;
if ( right === void 0 ) right = false;
var count = digits - String(number).length;
var result = number;
if (count > 0) {
var padString = new Array(count + 1).join("0");
result = right ? number + padString : padString + number;
}
return result;
}
var MAX_PRECISION = 20;
function round(value, precision) {
var result = value;
var decimals = precision || 0;
result = result.toString().split('e');
result = Math.round(Number(result[0] + 'e' + (result[1] ? (Number(result[1]) + decimals) : decimals)));
result = result.toString().split('e');
result = Number(result[0] + 'e' + (result[1] ? (Number(result[1]) - decimals) : -decimals));
return result.toFixed(Math.min(decimals, MAX_PRECISION));
}
var DEFAULT_DECIMAL_ROUNDING = 3;
var DEFAULT_PERCENT_ROUNDING = 0;
var trailingZeroRegex = /0+$/;
function fractionOptions(options) {
var minimumFractionDigits = options.minimumFractionDigits;
var maximumFractionDigits = options.maximumFractionDigits;
var style = options.style;
var isCurrency = isCurrencyStyle(style);
var currencyFractions;
if (isCurrency) {
currencyFractions = currencyFractionOptions(options.currency);
}
if (minimumFractionDigits === undefined) {
minimumFractionDigits = isCurrency ? currencyFractions.minimumFractionDigits : 0;
}
if (maximumFractionDigits === undefined) {
if (style === PERCENT) {
maximumFractionDigits = Math.max(minimumFractionDigits, DEFAULT_PERCENT_ROUNDING);
} else if (isCurrency) {
maximumFractionDigits = Math.max(minimumFractionDigits, currencyFractions.maximumFractionDigits);
} else {
maximumFractionDigits = Math.max(minimumFractionDigits, DEFAULT_DECIMAL_ROUNDING);
}
}
return {
minimumFractionDigits: minimumFractionDigits,
maximumFractionDigits: maximumFractionDigits
};
}
function applyPattern(value, pattern, symbol) {
var result = EMPTY;
for (var idx = 0, length = pattern.length; idx < length; idx++) {
var ch = pattern.charAt(idx);
if (ch === NUMBER_PLACEHOLDER) {
result += value;
} else if (ch === CURRENCY_PLACEHOLDER || ch === PERCENT_PLACEHOLDER) {
result += symbol;
} else {
result += ch;
}
}
return result;
}
function currencyUnitPattern(info, value) {
var currencyInfo = info.numbers.currency;
var pattern = value !== 1 ? currencyInfo["unitPattern-count-other"] : currencyInfo["unitPattern-count-one"];
if (value < 0) {
pattern = pattern.replace(NUMBER_PLACEHOLDER, ("-" + NUMBER_PLACEHOLDER));
}
return pattern;
}
function standardNumberFormat(number, options, info) {
var symbols = info.numbers.symbols;
var style = options.style;
var isCurrency = isCurrencyStyle(style);
//return number in exponential format
if (style === SCIENTIFIC) {
var exponential = options.minimumFractionDigits !== undefined ? number.toExponential(options.minimumFractionDigits) : number.toExponential();
return exponential.replace(POINT, symbols.decimal);
}
var value = number;
var symbol;
if (isCurrency) {
options.value = value;
symbol = formatCurrencySymbol(info, options);
}
if (style === PERCENT) {
value *= 100;
symbol = symbols.percentSign;
}
var ref = fractionOptions(options);
var minimumFractionDigits = ref.minimumFractionDigits;
var maximumFractionDigits = ref.maximumFractionDigits;
value = round(value, maximumFractionDigits);
var negative = value < 0;
var negativeZero = isNegativeZero(number);
var parts = value.split(POINT);
var integer = parts[0];
var fraction = pad(parts[1] ? parts[1].replace(trailingZeroRegex, EMPTY) : EMPTY, minimumFractionDigits, true);
//exclude "-" if number is negative.
if (negative) {
integer = integer.substring(1);
}
if (options.minimumIntegerDigits) {
integer = pad(integer, options.minimumIntegerDigits);
}
var formattedValue = options.useGrouping !== false ? groupInteger(integer, 0, integer.length, options, info) : integer;
if (fraction) {
formattedValue += symbols.decimal + fraction;
}
var pattern;
if (isCurrency && options.currencyDisplay === "name") {
pattern = currencyUnitPattern(info, number);
} else {
var patterns = options.patterns;
pattern = (negative || negativeZero) ? patterns[1] || ("-" + patterns[0]) : patterns[0];
}
if (pattern === NUMBER_PLACEHOLDER && !negative) {
return formattedValue;
}
var result = applyPattern(formattedValue, pattern, symbol);
return result;
}
var literalRegExp = /(\\.)|(['][^']*[']?)|(["][^"]*["]?)/g;
var PLACEHOLDER = "__??__";
function setStyleOptions(formatOptions, info) {
var format = formatOptions.format;
//multiply number if the format has percent
if (format.indexOf(PERCENT_PLACEHOLDER) !== -1) {
formatOptions.style = PERCENT;
formatOptions.symbol = info.numbers.symbols.percentSign;
formatOptions.number *= 100;
}
if (format.indexOf(CURRENCY_PLACEHOLDER) !== -1) {
formatOptions.style = CURRENCY;
formatOptions.symbol = formatCurrencySymbol(info);
}
}
function setFormatLiterals(formatOptions) {
var format = formatOptions.format;
if (format.indexOf("'") > -1 || format.indexOf("\"") > -1 || format.indexOf("\\") > -1) {
var literals = formatOptions.literals = [];
formatOptions.format = format.replace(literalRegExp, function(match) {
var quoteChar = match.charAt(0).replace("\\", EMPTY);
var literal = match.slice(1).replace(quoteChar, EMPTY);
literals.push(literal);
return PLACEHOLDER;
});
}
}
function replaceLiterals(number, literals) {
var result = number;
if (literals) {
var length = literals.length;
for (var idx = 0; idx < length; idx++) {
result = result.replace(PLACEHOLDER, literals[idx]);
}
}
return result;
}
var SHARP = "#";
var ZERO = "0";
var trailingZerosRegExp = /(\.(?:[0-9]*[1-9])?)0+$/g;
var trailingPointRegExp = /\.$/;
var commaRegExp = /\,/g;
function trimTrailingZeros(value, lastZero) {
var trimRegex;
if (lastZero === 0) {
trimRegex = trailingZerosRegExp;
} else {
trimRegex = new RegExp(("(\\.[0-9]{" + lastZero + "}[1-9]*)0+$"), 'g');
}
return value.replace(trimRegex, '$