3012 lines
102 KiB
JavaScript
3012 lines
102 KiB
JavaScript
(window.webpackJsonp = window.webpackJsonp || []).push([
|
||
[34],
|
||
{
|
||
'0tRk': function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
e.defineLocale('pt-br', {
|
||
months: 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split(
|
||
'_',
|
||
),
|
||
monthsShort: 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split(
|
||
'_',
|
||
),
|
||
weekdays: 'Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
|
||
weekdaysMin: 'Dom_2ª_3ª_4ª_5ª_6ª_Sáb'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'DD/MM/YYYY',
|
||
LL: 'D [de] MMMM [de] YYYY',
|
||
LLL: 'D [de] MMMM [de] YYYY [às] HH:mm',
|
||
LLLL: 'dddd, D [de] MMMM [de] YYYY [às] HH:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: '[Hoje às] LT',
|
||
nextDay: '[Amanhã às] LT',
|
||
nextWeek: 'dddd [às] LT',
|
||
lastDay: '[Ontem às] LT',
|
||
lastWeek: function () {
|
||
return 0 === this.day() || 6 === this.day()
|
||
? '[Último] dddd [às] LT'
|
||
: '[Última] dddd [às] LT';
|
||
},
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: 'em %s',
|
||
past: '%s atrás',
|
||
s: 'poucos segundos',
|
||
m: 'um minuto',
|
||
mm: '%d minutos',
|
||
h: 'uma hora',
|
||
hh: '%d horas',
|
||
d: 'um dia',
|
||
dd: '%d dias',
|
||
M: 'um mês',
|
||
MM: '%d meses',
|
||
y: 'um ano',
|
||
yy: '%d anos',
|
||
},
|
||
ordinalParse: /\d{1,2}º/,
|
||
ordinal: '%dº',
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
'8mBD': function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
e.defineLocale('pt', {
|
||
months: 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split(
|
||
'_',
|
||
),
|
||
monthsShort: 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split(
|
||
'_',
|
||
),
|
||
weekdays: 'Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
|
||
weekdaysMin: 'Dom_2ª_3ª_4ª_5ª_6ª_Sáb'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'DD/MM/YYYY',
|
||
LL: 'D [de] MMMM [de] YYYY',
|
||
LLL: 'D [de] MMMM [de] YYYY HH:mm',
|
||
LLLL: 'dddd, D [de] MMMM [de] YYYY HH:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: '[Hoje às] LT',
|
||
nextDay: '[Amanhã às] LT',
|
||
nextWeek: 'dddd [às] LT',
|
||
lastDay: '[Ontem às] LT',
|
||
lastWeek: function () {
|
||
return 0 === this.day() || 6 === this.day()
|
||
? '[Último] dddd [às] LT'
|
||
: '[Última] dddd [às] LT';
|
||
},
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: 'em %s',
|
||
past: 'há %s',
|
||
s: 'segundos',
|
||
m: 'um minuto',
|
||
mm: '%d minutos',
|
||
h: 'uma hora',
|
||
hh: '%d horas',
|
||
d: 'um dia',
|
||
dd: '%d dias',
|
||
M: 'um mês',
|
||
MM: '%d meses',
|
||
y: 'um ano',
|
||
yy: '%d anos',
|
||
},
|
||
ordinalParse: /\d{1,2}º/,
|
||
ordinal: '%dº',
|
||
week: { dow: 1, doy: 4 },
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
B55N: function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
e.defineLocale('ja', {
|
||
months: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
|
||
'_',
|
||
),
|
||
monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
|
||
'_',
|
||
),
|
||
weekdays: '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: '日_月_火_水_木_金_土'.split('_'),
|
||
weekdaysMin: '日_月_火_水_木_金_土'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'Ah時m分',
|
||
LTS: 'Ah時m分s秒',
|
||
L: 'YYYY/MM/DD',
|
||
LL: 'YYYY年M月D日',
|
||
LLL: 'YYYY年M月D日Ah時m分',
|
||
LLLL: 'YYYY年M月D日Ah時m分 dddd',
|
||
},
|
||
meridiemParse: /午前|午後/i,
|
||
isPM: function (e) {
|
||
return '午後' === e;
|
||
},
|
||
meridiem: function (e, t, n) {
|
||
return e < 12 ? '午前' : '午後';
|
||
},
|
||
calendar: {
|
||
sameDay: '[今日] LT',
|
||
nextDay: '[明日] LT',
|
||
nextWeek: '[来週]dddd LT',
|
||
lastDay: '[昨日] LT',
|
||
lastWeek: '[前週]dddd LT',
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: '%s後',
|
||
past: '%s前',
|
||
s: '数秒',
|
||
m: '1分',
|
||
mm: '%d分',
|
||
h: '1時間',
|
||
hh: '%d時間',
|
||
d: '1日',
|
||
dd: '%d日',
|
||
M: '1ヶ月',
|
||
MM: '%dヶ月',
|
||
y: '1年',
|
||
yy: '%d年',
|
||
},
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
DoHr: function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
var t = {
|
||
1: "'inci",
|
||
5: "'inci",
|
||
8: "'inci",
|
||
70: "'inci",
|
||
80: "'inci",
|
||
2: "'nci",
|
||
7: "'nci",
|
||
20: "'nci",
|
||
50: "'nci",
|
||
3: "'üncü",
|
||
4: "'üncü",
|
||
100: "'üncü",
|
||
6: "'ncı",
|
||
9: "'uncu",
|
||
10: "'uncu",
|
||
30: "'uncu",
|
||
60: "'ıncı",
|
||
90: "'ıncı",
|
||
};
|
||
e.defineLocale('tr', {
|
||
months: 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split(
|
||
'_',
|
||
),
|
||
monthsShort: 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split(
|
||
'_',
|
||
),
|
||
weekdays: 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
|
||
weekdaysMin: 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'DD.MM.YYYY',
|
||
LL: 'D MMMM YYYY',
|
||
LLL: 'D MMMM YYYY HH:mm',
|
||
LLLL: 'dddd, D MMMM YYYY HH:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: '[bugün saat] LT',
|
||
nextDay: '[yarın saat] LT',
|
||
nextWeek: '[haftaya] dddd [saat] LT',
|
||
lastDay: '[dün] LT',
|
||
lastWeek: '[geçen hafta] dddd [saat] LT',
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: '%s sonra',
|
||
past: '%s önce',
|
||
s: 'birkaç saniye',
|
||
m: 'bir dakika',
|
||
mm: '%d dakika',
|
||
h: 'bir saat',
|
||
hh: '%d saat',
|
||
d: 'bir gün',
|
||
dd: '%d gün',
|
||
M: 'bir ay',
|
||
MM: '%d ay',
|
||
y: 'bir yıl',
|
||
yy: '%d yıl',
|
||
},
|
||
ordinalParse: /\d{1,2}'(inci|nci|üncü|ncı|uncu|ıncı)/,
|
||
ordinal: function (e) {
|
||
if (0 === e) return e + "'ıncı";
|
||
var n = e % 10;
|
||
return e + (t[n] || t[(e % 100) - n] || t[e >= 100 ? 100 : null]);
|
||
},
|
||
week: { dow: 1, doy: 7 },
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
'Ivi+': function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
e.defineLocale('ko', {
|
||
months: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split(
|
||
'_',
|
||
),
|
||
monthsShort: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split(
|
||
'_',
|
||
),
|
||
weekdays: '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: '일_월_화_수_목_금_토'.split('_'),
|
||
weekdaysMin: '일_월_화_수_목_금_토'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'A h시 m분',
|
||
LTS: 'A h시 m분 s초',
|
||
L: 'YYYY.MM.DD',
|
||
LL: 'YYYY년 MMMM D일',
|
||
LLL: 'YYYY년 MMMM D일 A h시 m분',
|
||
LLLL: 'YYYY년 MMMM D일 dddd A h시 m분',
|
||
},
|
||
calendar: {
|
||
sameDay: '오늘 LT',
|
||
nextDay: '내일 LT',
|
||
nextWeek: 'dddd LT',
|
||
lastDay: '어제 LT',
|
||
lastWeek: '지난주 dddd LT',
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: '%s 후',
|
||
past: '%s 전',
|
||
s: '몇초',
|
||
ss: '%d초',
|
||
m: '일분',
|
||
mm: '%d분',
|
||
h: '한시간',
|
||
hh: '%d시간',
|
||
d: '하루',
|
||
dd: '%d일',
|
||
M: '한달',
|
||
MM: '%d달',
|
||
y: '일년',
|
||
yy: '%d년',
|
||
},
|
||
ordinalParse: /\d{1,2}일/,
|
||
ordinal: '%d일',
|
||
meridiemParse: /오전|오후/,
|
||
isPM: function (e) {
|
||
return '오후' === e;
|
||
},
|
||
meridiem: function (e, t, n) {
|
||
return e < 12 ? '오전' : '오후';
|
||
},
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
Oaa7: function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
e.defineLocale('en-gb', {
|
||
months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
|
||
'_',
|
||
),
|
||
monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split(
|
||
'_',
|
||
),
|
||
weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
|
||
weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'DD/MM/YYYY',
|
||
LL: 'D MMMM YYYY',
|
||
LLL: 'D MMMM YYYY HH:mm',
|
||
LLLL: 'dddd, D MMMM YYYY HH:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: '[Today at] LT',
|
||
nextDay: '[Tomorrow at] LT',
|
||
nextWeek: 'dddd [at] LT',
|
||
lastDay: '[Yesterday at] LT',
|
||
lastWeek: '[Last] dddd [at] LT',
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: 'in %s',
|
||
past: '%s ago',
|
||
s: 'a few seconds',
|
||
m: 'a minute',
|
||
mm: '%d minutes',
|
||
h: 'an hour',
|
||
hh: '%d hours',
|
||
d: 'a day',
|
||
dd: '%d days',
|
||
M: 'a month',
|
||
MM: '%d months',
|
||
y: 'a year',
|
||
yy: '%d years',
|
||
},
|
||
ordinalParse: /\d{1,2}(st|nd|rd|th)/,
|
||
ordinal: function (e) {
|
||
var t = e % 10;
|
||
return (
|
||
e +
|
||
(1 == ~~((e % 100) / 10)
|
||
? 'th'
|
||
: 1 === t
|
||
? 'st'
|
||
: 2 === t
|
||
? 'nd'
|
||
: 3 === t
|
||
? 'rd'
|
||
: 'th')
|
||
);
|
||
},
|
||
week: { dow: 1, doy: 4 },
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
bpih: function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
e.defineLocale('it', {
|
||
months: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split(
|
||
'_',
|
||
),
|
||
monthsShort: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split(
|
||
'_',
|
||
),
|
||
weekdays: 'Domenica_Lunedì_Martedì_Mercoledì_Giovedì_Venerdì_Sabato'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: 'Dom_Lun_Mar_Mer_Gio_Ven_Sab'.split('_'),
|
||
weekdaysMin: 'D_L_Ma_Me_G_V_S'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'DD/MM/YYYY',
|
||
LL: 'D MMMM YYYY',
|
||
LLL: 'D MMMM YYYY HH:mm',
|
||
LLLL: 'dddd, D MMMM YYYY HH:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: '[Oggi alle] LT',
|
||
nextDay: '[Domani alle] LT',
|
||
nextWeek: 'dddd [alle] LT',
|
||
lastDay: '[Ieri alle] LT',
|
||
lastWeek: function () {
|
||
switch (this.day()) {
|
||
case 0:
|
||
return '[la scorsa] dddd [alle] LT';
|
||
default:
|
||
return '[lo scorso] dddd [alle] LT';
|
||
}
|
||
},
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: function (e) {
|
||
return (/^[0-9].+$/.test(e) ? 'tra' : 'in') + ' ' + e;
|
||
},
|
||
past: '%s fa',
|
||
s: 'alcuni secondi',
|
||
m: 'un minuto',
|
||
mm: '%d minuti',
|
||
h: "un'ora",
|
||
hh: '%d ore',
|
||
d: 'un giorno',
|
||
dd: '%d giorni',
|
||
M: 'un mese',
|
||
MM: '%d mesi',
|
||
y: 'un anno',
|
||
yy: '%d anni',
|
||
},
|
||
ordinalParse: /\d{1,2}º/,
|
||
ordinal: '%dº',
|
||
week: { dow: 1, doy: 4 },
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
iYuL: function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
var t = 'Ene._Feb._Mar._Abr._May._Jun._Jul._Ago._Sep._Oct._Nov._Dic.'.split(
|
||
'_',
|
||
),
|
||
n = 'Ene_Feb_Mar_Abr_May_Jun_Jul_Ago_Sep_Oct_Nov_Dic'.split('_');
|
||
e.defineLocale('es', {
|
||
months: 'Enero_Febrero_Marzo_Abril_Mayo_Junio_Julio_Agosto_Septiembre_Octubre_Noviembre_Diciembre'.split(
|
||
'_',
|
||
),
|
||
monthsShort: function (e, i) {
|
||
return /-MMM-/.test(i) ? n[e.month()] : t[e.month()];
|
||
},
|
||
weekdays: 'Domingo_Lunes_Martes_Miércoles_Jueves_Viernes_Sábado'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: 'Dom._Lun._Mar._Mié._Jue._Vie._Sáb.'.split('_'),
|
||
weekdaysMin: 'Do_Lu_Ma_Mi_Ju_Vi_Sá'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'H:mm',
|
||
LTS: 'H:mm:ss',
|
||
L: 'DD/MM/YYYY',
|
||
LL: 'D [de] MMMM [de] YYYY',
|
||
LLL: 'D [de] MMMM [de] YYYY H:mm',
|
||
LLLL: 'dddd, D [de] MMMM [de] YYYY H:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: function () {
|
||
return '[hoy a la' + (1 !== this.hours() ? 's' : '') + '] LT';
|
||
},
|
||
nextDay: function () {
|
||
return '[mañana a la' + (1 !== this.hours() ? 's' : '') + '] LT';
|
||
},
|
||
nextWeek: function () {
|
||
return 'dddd [a la' + (1 !== this.hours() ? 's' : '') + '] LT';
|
||
},
|
||
lastDay: function () {
|
||
return '[ayer a la' + (1 !== this.hours() ? 's' : '') + '] LT';
|
||
},
|
||
lastWeek: function () {
|
||
return (
|
||
'[el] dddd [pasado a la' +
|
||
(1 !== this.hours() ? 's' : '') +
|
||
'] LT'
|
||
);
|
||
},
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: 'en %s',
|
||
past: 'hace %s',
|
||
s: 'unos segundos',
|
||
m: 'un minuto',
|
||
mm: '%d minutos',
|
||
h: 'una hora',
|
||
hh: '%d horas',
|
||
d: 'un día',
|
||
dd: '%d días',
|
||
M: 'un mes',
|
||
MM: '%d meses',
|
||
y: 'un año',
|
||
yy: '%d años',
|
||
},
|
||
ordinalParse: /\d{1,2}º/,
|
||
ordinal: '%dº',
|
||
week: { dow: 1, doy: 4 },
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
jVdC: function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
var t = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split(
|
||
'_',
|
||
),
|
||
n = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split(
|
||
'_',
|
||
);
|
||
function i(e) {
|
||
return e % 10 < 5 && e % 10 > 1 && ~~(e / 10) % 10 != 1;
|
||
}
|
||
function a(e, t, n) {
|
||
var a = e + ' ';
|
||
switch (n) {
|
||
case 'm':
|
||
return t ? 'minuta' : 'minutę';
|
||
case 'mm':
|
||
return a + (i(e) ? 'minuty' : 'minut');
|
||
case 'h':
|
||
return t ? 'godzina' : 'godzinę';
|
||
case 'hh':
|
||
return a + (i(e) ? 'godziny' : 'godzin');
|
||
case 'MM':
|
||
return a + (i(e) ? 'miesiące' : 'miesięcy');
|
||
case 'yy':
|
||
return a + (i(e) ? 'lata' : 'lat');
|
||
}
|
||
}
|
||
e.defineLocale('pl', {
|
||
months: function (e, i) {
|
||
return '' === i
|
||
? '(' + n[e.month()] + '|' + t[e.month()] + ')'
|
||
: /D MMMM/.test(i)
|
||
? n[e.month()]
|
||
: t[e.month()];
|
||
},
|
||
monthsShort: 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split(
|
||
'_',
|
||
),
|
||
weekdays: 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split(
|
||
'_',
|
||
),
|
||
weekdaysShort: 'nie_pon_wt_śr_czw_pt_sb'.split('_'),
|
||
weekdaysMin: 'N_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'DD.MM.YYYY',
|
||
LL: 'D MMMM YYYY',
|
||
LLL: 'D MMMM YYYY HH:mm',
|
||
LLLL: 'dddd, D MMMM YYYY HH:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: '[Dziś o] LT',
|
||
nextDay: '[Jutro o] LT',
|
||
nextWeek: '[W] dddd [o] LT',
|
||
lastDay: '[Wczoraj o] LT',
|
||
lastWeek: function () {
|
||
switch (this.day()) {
|
||
case 0:
|
||
return '[W zeszłą niedzielę o] LT';
|
||
case 3:
|
||
return '[W zeszłą środę o] LT';
|
||
case 6:
|
||
return '[W zeszłą sobotę o] LT';
|
||
default:
|
||
return '[W zeszły] dddd [o] LT';
|
||
}
|
||
},
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: 'za %s',
|
||
past: '%s temu',
|
||
s: 'kilka sekund',
|
||
m: a,
|
||
mm: a,
|
||
h: a,
|
||
hh: a,
|
||
d: '1 dzień',
|
||
dd: '%d dni',
|
||
M: 'miesiąc',
|
||
MM: a,
|
||
y: 'rok',
|
||
yy: a,
|
||
},
|
||
ordinalParse: /\d{1,2}\./,
|
||
ordinal: '%d.',
|
||
week: { dow: 1, doy: 4 },
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
lXzo: function (e, t, n) {
|
||
!(function (e) {
|
||
'use strict';
|
||
function t(e, t, n) {
|
||
var i, a;
|
||
return 'm' === n
|
||
? t
|
||
? 'минута'
|
||
: 'минуту'
|
||
: e +
|
||
' ' +
|
||
((i = +e),
|
||
(a = {
|
||
mm: t ? 'минута_минуты_минут' : 'минуту_минуты_минут',
|
||
hh: 'час_часа_часов',
|
||
dd: 'день_дня_дней',
|
||
MM: 'месяц_месяца_месяцев',
|
||
yy: 'год_года_лет',
|
||
}[n].split('_')),
|
||
i % 10 == 1 && i % 100 != 11
|
||
? a[0]
|
||
: i % 10 >= 2 &&
|
||
i % 10 <= 4 &&
|
||
(i % 100 < 10 || i % 100 >= 20)
|
||
? a[1]
|
||
: a[2]);
|
||
}
|
||
e.defineLocale('ru', {
|
||
months: function (e, t) {
|
||
return {
|
||
nominative: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split(
|
||
'_',
|
||
),
|
||
accusative: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split(
|
||
'_',
|
||
),
|
||
}[
|
||
/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/.test(t)
|
||
? 'accusative'
|
||
: 'nominative'
|
||
][e.month()];
|
||
},
|
||
monthsShort: function (e, t) {
|
||
return {
|
||
nominative: 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split(
|
||
'_',
|
||
),
|
||
accusative: 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split(
|
||
'_',
|
||
),
|
||
}[
|
||
/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/.test(t)
|
||
? 'accusative'
|
||
: 'nominative'
|
||
][e.month()];
|
||
},
|
||
weekdays: function (e, t) {
|
||
return {
|
||
nominative: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split(
|
||
'_',
|
||
),
|
||
accusative: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split(
|
||
'_',
|
||
),
|
||
}[
|
||
/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/.test(t)
|
||
? 'accusative'
|
||
: 'nominative'
|
||
][e.day()];
|
||
},
|
||
weekdaysShort: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
|
||
weekdaysMin: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
|
||
monthsParse: [
|
||
/^янв/i,
|
||
/^фев/i,
|
||
/^мар/i,
|
||
/^апр/i,
|
||
/^ма[й|я]/i,
|
||
/^июн/i,
|
||
/^июл/i,
|
||
/^авг/i,
|
||
/^сен/i,
|
||
/^окт/i,
|
||
/^ноя/i,
|
||
/^дек/i,
|
||
],
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'DD.MM.YYYY',
|
||
LL: 'D MMMM YYYY г.',
|
||
LLL: 'D MMMM YYYY г., HH:mm',
|
||
LLLL: 'dddd, D MMMM YYYY г., HH:mm',
|
||
},
|
||
calendar: {
|
||
sameDay: '[Сегодня в] LT',
|
||
nextDay: '[Завтра в] LT',
|
||
lastDay: '[Вчера в] LT',
|
||
nextWeek: function () {
|
||
return 2 === this.day() ? '[Во] dddd [в] LT' : '[В] dddd [в] LT';
|
||
},
|
||
lastWeek: function (e) {
|
||
if (e.week() === this.week())
|
||
return 2 === this.day()
|
||
? '[Во] dddd [в] LT'
|
||
: '[В] dddd [в] LT';
|
||
switch (this.day()) {
|
||
case 0:
|
||
return '[В прошлое] dddd [в] LT';
|
||
case 1:
|
||
case 2:
|
||
case 4:
|
||
return '[В прошлый] dddd [в] LT';
|
||
case 3:
|
||
case 5:
|
||
case 6:
|
||
return '[В прошлую] dddd [в] LT';
|
||
}
|
||
},
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: 'через %s',
|
||
past: '%s назад',
|
||
s: 'несколько секунд',
|
||
m: t,
|
||
mm: t,
|
||
h: 'час',
|
||
hh: t,
|
||
d: 'день',
|
||
dd: t,
|
||
M: 'месяц',
|
||
MM: t,
|
||
y: 'год',
|
||
yy: t,
|
||
},
|
||
meridiemParse: /ночи|утра|дня|вечера/i,
|
||
isPM: function (e) {
|
||
return /^(дня|вечера)$/.test(e);
|
||
},
|
||
meridiem: function (e, t, n) {
|
||
return e < 4 ? 'ночи' : e < 12 ? 'утра' : e < 17 ? 'дня' : 'вечера';
|
||
},
|
||
ordinalParse: /\d{1,2}-(й|го|я)/,
|
||
ordinal: function (e, t) {
|
||
switch (t) {
|
||
case 'M':
|
||
case 'd':
|
||
case 'DDD':
|
||
return e + '-й';
|
||
case 'D':
|
||
return e + '-го';
|
||
case 'w':
|
||
case 'W':
|
||
return e + '-я';
|
||
default:
|
||
return e;
|
||
}
|
||
},
|
||
week: { dow: 1, doy: 7 },
|
||
});
|
||
})(n('wd/R'));
|
||
},
|
||
ldgD: function (e, t, n) {
|
||
'use strict';
|
||
n('YFKU'), n('HbRj');
|
||
var i = n('wd/R');
|
||
window.language &&
|
||
(i.locale(window.language, {
|
||
months: [
|
||
window.t('January'),
|
||
window.t('February'),
|
||
window.t('March'),
|
||
window.t('April'),
|
||
window.t('May'),
|
||
window.t('June'),
|
||
window.t('July'),
|
||
window.t('August'),
|
||
window.t('September'),
|
||
window.t('October'),
|
||
window.t('November'),
|
||
window.t('December'),
|
||
],
|
||
monthsShort: [
|
||
window.t('Jan'),
|
||
window.t('Feb'),
|
||
window.t('Mar'),
|
||
window.t('Apr'),
|
||
window.t('May'),
|
||
window.t('Jun'),
|
||
window.t('Jul'),
|
||
window.t('Aug'),
|
||
window.t('Sep'),
|
||
window.t('Oct'),
|
||
window.t('Nov'),
|
||
window.t('Dec'),
|
||
],
|
||
weekdays: [
|
||
window.t('Sunday'),
|
||
window.t('Monday'),
|
||
window.t('Tuesday'),
|
||
window.t('Wednesday'),
|
||
window.t('Thursday'),
|
||
window.t('Friday'),
|
||
window.t('Saturday'),
|
||
],
|
||
weekdaysShort: [
|
||
window.t('Sun'),
|
||
window.t('Mon'),
|
||
window.t('Tue'),
|
||
window.t('Wed'),
|
||
window.t('Thu'),
|
||
window.t('Fri'),
|
||
window.t('Sat'),
|
||
],
|
||
weekdaysMin: [
|
||
window.t('Su', { context: 'day_of_week' }),
|
||
window.t('Mo', { context: 'day_of_week' }),
|
||
window.t('Tu', { context: 'day_of_week' }),
|
||
window.t('We', { context: 'day_of_week' }),
|
||
window.t('Th', { context: 'day_of_week' }),
|
||
window.t('Fr', { context: 'day_of_week' }),
|
||
window.t('Sa', { context: 'day_of_week' }),
|
||
],
|
||
longDateFormat: {
|
||
LT: 'HH:mm',
|
||
LTS: 'HH:mm:ss',
|
||
L: 'MMM D',
|
||
l: 'M/D/YYYY',
|
||
LL: 'MMM D, YYYY',
|
||
ll: 'MMM D LT',
|
||
LLL: 'LT - LL',
|
||
lll: 'MMM D, YYYY LT',
|
||
LLLL: 'ddd D MMMM YYYY LT',
|
||
llll: 'ddd D MMM YYYY LT',
|
||
},
|
||
calendar: {
|
||
sameDay: window
|
||
.t('{specialSymbolOpen}Today at{specialSymbolClose} {dayTime}')
|
||
.format({
|
||
specialSymbolOpen: '[',
|
||
specialSymbolClose: ']',
|
||
dayTime: 'LT',
|
||
}),
|
||
nextDay: window
|
||
.t('{specialSymbolOpen}Tomorrow at{specialSymbolClose} {dayTime}')
|
||
.format({
|
||
specialSymbolOpen: '[',
|
||
specialSymbolClose: ']',
|
||
dayTime: 'LT',
|
||
}),
|
||
nextWeek: window
|
||
.t(
|
||
'{dayName} {specialSymbolOpen}at{specialSymbolClose} {dayTime}',
|
||
)
|
||
.format({
|
||
specialSymbolOpen: '[',
|
||
specialSymbolClose: ']',
|
||
dayTime: 'LT',
|
||
dayName: 'dddd',
|
||
}),
|
||
lastDay: window
|
||
.t(
|
||
'{specialSymbolOpen}Yesterday at{specialSymbolClose} {dayTime}',
|
||
)
|
||
.format({
|
||
specialSymbolOpen: '[',
|
||
specialSymbolClose: ']',
|
||
dayTime: 'LT',
|
||
}),
|
||
lastWeek: window
|
||
.t(
|
||
'{specialSymbolOpen}Last{specialSymbolClose} {dayName} {specialSymbolOpen}at{specialSymbolClose} {dayTime}',
|
||
)
|
||
.format({
|
||
specialSymbolOpen: '[',
|
||
specialSymbolClose: ']',
|
||
dayTime: 'LT',
|
||
dayName: 'dddd',
|
||
}),
|
||
sameElse: 'L',
|
||
},
|
||
relativeTime: {
|
||
future: function (e) {
|
||
return e === window.t('just now')
|
||
? e
|
||
: window.t('in %s', { context: 'time_range' }).replace('%s', e);
|
||
},
|
||
past: function (e) {
|
||
return e === window.t('just now')
|
||
? e
|
||
: window
|
||
.t('%s ago', { context: 'time_range' })
|
||
.replace('%s', e);
|
||
},
|
||
s: window.t('just now'),
|
||
m: function (e) {
|
||
return window
|
||
.t('%d minute', { plural: '%d minutes', count: e })
|
||
.replace('%d', e);
|
||
},
|
||
mm: function (e) {
|
||
return window
|
||
.t('%d minute', { plural: '%d minutes', count: e })
|
||
.replace('%d', e);
|
||
},
|
||
h: window.t('an hour'),
|
||
hh: function (e) {
|
||
return window
|
||
.t('%d hour', { plural: '%d hours', count: e })
|
||
.replace('%d', e);
|
||
},
|
||
d: window.t('a day'),
|
||
dd: function (e) {
|
||
return window
|
||
.t('%d day', { plural: '%d days', count: e })
|
||
.replace('%d', e);
|
||
},
|
||
M: window.t('a month'),
|
||
MM: function (e) {
|
||
return window
|
||
.t('%d month', { plural: '%d months', count: e })
|
||
.replace('%d', e);
|
||
},
|
||
y: window.t('a year'),
|
||
yy: function (e) {
|
||
return window
|
||
.t('%d year', { plural: '%d years', count: e })
|
||
.replace('%d', e);
|
||
},
|
||
},
|
||
week: { dow: 1, doy: 4 },
|
||
}),
|
||
i.locale(window.language)),
|
||
(e.exports = i);
|
||
},
|
||
qoI1: function (e, t, n) {
|
||
var i = {
|
||
'./en-gb': 'Oaa7',
|
||
'./en-gb.js': 'Oaa7',
|
||
'./es': 'iYuL',
|
||
'./es.js': 'iYuL',
|
||
'./it': 'bpih',
|
||
'./it.js': 'bpih',
|
||
'./ja': 'B55N',
|
||
'./ja.js': 'B55N',
|
||
'./ko': 'Ivi+',
|
||
'./ko.js': 'Ivi+',
|
||
'./pl': 'jVdC',
|
||
'./pl.js': 'jVdC',
|
||
'./pt': '8mBD',
|
||
'./pt-br': '0tRk',
|
||
'./pt-br.js': '0tRk',
|
||
'./pt.js': '8mBD',
|
||
'./ru': 'lXzo',
|
||
'./ru.js': 'lXzo',
|
||
'./tr': 'DoHr',
|
||
'./tr.js': 'DoHr',
|
||
};
|
||
function a(e) {
|
||
var t = s(e);
|
||
return n(t);
|
||
}
|
||
function s(e) {
|
||
if (!n.o(i, e)) {
|
||
var t = new Error("Cannot find module '" + e + "'");
|
||
throw ((t.code = 'MODULE_NOT_FOUND'), t);
|
||
}
|
||
return i[e];
|
||
}
|
||
(a.keys = function () {
|
||
return Object.keys(i);
|
||
}),
|
||
(a.resolve = s),
|
||
(e.exports = a),
|
||
(a.id = 'qoI1');
|
||
},
|
||
'wd/R': function (e, t, n) {
|
||
(function (e) {
|
||
e.exports = (function () {
|
||
'use strict';
|
||
var t;
|
||
function i() {
|
||
return t.apply(null, arguments);
|
||
}
|
||
function a(e) {
|
||
return '[object Array]' === Object.prototype.toString.call(e);
|
||
}
|
||
function s(e) {
|
||
return (
|
||
e instanceof Date ||
|
||
'[object Date]' === Object.prototype.toString.call(e)
|
||
);
|
||
}
|
||
function r(e, t) {
|
||
return Object.prototype.hasOwnProperty.call(e, t);
|
||
}
|
||
function o(e, t) {
|
||
for (var n in t) r(t, n) && (e[n] = t[n]);
|
||
return (
|
||
r(t, 'toString') && (e.toString = t.toString),
|
||
r(t, 'valueOf') && (e.valueOf = t.valueOf),
|
||
e
|
||
);
|
||
}
|
||
function d(e, t, n, i) {
|
||
return Pe(e, t, n, i, !0).utc();
|
||
}
|
||
function u(e) {
|
||
return (
|
||
null == e._pf &&
|
||
(e._pf = {
|
||
empty: !1,
|
||
unusedTokens: [],
|
||
unusedInput: [],
|
||
overflow: -2,
|
||
charsLeftOver: 0,
|
||
nullInput: !1,
|
||
invalidMonth: null,
|
||
invalidFormat: !1,
|
||
userInvalidated: !1,
|
||
iso: !1,
|
||
}),
|
||
e._pf
|
||
);
|
||
}
|
||
function l(e) {
|
||
if (null == e._isValid) {
|
||
var t = u(e);
|
||
(e._isValid = !(
|
||
isNaN(e._d.getTime()) ||
|
||
!(t.overflow < 0) ||
|
||
t.empty ||
|
||
t.invalidMonth ||
|
||
t.invalidWeekday ||
|
||
t.nullInput ||
|
||
t.invalidFormat ||
|
||
t.userInvalidated
|
||
)),
|
||
e._strict &&
|
||
(e._isValid =
|
||
e._isValid &&
|
||
0 === t.charsLeftOver &&
|
||
0 === t.unusedTokens.length &&
|
||
void 0 === t.bigHour);
|
||
}
|
||
return e._isValid;
|
||
}
|
||
function _(e) {
|
||
var t = d(NaN);
|
||
return null != e ? o(u(t), e) : (u(t).userInvalidated = !0), t;
|
||
}
|
||
var c = (i.momentProperties = []);
|
||
function m(e, t) {
|
||
var n, i, a;
|
||
if (
|
||
(void 0 !== t._isAMomentObject &&
|
||
(e._isAMomentObject = t._isAMomentObject),
|
||
void 0 !== t._i && (e._i = t._i),
|
||
void 0 !== t._f && (e._f = t._f),
|
||
void 0 !== t._l && (e._l = t._l),
|
||
void 0 !== t._strict && (e._strict = t._strict),
|
||
void 0 !== t._tzm && (e._tzm = t._tzm),
|
||
void 0 !== t._isUTC && (e._isUTC = t._isUTC),
|
||
void 0 !== t._offset && (e._offset = t._offset),
|
||
void 0 !== t._pf && (e._pf = u(t)),
|
||
void 0 !== t._locale && (e._locale = t._locale),
|
||
c.length > 0)
|
||
)
|
||
for (n in c) void 0 !== (a = t[(i = c[n])]) && (e[i] = a);
|
||
return e;
|
||
}
|
||
var h = !1;
|
||
function f(e) {
|
||
m(this, e),
|
||
(this._d = new Date(null != e._d ? e._d.getTime() : NaN)),
|
||
!1 === h && ((h = !0), i.updateOffset(this), (h = !1));
|
||
}
|
||
function y(e) {
|
||
return e instanceof f || (null != e && null != e._isAMomentObject);
|
||
}
|
||
function M(e) {
|
||
return e < 0 ? Math.ceil(e) : Math.floor(e);
|
||
}
|
||
function w(e) {
|
||
var t = +e,
|
||
n = 0;
|
||
return 0 !== t && isFinite(t) && (n = M(t)), n;
|
||
}
|
||
function p(e, t, n) {
|
||
var i,
|
||
a = Math.min(e.length, t.length),
|
||
s = Math.abs(e.length - t.length),
|
||
r = 0;
|
||
for (i = 0; i < a; i++)
|
||
((n && e[i] !== t[i]) || (!n && w(e[i]) !== w(t[i]))) && r++;
|
||
return r + s;
|
||
}
|
||
function Y() {}
|
||
var D,
|
||
L = {};
|
||
function g(e) {
|
||
return e ? e.toLowerCase().replace('_', '-') : e;
|
||
}
|
||
function v(t) {
|
||
var i = null;
|
||
if (!L[t] && void 0 !== e && e && e.exports)
|
||
try {
|
||
(i = D._abbr), n('qoI1')('./' + t), T(i);
|
||
} catch (a) {}
|
||
return L[t];
|
||
}
|
||
function T(e, t) {
|
||
var n;
|
||
return e && (n = void 0 === t ? k(e) : S(e, t)) && (D = n), D._abbr;
|
||
}
|
||
function S(e, t) {
|
||
return null !== t
|
||
? ((t.abbr = e),
|
||
(L[e] = L[e] || new Y()),
|
||
L[e].set(t),
|
||
T(e),
|
||
L[e])
|
||
: (delete L[e], null);
|
||
}
|
||
function k(e) {
|
||
var t;
|
||
if (
|
||
(e && e._locale && e._locale._abbr && (e = e._locale._abbr), !e)
|
||
)
|
||
return D;
|
||
if (!a(e)) {
|
||
if ((t = v(e))) return t;
|
||
e = [e];
|
||
}
|
||
return (function (e) {
|
||
for (var t, n, i, a, s = 0; s < e.length; ) {
|
||
for (
|
||
t = (a = g(e[s]).split('-')).length,
|
||
n = (n = g(e[s + 1])) ? n.split('-') : null;
|
||
t > 0;
|
||
|
||
) {
|
||
if ((i = v(a.slice(0, t).join('-')))) return i;
|
||
if (n && n.length >= t && p(a, n, !0) >= t - 1) break;
|
||
t--;
|
||
}
|
||
s++;
|
||
}
|
||
return null;
|
||
})(e);
|
||
}
|
||
var b = {};
|
||
function O(e, t) {
|
||
var n = e.toLowerCase();
|
||
b[n] = b[n + 's'] = b[t] = e;
|
||
}
|
||
function H(e) {
|
||
return 'string' == typeof e ? b[e] || b[e.toLowerCase()] : void 0;
|
||
}
|
||
function F(e) {
|
||
var t,
|
||
n,
|
||
i = {};
|
||
for (n in e) r(e, n) && (t = H(n)) && (i[t] = e[n]);
|
||
return i;
|
||
}
|
||
function W(e, t) {
|
||
return function (n) {
|
||
return null != n
|
||
? (P(this, e, n), i.updateOffset(this, t), this)
|
||
: C(this, e);
|
||
};
|
||
}
|
||
function C(e, t) {
|
||
return e._d['get' + (e._isUTC ? 'UTC' : '') + t]();
|
||
}
|
||
function P(e, t, n) {
|
||
return e._d['set' + (e._isUTC ? 'UTC' : '') + t](n);
|
||
}
|
||
function x(e, t) {
|
||
var n;
|
||
if ('object' == typeof e) for (n in e) this.set(n, e[n]);
|
||
else if ('function' == typeof this[(e = H(e))]) return this[e](t);
|
||
return this;
|
||
}
|
||
function z(e, t, n) {
|
||
var i = '' + Math.abs(e),
|
||
a = t - i.length;
|
||
return (
|
||
(e >= 0 ? (n ? '+' : '') : '-') +
|
||
Math.pow(10, Math.max(0, a)).toString().substr(1) +
|
||
i
|
||
);
|
||
}
|
||
var A = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
|
||
U = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
|
||
G = {},
|
||
j = {};
|
||
function N(e, t, n, i) {
|
||
var a = i;
|
||
'string' == typeof i &&
|
||
(a = function () {
|
||
return this[i]();
|
||
}),
|
||
e && (j[e] = a),
|
||
t &&
|
||
(j[t[0]] = function () {
|
||
return z(a.apply(this, arguments), t[1], t[2]);
|
||
}),
|
||
n &&
|
||
(j[n] = function () {
|
||
return this.localeData().ordinal(a.apply(this, arguments), e);
|
||
});
|
||
}
|
||
function J(e, t) {
|
||
return e.isValid()
|
||
? ((t = I(t, e.localeData())),
|
||
(G[t] =
|
||
G[t] ||
|
||
(function (e) {
|
||
var t,
|
||
n,
|
||
i,
|
||
a = e.match(A);
|
||
for (t = 0, n = a.length; t < n; t++)
|
||
j[a[t]]
|
||
? (a[t] = j[a[t]])
|
||
: (a[t] = (i = a[t]).match(/\[[\s\S]/)
|
||
? i.replace(/^\[|\]$/g, '')
|
||
: i.replace(/\\/g, ''));
|
||
return function (i) {
|
||
var s = '';
|
||
for (t = 0; t < n; t++)
|
||
s += a[t] instanceof Function ? a[t].call(i, e) : a[t];
|
||
return s;
|
||
};
|
||
})(t)),
|
||
G[t](e))
|
||
: e.localeData().invalidDate();
|
||
}
|
||
function I(e, t) {
|
||
var n = 5;
|
||
function i(e) {
|
||
return t.longDateFormat(e) || e;
|
||
}
|
||
for (U.lastIndex = 0; n >= 0 && U.test(e); )
|
||
(e = e.replace(U, i)), (U.lastIndex = 0), (n -= 1);
|
||
return e;
|
||
}
|
||
var E = /\d/,
|
||
V = /\d\d/,
|
||
R = /\d{3}/,
|
||
Z = /\d{4}/,
|
||
Q = /[+-]?\d{6}/,
|
||
q = /\d\d?/,
|
||
B = /\d{1,3}/,
|
||
$ = /\d{1,4}/,
|
||
X = /[+-]?\d{1,6}/,
|
||
K = /\d+/,
|
||
ee = /[+-]?\d+/,
|
||
te = /Z|[+-]\d\d:?\d\d/gi,
|
||
ne = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i,
|
||
ie = {};
|
||
function ae(e, t, n) {
|
||
var i;
|
||
ie[e] =
|
||
'function' == typeof (i = t) &&
|
||
'[object Function]' === Object.prototype.toString.call(i)
|
||
? t
|
||
: function (e) {
|
||
return e && n ? n : t;
|
||
};
|
||
}
|
||
function se(e, t) {
|
||
return r(ie, e)
|
||
? ie[e](t._strict, t._locale)
|
||
: new RegExp(
|
||
e
|
||
.replace('\\', '')
|
||
.replace(
|
||
/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
|
||
function (e, t, n, i, a) {
|
||
return t || n || i || a;
|
||
},
|
||
)
|
||
.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'),
|
||
);
|
||
}
|
||
var re = {};
|
||
function oe(e, t) {
|
||
var n,
|
||
i = t;
|
||
for (
|
||
'string' == typeof e && (e = [e]),
|
||
'number' == typeof t &&
|
||
(i = function (e, n) {
|
||
n[t] = w(e);
|
||
}),
|
||
n = 0;
|
||
n < e.length;
|
||
n++
|
||
)
|
||
re[e[n]] = i;
|
||
}
|
||
function de(e, t) {
|
||
oe(e, function (e, n, i, a) {
|
||
(i._w = i._w || {}), t(e, i._w, i, a);
|
||
});
|
||
}
|
||
function ue(e, t, n) {
|
||
null != t && r(re, e) && re[e](t, n._a, n, e);
|
||
}
|
||
function le(e, t) {
|
||
return new Date(Date.UTC(e, t + 1, 0)).getUTCDate();
|
||
}
|
||
N('M', ['MM', 2], 'Mo', function () {
|
||
return this.month() + 1;
|
||
}),
|
||
N('MMM', 0, 0, function (e) {
|
||
return this.localeData().monthsShort(this, e);
|
||
}),
|
||
N('MMMM', 0, 0, function (e) {
|
||
return this.localeData().months(this, e);
|
||
}),
|
||
O('month', 'M'),
|
||
ae('M', q),
|
||
ae('MM', q, V),
|
||
ae('MMM', ne),
|
||
ae('MMMM', ne),
|
||
oe(['M', 'MM'], function (e, t) {
|
||
t[1] = w(e) - 1;
|
||
}),
|
||
oe(['MMM', 'MMMM'], function (e, t, n, i) {
|
||
var a = n._locale.monthsParse(e, i, n._strict);
|
||
null != a ? (t[1] = a) : (u(n).invalidMonth = e);
|
||
});
|
||
var _e = 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
|
||
'_',
|
||
),
|
||
ce = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
|
||
function me(e, t) {
|
||
var n;
|
||
return (
|
||
('string' == typeof t &&
|
||
'number' != typeof (t = e.localeData().monthsParse(t))) ||
|
||
((n = Math.min(e.date(), le(e.year(), t))),
|
||
e._d['set' + (e._isUTC ? 'UTC' : '') + 'Month'](t, n)),
|
||
e
|
||
);
|
||
}
|
||
function he(e) {
|
||
return null != e
|
||
? (me(this, e), i.updateOffset(this, !0), this)
|
||
: C(this, 'Month');
|
||
}
|
||
function fe(e) {
|
||
var t,
|
||
n = e._a;
|
||
return (
|
||
n &&
|
||
-2 === u(e).overflow &&
|
||
((t =
|
||
n[1] < 0 || n[1] > 11
|
||
? 1
|
||
: n[2] < 1 || n[2] > le(n[0], n[1])
|
||
? 2
|
||
: n[3] < 0 ||
|
||
n[3] > 24 ||
|
||
(24 === n[3] && (0 !== n[4] || 0 !== n[5] || 0 !== n[6]))
|
||
? 3
|
||
: n[4] < 0 || n[4] > 59
|
||
? 4
|
||
: n[5] < 0 || n[5] > 59
|
||
? 5
|
||
: n[6] < 0 || n[6] > 999
|
||
? 6
|
||
: -1),
|
||
u(e)._overflowDayOfYear && (t < 0 || t > 2) && (t = 2),
|
||
(u(e).overflow = t)),
|
||
e
|
||
);
|
||
}
|
||
function ye(e) {
|
||
!1 === i.suppressDeprecationWarnings &&
|
||
'undefined' != typeof console &&
|
||
console.warn &&
|
||
console.warn('Deprecation warning: ' + e);
|
||
}
|
||
function Me(e, t) {
|
||
var n = !0;
|
||
return o(function () {
|
||
return (
|
||
n && (ye(e + '\n' + new Error().stack), (n = !1)),
|
||
t.apply(this, arguments)
|
||
);
|
||
}, t);
|
||
}
|
||
var we = {};
|
||
i.suppressDeprecationWarnings = !1;
|
||
var pe = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
|
||
Ye = [
|
||
['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
|
||
['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
|
||
['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
|
||
['GGGG-[W]WW', /\d{4}-W\d{2}/],
|
||
['YYYY-DDD', /\d{4}-\d{3}/],
|
||
],
|
||
De = [
|
||
['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
|
||
['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
|
||
['HH:mm', /(T| )\d\d:\d\d/],
|
||
['HH', /(T| )\d\d/],
|
||
],
|
||
Le = /^\/?Date\((\-?\d+)/i;
|
||
function ge(e) {
|
||
var t,
|
||
n,
|
||
i = e._i,
|
||
a = pe.exec(i);
|
||
if (a) {
|
||
for (u(e).iso = !0, t = 0, n = Ye.length; t < n; t++)
|
||
if (Ye[t][1].exec(i)) {
|
||
e._f = Ye[t][0];
|
||
break;
|
||
}
|
||
for (t = 0, n = De.length; t < n; t++)
|
||
if (De[t][1].exec(i)) {
|
||
e._f += (a[6] || ' ') + De[t][0];
|
||
break;
|
||
}
|
||
i.match(te) && (e._f += 'Z'), We(e);
|
||
} else e._isValid = !1;
|
||
}
|
||
function ve(e, t, n, i, a, s, r) {
|
||
var o = new Date(e, t, n, i, a, s, r);
|
||
return e < 1970 && o.setFullYear(e), o;
|
||
}
|
||
function Te(e) {
|
||
var t = new Date(Date.UTC.apply(null, arguments));
|
||
return e < 1970 && t.setUTCFullYear(e), t;
|
||
}
|
||
function Se(e) {
|
||
return ke(e) ? 366 : 365;
|
||
}
|
||
function ke(e) {
|
||
return (e % 4 == 0 && e % 100 != 0) || e % 400 == 0;
|
||
}
|
||
(i.createFromInputFallback = Me(
|
||
'moment construction falls back to js Date. This is discouraged and will be removed in upcoming major release. Please refer to https://github.com/moment/moment/issues/1407 for more info.',
|
||
function (e) {
|
||
e._d = new Date(e._i + (e._useUTC ? ' UTC' : ''));
|
||
},
|
||
)),
|
||
N(0, ['YY', 2], 0, function () {
|
||
return this.year() % 100;
|
||
}),
|
||
N(0, ['YYYY', 4], 0, 'year'),
|
||
N(0, ['YYYYY', 5], 0, 'year'),
|
||
N(0, ['YYYYYY', 6, !0], 0, 'year'),
|
||
O('year', 'y'),
|
||
ae('Y', ee),
|
||
ae('YY', q, V),
|
||
ae('YYYY', $, Z),
|
||
ae('YYYYY', X, Q),
|
||
ae('YYYYYY', X, Q),
|
||
oe(['YYYYY', 'YYYYYY'], 0),
|
||
oe('YYYY', function (e, t) {
|
||
t[0] = 2 === e.length ? i.parseTwoDigitYear(e) : w(e);
|
||
}),
|
||
oe('YY', function (e, t) {
|
||
t[0] = i.parseTwoDigitYear(e);
|
||
}),
|
||
(i.parseTwoDigitYear = function (e) {
|
||
return w(e) + (w(e) > 68 ? 1900 : 2e3);
|
||
});
|
||
var be = W('FullYear', !1);
|
||
function Oe(e, t, n) {
|
||
var i,
|
||
a = n - t,
|
||
s = n - e.day();
|
||
return (
|
||
s > a && (s -= 7),
|
||
s < a - 7 && (s += 7),
|
||
(i = xe(e).add(s, 'd')),
|
||
{ week: Math.ceil(i.dayOfYear() / 7), year: i.year() }
|
||
);
|
||
}
|
||
function He(e, t, n) {
|
||
return null != e ? e : null != t ? t : n;
|
||
}
|
||
function Fe(e) {
|
||
var t,
|
||
n,
|
||
i,
|
||
a,
|
||
s = [];
|
||
if (!e._d) {
|
||
for (
|
||
i = (function (e) {
|
||
var t = new Date();
|
||
return e._useUTC
|
||
? [t.getUTCFullYear(), t.getUTCMonth(), t.getUTCDate()]
|
||
: [t.getFullYear(), t.getMonth(), t.getDate()];
|
||
})(e),
|
||
e._w &&
|
||
null == e._a[2] &&
|
||
null == e._a[1] &&
|
||
(function (e) {
|
||
var t, n, i, a, s, r, o;
|
||
null != (t = e._w).GG || null != t.W || null != t.E
|
||
? ((s = 1),
|
||
(r = 4),
|
||
(n = He(t.GG, e._a[0], Oe(xe(), 1, 4).year)),
|
||
(i = He(t.W, 1)),
|
||
(a = He(t.E, 1)))
|
||
: ((s = e._locale._week.dow),
|
||
(r = e._locale._week.doy),
|
||
(n = He(t.gg, e._a[0], Oe(xe(), s, r).year)),
|
||
(i = He(t.w, 1)),
|
||
null != t.d
|
||
? (a = t.d) < s && ++i
|
||
: (a = null != t.e ? t.e + s : s)),
|
||
(o = (function (e, t, n, i, a) {
|
||
var s,
|
||
r = 6 + a - i,
|
||
o = Te(e, 0, 1 + r).getUTCDay();
|
||
return (
|
||
o < a && (o += 7),
|
||
{
|
||
year:
|
||
(s =
|
||
1 +
|
||
r +
|
||
7 * (t - 1) -
|
||
o +
|
||
(n = null != n ? 1 * n : a)) > 0
|
||
? e
|
||
: e - 1,
|
||
dayOfYear: s > 0 ? s : Se(e - 1) + s,
|
||
}
|
||
);
|
||
})(n, i, a, r, s)),
|
||
(e._a[0] = o.year),
|
||
(e._dayOfYear = o.dayOfYear);
|
||
})(e),
|
||
e._dayOfYear &&
|
||
((a = He(e._a[0], i[0])),
|
||
e._dayOfYear > Se(a) && (u(e)._overflowDayOfYear = !0),
|
||
(n = Te(a, 0, e._dayOfYear)),
|
||
(e._a[1] = n.getUTCMonth()),
|
||
(e._a[2] = n.getUTCDate())),
|
||
t = 0;
|
||
t < 3 && null == e._a[t];
|
||
++t
|
||
)
|
||
e._a[t] = s[t] = i[t];
|
||
for (; t < 7; t++)
|
||
e._a[t] = s[t] = null == e._a[t] ? (2 === t ? 1 : 0) : e._a[t];
|
||
24 === e._a[3] &&
|
||
0 === e._a[4] &&
|
||
0 === e._a[5] &&
|
||
0 === e._a[6] &&
|
||
((e._nextDay = !0), (e._a[3] = 0)),
|
||
(e._d = (e._useUTC ? Te : ve).apply(null, s)),
|
||
null != e._tzm &&
|
||
e._d.setUTCMinutes(e._d.getUTCMinutes() - e._tzm),
|
||
e._nextDay && (e._a[3] = 24);
|
||
}
|
||
}
|
||
function We(e) {
|
||
if (e._f !== i.ISO_8601) {
|
||
(e._a = []), (u(e).empty = !0);
|
||
var t,
|
||
n,
|
||
a,
|
||
s,
|
||
r,
|
||
o = '' + e._i,
|
||
d = o.length,
|
||
l = 0;
|
||
for (
|
||
a = I(e._f, e._locale).match(A) || [], t = 0;
|
||
t < a.length;
|
||
t++
|
||
)
|
||
(s = a[t]),
|
||
(n = (o.match(se(s, e)) || [])[0]) &&
|
||
((r = o.substr(0, o.indexOf(n))).length > 0 &&
|
||
u(e).unusedInput.push(r),
|
||
(o = o.slice(o.indexOf(n) + n.length)),
|
||
(l += n.length)),
|
||
j[s]
|
||
? (n ? (u(e).empty = !1) : u(e).unusedTokens.push(s),
|
||
ue(s, n, e))
|
||
: e._strict && !n && u(e).unusedTokens.push(s);
|
||
(u(e).charsLeftOver = d - l),
|
||
o.length > 0 && u(e).unusedInput.push(o),
|
||
!0 === u(e).bigHour &&
|
||
e._a[3] <= 12 &&
|
||
e._a[3] > 0 &&
|
||
(u(e).bigHour = void 0),
|
||
(e._a[3] = (function (e, t, n) {
|
||
var i;
|
||
return null == n
|
||
? t
|
||
: null != e.meridiemHour
|
||
? e.meridiemHour(t, n)
|
||
: null != e.isPM
|
||
? ((i = e.isPM(n)) && t < 12 && (t += 12),
|
||
i || 12 !== t || (t = 0),
|
||
t)
|
||
: t;
|
||
})(e._locale, e._a[3], e._meridiem)),
|
||
Fe(e),
|
||
fe(e);
|
||
} else ge(e);
|
||
}
|
||
function Ce(e) {
|
||
var t = e._i,
|
||
n = e._f;
|
||
return (
|
||
(e._locale = e._locale || k(e._l)),
|
||
null === t || (void 0 === n && '' === t)
|
||
? _({ nullInput: !0 })
|
||
: ('string' == typeof t && (e._i = t = e._locale.preparse(t)),
|
||
y(t)
|
||
? new f(fe(t))
|
||
: (a(n)
|
||
? (function (e) {
|
||
var t, n, i, a, s;
|
||
if (0 === e._f.length)
|
||
return (
|
||
(u(e).invalidFormat = !0),
|
||
void (e._d = new Date(NaN))
|
||
);
|
||
for (a = 0; a < e._f.length; a++)
|
||
(s = 0),
|
||
(t = m({}, e)),
|
||
null != e._useUTC && (t._useUTC = e._useUTC),
|
||
(t._f = e._f[a]),
|
||
We(t),
|
||
l(t) &&
|
||
((s += u(t).charsLeftOver),
|
||
(s += 10 * u(t).unusedTokens.length),
|
||
(u(t).score = s),
|
||
(null == i || s < i) && ((i = s), (n = t)));
|
||
o(e, n || t);
|
||
})(e)
|
||
: n
|
||
? We(e)
|
||
: s(t)
|
||
? (e._d = t)
|
||
: (function (e) {
|
||
var t = e._i;
|
||
void 0 === t
|
||
? (e._d = new Date())
|
||
: s(t)
|
||
? (e._d = new Date(+t))
|
||
: 'string' == typeof t
|
||
? (function (e) {
|
||
var t = Le.exec(e._i);
|
||
null === t
|
||
? (ge(e),
|
||
!1 === e._isValid &&
|
||
(delete e._isValid,
|
||
i.createFromInputFallback(e)))
|
||
: (e._d = new Date(+t[1]));
|
||
})(e)
|
||
: a(t)
|
||
? ((e._a = (function (e, t) {
|
||
var n,
|
||
i = [];
|
||
for (n = 0; n < e.length; ++n)
|
||
i.push(t(e[n], n));
|
||
return i;
|
||
})(t.slice(0), function (e) {
|
||
return parseInt(e, 10);
|
||
})),
|
||
Fe(e))
|
||
: 'object' == typeof t
|
||
? (function (e) {
|
||
if (!e._d) {
|
||
var t = F(e._i);
|
||
(e._a = [
|
||
t.year,
|
||
t.month,
|
||
t.day || t.date,
|
||
t.hour,
|
||
t.minute,
|
||
t.second,
|
||
t.millisecond,
|
||
]),
|
||
Fe(e);
|
||
}
|
||
})(e)
|
||
: 'number' == typeof t
|
||
? (e._d = new Date(t))
|
||
: i.createFromInputFallback(e);
|
||
})(e),
|
||
e))
|
||
);
|
||
}
|
||
function Pe(e, t, n, i, a) {
|
||
var s,
|
||
r = {};
|
||
return (
|
||
'boolean' == typeof n && ((i = n), (n = void 0)),
|
||
(r._isAMomentObject = !0),
|
||
(r._useUTC = r._isUTC = a),
|
||
(r._l = n),
|
||
(r._i = e),
|
||
(r._f = t),
|
||
(r._strict = i),
|
||
(s = new f(fe(Ce(r))))._nextDay &&
|
||
(s.add(1, 'd'), (s._nextDay = void 0)),
|
||
s
|
||
);
|
||
}
|
||
function xe(e, t, n, i) {
|
||
return Pe(e, t, n, i, !1);
|
||
}
|
||
N('w', ['ww', 2], 'wo', 'week'),
|
||
N('W', ['WW', 2], 'Wo', 'isoWeek'),
|
||
O('week', 'w'),
|
||
O('isoWeek', 'W'),
|
||
ae('w', q),
|
||
ae('ww', q, V),
|
||
ae('W', q),
|
||
ae('WW', q, V),
|
||
de(['w', 'ww', 'W', 'WW'], function (e, t, n, i) {
|
||
t[i.substr(0, 1)] = w(e);
|
||
}),
|
||
N('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'),
|
||
O('dayOfYear', 'DDD'),
|
||
ae('DDD', B),
|
||
ae('DDDD', R),
|
||
oe(['DDD', 'DDDD'], function (e, t, n) {
|
||
n._dayOfYear = w(e);
|
||
}),
|
||
(i.ISO_8601 = function () {});
|
||
var ze = Me(
|
||
'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
|
||
function () {
|
||
var e = xe.apply(null, arguments);
|
||
return e < this ? this : e;
|
||
},
|
||
),
|
||
Ae = Me(
|
||
'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
|
||
function () {
|
||
var e = xe.apply(null, arguments);
|
||
return e > this ? this : e;
|
||
},
|
||
);
|
||
function Ue(e, t) {
|
||
var n, i;
|
||
if ((1 === t.length && a(t[0]) && (t = t[0]), !t.length))
|
||
return xe();
|
||
for (n = t[0], i = 1; i < t.length; ++i)
|
||
(t[i].isValid() && !t[i][e](n)) || (n = t[i]);
|
||
return n;
|
||
}
|
||
function Ge(e) {
|
||
var t = F(e),
|
||
n = t.year || 0,
|
||
i = t.quarter || 0,
|
||
a = t.month || 0,
|
||
s = t.week || 0,
|
||
r = t.day || 0,
|
||
o = t.hour || 0,
|
||
d = t.minute || 0,
|
||
u = t.second || 0,
|
||
l = t.millisecond || 0;
|
||
(this._milliseconds = +l + 1e3 * u + 6e4 * d + 36e5 * o),
|
||
(this._days = +r + 7 * s),
|
||
(this._months = +a + 3 * i + 12 * n),
|
||
(this._data = {}),
|
||
(this._locale = k()),
|
||
this._bubble();
|
||
}
|
||
function je(e) {
|
||
return e instanceof Ge;
|
||
}
|
||
function Ne(e, t) {
|
||
N(e, 0, 0, function () {
|
||
var e = this.utcOffset(),
|
||
n = '+';
|
||
return (
|
||
e < 0 && ((e = -e), (n = '-')),
|
||
n + z(~~(e / 60), 2) + t + z(~~e % 60, 2)
|
||
);
|
||
});
|
||
}
|
||
Ne('Z', ':'),
|
||
Ne('ZZ', ''),
|
||
ae('Z', te),
|
||
ae('ZZ', te),
|
||
oe(['Z', 'ZZ'], function (e, t, n) {
|
||
(n._useUTC = !0), (n._tzm = Ie(e));
|
||
});
|
||
var Je = /([\+\-]|\d\d)/gi;
|
||
function Ie(e) {
|
||
var t = (e || '').match(te) || [],
|
||
n = ((t[t.length - 1] || []) + '').match(Je) || ['-', 0, 0],
|
||
i = 60 * n[1] + w(n[2]);
|
||
return '+' === n[0] ? i : -i;
|
||
}
|
||
function Ee(e, t) {
|
||
var n, a;
|
||
return t._isUTC
|
||
? ((n = t.clone()),
|
||
(a = (y(e) || s(e) ? +e : +xe(e)) - +n),
|
||
n._d.setTime(+n._d + a),
|
||
i.updateOffset(n, !1),
|
||
n)
|
||
: xe(e).local();
|
||
}
|
||
function Ve(e) {
|
||
return 15 * -Math.round(e._d.getTimezoneOffset() / 15);
|
||
}
|
||
function Re() {
|
||
return this._isUTC && 0 === this._offset;
|
||
}
|
||
i.updateOffset = function () {};
|
||
var Ze = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/,
|
||
Qe = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
|
||
function qe(e, t) {
|
||
var n,
|
||
i,
|
||
a,
|
||
s,
|
||
o,
|
||
d,
|
||
u = e,
|
||
l = null;
|
||
return (
|
||
je(e)
|
||
? (u = { ms: e._milliseconds, d: e._days, M: e._months })
|
||
: 'number' == typeof e
|
||
? ((u = {}), t ? (u[t] = e) : (u.milliseconds = e))
|
||
: (l = Ze.exec(e))
|
||
? ((n = '-' === l[1] ? -1 : 1),
|
||
(u = {
|
||
y: 0,
|
||
d: w(l[2]) * n,
|
||
h: w(l[3]) * n,
|
||
m: w(l[4]) * n,
|
||
s: w(l[5]) * n,
|
||
ms: w(l[6]) * n,
|
||
}))
|
||
: (l = Qe.exec(e))
|
||
? ((n = '-' === l[1] ? -1 : 1),
|
||
(u = {
|
||
y: Be(l[2], n),
|
||
M: Be(l[3], n),
|
||
d: Be(l[4], n),
|
||
h: Be(l[5], n),
|
||
m: Be(l[6], n),
|
||
s: Be(l[7], n),
|
||
w: Be(l[8], n),
|
||
}))
|
||
: null == u
|
||
? (u = {})
|
||
: 'object' == typeof u &&
|
||
('from' in u || 'to' in u) &&
|
||
((s = xe(u.from)),
|
||
(o = Ee((o = xe(u.to)), s)),
|
||
s.isBefore(o)
|
||
? (d = $e(s, o))
|
||
: (((d = $e(o, s)).milliseconds = -d.milliseconds),
|
||
(d.months = -d.months)),
|
||
((u = {}).ms = (a = d).milliseconds),
|
||
(u.M = a.months)),
|
||
(i = new Ge(u)),
|
||
je(e) && r(e, '_locale') && (i._locale = e._locale),
|
||
i
|
||
);
|
||
}
|
||
function Be(e, t) {
|
||
var n = e && parseFloat(e.replace(',', '.'));
|
||
return (isNaN(n) ? 0 : n) * t;
|
||
}
|
||
function $e(e, t) {
|
||
var n = { milliseconds: 0, months: 0 };
|
||
return (
|
||
(n.months = t.month() - e.month() + 12 * (t.year() - e.year())),
|
||
e.clone().add(n.months, 'M').isAfter(t) && --n.months,
|
||
(n.milliseconds = +t - +e.clone().add(n.months, 'M')),
|
||
n
|
||
);
|
||
}
|
||
function Xe(e, t) {
|
||
return function (n, i) {
|
||
var a;
|
||
return (
|
||
null === i ||
|
||
isNaN(+i) ||
|
||
((function (e, t) {
|
||
we[e] || (ye(t), (we[e] = !0));
|
||
})(
|
||
t,
|
||
'moment().' +
|
||
t +
|
||
'(period, number) is deprecated. Please use moment().' +
|
||
t +
|
||
'(number, period).',
|
||
),
|
||
(a = n),
|
||
(n = i),
|
||
(i = a)),
|
||
Ke(this, qe((n = 'string' == typeof n ? +n : n), i), e),
|
||
this
|
||
);
|
||
};
|
||
}
|
||
function Ke(e, t, n, a) {
|
||
var s = t._milliseconds,
|
||
r = t._days,
|
||
o = t._months;
|
||
(a = null == a || a),
|
||
s && e._d.setTime(+e._d + s * n),
|
||
r && P(e, 'Date', C(e, 'Date') + r * n),
|
||
o && me(e, C(e, 'Month') + o * n),
|
||
a && i.updateOffset(e, r || o);
|
||
}
|
||
qe.fn = Ge.prototype;
|
||
var et = Xe(1, 'add'),
|
||
tt = Xe(-1, 'subtract');
|
||
function nt() {
|
||
var e = this.clone().utc();
|
||
return 0 < e.year() && e.year() <= 9999
|
||
? 'function' == typeof Date.prototype.toISOString
|
||
? this.toDate().toISOString()
|
||
: J(e, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]')
|
||
: J(e, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
|
||
}
|
||
function it(e) {
|
||
var t;
|
||
return void 0 === e
|
||
? this._locale._abbr
|
||
: (null != (t = k(e)) && (this._locale = t), this);
|
||
}
|
||
i.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
|
||
var at = Me(
|
||
'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
|
||
function (e) {
|
||
return void 0 === e ? this.localeData() : this.locale(e);
|
||
},
|
||
);
|
||
function st() {
|
||
return this._locale;
|
||
}
|
||
function rt(e, t) {
|
||
N(0, [e, e.length], 0, t);
|
||
}
|
||
function ot(e, t, n) {
|
||
return Oe(xe([e, 11, 31 + t - n]), t, n).week;
|
||
}
|
||
N(0, ['gg', 2], 0, function () {
|
||
return this.weekYear() % 100;
|
||
}),
|
||
N(0, ['GG', 2], 0, function () {
|
||
return this.isoWeekYear() % 100;
|
||
}),
|
||
rt('gggg', 'weekYear'),
|
||
rt('ggggg', 'weekYear'),
|
||
rt('GGGG', 'isoWeekYear'),
|
||
rt('GGGGG', 'isoWeekYear'),
|
||
O('weekYear', 'gg'),
|
||
O('isoWeekYear', 'GG'),
|
||
ae('G', ee),
|
||
ae('g', ee),
|
||
ae('GG', q, V),
|
||
ae('gg', q, V),
|
||
ae('GGGG', $, Z),
|
||
ae('gggg', $, Z),
|
||
ae('GGGGG', X, Q),
|
||
ae('ggggg', X, Q),
|
||
de(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (e, t, n, i) {
|
||
t[i.substr(0, 2)] = w(e);
|
||
}),
|
||
de(['gg', 'GG'], function (e, t, n, a) {
|
||
t[a] = i.parseTwoDigitYear(e);
|
||
}),
|
||
N('Q', 0, 0, 'quarter'),
|
||
O('quarter', 'Q'),
|
||
ae('Q', E),
|
||
oe('Q', function (e, t) {
|
||
t[1] = 3 * (w(e) - 1);
|
||
}),
|
||
N('D', ['DD', 2], 'Do', 'date'),
|
||
O('date', 'D'),
|
||
ae('D', q),
|
||
ae('DD', q, V),
|
||
ae('Do', function (e, t) {
|
||
return e ? t._ordinalParse : t._ordinalParseLenient;
|
||
}),
|
||
oe(['D', 'DD'], 2),
|
||
oe('Do', function (e, t) {
|
||
t[2] = w(e.match(q)[0]);
|
||
});
|
||
var dt = W('Date', !0);
|
||
N('d', 0, 'do', 'day'),
|
||
N('dd', 0, 0, function (e) {
|
||
return this.localeData().weekdaysMin(this, e);
|
||
}),
|
||
N('ddd', 0, 0, function (e) {
|
||
return this.localeData().weekdaysShort(this, e);
|
||
}),
|
||
N('dddd', 0, 0, function (e) {
|
||
return this.localeData().weekdays(this, e);
|
||
}),
|
||
N('e', 0, 0, 'weekday'),
|
||
N('E', 0, 0, 'isoWeekday'),
|
||
O('day', 'd'),
|
||
O('weekday', 'e'),
|
||
O('isoWeekday', 'E'),
|
||
ae('d', q),
|
||
ae('e', q),
|
||
ae('E', q),
|
||
ae('dd', ne),
|
||
ae('ddd', ne),
|
||
ae('dddd', ne),
|
||
de(['dd', 'ddd', 'dddd'], function (e, t, n) {
|
||
var i = n._locale.weekdaysParse(e);
|
||
null != i ? (t.d = i) : (u(n).invalidWeekday = e);
|
||
}),
|
||
de(['d', 'e', 'E'], function (e, t, n, i) {
|
||
t[i] = w(e);
|
||
});
|
||
var ut = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
|
||
'_',
|
||
),
|
||
lt = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
|
||
_t = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
|
||
function ct(e, t) {
|
||
N(e, 0, 0, function () {
|
||
return this.localeData().meridiem(
|
||
this.hours(),
|
||
this.minutes(),
|
||
t,
|
||
);
|
||
});
|
||
}
|
||
function mt(e, t) {
|
||
return t._meridiemParse;
|
||
}
|
||
N('H', ['HH', 2], 0, 'hour'),
|
||
N('h', ['hh', 2], 0, function () {
|
||
return this.hours() % 12 || 12;
|
||
}),
|
||
ct('a', !0),
|
||
ct('A', !1),
|
||
O('hour', 'h'),
|
||
ae('a', mt),
|
||
ae('A', mt),
|
||
ae('H', q),
|
||
ae('h', q),
|
||
ae('HH', q, V),
|
||
ae('hh', q, V),
|
||
oe(['H', 'HH'], 3),
|
||
oe(['a', 'A'], function (e, t, n) {
|
||
(n._isPm = n._locale.isPM(e)), (n._meridiem = e);
|
||
}),
|
||
oe(['h', 'hh'], function (e, t, n) {
|
||
(t[3] = w(e)), (u(n).bigHour = !0);
|
||
});
|
||
var ht = W('Hours', !0);
|
||
N('m', ['mm', 2], 0, 'minute'),
|
||
O('minute', 'm'),
|
||
ae('m', q),
|
||
ae('mm', q, V),
|
||
oe(['m', 'mm'], 4);
|
||
var ft = W('Minutes', !1);
|
||
N('s', ['ss', 2], 0, 'second'),
|
||
O('second', 's'),
|
||
ae('s', q),
|
||
ae('ss', q, V),
|
||
oe(['s', 'ss'], 5);
|
||
var yt,
|
||
Mt = W('Seconds', !1);
|
||
for (
|
||
N('S', 0, 0, function () {
|
||
return ~~(this.millisecond() / 100);
|
||
}),
|
||
N(0, ['SS', 2], 0, function () {
|
||
return ~~(this.millisecond() / 10);
|
||
}),
|
||
N(0, ['SSS', 3], 0, 'millisecond'),
|
||
N(0, ['SSSS', 4], 0, function () {
|
||
return 10 * this.millisecond();
|
||
}),
|
||
N(0, ['SSSSS', 5], 0, function () {
|
||
return 100 * this.millisecond();
|
||
}),
|
||
N(0, ['SSSSSS', 6], 0, function () {
|
||
return 1e3 * this.millisecond();
|
||
}),
|
||
N(0, ['SSSSSSS', 7], 0, function () {
|
||
return 1e4 * this.millisecond();
|
||
}),
|
||
N(0, ['SSSSSSSS', 8], 0, function () {
|
||
return 1e5 * this.millisecond();
|
||
}),
|
||
N(0, ['SSSSSSSSS', 9], 0, function () {
|
||
return 1e6 * this.millisecond();
|
||
}),
|
||
O('millisecond', 'ms'),
|
||
ae('S', B, E),
|
||
ae('SS', B, V),
|
||
ae('SSS', B, R),
|
||
yt = 'SSSS';
|
||
yt.length <= 9;
|
||
yt += 'S'
|
||
)
|
||
ae(yt, K);
|
||
function wt(e, t) {
|
||
t[6] = w(1e3 * ('0.' + e));
|
||
}
|
||
for (yt = 'S'; yt.length <= 9; yt += 'S') oe(yt, wt);
|
||
var pt = W('Milliseconds', !1);
|
||
N('z', 0, 0, 'zoneAbbr'), N('zz', 0, 0, 'zoneName');
|
||
var Yt = f.prototype;
|
||
(Yt.add = et),
|
||
(Yt.calendar = function (e, t) {
|
||
var n = e || xe(),
|
||
i = Ee(n, this).startOf('day'),
|
||
a = this.diff(i, 'days', !0),
|
||
s =
|
||
a < -6
|
||
? 'sameElse'
|
||
: a < -1
|
||
? 'lastWeek'
|
||
: a < 0
|
||
? 'lastDay'
|
||
: a < 1
|
||
? 'sameDay'
|
||
: a < 2
|
||
? 'nextDay'
|
||
: a < 7
|
||
? 'nextWeek'
|
||
: 'sameElse';
|
||
return this.format(
|
||
(t && t[s]) || this.localeData().calendar(s, this, xe(n)),
|
||
);
|
||
}),
|
||
(Yt.clone = function () {
|
||
return new f(this);
|
||
}),
|
||
(Yt.diff = function (e, t, n) {
|
||
var i,
|
||
a,
|
||
s,
|
||
r,
|
||
o,
|
||
d,
|
||
u,
|
||
l,
|
||
_ = Ee(e, this),
|
||
c = 6e4 * (_.utcOffset() - this.utcOffset());
|
||
return (
|
||
'year' === (t = H(t)) || 'month' === t || 'quarter' === t
|
||
? ((s = this),
|
||
(u =
|
||
12 * ((r = _).year() - s.year()) +
|
||
(r.month() - s.month())),
|
||
(l = s.clone().add(u, 'months')),
|
||
r - l < 0
|
||
? ((o = s.clone().add(u - 1, 'months')),
|
||
(d = (r - l) / (l - o)))
|
||
: ((o = s.clone().add(u + 1, 'months')),
|
||
(d = (r - l) / (o - l))),
|
||
(a = -(u + d)),
|
||
'quarter' === t ? (a /= 3) : 'year' === t && (a /= 12))
|
||
: ((i = this - _),
|
||
(a =
|
||
'second' === t
|
||
? i / 1e3
|
||
: 'minute' === t
|
||
? i / 6e4
|
||
: 'hour' === t
|
||
? i / 36e5
|
||
: 'day' === t
|
||
? (i - c) / 864e5
|
||
: 'week' === t
|
||
? (i - c) / 6048e5
|
||
: i)),
|
||
n ? a : M(a)
|
||
);
|
||
}),
|
||
(Yt.endOf = function (e) {
|
||
return void 0 === (e = H(e)) || 'millisecond' === e
|
||
? this
|
||
: this.startOf(e)
|
||
.add(1, 'isoWeek' === e ? 'week' : e)
|
||
.subtract(1, 'ms');
|
||
}),
|
||
(Yt.format = function (e) {
|
||
var t = J(this, e || i.defaultFormat);
|
||
return this.localeData().postformat(t);
|
||
}),
|
||
(Yt.from = function (e, t) {
|
||
return this.isValid()
|
||
? qe({ to: this, from: e }).locale(this.locale()).humanize(!t)
|
||
: this.localeData().invalidDate();
|
||
}),
|
||
(Yt.fromNow = function (e) {
|
||
return this.from(xe(), e);
|
||
}),
|
||
(Yt.to = function (e, t) {
|
||
return this.isValid()
|
||
? qe({ from: this, to: e }).locale(this.locale()).humanize(!t)
|
||
: this.localeData().invalidDate();
|
||
}),
|
||
(Yt.toNow = function (e) {
|
||
return this.to(xe(), e);
|
||
}),
|
||
(Yt.get = x),
|
||
(Yt.invalidAt = function () {
|
||
return u(this).overflow;
|
||
}),
|
||
(Yt.isAfter = function (e, t) {
|
||
return 'millisecond' === (t = H(void 0 !== t ? t : 'millisecond'))
|
||
? +this > +(e = y(e) ? e : xe(e))
|
||
: (y(e) ? +e : +xe(e)) < +this.clone().startOf(t);
|
||
}),
|
||
(Yt.isBefore = function (e, t) {
|
||
var n;
|
||
return 'millisecond' === (t = H(void 0 !== t ? t : 'millisecond'))
|
||
? +this < +(e = y(e) ? e : xe(e))
|
||
: ((n = y(e) ? +e : +xe(e)), +this.clone().endOf(t) < n);
|
||
}),
|
||
(Yt.isBetween = function (e, t, n) {
|
||
return this.isAfter(e, n) && this.isBefore(t, n);
|
||
}),
|
||
(Yt.isSame = function (e, t) {
|
||
var n;
|
||
return 'millisecond' === (t = H(t || 'millisecond'))
|
||
? +this == +(e = y(e) ? e : xe(e))
|
||
: ((n = +xe(e)),
|
||
+this.clone().startOf(t) <= n && n <= +this.clone().endOf(t));
|
||
}),
|
||
(Yt.isValid = function () {
|
||
return l(this);
|
||
}),
|
||
(Yt.lang = at),
|
||
(Yt.locale = it),
|
||
(Yt.localeData = st),
|
||
(Yt.max = Ae),
|
||
(Yt.min = ze),
|
||
(Yt.parsingFlags = function () {
|
||
return o({}, u(this));
|
||
}),
|
||
(Yt.set = x),
|
||
(Yt.startOf = function (e) {
|
||
switch ((e = H(e))) {
|
||
case 'year':
|
||
this.month(0);
|
||
case 'quarter':
|
||
case 'month':
|
||
this.date(1);
|
||
case 'week':
|
||
case 'isoWeek':
|
||
case 'day':
|
||
this.hours(0);
|
||
case 'hour':
|
||
this.minutes(0);
|
||
case 'minute':
|
||
this.seconds(0);
|
||
case 'second':
|
||
this.milliseconds(0);
|
||
}
|
||
return (
|
||
'week' === e && this.weekday(0),
|
||
'isoWeek' === e && this.isoWeekday(1),
|
||
'quarter' === e && this.month(3 * Math.floor(this.month() / 3)),
|
||
this
|
||
);
|
||
}),
|
||
(Yt.subtract = tt),
|
||
(Yt.toArray = function () {
|
||
var e = this;
|
||
return [
|
||
e.year(),
|
||
e.month(),
|
||
e.date(),
|
||
e.hour(),
|
||
e.minute(),
|
||
e.second(),
|
||
e.millisecond(),
|
||
];
|
||
}),
|
||
(Yt.toObject = function () {
|
||
var e = this;
|
||
return {
|
||
years: e.year(),
|
||
months: e.month(),
|
||
date: e.date(),
|
||
hours: e.hours(),
|
||
minutes: e.minutes(),
|
||
seconds: e.seconds(),
|
||
milliseconds: e.milliseconds(),
|
||
};
|
||
}),
|
||
(Yt.toDate = function () {
|
||
return this._offset ? new Date(+this) : this._d;
|
||
}),
|
||
(Yt.toISOString = nt),
|
||
(Yt.toJSON = nt),
|
||
(Yt.toString = function () {
|
||
return this.clone()
|
||
.locale('en')
|
||
.format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
|
||
}),
|
||
(Yt.unix = function () {
|
||
return Math.floor(+this / 1e3);
|
||
}),
|
||
(Yt.valueOf = function () {
|
||
return +this._d - 6e4 * (this._offset || 0);
|
||
}),
|
||
(Yt.year = be),
|
||
(Yt.isLeapYear = function () {
|
||
return ke(this.year());
|
||
}),
|
||
(Yt.weekYear = function (e) {
|
||
var t = Oe(
|
||
this,
|
||
this.localeData()._week.dow,
|
||
this.localeData()._week.doy,
|
||
).year;
|
||
return null == e ? t : this.add(e - t, 'y');
|
||
}),
|
||
(Yt.isoWeekYear = function (e) {
|
||
var t = Oe(this, 1, 4).year;
|
||
return null == e ? t : this.add(e - t, 'y');
|
||
}),
|
||
(Yt.quarter = Yt.quarters = function (e) {
|
||
return null == e
|
||
? Math.ceil((this.month() + 1) / 3)
|
||
: this.month(3 * (e - 1) + (this.month() % 3));
|
||
}),
|
||
(Yt.month = he),
|
||
(Yt.daysInMonth = function () {
|
||
return le(this.year(), this.month());
|
||
}),
|
||
(Yt.week = Yt.weeks = function (e) {
|
||
var t = this.localeData().week(this);
|
||
return null == e ? t : this.add(7 * (e - t), 'd');
|
||
}),
|
||
(Yt.isoWeek = Yt.isoWeeks = function (e) {
|
||
var t = Oe(this, 1, 4).week;
|
||
return null == e ? t : this.add(7 * (e - t), 'd');
|
||
}),
|
||
(Yt.weeksInYear = function () {
|
||
var e = this.localeData()._week;
|
||
return ot(this.year(), e.dow, e.doy);
|
||
}),
|
||
(Yt.isoWeeksInYear = function () {
|
||
return ot(this.year(), 1, 4);
|
||
}),
|
||
(Yt.date = dt),
|
||
(Yt.day = Yt.days = function (e) {
|
||
var t = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
|
||
return null != e
|
||
? ((e = (function (e, t) {
|
||
return 'string' != typeof e
|
||
? e
|
||
: isNaN(e)
|
||
? 'number' == typeof (e = t.weekdaysParse(e))
|
||
? e
|
||
: null
|
||
: parseInt(e, 10);
|
||
})(e, this.localeData())),
|
||
this.add(e - t, 'd'))
|
||
: t;
|
||
}),
|
||
(Yt.weekday = function (e) {
|
||
var t = (this.day() + 7 - this.localeData()._week.dow) % 7;
|
||
return null == e ? t : this.add(e - t, 'd');
|
||
}),
|
||
(Yt.isoWeekday = function (e) {
|
||
return null == e
|
||
? this.day() || 7
|
||
: this.day(this.day() % 7 ? e : e - 7);
|
||
}),
|
||
(Yt.dayOfYear = function (e) {
|
||
var t =
|
||
Math.round(
|
||
(this.clone().startOf('day') - this.clone().startOf('year')) /
|
||
864e5,
|
||
) + 1;
|
||
return null == e ? t : this.add(e - t, 'd');
|
||
}),
|
||
(Yt.hour = Yt.hours = ht),
|
||
(Yt.minute = Yt.minutes = ft),
|
||
(Yt.second = Yt.seconds = Mt),
|
||
(Yt.millisecond = Yt.milliseconds = pt),
|
||
(Yt.utcOffset = function (e, t) {
|
||
var n,
|
||
a = this._offset || 0;
|
||
return null != e
|
||
? ('string' == typeof e && (e = Ie(e)),
|
||
Math.abs(e) < 16 && (e *= 60),
|
||
!this._isUTC && t && (n = Ve(this)),
|
||
(this._offset = e),
|
||
(this._isUTC = !0),
|
||
null != n && this.add(n, 'm'),
|
||
a !== e &&
|
||
(!t || this._changeInProgress
|
||
? Ke(this, qe(e - a, 'm'), 1, !1)
|
||
: this._changeInProgress ||
|
||
((this._changeInProgress = !0),
|
||
i.updateOffset(this, !0),
|
||
(this._changeInProgress = null))),
|
||
this)
|
||
: this._isUTC
|
||
? a
|
||
: Ve(this);
|
||
}),
|
||
(Yt.utc = function (e) {
|
||
return this.utcOffset(0, e);
|
||
}),
|
||
(Yt.local = function (e) {
|
||
return (
|
||
this._isUTC &&
|
||
(this.utcOffset(0, e),
|
||
(this._isUTC = !1),
|
||
e && this.subtract(Ve(this), 'm')),
|
||
this
|
||
);
|
||
}),
|
||
(Yt.parseZone = function () {
|
||
return (
|
||
this._tzm
|
||
? this.utcOffset(this._tzm)
|
||
: 'string' == typeof this._i && this.utcOffset(Ie(this._i)),
|
||
this
|
||
);
|
||
}),
|
||
(Yt.hasAlignedHourOffset = function (e) {
|
||
return (
|
||
(e = e ? xe(e).utcOffset() : 0),
|
||
(this.utcOffset() - e) % 60 == 0
|
||
);
|
||
}),
|
||
(Yt.isDST = function () {
|
||
return (
|
||
this.utcOffset() > this.clone().month(0).utcOffset() ||
|
||
this.utcOffset() > this.clone().month(5).utcOffset()
|
||
);
|
||
}),
|
||
(Yt.isDSTShifted = function () {
|
||
if (void 0 !== this._isDSTShifted) return this._isDSTShifted;
|
||
var e = {};
|
||
if ((m(e, this), (e = Ce(e))._a)) {
|
||
var t = e._isUTC ? d(e._a) : xe(e._a);
|
||
this._isDSTShifted = this.isValid() && p(e._a, t.toArray()) > 0;
|
||
} else this._isDSTShifted = !1;
|
||
return this._isDSTShifted;
|
||
}),
|
||
(Yt.isLocal = function () {
|
||
return !this._isUTC;
|
||
}),
|
||
(Yt.isUtcOffset = function () {
|
||
return this._isUTC;
|
||
}),
|
||
(Yt.isUtc = Re),
|
||
(Yt.isUTC = Re),
|
||
(Yt.zoneAbbr = function () {
|
||
return this._isUTC ? 'UTC' : '';
|
||
}),
|
||
(Yt.zoneName = function () {
|
||
return this._isUTC ? 'Coordinated Universal Time' : '';
|
||
}),
|
||
(Yt.dates = Me(
|
||
'dates accessor is deprecated. Use date instead.',
|
||
dt,
|
||
)),
|
||
(Yt.months = Me(
|
||
'months accessor is deprecated. Use month instead',
|
||
he,
|
||
)),
|
||
(Yt.years = Me(
|
||
'years accessor is deprecated. Use year instead',
|
||
be,
|
||
)),
|
||
(Yt.zone = Me(
|
||
'moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779',
|
||
function (e, t) {
|
||
return null != e
|
||
? ('string' != typeof e && (e = -e),
|
||
this.utcOffset(e, t),
|
||
this)
|
||
: -this.utcOffset();
|
||
},
|
||
));
|
||
var Dt = Yt;
|
||
function Lt(e) {
|
||
return e;
|
||
}
|
||
var gt = Y.prototype;
|
||
function vt(e, t, n, i) {
|
||
var a = k(),
|
||
s = d().set(i, t);
|
||
return a[n](s, e);
|
||
}
|
||
function Tt(e, t, n, i, a) {
|
||
if (
|
||
('number' == typeof e && ((t = e), (e = void 0)),
|
||
(e = e || ''),
|
||
null != t)
|
||
)
|
||
return vt(e, t, n, a);
|
||
var s,
|
||
r = [];
|
||
for (s = 0; s < i; s++) r[s] = vt(e, s, n, a);
|
||
return r;
|
||
}
|
||
(gt._calendar = {
|
||
sameDay: '[Today at] LT',
|
||
nextDay: '[Tomorrow at] LT',
|
||
nextWeek: 'dddd [at] LT',
|
||
lastDay: '[Yesterday at] LT',
|
||
lastWeek: '[Last] dddd [at] LT',
|
||
sameElse: 'L',
|
||
}),
|
||
(gt.calendar = function (e, t, n) {
|
||
var i = this._calendar[e];
|
||
return 'function' == typeof i ? i.call(t, n) : i;
|
||
}),
|
||
(gt._longDateFormat = {
|
||
LTS: 'h:mm:ss A',
|
||
LT: 'h:mm A',
|
||
L: 'MM/DD/YYYY',
|
||
LL: 'MMMM D, YYYY',
|
||
LLL: 'MMMM D, YYYY h:mm A',
|
||
LLLL: 'dddd, MMMM D, YYYY h:mm A',
|
||
}),
|
||
(gt.longDateFormat = function (e) {
|
||
var t = this._longDateFormat[e],
|
||
n = this._longDateFormat[e.toUpperCase()];
|
||
return t || !n
|
||
? t
|
||
: ((this._longDateFormat[e] = n.replace(
|
||
/MMMM|MM|DD|dddd/g,
|
||
function (e) {
|
||
return e.slice(1);
|
||
},
|
||
)),
|
||
this._longDateFormat[e]);
|
||
}),
|
||
(gt._invalidDate = 'Invalid date'),
|
||
(gt.invalidDate = function () {
|
||
return this._invalidDate;
|
||
}),
|
||
(gt._ordinal = '%d'),
|
||
(gt.ordinal = function (e) {
|
||
return this._ordinal.replace('%d', e);
|
||
}),
|
||
(gt._ordinalParse = /\d{1,2}/),
|
||
(gt.preparse = Lt),
|
||
(gt.postformat = Lt),
|
||
(gt._relativeTime = {
|
||
future: 'in %s',
|
||
past: '%s ago',
|
||
s: 'a few seconds',
|
||
m: 'a minute',
|
||
mm: '%d minutes',
|
||
h: 'an hour',
|
||
hh: '%d hours',
|
||
d: 'a day',
|
||
dd: '%d days',
|
||
M: 'a month',
|
||
MM: '%d months',
|
||
y: 'a year',
|
||
yy: '%d years',
|
||
}),
|
||
(gt.relativeTime = function (e, t, n, i) {
|
||
var a = this._relativeTime[n];
|
||
return 'function' == typeof a
|
||
? a(e, t, n, i)
|
||
: a.replace(/%d/i, e);
|
||
}),
|
||
(gt.pastFuture = function (e, t) {
|
||
var n = this._relativeTime[e > 0 ? 'future' : 'past'];
|
||
return 'function' == typeof n ? n(t) : n.replace(/%s/i, t);
|
||
}),
|
||
(gt.set = function (e) {
|
||
var t, n;
|
||
for (n in e)
|
||
'function' == typeof (t = e[n])
|
||
? (this[n] = t)
|
||
: (this['_' + n] = t);
|
||
this._ordinalParseLenient = new RegExp(
|
||
this._ordinalParse.source + '|' + /\d{1,2}/.source,
|
||
);
|
||
}),
|
||
(gt.months = function (e) {
|
||
return this._months[e.month()];
|
||
}),
|
||
(gt._months = _e),
|
||
(gt.monthsShort = function (e) {
|
||
return this._monthsShort[e.month()];
|
||
}),
|
||
(gt._monthsShort = ce),
|
||
(gt.monthsParse = function (e, t, n) {
|
||
var i, a, s;
|
||
for (
|
||
this._monthsParse ||
|
||
((this._monthsParse = []),
|
||
(this._longMonthsParse = []),
|
||
(this._shortMonthsParse = [])),
|
||
i = 0;
|
||
i < 12;
|
||
i++
|
||
) {
|
||
if (
|
||
((a = d([2e3, i])),
|
||
n &&
|
||
!this._longMonthsParse[i] &&
|
||
((this._longMonthsParse[i] = new RegExp(
|
||
'^' + this.months(a, '').replace('.', '') + '$',
|
||
'i',
|
||
)),
|
||
(this._shortMonthsParse[i] = new RegExp(
|
||
'^' + this.monthsShort(a, '').replace('.', '') + '$',
|
||
'i',
|
||
))),
|
||
n ||
|
||
this._monthsParse[i] ||
|
||
((s =
|
||
'^' +
|
||
this.months(a, '') +
|
||
'|^' +
|
||
this.monthsShort(a, '')),
|
||
(this._monthsParse[i] = new RegExp(
|
||
s.replace('.', ''),
|
||
'i',
|
||
))),
|
||
n && 'MMMM' === t && this._longMonthsParse[i].test(e))
|
||
)
|
||
return i;
|
||
if (n && 'MMM' === t && this._shortMonthsParse[i].test(e))
|
||
return i;
|
||
if (!n && this._monthsParse[i].test(e)) return i;
|
||
}
|
||
}),
|
||
(gt.week = function (e) {
|
||
return Oe(e, this._week.dow, this._week.doy).week;
|
||
}),
|
||
(gt._week = { dow: 0, doy: 6 }),
|
||
(gt.firstDayOfYear = function () {
|
||
return this._week.doy;
|
||
}),
|
||
(gt.firstDayOfWeek = function () {
|
||
return this._week.dow;
|
||
}),
|
||
(gt.weekdays = function (e) {
|
||
return this._weekdays[e.day()];
|
||
}),
|
||
(gt._weekdays = ut),
|
||
(gt.weekdaysMin = function (e) {
|
||
return this._weekdaysMin[e.day()];
|
||
}),
|
||
(gt._weekdaysMin = _t),
|
||
(gt.weekdaysShort = function (e) {
|
||
return this._weekdaysShort[e.day()];
|
||
}),
|
||
(gt._weekdaysShort = lt),
|
||
(gt.weekdaysParse = function (e) {
|
||
var t, n, i;
|
||
for (
|
||
this._weekdaysParse = this._weekdaysParse || [], t = 0;
|
||
t < 7;
|
||
t++
|
||
)
|
||
if (
|
||
(this._weekdaysParse[t] ||
|
||
((n = xe([2e3, 1]).day(t)),
|
||
(i =
|
||
'^' +
|
||
this.weekdays(n, '') +
|
||
'|^' +
|
||
this.weekdaysShort(n, '') +
|
||
'|^' +
|
||
this.weekdaysMin(n, '')),
|
||
(this._weekdaysParse[t] = new RegExp(
|
||
i.replace('.', ''),
|
||
'i',
|
||
))),
|
||
this._weekdaysParse[t].test(e))
|
||
)
|
||
return t;
|
||
}),
|
||
(gt.isPM = function (e) {
|
||
return 'p' === (e + '').toLowerCase().charAt(0);
|
||
}),
|
||
(gt._meridiemParse = /[ap]\.?m?\.?/i),
|
||
(gt.meridiem = function (e, t, n) {
|
||
return e > 11 ? (n ? 'pm' : 'PM') : n ? 'am' : 'AM';
|
||
}),
|
||
T('en', {
|
||
ordinalParse: /\d{1,2}(th|st|nd|rd)/,
|
||
ordinal: function (e) {
|
||
var t = e % 10;
|
||
return (
|
||
e +
|
||
(1 === w((e % 100) / 10)
|
||
? 'th'
|
||
: 1 === t
|
||
? 'st'
|
||
: 2 === t
|
||
? 'nd'
|
||
: 3 === t
|
||
? 'rd'
|
||
: 'th')
|
||
);
|
||
},
|
||
}),
|
||
(i.lang = Me(
|
||
'moment.lang is deprecated. Use moment.locale instead.',
|
||
T,
|
||
)),
|
||
(i.langData = Me(
|
||
'moment.langData is deprecated. Use moment.localeData instead.',
|
||
k,
|
||
));
|
||
var St = Math.abs;
|
||
function kt(e, t, n, i) {
|
||
var a = qe(t, n);
|
||
return (
|
||
(e._milliseconds += i * a._milliseconds),
|
||
(e._days += i * a._days),
|
||
(e._months += i * a._months),
|
||
e._bubble()
|
||
);
|
||
}
|
||
function bt(e) {
|
||
return e < 0 ? Math.floor(e) : Math.ceil(e);
|
||
}
|
||
function Ot(e) {
|
||
return (4800 * e) / 146097;
|
||
}
|
||
function Ht(e) {
|
||
return (146097 * e) / 4800;
|
||
}
|
||
function Ft(e) {
|
||
return function () {
|
||
return this.as(e);
|
||
};
|
||
}
|
||
var Wt = Ft('ms'),
|
||
Ct = Ft('s'),
|
||
Pt = Ft('m'),
|
||
xt = Ft('h'),
|
||
zt = Ft('d'),
|
||
At = Ft('w'),
|
||
Ut = Ft('M'),
|
||
Gt = Ft('y');
|
||
function jt(e) {
|
||
return function () {
|
||
return this._data[e];
|
||
};
|
||
}
|
||
var Nt = jt('milliseconds'),
|
||
Jt = jt('seconds'),
|
||
It = jt('minutes'),
|
||
Et = jt('hours'),
|
||
Vt = jt('days'),
|
||
Rt = jt('months'),
|
||
Zt = jt('years'),
|
||
Qt = Math.round,
|
||
qt = { s: 45, m: 45, h: 22, d: 26, M: 11 };
|
||
function Bt(e, t, n, i, a) {
|
||
return a.relativeTime(t || 1, !!n, e, i);
|
||
}
|
||
var $t = Math.abs;
|
||
function Xt() {
|
||
var e,
|
||
t,
|
||
n = $t(this._milliseconds) / 1e3,
|
||
i = $t(this._days),
|
||
a = $t(this._months);
|
||
(e = M(n / 60)), (t = M(e / 60)), (n %= 60), (e %= 60);
|
||
var s = M(a / 12),
|
||
r = (a %= 12),
|
||
o = i,
|
||
d = t,
|
||
u = e,
|
||
l = n,
|
||
_ = this.asSeconds();
|
||
return _
|
||
? (_ < 0 ? '-' : '') +
|
||
'P' +
|
||
(s ? s + 'Y' : '') +
|
||
(r ? r + 'M' : '') +
|
||
(o ? o + 'D' : '') +
|
||
(d || u || l ? 'T' : '') +
|
||
(d ? d + 'H' : '') +
|
||
(u ? u + 'M' : '') +
|
||
(l ? l + 'S' : '')
|
||
: 'P0D';
|
||
}
|
||
var Kt = Ge.prototype;
|
||
return (
|
||
(Kt.abs = function () {
|
||
var e = this._data;
|
||
return (
|
||
(this._milliseconds = St(this._milliseconds)),
|
||
(this._days = St(this._days)),
|
||
(this._months = St(this._months)),
|
||
(e.milliseconds = St(e.milliseconds)),
|
||
(e.seconds = St(e.seconds)),
|
||
(e.minutes = St(e.minutes)),
|
||
(e.hours = St(e.hours)),
|
||
(e.months = St(e.months)),
|
||
(e.years = St(e.years)),
|
||
this
|
||
);
|
||
}),
|
||
(Kt.add = function (e, t) {
|
||
return kt(this, e, t, 1);
|
||
}),
|
||
(Kt.subtract = function (e, t) {
|
||
return kt(this, e, t, -1);
|
||
}),
|
||
(Kt.as = function (e) {
|
||
var t,
|
||
n,
|
||
i = this._milliseconds;
|
||
if ('month' === (e = H(e)) || 'year' === e)
|
||
return (
|
||
(t = this._days + i / 864e5),
|
||
(n = this._months + Ot(t)),
|
||
'month' === e ? n : n / 12
|
||
);
|
||
switch (((t = this._days + Math.round(Ht(this._months))), e)) {
|
||
case 'week':
|
||
return t / 7 + i / 6048e5;
|
||
case 'day':
|
||
return t + i / 864e5;
|
||
case 'hour':
|
||
return 24 * t + i / 36e5;
|
||
case 'minute':
|
||
return 1440 * t + i / 6e4;
|
||
case 'second':
|
||
return 86400 * t + i / 1e3;
|
||
case 'millisecond':
|
||
return Math.floor(864e5 * t) + i;
|
||
default:
|
||
throw new Error('Unknown unit ' + e);
|
||
}
|
||
}),
|
||
(Kt.asMilliseconds = Wt),
|
||
(Kt.asSeconds = Ct),
|
||
(Kt.asMinutes = Pt),
|
||
(Kt.asHours = xt),
|
||
(Kt.asDays = zt),
|
||
(Kt.asWeeks = At),
|
||
(Kt.asMonths = Ut),
|
||
(Kt.asYears = Gt),
|
||
(Kt.valueOf = function () {
|
||
return (
|
||
this._milliseconds +
|
||
864e5 * this._days +
|
||
(this._months % 12) * 2592e6 +
|
||
31536e6 * w(this._months / 12)
|
||
);
|
||
}),
|
||
(Kt._bubble = function () {
|
||
var e,
|
||
t,
|
||
n,
|
||
i,
|
||
a,
|
||
s = this._milliseconds,
|
||
r = this._days,
|
||
o = this._months,
|
||
d = this._data;
|
||
return (
|
||
(s >= 0 && r >= 0 && o >= 0) ||
|
||
(s <= 0 && r <= 0 && o <= 0) ||
|
||
((s += 864e5 * bt(Ht(o) + r)), (r = 0), (o = 0)),
|
||
(d.milliseconds = s % 1e3),
|
||
(e = M(s / 1e3)),
|
||
(d.seconds = e % 60),
|
||
(t = M(e / 60)),
|
||
(d.minutes = t % 60),
|
||
(n = M(t / 60)),
|
||
(d.hours = n % 24),
|
||
(r += M(n / 24)),
|
||
(a = M(Ot(r))),
|
||
(o += a),
|
||
(r -= bt(Ht(a))),
|
||
(i = M(o / 12)),
|
||
(o %= 12),
|
||
(d.days = r),
|
||
(d.months = o),
|
||
(d.years = i),
|
||
this
|
||
);
|
||
}),
|
||
(Kt.get = function (e) {
|
||
return this[(e = H(e)) + 's']();
|
||
}),
|
||
(Kt.milliseconds = Nt),
|
||
(Kt.seconds = Jt),
|
||
(Kt.minutes = It),
|
||
(Kt.hours = Et),
|
||
(Kt.days = Vt),
|
||
(Kt.weeks = function () {
|
||
return M(this.days() / 7);
|
||
}),
|
||
(Kt.months = Rt),
|
||
(Kt.years = Zt),
|
||
(Kt.humanize = function (e) {
|
||
var t = this.localeData(),
|
||
n = (function (e, t, n) {
|
||
var i = qe(e).abs(),
|
||
a = Qt(i.as('s')),
|
||
s = Qt(i.as('m')),
|
||
r = Qt(i.as('h')),
|
||
o = Qt(i.as('d')),
|
||
d = Qt(i.as('M')),
|
||
u = Qt(i.as('y')),
|
||
l = (a < qt.s && ['s', a]) ||
|
||
(1 === s && ['m']) ||
|
||
(s < qt.m && ['mm', s]) ||
|
||
(1 === r && ['h']) ||
|
||
(r < qt.h && ['hh', r]) ||
|
||
(1 === o && ['d']) ||
|
||
(o < qt.d && ['dd', o]) ||
|
||
(1 === d && ['M']) ||
|
||
(d < qt.M && ['MM', d]) ||
|
||
(1 === u && ['y']) || ['yy', u];
|
||
return (
|
||
(l[2] = t), (l[3] = +e > 0), (l[4] = n), Bt.apply(null, l)
|
||
);
|
||
})(this, !e, t);
|
||
return e && (n = t.pastFuture(+this, n)), t.postformat(n);
|
||
}),
|
||
(Kt.toISOString = Xt),
|
||
(Kt.toString = Xt),
|
||
(Kt.toJSON = Xt),
|
||
(Kt.locale = it),
|
||
(Kt.localeData = st),
|
||
(Kt.toIsoString = Me(
|
||
'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
|
||
Xt,
|
||
)),
|
||
(Kt.lang = at),
|
||
N('X', 0, 0, 'unix'),
|
||
N('x', 0, 0, 'valueOf'),
|
||
ae('x', ee),
|
||
ae('X', /[+-]?\d+(\.\d{1,3})?/),
|
||
oe('X', function (e, t, n) {
|
||
n._d = new Date(1e3 * parseFloat(e, 10));
|
||
}),
|
||
oe('x', function (e, t, n) {
|
||
n._d = new Date(w(e));
|
||
}),
|
||
(i.version = '2.10.6'),
|
||
(t = xe),
|
||
(i.fn = Dt),
|
||
(i.min = function () {
|
||
var e = [].slice.call(arguments, 0);
|
||
return Ue('isBefore', e);
|
||
}),
|
||
(i.max = function () {
|
||
var e = [].slice.call(arguments, 0);
|
||
return Ue('isAfter', e);
|
||
}),
|
||
(i.utc = d),
|
||
(i.unix = function (e) {
|
||
return xe(1e3 * e);
|
||
}),
|
||
(i.months = function (e, t) {
|
||
return Tt(e, t, 'months', 12, 'month');
|
||
}),
|
||
(i.isDate = s),
|
||
(i.locale = T),
|
||
(i.invalid = _),
|
||
(i.duration = qe),
|
||
(i.isMoment = y),
|
||
(i.weekdays = function (e, t) {
|
||
return Tt(e, t, 'weekdays', 7, 'day');
|
||
}),
|
||
(i.parseZone = function () {
|
||
return xe.apply(null, arguments).parseZone();
|
||
}),
|
||
(i.localeData = k),
|
||
(i.isDuration = je),
|
||
(i.monthsShort = function (e, t) {
|
||
return Tt(e, t, 'monthsShort', 12, 'month');
|
||
}),
|
||
(i.weekdaysMin = function (e, t) {
|
||
return Tt(e, t, 'weekdaysMin', 7, 'day');
|
||
}),
|
||
(i.defineLocale = S),
|
||
(i.weekdaysShort = function (e, t) {
|
||
return Tt(e, t, 'weekdaysShort', 7, 'day');
|
||
}),
|
||
(i.normalizeUnits = H),
|
||
(i.relativeTimeThreshold = function (e, t) {
|
||
return (
|
||
void 0 !== qt[e] && (void 0 === t ? qt[e] : ((qt[e] = t), !0))
|
||
);
|
||
}),
|
||
i
|
||
);
|
||
})();
|
||
}.call(this, n('YuTi')(e)));
|
||
},
|
||
},
|
||
]);
|