@datepicker-react/styled
Version:
A React datepicker build with styled-components.
1,762 lines • 158 kB
JavaScript
import e, {
useState as t,
useEffect as n,
useCallback as r,
useMemo as a,
useContext as o,
useRef as i,
useImperativeHandle as d,
} from 'react'
import s, {ThemeContext as c, css as u, keyframes as l, ThemeProvider as p} from 'styled-components'
var f = {
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'},
aboutXWeeks: {one: 'about 1 week', other: 'about {{count}} weeks'},
xWeeks: {one: '1 week', other: '{{count}} weeks'},
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 g(e) {
return function (t) {
var n = t || {},
r = n.width ? String(n.width) : e.defaultWidth
return e.formats[r] || e.formats[e.defaultWidth]
}
}
var h = {
date: g({
formats: {
full: 'EEEE, MMMM do, y',
long: 'MMMM do, y',
medium: 'MMM d, y',
short: 'MM/dd/yyyy',
},
defaultWidth: 'full',
}),
time: g({
formats: {full: 'h:mm:ss a zzzz', long: 'h:mm:ss a z', medium: 'h:mm:ss a', short: 'h:mm a'},
defaultWidth: 'full',
}),
dateTime: g({
formats: {
full: "{{date}} 'at' {{time}}",
long: "{{date}} 'at' {{time}}",
medium: '{{date}}, {{time}}',
short: '{{date}}, {{time}}',
},
defaultWidth: 'full',
}),
},
m = {
lastWeek: "'last' eeee 'at' p",
yesterday: "'yesterday at' p",
today: "'today at' p",
tomorrow: "'tomorrow at' p",
nextWeek: "eeee 'at' p",
other: 'P',
}
function y(e) {
return function (t, n) {
var r,
a = n || {}
if ('formatting' === (a.context ? String(a.context) : 'standalone') && e.formattingValues) {
var o = e.defaultFormattingWidth || e.defaultWidth,
i = a.width ? String(a.width) : o
r = e.formattingValues[i] || e.formattingValues[o]
} else {
var d = e.defaultWidth,
s = a.width ? String(a.width) : e.defaultWidth
r = e.values[s] || e.values[d]
}
return r[e.argumentCallback ? e.argumentCallback(t) : t]
}
}
function v(e) {
return function (t, n) {
var r = String(t),
a = n || {},
o = a.width,
i = (o && e.matchPatterns[o]) || e.matchPatterns[e.defaultMatchWidth],
d = r.match(i)
if (!d) return null
var s,
c = d[0],
u = (o && e.parsePatterns[o]) || e.parsePatterns[e.defaultParseWidth]
return (
(s =
'[object Array]' === Object.prototype.toString.call(u)
? (function (e, t) {
for (var n = 0; n < e.length; n++) if (t(e[n])) return n
})(u, function (e) {
return e.test(c)
})
: (function (e, t) {
for (var n in e) if (e.hasOwnProperty(n) && t(e[n])) return n
})(u, function (e) {
return e.test(c)
})),
(s = e.valueCallback ? e.valueCallback(s) : s),
{value: (s = a.valueCallback ? a.valueCallback(s) : s), rest: r.slice(c.length)}
)
}
}
var b,
w = {
code: 'en-US',
formatDistance: function (e, t, n) {
var r
return (
(n = n || {}),
(r =
'string' == typeof f[e] ? f[e] : 1 === t ? f[e].one : f[e].other.replace('{{count}}', t)),
n.addSuffix ? (n.comparison > 0 ? 'in ' + r : r + ' ago') : r
)
},
formatLong: h,
formatRelative: function (e, t, n, r) {
return m[e]
},
localize: {
ordinalNumber: function (e, t) {
var n = Number(e),
r = n % 100
if (r > 20 || r < 10)
switch (r % 10) {
case 1:
return n + 'st'
case 2:
return n + 'nd'
case 3:
return n + 'rd'
}
return n + 'th'
},
era: y({
values: {
narrow: ['B', 'A'],
abbreviated: ['BC', 'AD'],
wide: ['Before Christ', 'Anno Domini'],
},
defaultWidth: 'wide',
}),
quarter: y({
values: {
narrow: ['1', '2', '3', '4'],
abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter'],
},
defaultWidth: 'wide',
argumentCallback: function (e) {
return Number(e) - 1
},
}),
month: y({
values: {
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',
],
},
defaultWidth: 'wide',
}),
day: y({
values: {
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'],
},
defaultWidth: 'wide',
}),
dayPeriod: y({
values: {
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',
},
},
defaultWidth: 'wide',
formattingValues: {
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',
},
},
defaultFormattingWidth: 'wide',
}),
},
match: {
ordinalNumber:
((b = {
matchPattern: /^(\d+)(th|st|nd|rd)?/i,
parsePattern: /\d+/i,
valueCallback: function (e) {
return parseInt(e, 10)
},
}),
function (e, t) {
var n = String(e),
r = t || {},
a = n.match(b.matchPattern)
if (!a) return null
var o = a[0],
i = n.match(b.parsePattern)
if (!i) return null
var d = b.valueCallback ? b.valueCallback(i[0]) : i[0]
return {value: (d = r.valueCallback ? r.valueCallback(d) : d), rest: n.slice(o.length)}
}),
era: v({
matchPatterns: {
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,
},
defaultMatchWidth: 'wide',
parsePatterns: {any: [/^b/i, /^(a|c)/i]},
defaultParseWidth: 'any',
}),
quarter: v({
matchPatterns: {
narrow: /^[1234]/i,
abbreviated: /^q[1234]/i,
wide: /^[1234](th|st|nd|rd)? quarter/i,
},
defaultMatchWidth: 'wide',
parsePatterns: {any: [/1/i, /2/i, /3/i, /4/i]},
defaultParseWidth: 'any',
valueCallback: function (e) {
return e + 1
},
}),
month: v({
matchPatterns: {
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,
},
defaultMatchWidth: 'wide',
parsePatterns: {
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,
],
},
defaultParseWidth: 'any',
}),
day: v({
matchPatterns: {
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,
},
defaultMatchWidth: 'wide',
parsePatterns: {
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],
},
defaultParseWidth: 'any',
}),
dayPeriod: v({
matchPatterns: {
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,
},
defaultMatchWidth: 'any',
parsePatterns: {
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,
},
},
defaultParseWidth: 'any',
}),
},
options: {weekStartsOn: 0, firstWeekContainsDate: 1},
}
function D(e) {
if (null === e || !0 === e || !1 === e) return NaN
var t = Number(e)
return isNaN(t) ? t : t < 0 ? Math.ceil(t) : Math.floor(t)
}
function k(e, t) {
if (t.length < e)
throw new TypeError(
e + ' argument' + (e > 1 ? 's' : '') + ' required, but only ' + t.length + ' present',
)
}
function x(e) {
k(1, arguments)
var t = Object.prototype.toString.call(e)
return e instanceof Date || ('object' == typeof e && '[object Date]' === t)
? new Date(e.getTime())
: 'number' == typeof e || '[object Number]' === t
? new Date(e)
: (('string' != typeof e && '[object String]' !== t) ||
'undefined' == typeof console ||
(console.warn(
"Starting with v2.0.0-beta.1 date-fns doesn't accept strings as arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule",
),
console.warn(new Error().stack)),
new Date(NaN))
}
function C(e, t) {
k(2, arguments)
var n = x(e).getTime(),
r = D(t)
return new Date(n + r)
}
function T(e, t) {
k(2, arguments)
var n = D(t)
return C(e, -n)
}
function S(e, t) {
if (null == e)
throw new TypeError('assign requires that input parameter not be null or undefined')
for (var n in (t = t || {})) t.hasOwnProperty(n) && (e[n] = t[n])
return e
}
function B(e, t) {
switch (e) {
case 'P':
return t.date({width: 'short'})
case 'PP':
return t.date({width: 'medium'})
case 'PPP':
return t.date({width: 'long'})
case 'PPPP':
default:
return t.date({width: 'full'})
}
}
function M(e, t) {
switch (e) {
case 'p':
return t.time({width: 'short'})
case 'pp':
return t.time({width: 'medium'})
case 'ppp':
return t.time({width: 'long'})
case 'pppp':
default:
return t.time({width: 'full'})
}
}
var L = {
p: M,
P: function (e, t) {
var n,
r = e.match(/(P+)(p+)?/),
a = r[1],
o = r[2]
if (!o) return B(e, t)
switch (a) {
case 'P':
n = t.dateTime({width: 'short'})
break
case 'PP':
n = t.dateTime({width: 'medium'})
break
case 'PPP':
n = t.dateTime({width: 'long'})
break
case 'PPPP':
default:
n = t.dateTime({width: 'full'})
}
return n.replace('{{date}}', B(a, t)).replace('{{time}}', M(o, t))
},
}
function W(e) {
return e.getTime() % 6e4
}
function R(e) {
var t = new Date(e.getTime()),
n = Math.ceil(t.getTimezoneOffset())
return t.setSeconds(0, 0), 6e4 * n + (n > 0 ? (6e4 + W(t)) % 6e4 : W(t))
}
var E = ['D', 'DD'],
F = ['YY', 'YYYY']
function H(e) {
return -1 !== E.indexOf(e)
}
function P(e) {
return -1 !== F.indexOf(e)
}
function O(e) {
if ('YYYY' === e)
throw new RangeError(
'Use `yyyy` instead of `YYYY` for formatting years; see: https://git.io/fxCyr',
)
if ('YY' === e)
throw new RangeError('Use `yy` instead of `YY` for formatting years; see: https://git.io/fxCyr')
if ('D' === e)
throw new RangeError(
'Use `d` instead of `D` for formatting days of the month; see: https://git.io/fxCyr',
)
if ('DD' === e)
throw new RangeError(
'Use `dd` instead of `DD` for formatting days of the month; see: https://git.io/fxCyr',
)
}
function I(e, t) {
k(1, arguments)
var n = t || {},
r = n.locale,
a = r && r.options && r.options.weekStartsOn,
o = null == a ? 0 : D(a),
i = null == n.weekStartsOn ? o : D(n.weekStartsOn)
if (!(i >= 0 && i <= 6)) throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
var d = x(e),
s = d.getUTCDay(),
c = (s < i ? 7 : 0) + s - i
return d.setUTCDate(d.getUTCDate() - c), d.setUTCHours(0, 0, 0, 0), d
}
function z(e, t) {
k(1, arguments)
var n = x(e, t),
r = n.getUTCFullYear(),
a = t || {},
o = a.locale,
i = o && o.options && o.options.firstWeekContainsDate,
d = null == i ? 1 : D(i),
s = null == a.firstWeekContainsDate ? d : D(a.firstWeekContainsDate)
if (!(s >= 1 && s <= 7))
throw new RangeError('firstWeekContainsDate must be between 1 and 7 inclusively')
var c = new Date(0)
c.setUTCFullYear(r + 1, 0, s), c.setUTCHours(0, 0, 0, 0)
var u = I(c, t),
l = new Date(0)
l.setUTCFullYear(r, 0, s), l.setUTCHours(0, 0, 0, 0)
var p = I(l, t)
return n.getTime() >= u.getTime() ? r + 1 : n.getTime() >= p.getTime() ? r : r - 1
}
function U(e, t, n) {
k(2, arguments)
var r = n || {},
a = r.locale,
o = a && a.options && a.options.weekStartsOn,
i = null == o ? 0 : D(o),
d = null == r.weekStartsOn ? i : D(r.weekStartsOn)
if (!(d >= 0 && d <= 6)) throw new RangeError('weekStartsOn must be between 0 and 6 inclusively')
var s = x(e),
c = D(t),
u = s.getUTCDay(),
l = c % 7,
p = (l + 7) % 7,
f = (p < d ? 7 : 0) + c - u
return s.setUTCDate(s.getUTCDate() + f), s
}
function N(e) {
k(1, arguments)
var t = 1,
n = x(e),
r = n.getUTCDay(),
a = (r < t ? 7 : 0) + r - t
return n.setUTCDate(n.getUTCDate() - a), n.setUTCHours(0, 0, 0, 0), n
}
function Y(e) {
k(1, arguments)
var t = x(e),
n = t.getUTCFullYear(),
r = new Date(0)
r.setUTCFullYear(n + 1, 0, 4), r.setUTCHours(0, 0, 0, 0)
var a = N(r),
o = new Date(0)
o.setUTCFullYear(n, 0, 4), o.setUTCHours(0, 0, 0, 0)
var i = N(o)
return t.getTime() >= a.getTime() ? n + 1 : t.getTime() >= i.getTime() ? n : n - 1
}
function A(e) {
k(1, arguments)
var t = Y(e),
n = new Date(0)
n.setUTCFullYear(t, 0, 4), n.setUTCHours(0, 0, 0, 0)
var r = N(n)
return r
}
function q(e) {
k(1, arguments)
var t = x(e),
n = N(t).getTime() - A(t).getTime()
return Math.round(n / 6048e5) + 1
}
function G(e, t) {
k(1, arguments)
var n = t || {},
r = n.locale,
a = r && r.options && r.options.firstWeekContainsDate,
o = null == a ? 1 : D(a),
i = null == n.firstWeekContainsDate ? o : D(n.firstWeekContainsDate),
d = z(e, t),
s = new Date(0)
s.setUTCFullYear(d, 0, i), s.setUTCHours(0, 0, 0, 0)
var c = I(s, t)
return c
}
function j(e, t) {
k(1, arguments)
var n = x(e),
r = I(n, t).getTime() - G(n, t).getTime()
return Math.round(r / 6048e5) + 1
}
var X = /^(1[0-2]|0?\d)/,
Q = /^(3[0-1]|[0-2]?\d)/,
V = /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
Z = /^(5[0-3]|[0-4]?\d)/,
K = /^(2[0-3]|[0-1]?\d)/,
J = /^(2[0-4]|[0-1]?\d)/,
_ = /^(1[0-1]|0?\d)/,
$ = /^(1[0-2]|0?\d)/,
ee = /^[0-5]?\d/,
te = /^[0-5]?\d/,
ne = /^\d/,
re = /^\d{1,2}/,
ae = /^\d{1,3}/,
oe = /^\d{1,4}/,
ie = /^-?\d+/,
de = /^-?\d/,
se = /^-?\d{1,2}/,
ce = /^-?\d{1,3}/,
ue = /^-?\d{1,4}/,
le = /^([+-])(\d{2})(\d{2})?|Z/,
pe = /^([+-])(\d{2})(\d{2})|Z/,
fe = /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
ge = /^([+-])(\d{2}):(\d{2})|Z/,
he = /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
function me(e, t, n) {
var r = t.match(e)
if (!r) return null
var a = parseInt(r[0], 10)
return {value: n ? n(a) : a, rest: t.slice(r[0].length)}
}
function ye(e, t) {
var n = t.match(e)
return n
? 'Z' === n[0]
? {value: 0, rest: t.slice(1)}
: {
value:
('+' === n[1] ? 1 : -1) *
(36e5 * (n[2] ? parseInt(n[2], 10) : 0) +
6e4 * (n[3] ? parseInt(n[3], 10) : 0) +
1e3 * (n[5] ? parseInt(n[5], 10) : 0)),
rest: t.slice(n[0].length),
}
: null
}
function ve(e, t) {
return me(ie, e, t)
}
function be(e, t, n) {
switch (e) {
case 1:
return me(ne, t, n)
case 2:
return me(re, t, n)
case 3:
return me(ae, t, n)
case 4:
return me(oe, t, n)
default:
return me(new RegExp('^\\d{1,' + e + '}'), t, n)
}
}
function we(e, t, n) {
switch (e) {
case 1:
return me(de, t, n)
case 2:
return me(se, t, n)
case 3:
return me(ce, t, n)
case 4:
return me(ue, t, n)
default:
return me(new RegExp('^-?\\d{1,' + e + '}'), t, n)
}
}
function De(e) {
switch (e) {
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 ke(e, t) {
var n,
r = t > 0,
a = r ? t : 1 - t
if (a <= 50) n = e || 100
else {
var o = a + 50
n = e + 100 * Math.floor(o / 100) - (e >= o % 100 ? 100 : 0)
}
return r ? n : 1 - n
}
var xe = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
Ce = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
function Te(e) {
return e % 400 == 0 || (e % 4 == 0 && e % 100 != 0)
}
var Se = {
G: {
priority: 140,
parse: function (e, t, n, r) {
switch (t) {
case 'G':
case 'GG':
case 'GGG':
return n.era(e, {width: 'abbreviated'}) || n.era(e, {width: 'narrow'})
case 'GGGGG':
return n.era(e, {width: 'narrow'})
case 'GGGG':
default:
return (
n.era(e, {width: 'wide'}) ||
n.era(e, {width: 'abbreviated'}) ||
n.era(e, {width: 'narrow'})
)
}
},
set: function (e, t, n, r) {
return (t.era = n), e.setUTCFullYear(n, 0, 1), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['R', 'u', 't', 'T'],
},
y: {
priority: 130,
parse: function (e, t, n, r) {
var a = function (e) {
return {year: e, isTwoDigitYear: 'yy' === t}
}
switch (t) {
case 'y':
return be(4, e, a)
case 'yo':
return n.ordinalNumber(e, {unit: 'year', valueCallback: a})
default:
return be(t.length, e, a)
}
},
validate: function (e, t, n) {
return t.isTwoDigitYear || t.year > 0
},
set: function (e, t, n, r) {
var a = e.getUTCFullYear()
if (n.isTwoDigitYear) {
var o = ke(n.year, a)
return e.setUTCFullYear(o, 0, 1), e.setUTCHours(0, 0, 0, 0), e
}
var i = 'era' in t && 1 !== t.era ? 1 - n.year : n.year
return e.setUTCFullYear(i, 0, 1), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['Y', 'R', 'u', 'w', 'I', 'i', 'e', 'c', 't', 'T'],
},
Y: {
priority: 130,
parse: function (e, t, n, r) {
var a = function (e) {
return {year: e, isTwoDigitYear: 'YY' === t}
}
switch (t) {
case 'Y':
return be(4, e, a)
case 'Yo':
return n.ordinalNumber(e, {unit: 'year', valueCallback: a})
default:
return be(t.length, e, a)
}
},
validate: function (e, t, n) {
return t.isTwoDigitYear || t.year > 0
},
set: function (e, t, n, r) {
var a = z(e, r)
if (n.isTwoDigitYear) {
var o = ke(n.year, a)
return e.setUTCFullYear(o, 0, r.firstWeekContainsDate), e.setUTCHours(0, 0, 0, 0), I(e, r)
}
var i = 'era' in t && 1 !== t.era ? 1 - n.year : n.year
return e.setUTCFullYear(i, 0, r.firstWeekContainsDate), e.setUTCHours(0, 0, 0, 0), I(e, r)
},
incompatibleTokens: ['y', 'R', 'u', 'Q', 'q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T'],
},
R: {
priority: 130,
parse: function (e, t, n, r) {
return we('R' === t ? 4 : t.length, e)
},
set: function (e, t, n, r) {
var a = new Date(0)
return a.setUTCFullYear(n, 0, 4), a.setUTCHours(0, 0, 0, 0), N(a)
},
incompatibleTokens: [
'G',
'y',
'Y',
'u',
'Q',
'q',
'M',
'L',
'w',
'd',
'D',
'e',
'c',
't',
'T',
],
},
u: {
priority: 130,
parse: function (e, t, n, r) {
return we('u' === t ? 4 : t.length, e)
},
set: function (e, t, n, r) {
return e.setUTCFullYear(n, 0, 1), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['G', 'y', 'Y', 'R', 'w', 'I', 'i', 'e', 'c', 't', 'T'],
},
Q: {
priority: 120,
parse: function (e, t, n, r) {
switch (t) {
case 'Q':
case 'QQ':
return be(t.length, e)
case 'Qo':
return n.ordinalNumber(e, {unit: 'quarter'})
case 'QQQ':
return (
n.quarter(e, {width: 'abbreviated', context: 'formatting'}) ||
n.quarter(e, {width: 'narrow', context: 'formatting'})
)
case 'QQQQQ':
return n.quarter(e, {width: 'narrow', context: 'formatting'})
case 'QQQQ':
default:
return (
n.quarter(e, {width: 'wide', context: 'formatting'}) ||
n.quarter(e, {width: 'abbreviated', context: 'formatting'}) ||
n.quarter(e, {width: 'narrow', context: 'formatting'})
)
}
},
validate: function (e, t, n) {
return t >= 1 && t <= 4
},
set: function (e, t, n, r) {
return e.setUTCMonth(3 * (n - 1), 1), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['Y', 'R', 'q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T'],
},
q: {
priority: 120,
parse: function (e, t, n, r) {
switch (t) {
case 'q':
case 'qq':
return be(t.length, e)
case 'qo':
return n.ordinalNumber(e, {unit: 'quarter'})
case 'qqq':
return (
n.quarter(e, {width: 'abbreviated', context: 'standalone'}) ||
n.quarter(e, {width: 'narrow', context: 'standalone'})
)
case 'qqqqq':
return n.quarter(e, {width: 'narrow', context: 'standalone'})
case 'qqqq':
default:
return (
n.quarter(e, {width: 'wide', context: 'standalone'}) ||
n.quarter(e, {width: 'abbreviated', context: 'standalone'}) ||
n.quarter(e, {width: 'narrow', context: 'standalone'})
)
}
},
validate: function (e, t, n) {
return t >= 1 && t <= 4
},
set: function (e, t, n, r) {
return e.setUTCMonth(3 * (n - 1), 1), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['Y', 'R', 'Q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T'],
},
M: {
priority: 110,
parse: function (e, t, n, r) {
var a = function (e) {
return e - 1
}
switch (t) {
case 'M':
return me(X, e, a)
case 'MM':
return be(2, e, a)
case 'Mo':
return n.ordinalNumber(e, {unit: 'month', valueCallback: a})
case 'MMM':
return (
n.month(e, {width: 'abbreviated', context: 'formatting'}) ||
n.month(e, {width: 'narrow', context: 'formatting'})
)
case 'MMMMM':
return n.month(e, {width: 'narrow', context: 'formatting'})
case 'MMMM':
default:
return (
n.month(e, {width: 'wide', context: 'formatting'}) ||
n.month(e, {width: 'abbreviated', context: 'formatting'}) ||
n.month(e, {width: 'narrow', context: 'formatting'})
)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 11
},
set: function (e, t, n, r) {
return e.setUTCMonth(n, 1), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['Y', 'R', 'q', 'Q', 'L', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'],
},
L: {
priority: 110,
parse: function (e, t, n, r) {
var a = function (e) {
return e - 1
}
switch (t) {
case 'L':
return me(X, e, a)
case 'LL':
return be(2, e, a)
case 'Lo':
return n.ordinalNumber(e, {unit: 'month', valueCallback: a})
case 'LLL':
return (
n.month(e, {width: 'abbreviated', context: 'standalone'}) ||
n.month(e, {width: 'narrow', context: 'standalone'})
)
case 'LLLLL':
return n.month(e, {width: 'narrow', context: 'standalone'})
case 'LLLL':
default:
return (
n.month(e, {width: 'wide', context: 'standalone'}) ||
n.month(e, {width: 'abbreviated', context: 'standalone'}) ||
n.month(e, {width: 'narrow', context: 'standalone'})
)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 11
},
set: function (e, t, n, r) {
return e.setUTCMonth(n, 1), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['Y', 'R', 'q', 'Q', 'M', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'],
},
w: {
priority: 100,
parse: function (e, t, n, r) {
switch (t) {
case 'w':
return me(Z, e)
case 'wo':
return n.ordinalNumber(e, {unit: 'week'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 1 && t <= 53
},
set: function (e, t, n, r) {
return I(
(function (e, t, n) {
k(2, arguments)
var r = x(e),
a = D(t),
o = j(r, n) - a
return r.setUTCDate(r.getUTCDate() - 7 * o), r
})(e, n, r),
r,
)
},
incompatibleTokens: ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T'],
},
I: {
priority: 100,
parse: function (e, t, n, r) {
switch (t) {
case 'I':
return me(Z, e)
case 'Io':
return n.ordinalNumber(e, {unit: 'week'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 1 && t <= 53
},
set: function (e, t, n, r) {
return N(
(function (e, t) {
k(2, arguments)
var n = x(e),
r = D(t),
a = q(n) - r
return n.setUTCDate(n.getUTCDate() - 7 * a), n
})(e, n, r),
r,
)
},
incompatibleTokens: ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'e', 'c', 't', 'T'],
},
d: {
priority: 90,
parse: function (e, t, n, r) {
switch (t) {
case 'd':
return me(Q, e)
case 'do':
return n.ordinalNumber(e, {unit: 'date'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
var r = Te(e.getUTCFullYear()),
a = e.getUTCMonth()
return r ? t >= 1 && t <= Ce[a] : t >= 1 && t <= xe[a]
},
set: function (e, t, n, r) {
return e.setUTCDate(n), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['Y', 'R', 'q', 'Q', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'],
},
D: {
priority: 90,
parse: function (e, t, n, r) {
switch (t) {
case 'D':
case 'DD':
return me(V, e)
case 'Do':
return n.ordinalNumber(e, {unit: 'date'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return Te(e.getUTCFullYear()) ? t >= 1 && t <= 366 : t >= 1 && t <= 365
},
set: function (e, t, n, r) {
return e.setUTCMonth(0, n), e.setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: [
'Y',
'R',
'q',
'Q',
'M',
'L',
'w',
'I',
'd',
'E',
'i',
'e',
'c',
't',
'T',
],
},
E: {
priority: 90,
parse: function (e, t, n, r) {
switch (t) {
case 'E':
case 'EE':
case 'EEE':
return (
n.day(e, {width: 'abbreviated', context: 'formatting'}) ||
n.day(e, {width: 'short', context: 'formatting'}) ||
n.day(e, {width: 'narrow', context: 'formatting'})
)
case 'EEEEE':
return n.day(e, {width: 'narrow', context: 'formatting'})
case 'EEEEEE':
return (
n.day(e, {width: 'short', context: 'formatting'}) ||
n.day(e, {width: 'narrow', context: 'formatting'})
)
case 'EEEE':
default:
return (
n.day(e, {width: 'wide', context: 'formatting'}) ||
n.day(e, {width: 'abbreviated', context: 'formatting'}) ||
n.day(e, {width: 'short', context: 'formatting'}) ||
n.day(e, {width: 'narrow', context: 'formatting'})
)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 6
},
set: function (e, t, n, r) {
return (e = U(e, n, r)).setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: ['D', 'i', 'e', 'c', 't', 'T'],
},
e: {
priority: 90,
parse: function (e, t, n, r) {
var a = function (e) {
var t = 7 * Math.floor((e - 1) / 7)
return ((e + r.weekStartsOn + 6) % 7) + t
}
switch (t) {
case 'e':
case 'ee':
return be(t.length, e, a)
case 'eo':
return n.ordinalNumber(e, {unit: 'day', valueCallback: a})
case 'eee':
return (
n.day(e, {width: 'abbreviated', context: 'formatting'}) ||
n.day(e, {width: 'short', context: 'formatting'}) ||
n.day(e, {width: 'narrow', context: 'formatting'})
)
case 'eeeee':
return n.day(e, {width: 'narrow', context: 'formatting'})
case 'eeeeee':
return (
n.day(e, {width: 'short', context: 'formatting'}) ||
n.day(e, {width: 'narrow', context: 'formatting'})
)
case 'eeee':
default:
return (
n.day(e, {width: 'wide', context: 'formatting'}) ||
n.day(e, {width: 'abbreviated', context: 'formatting'}) ||
n.day(e, {width: 'short', context: 'formatting'}) ||
n.day(e, {width: 'narrow', context: 'formatting'})
)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 6
},
set: function (e, t, n, r) {
return (e = U(e, n, r)).setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: [
'y',
'R',
'u',
'q',
'Q',
'M',
'L',
'I',
'd',
'D',
'E',
'i',
'c',
't',
'T',
],
},
c: {
priority: 90,
parse: function (e, t, n, r) {
var a = function (e) {
var t = 7 * Math.floor((e - 1) / 7)
return ((e + r.weekStartsOn + 6) % 7) + t
}
switch (t) {
case 'c':
case 'cc':
return be(t.length, e, a)
case 'co':
return n.ordinalNumber(e, {unit: 'day', valueCallback: a})
case 'ccc':
return (
n.day(e, {width: 'abbreviated', context: 'standalone'}) ||
n.day(e, {width: 'short', context: 'standalone'}) ||
n.day(e, {width: 'narrow', context: 'standalone'})
)
case 'ccccc':
return n.day(e, {width: 'narrow', context: 'standalone'})
case 'cccccc':
return (
n.day(e, {width: 'short', context: 'standalone'}) ||
n.day(e, {width: 'narrow', context: 'standalone'})
)
case 'cccc':
default:
return (
n.day(e, {width: 'wide', context: 'standalone'}) ||
n.day(e, {width: 'abbreviated', context: 'standalone'}) ||
n.day(e, {width: 'short', context: 'standalone'}) ||
n.day(e, {width: 'narrow', context: 'standalone'})
)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 6
},
set: function (e, t, n, r) {
return (e = U(e, n, r)).setUTCHours(0, 0, 0, 0), e
},
incompatibleTokens: [
'y',
'R',
'u',
'q',
'Q',
'M',
'L',
'I',
'd',
'D',
'E',
'i',
'e',
't',
'T',
],
},
i: {
priority: 90,
parse: function (e, t, n, r) {
var a = function (e) {
return 0 === e ? 7 : e
}
switch (t) {
case 'i':
case 'ii':
return be(t.length, e)
case 'io':
return n.ordinalNumber(e, {unit: 'day'})
case 'iii':
return (
n.day(e, {width: 'abbreviated', context: 'formatting', valueCallback: a}) ||
n.day(e, {width: 'short', context: 'formatting', valueCallback: a}) ||
n.day(e, {width: 'narrow', context: 'formatting', valueCallback: a})
)
case 'iiiii':
return n.day(e, {width: 'narrow', context: 'formatting', valueCallback: a})
case 'iiiiii':
return (
n.day(e, {width: 'short', context: 'formatting', valueCallback: a}) ||
n.day(e, {width: 'narrow', context: 'formatting', valueCallback: a})
)
case 'iiii':
default:
return (
n.day(e, {width: 'wide', context: 'formatting', valueCallback: a}) ||
n.day(e, {width: 'abbreviated', context: 'formatting', valueCallback: a}) ||
n.day(e, {width: 'short', context: 'formatting', valueCallback: a}) ||
n.day(e, {width: 'narrow', context: 'formatting', valueCallback: a})
)
}
},
validate: function (e, t, n) {
return t >= 1 && t <= 7
},
set: function (e, t, n, r) {
return (
(e = (function (e, t) {
k(2, arguments)
var n = D(t)
n % 7 == 0 && (n -= 7)
var r = 1,
a = x(e),
o = a.getUTCDay(),
i = n % 7,
d = (i + 7) % 7,
s = (d < r ? 7 : 0) + n - o
return a.setUTCDate(a.getUTCDate() + s), a
})(e, n, r)).setUTCHours(0, 0, 0, 0),
e
)
},
incompatibleTokens: [
'y',
'Y',
'u',
'q',
'Q',
'M',
'L',
'w',
'd',
'D',
'E',
'e',
'c',
't',
'T',
],
},
a: {
priority: 80,
parse: function (e, t, n, r) {
switch (t) {
case 'a':
case 'aa':
case 'aaa':
return (
n.dayPeriod(e, {width: 'abbreviated', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
)
case 'aaaaa':
return n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
case 'aaaa':
default:
return (
n.dayPeriod(e, {width: 'wide', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'abbreviated', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
)
}
},
set: function (e, t, n, r) {
return e.setUTCHours(De(n), 0, 0, 0), e
},
incompatibleTokens: ['b', 'B', 'H', 'K', 'k', 't', 'T'],
},
b: {
priority: 80,
parse: function (e, t, n, r) {
switch (t) {
case 'b':
case 'bb':
case 'bbb':
return (
n.dayPeriod(e, {width: 'abbreviated', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
)
case 'bbbbb':
return n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
case 'bbbb':
default:
return (
n.dayPeriod(e, {width: 'wide', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'abbreviated', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
)
}
},
set: function (e, t, n, r) {
return e.setUTCHours(De(n), 0, 0, 0), e
},
incompatibleTokens: ['a', 'B', 'H', 'K', 'k', 't', 'T'],
},
B: {
priority: 80,
parse: function (e, t, n, r) {
switch (t) {
case 'B':
case 'BB':
case 'BBB':
return (
n.dayPeriod(e, {width: 'abbreviated', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
)
case 'BBBBB':
return n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
case 'BBBB':
default:
return (
n.dayPeriod(e, {width: 'wide', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'abbreviated', context: 'formatting'}) ||
n.dayPeriod(e, {width: 'narrow', context: 'formatting'})
)
}
},
set: function (e, t, n, r) {
return e.setUTCHours(De(n), 0, 0, 0), e
},
incompatibleTokens: ['a', 'b', 't', 'T'],
},
h: {
priority: 70,
parse: function (e, t, n, r) {
switch (t) {
case 'h':
return me($, e)
case 'ho':
return n.ordinalNumber(e, {unit: 'hour'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 1 && t <= 12
},
set: function (e, t, n, r) {
var a = e.getUTCHours() >= 12
return (
a && n < 12
? e.setUTCHours(n + 12, 0, 0, 0)
: a || 12 !== n
? e.setUTCHours(n, 0, 0, 0)
: e.setUTCHours(0, 0, 0, 0),
e
)
},
incompatibleTokens: ['H', 'K', 'k', 't', 'T'],
},
H: {
priority: 70,
parse: function (e, t, n, r) {
switch (t) {
case 'H':
return me(K, e)
case 'Ho':
return n.ordinalNumber(e, {unit: 'hour'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 23
},
set: function (e, t, n, r) {
return e.setUTCHours(n, 0, 0, 0), e
},
incompatibleTokens: ['a', 'b', 'h', 'K', 'k', 't', 'T'],
},
K: {
priority: 70,
parse: function (e, t, n, r) {
switch (t) {
case 'K':
return me(_, e)
case 'Ko':
return n.ordinalNumber(e, {unit: 'hour'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 11
},
set: function (e, t, n, r) {
return (
e.getUTCHours() >= 12 && n < 12
? e.setUTCHours(n + 12, 0, 0, 0)
: e.setUTCHours(n, 0, 0, 0),
e
)
},
incompatibleTokens: ['a', 'b', 'h', 'H', 'k', 't', 'T'],
},
k: {
priority: 70,
parse: function (e, t, n, r) {
switch (t) {
case 'k':
return me(J, e)
case 'ko':
return n.ordinalNumber(e, {unit: 'hour'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 1 && t <= 24
},
set: function (e, t, n, r) {
var a = n <= 24 ? n % 24 : n
return e.setUTCHours(a, 0, 0, 0), e
},
incompatibleTokens: ['a', 'b', 'h', 'H', 'K', 't', 'T'],
},
m: {
priority: 60,
parse: function (e, t, n, r) {
switch (t) {
case 'm':
return me(ee, e)
case 'mo':
return n.ordinalNumber(e, {unit: 'minute'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 59
},
set: function (e, t, n, r) {
return e.setUTCMinutes(n, 0, 0), e
},
incompatibleTokens: ['t', 'T'],
},
s: {
priority: 50,
parse: function (e, t, n, r) {
switch (t) {
case 's':
return me(te, e)
case 'so':
return n.ordinalNumber(e, {unit: 'second'})
default:
return be(t.length, e)
}
},
validate: function (e, t, n) {
return t >= 0 && t <= 59
},
set: function (e, t, n, r) {
return e.setUTCSeconds(n, 0), e
},
incompatibleTokens: ['t', 'T'],
},
S: {
priority: 30,
parse: function (e, t, n, r) {
return be(t.length, e, function (e) {
return Math.floor(e * Math.pow(10, 3 - t.length))
})
},
set: function (e, t, n, r) {
return e.setUTCMilliseconds(n), e
},
incompatibleTokens: ['t', 'T'],
},
X: {
priority: 10,
parse: function (e, t, n, r) {
switch (t) {
case 'X':
return ye(le, e)
case 'XX':
return ye(pe, e)
case 'XXXX':
return ye(fe, e)
case 'XXXXX':
return ye(he, e)
case 'XXX':
default:
return ye(ge, e)
}
},
set: function (e, t, n, r) {
return t.timestampIsSet ? e : new Date(e.getTime() - n)
},
incompatibleTokens: ['t', 'T', 'x'],
},
x: {
priority: 10,
parse: function (e, t, n, r) {
switch (t) {
case 'x':
return ye(le, e)
case 'xx':
return ye(pe, e)
case 'xxxx':
return ye(fe, e)
case 'xxxxx':
return ye(he, e)
case 'xxx':
default:
return ye(ge, e)
}
},
set: function (e, t, n, r) {
return t.timestampIsSet ? e : new Date(e.getTime() - n)
},
incompatibleTokens: ['t', 'T', 'X'],
},
t: {
priority: 40,
parse: function (e, t, n, r) {
return ve(e)
},
set: function (e, t, n, r) {
return [new Date(1e3 * n), {timestampIsSet: !0}]
},
incompatibleTokens: '*',
},
T: {
priority: 20,
parse: function (e, t, n, r) {
return ve(e)
},
set: function (e, t, n, r) {
return [new Date(n), {timestampIsSet: !0}]
},
incompatibleTokens: '*',
},
},
Be = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g,
Me = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g,
Le = /^'([^]*?)'?$/,
We = /''/g,
Re = /\S/,
Ee = /[a-zA-Z]/
function Fe(e, t) {
if (t.timestampIsSet) return e
var n = new Date(0)
return (
n.setFullYear(e.getUTCFullYear(), e.getUTCMonth(), e.getUTCDate()),
n.setHours(e.getUTCHours(), e.getUTCMinutes(), e.getUTCSeconds(), e.getUTCMilliseconds()),
n
)
}
function He(e) {
return e.match(Le)[1].replace(We, "'")
}
function Pe(e) {
k(1, arguments)
var t = x(e)
return !isNaN(t)
}
function Oe(e, t) {
for (var n = e < 0 ? '-' : '', r = Math.abs(e).toString(); r.length < t; ) r = '0' + r
return n + r
}
var Ie = {
G: function (e, t, n) {
var r = e.getUTCFullYear() > 0 ? 1 : 0
switch (t) {
case 'G':
case 'GG':
case 'GGG':
return n.era(r, {width: 'abbreviated'})
case 'GGGGG':
return n.era(r, {width: 'narrow'})
case 'GGGG':
default:
return n.era(r, {width: 'wide'})
}
},
y: function (e, t, n) {
if ('yo' === t) {
var r = e.getUTCFullYear(),
a = r > 0 ? r : 1 - r
return n.ordinalNumber(a, {unit: 'year'})
}
return (function (e, t) {
var n = e.getUTCFullYear(),
r = n > 0 ? n : 1 - n
return Oe('yy' === t ? r % 100 : r, t.length)
})(e, t)
},
Y: function (e, t, n, r) {
var a = z(e, r),
o = a > 0 ? a : 1 - a
return 'YY' === t
? Oe(o % 100, 2)
: 'Yo' === t
? n.ordinalNumber(o, {unit: 'year'})
: Oe(o, t.length)
},
R: function (e, t) {
return Oe(Y(e), t.length)
},
u: function (e, t) {
return Oe(e.getUTCFullYear(), t.length)
},
Q: function (e, t, n) {
var r = Math.ceil((e.getUTCMonth() + 1) / 3)
switch (t) {
case 'Q':
return String(r)
case 'QQ':
return Oe(r, 2)
case 'Qo':
return n.ordinalNumber(r, {unit: 'quarter'})
case 'QQQ':
return n.quarter(r, {width: 'abbreviated', context: 'formatting'})
case 'QQQQQ':
return n.quarter(r, {width: 'narrow', context: 'formatting'})
case 'QQQQ':
default:
return n.quarter(r, {width: 'wide', context: 'formatting'})
}
},
q: function (e, t, n) {
var r = Math.ceil((e.getUTCMonth() + 1) / 3)
switch (t) {
case 'q':
return String(r)
case 'qq':
return Oe(r, 2)
case 'qo':
return n.ordinalNumber(r, {unit: 'quarter'})
case 'qqq':
return n.quarter(r, {width: 'abbreviated', context: 'standalone'})
case 'qqqqq':
return n.quarter(r, {width: 'narrow', context: 'standalone'})
case 'qqqq':
default:
return n.quarter(r, {width: 'wide', context: 'standalone'})
}
},
M: function (e, t, n) {
var r = e.getUTCMonth()
switch (t) {
case 'M':
case 'MM':
return (function (e, t) {
var n = e.getUTCMonth()
return 'M' === t ? String(n + 1) : Oe(n + 1, 2)
})(e, t)
case 'Mo':
return n.ordinalNumber(r + 1, {unit: 'month'})
case 'MMM':
return n.month(r, {width: 'abbreviated', context: 'formatting'})
case 'MMMMM':
return n.month(r, {width: 'narrow', context: 'formatting'})
case 'MMMM':
default:
return n.month(r, {width: 'wide', context: 'formatting'})
}
},
L: function (e, t, n) {
var r = e.getUTCMonth()
switch (t) {
case 'L':
return String(r + 1)
case 'LL':
return Oe(r + 1, 2)
case 'Lo':
return n.ordinalNumber(r + 1, {unit: 'month'})