ngx-bootstrap
Version:
Native Angular Bootstrap Components
1,851 lines (1,831 loc) • 277 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} n
* @param {?} x
* @return {?}
*/
function mod(n, x) {
return (n % x + x) % x;
}
/**
* @param {?} num
* @return {?}
*/
function absFloor(num) {
return num < 0 ? Math.ceil(num) || 0 : Math.floor(num);
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} str
* @return {?}
*/
function isString(str) {
return typeof str === 'string';
}
/**
* @param {?} value
* @return {?}
*/
function isDate(value) {
return value instanceof Date || Object.prototype.toString.call(value) === '[object Date]';
}
/**
* @param {?} date
* @return {?}
*/
function isDateValid(date) {
return date && date.getTime && !isNaN(date.getTime());
}
/**
* @param {?} fn
* @return {?}
*/
function isFunction(fn) {
return (fn instanceof Function ||
Object.prototype.toString.call(fn) === '[object Function]');
}
/**
* @param {?=} value
* @return {?}
*/
function isNumber(value) {
return typeof value === 'number' || Object.prototype.toString.call(value) === '[object Number]';
}
/**
* @template T
* @param {?=} input
* @return {?}
*/
function isArray(input) {
return (input instanceof Array ||
Object.prototype.toString.call(input) === '[object Array]');
}
/**
* @template T
* @param {?} a
* @param {?} b
* @return {?}
*/
function hasOwnProp(a /*object*/, b) {
return Object.prototype.hasOwnProperty.call(a, b);
}
/**
* @template T
* @param {?} input
* @return {?}
*/
function isObject(input /*object*/) {
// IE8 will treat undefined and null as object if it wasn't for
// input != null
return (input != null && Object.prototype.toString.call(input) === '[object Object]');
}
/**
* @param {?} obj
* @return {?}
*/
function isObjectEmpty(obj) {
if (Object.getOwnPropertyNames) {
return (Object.getOwnPropertyNames(obj).length === 0);
}
/** @type {?} */
var k;
for (k in obj) {
if (obj.hasOwnProperty(k)) {
return false;
}
}
return true;
}
/**
* @param {?} input
* @return {?}
*/
function isUndefined(input) {
return input === void 0;
}
/**
* @template T
* @param {?} argumentForCoercion
* @return {?}
*/
function toInt(argumentForCoercion) {
/** @type {?} */
var coercedNumber = +argumentForCoercion;
/** @type {?} */
var value = 0;
if (coercedNumber !== 0 && isFinite(coercedNumber)) {
value = absFloor(coercedNumber);
}
return value;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var aliases = {};
/** @type {?} */
var _mapUnits = {
date: 'day',
hour: 'hours',
minute: 'minutes',
second: 'seconds',
millisecond: 'milliseconds'
};
/**
* @param {?} unit
* @param {?} shorthand
* @return {?}
*/
function addUnitAlias(unit, shorthand) {
/** @type {?} */
var lowerCase = unit.toLowerCase();
/** @type {?} */
var _unit = unit;
if (lowerCase in _mapUnits) {
_unit = _mapUnits[lowerCase];
}
aliases[lowerCase] = aliases[lowerCase + "s"] = aliases[shorthand] = _unit;
}
/**
* @param {?} units
* @return {?}
*/
function normalizeUnits(units) {
return isString(units) ? aliases[units] || aliases[units.toLowerCase()] : undefined;
}
/**
* @param {?} inputObject
* @return {?}
*/
function normalizeObjectUnits(inputObject) {
/** @type {?} */
var normalizedInput = {};
/** @type {?} */
var normalizedProp;
/** @type {?} */
var prop;
for (prop in inputObject) {
if (hasOwnProp(inputObject, prop)) {
normalizedProp = normalizeUnits(prop);
if (normalizedProp) {
normalizedInput[normalizedProp] = inputObject[prop];
}
}
}
return (/** @type {?} */ (normalizedInput));
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// place in new Date([array])
/** @type {?} */
var YEAR = 0;
/** @type {?} */
var MONTH = 1;
/** @type {?} */
var DATE = 2;
/** @type {?} */
var HOUR = 3;
/** @type {?} */
var MINUTE = 4;
/** @type {?} */
var SECOND = 5;
/** @type {?} */
var MILLISECOND = 6;
/** @type {?} */
var WEEK = 7;
/** @type {?} */
var WEEKDAY = 8;
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} num
* @param {?} targetLength
* @param {?=} forceSign
* @return {?}
*/
function zeroFill(num, targetLength, forceSign) {
/** @type {?} */
var absNumber = "" + Math.abs(num);
/** @type {?} */
var zerosToFill = targetLength - absNumber.length;
/** @type {?} */
var sign = num >= 0;
/** @type {?} */
var _sign = sign ? (forceSign ? '+' : '') : '-';
// todo: this is crazy slow
/** @type {?} */
var _zeros = Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1);
return (_sign + _zeros + absNumber);
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var formatFunctions = {};
/** @type {?} */
var formatTokenFunctions = {};
// tslint:disable-next-line
/** @type {?} */
var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
// token: 'M'
// padded: ['MM', 2]
// ordinal: 'Mo'
// callback: function () { this.month() + 1 }
/**
* @param {?} token
* @param {?} padded
* @param {?} ordinal
* @param {?} callback
* @return {?}
*/
function addFormatToken(token, padded, ordinal, callback) {
if (token) {
formatTokenFunctions[token] = callback;
}
if (padded) {
formatTokenFunctions[padded[0]] = function () {
return zeroFill(callback.apply(null, arguments), padded[1], padded[2]);
};
}
if (ordinal) {
formatTokenFunctions[ordinal] = function (date, opts) {
return opts.locale.ordinal(callback.apply(null, arguments), token);
};
}
}
/**
* @param {?} format
* @return {?}
*/
function makeFormatFunction(format) {
/** @type {?} */
var array = format.match(formattingTokens);
/** @type {?} */
var length = array.length;
/** @type {?} */
var formatArr = new Array(length);
for (var i = 0; i < length; i++) {
formatArr[i] = formatTokenFunctions[array[i]]
? formatTokenFunctions[array[i]]
: removeFormattingTokens(array[i]);
}
return function (date, locale, isUTC, offset) {
if (offset === void 0) { offset = 0; }
/** @type {?} */
var output = '';
for (var j = 0; j < length; j++) {
output += isFunction(formatArr[j])
? ((/** @type {?} */ (formatArr[j]))).call(null, date, { format: format, locale: locale, isUTC: isUTC, offset: offset })
: formatArr[j];
}
return output;
};
}
/**
* @param {?} input
* @return {?}
*/
function removeFormattingTokens(input) {
if (input.match(/\[[\s\S]/)) {
return input.replace(/^\[|\]$/g, '');
}
return input.replace(/\\/g, '');
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?=} y
* @param {?=} m
* @param {?=} d
* @return {?}
*/
function createUTCDate(y, m, d) {
/** @type {?} */
var date = new Date(Date.UTC.apply(null, arguments));
// the Date.UTC function remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
date.setUTCFullYear(y);
}
return date;
}
/**
* @param {?=} y
* @param {?=} m
* @param {?=} d
* @param {?=} h
* @param {?=} M
* @param {?=} s
* @param {?=} ms
* @return {?}
*/
function createDate(y, m, d, h, M, s, ms) {
if (m === void 0) { m = 0; }
if (d === void 0) { d = 1; }
if (h === void 0) { h = 0; }
if (M === void 0) { M = 0; }
if (s === void 0) { s = 0; }
if (ms === void 0) { ms = 0; }
/** @type {?} */
var date = new Date(y, m, d, h, M, s, ms);
// the date constructor remaps years 0-99 to 1900-1999
if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
date.setFullYear(y);
}
return date;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getHours(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCHours() : date.getHours();
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getMinutes(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCMinutes() : date.getMinutes();
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getSeconds(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCSeconds() : date.getSeconds();
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getMilliseconds(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCMilliseconds() : date.getMilliseconds();
}
/**
* @param {?} date
* @return {?}
*/
function getTime(date) {
return date.getTime();
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getDay(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCDay() : date.getDay();
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getDate(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCDate() : date.getDate();
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getMonth(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCMonth() : date.getMonth();
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getFullYear(date, isUTC) {
if (isUTC === void 0) { isUTC = false; }
return isUTC ? date.getUTCFullYear() : date.getFullYear();
}
/**
* @param {?} date
* @return {?}
*/
function unix(date) {
return Math.floor(date.valueOf() / 1000);
}
/**
* @param {?} date
* @return {?}
*/
function getFirstDayOfMonth(date) {
return createDate(date.getFullYear(), date.getMonth(), 1, date.getHours(), date.getMinutes(), date.getSeconds());
}
/**
* @param {?} date
* @param {?} firstDayOfWeek
* @return {?}
*/
function isFirstDayOfWeek(date, firstDayOfWeek) {
return date.getDay() === firstDayOfWeek;
}
/**
* @param {?} date1
* @param {?} date2
* @return {?}
*/
function isSameMonth(date1, date2) {
if (!date1 || !date2) {
return false;
}
return isSameYear(date1, date2) && getMonth(date1) === getMonth(date2);
}
/**
* @param {?} date1
* @param {?} date2
* @return {?}
*/
function isSameYear(date1, date2) {
if (!date1 || !date2) {
return false;
}
return getFullYear(date1) === getFullYear(date2);
}
/**
* @param {?} date1
* @param {?} date2
* @return {?}
*/
function isSameDay(date1, date2) {
if (!date1 || !date2) {
return false;
}
return (isSameYear(date1, date2) &&
isSameMonth(date1, date2) &&
getDate(date1) === getDate(date2));
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var match1 = /\d/;
// 0 - 9
/** @type {?} */
var match2 = /\d\d/;
// 00 - 99
/** @type {?} */
var match3 = /\d{3}/;
// 000 - 999
/** @type {?} */
var match4 = /\d{4}/;
// 0000 - 9999
/** @type {?} */
var match6 = /[+-]?\d{6}/;
// -999999 - 999999
/** @type {?} */
var match1to2 = /\d\d?/;
// 0 - 99
/** @type {?} */
var match3to4 = /\d\d\d\d?/;
// 999 - 9999
/** @type {?} */
var match5to6 = /\d\d\d\d\d\d?/;
// 99999 - 999999
/** @type {?} */
var match1to3 = /\d{1,3}/;
// 0 - 999
/** @type {?} */
var match1to4 = /\d{1,4}/;
// 0 - 9999
/** @type {?} */
var match1to6 = /[+-]?\d{1,6}/;
// -999999 - 999999
/** @type {?} */
var matchUnsigned = /\d+/;
// 0 - inf
/** @type {?} */
var matchSigned = /[+-]?\d+/;
// +00:00 -00:00 +0000 -0000 or Z
/** @type {?} */
var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi;
// +00 -00 +00:00 -00:00 +0000 -0000 or Z
/** @type {?} */
var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/;
// 123456789 123456789.123
// any word (or two) characters or numbers including two/three word month in arabic.
// includes scottish gaelic two word and hyphenated months
// tslint:disable-next-line
/** @type {?} */
var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;
/** @type {?} */
var regexes = {};
/**
* @param {?} token
* @param {?} regex
* @param {?=} strictRegex
* @return {?}
*/
function addRegexToken(token, regex, strictRegex) {
if (isFunction(regex)) {
regexes[token] = regex;
return;
}
regexes[token] = function (isStrict, locale) {
return (isStrict && strictRegex) ? strictRegex : regex;
};
}
/**
* @param {?} token
* @param {?} locale
* @return {?}
*/
function getParseRegexForToken(token, locale) {
/** @type {?} */
var _strict = false;
if (!hasOwnProp(regexes, token)) {
return new RegExp(unescapeFormat(token));
}
return regexes[token](_strict, locale);
}
// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
/**
* @param {?} str
* @return {?}
*/
function unescapeFormat(str) {
// tslint:disable-next-line
return regexEscape(str
.replace('\\', '')
.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) { return p1 || p2 || p3 || p4; }));
}
/**
* @param {?} str
* @return {?}
*/
function regexEscape(str) {
return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var tokens = {};
/**
* @param {?} token
* @param {?} callback
* @return {?}
*/
function addParseToken(token, callback) {
/** @type {?} */
var _token = isString(token) ? [token] : token;
/** @type {?} */
var func = callback;
if (isNumber(callback)) {
func = function (input, array, config) {
array[callback] = toInt(input);
return config;
};
}
if (isArray(_token) && isFunction(func)) {
/** @type {?} */
var i = void 0;
for (i = 0; i < _token.length; i++) {
tokens[_token[i]] = func;
}
}
}
/**
* @param {?} token
* @param {?} callback
* @return {?}
*/
function addWeekParseToken(token, callback) {
addParseToken(token, function (input, array, config, _token) {
config._w = config._w || {};
return callback(input, config._w, config, _token);
});
}
/**
* @param {?} token
* @param {?} input
* @param {?} config
* @return {?}
*/
function addTimeToArrayFromToken(token, input, config) {
if (input != null && hasOwnProp(tokens, token)) {
tokens[token](input, config._a, config, token);
}
return config;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @return {?}
*/
function initDayOfMonth() {
// FORMATTING
addFormatToken('D', ['DD', 2, false], 'Do', function (date, opts) {
return getDate(date, opts.isUTC)
.toString(10);
});
// ALIASES
addUnitAlias('date', 'D');
// PARSING
addRegexToken('D', match1to2);
addRegexToken('DD', match1to2, match2);
addRegexToken('Do', function (isStrict, locale) {
return locale._dayOfMonthOrdinalParse || locale._ordinalParse;
});
addParseToken(['D', 'DD'], DATE);
addParseToken('Do', function (input, array, config) {
array[DATE] = toInt(input.match(match1to2)[0]);
return config;
});
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @return {?}
*/
function defaultParsingFlags() {
// We need to deep clone this object.
return {
empty: false,
unusedTokens: [],
unusedInput: [],
overflow: -2,
charsLeftOver: 0,
nullInput: false,
invalidMonth: null,
invalidFormat: false,
userInvalidated: false,
iso: false,
parsedDateParts: [],
meridiem: null,
rfc2822: false,
weekdayMismatch: false
};
}
/**
* @param {?} config
* @return {?}
*/
function getParsingFlags(config) {
if (config._pf == null) {
config._pf = defaultParsingFlags();
}
return config._pf;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// FORMATTING
/**
* @param {?} date
* @param {?} opts
* @return {?}
*/
function getYear(date, opts) {
return getFullYear(date, opts.isUTC).toString();
}
/**
* @return {?}
*/
function initYear() {
addFormatToken('Y', null, null, function (date, opts) {
/** @type {?} */
var y = getFullYear(date, opts.isUTC);
return y <= 9999 ? y.toString(10) : "+" + y;
});
addFormatToken(null, ['YY', 2, false], null, function (date, opts) {
return (getFullYear(date, opts.isUTC) % 100).toString(10);
});
addFormatToken(null, ['YYYY', 4, false], null, getYear);
addFormatToken(null, ['YYYYY', 5, false], null, getYear);
addFormatToken(null, ['YYYYYY', 6, true], null, getYear);
// ALIASES
addUnitAlias('year', 'y');
// PARSING
addRegexToken('Y', matchSigned);
addRegexToken('YY', match1to2, match2);
addRegexToken('YYYY', match1to4, match4);
addRegexToken('YYYYY', match1to6, match6);
addRegexToken('YYYYYY', match1to6, match6);
addParseToken(['YYYYY', 'YYYYYY'], YEAR);
addParseToken('YYYY', function (input, array, config) {
array[YEAR] = input.length === 2 ? parseTwoDigitYear(input) : toInt(input);
return config;
});
addParseToken('YY', function (input, array, config) {
array[YEAR] = parseTwoDigitYear(input);
return config;
});
addParseToken('Y', function (input, array, config) {
array[YEAR] = parseInt(input, 10);
return config;
});
}
/**
* @param {?} input
* @return {?}
*/
function parseTwoDigitYear(input) {
return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
}
/**
* @param {?} year
* @return {?}
*/
function daysInYear(year) {
return isLeapYear(year) ? 366 : 365;
}
/**
* @param {?} year
* @return {?}
*/
function isLeapYear(year) {
return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// todo: this is duplicate, source in date-getters.ts
/**
* @param {?} year
* @param {?} month
* @return {?}
*/
function daysInMonth$1(year, month) {
if (isNaN(year) || isNaN(month)) {
return NaN;
}
/** @type {?} */
var modMonth = mod(month, 12);
/** @type {?} */
var _year = year + (month - modMonth) / 12;
return modMonth === 1
? isLeapYear(_year) ? 29 : 28
: (31 - modMonth % 7 % 2);
}
/**
* @return {?}
*/
function initMonth() {
// FORMATTING
addFormatToken('M', ['MM', 2, false], 'Mo', function (date, opts) {
return (getMonth(date, opts.isUTC) + 1).toString(10);
});
addFormatToken('MMM', null, null, function (date, opts) {
return opts.locale.monthsShort(date, opts.format, opts.isUTC);
});
addFormatToken('MMMM', null, null, function (date, opts) {
return opts.locale.months(date, opts.format, opts.isUTC);
});
// ALIASES
addUnitAlias('month', 'M');
// PARSING
addRegexToken('M', match1to2);
addRegexToken('MM', match1to2, match2);
addRegexToken('MMM', function (isStrict, locale) {
return locale.monthsShortRegex(isStrict);
});
addRegexToken('MMMM', function (isStrict, locale) {
return locale.monthsRegex(isStrict);
});
addParseToken(['M', 'MM'], function (input, array, config) {
array[MONTH] = toInt(input) - 1;
return config;
});
addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
/** @type {?} */
var month = config._locale.monthsParse(input, token, config._strict);
// if we didn't find a month name, mark the date as invalid.
if (month != null) {
array[MONTH] = month;
}
else {
getParsingFlags(config).invalidMonth = !!input;
}
return config;
});
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var defaultTimeUnit = {
year: 0,
month: 0,
day: 0,
hour: 0,
minute: 0,
seconds: 0
};
/**
* @param {?} date
* @param {?} unit
* @return {?}
*/
function shiftDate(date, unit) {
/** @type {?} */
var _unit = Object.assign({}, defaultTimeUnit, unit);
/** @type {?} */
var year = date.getFullYear() + (_unit.year || 0);
/** @type {?} */
var month = date.getMonth() + (_unit.month || 0);
/** @type {?} */
var day = date.getDate() + (_unit.day || 0);
if (_unit.month && !_unit.day) {
day = Math.min(day, daysInMonth$1(year, month));
}
return createDate(year, month, day, date.getHours() + (_unit.hour || 0), date.getMinutes() + (_unit.minute || 0), date.getSeconds() + (_unit.seconds || 0));
}
/**
* @param {?} date
* @param {?} unit
* @return {?}
*/
function setFullDate(date, unit) {
return createDate(getNum(date.getFullYear(), unit.year), getNum(date.getMonth(), unit.month), getNum(date.getDate(), unit.day), getNum(date.getHours(), unit.hour), getNum(date.getMinutes(), unit.minute), getNum(date.getSeconds(), unit.seconds), getNum(date.getMilliseconds(), unit.milliseconds));
}
/**
* @param {?} def
* @param {?=} num
* @return {?}
*/
function getNum(def, num) {
return isNumber(num) ? num : def;
}
/**
* @param {?} date
* @param {?} value
* @param {?=} isUTC
* @return {?}
*/
function setMonth(date, value, isUTC) {
/** @type {?} */
var dayOfMonth = Math.min(getDate(date), daysInMonth$1(getFullYear(date), value));
isUTC ? date.setUTCMonth(value, dayOfMonth) : date.setMonth(value, dayOfMonth);
return date;
}
/**
* @param {?} date
* @param {?} value
* @param {?=} isUTC
* @return {?}
*/
function setHours(date, value, isUTC) {
isUTC ? date.setUTCHours(value) : date.setHours(value);
return date;
}
/**
* @param {?} date
* @param {?} value
* @param {?=} isUTC
* @return {?}
*/
function setMinutes(date, value, isUTC) {
isUTC ? date.setUTCMinutes(value) : date.setMinutes(value);
return date;
}
/**
* @param {?} date
* @param {?} value
* @param {?=} isUTC
* @return {?}
*/
function setSeconds(date, value, isUTC) {
isUTC ? date.setUTCSeconds(value) : date.setSeconds(value);
return date;
}
/**
* @param {?} date
* @param {?} value
* @param {?=} isUTC
* @return {?}
*/
function setMilliseconds(date, value, isUTC) {
isUTC ? date.setUTCMilliseconds(value) : date.setMilliseconds(value);
return date;
}
/**
* @param {?} date
* @param {?} value
* @param {?=} isUTC
* @return {?}
*/
function setDate(date, value, isUTC) {
isUTC ? date.setUTCDate(value) : date.setDate(value);
return date;
}
/**
* @param {?} date
* @param {?} value
* @return {?}
*/
function setTime(date, value) {
date.setTime(value);
return date;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// fastest way to clone date
// https://jsperf.com/clone-date-object2
/**
* @param {?} date
* @return {?}
*/
function cloneDate(date) {
return new Date(date.getTime());
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} date
* @param {?} unit
* @param {?=} isUTC
* @return {?}
*/
function startOf(date, unit, isUTC) {
/** @type {?} */
var _date = cloneDate(date);
// the following switch intentionally omits break keywords
// to utilize falling through the cases.
switch (unit) {
case 'year':
setMonth(_date, 0, isUTC);
/* falls through */
case 'quarter':
case 'month':
setDate(_date, 1, isUTC);
/* falls through */
case 'week':
case 'isoWeek':
case 'day':
case 'date':
setHours(_date, 0, isUTC);
/* falls through */
case 'hours':
setMinutes(_date, 0, isUTC);
/* falls through */
case 'minutes':
setSeconds(_date, 0, isUTC);
/* falls through */
case 'seconds':
setMilliseconds(_date, 0, isUTC);
}
// weeks are a special case
if (unit === 'week') {
setLocaleDayOfWeek(_date, 0, { isUTC: isUTC });
}
if (unit === 'isoWeek') {
setISODayOfWeek(_date, 1);
}
// quarters are also special
if (unit === 'quarter') {
setMonth(_date, Math.floor(getMonth(_date, isUTC) / 3) * 3, isUTC);
}
return _date;
}
/**
* @param {?} date
* @param {?} unit
* @param {?=} isUTC
* @return {?}
*/
function endOf(date, unit, isUTC) {
/** @type {?} */
var _unit = unit;
// 'date' is an alias for 'day', so it should be considered as such.
if (_unit === 'date') {
_unit = 'day';
}
/** @type {?} */
var start = startOf(date, _unit, isUTC);
/** @type {?} */
var _step = add(start, 1, _unit === 'isoWeek' ? 'week' : _unit, isUTC);
/** @type {?} */
var res = subtract(_step, 1, 'milliseconds', isUTC);
return res;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @return {?}
*/
function initDayOfYear() {
// FORMATTING
addFormatToken('DDD', ['DDDD', 3, false], 'DDDo', function (date) {
return getDayOfYear(date)
.toString(10);
});
// ALIASES
addUnitAlias('dayOfYear', 'DDD');
addRegexToken('DDD', match1to3);
addRegexToken('DDDD', match3);
addParseToken(['DDD', 'DDDD'], function (input, array, config) {
config._dayOfYear = toInt(input);
return config;
});
}
/**
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function getDayOfYear(date, isUTC) {
/** @type {?} */
var date1 = +startOf(date, 'day', isUTC);
/** @type {?} */
var date2 = +startOf(date, 'year', isUTC);
/** @type {?} */
var someDate = date1 - date2;
/** @type {?} */
var oneDay = 1000 * 60 * 60 * 24;
return Math.round(someDate / oneDay) + 1;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} year
* @param {?} dow
* @param {?} doy
* @return {?}
*/
function firstWeekOffset(year, dow, doy) {
// first-week day -- which january is always in the first week (4 for iso, 1 for other)
/** @type {?} */
var fwd = dow - doy + 7;
// first-week day local weekday -- which local weekday is fwd
/** @type {?} */
var fwdlw = (createUTCDate(year, 0, fwd).getUTCDay() - dow + 7) % 7;
return -fwdlw + fwd - 1;
}
// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
/**
* @param {?} year
* @param {?} week
* @param {?} weekday
* @param {?} dow
* @param {?} doy
* @return {?}
*/
function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
/** @type {?} */
var localWeekday = (7 + weekday - dow) % 7;
/** @type {?} */
var weekOffset = firstWeekOffset(year, dow, doy);
/** @type {?} */
var dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset;
/** @type {?} */
var resYear;
/** @type {?} */
var resDayOfYear;
if (dayOfYear <= 0) {
resYear = year - 1;
resDayOfYear = daysInYear(resYear) + dayOfYear;
}
else if (dayOfYear > daysInYear(year)) {
resYear = year + 1;
resDayOfYear = dayOfYear - daysInYear(year);
}
else {
resYear = year;
resDayOfYear = dayOfYear;
}
return {
year: resYear,
dayOfYear: resDayOfYear
};
}
/**
* @param {?} date
* @param {?} dow
* @param {?} doy
* @param {?=} isUTC
* @return {?}
*/
function weekOfYear(date, dow, doy, isUTC) {
/** @type {?} */
var weekOffset = firstWeekOffset(getFullYear(date, isUTC), dow, doy);
/** @type {?} */
var week = Math.floor((getDayOfYear(date, isUTC) - weekOffset - 1) / 7) + 1;
/** @type {?} */
var resWeek;
/** @type {?} */
var resYear;
if (week < 1) {
resYear = getFullYear(date, isUTC) - 1;
resWeek = week + weeksInYear(resYear, dow, doy);
}
else if (week > weeksInYear(getFullYear(date, isUTC), dow, doy)) {
resWeek = week - weeksInYear(getFullYear(date, isUTC), dow, doy);
resYear = getFullYear(date, isUTC) + 1;
}
else {
resYear = getFullYear(date, isUTC);
resWeek = week;
}
return {
week: resWeek,
year: resYear
};
}
/**
* @param {?} year
* @param {?} dow
* @param {?} doy
* @return {?}
*/
function weeksInYear(year, dow, doy) {
/** @type {?} */
var weekOffset = firstWeekOffset(year, dow, doy);
/** @type {?} */
var weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
/** @type {?} */
var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
/** @type {?} */
var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
/** @type {?} */
var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
/** @type {?} */
var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
/** @type {?} */
var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
/** @type {?} */
var defaultLongDateFormat = {
LTS: 'h:mm:ss A',
LT: 'h:mm A',
L: 'MM/DD/YYYY',
LL: 'MMMM D, YYYY',
LLL: 'MMMM D, YYYY h:mm A',
LLLL: 'dddd, MMMM D, YYYY h:mm A'
};
/** @type {?} */
var defaultOrdinal = '%d';
/** @type {?} */
var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
/** @type {?} */
var defaultMonthsShortRegex = matchWord;
/** @type {?} */
var defaultMonthsRegex = matchWord;
var Locale = /** @class */ (function () {
function Locale(config) {
if (!!config) {
this.set(config);
}
}
/**
* @param {?} config
* @return {?}
*/
Locale.prototype.set = /**
* @param {?} config
* @return {?}
*/
function (config) {
/** @type {?} */
var confKey;
for (confKey in config) {
if (!config.hasOwnProperty(confKey)) {
continue;
}
/** @type {?} */
var prop = config[(/** @type {?} */ (confKey))];
/** @type {?} */
var key = (/** @type {?} */ ((isFunction(prop) ? confKey : "_" + confKey)));
this[key] = (/** @type {?} */ (prop));
}
this._config = config;
};
/**
* @param {?} key
* @param {?} date
* @param {?} now
* @return {?}
*/
Locale.prototype.calendar = /**
* @param {?} key
* @param {?} date
* @param {?} now
* @return {?}
*/
function (key, date, now) {
/** @type {?} */
var output = this._calendar[key] || this._calendar.sameElse;
return isFunction(output) ? output.call(null, date, now) : output;
};
/**
* @param {?} key
* @return {?}
*/
Locale.prototype.longDateFormat = /**
* @param {?} key
* @return {?}
*/
function (key) {
/** @type {?} */
var format = this._longDateFormat[key];
/** @type {?} */
var formatUpper = this._longDateFormat[key.toUpperCase()];
if (format || !formatUpper) {
return format;
}
this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
return val.slice(1);
});
return this._longDateFormat[key];
};
Object.defineProperty(Locale.prototype, "invalidDate", {
get: /**
* @return {?}
*/
function () {
return this._invalidDate;
},
set: /**
* @param {?} val
* @return {?}
*/
function (val) {
this._invalidDate = val;
},
enumerable: true,
configurable: true
});
/**
* @param {?} num
* @param {?=} token
* @return {?}
*/
Locale.prototype.ordinal = /**
* @param {?} num
* @param {?=} token
* @return {?}
*/
function (num, token) {
return this._ordinal.replace('%d', num.toString(10));
};
/**
* @param {?} str
* @return {?}
*/
Locale.prototype.preparse = /**
* @param {?} str
* @return {?}
*/
function (str) {
return str;
};
/**
* @param {?} str
* @return {?}
*/
Locale.prototype.postformat = /**
* @param {?} str
* @return {?}
*/
function (str) {
return str;
};
/**
* @param {?} num
* @param {?} withoutSuffix
* @param {?} str
* @param {?} isFuture
* @return {?}
*/
Locale.prototype.relativeTime = /**
* @param {?} num
* @param {?} withoutSuffix
* @param {?} str
* @param {?} isFuture
* @return {?}
*/
function (num, withoutSuffix, str, isFuture) {
/** @type {?} */
var output = this._relativeTime[str];
return (isFunction(output)) ?
output(num, withoutSuffix, str, isFuture) :
output.replace(/%d/i, num.toString(10));
};
/**
* @param {?} diff
* @param {?} output
* @return {?}
*/
Locale.prototype.pastFuture = /**
* @param {?} diff
* @param {?} output
* @return {?}
*/
function (diff, output) {
/** @type {?} */
var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
return isFunction(format) ? format(output) : format.replace(/%s/i, output);
};
/**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
Locale.prototype.months = /**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
function (date, format, isUTC) {
if (isUTC === void 0) { isUTC = false; }
if (!date) {
return isArray(this._months)
? this._months
: this._months.standalone;
}
if (isArray(this._months)) {
return this._months[getMonth(date, isUTC)];
}
/** @type {?} */
var key = (this._months.isFormat || MONTHS_IN_FORMAT).test(format)
? 'format'
: 'standalone';
return this._months[key][getMonth(date, isUTC)];
};
/**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
Locale.prototype.monthsShort = /**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
function (date, format, isUTC) {
if (isUTC === void 0) { isUTC = false; }
if (!date) {
return isArray(this._monthsShort)
? this._monthsShort
: this._monthsShort.standalone;
}
if (isArray(this._monthsShort)) {
return this._monthsShort[getMonth(date, isUTC)];
}
/** @type {?} */
var key = MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone';
return this._monthsShort[key][getMonth(date, isUTC)];
};
/**
* @param {?} monthName
* @param {?=} format
* @param {?=} strict
* @return {?}
*/
Locale.prototype.monthsParse = /**
* @param {?} monthName
* @param {?=} format
* @param {?=} strict
* @return {?}
*/
function (monthName, format, strict) {
/** @type {?} */
var date;
/** @type {?} */
var regex;
if (this._monthsParseExact) {
return this.handleMonthStrictParse(monthName, format, strict);
}
if (!this._monthsParse) {
this._monthsParse = [];
this._longMonthsParse = [];
this._shortMonthsParse = [];
}
// TODO: add sorting
// Sorting makes sure if one month (or abbr) is a prefix of another
// see sorting in computeMonthsParse
/** @type {?} */
var i;
for (i = 0; i < 12; i++) {
// make the regex if we don't have it already
date = new Date(Date.UTC(2000, i));
if (strict && !this._longMonthsParse[i]) {
/** @type {?} */
var _months = this.months(date, '', true).replace('.', '');
/** @type {?} */
var _shortMonths = this.monthsShort(date, '', true).replace('.', '');
this._longMonthsParse[i] = new RegExp("^" + _months + "$", 'i');
this._shortMonthsParse[i] = new RegExp("^" + _shortMonths + "$", 'i');
}
if (!strict && !this._monthsParse[i]) {
regex = "^" + this.months(date, '', true) + "|^" + this.monthsShort(date, '', true);
this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
}
// test the regex
if (strict && format === 'MMMM' && ((/** @type {?} */ (this._longMonthsParse[i]))).test(monthName)) {
return i;
}
if (strict && format === 'MMM' && ((/** @type {?} */ (this._shortMonthsParse[i]))).test(monthName)) {
return i;
}
if (!strict && this._monthsParse[i].test(monthName)) {
return i;
}
}
};
/**
* @param {?} isStrict
* @return {?}
*/
Locale.prototype.monthsRegex = /**
* @param {?} isStrict
* @return {?}
*/
function (isStrict) {
if (this._monthsParseExact) {
if (!hasOwnProp(this, '_monthsRegex')) {
this.computeMonthsParse();
}
if (isStrict) {
return this._monthsStrictRegex;
}
return this._monthsRegex;
}
if (!hasOwnProp(this, '_monthsRegex')) {
this._monthsRegex = defaultMonthsRegex;
}
return this._monthsStrictRegex && isStrict ?
this._monthsStrictRegex : this._monthsRegex;
};
/**
* @param {?} isStrict
* @return {?}
*/
Locale.prototype.monthsShortRegex = /**
* @param {?} isStrict
* @return {?}
*/
function (isStrict) {
if (this._monthsParseExact) {
if (!hasOwnProp(this, '_monthsRegex')) {
this.computeMonthsParse();
}
if (isStrict) {
return this._monthsShortStrictRegex;
}
return this._monthsShortRegex;
}
if (!hasOwnProp(this, '_monthsShortRegex')) {
this._monthsShortRegex = defaultMonthsShortRegex;
}
return this._monthsShortStrictRegex && isStrict ?
this._monthsShortStrictRegex : this._monthsShortRegex;
};
/** Week */
/**
* Week
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
Locale.prototype.week = /**
* Week
* @param {?} date
* @param {?=} isUTC
* @return {?}
*/
function (date, isUTC) {
return weekOfYear(date, this._week.dow, this._week.doy, isUTC).week;
};
/**
* @return {?}
*/
Locale.prototype.firstDayOfWeek = /**
* @return {?}
*/
function () {
return this._week.dow;
};
/**
* @return {?}
*/
Locale.prototype.firstDayOfYear = /**
* @return {?}
*/
function () {
return this._week.doy;
};
/**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
Locale.prototype.weekdays = /**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
function (date, format, isUTC) {
if (!date) {
return isArray(this._weekdays)
? this._weekdays
: this._weekdays.standalone;
}
if (isArray(this._weekdays)) {
return this._weekdays[getDay(date, isUTC)];
}
/** @type {?} */
var _key = this._weekdays.isFormat.test(format)
? 'format'
: 'standalone';
return this._weekdays[_key][getDay(date, isUTC)];
};
/**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
Locale.prototype.weekdaysMin = /**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
function (date, format, isUTC) {
return date ? this._weekdaysMin[getDay(date, isUTC)] : this._weekdaysMin;
};
/**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
Locale.prototype.weekdaysShort = /**
* @param {?=} date
* @param {?=} format
* @param {?=} isUTC
* @return {?}
*/
function (date, format, isUTC) {
return date ? this._weekdaysShort[getDay(date, isUTC)] : this._weekdaysShort;
};
// proto.weekdaysParse = localeWeekdaysParse;
// proto.weekdaysParse = localeWeekdaysParse;
/**
* @param {?=} weekdayName
* @param {?=} format
* @param {?=} strict
* @return {?}
*/
Locale.prototype.weekdaysParse =
// proto.weekdaysParse = localeWeekdaysParse;
/**
* @param {?=} weekdayName
* @param {?=} format
* @param {?=} strict
* @return {?}
*/
function (weekdayName, format, strict) {
/** @type {?} */
var i;
/** @type {?} */
var regex;
if (this._weekdaysParseExact) {
return this.handleWeekStrictParse(weekdayName, format, strict);
}
if (!this._weekdaysParse) {
this._weekdaysParse = [];
this._minWeekdaysParse = [];
this._shortWeekdaysParse = [];
this._fullWeekdaysParse = [];
}
for (i = 0; i < 7; i++) {
// make the regex if we don't have it already
// fix: here is the issue
/** @type {?} */
var date = setDayOfWeek(new Date(Date.UTC(2000, 1)), i, null, true);
if (strict && !this._fullWeekdaysParse[i]) {
this._fullWeekdaysParse[i] = new RegExp("^" + this.weekdays(date, '', true).replace('.', '\.?') + "$", 'i');
this._shortWeekdaysParse[i] = new RegExp("^" + this.weekdaysShort(date, '', true).replace('.', '\.?') + "$", 'i');
this._minWeekdaysParse[i] = new RegExp("^" + this.weekdaysMin(date, '', true).replace('.', '\.?') + "$", 'i');
}
if (!this._weekdaysParse[i]) {
regex = "^" + this.weekdays(date, '', true) + "|^" + this.weekdaysShort(date, '', true) + "|^" + this.weekdaysMin(date, '', true);
this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
}
if (!isArray(this._fullWeekdaysParse)
|| !isArray(this._shortWeekdaysParse)
|| !isArray(this._minWeekdaysParse)
|| !isArray(this._weekdaysParse)) {
return;
}
// test the regex
if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
return i;
}
else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
return i;
}
else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
return i;
}
else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
return i;
}
}
};
// proto.weekdaysRegex = weekdaysRegex;
// proto.weekdaysRegex = weekdaysRegex;
/**
* @param {?} isStrict
* @return {?}
*/
Locale.prototype.weekdaysRegex =
// proto.weekdaysRegex = weekdaysRegex;
/**
* @param {?} isStrict
* @return {?}
*/
function (isStrict) {
if (this._weekdaysParseExact) {
if (!hasOwnProp(this, '_weekdaysRegex')) {
this.computeWeekdaysParse();
}
if (isStrict) {
return this._weekdaysStrictRegex;
}
else {
return this._weekdaysRegex;
}
}
else {
if (!hasOwnProp(this, '_weekdaysRegex')) {
this._weekdaysRegex = matchWord;
}
return this._weekdaysStrictRegex && isStrict ?
this._weekdaysStrictRegex : this._weekdaysRegex;
}
};
// proto.weekdaysShortRegex = weekdaysShortRegex;
// proto.weekdaysMinRegex = weekdaysMinRegex;
// proto.weekdaysShortRegex = weekdaysShortRegex;
// proto.weekdaysMinRegex = weekdaysMinRegex;
/**
* @param {?=} isStrict
* @return {?}
*/
Locale.prototype.weekdaysShortRegex =
// proto.weekdaysShortRegex = weekdaysShortRegex;
// proto.weekdaysMinRegex = weekdaysMinRegex;
/**
* @param {?=} isStrict
* @return {?}
*/
function (isStrict) {
if (this._weekdaysParseExact) {
if (!hasOwnProp(this, '_weekdaysRegex')) {
this.computeWeekdaysParse();
}
if (isStrict) {
return this._weekdaysShortStrictRegex;
}
else {
return this._weekdaysShortRegex;
}
}
else {
if (!hasOwnProp(this, '_weekdaysShortRegex')) {
this._weekdaysShortRegex = matchWord;
}
return this._weekdaysShortStrictRegex && isStrict ?
this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
}
};
/**
* @param {?=} isStrict
* @return {?}
*/
Locale.prototype.weekdaysMinRegex = /**
* @param {?=} isStrict
* @return {?}
*/
function (isStrict) {
if (this._weekdaysParseExact) {
if (!hasOwnProp(this, '_weekdaysRegex')) {
this.computeWeekdaysParse();
}
if (isStrict) {
return this._weekdaysMinStrictRegex;
}
else {
return this._weekdaysMinRegex;
}
}
else {
if (!hasOwnProp(this, '_weekdaysMinRegex')) {
this._weekdaysMinRegex = matchWord;
}
return this._weekdaysMinStrictRegex && isStrict ?
this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
}
};
/**
* @param {?} input
* @return {?}
*/
Locale.prototype.isPM = /**
* @param {?} input
* @return {?}
*/
function (input) {
// IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
// Using charAt should be more compatible.
return input.toLowerCase().charAt(0) === 'p';
};
/**
* @param {?} hours
* @param {?} minutes
* @param {?} isLower
* @return {?}
*/
Locale.prototype.meridiem = /**
* @param {?} hours
* @param {?} minutes
* @param {?} isLower
* @return {?}
*/
function (hours, minutes, isLower) {
if (hours > 11) {
return isLower ? 'pm' : 'PM';
}
return isLower ? 'am' : 'AM';
};
/**
* @param {?} key
* @return {?}
*/
Locale.prototype.formatLongDate = /**
* @param {?} key
* @return {?}
*/
function (key) {
this._longDateFormat = this._longDateFormat ? this._longDateFormat : defaultLongDateFormat;
/** @type {?} */
var format = this._lo