| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/jungly/node_modules/vee-validate/dist/ |
Upload File : |
/**
* vee-validate v2.2.15
* (c) 2019 Abdelrahman Awad
* @license MIT
*/
function toInteger (dirtyNumber) {
if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
return NaN
}
var number = Number(dirtyNumber);
if (isNaN(number)) {
return number
}
return number < 0 ? Math.ceil(number) : Math.floor(number)
}
var MILLISECONDS_IN_MINUTE = 60000;
/**
* Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
* They usually appear for dates that denote time before the timezones were introduced
* (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
* and GMT+01:00:00 after that date)
*
* Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
* which would lead to incorrect calculations.
*
* This function returns the timezone offset in milliseconds that takes seconds in account.
*/
function getTimezoneOffsetInMilliseconds (dirtyDate) {
var date = new Date(dirtyDate.getTime());
var baseTimezoneOffset = date.getTimezoneOffset();
date.setSeconds(0, 0);
var millisecondsPartOfTimezoneOffset = date.getTime() % MILLISECONDS_IN_MINUTE;
return baseTimezoneOffset * MILLISECONDS_IN_MINUTE + millisecondsPartOfTimezoneOffset
}
var MILLISECONDS_IN_HOUR = 3600000;
var MILLISECONDS_IN_MINUTE$1 = 60000;
var DEFAULT_ADDITIONAL_DIGITS = 2;
var patterns = {
dateTimeDelimeter: /[T ]/,
plainTime: /:/,
timeZoneDelimeter: /[Z ]/i,
// year tokens
YY: /^(\d{2})$/,
YYY: [
/^([+-]\d{2})$/, // 0 additional digits
/^([+-]\d{3})$/, // 1 additional digit
/^([+-]\d{4})$/ // 2 additional digits
],
YYYY: /^(\d{4})/,
YYYYY: [
/^([+-]\d{4})/, // 0 additional digits
/^([+-]\d{5})/, // 1 additional digit
/^([+-]\d{6})/ // 2 additional digits
],
// date tokens
MM: /^-(\d{2})$/,
DDD: /^-?(\d{3})$/,
MMDD: /^-?(\d{2})-?(\d{2})$/,
Www: /^-?W(\d{2})$/,
WwwD: /^-?W(\d{2})-?(\d{1})$/,
HH: /^(\d{2}([.,]\d*)?)$/,
HHMM: /^(\d{2}):?(\d{2}([.,]\d*)?)$/,
HHMMSS: /^(\d{2}):?(\d{2}):?(\d{2}([.,]\d*)?)$/,
// timezone tokens
timezone: /([Z+-].*)$/,
timezoneZ: /^(Z)$/,
timezoneHH: /^([+-])(\d{2})$/,
timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/
};
/**
* @name toDate
* @category Common Helpers
* @summary Convert the given argument to an instance of Date.
*
* @description
* Convert the given argument to an instance of Date.
*
* If the argument is an instance of Date, the function returns its clone.
*
* If the argument is a number, it is treated as a timestamp.
*
* If an argument is a string, the function tries to parse it.
* Function accepts complete ISO 8601 formats as well as partial implementations.
* ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
* If the function cannot parse the string or the values are invalid, it returns Invalid Date.
*
* If the argument is none of the above, the function returns Invalid Date.
*
* **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
* All *date-fns* functions will throw `RangeError` if `options.additionalDigits` is not 0, 1, 2 or undefined.
*
* @param {Date|String|Number} argument - the value to convert
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - the additional number of digits in the extended year format
* @returns {Date} the parsed date in the local time zone
* @throws {TypeError} 1 argument required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
*
* @example
* // Convert string '2014-02-11T11:30:30' to date:
* var result = toDate('2014-02-11T11:30:30')
* //=> Tue Feb 11 2014 11:30:30
*
* @example
* // Convert string '+02014101' to date,
* // if the additional number of digits in the extended year format is 1:
* var result = toDate('+02014101', {additionalDigits: 1})
* //=> Fri Apr 11 2014 00:00:00
*/
function toDate (argument, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
if (argument === null) {
return new Date(NaN)
}
var options = dirtyOptions || {};
var additionalDigits = options.additionalDigits == null ? DEFAULT_ADDITIONAL_DIGITS : toInteger(options.additionalDigits);
if (additionalDigits !== 2 && additionalDigits !== 1 && additionalDigits !== 0) {
throw new RangeError('additionalDigits must be 0, 1 or 2')
}
// Clone the date
if (argument instanceof Date ||
(typeof argument === 'object' && Object.prototype.toString.call(argument) === '[object Date]')
) {
// Prevent the date to lose the milliseconds when passed to new Date() in IE10
return new Date(argument.getTime())
} else if (typeof argument === 'number' || Object.prototype.toString.call(argument) === '[object Number]') {
return new Date(argument)
} else if (!(typeof argument === 'string' || Object.prototype.toString.call(argument) === '[object String]')) {
return new Date(NaN)
}
var dateStrings = splitDateString(argument);
var parseYearResult = parseYear(dateStrings.date, additionalDigits);
var year = parseYearResult.year;
var restDateString = parseYearResult.restDateString;
var date = parseDate(restDateString, year);
if (isNaN(date)) {
return new Date(NaN)
}
if (date) {
var timestamp = date.getTime();
var time = 0;
var offset;
if (dateStrings.time) {
time = parseTime(dateStrings.time);
if (isNaN(time)) {
return new Date(NaN)
}
}
if (dateStrings.timezone) {
offset = parseTimezone(dateStrings.timezone);
if (isNaN(offset)) {
return new Date(NaN)
}
} else {
// get offset accurate to hour in timezones that change offset
offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time));
offset = getTimezoneOffsetInMilliseconds(new Date(timestamp + time + offset));
}
return new Date(timestamp + time + offset)
} else {
return new Date(NaN)
}
}
function splitDateString (dateString) {
var dateStrings = {};
var array = dateString.split(patterns.dateTimeDelimeter);
var timeString;
if (patterns.plainTime.test(array[0])) {
dateStrings.date = null;
timeString = array[0];
} else {
dateStrings.date = array[0];
timeString = array[1];
if (patterns.timeZoneDelimeter.test(dateStrings.date)) {
dateStrings.date = dateString.split(patterns.timeZoneDelimeter)[0];
timeString = dateString.substr(dateStrings.date.length, dateString.length);
}
}
if (timeString) {
var token = patterns.timezone.exec(timeString);
if (token) {
dateStrings.time = timeString.replace(token[1], '');
dateStrings.timezone = token[1];
} else {
dateStrings.time = timeString;
}
}
return dateStrings
}
function parseYear (dateString, additionalDigits) {
var patternYYY = patterns.YYY[additionalDigits];
var patternYYYYY = patterns.YYYYY[additionalDigits];
var token;
// YYYY or ±YYYYY
token = patterns.YYYY.exec(dateString) || patternYYYYY.exec(dateString);
if (token) {
var yearString = token[1];
return {
year: parseInt(yearString, 10),
restDateString: dateString.slice(yearString.length)
}
}
// YY or ±YYY
token = patterns.YY.exec(dateString) || patternYYY.exec(dateString);
if (token) {
var centuryString = token[1];
return {
year: parseInt(centuryString, 10) * 100,
restDateString: dateString.slice(centuryString.length)
}
}
// Invalid ISO-formatted year
return {
year: null
}
}
function parseDate (dateString, year) {
// Invalid ISO-formatted year
if (year === null) {
return null
}
var token;
var date;
var month;
var week;
// YYYY
if (dateString.length === 0) {
date = new Date(0);
date.setUTCFullYear(year);
return date
}
// YYYY-MM
token = patterns.MM.exec(dateString);
if (token) {
date = new Date(0);
month = parseInt(token[1], 10) - 1;
if (!validateDate(year, month)) {
return new Date(NaN)
}
date.setUTCFullYear(year, month);
return date
}
// YYYY-DDD or YYYYDDD
token = patterns.DDD.exec(dateString);
if (token) {
date = new Date(0);
var dayOfYear = parseInt(token[1], 10);
if (!validateDayOfYearDate(year, dayOfYear)) {
return new Date(NaN)
}
date.setUTCFullYear(year, 0, dayOfYear);
return date
}
// YYYY-MM-DD or YYYYMMDD
token = patterns.MMDD.exec(dateString);
if (token) {
date = new Date(0);
month = parseInt(token[1], 10) - 1;
var day = parseInt(token[2], 10);
if (!validateDate(year, month, day)) {
return new Date(NaN)
}
date.setUTCFullYear(year, month, day);
return date
}
// YYYY-Www or YYYYWww
token = patterns.Www.exec(dateString);
if (token) {
week = parseInt(token[1], 10) - 1;
if (!validateWeekDate(year, week)) {
return new Date(NaN)
}
return dayOfISOWeekYear(year, week)
}
// YYYY-Www-D or YYYYWwwD
token = patterns.WwwD.exec(dateString);
if (token) {
week = parseInt(token[1], 10) - 1;
var dayOfWeek = parseInt(token[2], 10) - 1;
if (!validateWeekDate(year, week, dayOfWeek)) {
return new Date(NaN)
}
return dayOfISOWeekYear(year, week, dayOfWeek)
}
// Invalid ISO-formatted date
return null
}
function parseTime (timeString) {
var token;
var hours;
var minutes;
// hh
token = patterns.HH.exec(timeString);
if (token) {
hours = parseFloat(token[1].replace(',', '.'));
if (!validateTime(hours)) {
return NaN
}
return (hours % 24) * MILLISECONDS_IN_HOUR
}
// hh:mm or hhmm
token = patterns.HHMM.exec(timeString);
if (token) {
hours = parseInt(token[1], 10);
minutes = parseFloat(token[2].replace(',', '.'));
if (!validateTime(hours, minutes)) {
return NaN
}
return (hours % 24) * MILLISECONDS_IN_HOUR +
minutes * MILLISECONDS_IN_MINUTE$1
}
// hh:mm:ss or hhmmss
token = patterns.HHMMSS.exec(timeString);
if (token) {
hours = parseInt(token[1], 10);
minutes = parseInt(token[2], 10);
var seconds = parseFloat(token[3].replace(',', '.'));
if (!validateTime(hours, minutes, seconds)) {
return NaN
}
return (hours % 24) * MILLISECONDS_IN_HOUR +
minutes * MILLISECONDS_IN_MINUTE$1 +
seconds * 1000
}
// Invalid ISO-formatted time
return null
}
function parseTimezone (timezoneString) {
var token;
var absoluteOffset;
// Z
token = patterns.timezoneZ.exec(timezoneString);
if (token) {
return 0
}
var hours;
// ±hh
token = patterns.timezoneHH.exec(timezoneString);
if (token) {
hours = parseInt(token[2], 10);
if (!validateTimezone()) {
return NaN
}
absoluteOffset = hours * MILLISECONDS_IN_HOUR;
return (token[1] === '+') ? -absoluteOffset : absoluteOffset
}
// ±hh:mm or ±hhmm
token = patterns.timezoneHHMM.exec(timezoneString);
if (token) {
hours = parseInt(token[2], 10);
var minutes = parseInt(token[3], 10);
if (!validateTimezone(hours, minutes)) {
return NaN
}
absoluteOffset = hours * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE$1;
return (token[1] === '+') ? -absoluteOffset : absoluteOffset
}
return 0
}
function dayOfISOWeekYear (isoWeekYear, week, day) {
week = week || 0;
day = day || 0;
var date = new Date(0);
date.setUTCFullYear(isoWeekYear, 0, 4);
var fourthOfJanuaryDay = date.getUTCDay() || 7;
var diff = week * 7 + day + 1 - fourthOfJanuaryDay;
date.setUTCDate(date.getUTCDate() + diff);
return date
}
// Validation functions
var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
var DAYS_IN_MONTH_LEAP_YEAR = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
function isLeapYearIndex (year) {
return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)
}
function validateDate (year, month, date) {
if (month < 0 || month > 11) {
return false
}
if (date != null) {
if (date < 1) {
return false
}
var isLeapYear = isLeapYearIndex(year);
if (isLeapYear && date > DAYS_IN_MONTH_LEAP_YEAR[month]) {
return false
}
if (!isLeapYear && date > DAYS_IN_MONTH[month]) {
return false
}
}
return true
}
function validateDayOfYearDate (year, dayOfYear) {
if (dayOfYear < 1) {
return false
}
var isLeapYear = isLeapYearIndex(year);
if (isLeapYear && dayOfYear > 366) {
return false
}
if (!isLeapYear && dayOfYear > 365) {
return false
}
return true
}
function validateWeekDate (year, week, day) {
if (week < 0 || week > 52) {
return false
}
if (day != null && (day < 0 || day > 6)) {
return false
}
return true
}
function validateTime (hours, minutes, seconds) {
if (hours != null && (hours < 0 || hours >= 25)) {
return false
}
if (minutes != null && (minutes < 0 || minutes >= 60)) {
return false
}
if (seconds != null && (seconds < 0 || seconds >= 60)) {
return false
}
return true
}
function validateTimezone (hours, minutes) {
if (minutes != null && (minutes < 0 || minutes > 59)) {
return false
}
return true
}
/**
* @name addMilliseconds
* @category Millisecond Helpers
* @summary Add the specified number of milliseconds to the given date.
*
* @description
* Add the specified number of milliseconds to the given date.
*
* @param {Date|String|Number} date - the date to be changed
* @param {Number} amount - the amount of milliseconds to be added
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @returns {Date} the new date with the milliseconds added
* @throws {TypeError} 2 arguments required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
*
* @example
* // Add 750 milliseconds to 10 July 2014 12:45:30.000:
* var result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
* //=> Thu Jul 10 2014 12:45:30.750
*/
function addMilliseconds (dirtyDate, dirtyAmount, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var timestamp = toDate(dirtyDate, dirtyOptions).getTime();
var amount = toInteger(dirtyAmount);
return new Date(timestamp + amount)
}
/**
* @name isValid
* @category Common Helpers
* @summary Is the given date valid?
*
* @description
* Returns false if argument is Invalid Date and true otherwise.
* Argument is converted to Date using `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* Invalid Date is a Date, whose time value is NaN.
*
* Time value of Date: http://es5.github.io/#x15.9.1.1
*
* @param {*} date - the date to check
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @returns {Boolean} the date is valid
* @throws {TypeError} 1 argument required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
*
* @example
* // For the valid date:
* var result = isValid(new Date(2014, 1, 31))
* //=> true
*
* @example
* // For the value, convertable into a date:
* var result = isValid('2014-02-31')
* //=> true
*
* @example
* // For the invalid date:
* var result = isValid(new Date(''))
* //=> false
*/
function isValid (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
return !isNaN(date)
}
var formatDistanceLocale = {
lessThanXSeconds: {
one: 'less than a second',
other: 'less than {{count}} seconds'
},
xSeconds: {
one: '1 second',
other: '{{count}} seconds'
},
halfAMinute: 'half a minute',
lessThanXMinutes: {
one: 'less than a minute',
other: 'less than {{count}} minutes'
},
xMinutes: {
one: '1 minute',
other: '{{count}} minutes'
},
aboutXHours: {
one: 'about 1 hour',
other: 'about {{count}} hours'
},
xHours: {
one: '1 hour',
other: '{{count}} hours'
},
xDays: {
one: '1 day',
other: '{{count}} days'
},
aboutXMonths: {
one: 'about 1 month',
other: 'about {{count}} months'
},
xMonths: {
one: '1 month',
other: '{{count}} months'
},
aboutXYears: {
one: 'about 1 year',
other: 'about {{count}} years'
},
xYears: {
one: '1 year',
other: '{{count}} years'
},
overXYears: {
one: 'over 1 year',
other: 'over {{count}} years'
},
almostXYears: {
one: 'almost 1 year',
other: 'almost {{count}} years'
}
};
function formatDistance (token, count, options) {
options = options || {};
var result;
if (typeof formatDistanceLocale[token] === 'string') {
result = formatDistanceLocale[token];
} else if (count === 1) {
result = formatDistanceLocale[token].one;
} else {
result = formatDistanceLocale[token].other.replace('{{count}}', count);
}
if (options.addSuffix) {
if (options.comparison > 0) {
return 'in ' + result
} else {
return result + ' ago'
}
}
return result
}
function buildFormatLongFn (args) {
return function (dirtyOptions) {
var options = dirtyOptions || {};
var width = options.width ? String(options.width) : args.defaultWidth;
var format = args.formats[width] || args.formats[args.defaultWidth];
return format
}
}
var dateFormats = {
full: 'EEEE, MMMM do, y',
long: 'MMMM do, y',
medium: 'MMM d, y',
short: 'MM/dd/yyyy'
};
var timeFormats = {
full: 'h:mm:ss a zzzz',
long: 'h:mm:ss a z',
medium: 'h:mm:ss a',
short: 'h:mm a'
};
var dateTimeFormats = {
full: "{{date}} 'at' {{time}}",
long: "{{date}} 'at' {{time}}",
medium: '{{date}}, {{time}}',
short: '{{date}}, {{time}}'
};
var formatLong = {
date: buildFormatLongFn({
formats: dateFormats,
defaultWidth: 'full'
}),
time: buildFormatLongFn({
formats: timeFormats,
defaultWidth: 'full'
}),
dateTime: buildFormatLongFn({
formats: dateTimeFormats,
defaultWidth: 'full'
})
};
var formatRelativeLocale = {
lastWeek: "'last' eeee 'at' p",
yesterday: "'yesterday at' p",
today: "'today at' p",
tomorrow: "'tomorrow at' p",
nextWeek: "eeee 'at' p",
other: 'P'
};
function formatRelative (token, date, baseDate, options) {
return formatRelativeLocale[token]
}
function buildLocalizeFn (args) {
return function (dirtyIndex, dirtyOptions) {
var options = dirtyOptions || {};
var width = options.width ? String(options.width) : args.defaultWidth;
var context = options.context ? String(options.context) : 'standalone';
var valuesArray;
if (context === 'formatting' && args.formattingValues) {
valuesArray = args.formattingValues[width] || args.formattingValues[args.defaultFormattingWidth];
} else {
valuesArray = args.values[width] || args.values[args.defaultWidth];
}
var index = args.argumentCallback ? args.argumentCallback(dirtyIndex) : dirtyIndex;
return valuesArray[index]
}
}
var eraValues = {
narrow: ['B', 'A'],
abbreviated: ['BC', 'AD'],
wide: ['Before Christ', 'Anno Domini']
};
var quarterValues = {
narrow: ['1', '2', '3', '4'],
abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter']
};
// Note: in English, the names of days of the week and months are capitalized.
// If you are making a new locale based on this one, check if the same is true for the language you're working on.
// Generally, formatted dates should look like they are in the middle of a sentence,
// e.g. in Spanish language the weekdays and months should be in the lowercase.
var monthValues = {
narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
wide: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
};
var dayValues = {
narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
};
var dayPeriodValues = {
narrow: {
am: 'a',
pm: 'p',
midnight: 'mi',
noon: 'n',
morning: 'morning',
afternoon: 'afternoon',
evening: 'evening',
night: 'night'
},
abbreviated: {
am: 'AM',
pm: 'PM',
midnight: 'midnight',
noon: 'noon',
morning: 'morning',
afternoon: 'afternoon',
evening: 'evening',
night: 'night'
},
wide: {
am: 'a.m.',
pm: 'p.m.',
midnight: 'midnight',
noon: 'noon',
morning: 'morning',
afternoon: 'afternoon',
evening: 'evening',
night: 'night'
}
};
var formattingDayPeriodValues = {
narrow: {
am: 'a',
pm: 'p',
midnight: 'mi',
noon: 'n',
morning: 'in the morning',
afternoon: 'in the afternoon',
evening: 'in the evening',
night: 'at night'
},
abbreviated: {
am: 'AM',
pm: 'PM',
midnight: 'midnight',
noon: 'noon',
morning: 'in the morning',
afternoon: 'in the afternoon',
evening: 'in the evening',
night: 'at night'
},
wide: {
am: 'a.m.',
pm: 'p.m.',
midnight: 'midnight',
noon: 'noon',
morning: 'in the morning',
afternoon: 'in the afternoon',
evening: 'in the evening',
night: 'at night'
}
};
function ordinalNumber (dirtyNumber, dirtyOptions) {
var number = Number(dirtyNumber);
// If ordinal numbers depend on context, for example,
// if they are different for different grammatical genders,
// use `options.unit`:
//
// var options = dirtyOptions || {}
// var unit = String(options.unit)
//
// where `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
// 'day', 'hour', 'minute', 'second'
var rem100 = number % 100;
if (rem100 > 20 || rem100 < 10) {
switch (rem100 % 10) {
case 1:
return number + 'st'
case 2:
return number + 'nd'
case 3:
return number + 'rd'
}
}
return number + 'th'
}
var localize = {
ordinalNumber: ordinalNumber,
era: buildLocalizeFn({
values: eraValues,
defaultWidth: 'wide'
}),
quarter: buildLocalizeFn({
values: quarterValues,
defaultWidth: 'wide',
argumentCallback: function (quarter) {
return Number(quarter) - 1
}
}),
month: buildLocalizeFn({
values: monthValues,
defaultWidth: 'wide'
}),
day: buildLocalizeFn({
values: dayValues,
defaultWidth: 'wide'
}),
dayPeriod: buildLocalizeFn({
values: dayPeriodValues,
defaultWidth: 'wide',
formattingValues: formattingDayPeriodValues,
defaulFormattingWidth: 'wide'
})
};
function buildMatchPatternFn (args) {
return function (dirtyString, dirtyOptions) {
var string = String(dirtyString);
var options = dirtyOptions || {};
var matchResult = string.match(args.matchPattern);
if (!matchResult) {
return null
}
var matchedString = matchResult[0];
var parseResult = string.match(args.parsePattern);
if (!parseResult) {
return null
}
var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
value = options.valueCallback ? options.valueCallback(value) : value;
return {
value: value,
rest: string.slice(matchedString.length)
}
}
}
function buildMatchFn (args) {
return function (dirtyString, dirtyOptions) {
var string = String(dirtyString);
var options = dirtyOptions || {};
var width = options.width;
var matchPattern = (width && args.matchPatterns[width]) || args.matchPatterns[args.defaultMatchWidth];
var matchResult = string.match(matchPattern);
if (!matchResult) {
return null
}
var matchedString = matchResult[0];
var parsePatterns = (width && args.parsePatterns[width]) || args.parsePatterns[args.defaultParseWidth];
var value;
if (Object.prototype.toString.call(parsePatterns) === '[object Array]') {
value = parsePatterns.findIndex(function (pattern) {
return pattern.test(string)
});
} else {
value = findKey(parsePatterns, function (pattern) {
return pattern.test(string)
});
}
value = args.valueCallback ? args.valueCallback(value) : value;
value = options.valueCallback ? options.valueCallback(value) : value;
return {
value: value,
rest: string.slice(matchedString.length)
}
}
}
function findKey (object, predicate) {
for (var key in object) {
if (object.hasOwnProperty(key) && predicate(object[key])) {
return key
}
}
}
var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
var parseOrdinalNumberPattern = /\d+/i;
var matchEraPatterns = {
narrow: /^(b|a)/i,
abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
wide: /^(before christ|before common era|anno domini|common era)/i
};
var parseEraPatterns = {
any: [/^b/i, /^(a|c)/i]
};
var matchQuarterPatterns = {
narrow: /^[1234]/i,
abbreviated: /^q[1234]/i,
wide: /^[1234](th|st|nd|rd)? quarter/i
};
var parseQuarterPatterns = {
any: [/1/i, /2/i, /3/i, /4/i]
};
var matchMonthPatterns = {
narrow: /^[jfmasond]/i,
abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
};
var parseMonthPatterns = {
narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
};
var matchDayPatterns = {
narrow: /^[smtwf]/i,
short: /^(su|mo|tu|we|th|fr|sa)/i,
abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
};
var parseDayPatterns = {
narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
};
var matchDayPeriodPatterns = {
narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
};
var parseDayPeriodPatterns = {
any: {
am: /^a/i,
pm: /^p/i,
midnight: /^mi/i,
noon: /^no/i,
morning: /morning/i,
afternoon: /afternoon/i,
evening: /evening/i,
night: /night/i
}
};
var match = {
ordinalNumber: buildMatchPatternFn({
matchPattern: matchOrdinalNumberPattern,
parsePattern: parseOrdinalNumberPattern,
valueCallback: function (value) {
return parseInt(value, 10)
}
}),
era: buildMatchFn({
matchPatterns: matchEraPatterns,
defaultMatchWidth: 'wide',
parsePatterns: parseEraPatterns,
defaultParseWidth: 'any'
}),
quarter: buildMatchFn({
matchPatterns: matchQuarterPatterns,
defaultMatchWidth: 'wide',
parsePatterns: parseQuarterPatterns,
defaultParseWidth: 'any',
valueCallback: function (index) {
return index + 1
}
}),
month: buildMatchFn({
matchPatterns: matchMonthPatterns,
defaultMatchWidth: 'wide',
parsePatterns: parseMonthPatterns,
defaultParseWidth: 'any'
}),
day: buildMatchFn({
matchPatterns: matchDayPatterns,
defaultMatchWidth: 'wide',
parsePatterns: parseDayPatterns,
defaultParseWidth: 'any'
}),
dayPeriod: buildMatchFn({
matchPatterns: matchDayPeriodPatterns,
defaultMatchWidth: 'any',
parsePatterns: parseDayPeriodPatterns,
defaultParseWidth: 'any'
})
};
/**
* @type {Locale}
* @category Locales
* @summary English locale (United States).
* @language English
* @iso-639-2 eng
* @author Sasha Koss [@kossnocorp]{@link https://github.com/kossnocorp}
* @author Lesha Koss [@leshakoss]{@link https://github.com/leshakoss}
*/
var locale = {
formatDistance: formatDistance,
formatLong: formatLong,
formatRelative: formatRelative,
localize: localize,
match: match,
options: {
weekStartsOn: 0 /* Sunday */,
firstWeekContainsDate: 1
}
};
var MILLISECONDS_IN_DAY = 86400000;
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function getUTCDayOfYear (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var timestamp = date.getTime();
date.setUTCMonth(0, 1);
date.setUTCHours(0, 0, 0, 0);
var startOfYearTimestamp = date.getTime();
var difference = timestamp - startOfYearTimestamp;
return Math.floor(difference / MILLISECONDS_IN_DAY) + 1
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function startOfUTCISOWeek (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var weekStartsOn = 1;
var date = toDate(dirtyDate, dirtyOptions);
var day = date.getUTCDay();
var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
date.setUTCDate(date.getUTCDate() - diff);
date.setUTCHours(0, 0, 0, 0);
return date
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function getUTCISOWeekYear (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var year = date.getUTCFullYear();
var fourthOfJanuaryOfNextYear = new Date(0);
fourthOfJanuaryOfNextYear.setUTCFullYear(year + 1, 0, 4);
fourthOfJanuaryOfNextYear.setUTCHours(0, 0, 0, 0);
var startOfNextYear = startOfUTCISOWeek(fourthOfJanuaryOfNextYear, dirtyOptions);
var fourthOfJanuaryOfThisYear = new Date(0);
fourthOfJanuaryOfThisYear.setUTCFullYear(year, 0, 4);
fourthOfJanuaryOfThisYear.setUTCHours(0, 0, 0, 0);
var startOfThisYear = startOfUTCISOWeek(fourthOfJanuaryOfThisYear, dirtyOptions);
if (date.getTime() >= startOfNextYear.getTime()) {
return year + 1
} else if (date.getTime() >= startOfThisYear.getTime()) {
return year
} else {
return year - 1
}
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function startOfUTCISOWeekYear (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var year = getUTCISOWeekYear(dirtyDate, dirtyOptions);
var fourthOfJanuary = new Date(0);
fourthOfJanuary.setUTCFullYear(year, 0, 4);
fourthOfJanuary.setUTCHours(0, 0, 0, 0);
var date = startOfUTCISOWeek(fourthOfJanuary, dirtyOptions);
return date
}
var MILLISECONDS_IN_WEEK = 604800000;
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function getUTCISOWeek (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var diff = startOfUTCISOWeek(date, dirtyOptions).getTime() - startOfUTCISOWeekYear(date, dirtyOptions).getTime();
// Round the number of days to the nearest integer
// because the number of milliseconds in a week is not constant
// (e.g. it's different in the week of the daylight saving time clock shift)
return Math.round(diff / MILLISECONDS_IN_WEEK) + 1
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function startOfUTCWeek (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var options = dirtyOptions || {};
var locale = options.locale;
var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;
var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn);
// Test if weekStartsOn is between 0 and 6 _and_ is not NaN
if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
}
var date = toDate(dirtyDate, options);
var day = date.getUTCDay();
var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
date.setUTCDate(date.getUTCDate() - diff);
date.setUTCHours(0, 0, 0, 0);
return date
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function getUTCWeekYear (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var year = date.getUTCFullYear();
var options = dirtyOptions || {};
var locale = options.locale;
var localeFirstWeekContainsDate = locale &&
locale.options &&
locale.options.firstWeekContainsDate;
var defaultFirstWeekContainsDate =
localeFirstWeekContainsDate == null
? 1
: toInteger(localeFirstWeekContainsDate);
var firstWeekContainsDate =
options.firstWeekContainsDate == null
? defaultFirstWeekContainsDate
: toInteger(options.firstWeekContainsDate);
// Test if weekStartsOn is between 1 and 7 _and_ is not NaN
if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
throw new RangeError('firstWeekContainsDate must be between 1 and 7 inclusively')
}
var firstWeekOfNextYear = new Date(0);
firstWeekOfNextYear.setUTCFullYear(year + 1, 0, firstWeekContainsDate);
firstWeekOfNextYear.setUTCHours(0, 0, 0, 0);
var startOfNextYear = startOfUTCWeek(firstWeekOfNextYear, dirtyOptions);
var firstWeekOfThisYear = new Date(0);
firstWeekOfThisYear.setUTCFullYear(year, 0, firstWeekContainsDate);
firstWeekOfThisYear.setUTCHours(0, 0, 0, 0);
var startOfThisYear = startOfUTCWeek(firstWeekOfThisYear, dirtyOptions);
if (date.getTime() >= startOfNextYear.getTime()) {
return year + 1
} else if (date.getTime() >= startOfThisYear.getTime()) {
return year
} else {
return year - 1
}
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function startOfUTCWeekYear (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var options = dirtyOptions || {};
var locale = options.locale;
var localeFirstWeekContainsDate = locale &&
locale.options &&
locale.options.firstWeekContainsDate;
var defaultFirstWeekContainsDate =
localeFirstWeekContainsDate == null
? 1
: toInteger(localeFirstWeekContainsDate);
var firstWeekContainsDate =
options.firstWeekContainsDate == null
? defaultFirstWeekContainsDate
: toInteger(options.firstWeekContainsDate);
var year = getUTCWeekYear(dirtyDate, dirtyOptions);
var firstWeek = new Date(0);
firstWeek.setUTCFullYear(year, 0, firstWeekContainsDate);
firstWeek.setUTCHours(0, 0, 0, 0);
var date = startOfUTCWeek(firstWeek, dirtyOptions);
return date
}
var MILLISECONDS_IN_WEEK$1 = 604800000;
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function getUTCWeek (dirtyDate, dirtyOptions) {
if (arguments.length < 1) {
throw new TypeError('1 argument required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var diff = startOfUTCWeek(date, dirtyOptions).getTime() - startOfUTCWeekYear(date, dirtyOptions).getTime();
// Round the number of days to the nearest integer
// because the number of milliseconds in a week is not constant
// (e.g. it's different in the week of the daylight saving time clock shift)
return Math.round(diff / MILLISECONDS_IN_WEEK$1) + 1
}
var dayPeriodEnum = {
am: 'am',
pm: 'pm',
midnight: 'midnight',
noon: 'noon',
morning: 'morning',
afternoon: 'afternoon',
evening: 'evening',
night: 'night'
};
/*
* | | Unit | | Unit |
* |-----|--------------------------------|-----|--------------------------------|
* | a | AM, PM | A* | Milliseconds in day |
* | b | AM, PM, noon, midnight | B | Flexible day period |
* | c | Stand-alone local day of week | C* | Localized hour w/ day period |
* | d | Day of month | D | Day of year |
* | e | Local day of week | E | Day of week |
* | f | | F* | Day of week in month |
* | g* | Modified Julian day | G | Era |
* | h | Hour [1-12] | H | Hour [0-23] |
* | i! | ISO day of week | I! | ISO week of year |
* | j* | Localized hour w/ day period | J* | Localized hour w/o day period |
* | k | Hour [1-24] | K | Hour [0-11] |
* | l* | (deprecated) | L | Stand-alone month |
* | m | Minute | M | Month |
* | n | | N | |
* | o! | Ordinal number modifier | O | Timezone (GMT) |
* | p! | Long localized time | P! | Long localized date |
* | q | Stand-alone quarter | Q | Quarter |
* | r* | Related Gregorian year | R! | ISO week-numbering year |
* | s | Second | S | Fraction of second |
* | t! | Seconds timestamp | T! | Milliseconds timestamp |
* | u | Extended year | U* | Cyclic year |
* | v* | Timezone (generic non-locat.) | V* | Timezone (location) |
* | w | Local week of year | W* | Week of month |
* | x | Timezone (ISO-8601 w/o Z) | X | Timezone (ISO-8601) |
* | y | Year (abs) | Y | Local week-numbering year |
* | z | Timezone (specific non-locat.) | Z* | Timezone (aliases) |
*
* Letters marked by * are not implemented but reserved by Unicode standard.
*
* Letters marked by ! are non-standard, but implemented by date-fns:
* - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
* - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
* i.e. 7 for Sunday, 1 for Monday, etc.
* - `I` is ISO week of year, as opposed to `w` which is local week of year.
* - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
* `R` is supposed to be used in conjunction with `I` and `i`
* for universal ISO week-numbering date, whereas
* `Y` is supposed to be used in conjunction with `w` and `e`
* for week-numbering date specific to the locale.
* - `P` is long localized date format
* - `p` is long localized time format
*/
var formatters = {
// Era
G: function (date, token, localize) {
var era = date.getUTCFullYear() > 0 ? 1 : 0;
switch (token) {
// AD, BC
case 'G':
case 'GG':
case 'GGG':
return localize.era(era, {width: 'abbreviated'})
// A, B
case 'GGGGG':
return localize.era(era, {width: 'narrow'})
// Anno Domini, Before Christ
case 'GGGG':
default:
return localize.era(era, {width: 'wide'})
}
},
// Year
y: function (date, token, localize, options) {
// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
// | Year | y | yy | yyy | yyyy | yyyyy |
// |----------|-------|----|-------|-------|-------|
// | AD 1 | 1 | 01 | 001 | 0001 | 00001 |
// | AD 12 | 12 | 12 | 012 | 0012 | 00012 |
// | AD 123 | 123 | 23 | 123 | 0123 | 00123 |
// | AD 1234 | 1234 | 34 | 1234 | 1234 | 01234 |
// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
var signedYear = date.getUTCFullYear();
// Returns 1 for 1 BC (which is year 0 in JavaScript)
var year = signedYear > 0 ? signedYear : 1 - signedYear;
// Two digit year
if (token === 'yy') {
var twoDigitYear = year % 100;
return addLeadingZeros(twoDigitYear, 2)
}
// Ordinal number
if (token === 'yo') {
return localize.ordinalNumber(year, {unit: 'year'})
}
// Padding
return addLeadingZeros(year, token.length)
},
// Local week-numbering year
Y: function (date, token, localize, options) {
var signedWeekYear = getUTCWeekYear(date, options);
var weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
// Two digit year
if (token === 'YY') {
var twoDigitYear = weekYear % 100;
return addLeadingZeros(twoDigitYear, 2)
}
// Ordinal number
if (token === 'Yo') {
return localize.ordinalNumber(weekYear, {unit: 'year'})
}
// Padding
return addLeadingZeros(weekYear, token.length)
},
// ISO week-numbering year
R: function (date, token, localize, options) {
var isoWeekYear = getUTCISOWeekYear(date, options);
// Padding
return addLeadingZeros(isoWeekYear, token.length)
},
// Extended year. This is a single number designating the year of this calendar system.
// The main difference between `y` and `u` localizers are B.C. years:
// | Year | `y` | `u` |
// |------|-----|-----|
// | AC 1 | 1 | 1 |
// | BC 1 | 1 | 0 |
// | BC 2 | 2 | -1 |
// Also `yy` always returns the last two digits of a year,
// while `uu` pads single digit years to 2 characters and returns other years unchanged.
u: function (date, token, localize, options) {
var year = date.getUTCFullYear();
return addLeadingZeros(year, token.length)
},
// Quarter
Q: function (date, token, localize, options) {
var quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
switch (token) {
// 1, 2, 3, 4
case 'Q':
return String(quarter)
// 01, 02, 03, 04
case 'QQ':
return addLeadingZeros(quarter, 2)
// 1st, 2nd, 3rd, 4th
case 'Qo':
return localize.ordinalNumber(quarter, {unit: 'quarter'})
// Q1, Q2, Q3, Q4
case 'QQQ':
return localize.quarter(quarter, {width: 'abbreviated', context: 'formatting'})
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case 'QQQQQ':
return localize.quarter(quarter, {width: 'narrow', context: 'formatting'})
// 1st quarter, 2nd quarter, ...
case 'QQQQ':
default:
return localize.quarter(quarter, {width: 'wide', context: 'formatting'})
}
},
// Stand-alone quarter
q: function (date, token, localize, options) {
var quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
switch (token) {
// 1, 2, 3, 4
case 'q':
return String(quarter)
// 01, 02, 03, 04
case 'qq':
return addLeadingZeros(quarter, 2)
// 1st, 2nd, 3rd, 4th
case 'qo':
return localize.ordinalNumber(quarter, {unit: 'quarter'})
// Q1, Q2, Q3, Q4
case 'qqq':
return localize.quarter(quarter, {width: 'abbreviated', context: 'standalone'})
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case 'qqqqq':
return localize.quarter(quarter, {width: 'narrow', context: 'standalone'})
// 1st quarter, 2nd quarter, ...
case 'qqqq':
default:
return localize.quarter(quarter, {width: 'wide', context: 'standalone'})
}
},
// Month
M: function (date, token, localize, options) {
var month = date.getUTCMonth();
switch (token) {
// 1, 2, ..., 12
case 'M':
return String(month + 1)
// 01, 02, ..., 12
case 'MM':
return addLeadingZeros(month + 1, 2)
// 1st, 2nd, ..., 12th
case 'Mo':
return localize.ordinalNumber(month + 1, {unit: 'month'})
// Jan, Feb, ..., Dec
case 'MMM':
return localize.month(month, {width: 'abbreviated', context: 'formatting'})
// J, F, ..., D
case 'MMMMM':
return localize.month(month, {width: 'narrow', context: 'formatting'})
// January, February, ..., December
case 'MMMM':
default:
return localize.month(month, {width: 'wide', context: 'formatting'})
}
},
// Stand-alone month
L: function (date, token, localize, options) {
var month = date.getUTCMonth();
switch (token) {
// 1, 2, ..., 12
case 'L':
return String(month + 1)
// 01, 02, ..., 12
case 'LL':
return addLeadingZeros(month + 1, 2)
// 1st, 2nd, ..., 12th
case 'Lo':
return localize.ordinalNumber(month + 1, {unit: 'month'})
// Jan, Feb, ..., Dec
case 'LLL':
return localize.month(month, {width: 'abbreviated', context: 'standalone'})
// J, F, ..., D
case 'LLLLL':
return localize.month(month, {width: 'narrow', context: 'standalone'})
// January, February, ..., December
case 'LLLL':
default:
return localize.month(month, {width: 'wide', context: 'standalone'})
}
},
// Local week of year
w: function (date, token, localize, options) {
var week = getUTCWeek(date, options);
if (token === 'wo') {
return localize.ordinalNumber(week, {unit: 'week'})
}
return addLeadingZeros(week, token.length)
},
// ISO week of year
I: function (date, token, localize, options) {
var isoWeek = getUTCISOWeek(date, options);
if (token === 'Io') {
return localize.ordinalNumber(isoWeek, {unit: 'week'})
}
return addLeadingZeros(isoWeek, token.length)
},
// Day of the month
d: function (date, token, localize, options) {
var dayOfMonth = date.getUTCDate();
if (token === 'do') {
return localize.ordinalNumber(dayOfMonth, {unit: 'date'})
}
return addLeadingZeros(dayOfMonth, token.length)
},
// Day of year
D: function (date, token, localize, options) {
var dayOfYear = getUTCDayOfYear(date, options);
if (token === 'Do') {
return localize.ordinalNumber(dayOfYear, {unit: 'dayOfYear'})
}
return addLeadingZeros(dayOfYear, token.length)
},
// Day of week
E: function (date, token, localize, options) {
var dayOfWeek = date.getUTCDay();
switch (token) {
// Tue
case 'E':
case 'EE':
case 'EEE':
return localize.day(dayOfWeek, {width: 'abbreviated', context: 'formatting'})
// T
case 'EEEEE':
return localize.day(dayOfWeek, {width: 'narrow', context: 'formatting'})
// Tu
case 'EEEEEE':
return localize.day(dayOfWeek, {width: 'short', context: 'formatting'})
// Tuesday
case 'EEEE':
default:
return localize.day(dayOfWeek, {width: 'wide', context: 'formatting'})
}
},
// Local day of week
e: function (date, token, localize, options) {
var dayOfWeek = date.getUTCDay();
var localDayOfWeek = ((dayOfWeek - options.weekStartsOn + 8) % 7) || 7;
switch (token) {
// Numerical value (Nth day of week with current locale or weekStartsOn)
case 'e':
return String(localDayOfWeek)
// Padded numerical value
case 'ee':
return addLeadingZeros(localDayOfWeek, 2)
// 1st, 2nd, ..., 7th
case 'eo':
return localize.ordinalNumber(localDayOfWeek, {unit: 'day'})
case 'eee':
return localize.day(dayOfWeek, {width: 'abbreviated', context: 'formatting'})
// T
case 'eeeee':
return localize.day(dayOfWeek, {width: 'narrow', context: 'formatting'})
// Tu
case 'eeeeee':
return localize.day(dayOfWeek, {width: 'short', context: 'formatting'})
// Tuesday
case 'eeee':
default:
return localize.day(dayOfWeek, {width: 'wide', context: 'formatting'})
}
},
// Stand-alone local day of week
c: function (date, token, localize, options) {
var dayOfWeek = date.getUTCDay();
var localDayOfWeek = ((dayOfWeek - options.weekStartsOn + 8) % 7) || 7;
switch (token) {
// Numerical value (same as in `e`)
case 'c':
return String(localDayOfWeek)
// Padded numberical value
case 'cc':
return addLeadingZeros(localDayOfWeek, token.length)
// 1st, 2nd, ..., 7th
case 'co':
return localize.ordinalNumber(localDayOfWeek, {unit: 'day'})
case 'ccc':
return localize.day(dayOfWeek, {width: 'abbreviated', context: 'standalone'})
// T
case 'ccccc':
return localize.day(dayOfWeek, {width: 'narrow', context: 'standalone'})
// Tu
case 'cccccc':
return localize.day(dayOfWeek, {width: 'short', context: 'standalone'})
// Tuesday
case 'cccc':
default:
return localize.day(dayOfWeek, {width: 'wide', context: 'standalone'})
}
},
// ISO day of week
i: function (date, token, localize, options) {
var dayOfWeek = date.getUTCDay();
var isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
switch (token) {
// 2
case 'i':
return String(isoDayOfWeek)
// 02
case 'ii':
return addLeadingZeros(isoDayOfWeek, token.length)
// 2nd
case 'io':
return localize.ordinalNumber(isoDayOfWeek, {unit: 'day'})
// Tue
case 'iii':
return localize.day(dayOfWeek, {width: 'abbreviated', context: 'formatting'})
// T
case 'iiiii':
return localize.day(dayOfWeek, {width: 'narrow', context: 'formatting'})
// Tu
case 'iiiiii':
return localize.day(dayOfWeek, {width: 'short', context: 'formatting'})
// Tuesday
case 'iiii':
default:
return localize.day(dayOfWeek, {width: 'wide', context: 'formatting'})
}
},
// AM or PM
a: function (date, token, localize) {
var hours = date.getUTCHours();
var dayPeriodEnumValue = (hours / 12) >= 1 ? 'pm' : 'am';
switch (token) {
case 'a':
case 'aa':
case 'aaa':
return localize.dayPeriod(dayPeriodEnumValue, {width: 'abbreviated', context: 'formatting'})
case 'aaaaa':
return localize.dayPeriod(dayPeriodEnumValue, {width: 'narrow', context: 'formatting'})
case 'aaaa':
default:
return localize.dayPeriod(dayPeriodEnumValue, {width: 'wide', context: 'formatting'})
}
},
// AM, PM, midnight, noon
b: function (date, token, localize) {
var hours = date.getUTCHours();
var dayPeriodEnumValue;
if (hours === 12) {
dayPeriodEnumValue = dayPeriodEnum.noon;
} else if (hours === 0) {
dayPeriodEnumValue = dayPeriodEnum.midnight;
} else {
dayPeriodEnumValue = (hours / 12) >= 1 ? 'pm' : 'am';
}
switch (token) {
case 'b':
case 'bb':
case 'bbb':
return localize.dayPeriod(dayPeriodEnumValue, {width: 'abbreviated', context: 'formatting'})
case 'bbbbb':
return localize.dayPeriod(dayPeriodEnumValue, {width: 'narrow', context: 'formatting'})
case 'bbbb':
default:
return localize.dayPeriod(dayPeriodEnumValue, {width: 'wide', context: 'formatting'})
}
},
// in the morning, in the afternoon, in the evening, at night
B: function (date, token, localize) {
var hours = date.getUTCHours();
var dayPeriodEnumValue;
if (hours >= 17) {
dayPeriodEnumValue = dayPeriodEnum.evening;
} else if (hours >= 12) {
dayPeriodEnumValue = dayPeriodEnum.afternoon;
} else if (hours >= 4) {
dayPeriodEnumValue = dayPeriodEnum.morning;
} else {
dayPeriodEnumValue = dayPeriodEnum.night;
}
switch (token) {
case 'B':
case 'BB':
case 'BBB':
return localize.dayPeriod(dayPeriodEnumValue, {width: 'abbreviated', context: 'formatting'})
case 'BBBBB':
return localize.dayPeriod(dayPeriodEnumValue, {width: 'narrow', context: 'formatting'})
case 'BBBB':
default:
return localize.dayPeriod(dayPeriodEnumValue, {width: 'wide', context: 'formatting'})
}
},
// Hour [1-12]
h: function (date, token, localize, options) {
var hours = date.getUTCHours() % 12;
if (hours === 0) {
hours = 12;
}
if (token === 'ho') {
return localize.ordinalNumber(hours, {unit: 'hour'})
}
return addLeadingZeros(hours, token.length)
},
// Hour [0-23]
H: function (date, token, localize, options) {
var hours = date.getUTCHours();
if (token === 'Ho') {
return localize.ordinalNumber(hours, {unit: 'hour'})
}
return addLeadingZeros(hours, token.length)
},
// Hour [0-11]
K: function (date, token, localize, options) {
var hours = date.getUTCHours() % 12;
if (token === 'Ko') {
return localize.ordinalNumber(hours, {unit: 'hour'})
}
return addLeadingZeros(hours, token.length)
},
// Hour [1-24]
k: function (date, token, localize, options) {
var hours = date.getUTCHours();
if (hours === 0) {
hours = 24;
}
if (token === 'ko') {
return localize.ordinalNumber(hours, {unit: 'hour'})
}
return addLeadingZeros(hours, token.length)
},
// Minute
m: function (date, token, localize, options) {
var minutes = date.getUTCMinutes();
if (token === 'mo') {
return localize.ordinalNumber(minutes, {unit: 'minute'})
}
return addLeadingZeros(minutes, token.length)
},
// Second
s: function (date, token, localize, options) {
var seconds = date.getUTCSeconds();
if (token === 'so') {
return localize.ordinalNumber(seconds, {unit: 'second'})
}
return addLeadingZeros(seconds, token.length)
},
// Fraction of second
S: function (date, token, localize, options) {
var numberOfDigits = token.length;
var milliseconds = date.getUTCMilliseconds();
var fractionalSeconds = Math.floor(milliseconds * Math.pow(10, numberOfDigits - 3));
return addLeadingZeros(fractionalSeconds, numberOfDigits)
},
// Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
X: function (date, token, localize, options) {
var originalDate = options._originalDate || date;
var timezoneOffset = originalDate.getTimezoneOffset();
if (timezoneOffset === 0) {
return 'Z'
}
switch (token) {
// Hours and optional minutes
case 'X':
return formatTimezoneWithOptionalMinutes(timezoneOffset)
// Hours, minutes and optional seconds without `:` delimeter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `XX`
case 'XXXX':
case 'XX': // Hours and minutes without `:` delimeter
return formatTimezone(timezoneOffset)
// Hours, minutes and optional seconds with `:` delimeter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `XXX`
case 'XXXXX':
case 'XXX': // Hours and minutes with `:` delimeter
default:
return formatTimezone(timezoneOffset, ':')
}
},
// Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
x: function (date, token, localize, options) {
var originalDate = options._originalDate || date;
var timezoneOffset = originalDate.getTimezoneOffset();
switch (token) {
// Hours and optional minutes
case 'x':
return formatTimezoneWithOptionalMinutes(timezoneOffset)
// Hours, minutes and optional seconds without `:` delimeter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `xx`
case 'xxxx':
case 'xx': // Hours and minutes without `:` delimeter
return formatTimezone(timezoneOffset)
// Hours, minutes and optional seconds with `:` delimeter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `xxx`
case 'xxxxx':
case 'xxx': // Hours and minutes with `:` delimeter
default:
return formatTimezone(timezoneOffset, ':')
}
},
// Timezone (GMT)
O: function (date, token, localize, options) {
var originalDate = options._originalDate || date;
var timezoneOffset = originalDate.getTimezoneOffset();
switch (token) {
// Short
case 'O':
case 'OO':
case 'OOO':
return 'GMT' + formatTimezoneShort(timezoneOffset, ':')
// Long
case 'OOOO':
default:
return 'GMT' + formatTimezone(timezoneOffset, ':')
}
},
// Timezone (specific non-location)
z: function (date, token, localize, options) {
var originalDate = options._originalDate || date;
var timezoneOffset = originalDate.getTimezoneOffset();
switch (token) {
// Short
case 'z':
case 'zz':
case 'zzz':
return 'GMT' + formatTimezoneShort(timezoneOffset, ':')
// Long
case 'zzzz':
default:
return 'GMT' + formatTimezone(timezoneOffset, ':')
}
},
// Seconds timestamp
t: function (date, token, localize, options) {
var originalDate = options._originalDate || date;
var timestamp = Math.floor(originalDate.getTime() / 1000);
return addLeadingZeros(timestamp, token.length)
},
// Milliseconds timestamp
T: function (date, token, localize, options) {
var originalDate = options._originalDate || date;
var timestamp = originalDate.getTime();
return addLeadingZeros(timestamp, token.length)
}
};
function addLeadingZeros (number, targetLength) {
var sign = number < 0 ? '-' : '';
var output = Math.abs(number).toString();
while (output.length < targetLength) {
output = '0' + output;
}
return sign + output
}
function formatTimezone (offset, dirtyDelimeter) {
var delimeter = dirtyDelimeter || '';
var sign = offset > 0 ? '-' : '+';
var absOffset = Math.abs(offset);
var hours = addLeadingZeros(Math.floor(absOffset / 60), 2);
var minutes = addLeadingZeros(absOffset % 60, 2);
return sign + hours + delimeter + minutes
}
function formatTimezoneWithOptionalMinutes (offset, dirtyDelimeter) {
if (offset % 60 === 0) {
var sign = offset > 0 ? '-' : '+';
return sign + addLeadingZeros(Math.abs(offset) / 60, 2)
}
return formatTimezone(offset, dirtyDelimeter)
}
function formatTimezoneShort (offset, dirtyDelimeter) {
var sign = offset > 0 ? '-' : '+';
var absOffset = Math.abs(offset);
var hours = Math.floor(absOffset / 60);
var minutes = absOffset % 60;
if (minutes === 0) {
return sign + String(hours)
}
var delimeter = dirtyDelimeter || '';
return sign + String(hours) + delimeter + addLeadingZeros(minutes, 2)
}
function dateLongFormatter (pattern, formatLong, options) {
switch (pattern) {
case 'P':
return formatLong.date({width: 'short'})
case 'PP':
return formatLong.date({width: 'medium'})
case 'PPP':
return formatLong.date({width: 'long'})
case 'PPPP':
default:
return formatLong.date({width: 'full'})
}
}
function timeLongFormatter (pattern, formatLong, options) {
switch (pattern) {
case 'p':
return formatLong.time({width: 'short'})
case 'pp':
return formatLong.time({width: 'medium'})
case 'ppp':
return formatLong.time({width: 'long'})
case 'pppp':
default:
return formatLong.time({width: 'full'})
}
}
function dateTimeLongFormatter (pattern, formatLong, options) {
var matchResult = pattern.match(/(P+)(p+)?/);
var datePattern = matchResult[1];
var timePattern = matchResult[2];
if (!timePattern) {
return dateLongFormatter(pattern, formatLong)
}
var dateTimeFormat;
switch (datePattern) {
case 'P':
dateTimeFormat = formatLong.dateTime({width: 'short'});
break
case 'PP':
dateTimeFormat = formatLong.dateTime({width: 'medium'});
break
case 'PPP':
dateTimeFormat = formatLong.dateTime({width: 'long'});
break
case 'PPPP':
default:
dateTimeFormat = formatLong.dateTime({width: 'full'});
break
}
return dateTimeFormat
.replace('{{date}}', dateLongFormatter(datePattern, formatLong))
.replace('{{time}}', timeLongFormatter(timePattern, formatLong))
}
var longFormatters = {
p: timeLongFormatter,
P: dateTimeLongFormatter
};
/**
* @name subMilliseconds
* @category Millisecond Helpers
* @summary Subtract the specified number of milliseconds from the given date.
*
* @description
* Subtract the specified number of milliseconds from the given date.
*
* @param {Date|String|Number} date - the date to be changed
* @param {Number} amount - the amount of milliseconds to be subtracted
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @returns {Date} the new date with the milliseconds subtracted
* @throws {TypeError} 2 arguments required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
*
* @example
* // Subtract 750 milliseconds from 10 July 2014 12:45:30.000:
* var result = subMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)
* //=> Thu Jul 10 2014 12:45:29.250
*/
function subMilliseconds (dirtyDate, dirtyAmount, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var amount = toInteger(dirtyAmount);
return addMilliseconds(dirtyDate, -amount, dirtyOptions)
}
var protectedTokens = ['D', 'DD', 'YY', 'YYYY'];
function isProtectedToken(token) {
return protectedTokens.indexOf(token) !== -1
}
function throwProtectedError(token) {
throw new RangeError(
'`options.awareOfUnicodeTokens` must be set to `true` to use `' +
token +
'` token; see: https://git.io/fxCyr'
)
}
// This RegExp consists of three parts separated by `|`:
// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token
// (one of the certain letters followed by `o`)
// - (\w)\1* matches any sequences of the same letter
// - '' matches two quote characters in a row
// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
// except a single quote symbol, which ends the sequence.
// Two quote characters do not end the sequence.
// If there is no matching single quote
// then the sequence will continue until the end of the string.
// - . matches any single character unmatched by previous parts of the RegExps
var formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
// This RegExp catches symbols escaped by quotes, and also
// sequences of symbols P, p, and the combinations like `PPPPPPPppppp`
var longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
var escapedStringRegExp = /^'(.*?)'?$/;
var doubleQuoteRegExp = /''/g;
/**
* @name format
* @category Common Helpers
* @summary Format the date.
*
* @description
* Return the formatted date string in the given format. The result may vary by locale.
*
* > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
* > See: https://git.io/fxCyr
*
* The characters wrapped between two single quotes characters (') are escaped.
* Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
* (see the last example)
*
* Format of the string is based on Unicode Technical Standard #35:
* https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
* with a few additions (see note 7 below the table).
*
* Accepted patterns:
* | Unit | Pattern | Result examples | Notes |
* |---------------------------------|---------|-----------------------------------|-------|
* | Era | G..GGG | AD, BC | |
* | | GGGG | Anno Domini, Before Christ | 2 |
* | | GGGGG | A, B | |
* | Calendar year | y | 44, 1, 1900, 2017 | 5 |
* | | yo | 44th, 1st, 0th, 17th | 5,7 |
* | | yy | 44, 01, 00, 17 | 5 |
* | | yyy | 044, 001, 1900, 2017 | 5 |
* | | yyyy | 0044, 0001, 1900, 2017 | 5 |
* | | yyyyy | ... | 3,5 |
* | Local week-numbering year | Y | 44, 1, 1900, 2017 | 5 |
* | | Yo | 44th, 1st, 1900th, 2017th | 5,7 |
* | | YY | 44, 01, 00, 17 | 5,8 |
* | | YYY | 044, 001, 1900, 2017 | 5 |
* | | YYYY | 0044, 0001, 1900, 2017 | 5,8 |
* | | YYYYY | ... | 3,5 |
* | ISO week-numbering year | R | -43, 0, 1, 1900, 2017 | 5,7 |
* | | RR | -43, 00, 01, 1900, 2017 | 5,7 |
* | | RRR | -043, 000, 001, 1900, 2017 | 5,7 |
* | | RRRR | -0043, 0000, 0001, 1900, 2017 | 5,7 |
* | | RRRRR | ... | 3,5,7 |
* | Extended year | u | -43, 0, 1, 1900, 2017 | 5 |
* | | uu | -43, 01, 1900, 2017 | 5 |
* | | uuu | -043, 001, 1900, 2017 | 5 |
* | | uuuu | -0043, 0001, 1900, 2017 | 5 |
* | | uuuuu | ... | 3,5 |
* | Quarter (formatting) | Q | 1, 2, 3, 4 | |
* | | Qo | 1st, 2nd, 3rd, 4th | 7 |
* | | QQ | 01, 02, 03, 04 | |
* | | QQQ | Q1, Q2, Q3, Q4 | |
* | | QQQQ | 1st quarter, 2nd quarter, ... | 2 |
* | | QQQQQ | 1, 2, 3, 4 | 4 |
* | Quarter (stand-alone) | q | 1, 2, 3, 4 | |
* | | qo | 1st, 2nd, 3rd, 4th | 7 |
* | | qq | 01, 02, 03, 04 | |
* | | qqq | Q1, Q2, Q3, Q4 | |
* | | qqqq | 1st quarter, 2nd quarter, ... | 2 |
* | | qqqqq | 1, 2, 3, 4 | 4 |
* | Month (formatting) | M | 1, 2, ..., 12 | |
* | | Mo | 1st, 2nd, ..., 12th | 7 |
* | | MM | 01, 02, ..., 12 | |
* | | MMM | Jan, Feb, ..., Dec | |
* | | MMMM | January, February, ..., December | 2 |
* | | MMMMM | J, F, ..., D | |
* | Month (stand-alone) | L | 1, 2, ..., 12 | |
* | | Lo | 1st, 2nd, ..., 12th | 7 |
* | | LL | 01, 02, ..., 12 | |
* | | LLL | Jan, Feb, ..., Dec | |
* | | LLLL | January, February, ..., December | 2 |
* | | LLLLL | J, F, ..., D | |
* | Local week of year | w | 1, 2, ..., 53 | |
* | | wo | 1st, 2nd, ..., 53th | 7 |
* | | ww | 01, 02, ..., 53 | |
* | ISO week of year | I | 1, 2, ..., 53 | 7 |
* | | Io | 1st, 2nd, ..., 53th | 7 |
* | | II | 01, 02, ..., 53 | 7 |
* | Day of month | d | 1, 2, ..., 31 | |
* | | do | 1st, 2nd, ..., 31st | 7 |
* | | dd | 01, 02, ..., 31 | |
* | Day of year | D | 1, 2, ..., 365, 366 | 8 |
* | | Do | 1st, 2nd, ..., 365th, 366th | 7 |
* | | DD | 01, 02, ..., 365, 366 | 8 |
* | | DDD | 001, 002, ..., 365, 366 | |
* | | DDDD | ... | 3 |
* | Day of week (formatting) | E..EEE | Mon, Tue, Wed, ..., Su | |
* | | EEEE | Monday, Tuesday, ..., Sunday | 2 |
* | | EEEEE | M, T, W, T, F, S, S | |
* | | EEEEEE | Mo, Tu, We, Th, Fr, Su, Sa | |
* | ISO day of week (formatting) | i | 1, 2, 3, ..., 7 | 7 |
* | | io | 1st, 2nd, ..., 7th | 7 |
* | | ii | 01, 02, ..., 07 | 7 |
* | | iii | Mon, Tue, Wed, ..., Su | 7 |
* | | iiii | Monday, Tuesday, ..., Sunday | 2,7 |
* | | iiiii | M, T, W, T, F, S, S | 7 |
* | | iiiiii | Mo, Tu, We, Th, Fr, Su, Sa | 7 |
* | Local day of week (formatting) | e | 2, 3, 4, ..., 1 | |
* | | eo | 2nd, 3rd, ..., 1st | 7 |
* | | ee | 02, 03, ..., 01 | |
* | | eee | Mon, Tue, Wed, ..., Su | |
* | | eeee | Monday, Tuesday, ..., Sunday | 2 |
* | | eeeee | M, T, W, T, F, S, S | |
* | | eeeeee | Mo, Tu, We, Th, Fr, Su, Sa | |
* | Local day of week (stand-alone) | c | 2, 3, 4, ..., 1 | |
* | | co | 2nd, 3rd, ..., 1st | 7 |
* | | cc | 02, 03, ..., 01 | |
* | | ccc | Mon, Tue, Wed, ..., Su | |
* | | cccc | Monday, Tuesday, ..., Sunday | 2 |
* | | ccccc | M, T, W, T, F, S, S | |
* | | cccccc | Mo, Tu, We, Th, Fr, Su, Sa | |
* | AM, PM | a..aaa | AM, PM | |
* | | aaaa | a.m., p.m. | 2 |
* | | aaaaa | a, p | |
* | AM, PM, noon, midnight | b..bbb | AM, PM, noon, midnight | |
* | | bbbb | a.m., p.m., noon, midnight | 2 |
* | | bbbbb | a, p, n, mi | |
* | Flexible day period | B..BBB | at night, in the morning, ... | |
* | | BBBB | at night, in the morning, ... | 2 |
* | | BBBBB | at night, in the morning, ... | |
* | Hour [1-12] | h | 1, 2, ..., 11, 12 | |
* | | ho | 1st, 2nd, ..., 11th, 12th | 7 |
* | | hh | 01, 02, ..., 11, 12 | |
* | Hour [0-23] | H | 0, 1, 2, ..., 23 | |
* | | Ho | 0th, 1st, 2nd, ..., 23rd | 7 |
* | | HH | 00, 01, 02, ..., 23 | |
* | Hour [0-11] | K | 1, 2, ..., 11, 0 | |
* | | Ko | 1st, 2nd, ..., 11th, 0th | 7 |
* | | KK | 1, 2, ..., 11, 0 | |
* | Hour [1-24] | k | 24, 1, 2, ..., 23 | |
* | | ko | 24th, 1st, 2nd, ..., 23rd | 7 |
* | | kk | 24, 01, 02, ..., 23 | |
* | Minute | m | 0, 1, ..., 59 | |
* | | mo | 0th, 1st, ..., 59th | 7 |
* | | mm | 00, 01, ..., 59 | |
* | Second | s | 0, 1, ..., 59 | |
* | | so | 0th, 1st, ..., 59th | 7 |
* | | ss | 00, 01, ..., 59 | |
* | Fraction of second | S | 0, 1, ..., 9 | |
* | | SS | 00, 01, ..., 99 | |
* | | SSS | 000, 0001, ..., 999 | |
* | | SSSS | ... | 3 |
* | Timezone (ISO-8601 w/ Z) | X | -08, +0530, Z | |
* | | XX | -0800, +0530, Z | |
* | | XXX | -08:00, +05:30, Z | |
* | | XXXX | -0800, +0530, Z, +123456 | 2 |
* | | XXXXX | -08:00, +05:30, Z, +12:34:56 | |
* | Timezone (ISO-8601 w/o Z) | x | -08, +0530, +00 | |
* | | xx | -0800, +0530, +0000 | |
* | | xxx | -08:00, +05:30, +00:00 | 2 |
* | | xxxx | -0800, +0530, +0000, +123456 | |
* | | xxxxx | -08:00, +05:30, +00:00, +12:34:56 | |
* | Timezone (GMT) | O...OOO | GMT-8, GMT+5:30, GMT+0 | |
* | | OOOO | GMT-08:00, GMT+05:30, GMT+00:00 | 2 |
* | Timezone (specific non-locat.) | z...zzz | GMT-8, GMT+5:30, GMT+0 | 6 |
* | | zzzz | GMT-08:00, GMT+05:30, GMT+00:00 | 2,6 |
* | Seconds timestamp | t | 512969520 | 7 |
* | | tt | ... | 3,7 |
* | Milliseconds timestamp | T | 512969520900 | 7 |
* | | TT | ... | 3,7 |
* | Long localized date | P | 05/29/1453 | 7 |
* | | PP | May 29, 1453 | 7 |
* | | PPP | May 29th, 1453 | 7 |
* | | PPPP | Sunday, May 29th, 1453 | 2,7 |
* | Long localized time | p | 12:00 AM | 7 |
* | | pp | 12:00:00 AM | 7 |
* | | ppp | 12:00:00 AM GMT+2 | 7 |
* | | pppp | 12:00:00 AM GMT+02:00 | 2,7 |
* | Combination of date and time | Pp | 05/29/1453, 12:00 AM | 7 |
* | | PPpp | May 29, 1453, 12:00:00 AM | 7 |
* | | PPPppp | May 29th, 1453 at ... | 7 |
* | | PPPPpppp| Sunday, May 29th, 1453 at ... | 2,7 |
* Notes:
* 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
* are the same as "stand-alone" units, but are different in some languages.
* "Formatting" units are declined according to the rules of the language
* in the context of a date. "Stand-alone" units are always nominative singular:
*
* `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
*
* `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
*
* 2. Any sequence of the identical letters is a pattern, unless it is escaped by
* the single quote characters (see below).
* If the sequence is longer than listed in table (e.g. `EEEEEEEEEEE`)
* the output will be the same as default pattern for this unit, usually
* the longest one (in case of ISO weekdays, `EEEE`). Default patterns for units
* are marked with "2" in the last column of the table.
*
* `format(new Date(2017, 10, 6), 'MMM') //=> 'Nov'`
*
* `format(new Date(2017, 10, 6), 'MMMM') //=> 'November'`
*
* `format(new Date(2017, 10, 6), 'MMMMM') //=> 'N'`
*
* `format(new Date(2017, 10, 6), 'MMMMMM') //=> 'November'`
*
* `format(new Date(2017, 10, 6), 'MMMMMMM') //=> 'November'`
*
* 3. Some patterns could be unlimited length (such as `yyyyyyyy`).
* The output will be padded with zeros to match the length of the pattern.
*
* `format(new Date(2017, 10, 6), 'yyyyyyyy') //=> '00002017'`
*
* 4. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
* These tokens represent the shortest form of the quarter.
*
* 5. The main difference between `y` and `u` patterns are B.C. years:
*
* | Year | `y` | `u` |
* |------|-----|-----|
* | AC 1 | 1 | 1 |
* | BC 1 | 1 | 0 |
* | BC 2 | 2 | -1 |
*
* Also `yy` always returns the last two digits of a year,
* while `uu` pads single digit years to 2 characters and returns other years unchanged:
*
* | Year | `yy` | `uu` |
* |------|------|------|
* | 1 | 01 | 01 |
* | 14 | 14 | 14 |
* | 376 | 76 | 376 |
* | 1453 | 53 | 1453 |
*
* The same difference is true for local and ISO week-numbering years (`Y` and `R`),
* except local week-numbering years are dependent on `options.weekStartsOn`
* and `options.firstWeekContainsDate` (compare [getISOWeekYear]{@link https://date-fns.org/docs/getISOWeekYear}
* and [getWeekYear]{@link https://date-fns.org/docs/getWeekYear}).
*
* 6. Specific non-location timezones are currently unavailable in `date-fns`,
* so right now these tokens fall back to GMT timezones.
*
* 7. These patterns are not in the Unicode Technical Standard #35:
* - `i`: ISO day of week
* - `I`: ISO week of year
* - `R`: ISO week-numbering year
* - `t`: seconds timestamp
* - `T`: milliseconds timestamp
* - `o`: ordinal number modifier
* - `P`: long localized date
* - `p`: long localized time
*
* 8. These tokens are often confused with others. See: https://git.io/fxCyr
*
* @param {Date|String|Number} date - the original date
* @param {String} format - the string of tokens
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
* @param {Number} [options.firstWeekContainsDate=1] - the day of January, which is
* @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
* @param {Boolean} [options.awareOfUnicodeTokens=false] - if true, allows usage of Unicode tokens causes confusion:
* - Some of the day of year tokens (`D`, `DD`) that are confused with the day of month tokens (`d`, `dd`).
* - Some of the local week-numbering year tokens (`YY`, `YYYY`) that are confused with the calendar year tokens (`yy`, `yyyy`).
* See: https://git.io/fxCyr
* @returns {String} the formatted date string
* @throws {TypeError} 2 arguments required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
* @throws {RangeError} `options.locale` must contain `localize` property
* @throws {RangeError} `options.locale` must contain `formatLong` property
* @throws {RangeError} `options.weekStartsOn` must be between 0 and 6
* @throws {RangeError} `options.firstWeekContainsDate` must be between 1 and 7
* @throws {RangeError} `options.awareOfUnicodeTokens` must be set to `true` to use `XX` token; see: https://git.io/fxCyr
*
* @example
* // Represent 11 February 2014 in middle-endian format:
* var result = format(
* new Date(2014, 1, 11),
* 'MM/dd/yyyy'
* )
* //=> '02/11/2014'
*
* @example
* // Represent 2 July 2014 in Esperanto:
* import { eoLocale } from 'date-fns/locale/eo'
* var result = format(
* new Date(2014, 6, 2),
* "do 'de' MMMM yyyy",
* {locale: eoLocale}
* )
* //=> '2-a de julio 2014'
*
* @example
* // Escape string by single quote characters:
* var result = format(
* new Date(2014, 6, 2, 15),
* "h 'o''clock'"
* )
* //=> "3 o'clock"
*/
function format(dirtyDate, dirtyFormatStr, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError(
'2 arguments required, but only ' + arguments.length + ' present'
)
}
var formatStr = String(dirtyFormatStr);
var options = dirtyOptions || {};
var locale$1 = options.locale || locale;
var localeFirstWeekContainsDate =
locale$1.options && locale$1.options.firstWeekContainsDate;
var defaultFirstWeekContainsDate =
localeFirstWeekContainsDate == null
? 1
: toInteger(localeFirstWeekContainsDate);
var firstWeekContainsDate =
options.firstWeekContainsDate == null
? defaultFirstWeekContainsDate
: toInteger(options.firstWeekContainsDate);
// Test if weekStartsOn is between 1 and 7 _and_ is not NaN
if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
throw new RangeError(
'firstWeekContainsDate must be between 1 and 7 inclusively'
)
}
var localeWeekStartsOn = locale$1.options && locale$1.options.weekStartsOn;
var defaultWeekStartsOn =
localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
var weekStartsOn =
options.weekStartsOn == null
? defaultWeekStartsOn
: toInteger(options.weekStartsOn);
// Test if weekStartsOn is between 0 and 6 _and_ is not NaN
if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
}
if (!locale$1.localize) {
throw new RangeError('locale must contain localize property')
}
if (!locale$1.formatLong) {
throw new RangeError('locale must contain formatLong property')
}
var originalDate = toDate(dirtyDate, options);
if (!isValid(originalDate, options)) {
return 'Invalid Date'
}
// Convert the date in system timezone to the same date in UTC+00:00 timezone.
// This ensures that when UTC functions will be implemented, locales will be compatible with them.
// See an issue about UTC functions: https://github.com/date-fns/date-fns/issues/376
var timezoneOffset = getTimezoneOffsetInMilliseconds(originalDate);
var utcDate = subMilliseconds(originalDate, timezoneOffset, options);
var formatterOptions = {
firstWeekContainsDate: firstWeekContainsDate,
weekStartsOn: weekStartsOn,
locale: locale$1,
_originalDate: originalDate
};
var result = formatStr
.match(longFormattingTokensRegExp)
.map(function(substring) {
var firstCharacter = substring[0];
if (firstCharacter === 'p' || firstCharacter === 'P') {
var longFormatter = longFormatters[firstCharacter];
return longFormatter(substring, locale$1.formatLong, formatterOptions)
}
return substring
})
.join('')
.match(formattingTokensRegExp)
.map(function(substring) {
// Replace two single quote characters with one single quote character
if (substring === "''") {
return "'"
}
var firstCharacter = substring[0];
if (firstCharacter === "'") {
return cleanEscapedString(substring)
}
var formatter = formatters[firstCharacter];
if (formatter) {
if (!options.awareOfUnicodeTokens && isProtectedToken(substring)) {
throwProtectedError(substring);
}
return formatter(utcDate, substring, locale$1.localize, formatterOptions)
}
return substring
})
.join('');
return result
}
function cleanEscapedString(input) {
return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'")
}
/**
* @name isAfter
* @category Common Helpers
* @summary Is the first date after the second one?
*
* @description
* Is the first date after the second one?
*
* @param {Date|String|Number} date - the date that should be after the other one to return true
* @param {Date|String|Number} dateToCompare - the date to compare with
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @returns {Boolean} the first date is after the second date
* @throws {TypeError} 2 arguments required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
*
* @example
* // Is 10 July 1989 after 11 February 1987?
* var result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
* //=> true
*/
function isAfter (dirtyDate, dirtyDateToCompare, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var dateToCompare = toDate(dirtyDateToCompare, dirtyOptions);
return date.getTime() > dateToCompare.getTime()
}
/**
* @name isBefore
* @category Common Helpers
* @summary Is the first date before the second one?
*
* @description
* Is the first date before the second one?
*
* @param {Date|String|Number} date - the date that should be before the other one to return true
* @param {Date|String|Number} dateToCompare - the date to compare with
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @returns {Boolean} the first date is before the second date
* @throws {TypeError} 2 arguments required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
*
* @example
* // Is 10 July 1989 before 11 February 1987?
* var result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
* //=> false
*/
function isBefore (dirtyDate, dirtyDateToCompare, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var dateToCompare = toDate(dirtyDateToCompare, dirtyOptions);
return date.getTime() < dateToCompare.getTime()
}
/**
* @name isEqual
* @category Common Helpers
* @summary Are the given dates equal?
*
* @description
* Are the given dates equal?
*
* @param {Date|String|Number} dateLeft - the first date to compare
* @param {Date|String|Number} dateRight - the second date to compare
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @returns {Boolean} the dates are equal
* @throws {TypeError} 2 arguments required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
*
* @example
* // Are 2 July 2014 06:30:45.000 and 2 July 2014 06:30:45.500 equal?
* var result = isEqual(
* new Date(2014, 6, 2, 6, 30, 45, 0)
* new Date(2014, 6, 2, 6, 30, 45, 500)
* )
* //=> false
*/
function isEqual (dirtyLeftDate, dirtyRightDate, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var dateLeft = toDate(dirtyLeftDate, dirtyOptions);
var dateRight = toDate(dirtyRightDate, dirtyOptions);
return dateLeft.getTime() === dateRight.getTime()
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function setUTCDay (dirtyDate, dirtyDay, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var options = dirtyOptions || {};
var locale = options.locale;
var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;
var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn);
// Test if weekStartsOn is between 0 and 6 _and_ is not NaN
if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
}
var date = toDate(dirtyDate, dirtyOptions);
var day = toInteger(dirtyDay);
var currentDay = date.getUTCDay();
var remainder = day % 7;
var dayIndex = (remainder + 7) % 7;
var diff = (dayIndex < weekStartsOn ? 7 : 0) + day - currentDay;
date.setUTCDate(date.getUTCDate() + diff);
return date
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function setUTCWeek (dirtyDate, dirtyWeek, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var week = toInteger(dirtyWeek);
var diff = getUTCWeek(date, dirtyOptions) - week;
date.setUTCDate(date.getUTCDate() - diff * 7);
return date
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function setUTCISODay (dirtyDate, dirtyDay, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var day = toInteger(dirtyDay);
if (day % 7 === 0) {
day = day - 7;
}
var weekStartsOn = 1;
var date = toDate(dirtyDate, dirtyOptions);
var currentDay = date.getUTCDay();
var remainder = day % 7;
var dayIndex = (remainder + 7) % 7;
var diff = (dayIndex < weekStartsOn ? 7 : 0) + day - currentDay;
date.setUTCDate(date.getUTCDate() + diff);
return date
}
// This function will be a part of public API when UTC function will be implemented.
// See issue: https://github.com/date-fns/date-fns/issues/376
function setUTCISOWeek (dirtyDate, dirtyISOWeek, dirtyOptions) {
if (arguments.length < 2) {
throw new TypeError('2 arguments required, but only ' + arguments.length + ' present')
}
var date = toDate(dirtyDate, dirtyOptions);
var isoWeek = toInteger(dirtyISOWeek);
var diff = getUTCISOWeek(date, dirtyOptions) - isoWeek;
date.setUTCDate(date.getUTCDate() - diff * 7);
return date
}
var MILLISECONDS_IN_HOUR$1 = 3600000;
var MILLISECONDS_IN_MINUTE$2 = 60000;
var MILLISECONDS_IN_SECOND = 1000;
var numericPatterns = {
month: /^(1[0-2]|0?\d)/, // 0 to 12
date: /^(3[0-1]|[0-2]?\d)/, // 0 to 31
dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/, // 0 to 366
week: /^(5[0-3]|[0-4]?\d)/, // 0 to 53
hour23h: /^(2[0-3]|[0-1]?\d)/, // 0 to 23
hour24h: /^(2[0-4]|[0-1]?\d)/, // 0 to 24
hour11h: /^(1[0-1]|0?\d)/, // 0 to 11
hour12h: /^(1[0-2]|0?\d)/, // 0 to 12
minute: /^[0-5]?\d/, // 0 to 59
second: /^[0-5]?\d/, // 0 to 59
singleDigit: /^\d/, // 0 to 9
twoDigits: /^\d{1,2}/, // 0 to 99
threeDigits: /^\d{1,3}/, // 0 to 999
fourDigits: /^\d{1,4}/, // 0 to 9999
anyDigitsSigned: /^-?\d+/,
singleDigitSigned: /^-?\d/, // 0 to 9, -0 to -9
twoDigitsSigned: /^-?\d{1,2}/, // 0 to 99, -0 to -99
threeDigitsSigned: /^-?\d{1,3}/, // 0 to 999, -0 to -999
fourDigitsSigned: /^-?\d{1,4}/ // 0 to 9999, -0 to -9999
};
var timezonePatterns = {
basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
basic: /^([+-])(\d{2})(\d{2})|Z/,
basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
extended: /^([+-])(\d{2}):(\d{2})|Z/,
extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
};
function parseNumericPattern (pattern, string, valueCallback) {
var matchResult = string.match(pattern);
if (!matchResult) {
return null
}
var value = parseInt(matchResult[0], 10);
return {
value: valueCallback ? valueCallback(value) : value,
rest: string.slice(matchResult[0].length)
}
}
function parseTimezonePattern (pattern, string) {
var matchResult = string.match(pattern);
if (!matchResult) {
return null
}
// Input is 'Z'
if (matchResult[0] === 'Z') {
return {
value: 0,
rest: string.slice(1)
}
}
var sign = matchResult[1] === '+' ? 1 : -1;
var hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
var minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
var seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
return {
value: sign * (
hours * MILLISECONDS_IN_HOUR$1 +
minutes * MILLISECONDS_IN_MINUTE$2 +
seconds * MILLISECONDS_IN_SECOND
),
rest: string.slice(matchResult[0].length)
}
}
function parseAnyDigitsSigned (string, valueCallback) {
return parseNumericPattern(numericPatterns.anyDigitsSigned, string, valueCallback)
}
function parseNDigits (n, string, valueCallback) {
switch (n) {
case 1:
return parseNumericPattern(numericPatterns.singleDigit, string, valueCallback)
case 2:
return parseNumericPattern(numericPatterns.twoDigits, string, valueCallback)
case 3:
return parseNumericPattern(numericPatterns.threeDigits, string, valueCallback)
case 4:
return parseNumericPattern(numericPatterns.fourDigits, string, valueCallback)
default:
return parseNumericPattern(new RegExp('^\\d{1,' + n + '}'), string, valueCallback)
}
}
function parseNDigitsSigned (n, string, valueCallback) {
switch (n) {
case 1:
return parseNumericPattern(numericPatterns.singleDigitSigned, string, valueCallback)
case 2:
return parseNumericPattern(numericPatterns.twoDigitsSigned, string, valueCallback)
case 3:
return parseNumericPattern(numericPatterns.threeDigitsSigned, string, valueCallback)
case 4:
return parseNumericPattern(numericPatterns.fourDigitsSigned, string, valueCallback)
default:
return parseNumericPattern(new RegExp('^-?\\d{1,' + n + '}'), string, valueCallback)
}
}
function dayPeriodEnumToHours (enumValue) {
switch (enumValue) {
case 'morning':
return 4
case 'evening':
return 17
case 'pm':
case 'noon':
case 'afternoon':
return 12
case 'am':
case 'midnight':
case 'night':
default:
return 0
}
}
function normalizeTwoDigitYear (twoDigitYear, currentYear) {
var isCommonEra = currentYear > 0;
// Absolute number of the current year:
// 1 -> 1 AC
// 0 -> 1 BC
// -1 -> 2 BC
var absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
var result;
if (absCurrentYear <= 50) {
result = twoDigitYear || 100;
} else {
var rangeEnd = absCurrentYear + 50;
var rangeEndCentury = Math.floor(rangeEnd / 100) * 100;
var isPreviousCentury = twoDigitYear >= rangeEnd % 100;
result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
}
return isCommonEra ? result : 1 - result
}
var DAYS_IN_MONTH$1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
var DAYS_IN_MONTH_LEAP_YEAR$1 = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
// User for validation
function isLeapYearIndex$1 (year) {
return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)
}
/*
* | | Unit | | Unit |
* |-----|--------------------------------|-----|--------------------------------|
* | a | AM, PM | A* | Milliseconds in day |
* | b | AM, PM, noon, midnight | B | Flexible day period |
* | c | Stand-alone local day of week | C* | Localized hour w/ day period |
* | d | Day of month | D | Day of year |
* | e | Local day of week | E | Day of week |
* | f | | F* | Day of week in month |
* | g* | Modified Julian day | G | Era |
* | h | Hour [1-12] | H | Hour [0-23] |
* | i! | ISO day of week | I! | ISO week of year |
* | j* | Localized hour w/ day period | J* | Localized hour w/o day period |
* | k | Hour [1-24] | K | Hour [0-11] |
* | l* | (deprecated) | L | Stand-alone month |
* | m | Minute | M | Month |
* | n | | N | |
* | o! | Ordinal number modifier | O* | Timezone (GMT) |
* | p | | P | |
* | q | Stand-alone quarter | Q | Quarter |
* | r* | Related Gregorian year | R! | ISO week-numbering year |
* | s | Second | S | Fraction of second |
* | t! | Seconds timestamp | T! | Milliseconds timestamp |
* | u | Extended year | U* | Cyclic year |
* | v* | Timezone (generic non-locat.) | V* | Timezone (location) |
* | w | Local week of year | W* | Week of month |
* | x | Timezone (ISO-8601 w/o Z) | X | Timezone (ISO-8601) |
* | y | Year (abs) | Y | Local week-numbering year |
* | z* | Timezone (specific non-locat.) | Z* | Timezone (aliases) |
*
* Letters marked by * are not implemented but reserved by Unicode standard.
*
* Letters marked by ! are non-standard, but implemented by date-fns:
* - `o` modifies the previous token to turn it into an ordinal (see `parse` docs)
* - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
* i.e. 7 for Sunday, 1 for Monday, etc.
* - `I` is ISO week of year, as opposed to `w` which is local week of year.
* - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
* `R` is supposed to be used in conjunction with `I` and `i`
* for universal ISO week-numbering date, whereas
* `Y` is supposed to be used in conjunction with `w` and `e`
* for week-numbering date specific to the locale.
*/
var parsers = {
// Era
G: {
priority: 140,
parse: function (string, token, match, options) {
switch (token) {
// AD, BC
case 'G':
case 'GG':
case 'GGG':
return match.era(string, {width: 'abbreviated'}) ||
match.era(string, {width: 'narrow'})
// A, B
case 'GGGGG':
return match.era(string, {width: 'narrow'})
// Anno Domini, Before Christ
case 'GGGG':
default:
return match.era(string, {width: 'wide'}) ||
match.era(string, {width: 'abbreviated'}) ||
match.era(string, {width: 'narrow'})
}
},
set: function (date, value, options) {
// Sets year 10 BC if BC, or 10 AC if AC
date.setUTCFullYear(value === 1 ? 10 : -9, 0, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Year
y: {
// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_Patterns
// | Year | y | yy | yyy | yyyy | yyyyy |
// |----------|-------|----|-------|-------|-------|
// | AD 1 | 1 | 01 | 001 | 0001 | 00001 |
// | AD 12 | 12 | 12 | 012 | 0012 | 00012 |
// | AD 123 | 123 | 23 | 123 | 0123 | 00123 |
// | AD 1234 | 1234 | 34 | 1234 | 1234 | 01234 |
// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
priority: 130,
parse: function (string, token, match, options) {
var valueCallback = function (year) {
return {
year: year,
isTwoDigitYear: token === 'yy'
}
};
switch (token) {
case 'y':
return parseNDigits(4, string, valueCallback)
case 'yo':
return match.ordinalNumber(string, {unit: 'year', valueCallback: valueCallback})
default:
return parseNDigits(token.length, string, valueCallback)
}
},
validate: function (date, value, options) {
return value.isTwoDigitYear || value.year > 0
},
set: function (date, value, options) {
var currentYear = getUTCWeekYear(date, options);
if (value.isTwoDigitYear) {
var normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
date.setUTCFullYear(normalizedTwoDigitYear, 0, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
var year = currentYear > 0 ? value.year : 1 - value.year;
date.setUTCFullYear(year, 0, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Local week-numbering year
Y: {
priority: 130,
parse: function (string, token, match, options) {
var valueCallback = function (year) {
return {
year: year,
isTwoDigitYear: token === 'YY'
}
};
switch (token) {
case 'Y':
return parseNDigits(4, string, valueCallback)
case 'Yo':
return match.ordinalNumber(string, {unit: 'year', valueCallback: valueCallback})
default:
return parseNDigits(token.length, string, valueCallback)
}
},
validate: function (date, value, options) {
return value.isTwoDigitYear || value.year > 0
},
set: function (date, value, options) {
var currentYear = date.getUTCFullYear();
if (value.isTwoDigitYear) {
var normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
date.setUTCFullYear(normalizedTwoDigitYear, 0, options.firstWeekContainsDate);
date.setUTCHours(0, 0, 0, 0);
return startOfUTCWeek(date, options)
}
var year = currentYear > 0 ? value.year : 1 - value.year;
date.setUTCFullYear(year, 0, options.firstWeekContainsDate);
date.setUTCHours(0, 0, 0, 0);
return startOfUTCWeek(date, options)
}
},
// ISO week-numbering year
R: {
priority: 130,
parse: function (string, token, match, options) {
if (token === 'R') {
return parseNDigitsSigned(4, string)
}
return parseNDigitsSigned(token.length, string)
},
set: function (date, value, options) {
var firstWeekOfYear = new Date(0);
firstWeekOfYear.setUTCFullYear(value, 0, 4);
firstWeekOfYear.setUTCHours(0, 0, 0, 0);
return startOfUTCISOWeek(firstWeekOfYear)
}
},
// Extended year
u: {
priority: 130,
parse: function (string, token, match, options) {
if (token === 'u') {
return parseNDigitsSigned(4, string)
}
return parseNDigitsSigned(token.length, string)
},
set: function (date, value, options) {
date.setUTCFullYear(value, 0, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Quarter
Q: {
priority: 120,
parse: function (string, token, match, options) {
switch (token) {
// 1, 2, 3, 4
case 'Q':
case 'QQ': // 01, 02, 03, 04
return parseNDigits(token.length, string)
// 1st, 2nd, 3rd, 4th
case 'Qo':
return match.ordinalNumber(string, {unit: 'quarter'})
// Q1, Q2, Q3, Q4
case 'QQQ':
return match.quarter(string, {width: 'abbreviated', context: 'formatting'}) ||
match.quarter(string, {width: 'narrow', context: 'formatting'})
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case 'QQQQQ':
return match.quarter(string, {width: 'narrow', context: 'formatting'})
// 1st quarter, 2nd quarter, ...
case 'QQQQ':
default:
return match.quarter(string, {width: 'wide', context: 'formatting'}) ||
match.quarter(string, {width: 'abbreviated', context: 'formatting'}) ||
match.quarter(string, {width: 'narrow', context: 'formatting'})
}
},
validate: function (date, value, options) {
return value >= 1 && value <= 4
},
set: function (date, value, options) {
date.setUTCMonth((value - 1) * 3, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Stand-alone quarter
q: {
priority: 120,
parse: function (string, token, match, options) {
switch (token) {
// 1, 2, 3, 4
case 'q':
case 'qq': // 01, 02, 03, 04
return parseNDigits(token.length, string)
// 1st, 2nd, 3rd, 4th
case 'qo':
return match.ordinalNumber(string, {unit: 'quarter'})
// Q1, Q2, Q3, Q4
case 'qqq':
return match.quarter(string, {width: 'abbreviated', context: 'standalone'}) ||
match.quarter(string, {width: 'narrow', context: 'standalone'})
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case 'qqqqq':
return match.quarter(string, {width: 'narrow', context: 'standalone'})
// 1st quarter, 2nd quarter, ...
case 'qqqq':
default:
return match.quarter(string, {width: 'wide', context: 'standalone'}) ||
match.quarter(string, {width: 'abbreviated', context: 'standalone'}) ||
match.quarter(string, {width: 'narrow', context: 'standalone'})
}
},
validate: function (date, value, options) {
return value >= 1 && value <= 4
},
set: function (date, value, options) {
date.setUTCMonth((value - 1) * 3, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Month
M: {
priority: 110,
parse: function (string, token, match, options) {
var valueCallback = function (value) {
return value - 1
};
switch (token) {
// 1, 2, ..., 12
case 'M':
return parseNumericPattern(numericPatterns.month, string, valueCallback)
// 01, 02, ..., 12
case 'MM':
return parseNDigits(2, string, valueCallback)
// 1st, 2nd, ..., 12th
case 'Mo':
return match.ordinalNumber(string, {unit: 'month', valueCallback: valueCallback})
// Jan, Feb, ..., Dec
case 'MMM':
return match.month(string, {width: 'abbreviated', context: 'formatting'}) ||
match.month(string, {width: 'narrow', context: 'formatting'})
// J, F, ..., D
case 'MMMMM':
return match.month(string, {width: 'narrow', context: 'formatting'})
// January, February, ..., December
case 'MMMM':
default:
return match.month(string, {width: 'wide', context: 'formatting'}) ||
match.month(string, {width: 'abbreviated', context: 'formatting'}) ||
match.month(string, {width: 'narrow', context: 'formatting'})
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 11
},
set: function (date, value, options) {
date.setUTCMonth(value, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Stand-alone month
L: {
priority: 110,
parse: function (string, token, match, options) {
var valueCallback = function (value) {
return value - 1
};
switch (token) {
// 1, 2, ..., 12
case 'L':
return parseNumericPattern(numericPatterns.month, string, valueCallback)
// 01, 02, ..., 12
case 'LL':
return parseNDigits(2, string, valueCallback)
// 1st, 2nd, ..., 12th
case 'Lo':
return match.ordinalNumber(string, {unit: 'month', valueCallback: valueCallback})
// Jan, Feb, ..., Dec
case 'LLL':
return match.month(string, {width: 'abbreviated', context: 'standalone'}) ||
match.month(string, {width: 'narrow', context: 'standalone'})
// J, F, ..., D
case 'LLLLL':
return match.month(string, {width: 'narrow', context: 'standalone'})
// January, February, ..., December
case 'LLLL':
default:
return match.month(string, {width: 'wide', context: 'standalone'}) ||
match.month(string, {width: 'abbreviated', context: 'standalone'}) ||
match.month(string, {width: 'narrow', context: 'standalone'})
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 11
},
set: function (date, value, options) {
date.setUTCMonth(value, 1);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Local week of year
w: {
priority: 100,
parse: function (string, token, match, options) {
switch (token) {
case 'w':
return parseNumericPattern(numericPatterns.week, string)
case 'wo':
return match.ordinalNumber(string, {unit: 'week'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 1 && value <= 53
},
set: function (date, value, options) {
return startOfUTCWeek(setUTCWeek(date, value, options), options)
}
},
// ISO week of year
I: {
priority: 100,
parse: function (string, token, match, options) {
switch (token) {
case 'I':
return parseNumericPattern(numericPatterns.week, string)
case 'Io':
return match.ordinalNumber(string, {unit: 'week'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 1 && value <= 53
},
set: function (date, value, options) {
return startOfUTCISOWeek(setUTCISOWeek(date, value, options), options)
}
},
// Day of the month
d: {
priority: 90,
parse: function (string, token, match, options) {
switch (token) {
case 'd':
return parseNumericPattern(numericPatterns.date, string)
case 'do':
return match.ordinalNumber(string, {unit: 'date'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
var year = date.getUTCFullYear();
var isLeapYear = isLeapYearIndex$1(year);
var month = date.getUTCMonth();
if (isLeapYear) {
return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR$1[month]
} else {
return value >= 1 && value <= DAYS_IN_MONTH$1[month]
}
},
set: function (date, value, options) {
date.setUTCDate(value);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Day of year
D: {
priority: 90,
parse: function (string, token, match, options) {
switch (token) {
case 'D':
case 'DD':
return parseNumericPattern(numericPatterns.dayOfYear, string)
case 'Do':
return match.ordinalNumber(string, {unit: 'date'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
var year = date.getUTCFullYear();
var isLeapYear = isLeapYearIndex$1(year);
if (isLeapYear) {
return value >= 1 && value <= 366
} else {
return value >= 1 && value <= 365
}
},
set: function (date, value, options) {
date.setUTCMonth(0, value);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Day of week
E: {
priority: 90,
parse: function (string, token, match, options) {
switch (token) {
// Tue
case 'E':
case 'EE':
case 'EEE':
return match.day(string, {width: 'abbreviated', context: 'formatting'}) ||
match.day(string, {width: 'short', context: 'formatting'}) ||
match.day(string, {width: 'narrow', context: 'formatting'})
// T
case 'EEEEE':
return match.day(string, {width: 'narrow', context: 'formatting'})
// Tu
case 'EEEEEE':
return match.day(string, {width: 'short', context: 'formatting'}) ||
match.day(string, {width: 'narrow', context: 'formatting'})
// Tuesday
case 'EEEE':
default:
return match.day(string, {width: 'wide', context: 'formatting'}) ||
match.day(string, {width: 'abbreviated', context: 'formatting'}) ||
match.day(string, {width: 'short', context: 'formatting'}) ||
match.day(string, {width: 'narrow', context: 'formatting'})
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 6
},
set: function (date, value, options) {
date = setUTCDay(date, value, options);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Local day of week
e: {
priority: 90,
parse: function (string, token, match, options) {
var valueCallback = function (value) {
var wholeWeekDays = Math.floor((value - 1) / 7) * 7;
return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays
};
switch (token) {
// 3
case 'e':
case 'ee': // 03
return parseNDigits(token.length, string, valueCallback)
// 3rd
case 'eo':
return match.ordinalNumber(string, {unit: 'day', valueCallback: valueCallback})
// Tue
case 'eee':
return match.day(string, {width: 'abbreviated', context: 'formatting'}) ||
match.day(string, {width: 'short', context: 'formatting'}) ||
match.day(string, {width: 'narrow', context: 'formatting'})
// T
case 'eeeee':
return match.day(string, {width: 'narrow', context: 'formatting'})
// Tu
case 'eeeeee':
return match.day(string, {width: 'short', context: 'formatting'}) ||
match.day(string, {width: 'narrow', context: 'formatting'})
// Tuesday
case 'eeee':
default:
return match.day(string, {width: 'wide', context: 'formatting'}) ||
match.day(string, {width: 'abbreviated', context: 'formatting'}) ||
match.day(string, {width: 'short', context: 'formatting'}) ||
match.day(string, {width: 'narrow', context: 'formatting'})
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 6
},
set: function (date, value, options) {
date = setUTCDay(date, value, options);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// Stand-alone local day of week
c: {
priority: 90,
parse: function (string, token, match, options) {
var valueCallback = function (value) {
var wholeWeekDays = Math.floor((value - 1) / 7) * 7;
return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays
};
switch (token) {
// 3
case 'c':
case 'cc': // 03
return parseNDigits(token.length, string, valueCallback)
// 3rd
case 'co':
return match.ordinalNumber(string, {unit: 'day', valueCallback: valueCallback})
// Tue
case 'ccc':
return match.day(string, {width: 'abbreviated', context: 'standalone'}) ||
match.day(string, {width: 'short', context: 'standalone'}) ||
match.day(string, {width: 'narrow', context: 'standalone'})
// T
case 'ccccc':
return match.day(string, {width: 'narrow', context: 'standalone'})
// Tu
case 'cccccc':
return match.day(string, {width: 'short', context: 'standalone'}) ||
match.day(string, {width: 'narrow', context: 'standalone'})
// Tuesday
case 'cccc':
default:
return match.day(string, {width: 'wide', context: 'standalone'}) ||
match.day(string, {width: 'abbreviated', context: 'standalone'}) ||
match.day(string, {width: 'short', context: 'standalone'}) ||
match.day(string, {width: 'narrow', context: 'standalone'})
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 6
},
set: function (date, value, options) {
date = setUTCDay(date, value, options);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// ISO day of week
i: {
priority: 90,
parse: function (string, token, match, options) {
var valueCallback = function (value) {
if (value === 0) {
return 7
}
return value
};
switch (token) {
// 2
case 'i':
case 'ii': // 02
return parseNDigits(token.length, string)
// 2nd
case 'io':
return match.ordinalNumber(string, {unit: 'day'})
// Tue
case 'iii':
return match.day(string, {width: 'abbreviated', context: 'formatting', valueCallback: valueCallback}) ||
match.day(string, {width: 'short', context: 'formatting', valueCallback: valueCallback}) ||
match.day(string, {width: 'narrow', context: 'formatting', valueCallback: valueCallback})
// T
case 'iiiii':
return match.day(string, {width: 'narrow', context: 'formatting', valueCallback: valueCallback})
// Tu
case 'iiiiii':
return match.day(string, {width: 'short', context: 'formatting', valueCallback: valueCallback}) ||
match.day(string, {width: 'narrow', context: 'formatting', valueCallback: valueCallback})
// Tuesday
case 'iiii':
default:
return match.day(string, {width: 'wide', context: 'formatting', valueCallback: valueCallback}) ||
match.day(string, {width: 'abbreviated', context: 'formatting', valueCallback: valueCallback}) ||
match.day(string, {width: 'short', context: 'formatting', valueCallback: valueCallback}) ||
match.day(string, {width: 'narrow', context: 'formatting', valueCallback: valueCallback})
}
},
validate: function (date, value, options) {
return value >= 1 && value <= 7
},
set: function (date, value, options) {
date = setUTCISODay(date, value, options);
date.setUTCHours(0, 0, 0, 0);
return date
}
},
// AM or PM
a: {
priority: 80,
parse: function (string, token, match, options) {
switch (token) {
case 'a':
case 'aa':
case 'aaa':
return match.dayPeriod(string, {width: 'abbreviated', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
case 'aaaaa':
return match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
case 'aaaa':
default:
return match.dayPeriod(string, {width: 'wide', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'abbreviated', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
}
},
set: function (date, value, options) {
date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date
}
},
// AM, PM, midnight
b: {
priority: 80,
parse: function (string, token, match, options) {
switch (token) {
case 'b':
case 'bb':
case 'bbb':
return match.dayPeriod(string, {width: 'abbreviated', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
case 'bbbbb':
return match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
case 'bbbb':
default:
return match.dayPeriod(string, {width: 'wide', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'abbreviated', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
}
},
set: function (date, value, options) {
date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date
}
},
// in the morning, in the afternoon, in the evening, at night
B: {
priority: 80,
parse: function (string, token, match, options) {
switch (token) {
case 'B':
case 'BB':
case 'BBB':
return match.dayPeriod(string, {width: 'abbreviated', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
case 'BBBBB':
return match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
case 'BBBB':
default:
return match.dayPeriod(string, {width: 'wide', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'abbreviated', context: 'formatting'}) ||
match.dayPeriod(string, {width: 'narrow', context: 'formatting'})
}
},
set: function (date, value, options) {
date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date
}
},
// Hour [1-12]
h: {
priority: 70,
parse: function (string, token, match, options) {
switch (token) {
case 'h':
return parseNumericPattern(numericPatterns.hour12h, string)
case 'ho':
return match.ordinalNumber(string, {unit: 'hour'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 1 && value <= 12
},
set: function (date, value, options) {
var isPM = date.getUTCHours() >= 12;
if (isPM && value < 12) {
date.setUTCHours(value + 12, 0, 0, 0);
} else if (!isPM && value === 12) {
date.setUTCHours(0, 0, 0, 0);
} else {
date.setUTCHours(value, 0, 0, 0);
}
return date
}
},
// Hour [0-23]
H: {
priority: 70,
parse: function (string, token, match, options) {
switch (token) {
case 'H':
return parseNumericPattern(numericPatterns.hour23h, string)
case 'Ho':
return match.ordinalNumber(string, {unit: 'hour'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 23
},
set: function (date, value, options) {
date.setUTCHours(value, 0, 0, 0);
return date
}
},
// Hour [0-11]
K: {
priority: 70,
parse: function (string, token, match, options) {
switch (token) {
case 'K':
return parseNumericPattern(numericPatterns.hour11h, string)
case 'Ko':
return match.ordinalNumber(string, {unit: 'hour'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 11
},
set: function (date, value, options) {
var isPM = date.getUTCHours() >= 12;
if (isPM && value < 12) {
date.setUTCHours(value + 12, 0, 0, 0);
} else {
date.setUTCHours(value, 0, 0, 0);
}
return date
}
},
// Hour [1-24]
k: {
priority: 70,
parse: function (string, token, match, options) {
switch (token) {
case 'k':
return parseNumericPattern(numericPatterns.hour24h, string)
case 'ko':
return match.ordinalNumber(string, {unit: 'hour'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 1 && value <= 24
},
set: function (date, value, options) {
var hours = value <= 24 ? value % 24 : value;
date.setUTCHours(hours, 0, 0, 0);
return date
}
},
// Minute
m: {
priority: 60,
parse: function (string, token, match, options) {
switch (token) {
case 'm':
return parseNumericPattern(numericPatterns.minute, string)
case 'mo':
return match.ordinalNumber(string, {unit: 'minute'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 59
},
set: function (date, value, options) {
date.setUTCMinutes(value, 0, 0);
return date
}
},
// Second
s: {
priority: 50,
parse: function (string, token, match, options) {
switch (token) {
case 's':
return parseNumericPattern(numericPatterns.second, string)
case 'so':
return match.ordinalNumber(string, {unit: 'second'})
default:
return parseNDigits(token.length, string)
}
},
validate: function (date, value, options) {
return value >= 0 && value <= 59
},
set: function (date, value, options) {
date.setUTCSeconds(value, 0);
return date
}
},
// Fraction of second
S: {
priority: 40,
parse: function (string, token, match, options) {
var valueCallback = function (value) {
return Math.floor(value * Math.pow(10, -token.length + 3))
};
return parseNDigits(token.length, string, valueCallback)
},
set: function (date, value, options) {
date.setUTCMilliseconds(value);
return date
}
},
// Timezone (ISO-8601. +00:00 is `'Z'`)
X: {
priority: 20,
parse: function (string, token, match, options) {
switch (token) {
case 'X':
return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, string)
case 'XX':
return parseTimezonePattern(timezonePatterns.basic, string)
case 'XXXX':
return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, string)
case 'XXXXX':
return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, string)
case 'XXX':
default:
return parseTimezonePattern(timezonePatterns.extended, string)
}
},
set: function (date, value, options) {
return new Date(date.getTime() - value)
}
},
// Timezone (ISO-8601)
x: {
priority: 20,
parse: function (string, token, match, options) {
switch (token) {
case 'x':
return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, string)
case 'xx':
return parseTimezonePattern(timezonePatterns.basic, string)
case 'xxxx':
return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, string)
case 'xxxxx':
return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, string)
case 'xxx':
default:
return parseTimezonePattern(timezonePatterns.extended, string)
}
},
set: function (date, value, options) {
return new Date(date.getTime() - value)
}
},
// Seconds timestamp
t: {
priority: 10,
parse: function (string, token, match, options) {
return parseAnyDigitsSigned(string)
},
set: function (date, value, options) {
return new Date(value * 1000)
}
},
// Milliseconds timestamp
T: {
priority: 10,
parse: function (string, token, match, options) {
return parseAnyDigitsSigned(string)
},
set: function (date, value, options) {
return new Date(value)
}
}
};
var TIMEZONE_UNIT_PRIORITY = 20;
// This RegExp consists of three parts separated by `|`:
// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token
// (one of the certain letters followed by `o`)
// - (\w)\1* matches any sequences of the same letter
// - '' matches two quote characters in a row
// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
// except a single quote symbol, which ends the sequence.
// Two quote characters do not end the sequence.
// If there is no matching single quote
// then the sequence will continue until the end of the string.
// - . matches any single character unmatched by previous parts of the RegExps
var formattingTokensRegExp$1 = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
var escapedStringRegExp$1 = /^'(.*?)'?$/;
var doubleQuoteRegExp$1 = /''/g;
var notWhitespaceRegExp = /\S/;
/**
* @name parse
* @category Common Helpers
* @summary Parse the date.
*
* @description
* Return the date parsed from string using the given format string.
*
* > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
* > See: https://git.io/fxCyr
*
* The characters in the format string wrapped between two single quotes characters (') are escaped.
* Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
*
* Format of the format string is based on Unicode Technical Standard #35:
* https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
* with a few additions (see note 5 below the table).
*
* Accepted format string patterns:
* | Unit |Prior| Pattern | Result examples | Notes |
* |---------------------------------|-----|---------|-----------------------------------|-------|
* | Era | 140 | G..GGG | AD, BC | |
* | | | GGGG | Anno Domini, Before Christ | 2 |
* | | | GGGGG | A, B | |
* | Calendar year | 130 | y | 44, 1, 1900, 2017, 9999 | 4 |
* | | | yo | 44th, 1st, 1900th, 9999999th | 4,5 |
* | | | yy | 44, 01, 00, 17 | 4 |
* | | | yyy | 044, 001, 123, 999 | 4 |
* | | | yyyy | 0044, 0001, 1900, 2017 | 4 |
* | | | yyyyy | ... | 2,4 |
* | Local week-numbering year | 130 | Y | 44, 1, 1900, 2017, 9000 | 4 |
* | | | Yo | 44th, 1st, 1900th, 9999999th | 4,5 |
* | | | YY | 44, 01, 00, 17 | 4,6 |
* | | | YYY | 044, 001, 123, 999 | 4 |
* | | | YYYY | 0044, 0001, 1900, 2017 | 4,6 |
* | | | YYYYY | ... | 2,4 |
* | ISO week-numbering year | 130 | R | -43, 1, 1900, 2017, 9999, -9999 | 4,5 |
* | | | RR | -43, 01, 00, 17 | 4,5 |
* | | | RRR | -043, 001, 123, 999, -999 | 4,5 |
* | | | RRRR | -0043, 0001, 2017, 9999, -9999 | 4,5 |
* | | | RRRRR | ... | 2,4,5 |
* | Extended year | 130 | u | -43, 1, 1900, 2017, 9999, -999 | 4 |
* | | | uu | -43, 01, 99, -99 | 4 |
* | | | uuu | -043, 001, 123, 999, -999 | 4 |
* | | | uuuu | -0043, 0001, 2017, 9999, -9999 | 4 |
* | | | uuuuu | ... | 2,4 |
* | Quarter (formatting) | 120 | Q | 1, 2, 3, 4 | |
* | | | Qo | 1st, 2nd, 3rd, 4th | 5 |
* | | | QQ | 01, 02, 03, 04 | |
* | | | QQQ | Q1, Q2, Q3, Q4 | |
* | | | QQQQ | 1st quarter, 2nd quarter, ... | 2 |
* | | | QQQQQ | 1, 2, 3, 4 | 4 |
* | Quarter (stand-alone) | 120 | q | 1, 2, 3, 4 | |
* | | | qo | 1st, 2nd, 3rd, 4th | 5 |
* | | | qq | 01, 02, 03, 04 | |
* | | | qqq | Q1, Q2, Q3, Q4 | |
* | | | qqqq | 1st quarter, 2nd quarter, ... | 2 |
* | | | qqqqq | 1, 2, 3, 4 | 3 |
* | Month (formatting) | 110 | M | 1, 2, ..., 12 | |
* | | | Mo | 1st, 2nd, ..., 12th | 5 |
* | | | MM | 01, 02, ..., 12 | |
* | | | MMM | Jan, Feb, ..., Dec | |
* | | | MMMM | January, February, ..., December | 2 |
* | | | MMMMM | J, F, ..., D | |
* | Month (stand-alone) | 110 | L | 1, 2, ..., 12 | |
* | | | Lo | 1st, 2nd, ..., 12th | 5 |
* | | | LL | 01, 02, ..., 12 | |
* | | | LLL | Jan, Feb, ..., Dec | |
* | | | LLLL | January, February, ..., December | 2 |
* | | | LLLLL | J, F, ..., D | |
* | Local week of year | 100 | w | 1, 2, ..., 53 | |
* | | | wo | 1st, 2nd, ..., 53th | 5 |
* | | | ww | 01, 02, ..., 53 | |
* | ISO week of year | 100 | I | 1, 2, ..., 53 | 5 |
* | | | Io | 1st, 2nd, ..., 53th | 5 |
* | | | II | 01, 02, ..., 53 | 5 |
* | Day of month | 90 | d | 1, 2, ..., 31 | |
* | | | do | 1st, 2nd, ..., 31st | 5 |
* | | | dd | 01, 02, ..., 31 | |
* | Day of year | 90 | D | 1, 2, ..., 365, 366 | 6 |
* | | | Do | 1st, 2nd, ..., 365th, 366th | 5 |
* | | | DD | 01, 02, ..., 365, 366 | 6 |
* | | | DDD | 001, 002, ..., 365, 366 | |
* | | | DDDD | ... | 2 |
* | Day of week (formatting) | 90 | E..EEE | Mon, Tue, Wed, ..., Su | |
* | | | EEEE | Monday, Tuesday, ..., Sunday | 2 |
* | | | EEEEE | M, T, W, T, F, S, S | |
* | | | EEEEEE | Mo, Tu, We, Th, Fr, Su, Sa | |
* | ISO day of week (formatting) | 90 | i | 1, 2, 3, ..., 7 | 5 |
* | | | io | 1st, 2nd, ..., 7th | 5 |
* | | | ii | 01, 02, ..., 07 | 5 |
* | | | iii | Mon, Tue, Wed, ..., Su | 5 |
* | | | iiii | Monday, Tuesday, ..., Sunday | 2,5 |
* | | | iiiii | M, T, W, T, F, S, S | 5 |
* | | | iiiiii | Mo, Tu, We, Th, Fr, Su, Sa | 5 |
* | Local day of week (formatting) | 90 | e | 2, 3, 4, ..., 1 | |
* | | | eo | 2nd, 3rd, ..., 1st | 5 |
* | | | ee | 02, 03, ..., 01 | |
* | | | eee | Mon, Tue, Wed, ..., Su | |
* | | | eeee | Monday, Tuesday, ..., Sunday | 2 |
* | | | eeeee | M, T, W, T, F, S, S | |
* | | | eeeeee | Mo, Tu, We, Th, Fr, Su, Sa | |
* | Local day of week (stand-alone) | 90 | c | 2, 3, 4, ..., 1 | |
* | | | co | 2nd, 3rd, ..., 1st | 5 |
* | | | cc | 02, 03, ..., 01 | |
* | | | ccc | Mon, Tue, Wed, ..., Su | |
* | | | cccc | Monday, Tuesday, ..., Sunday | 2 |
* | | | ccccc | M, T, W, T, F, S, S | |
* | | | cccccc | Mo, Tu, We, Th, Fr, Su, Sa | |
* | AM, PM | 80 | a..aaa | AM, PM | |
* | | | aaaa | a.m., p.m. | 2 |
* | | | aaaaa | a, p | |
* | AM, PM, noon, midnight | 80 | b..bbb | AM, PM, noon, midnight | |
* | | | bbbb | a.m., p.m., noon, midnight | 2 |
* | | | bbbbb | a, p, n, mi | |
* | Flexible day period | 80 | B..BBB | at night, in the morning, ... | |
* | | | BBBB | at night, in the morning, ... | 2 |
* | | | BBBBB | at night, in the morning, ... | |
* | Hour [1-12] | 70 | h | 1, 2, ..., 11, 12 | |
* | | | ho | 1st, 2nd, ..., 11th, 12th | 5 |
* | | | hh | 01, 02, ..., 11, 12 | |
* | Hour [0-23] | 70 | H | 0, 1, 2, ..., 23 | |
* | | | Ho | 0th, 1st, 2nd, ..., 23rd | 5 |
* | | | HH | 00, 01, 02, ..., 23 | |
* | Hour [0-11] | 70 | K | 1, 2, ..., 11, 0 | |
* | | | Ko | 1st, 2nd, ..., 11th, 0th | 5 |
* | | | KK | 1, 2, ..., 11, 0 | |
* | Hour [1-24] | 70 | k | 24, 1, 2, ..., 23 | |
* | | | ko | 24th, 1st, 2nd, ..., 23rd | 5 |
* | | | kk | 24, 01, 02, ..., 23 | |
* | Minute | 60 | m | 0, 1, ..., 59 | |
* | | | mo | 0th, 1st, ..., 59th | 5 |
* | | | mm | 00, 01, ..., 59 | |
* | Second | 50 | s | 0, 1, ..., 59 | |
* | | | so | 0th, 1st, ..., 59th | 5 |
* | | | ss | 00, 01, ..., 59 | |
* | Fraction of second | 40 | S | 0, 1, ..., 9 | |
* | | | SS | 00, 01, ..., 99 | |
* | | | SSS | 000, 0001, ..., 999 | |
* | | | SSSS | ... | 2 |
* | Timezone (ISO-8601 w/ Z) | 20 | X | -08, +0530, Z | |
* | | | XX | -0800, +0530, Z | |
* | | | XXX | -08:00, +05:30, Z | |
* | | | XXXX | -0800, +0530, Z, +123456 | 2 |
* | | | XXXXX | -08:00, +05:30, Z, +12:34:56 | |
* | Timezone (ISO-8601 w/o Z) | 20 | x | -08, +0530, +00 | |
* | | | xx | -0800, +0530, +0000 | |
* | | | xxx | -08:00, +05:30, +00:00 | 2 |
* | | | xxxx | -0800, +0530, +0000, +123456 | |
* | | | xxxxx | -08:00, +05:30, +00:00, +12:34:56 | |
* | Seconds timestamp | 10 | t | 512969520 | |
* | | | tt | ... | 2 |
* | Milliseconds timestamp | 10 | T | 512969520900 | |
* | | | TT | ... | 2 |
* Notes:
* 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
* are the same as "stand-alone" units, but are different in some languages.
* "Formatting" units are declined according to the rules of the language
* in the context of a date. "Stand-alone" units are always nominative singular.
* In `format` function, they will produce different result:
*
* `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
*
* `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
*
* `parse` will try to match both formatting and stand-alone units interchangably.
*
* 2. Any sequence of the identical letters is a pattern, unless it is escaped by
* the single quote characters (see below).
* If the sequence is longer than listed in table:
* - for numerical units (`yyyyyyyy`) `parse` will try to match a number
* as wide as the sequence
* - for text units (`MMMMMMMM`) `parse` will try to match the widest variation of the unit.
* These variations are marked with "2" in the last column of the table.
*
* 3. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
* These tokens represent the shortest form of the quarter.
*
* 4. The main difference between `y` and `u` patterns are B.C. years:
*
* | Year | `y` | `u` |
* |------|-----|-----|
* | AC 1 | 1 | 1 |
* | BC 1 | 1 | 0 |
* | BC 2 | 2 | -1 |
*
* Also `yy` will try to guess the century of two digit year by proximity with `baseDate`:
*
* `parse('50', 'yy', new Date(2018, 0, 1)) //=> Sat Jan 01 2050 00:00:00`
*
* `parse('75', 'yy', new Date(2018, 0, 1)) //=> Wed Jan 01 1975 00:00:00`
*
* while `uu` will just assign the year as is:
*
* `parse('50', 'uu', new Date(2018, 0, 1)) //=> Sat Jan 01 0050 00:00:00`
*
* `parse('75', 'uu', new Date(2018, 0, 1)) //=> Tue Jan 01 0075 00:00:00`
*
* The same difference is true for local and ISO week-numbering years (`Y` and `R`),
* except local week-numbering years are dependent on `options.weekStartsOn`
* and `options.firstWeekContainsDate` (compare [setISOWeekYear]{@link https://date-fns.org/docs/setISOWeekYear}
* and [setWeekYear]{@link https://date-fns.org/docs/setWeekYear}).
*
* 5. These patterns are not in the Unicode Technical Standard #35:
* - `i`: ISO day of week
* - `I`: ISO week of year
* - `R`: ISO week-numbering year
* - `o`: ordinal number modifier
*
* 6. These tokens are often confused with others. See: https://git.io/fxCyr
*
* Values will be assigned to the date in the descending order of its unit's priority.
* Units of an equal priority overwrite each other in the order of appearance.
*
* If no values of higher priority are parsed (e.g. when parsing string 'January 1st' without a year),
* the values will be taken from 3rd argument `baseDate` which works as a context of parsing.
*
* `baseDate` must be passed for correct work of the function.
* If you're not sure which `baseDate` to supply, create a new instance of Date:
* `parse('02/11/2014', 'MM/dd/yyyy', new Date())`
* In this case parsing will be done in the context of the current date.
* If `baseDate` is `Invalid Date` or a value not convertible to valid `Date`,
* then `Invalid Date` will be returned.
*
* The result may vary by locale.
*
* If `formatString` matches with `dateString` but does not provides tokens, `baseDate` will be returned.
*
* If parsing failed, `Invalid Date` will be returned.
* Invalid Date is a Date, whose time value is NaN.
* Time value of Date: http://es5.github.io/#x15.9.1.1
*
* @param {String} dateString - the string to parse
* @param {String} formatString - the string of tokens
* @param {Date|String|Number} baseDate - defines values missing from the parsed dateString
* @param {Options} [options] - the object with options. See [Options]{@link https://date-fns.org/docs/Options}
* @param {0|1|2} [options.additionalDigits=2] - passed to `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
* @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
* @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
* @param {1|2|3|4|5|6|7} [options.firstWeekContainsDate=1] - the day of January, which is always in the first week of the year
* @param {Boolean} [options.awareOfUnicodeTokens=false] - if true, allows usage of Unicode tokens causes confusion:
* - Some of the day of year tokens (`D`, `DD`) that are confused with the day of month tokens (`d`, `dd`).
* - Some of the local week-numbering year tokens (`YY`, `YYYY`) that are confused with the calendar year tokens (`yy`, `yyyy`).
* See: https://git.io/fxCyr
* @returns {Date} the parsed date
* @throws {TypeError} 3 arguments required
* @throws {RangeError} `options.additionalDigits` must be 0, 1 or 2
* @throws {RangeError} `options.weekStartsOn` must be between 0 and 6
* @throws {RangeError} `options.firstWeekContainsDate` must be between 1 and 7
* @throws {RangeError} `options.locale` must contain `match` property
* @throws {RangeError} `options.awareOfUnicodeTokens` must be set to `true` to use `XX` token; see: https://git.io/fxCyr
*
* @example
* // Parse 11 February 2014 from middle-endian format:
* var result = parse(
* '02/11/2014',
* 'MM/dd/yyyy',
* new Date()
* )
* //=> Tue Feb 11 2014 00:00:00
*
* @example
* // Parse 28th of February in Esperanto locale in the context of 2010 year:
* import eo from 'date-fns/locale/eo'
* var result = parse(
* '28-a de februaro',
* "do 'de' MMMM",
* new Date(2010, 0, 1),
* {locale: eo}
* )
* //=> Sun Feb 28 2010 00:00:00
*/
function parse(
dirtyDateString,
dirtyFormatString,
dirtyBaseDate,
dirtyOptions
) {
if (arguments.length < 3) {
throw new TypeError(
'3 arguments required, but only ' + arguments.length + ' present'
)
}
var dateString = String(dirtyDateString);
var formatString = String(dirtyFormatString);
var options = dirtyOptions || {};
var locale$1 = options.locale || locale;
if (!locale$1.match) {
throw new RangeError('locale must contain match property')
}
var localeFirstWeekContainsDate =
locale$1.options && locale$1.options.firstWeekContainsDate;
var defaultFirstWeekContainsDate =
localeFirstWeekContainsDate == null
? 1
: toInteger(localeFirstWeekContainsDate);
var firstWeekContainsDate =
options.firstWeekContainsDate == null
? defaultFirstWeekContainsDate
: toInteger(options.firstWeekContainsDate);
// Test if weekStartsOn is between 1 and 7 _and_ is not NaN
if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
throw new RangeError(
'firstWeekContainsDate must be between 1 and 7 inclusively'
)
}
var localeWeekStartsOn = locale$1.options && locale$1.options.weekStartsOn;
var defaultWeekStartsOn =
localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
var weekStartsOn =
options.weekStartsOn == null
? defaultWeekStartsOn
: toInteger(options.weekStartsOn);
// Test if weekStartsOn is between 0 and 6 _and_ is not NaN
if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
}
if (formatString === '') {
if (dateString === '') {
return toDate(dirtyBaseDate, options)
} else {
return new Date(NaN)
}
}
var subFnOptions = {
firstWeekContainsDate: firstWeekContainsDate,
weekStartsOn: weekStartsOn,
locale: locale$1
};
// If timezone isn't specified, it will be set to the system timezone
var setters = [
{
priority: TIMEZONE_UNIT_PRIORITY,
set: dateToSystemTimezone,
index: 0
}
];
var i;
var tokens = formatString.match(formattingTokensRegExp$1);
for (i = 0; i < tokens.length; i++) {
var token = tokens[i];
if (!options.awareOfUnicodeTokens && isProtectedToken(token)) {
throwProtectedError(token);
}
var firstCharacter = token[0];
var parser = parsers[firstCharacter];
if (parser) {
var parseResult = parser.parse(
dateString,
token,
locale$1.match,
subFnOptions
);
if (!parseResult) {
return new Date(NaN)
}
setters.push({
priority: parser.priority,
set: parser.set,
validate: parser.validate,
value: parseResult.value,
index: setters.length
});
dateString = parseResult.rest;
} else {
// Replace two single quote characters with one single quote character
if (token === "''") {
token = "'";
} else if (firstCharacter === "'") {
token = cleanEscapedString$1(token);
}
// Cut token from string, or, if string doesn't match the token, return Invalid Date
if (dateString.indexOf(token) === 0) {
dateString = dateString.slice(token.length);
} else {
return new Date(NaN)
}
}
}
// Check if the remaining input contains something other than whitespace
if (dateString.length > 0 && notWhitespaceRegExp.test(dateString)) {
return new Date(NaN)
}
var uniquePrioritySetters = setters
.map(function(setter) {
return setter.priority
})
.sort(function(a, b) {
return b - a
})
.filter(function(priority, index, array) {
return array.indexOf(priority) === index
})
.map(function(priority) {
return setters
.filter(function(setter) {
return setter.priority === priority
})
.reverse()
})
.map(function(setterArray) {
return setterArray[0]
});
var date = toDate(dirtyBaseDate, options);
if (isNaN(date)) {
return new Date(NaN)
}
// Convert the date in system timezone to the same date in UTC+00:00 timezone.
// This ensures that when UTC functions will be implemented, locales will be compatible with them.
// See an issue about UTC functions: https://github.com/date-fns/date-fns/issues/37
var utcDate = subMilliseconds(date, getTimezoneOffsetInMilliseconds(date));
for (i = 0; i < uniquePrioritySetters.length; i++) {
var setter = uniquePrioritySetters[i];
if (
setter.validate &&
!setter.validate(utcDate, setter.value, subFnOptions)
) {
return new Date(NaN)
}
utcDate = setter.set(utcDate, setter.value, subFnOptions);
}
return utcDate
}
function dateToSystemTimezone(date) {
var convertedDate = new Date(0);
convertedDate.setFullYear(
date.getUTCFullYear(),
date.getUTCMonth(),
date.getUTCDate()
);
convertedDate.setHours(
date.getUTCHours(),
date.getUTCMinutes(),
date.getUTCSeconds(),
date.getUTCMilliseconds()
);
return convertedDate
}
function cleanEscapedString$1(input) {
return input.match(escapedStringRegExp$1)[1].replace(doubleQuoteRegExp$1, "'")
}
//
/**
* Custom parse behavior on top of date-fns parse function.
*/
function parseDate$1 (date, format$1) {
if (typeof date !== 'string') {
return isValid(date) ? date : null;
}
var parsed = parse(date, format$1, new Date());
// if date is not valid or the formatted output after parsing does not match
// the string value passed in (avoids overflows)
if (!isValid(parsed) || format(parsed, format$1) !== date) {
return null;
}
return parsed;
}
var afterValidator = function (value, ref) {
if ( ref === void 0 ) ref = {};
var targetValue = ref.targetValue;
var inclusion = ref.inclusion; if ( inclusion === void 0 ) inclusion = false;
var format = ref.format;
if (typeof format === 'undefined') {
format = inclusion;
inclusion = false;
}
value = parseDate$1(value, format);
targetValue = parseDate$1(targetValue, format);
// if either is not valid.
if (!value || !targetValue) {
return false;
}
return isAfter(value, targetValue) || (inclusion && isEqual(value, targetValue));
};
var options = {
hasTarget: true,
isDate: true
};
// required to convert from a list of array values to an object.
var paramNames = ['targetValue', 'inclusion', 'format'];
var after = {
validate: afterValidator,
options: options,
paramNames: paramNames
};
/**
* Some Alpha Regex helpers.
* https://github.com/chriso/validator.js/blob/master/src/lib/alpha.js
*/
var alpha = {
en: /^[A-Z]*$/i,
cs: /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]*$/i,
da: /^[A-ZÆØÅ]*$/i,
de: /^[A-ZÄÖÜß]*$/i,
es: /^[A-ZÁÉÍÑÓÚÜ]*$/i,
fa: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰپژگچکی]*$/,
fr: /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]*$/i,
it: /^[A-Z\xC0-\xFF]*$/i,
lt: /^[A-ZĄČĘĖĮŠŲŪŽ]*$/i,
nl: /^[A-ZÉËÏÓÖÜ]*$/i,
hu: /^[A-ZÁÉÍÓÖŐÚÜŰ]*$/i,
pl: /^[A-ZĄĆĘŚŁŃÓŻŹ]*$/i,
pt: /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]*$/i,
ru: /^[А-ЯЁ]*$/i,
sk: /^[A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ]*$/i,
sr: /^[A-ZČĆŽŠĐ]*$/i,
sv: /^[A-ZÅÄÖ]*$/i,
tr: /^[A-ZÇĞİıÖŞÜ]*$/i,
uk: /^[А-ЩЬЮЯЄІЇҐ]*$/i,
ar: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ]*$/,
az: /^[A-ZÇƏĞİıÖŞÜ]*$/i
};
var alphaSpaces = {
en: /^[A-Z\s]*$/i,
cs: /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ\s]*$/i,
da: /^[A-ZÆØÅ\s]*$/i,
de: /^[A-ZÄÖÜß\s]*$/i,
es: /^[A-ZÁÉÍÑÓÚÜ\s]*$/i,
fa: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰپژگچکی\s]*$/,
fr: /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ\s]*$/i,
it: /^[A-Z\xC0-\xFF\s]*$/i,
lt: /^[A-ZĄČĘĖĮŠŲŪŽ\s]*$/i,
nl: /^[A-ZÉËÏÓÖÜ\s]*$/i,
hu: /^[A-ZÁÉÍÓÖŐÚÜŰ\s]*$/i,
pl: /^[A-ZĄĆĘŚŁŃÓŻŹ\s]*$/i,
pt: /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ\s]*$/i,
ru: /^[А-ЯЁ\s]*$/i,
sk: /^[A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ\s]*$/i,
sr: /^[A-ZČĆŽŠĐ\s]*$/i,
sv: /^[A-ZÅÄÖ\s]*$/i,
tr: /^[A-ZÇĞİıÖŞÜ\s]*$/i,
uk: /^[А-ЩЬЮЯЄІЇҐ\s]*$/i,
ar: /^[ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ\s]*$/,
az: /^[A-ZÇƏĞİıÖŞÜ\s]*$/i
};
var alphanumeric = {
en: /^[0-9A-Z]*$/i,
cs: /^[0-9A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]*$/i,
da: /^[0-9A-ZÆØÅ]$/i,
de: /^[0-9A-ZÄÖÜß]*$/i,
es: /^[0-9A-ZÁÉÍÑÓÚÜ]*$/i,
fa: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰپژگچکی]*$/,
fr: /^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]*$/i,
it: /^[0-9A-Z\xC0-\xFF]*$/i,
lt: /^[0-9A-ZĄČĘĖĮŠŲŪŽ]*$/i,
hu: /^[0-9A-ZÁÉÍÓÖŐÚÜŰ]*$/i,
nl: /^[0-9A-ZÉËÏÓÖÜ]*$/i,
pl: /^[0-9A-ZĄĆĘŚŁŃÓŻŹ]*$/i,
pt: /^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]*$/i,
ru: /^[0-9А-ЯЁ]*$/i,
sk: /^[0-9A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ]*$/i,
sr: /^[0-9A-ZČĆŽŠĐ]*$/i,
sv: /^[0-9A-ZÅÄÖ]*$/i,
tr: /^[0-9A-ZÇĞİıÖŞÜ]*$/i,
uk: /^[0-9А-ЩЬЮЯЄІЇҐ]*$/i,
ar: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ]*$/,
az: /^[0-9A-ZÇƏĞİıÖŞÜ]*$/i
};
var alphaDash = {
en: /^[0-9A-Z_-]*$/i,
cs: /^[0-9A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ_-]*$/i,
da: /^[0-9A-ZÆØÅ_-]*$/i,
de: /^[0-9A-ZÄÖÜß_-]*$/i,
es: /^[0-9A-ZÁÉÍÑÓÚÜ_-]*$/i,
fa: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰپژگچکی_-]*$/,
fr: /^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ_-]*$/i,
it: /^[0-9A-Z\xC0-\xFF_-]*$/i,
lt: /^[0-9A-ZĄČĘĖĮŠŲŪŽ_-]*$/i,
nl: /^[0-9A-ZÉËÏÓÖÜ_-]*$/i,
hu: /^[0-9A-ZÁÉÍÓÖŐÚÜŰ_-]*$/i,
pl: /^[0-9A-ZĄĆĘŚŁŃÓŻŹ_-]*$/i,
pt: /^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ_-]*$/i,
ru: /^[0-9А-ЯЁ_-]*$/i,
sk: /^[0-9A-ZÁÄČĎÉÍĹĽŇÓŔŠŤÚÝŽ_-]*$/i,
sr: /^[0-9A-ZČĆŽŠĐ_-]*$/i,
sv: /^[0-9A-ZÅÄÖ_-]*$/i,
tr: /^[0-9A-ZÇĞİıÖŞÜ_-]*$/i,
uk: /^[0-9А-ЩЬЮЯЄІЇҐ_-]*$/i,
ar: /^[٠١٢٣٤٥٦٧٨٩0-9ءآأؤإئابةتثجحخدذرزسشصضطظعغفقكلمنهوىيًٌٍَُِّْٰ_-]*$/,
az: /^[0-9A-ZÇƏĞİıÖŞÜ_-]*$/i
};
var validate = function (value, ref) {
if ( ref === void 0 ) ref = {};
var locale = ref.locale;
if (Array.isArray(value)) {
return value.every(function (val) { return validate(val, [locale]); });
}
// Match at least one locale.
if (! locale) {
return Object.keys(alpha).some(function (loc) { return alpha[loc].test(value); });
}
return (alpha[locale] || alpha.en).test(value);
};
var paramNames$1 = ['locale'];
var alpha$1 = {
validate: validate,
paramNames: paramNames$1
};
var validate$1 = function (value, ref) {
if ( ref === void 0 ) ref = {};
var locale = ref.locale;
if (Array.isArray(value)) {
return value.every(function (val) { return validate$1(val, [locale]); });
}
// Match at least one locale.
if (! locale) {
return Object.keys(alphaDash).some(function (loc) { return alphaDash[loc].test(value); });
}
return (alphaDash[locale] || alphaDash.en).test(value);
};
var paramNames$2 = ['locale'];
var alpha_dash = {
validate: validate$1,
paramNames: paramNames$2
};
var validate$2 = function (value, ref) {
if ( ref === void 0 ) ref = {};
var locale = ref.locale;
if (Array.isArray(value)) {
return value.every(function (val) { return validate$2(val, [locale]); });
}
// Match at least one locale.
if (! locale) {
return Object.keys(alphanumeric).some(function (loc) { return alphanumeric[loc].test(value); });
}
return (alphanumeric[locale] || alphanumeric.en).test(value);
};
var paramNames$3 = ['locale'];
var alpha_num = {
validate: validate$2,
paramNames: paramNames$3
};
var validate$3 = function (value, ref) {
if ( ref === void 0 ) ref = {};
var locale = ref.locale;
if (Array.isArray(value)) {
return value.every(function (val) { return validate$3(val, [locale]); });
}
// Match at least one locale.
if (! locale) {
return Object.keys(alphaSpaces).some(function (loc) { return alphaSpaces[loc].test(value); });
}
return (alphaSpaces[locale] || alphaSpaces.en).test(value);
};
var paramNames$4 = ['locale'];
var alpha_spaces = {
validate: validate$3,
paramNames: paramNames$4
};
var validate$4 = function (value, ref) {
if ( ref === void 0 ) ref = {};
var targetValue = ref.targetValue;
var inclusion = ref.inclusion; if ( inclusion === void 0 ) inclusion = false;
var format = ref.format;
if (typeof format === 'undefined') {
format = inclusion;
inclusion = false;
}
value = parseDate$1(value, format);
targetValue = parseDate$1(targetValue, format);
// if either is not valid.
if (!value || !targetValue) {
return false;
}
return isBefore(value, targetValue) || (inclusion && isEqual(value, targetValue));
};
var options$1 = {
hasTarget: true,
isDate: true
};
var paramNames$5 = ['targetValue', 'inclusion', 'format'];
var before = {
validate: validate$4,
options: options$1,
paramNames: paramNames$5
};
var validate$5 = function (value, ref) {
if ( ref === void 0 ) ref = {};
var min = ref.min;
var max = ref.max;
if (Array.isArray(value)) {
return value.every(function (val) { return validate$5(val, { min: min, max: max }); });
}
return Number(min) <= value && Number(max) >= value;
};
var paramNames$6 = ['min', 'max'];
var between = {
validate: validate$5,
paramNames: paramNames$6
};
var validate$6 = function (value, ref) {
var targetValue = ref.targetValue;
return String(value) === String(targetValue);
};
var options$2 = {
hasTarget: true
};
var paramNames$7 = ['targetValue'];
var confirmed = {
validate: validate$6,
options: options$2,
paramNames: paramNames$7
};
function unwrapExports (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
var assertString_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = assertString;
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function assertString(input) {
var isString = typeof input === 'string' || input instanceof String;
if (!isString) {
var invalidType;
if (input === null) {
invalidType = 'null';
} else {
invalidType = _typeof(input);
if (invalidType === 'object' && input.constructor && input.constructor.hasOwnProperty('name')) {
invalidType = input.constructor.name;
} else {
invalidType = "a ".concat(invalidType);
}
}
throw new TypeError("Expected string but received ".concat(invalidType, "."));
}
}
module.exports = exports.default;
module.exports.default = exports.default;
});
unwrapExports(assertString_1);
var isCreditCard_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = isCreditCard;
var _assertString = _interopRequireDefault(assertString_1);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/* eslint-disable max-len */
var creditCard = /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|(222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11}|6[27][0-9]{14})$/;
/* eslint-enable max-len */
function isCreditCard(str) {
(0, _assertString.default)(str);
var sanitized = str.replace(/[- ]+/g, '');
if (!creditCard.test(sanitized)) {
return false;
}
var sum = 0;
var digit;
var tmpNum;
var shouldDouble;
for (var i = sanitized.length - 1; i >= 0; i--) {
digit = sanitized.substring(i, i + 1);
tmpNum = parseInt(digit, 10);
if (shouldDouble) {
tmpNum *= 2;
if (tmpNum >= 10) {
sum += tmpNum % 10 + 1;
} else {
sum += tmpNum;
}
} else {
sum += tmpNum;
}
shouldDouble = !shouldDouble;
}
return !!(sum % 10 === 0 ? sanitized : false);
}
module.exports = exports.default;
module.exports.default = exports.default;
});
var isCreditCard = unwrapExports(isCreditCard_1);
var validate$7 = function (value) { return isCreditCard(String(value)); };
var credit_card = {
validate: validate$7
};
var validate$8 = function (value, ref) {
if ( ref === void 0 ) ref = {};
var min = ref.min;
var max = ref.max;
var inclusivity = ref.inclusivity; if ( inclusivity === void 0 ) inclusivity = '()';
var format = ref.format;
if (typeof format === 'undefined') {
format = inclusivity;
inclusivity = '()';
}
var minDate = parseDate$1(String(min), format);
var maxDate = parseDate$1(String(max), format);
var dateVal = parseDate$1(String(value), format);
if (!minDate || !maxDate || !dateVal) {
return false;
}
if (inclusivity === '()') {
return isAfter(dateVal, minDate) && isBefore(dateVal, maxDate);
}
if (inclusivity === '(]') {
return isAfter(dateVal, minDate) && (isEqual(dateVal, maxDate) || isBefore(dateVal, maxDate));
}
if (inclusivity === '[)') {
return isBefore(dateVal, maxDate) && (isEqual(dateVal, minDate) || isAfter(dateVal, minDate));
}
return isEqual(dateVal, maxDate) || isEqual(dateVal, minDate) ||
(isBefore(dateVal, maxDate) && isAfter(dateVal, minDate));
};
var options$3 = {
isDate: true
};
var paramNames$8 = ['min', 'max', 'inclusivity', 'format'];
var date_between = {
validate: validate$8,
options: options$3,
paramNames: paramNames$8
};
var validate$9 = function (value, ref) {
var format = ref.format;
return !!parseDate$1(value, format);
};
var options$4 = {
isDate: true
};
var paramNames$9 = ['format'];
var date_format = {
validate: validate$9,
options: options$4,
paramNames: paramNames$9
};
//
/**
* Checks if the values are either null or undefined.
*/
var isNullOrUndefined = function () {
var values = [], len = arguments.length;
while ( len-- ) values[ len ] = arguments[ len ];
return values.every(function (value) {
return value === null || value === undefined;
});
};
/**
* Checks if a function is callable.
*/
var isCallable = function (func) { return typeof func === 'function'; };
/**
* Converts an array-like object to array, provides a simple polyfill for Array.from
*/
var toArray = function (arrayLike) {
if (isCallable(Array.from)) {
return Array.from(arrayLike);
}
var array = [];
var length = arrayLike.length;
/* istanbul ignore next */
for (var i = 0; i < length; i++) {
array.push(arrayLike[i]);
}
/* istanbul ignore next */
return array;
};
/**
* Converts an array-like object to array and place other elements in an array
*/
var ensureArray = function (arrayLike) {
if (Array.isArray(arrayLike)) {
return [].concat( arrayLike );
}
var array = toArray(arrayLike);
return isEmptyArray(array) ? [arrayLike] : array;
};
/**
* Assign polyfill from the mdn.
*/
var assign = function (target) {
var others = [], len = arguments.length - 1;
while ( len-- > 0 ) others[ len ] = arguments[ len + 1 ];
/* istanbul ignore else */
if (isCallable(Object.assign)) {
return Object.assign.apply(Object, [ target ].concat( others ));
}
/* istanbul ignore next */
if (target == null) {
throw new TypeError('Cannot convert undefined or null to object');
}
/* istanbul ignore next */
var to = Object(target);
/* istanbul ignore next */
others.forEach(function (arg) {
// Skip over if undefined or null
if (arg != null) {
Object.keys(arg).forEach(function (key) {
to[key] = arg[key];
});
}
});
/* istanbul ignore next */
return to;
};
var isEmptyArray = function (arr) {
return Array.isArray(arr) && arr.length === 0;
};
var validate$a = function (value, ref) {
if ( ref === void 0 ) ref = {};
var decimals = ref.decimals; if ( decimals === void 0 ) decimals = '*';
var separator = ref.separator; if ( separator === void 0 ) separator = '.';
if (isNullOrUndefined(value) || value === '') {
return false;
}
if (Array.isArray(value)) {
return value.every(function (val) { return validate$a(val, { decimals: decimals, separator: separator }); });
}
// if is 0.
if (Number(decimals) === 0) {
return /^-?\d*$/.test(value);
}
var regexPart = decimals === '*' ? '+' : ("{1," + decimals + "}");
var regex = new RegExp(("^[-+]?\\d*(\\" + separator + "\\d" + regexPart + ")?([eE]{1}[-]?\\d+)?$"));
if (! regex.test(value)) {
return false;
}
var parsedValue = parseFloat(value);
// eslint-disable-next-line
return parsedValue === parsedValue;
};
var paramNames$a = ['decimals', 'separator'];
var decimal = {
validate: validate$a,
paramNames: paramNames$a
};
var validate$b = function (value, ref) {
var length = ref[0];
if (Array.isArray(value)) {
return value.every(function (val) { return validate$b(val, [length]); });
}
var strVal = String(value);
return /^[0-9]*$/.test(strVal) && strVal.length === Number(length);
};
var digits = {
validate: validate$b
};
var imageRegex = /\.(jpg|svg|jpeg|png|bmp|gif)$/i;
var validateImage = function (file, width, height) {
var URL = window.URL || window.webkitURL;
return new Promise(function (resolve) {
var image = new Image();
image.onerror = function () { return resolve({ valid: false }); };
image.onload = function () { return resolve({
valid: image.width === Number(width) && image.height === Number(height)
}); };
image.src = URL.createObjectURL(file);
});
};
var validate$c = function (files, ref) {
var width = ref[0];
var height = ref[1];
var images = ensureArray(files).filter(function (file) { return imageRegex.test(file.name); });
if (images.length === 0) {
return false;
}
return Promise.all(images.map(function (image) { return validateImage(image, width, height); }));
};
var dimensions = {
validate: validate$c
};
var merge_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = merge;
function merge() {
var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var defaults = arguments.length > 1 ? arguments[1] : undefined;
for (var key in defaults) {
if (typeof obj[key] === 'undefined') {
obj[key] = defaults[key];
}
}
return obj;
}
module.exports = exports.default;
module.exports.default = exports.default;
});
unwrapExports(merge_1);
var isByteLength_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = isByteLength;
var _assertString = _interopRequireDefault(assertString_1);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
/* eslint-disable prefer-rest-params */
function isByteLength(str, options) {
(0, _assertString.default)(str);
var min;
var max;
if (_typeof(options) === 'object') {
min = options.min || 0;
max = options.max;
} else {
// backwards compatibility: isByteLength(str, min [, max])
min = arguments[1];
max = arguments[2];
}
var len = encodeURI(str).split(/%..|./).length - 1;
return len >= min && (typeof max === 'undefined' || len <= max);
}
module.exports = exports.default;
module.exports.default = exports.default;
});
unwrapExports(isByteLength_1);
var isFQDN_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = isFQDN;
var _assertString = _interopRequireDefault(assertString_1);
var _merge = _interopRequireDefault(merge_1);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var default_fqdn_options = {
require_tld: true,
allow_underscores: false,
allow_trailing_dot: false
};
function isFQDN(str, options) {
(0, _assertString.default)(str);
options = (0, _merge.default)(options, default_fqdn_options);
/* Remove the optional trailing dot before checking validity */
if (options.allow_trailing_dot && str[str.length - 1] === '.') {
str = str.substring(0, str.length - 1);
}
var parts = str.split('.');
for (var i = 0; i < parts.length; i++) {
if (parts[i].length > 63) {
return false;
}
}
if (options.require_tld) {
var tld = parts.pop();
if (!parts.length || !/^([a-z\u00a1-\uffff]{2,}|xn[a-z0-9-]{2,})$/i.test(tld)) {
return false;
} // disallow spaces
if (/[\s\u2002-\u200B\u202F\u205F\u3000\uFEFF\uDB40\uDC20]/.test(tld)) {
return false;
}
}
for (var part, _i = 0; _i < parts.length; _i++) {
part = parts[_i];
if (options.allow_underscores) {
part = part.replace(/_/g, '');
}
if (!/^[a-z\u00a1-\uffff0-9-]+$/i.test(part)) {
return false;
} // disallow full-width chars
if (/[\uff01-\uff5e]/.test(part)) {
return false;
}
if (part[0] === '-' || part[part.length - 1] === '-') {
return false;
}
}
return true;
}
module.exports = exports.default;
module.exports.default = exports.default;
});
var isFQDN = unwrapExports(isFQDN_1);
var isIP_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = isIP;
var _assertString = _interopRequireDefault(assertString_1);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var ipv4Maybe = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
var ipv6Block = /^[0-9A-F]{1,4}$/i;
function isIP(str) {
var version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
(0, _assertString.default)(str);
version = String(version);
if (!version) {
return isIP(str, 4) || isIP(str, 6);
} else if (version === '4') {
if (!ipv4Maybe.test(str)) {
return false;
}
var parts = str.split('.').sort(function (a, b) {
return a - b;
});
return parts[3] <= 255;
} else if (version === '6') {
var blocks = str.split(':');
var foundOmissionBlock = false; // marker to indicate ::
// At least some OS accept the last 32 bits of an IPv6 address
// (i.e. 2 of the blocks) in IPv4 notation, and RFC 3493 says
// that '::ffff:a.b.c.d' is valid for IPv4-mapped IPv6 addresses,
// and '::a.b.c.d' is deprecated, but also valid.
var foundIPv4TransitionBlock = isIP(blocks[blocks.length - 1], 4);
var expectedNumberOfBlocks = foundIPv4TransitionBlock ? 7 : 8;
if (blocks.length > expectedNumberOfBlocks) {
return false;
} // initial or final ::
if (str === '::') {
return true;
} else if (str.substr(0, 2) === '::') {
blocks.shift();
blocks.shift();
foundOmissionBlock = true;
} else if (str.substr(str.length - 2) === '::') {
blocks.pop();
blocks.pop();
foundOmissionBlock = true;
}
for (var i = 0; i < blocks.length; ++i) {
// test for a :: which can not be at the string start/end
// since those cases have been handled above
if (blocks[i] === '' && i > 0 && i < blocks.length - 1) {
if (foundOmissionBlock) {
return false; // multiple :: in address
}
foundOmissionBlock = true;
} else if (foundIPv4TransitionBlock && i === blocks.length - 1) ; else if (!ipv6Block.test(blocks[i])) {
return false;
}
}
if (foundOmissionBlock) {
return blocks.length >= 1;
}
return blocks.length === expectedNumberOfBlocks;
}
return false;
}
module.exports = exports.default;
module.exports.default = exports.default;
});
var isIP = unwrapExports(isIP_1);
var isEmail_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = isEmail;
var _assertString = _interopRequireDefault(assertString_1);
var _merge = _interopRequireDefault(merge_1);
var _isByteLength = _interopRequireDefault(isByteLength_1);
var _isFQDN = _interopRequireDefault(isFQDN_1);
var _isIP = _interopRequireDefault(isIP_1);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var default_email_options = {
allow_display_name: false,
require_display_name: false,
allow_utf8_local_part: true,
require_tld: true
};
/* eslint-disable max-len */
/* eslint-disable no-control-regex */
var displayName = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\,\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\s]*<(.+)>$/i;
var emailUserPart = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~]+$/i;
var gmailUserPart = /^[a-z\d]+$/;
var quotedEmailUser = /^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f]))*$/i;
var emailUserUtf8Part = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$/i;
var quotedEmailUserUtf8 = /^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*$/i;
/* eslint-enable max-len */
/* eslint-enable no-control-regex */
function isEmail(str, options) {
(0, _assertString.default)(str);
options = (0, _merge.default)(options, default_email_options);
if (options.require_display_name || options.allow_display_name) {
var display_email = str.match(displayName);
if (display_email) {
str = display_email[1];
} else if (options.require_display_name) {
return false;
}
}
var parts = str.split('@');
var domain = parts.pop();
var user = parts.join('@');
var lower_domain = domain.toLowerCase();
if (options.domain_specific_validation && (lower_domain === 'gmail.com' || lower_domain === 'googlemail.com')) {
/*
Previously we removed dots for gmail addresses before validating.
This was removed because it allows `multiple..dots@gmail.com`
to be reported as valid, but it is not.
Gmail only normalizes single dots, removing them from here is pointless,
should be done in normalizeEmail
*/
user = user.toLowerCase(); // Removing sub-address from username before gmail validation
var username = user.split('+')[0]; // Dots are not included in gmail length restriction
if (!(0, _isByteLength.default)(username.replace('.', ''), {
min: 6,
max: 30
})) {
return false;
}
var _user_parts = username.split('.');
for (var i = 0; i < _user_parts.length; i++) {
if (!gmailUserPart.test(_user_parts[i])) {
return false;
}
}
}
if (!(0, _isByteLength.default)(user, {
max: 64
}) || !(0, _isByteLength.default)(domain, {
max: 254
})) {
return false;
}
if (!(0, _isFQDN.default)(domain, {
require_tld: options.require_tld
})) {
if (!options.allow_ip_domain) {
return false;
}
if (!(0, _isIP.default)(domain)) {
if (!domain.startsWith('[') || !domain.endsWith(']')) {
return false;
}
var noBracketdomain = domain.substr(1, domain.length - 2);
if (noBracketdomain.length === 0 || !(0, _isIP.default)(noBracketdomain)) {
return false;
}
}
}
if (user[0] === '"') {
user = user.slice(1, user.length - 1);
return options.allow_utf8_local_part ? quotedEmailUserUtf8.test(user) : quotedEmailUser.test(user);
}
var pattern = options.allow_utf8_local_part ? emailUserUtf8Part : emailUserPart;
var user_parts = user.split('.');
for (var _i = 0; _i < user_parts.length; _i++) {
if (!pattern.test(user_parts[_i])) {
return false;
}
}
return true;
}
module.exports = exports.default;
module.exports.default = exports.default;
});
var isEmail = unwrapExports(isEmail_1);
function objectWithoutProperties (obj, exclude) { var target = {}; for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k) && exclude.indexOf(k) === -1) target[k] = obj[k]; return target; }
var validate$d = function (value, ref) {
if ( ref === void 0 ) ref = {};
var multiple = ref.multiple; if ( multiple === void 0 ) multiple = false;
var rest = objectWithoutProperties( ref, ["multiple"] );
var options = rest;
if (multiple && !Array.isArray(value)) {
value = String(value).split(',').map(function (emailStr) { return emailStr.trim(); });
}
var validatorOptions = assign({}, options);
if (Array.isArray(value)) {
return value.every(function (val) { return isEmail(String(val), validatorOptions); });
}
return isEmail(String(value), validatorOptions);
};
var email = {
validate: validate$d
};
var validate$e = function (value, options) {
if (Array.isArray(value)) {
return value.every(function (val) { return validate$e(val, options); });
}
return toArray(options).some(function (item) {
// eslint-disable-next-line
return item == value;
});
};
var included = {
validate: validate$e
};
var validate$f = function () {
var args = [], len = arguments.length;
while ( len-- ) args[ len ] = arguments[ len ];
return !validate$e.apply(void 0, args);
};
var excluded = {
validate: validate$f
};
var validate$g = function (files, extensions) {
var regex = new RegExp((".(" + (extensions.join('|')) + ")$"), 'i');
return ensureArray(files).every(function (file) { return regex.test(file.name); });
};
var ext = {
validate: validate$g
};
var validate$h = function (files) { return (Array.isArray(files) ? files : [files]).every(function (file) { return /\.(jpg|svg|jpeg|png|bmp|gif)$/i.test(file.name); }); };
var image = {
validate: validate$h
};
var validate$i = function (value) {
if (Array.isArray(value)) {
return value.every(function (val) { return /^-?[0-9]+$/.test(String(val)); });
}
return /^-?[0-9]+$/.test(String(value));
};
var integer = {
validate: validate$i
};
var validate$j = function (value, ref) {
if ( ref === void 0 ) ref = {};
var version = ref.version; if ( version === void 0 ) version = 4;
if (isNullOrUndefined(value)) {
value = '';
}
if (Array.isArray(value)) {
return value.every(function (val) { return isIP(val, version); });
}
return isIP(value, version);
};
var paramNames$b = ['version'];
var ip = {
validate: validate$j,
paramNames: paramNames$b
};
var validate$k = function (value) {
if (isNullOrUndefined(value)) {
value = '';
}
if (Array.isArray(value)) {
return value.every(function (val) { return (isIP(val, '') || isFQDN(val)); });
}
return isIP(value, '') || isFQDN(value);
};
var ip_or_fqdn = {
validate: validate$k
};
var validate$l = function (value, ref) {
if ( ref === void 0 ) ref = [];
var other = ref[0];
return value === other;
};
var is = {
validate: validate$l
};
var validate$m = function (value, ref) {
if ( ref === void 0 ) ref = [];
var other = ref[0];
return value !== other;
};
var is_not = {
validate: validate$m
};
/**
* @param {Array|String} value
* @param {Number} length
* @param {Number} max
*/
var compare = function (value, length, max) {
if (max === undefined) {
return value.length === length;
}
// cast to number.
max = Number(max);
return value.length >= length && value.length <= max;
};
var validate$n = function (value, ref) {
var length = ref[0];
var max = ref[1]; if ( max === void 0 ) max = undefined;
if (isNullOrUndefined(value)) {
return false;
}
length = Number(length);
if (typeof value === 'number') {
value = String(value);
}
if (!value.length) {
value = toArray(value);
}
return compare(value, length, max);
};
var length = {
validate: validate$n
};
var validate$o = function (value, ref) {
var length = ref[0];
if (isNullOrUndefined(value)) {
return length >= 0;
}
if (Array.isArray(value)) {
return value.every(function (val) { return validate$o(val, [length]); });
}
return String(value).length <= length;
};
var max = {
validate: validate$o
};
var validate$p = function (value, ref) {
var max = ref[0];
if (isNullOrUndefined(value) || value === '') {
return false;
}
if (Array.isArray(value)) {
return value.length > 0 && value.every(function (val) { return validate$p(val, [max]); });
}
return Number(value) <= max;
};
var max_value = {
validate: validate$p
};
var validate$q = function (files, mimes) {
var regex = new RegExp(((mimes.join('|').replace('*', '.+')) + "$"), 'i');
return ensureArray(files).every(function (file) { return regex.test(file.type); });
};
var mimes = {
validate: validate$q
};
var validate$r = function (value, ref) {
var length = ref[0];
if (isNullOrUndefined(value)) {
return false;
}
if (Array.isArray(value)) {
return value.every(function (val) { return validate$r(val, [length]); });
}
return String(value).length >= length;
};
var min = {
validate: validate$r
};
var validate$s = function (value, ref) {
var min = ref[0];
if (isNullOrUndefined(value) || value === '') {
return false;
}
if (Array.isArray(value)) {
return value.length > 0 && value.every(function (val) { return validate$s(val, [min]); });
}
return Number(value) >= min;
};
var min_value = {
validate: validate$s
};
var ar = /^[٠١٢٣٤٥٦٧٨٩]+$/;
var en = /^[0-9]+$/;
var validate$t = function (value) {
var testValue = function (val) {
var strValue = String(val);
return en.test(strValue) || ar.test(strValue);
};
if (Array.isArray(value)) {
return value.every(testValue);
}
return testValue(value);
};
var numeric = {
validate: validate$t
};
var validate$u = function (value, ref) {
var expression = ref.expression;
if (typeof expression === 'string') {
expression = new RegExp(expression);
}
if (Array.isArray(value)) {
return value.every(function (val) { return validate$u(val, { expression: expression }); });
}
return expression.test(String(value));
};
var paramNames$c = ['expression'];
var regex = {
validate: validate$u,
paramNames: paramNames$c
};
var validate$v = function (value, ref) {
if ( ref === void 0 ) ref = [];
var invalidateFalse = ref[0]; if ( invalidateFalse === void 0 ) invalidateFalse = false;
if (isNullOrUndefined(value) || isEmptyArray(value)) {
return false;
}
// incase a field considers `false` as an empty value like checkboxes.
if (value === false && invalidateFalse) {
return false;
}
return !!String(value).trim().length;
};
var required = {
validate: validate$v
};
var validate$w = function (value, ref) {
if ( ref === void 0 ) ref = [];
var otherFieldVal = ref[0];
var possibleVals = ref.slice(1);
var required = possibleVals.includes(String(otherFieldVal).trim());
if (!required) {
return {
valid: true,
data: {
required: required
}
};
}
var invalid = (isEmptyArray(value) || [false, null, undefined].includes(value));
invalid = invalid || !String(value).trim().length;
return {
valid: !invalid,
data: {
required: required
}
};
};
var options$5 = {
hasTarget: true,
computesRequired: true
};
var required_if = {
validate: validate$w,
options: options$5
};
var validate$x = function (files, ref) {
var size = ref[0];
if (isNaN(size)) {
return false;
}
var nSize = Number(size) * 1024;
return ensureArray(files).every(function (file) { return file.size <= nSize; });
};
var size = {
validate: validate$x
};
var isURL_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = isURL;
var _assertString = _interopRequireDefault(assertString_1);
var _isFQDN = _interopRequireDefault(isFQDN_1);
var _isIP = _interopRequireDefault(isIP_1);
var _merge = _interopRequireDefault(merge_1);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var default_url_options = {
protocols: ['http', 'https', 'ftp'],
require_tld: true,
require_protocol: false,
require_host: true,
require_valid_protocol: true,
allow_underscores: false,
allow_trailing_dot: false,
allow_protocol_relative_urls: false
};
var wrapped_ipv6 = /^\[([^\]]+)\](?::([0-9]+))?$/;
function isRegExp(obj) {
return Object.prototype.toString.call(obj) === '[object RegExp]';
}
function checkHost(host, matches) {
for (var i = 0; i < matches.length; i++) {
var match = matches[i];
if (host === match || isRegExp(match) && match.test(host)) {
return true;
}
}
return false;
}
function isURL(url, options) {
(0, _assertString.default)(url);
if (!url || url.length >= 2083 || /[\s<>]/.test(url)) {
return false;
}
if (url.indexOf('mailto:') === 0) {
return false;
}
options = (0, _merge.default)(options, default_url_options);
var protocol, auth, host, hostname, port, port_str, split, ipv6;
split = url.split('#');
url = split.shift();
split = url.split('?');
url = split.shift();
split = url.split('://');
if (split.length > 1) {
protocol = split.shift().toLowerCase();
if (options.require_valid_protocol && options.protocols.indexOf(protocol) === -1) {
return false;
}
} else if (options.require_protocol) {
return false;
} else if (url.substr(0, 2) === '//') {
if (!options.allow_protocol_relative_urls) {
return false;
}
split[0] = url.substr(2);
}
url = split.join('://');
if (url === '') {
return false;
}
split = url.split('/');
url = split.shift();
if (url === '' && !options.require_host) {
return true;
}
split = url.split('@');
if (split.length > 1) {
if (options.disallow_auth) {
return false;
}
auth = split.shift();
if (auth.indexOf(':') >= 0 && auth.split(':').length > 2) {
return false;
}
}
hostname = split.join('@');
port_str = null;
ipv6 = null;
var ipv6_match = hostname.match(wrapped_ipv6);
if (ipv6_match) {
host = '';
ipv6 = ipv6_match[1];
port_str = ipv6_match[2] || null;
} else {
split = hostname.split(':');
host = split.shift();
if (split.length) {
port_str = split.join(':');
}
}
if (port_str !== null) {
port = parseInt(port_str, 10);
if (!/^[0-9]+$/.test(port_str) || port <= 0 || port > 65535) {
return false;
}
}
if (!(0, _isIP.default)(host) && !(0, _isFQDN.default)(host, options) && (!ipv6 || !(0, _isIP.default)(ipv6, 6))) {
return false;
}
host = host || ipv6;
if (options.host_whitelist && !checkHost(host, options.host_whitelist)) {
return false;
}
if (options.host_blacklist && checkHost(host, options.host_blacklist)) {
return false;
}
return true;
}
module.exports = exports.default;
module.exports.default = exports.default;
});
var isURL = unwrapExports(isURL_1);
var validate$y = function (value, options) {
if ( options === void 0 ) options = {};
if (isNullOrUndefined(value)) {
value = '';
}
var validatorOptions = assign({}, options);
if (Array.isArray(value)) {
return value.every(function (val) { return isURL(val, validatorOptions); });
}
return isURL(value, validatorOptions);
};
var url = {
validate: validate$y
};
export { after, alpha$1 as alpha, alpha_dash, alpha_num, alpha_spaces, before, between, confirmed, credit_card, date_between, date_format, decimal, digits, dimensions, email, excluded, ext, image, included, integer, ip, ip_or_fqdn, is, is_not, length, max, max_value, mimes, min, min_value, numeric, regex, required, required_if, size, url };