1 ;(function (global
, factory
) {
2 typeof exports
=== 'object' && typeof module
!== 'undefined' ? module
.exports
= factory() :
3 typeof define
=== 'function' && define
.amd
? define(factory
) :
4 global
.moment
= factory()
5 }(this, (function () { 'use strict';
10 return hookCallback
.apply(null, arguments
);
13 // This is done to register the method called with moment()
14 // without creating circular dependencies.
15 function setHookCallback(callback
) {
16 hookCallback
= callback
;
19 function isArray(input
) {
21 input
instanceof Array
||
22 Object
.prototype.toString
.call(input
) === '[object Array]'
26 function isObject(input
) {
27 // IE8 will treat undefined and null as object if it wasn't for
31 Object
.prototype.toString
.call(input
) === '[object Object]'
35 function hasOwnProp(a
, b
) {
36 return Object
.prototype.hasOwnProperty
.call(a
, b
);
39 function isObjectEmpty(obj
) {
40 if (Object
.getOwnPropertyNames
) {
41 return Object
.getOwnPropertyNames(obj
).length
=== 0;
45 if (hasOwnProp(obj
, k
)) {
53 function isUndefined(input
) {
54 return input
=== void 0;
57 function isNumber(input
) {
59 typeof input
=== 'number' ||
60 Object
.prototype.toString
.call(input
) === '[object Number]'
64 function isDate(input
) {
66 input
instanceof Date
||
67 Object
.prototype.toString
.call(input
) === '[object Date]'
71 function map(arr
, fn
) {
74 for (i
= 0; i
< arr
.length
; ++i
) {
75 res
.push(fn(arr
[i
], i
));
80 function extend(a
, b
) {
82 if (hasOwnProp(b
, i
)) {
87 if (hasOwnProp(b
, 'toString')) {
88 a
.toString
= b
.toString
;
91 if (hasOwnProp(b
, 'valueOf')) {
92 a
.valueOf
= b
.valueOf
;
98 function createUTC(input
, format
, locale
, strict
) {
99 return createLocalOrUTC(input
, format
, locale
, strict
, true).utc();
102 function defaultParsingFlags() {
103 // We need to deep clone this object.
113 invalidFormat
: false,
114 userInvalidated
: false,
120 weekdayMismatch
: false,
124 function getParsingFlags(m
) {
126 m
._pf
= defaultParsingFlags();
132 if (Array
.prototype.some
) {
133 some
= Array
.prototype.some
;
135 some = function (fun
) {
136 var t
= Object(this),
137 len
= t
.length
>>> 0,
140 for (i
= 0; i
< len
; i
++) {
141 if (i
in t
&& fun
.call(this, t
[i
], i
, t
)) {
150 function isValid(m
) {
151 if (m
._isValid
== null) {
152 var flags
= getParsingFlags(m
),
153 parsedParts
= some
.call(flags
.parsedDateParts
, function (i
) {
157 !isNaN(m
._d
.getTime()) &&
158 flags
.overflow
< 0 &&
161 !flags
.invalidMonth
&&
162 !flags
.invalidWeekday
&&
163 !flags
.weekdayMismatch
&&
165 !flags
.invalidFormat
&&
166 !flags
.userInvalidated
&&
167 (!flags
.meridiem
|| (flags
.meridiem
&& parsedParts
));
172 flags
.charsLeftOver
=== 0 &&
173 flags
.unusedTokens
.length
=== 0 &&
174 flags
.bigHour
=== undefined;
177 if (Object
.isFrozen
== null || !Object
.isFrozen(m
)) {
178 m
._isValid
= isNowValid
;
186 function createInvalid(flags
) {
187 var m
= createUTC(NaN
);
189 extend(getParsingFlags(m
), flags
);
191 getParsingFlags(m
).userInvalidated
= true;
197 // Plugins that add properties should also add the key here (null value),
198 // so we can properly clone ourselves.
199 var momentProperties
= (hooks
.momentProperties
= []),
200 updateInProgress
= false;
202 function copyConfig(to
, from) {
205 if (!isUndefined(from._isAMomentObject
)) {
206 to
._isAMomentObject
= from._isAMomentObject
;
208 if (!isUndefined(from._i
)) {
211 if (!isUndefined(from._f
)) {
214 if (!isUndefined(from._l
)) {
217 if (!isUndefined(from._strict
)) {
218 to
._strict
= from._strict
;
220 if (!isUndefined(from._tzm
)) {
223 if (!isUndefined(from._isUTC
)) {
224 to
._isUTC
= from._isUTC
;
226 if (!isUndefined(from._offset
)) {
227 to
._offset
= from._offset
;
229 if (!isUndefined(from._pf
)) {
230 to
._pf
= getParsingFlags(from);
232 if (!isUndefined(from._locale
)) {
233 to
._locale
= from._locale
;
236 if (momentProperties
.length
> 0) {
237 for (i
= 0; i
< momentProperties
.length
; i
++) {
238 prop
= momentProperties
[i
];
240 if (!isUndefined(val
)) {
249 // Moment prototype object
250 function Moment(config
) {
251 copyConfig(this, config
);
252 this._d
= new Date(config
._d
!= null ? config
._d
.getTime() : NaN
);
253 if (!this.isValid()) {
254 this._d
= new Date(NaN
);
256 // Prevent infinite loop in case updateOffset creates new moment
258 if (updateInProgress
=== false) {
259 updateInProgress
= true;
260 hooks
.updateOffset(this);
261 updateInProgress
= false;
265 function isMoment(obj
) {
267 obj
instanceof Moment
|| (obj
!= null && obj
._isAMomentObject
!= null)
273 hooks
.suppressDeprecationWarnings
=== false &&
274 typeof console
!== 'undefined' &&
277 console
.warn('Deprecation warning: ' + msg
);
281 function deprecate(msg
, fn
) {
282 var firstTime
= true;
284 return extend(function () {
285 if (hooks
.deprecationHandler
!= null) {
286 hooks
.deprecationHandler(null, msg
);
293 for (i
= 0; i
< arguments
.length
; i
++) {
295 if (typeof arguments
[i
] === 'object') {
296 arg
+= '\n[' + i
+ '] ';
297 for (key
in arguments
[0]) {
298 if (hasOwnProp(arguments
[0], key
)) {
299 arg
+= key
+ ': ' + arguments
[0][key
] + ', ';
302 arg
= arg
.slice(0, -2); // Remove trailing comma and space
311 Array
.prototype.slice
.call(args
).join('') +
317 return fn
.apply(this, arguments
);
321 var deprecations
= {};
323 function deprecateSimple(name
, msg
) {
324 if (hooks
.deprecationHandler
!= null) {
325 hooks
.deprecationHandler(name
, msg
);
327 if (!deprecations
[name
]) {
329 deprecations
[name
] = true;
333 hooks
.suppressDeprecationWarnings
= false;
334 hooks
.deprecationHandler
= null;
336 function isFunction(input
) {
338 (typeof Function
!== 'undefined' && input
instanceof Function
) ||
339 Object
.prototype.toString
.call(input
) === '[object Function]'
343 function set(config
) {
346 if (hasOwnProp(config
, i
)) {
348 if (isFunction(prop
)) {
351 this['_' + i
] = prop
;
355 this._config
= config
;
356 // Lenient ordinal parsing accepts just a number in addition to
357 // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
358 // TODO: Remove "ordinalParse" fallback in next major release.
359 this._dayOfMonthOrdinalParseLenient
= new RegExp(
360 (this._dayOfMonthOrdinalParse
.source
|| this._ordinalParse
.source
) +
366 function mergeConfigs(parentConfig
, childConfig
) {
367 var res
= extend({}, parentConfig
),
369 for (prop
in childConfig
) {
370 if (hasOwnProp(childConfig
, prop
)) {
371 if (isObject(parentConfig
[prop
]) && isObject(childConfig
[prop
])) {
373 extend(res
[prop
], parentConfig
[prop
]);
374 extend(res
[prop
], childConfig
[prop
]);
375 } else if (childConfig
[prop
] != null) {
376 res
[prop
] = childConfig
[prop
];
382 for (prop
in parentConfig
) {
384 hasOwnProp(parentConfig
, prop
) &&
385 !hasOwnProp(childConfig
, prop
) &&
386 isObject(parentConfig
[prop
])
388 // make sure changes to properties don't modify parent config
389 res
[prop
] = extend({}, res
[prop
]);
395 function Locale(config
) {
396 if (config
!= null) {
406 keys = function (obj
) {
410 if (hasOwnProp(obj
, i
)) {
418 var defaultCalendar
= {
419 sameDay
: '[Today at] LT',
420 nextDay
: '[Tomorrow at] LT',
421 nextWeek
: 'dddd [at] LT',
422 lastDay
: '[Yesterday at] LT',
423 lastWeek
: '[Last] dddd [at] LT',
427 function calendar(key
, mom
, now
) {
428 var output
= this._calendar
[key
] || this._calendar
['sameElse'];
429 return isFunction(output
) ? output
.call(mom
, now
) : output
;
432 function zeroFill(number
, targetLength
, forceSign
) {
433 var absNumber
= '' + Math
.abs(number
),
434 zerosToFill
= targetLength
- absNumber
.length
,
437 (sign
? (forceSign
? '+' : '') : '-') +
438 Math
.pow(10, Math
.max(0, zerosToFill
)).toString().substr(1) +
443 var formattingTokens
= /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
444 localFormattingTokens
= /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
445 formatFunctions
= {},
446 formatTokenFunctions
= {};
451 // callback: function () { this.month() + 1 }
452 function addFormatToken(token
, padded
, ordinal
, callback
) {
454 if (typeof callback
=== 'string') {
456 return this[callback
]();
460 formatTokenFunctions
[token
] = func
;
463 formatTokenFunctions
[padded
[0]] = function () {
464 return zeroFill(func
.apply(this, arguments
), padded
[1], padded
[2]);
468 formatTokenFunctions
[ordinal
] = function () {
469 return this.localeData().ordinal(
470 func
.apply(this, arguments
),
477 function removeFormattingTokens(input
) {
478 if (input
.match(/\[[\s\S]/)) {
479 return input
.replace(/^\[|\]$/g, '');
481 return input
.replace(/\\/g
, '');
484 function makeFormatFunction(format
) {
485 var array
= format
.match(formattingTokens
),
489 for (i
= 0, length
= array
.length
; i
< length
; i
++) {
490 if (formatTokenFunctions
[array
[i
]]) {
491 array
[i
] = formatTokenFunctions
[array
[i
]];
493 array
[i
] = removeFormattingTokens(array
[i
]);
497 return function (mom
) {
500 for (i
= 0; i
< length
; i
++) {
501 output
+= isFunction(array
[i
])
502 ? array
[i
].call(mom
, format
)
509 // format date using native date object
510 function formatMoment(m
, format
) {
512 return m
.localeData().invalidDate();
515 format
= expandFormat(format
, m
.localeData());
516 formatFunctions
[format
] =
517 formatFunctions
[format
] || makeFormatFunction(format
);
519 return formatFunctions
[format
](m
);
522 function expandFormat(format
, locale
) {
525 function replaceLongDateFormatTokens(input
) {
526 return locale
.longDateFormat(input
) || input
;
529 localFormattingTokens
.lastIndex
= 0;
530 while (i
>= 0 && localFormattingTokens
.test(format
)) {
531 format
= format
.replace(
532 localFormattingTokens
,
533 replaceLongDateFormatTokens
535 localFormattingTokens
.lastIndex
= 0;
542 var defaultLongDateFormat
= {
547 LLL
: 'MMMM D, YYYY h:mm A',
548 LLLL
: 'dddd, MMMM D, YYYY h:mm A',
551 function longDateFormat(key
) {
552 var format
= this._longDateFormat
[key
],
553 formatUpper
= this._longDateFormat
[key
.toUpperCase()];
555 if (format
|| !formatUpper
) {
559 this._longDateFormat
[key
] = formatUpper
560 .match(formattingTokens
)
561 .map(function (tok
) {
574 return this._longDateFormat
[key
];
577 var defaultInvalidDate
= 'Invalid date';
579 function invalidDate() {
580 return this._invalidDate
;
583 var defaultOrdinal
= '%d',
584 defaultDayOfMonthOrdinalParse
= /\d{1,2}/;
586 function ordinal(number
) {
587 return this._ordinal
.replace('%d', number
);
590 var defaultRelativeTime
= {
609 function relativeTime(number
, withoutSuffix
, string
, isFuture
) {
610 var output
= this._relativeTime
[string
];
611 return isFunction(output
)
612 ? output(number
, withoutSuffix
, string
, isFuture
)
613 : output
.replace(/%d/i, number
);
616 function pastFuture(diff
, output
) {
617 var format
= this._relativeTime
[diff
> 0 ? 'future' : 'past'];
618 return isFunction(format
) ? format(output
) : format
.replace(/%s/i, output
);
623 function addUnitAlias(unit
, shorthand
) {
624 var lowerCase
= unit
.toLowerCase();
625 aliases
[lowerCase
] = aliases
[lowerCase
+ 's'] = aliases
[shorthand
] = unit
;
628 function normalizeUnits(units
) {
629 return typeof units
=== 'string'
630 ? aliases
[units
] || aliases
[units
.toLowerCase()]
634 function normalizeObjectUnits(inputObject
) {
635 var normalizedInput
= {},
639 for (prop
in inputObject
) {
640 if (hasOwnProp(inputObject
, prop
)) {
641 normalizedProp
= normalizeUnits(prop
);
642 if (normalizedProp
) {
643 normalizedInput
[normalizedProp
] = inputObject
[prop
];
648 return normalizedInput
;
653 function addUnitPriority(unit
, priority
) {
654 priorities
[unit
] = priority
;
657 function getPrioritizedUnits(unitsObj
) {
660 for (u
in unitsObj
) {
661 if (hasOwnProp(unitsObj
, u
)) {
662 units
.push({ unit
: u
, priority
: priorities
[u
] });
665 units
.sort(function (a
, b
) {
666 return a
.priority
- b
.priority
;
671 function isLeapYear(year
) {
672 return (year
% 4 === 0 && year
% 100 !== 0) || year
% 400 === 0;
675 function absFloor(number
) {
678 return Math
.ceil(number
) || 0;
680 return Math
.floor(number
);
684 function toInt(argumentForCoercion
) {
685 var coercedNumber
= +argumentForCoercion
,
688 if (coercedNumber
!== 0 && isFinite(coercedNumber
)) {
689 value
= absFloor(coercedNumber
);
695 function makeGetSet(unit
, keepTime
) {
696 return function (value
) {
698 set$1(this, unit
, value
);
699 hooks
.updateOffset(this, keepTime
);
702 return get(this, unit
);
707 function get(mom
, unit
) {
709 ? mom
._d
['get' + (mom
._isUTC
? 'UTC' : '') + unit
]()
713 function set$1(mom
, unit
, value
) {
714 if (mom
.isValid() && !isNaN(value
)) {
716 unit
=== 'FullYear' &&
717 isLeapYear(mom
.year()) &&
721 value
= toInt(value
);
722 mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + unit
](
725 daysInMonth(value
, mom
.month())
728 mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + unit
](value
);
735 function stringGet(units
) {
736 units
= normalizeUnits(units
);
737 if (isFunction(this[units
])) {
738 return this[units
]();
743 function stringSet(units
, value
) {
744 if (typeof units
=== 'object') {
745 units
= normalizeObjectUnits(units
);
746 var prioritized
= getPrioritizedUnits(units
),
748 for (i
= 0; i
< prioritized
.length
; i
++) {
749 this[prioritized
[i
].unit
](units
[prioritized
[i
].unit
]);
752 units
= normalizeUnits(units
);
753 if (isFunction(this[units
])) {
754 return this[units
](value
);
760 var match1
= /\d/, // 0 - 9
761 match2
= /\d\d/, // 00 - 99
762 match3
= /\d{3}/, // 000 - 999
763 match4
= /\d{4}/, // 0000 - 9999
764 match6
= /[+-]?\d{6}/, // -999999 - 999999
765 match1to2
= /\d\d?/, // 0 - 99
766 match3to4
= /\d\d\d\d?/, // 999 - 9999
767 match5to6
= /\d\d\d\d\d\d?/, // 99999 - 999999
768 match1to3
= /\d{1,3}/, // 0 - 999
769 match1to4
= /\d{1,4}/, // 0 - 9999
770 match1to6
= /[+-]?\d{1,6}/, // -999999 - 999999
771 matchUnsigned
= /\d+/, // 0 - inf
772 matchSigned
= /[+-]?\d+/, // -inf - inf
773 matchOffset
= /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
774 matchShortOffset
= /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
775 matchTimestamp
= /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
776 // any word (or two) characters or numbers including two/three word month in arabic.
777 // includes scottish gaelic two word and hyphenated months
778 matchWord
= /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
783 function addRegexToken(token
, regex
, strictRegex
) {
784 regexes
[token
] = isFunction(regex
)
786 : function (isStrict
, localeData
) {
787 return isStrict
&& strictRegex
? strictRegex
: regex
;
791 function getParseRegexForToken(token
, config
) {
792 if (!hasOwnProp(regexes
, token
)) {
793 return new RegExp(unescapeFormat(token
));
796 return regexes
[token
](config
._strict
, config
._locale
);
799 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
800 function unescapeFormat(s
) {
804 .replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (
811 return p1
|| p2
|| p3
|| p4
;
816 function regexEscape(s
) {
817 return s
.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
822 function addParseToken(token
, callback
) {
825 if (typeof token
=== 'string') {
828 if (isNumber(callback
)) {
829 func = function (input
, array
) {
830 array
[callback
] = toInt(input
);
833 for (i
= 0; i
< token
.length
; i
++) {
834 tokens
[token
[i
]] = func
;
838 function addWeekParseToken(token
, callback
) {
839 addParseToken(token
, function (input
, array
, config
, token
) {
840 config
._w
= config
._w
|| {};
841 callback(input
, config
._w
, config
, token
);
845 function addTimeToArrayFromToken(token
, input
, config
) {
846 if (input
!= null && hasOwnProp(tokens
, token
)) {
847 tokens
[token
](input
, config
._a
, config
, token
);
862 return ((n
% x
) + x
) % x
;
867 if (Array
.prototype.indexOf
) {
868 indexOf
= Array
.prototype.indexOf
;
870 indexOf = function (o
) {
873 for (i
= 0; i
< this.length
; ++i
) {
882 function daysInMonth(year
, month
) {
883 if (isNaN(year
) || isNaN(month
)) {
886 var modMonth
= mod(month
, 12);
887 year
+= (month
- modMonth
) / 12;
888 return modMonth
=== 1
892 : 31 - ((modMonth
% 7) % 2);
897 addFormatToken('M', ['MM', 2], 'Mo', function () {
898 return this.month() + 1;
901 addFormatToken('MMM', 0, 0, function (format
) {
902 return this.localeData().monthsShort(this, format
);
905 addFormatToken('MMMM', 0, 0, function (format
) {
906 return this.localeData().months(this, format
);
911 addUnitAlias('month', 'M');
915 addUnitPriority('month', 8);
919 addRegexToken('M', match1to2
);
920 addRegexToken('MM', match1to2
, match2
);
921 addRegexToken('MMM', function (isStrict
, locale
) {
922 return locale
.monthsShortRegex(isStrict
);
924 addRegexToken('MMMM', function (isStrict
, locale
) {
925 return locale
.monthsRegex(isStrict
);
928 addParseToken(['M', 'MM'], function (input
, array
) {
929 array
[MONTH
] = toInt(input
) - 1;
932 addParseToken(['MMM', 'MMMM'], function (input
, array
, config
, token
) {
933 var month
= config
._locale
.monthsParse(input
, token
, config
._strict
);
934 // if we didn't find a month name, mark the date as invalid.
936 array
[MONTH
] = month
;
938 getParsingFlags(config
).invalidMonth
= input
;
944 var defaultLocaleMonths
= 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
947 defaultLocaleMonthsShort
= 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split(
950 MONTHS_IN_FORMAT
= /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
951 defaultMonthsShortRegex
= matchWord
,
952 defaultMonthsRegex
= matchWord
;
954 function localeMonths(m
, format
) {
956 return isArray(this._months
)
958 : this._months
['standalone'];
960 return isArray(this._months
)
961 ? this._months
[m
.month()]
963 (this._months
.isFormat
|| MONTHS_IN_FORMAT
).test(format
)
969 function localeMonthsShort(m
, format
) {
971 return isArray(this._monthsShort
)
973 : this._monthsShort
['standalone'];
975 return isArray(this._monthsShort
)
976 ? this._monthsShort
[m
.month()]
978 MONTHS_IN_FORMAT
.test(format
) ? 'format' : 'standalone'
982 function handleStrictParse(monthName
, format
, strict
) {
986 llc
= monthName
.toLocaleLowerCase();
987 if (!this._monthsParse
) {
989 this._monthsParse
= [];
990 this._longMonthsParse
= [];
991 this._shortMonthsParse
= [];
992 for (i
= 0; i
< 12; ++i
) {
993 mom
= createUTC([2000, i
]);
994 this._shortMonthsParse
[i
] = this.monthsShort(
997 ).toLocaleLowerCase();
998 this._longMonthsParse
[i
] = this.months(mom
, '').toLocaleLowerCase();
1003 if (format
=== 'MMM') {
1004 ii
= indexOf
.call(this._shortMonthsParse
, llc
);
1005 return ii
!== -1 ? ii
: null;
1007 ii
= indexOf
.call(this._longMonthsParse
, llc
);
1008 return ii
!== -1 ? ii
: null;
1011 if (format
=== 'MMM') {
1012 ii
= indexOf
.call(this._shortMonthsParse
, llc
);
1016 ii
= indexOf
.call(this._longMonthsParse
, llc
);
1017 return ii
!== -1 ? ii
: null;
1019 ii
= indexOf
.call(this._longMonthsParse
, llc
);
1023 ii
= indexOf
.call(this._shortMonthsParse
, llc
);
1024 return ii
!== -1 ? ii
: null;
1029 function localeMonthsParse(monthName
, format
, strict
) {
1032 if (this._monthsParseExact
) {
1033 return handleStrictParse
.call(this, monthName
, format
, strict
);
1036 if (!this._monthsParse
) {
1037 this._monthsParse
= [];
1038 this._longMonthsParse
= [];
1039 this._shortMonthsParse
= [];
1042 // TODO: add sorting
1043 // Sorting makes sure if one month (or abbr) is a prefix of another
1044 // see sorting in computeMonthsParse
1045 for (i
= 0; i
< 12; i
++) {
1046 // make the regex if we don't have it already
1047 mom
= createUTC([2000, i
]);
1048 if (strict
&& !this._longMonthsParse
[i
]) {
1049 this._longMonthsParse
[i
] = new RegExp(
1050 '^' + this.months(mom
, '').replace('.', '') + '$',
1053 this._shortMonthsParse
[i
] = new RegExp(
1054 '^' + this.monthsShort(mom
, '').replace('.', '') + '$',
1058 if (!strict
&& !this._monthsParse
[i
]) {
1060 '^' + this.months(mom
, '') + '|^' + this.monthsShort(mom
, '');
1061 this._monthsParse
[i
] = new RegExp(regex
.replace('.', ''), 'i');
1066 format
=== 'MMMM' &&
1067 this._longMonthsParse
[i
].test(monthName
)
1073 this._shortMonthsParse
[i
].test(monthName
)
1076 } else if (!strict
&& this._monthsParse
[i
].test(monthName
)) {
1084 function setMonth(mom
, value
) {
1087 if (!mom
.isValid()) {
1092 if (typeof value
=== 'string') {
1093 if (/^\d+$/.test(value
)) {
1094 value
= toInt(value
);
1096 value
= mom
.localeData().monthsParse(value
);
1097 // TODO: Another silent failure?
1098 if (!isNumber(value
)) {
1104 dayOfMonth
= Math
.min(mom
.date(), daysInMonth(mom
.year(), value
));
1105 mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + 'Month'](value
, dayOfMonth
);
1109 function getSetMonth(value
) {
1110 if (value
!= null) {
1111 setMonth(this, value
);
1112 hooks
.updateOffset(this, true);
1115 return get(this, 'Month');
1119 function getDaysInMonth() {
1120 return daysInMonth(this.year(), this.month());
1123 function monthsShortRegex(isStrict
) {
1124 if (this._monthsParseExact
) {
1125 if (!hasOwnProp(this, '_monthsRegex')) {
1126 computeMonthsParse
.call(this);
1129 return this._monthsShortStrictRegex
;
1131 return this._monthsShortRegex
;
1134 if (!hasOwnProp(this, '_monthsShortRegex')) {
1135 this._monthsShortRegex
= defaultMonthsShortRegex
;
1137 return this._monthsShortStrictRegex
&& isStrict
1138 ? this._monthsShortStrictRegex
1139 : this._monthsShortRegex
;
1143 function monthsRegex(isStrict
) {
1144 if (this._monthsParseExact
) {
1145 if (!hasOwnProp(this, '_monthsRegex')) {
1146 computeMonthsParse
.call(this);
1149 return this._monthsStrictRegex
;
1151 return this._monthsRegex
;
1154 if (!hasOwnProp(this, '_monthsRegex')) {
1155 this._monthsRegex
= defaultMonthsRegex
;
1157 return this._monthsStrictRegex
&& isStrict
1158 ? this._monthsStrictRegex
1159 : this._monthsRegex
;
1163 function computeMonthsParse() {
1164 function cmpLenRev(a
, b
) {
1165 return b
.length
- a
.length
;
1168 var shortPieces
= [],
1173 for (i
= 0; i
< 12; i
++) {
1174 // make the regex if we don't have it already
1175 mom
= createUTC([2000, i
]);
1176 shortPieces
.push(this.monthsShort(mom
, ''));
1177 longPieces
.push(this.months(mom
, ''));
1178 mixedPieces
.push(this.months(mom
, ''));
1179 mixedPieces
.push(this.monthsShort(mom
, ''));
1181 // Sorting makes sure if one month (or abbr) is a prefix of another it
1182 // will match the longer piece.
1183 shortPieces
.sort(cmpLenRev
);
1184 longPieces
.sort(cmpLenRev
);
1185 mixedPieces
.sort(cmpLenRev
);
1186 for (i
= 0; i
< 12; i
++) {
1187 shortPieces
[i
] = regexEscape(shortPieces
[i
]);
1188 longPieces
[i
] = regexEscape(longPieces
[i
]);
1190 for (i
= 0; i
< 24; i
++) {
1191 mixedPieces
[i
] = regexEscape(mixedPieces
[i
]);
1194 this._monthsRegex
= new RegExp('^(' + mixedPieces
.join('|') + ')', 'i');
1195 this._monthsShortRegex
= this._monthsRegex
;
1196 this._monthsStrictRegex
= new RegExp(
1197 '^(' + longPieces
.join('|') + ')',
1200 this._monthsShortStrictRegex
= new RegExp(
1201 '^(' + shortPieces
.join('|') + ')',
1208 addFormatToken('Y', 0, 0, function () {
1209 var y
= this.year();
1210 return y
<= 9999 ? zeroFill(y
, 4) : '+' + y
;
1213 addFormatToken(0, ['YY', 2], 0, function () {
1214 return this.year() % 100;
1217 addFormatToken(0, ['YYYY', 4], 0, 'year');
1218 addFormatToken(0, ['YYYYY', 5], 0, 'year');
1219 addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
1223 addUnitAlias('year', 'y');
1227 addUnitPriority('year', 1);
1231 addRegexToken('Y', matchSigned
);
1232 addRegexToken('YY', match1to2
, match2
);
1233 addRegexToken('YYYY', match1to4
, match4
);
1234 addRegexToken('YYYYY', match1to6
, match6
);
1235 addRegexToken('YYYYYY', match1to6
, match6
);
1237 addParseToken(['YYYYY', 'YYYYYY'], YEAR
);
1238 addParseToken('YYYY', function (input
, array
) {
1240 input
.length
=== 2 ? hooks
.parseTwoDigitYear(input
) : toInt(input
);
1242 addParseToken('YY', function (input
, array
) {
1243 array
[YEAR
] = hooks
.parseTwoDigitYear(input
);
1245 addParseToken('Y', function (input
, array
) {
1246 array
[YEAR
] = parseInt(input
, 10);
1251 function daysInYear(year
) {
1252 return isLeapYear(year
) ? 366 : 365;
1257 hooks
.parseTwoDigitYear = function (input
) {
1258 return toInt(input
) + (toInt(input
) > 68 ? 1900 : 2000);
1263 var getSetYear
= makeGetSet('FullYear', true);
1265 function getIsLeapYear() {
1266 return isLeapYear(this.year());
1269 function createDate(y
, m
, d
, h
, M
, s
, ms
) {
1270 // can't just apply() to create a date:
1271 // https://stackoverflow.com/q/181348
1273 // the date constructor remaps years 0-99 to 1900-1999
1274 if (y
< 100 && y
>= 0) {
1275 // preserve leap years using a full 400 year cycle, then reset
1276 date
= new Date(y
+ 400, m
, d
, h
, M
, s
, ms
);
1277 if (isFinite(date
.getFullYear())) {
1278 date
.setFullYear(y
);
1281 date
= new Date(y
, m
, d
, h
, M
, s
, ms
);
1287 function createUTCDate(y
) {
1289 // the Date.UTC function remaps years 0-99 to 1900-1999
1290 if (y
< 100 && y
>= 0) {
1291 args
= Array
.prototype.slice
.call(arguments
);
1292 // preserve leap years using a full 400 year cycle, then reset
1294 date
= new Date(Date
.UTC
.apply(null, args
));
1295 if (isFinite(date
.getUTCFullYear())) {
1296 date
.setUTCFullYear(y
);
1299 date
= new Date(Date
.UTC
.apply(null, arguments
));
1305 // start-of-first-week - start-of-year
1306 function firstWeekOffset(year
, dow
, doy
) {
1307 var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1308 fwd
= 7 + dow
- doy
,
1309 // first-week day local weekday -- which local weekday is fwd
1310 fwdlw
= (7 + createUTCDate(year
, 0, fwd
).getUTCDay() - dow
) % 7;
1312 return -fwdlw
+ fwd
- 1;
1315 // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1316 function dayOfYearFromWeeks(year
, week
, weekday
, dow
, doy
) {
1317 var localWeekday
= (7 + weekday
- dow
) % 7,
1318 weekOffset
= firstWeekOffset(year
, dow
, doy
),
1319 dayOfYear
= 1 + 7 * (week
- 1) + localWeekday
+ weekOffset
,
1323 if (dayOfYear
<= 0) {
1325 resDayOfYear
= daysInYear(resYear
) + dayOfYear
;
1326 } else if (dayOfYear
> daysInYear(year
)) {
1328 resDayOfYear
= dayOfYear
- daysInYear(year
);
1331 resDayOfYear
= dayOfYear
;
1336 dayOfYear
: resDayOfYear
,
1340 function weekOfYear(mom
, dow
, doy
) {
1341 var weekOffset
= firstWeekOffset(mom
.year(), dow
, doy
),
1342 week
= Math
.floor((mom
.dayOfYear() - weekOffset
- 1) / 7) + 1,
1347 resYear
= mom
.year() - 1;
1348 resWeek
= week
+ weeksInYear(resYear
, dow
, doy
);
1349 } else if (week
> weeksInYear(mom
.year(), dow
, doy
)) {
1350 resWeek
= week
- weeksInYear(mom
.year(), dow
, doy
);
1351 resYear
= mom
.year() + 1;
1353 resYear
= mom
.year();
1363 function weeksInYear(year
, dow
, doy
) {
1364 var weekOffset
= firstWeekOffset(year
, dow
, doy
),
1365 weekOffsetNext
= firstWeekOffset(year
+ 1, dow
, doy
);
1366 return (daysInYear(year
) - weekOffset
+ weekOffsetNext
) / 7;
1371 addFormatToken('w', ['ww', 2], 'wo', 'week');
1372 addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1376 addUnitAlias('week', 'w');
1377 addUnitAlias('isoWeek', 'W');
1381 addUnitPriority('week', 5);
1382 addUnitPriority('isoWeek', 5);
1386 addRegexToken('w', match1to2
);
1387 addRegexToken('ww', match1to2
, match2
);
1388 addRegexToken('W', match1to2
);
1389 addRegexToken('WW', match1to2
, match2
);
1391 addWeekParseToken(['w', 'ww', 'W', 'WW'], function (
1397 week
[token
.substr(0, 1)] = toInt(input
);
1404 function localeWeek(mom
) {
1405 return weekOfYear(mom
, this._week
.dow
, this._week
.doy
).week
;
1408 var defaultLocaleWeek
= {
1409 dow
: 0, // Sunday is the first day of the week.
1410 doy
: 6, // The week that contains Jan 6th is the first week of the year.
1413 function localeFirstDayOfWeek() {
1414 return this._week
.dow
;
1417 function localeFirstDayOfYear() {
1418 return this._week
.doy
;
1423 function getSetWeek(input
) {
1424 var week
= this.localeData().week(this);
1425 return input
== null ? week
: this.add((input
- week
) * 7, 'd');
1428 function getSetISOWeek(input
) {
1429 var week
= weekOfYear(this, 1, 4).week
;
1430 return input
== null ? week
: this.add((input
- week
) * 7, 'd');
1435 addFormatToken('d', 0, 'do', 'day');
1437 addFormatToken('dd', 0, 0, function (format
) {
1438 return this.localeData().weekdaysMin(this, format
);
1441 addFormatToken('ddd', 0, 0, function (format
) {
1442 return this.localeData().weekdaysShort(this, format
);
1445 addFormatToken('dddd', 0, 0, function (format
) {
1446 return this.localeData().weekdays(this, format
);
1449 addFormatToken('e', 0, 0, 'weekday');
1450 addFormatToken('E', 0, 0, 'isoWeekday');
1454 addUnitAlias('day', 'd');
1455 addUnitAlias('weekday', 'e');
1456 addUnitAlias('isoWeekday', 'E');
1459 addUnitPriority('day', 11);
1460 addUnitPriority('weekday', 11);
1461 addUnitPriority('isoWeekday', 11);
1465 addRegexToken('d', match1to2
);
1466 addRegexToken('e', match1to2
);
1467 addRegexToken('E', match1to2
);
1468 addRegexToken('dd', function (isStrict
, locale
) {
1469 return locale
.weekdaysMinRegex(isStrict
);
1471 addRegexToken('ddd', function (isStrict
, locale
) {
1472 return locale
.weekdaysShortRegex(isStrict
);
1474 addRegexToken('dddd', function (isStrict
, locale
) {
1475 return locale
.weekdaysRegex(isStrict
);
1478 addWeekParseToken(['dd', 'ddd', 'dddd'], function (input
, week
, config
, token
) {
1479 var weekday
= config
._locale
.weekdaysParse(input
, token
, config
._strict
);
1480 // if we didn't get a weekday name, mark the date as invalid
1481 if (weekday
!= null) {
1484 getParsingFlags(config
).invalidWeekday
= input
;
1488 addWeekParseToken(['d', 'e', 'E'], function (input
, week
, config
, token
) {
1489 week
[token
] = toInt(input
);
1494 function parseWeekday(input
, locale
) {
1495 if (typeof input
!== 'string') {
1499 if (!isNaN(input
)) {
1500 return parseInt(input
, 10);
1503 input
= locale
.weekdaysParse(input
);
1504 if (typeof input
=== 'number') {
1511 function parseIsoWeekday(input
, locale
) {
1512 if (typeof input
=== 'string') {
1513 return locale
.weekdaysParse(input
) % 7 || 7;
1515 return isNaN(input
) ? null : input
;
1519 function shiftWeekdays(ws
, n
) {
1520 return ws
.slice(n
, 7).concat(ws
.slice(0, n
));
1523 var defaultLocaleWeekdays
= 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
1526 defaultLocaleWeekdaysShort
= 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
1527 defaultLocaleWeekdaysMin
= 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
1528 defaultWeekdaysRegex
= matchWord
,
1529 defaultWeekdaysShortRegex
= matchWord
,
1530 defaultWeekdaysMinRegex
= matchWord
;
1532 function localeWeekdays(m
, format
) {
1533 var weekdays
= isArray(this._weekdays
)
1536 m
&& m
!== true && this._weekdays
.isFormat
.test(format
)
1541 ? shiftWeekdays(weekdays
, this._week
.dow
)
1547 function localeWeekdaysShort(m
) {
1549 ? shiftWeekdays(this._weekdaysShort
, this._week
.dow
)
1551 ? this._weekdaysShort
[m
.day()]
1552 : this._weekdaysShort
;
1555 function localeWeekdaysMin(m
) {
1557 ? shiftWeekdays(this._weekdaysMin
, this._week
.dow
)
1559 ? this._weekdaysMin
[m
.day()]
1560 : this._weekdaysMin
;
1563 function handleStrictParse
$1(weekdayName
, format
, strict
) {
1567 llc
= weekdayName
.toLocaleLowerCase();
1568 if (!this._weekdaysParse
) {
1569 this._weekdaysParse
= [];
1570 this._shortWeekdaysParse
= [];
1571 this._minWeekdaysParse
= [];
1573 for (i
= 0; i
< 7; ++i
) {
1574 mom
= createUTC([2000, 1]).day(i
);
1575 this._minWeekdaysParse
[i
] = this.weekdaysMin(
1578 ).toLocaleLowerCase();
1579 this._shortWeekdaysParse
[i
] = this.weekdaysShort(
1582 ).toLocaleLowerCase();
1583 this._weekdaysParse
[i
] = this.weekdays(mom
, '').toLocaleLowerCase();
1588 if (format
=== 'dddd') {
1589 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1590 return ii
!== -1 ? ii
: null;
1591 } else if (format
=== 'ddd') {
1592 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1593 return ii
!== -1 ? ii
: null;
1595 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1596 return ii
!== -1 ? ii
: null;
1599 if (format
=== 'dddd') {
1600 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1604 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1608 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1609 return ii
!== -1 ? ii
: null;
1610 } else if (format
=== 'ddd') {
1611 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1615 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1619 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1620 return ii
!== -1 ? ii
: null;
1622 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1626 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1630 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1631 return ii
!== -1 ? ii
: null;
1636 function localeWeekdaysParse(weekdayName
, format
, strict
) {
1639 if (this._weekdaysParseExact
) {
1640 return handleStrictParse
$1.call(this, weekdayName
, format
, strict
);
1643 if (!this._weekdaysParse
) {
1644 this._weekdaysParse
= [];
1645 this._minWeekdaysParse
= [];
1646 this._shortWeekdaysParse
= [];
1647 this._fullWeekdaysParse
= [];
1650 for (i
= 0; i
< 7; i
++) {
1651 // make the regex if we don't have it already
1653 mom
= createUTC([2000, 1]).day(i
);
1654 if (strict
&& !this._fullWeekdaysParse
[i
]) {
1655 this._fullWeekdaysParse
[i
] = new RegExp(
1656 '^' + this.weekdays(mom
, '').replace('.', '\\.?') + '$',
1659 this._shortWeekdaysParse
[i
] = new RegExp(
1660 '^' + this.weekdaysShort(mom
, '').replace('.', '\\.?') + '$',
1663 this._minWeekdaysParse
[i
] = new RegExp(
1664 '^' + this.weekdaysMin(mom
, '').replace('.', '\\.?') + '$',
1668 if (!this._weekdaysParse
[i
]) {
1671 this.weekdays(mom
, '') +
1673 this.weekdaysShort(mom
, '') +
1675 this.weekdaysMin(mom
, '');
1676 this._weekdaysParse
[i
] = new RegExp(regex
.replace('.', ''), 'i');
1681 format
=== 'dddd' &&
1682 this._fullWeekdaysParse
[i
].test(weekdayName
)
1688 this._shortWeekdaysParse
[i
].test(weekdayName
)
1694 this._minWeekdaysParse
[i
].test(weekdayName
)
1697 } else if (!strict
&& this._weekdaysParse
[i
].test(weekdayName
)) {
1705 function getSetDayOfWeek(input
) {
1706 if (!this.isValid()) {
1707 return input
!= null ? this : NaN
;
1709 var day
= this._isUTC
? this._d
.getUTCDay() : this._d
.getDay();
1710 if (input
!= null) {
1711 input
= parseWeekday(input
, this.localeData());
1712 return this.add(input
- day
, 'd');
1718 function getSetLocaleDayOfWeek(input
) {
1719 if (!this.isValid()) {
1720 return input
!= null ? this : NaN
;
1722 var weekday
= (this.day() + 7 - this.localeData()._week
.dow
) % 7;
1723 return input
== null ? weekday
: this.add(input
- weekday
, 'd');
1726 function getSetISODayOfWeek(input
) {
1727 if (!this.isValid()) {
1728 return input
!= null ? this : NaN
;
1731 // behaves the same as moment#day except
1732 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1733 // as a setter, sunday should belong to the previous week.
1735 if (input
!= null) {
1736 var weekday
= parseIsoWeekday(input
, this.localeData());
1737 return this.day(this.day() % 7 ? weekday
: weekday
- 7);
1739 return this.day() || 7;
1743 function weekdaysRegex(isStrict
) {
1744 if (this._weekdaysParseExact
) {
1745 if (!hasOwnProp(this, '_weekdaysRegex')) {
1746 computeWeekdaysParse
.call(this);
1749 return this._weekdaysStrictRegex
;
1751 return this._weekdaysRegex
;
1754 if (!hasOwnProp(this, '_weekdaysRegex')) {
1755 this._weekdaysRegex
= defaultWeekdaysRegex
;
1757 return this._weekdaysStrictRegex
&& isStrict
1758 ? this._weekdaysStrictRegex
1759 : this._weekdaysRegex
;
1763 function weekdaysShortRegex(isStrict
) {
1764 if (this._weekdaysParseExact
) {
1765 if (!hasOwnProp(this, '_weekdaysRegex')) {
1766 computeWeekdaysParse
.call(this);
1769 return this._weekdaysShortStrictRegex
;
1771 return this._weekdaysShortRegex
;
1774 if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1775 this._weekdaysShortRegex
= defaultWeekdaysShortRegex
;
1777 return this._weekdaysShortStrictRegex
&& isStrict
1778 ? this._weekdaysShortStrictRegex
1779 : this._weekdaysShortRegex
;
1783 function weekdaysMinRegex(isStrict
) {
1784 if (this._weekdaysParseExact
) {
1785 if (!hasOwnProp(this, '_weekdaysRegex')) {
1786 computeWeekdaysParse
.call(this);
1789 return this._weekdaysMinStrictRegex
;
1791 return this._weekdaysMinRegex
;
1794 if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1795 this._weekdaysMinRegex
= defaultWeekdaysMinRegex
;
1797 return this._weekdaysMinStrictRegex
&& isStrict
1798 ? this._weekdaysMinStrictRegex
1799 : this._weekdaysMinRegex
;
1803 function computeWeekdaysParse() {
1804 function cmpLenRev(a
, b
) {
1805 return b
.length
- a
.length
;
1817 for (i
= 0; i
< 7; i
++) {
1818 // make the regex if we don't have it already
1819 mom
= createUTC([2000, 1]).day(i
);
1820 minp
= regexEscape(this.weekdaysMin(mom
, ''));
1821 shortp
= regexEscape(this.weekdaysShort(mom
, ''));
1822 longp
= regexEscape(this.weekdays(mom
, ''));
1823 minPieces
.push(minp
);
1824 shortPieces
.push(shortp
);
1825 longPieces
.push(longp
);
1826 mixedPieces
.push(minp
);
1827 mixedPieces
.push(shortp
);
1828 mixedPieces
.push(longp
);
1830 // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1831 // will match the longer piece.
1832 minPieces
.sort(cmpLenRev
);
1833 shortPieces
.sort(cmpLenRev
);
1834 longPieces
.sort(cmpLenRev
);
1835 mixedPieces
.sort(cmpLenRev
);
1837 this._weekdaysRegex
= new RegExp('^(' + mixedPieces
.join('|') + ')', 'i');
1838 this._weekdaysShortRegex
= this._weekdaysRegex
;
1839 this._weekdaysMinRegex
= this._weekdaysRegex
;
1841 this._weekdaysStrictRegex
= new RegExp(
1842 '^(' + longPieces
.join('|') + ')',
1845 this._weekdaysShortStrictRegex
= new RegExp(
1846 '^(' + shortPieces
.join('|') + ')',
1849 this._weekdaysMinStrictRegex
= new RegExp(
1850 '^(' + minPieces
.join('|') + ')',
1857 function hFormat() {
1858 return this.hours() % 12 || 12;
1861 function kFormat() {
1862 return this.hours() || 24;
1865 addFormatToken('H', ['HH', 2], 0, 'hour');
1866 addFormatToken('h', ['hh', 2], 0, hFormat
);
1867 addFormatToken('k', ['kk', 2], 0, kFormat
);
1869 addFormatToken('hmm', 0, 0, function () {
1870 return '' + hFormat
.apply(this) + zeroFill(this.minutes(), 2);
1873 addFormatToken('hmmss', 0, 0, function () {
1876 hFormat
.apply(this) +
1877 zeroFill(this.minutes(), 2) +
1878 zeroFill(this.seconds(), 2)
1882 addFormatToken('Hmm', 0, 0, function () {
1883 return '' + this.hours() + zeroFill(this.minutes(), 2);
1886 addFormatToken('Hmmss', 0, 0, function () {
1890 zeroFill(this.minutes(), 2) +
1891 zeroFill(this.seconds(), 2)
1895 function meridiem(token
, lowercase
) {
1896 addFormatToken(token
, 0, 0, function () {
1897 return this.localeData().meridiem(
1905 meridiem('a', true);
1906 meridiem('A', false);
1910 addUnitAlias('hour', 'h');
1913 addUnitPriority('hour', 13);
1917 function matchMeridiem(isStrict
, locale
) {
1918 return locale
._meridiemParse
;
1921 addRegexToken('a', matchMeridiem
);
1922 addRegexToken('A', matchMeridiem
);
1923 addRegexToken('H', match1to2
);
1924 addRegexToken('h', match1to2
);
1925 addRegexToken('k', match1to2
);
1926 addRegexToken('HH', match1to2
, match2
);
1927 addRegexToken('hh', match1to2
, match2
);
1928 addRegexToken('kk', match1to2
, match2
);
1930 addRegexToken('hmm', match3to4
);
1931 addRegexToken('hmmss', match5to6
);
1932 addRegexToken('Hmm', match3to4
);
1933 addRegexToken('Hmmss', match5to6
);
1935 addParseToken(['H', 'HH'], HOUR
);
1936 addParseToken(['k', 'kk'], function (input
, array
, config
) {
1937 var kInput
= toInt(input
);
1938 array
[HOUR
] = kInput
=== 24 ? 0 : kInput
;
1940 addParseToken(['a', 'A'], function (input
, array
, config
) {
1941 config
._isPm
= config
._locale
.isPM(input
);
1942 config
._meridiem
= input
;
1944 addParseToken(['h', 'hh'], function (input
, array
, config
) {
1945 array
[HOUR
] = toInt(input
);
1946 getParsingFlags(config
).bigHour
= true;
1948 addParseToken('hmm', function (input
, array
, config
) {
1949 var pos
= input
.length
- 2;
1950 array
[HOUR
] = toInt(input
.substr(0, pos
));
1951 array
[MINUTE
] = toInt(input
.substr(pos
));
1952 getParsingFlags(config
).bigHour
= true;
1954 addParseToken('hmmss', function (input
, array
, config
) {
1955 var pos1
= input
.length
- 4,
1956 pos2
= input
.length
- 2;
1957 array
[HOUR
] = toInt(input
.substr(0, pos1
));
1958 array
[MINUTE
] = toInt(input
.substr(pos1
, 2));
1959 array
[SECOND
] = toInt(input
.substr(pos2
));
1960 getParsingFlags(config
).bigHour
= true;
1962 addParseToken('Hmm', function (input
, array
, config
) {
1963 var pos
= input
.length
- 2;
1964 array
[HOUR
] = toInt(input
.substr(0, pos
));
1965 array
[MINUTE
] = toInt(input
.substr(pos
));
1967 addParseToken('Hmmss', function (input
, array
, config
) {
1968 var pos1
= input
.length
- 4,
1969 pos2
= input
.length
- 2;
1970 array
[HOUR
] = toInt(input
.substr(0, pos1
));
1971 array
[MINUTE
] = toInt(input
.substr(pos1
, 2));
1972 array
[SECOND
] = toInt(input
.substr(pos2
));
1977 function localeIsPM(input
) {
1978 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1979 // Using charAt should be more compatible.
1980 return (input
+ '').toLowerCase().charAt(0) === 'p';
1983 var defaultLocaleMeridiemParse
= /[ap]\.?m?\.?/i,
1984 // Setting the hour should keep the time, because the user explicitly
1985 // specified which hour they want. So trying to maintain the same hour (in
1986 // a new timezone) makes sense. Adding/subtracting hours does not follow
1988 getSetHour
= makeGetSet('Hours', true);
1990 function localeMeridiem(hours
, minutes
, isLower
) {
1992 return isLower
? 'pm' : 'PM';
1994 return isLower
? 'am' : 'AM';
1999 calendar
: defaultCalendar
,
2000 longDateFormat
: defaultLongDateFormat
,
2001 invalidDate
: defaultInvalidDate
,
2002 ordinal
: defaultOrdinal
,
2003 dayOfMonthOrdinalParse
: defaultDayOfMonthOrdinalParse
,
2004 relativeTime
: defaultRelativeTime
,
2006 months
: defaultLocaleMonths
,
2007 monthsShort
: defaultLocaleMonthsShort
,
2009 week
: defaultLocaleWeek
,
2011 weekdays
: defaultLocaleWeekdays
,
2012 weekdaysMin
: defaultLocaleWeekdaysMin
,
2013 weekdaysShort
: defaultLocaleWeekdaysShort
,
2015 meridiemParse
: defaultLocaleMeridiemParse
,
2018 // internal storage for locale config files
2020 localeFamilies
= {},
2023 function commonPrefix(arr1
, arr2
) {
2025 minl
= Math
.min(arr1
.length
, arr2
.length
);
2026 for (i
= 0; i
< minl
; i
+= 1) {
2027 if (arr1
[i
] !== arr2
[i
]) {
2034 function normalizeLocale(key
) {
2035 return key
? key
.toLowerCase().replace('_', '-') : key
;
2038 // pick the locale from the array
2039 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
2040 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
2041 function chooseLocale(names
) {
2048 while (i
< names
.length
) {
2049 split
= normalizeLocale(names
[i
]).split('-');
2051 next
= normalizeLocale(names
[i
+ 1]);
2052 next
= next
? next
.split('-') : null;
2054 locale
= loadLocale(split
.slice(0, j
).join('-'));
2061 commonPrefix(split
, next
) >= j
- 1
2063 //the next array item is better than a shallower substring of this one
2070 return globalLocale
;
2073 function loadLocale(name
) {
2074 var oldLocale
= null,
2076 // TODO: Find a better way to register and load all the locales in Node
2078 locales
[name
] === undefined &&
2079 typeof module
!== 'undefined' &&
2084 oldLocale
= globalLocale
._abbr
;
2085 aliasedRequire
= require
;
2086 aliasedRequire('./locale/' + name
);
2087 getSetGlobalLocale(oldLocale
);
2089 // mark as not found to avoid repeating expensive file require call causing high CPU
2090 // when trying to find en-US, en_US, en-us for every format call
2091 locales
[name
] = null; // null means not found
2094 return locales
[name
];
2097 // This function will load locale and then set the global locale. If
2098 // no arguments are passed in, it will simply return the current global
2100 function getSetGlobalLocale(key
, values
) {
2103 if (isUndefined(values
)) {
2104 data
= getLocale(key
);
2106 data
= defineLocale(key
, values
);
2110 // moment.duration._locale = moment._locale = data;
2111 globalLocale
= data
;
2113 if (typeof console
!== 'undefined' && console
.warn
) {
2114 //warn user if arguments are passed but the locale could not be set
2116 'Locale ' + key
+ ' not found. Did you forget to load it?'
2122 return globalLocale
._abbr
;
2125 function defineLocale(name
, config
) {
2126 if (config
!== null) {
2128 parentConfig
= baseConfig
;
2130 if (locales
[name
] != null) {
2132 'defineLocaleOverride',
2133 'use moment.updateLocale(localeName, config) to change ' +
2134 'an existing locale. moment.defineLocale(localeName, ' +
2135 'config) should only be used for creating a new locale ' +
2136 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
2138 parentConfig
= locales
[name
]._config
;
2139 } else if (config
.parentLocale
!= null) {
2140 if (locales
[config
.parentLocale
] != null) {
2141 parentConfig
= locales
[config
.parentLocale
]._config
;
2143 locale
= loadLocale(config
.parentLocale
);
2144 if (locale
!= null) {
2145 parentConfig
= locale
._config
;
2147 if (!localeFamilies
[config
.parentLocale
]) {
2148 localeFamilies
[config
.parentLocale
] = [];
2150 localeFamilies
[config
.parentLocale
].push({
2158 locales
[name
] = new Locale(mergeConfigs(parentConfig
, config
));
2160 if (localeFamilies
[name
]) {
2161 localeFamilies
[name
].forEach(function (x
) {
2162 defineLocale(x
.name
, x
.config
);
2166 // backwards compat for now: also set the locale
2167 // make sure we set the locale AFTER all child locales have been
2168 // created, so we won't end up with the child locale set.
2169 getSetGlobalLocale(name
);
2171 return locales
[name
];
2173 // useful for testing
2174 delete locales
[name
];
2179 function updateLocale(name
, config
) {
2180 if (config
!= null) {
2183 parentConfig
= baseConfig
;
2185 if (locales
[name
] != null && locales
[name
].parentLocale
!= null) {
2186 // Update existing child locale in-place to avoid memory-leaks
2187 locales
[name
].set(mergeConfigs(locales
[name
]._config
, config
));
2190 tmpLocale
= loadLocale(name
);
2191 if (tmpLocale
!= null) {
2192 parentConfig
= tmpLocale
._config
;
2194 config
= mergeConfigs(parentConfig
, config
);
2195 if (tmpLocale
== null) {
2196 // updateLocale is called for creating a new locale
2197 // Set abbr so it will have a name (getters return
2198 // undefined otherwise).
2201 locale
= new Locale(config
);
2202 locale
.parentLocale
= locales
[name
];
2203 locales
[name
] = locale
;
2206 // backwards compat for now: also set the locale
2207 getSetGlobalLocale(name
);
2209 // pass null for config to unupdate, useful for tests
2210 if (locales
[name
] != null) {
2211 if (locales
[name
].parentLocale
!= null) {
2212 locales
[name
] = locales
[name
].parentLocale
;
2213 if (name
=== getSetGlobalLocale()) {
2214 getSetGlobalLocale(name
);
2216 } else if (locales
[name
] != null) {
2217 delete locales
[name
];
2221 return locales
[name
];
2224 // returns locale data
2225 function getLocale(key
) {
2228 if (key
&& key
._locale
&& key
._locale
._abbr
) {
2229 key
= key
._locale
._abbr
;
2233 return globalLocale
;
2236 if (!isArray(key
)) {
2237 //short-circuit everything else
2238 locale
= loadLocale(key
);
2245 return chooseLocale(key
);
2248 function listLocales() {
2249 return keys(locales
);
2252 function checkOverflow(m
) {
2256 if (a
&& getParsingFlags(m
).overflow
=== -2) {
2258 a
[MONTH
] < 0 || a
[MONTH
] > 11
2260 : a
[DATE
] < 1 || a
[DATE
] > daysInMonth(a
[YEAR
], a
[MONTH
])
2267 a
[MILLISECOND
] !== 0))
2269 : a
[MINUTE
] < 0 || a
[MINUTE
] > 59
2271 : a
[SECOND
] < 0 || a
[SECOND
] > 59
2273 : a
[MILLISECOND
] < 0 || a
[MILLISECOND
] > 999
2278 getParsingFlags(m
)._overflowDayOfYear
&&
2279 (overflow
< YEAR
|| overflow
> DATE
)
2283 if (getParsingFlags(m
)._overflowWeeks
&& overflow
=== -1) {
2286 if (getParsingFlags(m
)._overflowWeekday
&& overflow
=== -1) {
2290 getParsingFlags(m
).overflow
= overflow
;
2297 // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
2298 var extendedIsoRegex
= /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
2299 basicIsoRegex
= /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
2300 tzRegex
= /Z|[+-]\d\d(?::?\d\d)?/,
2302 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2303 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2304 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2305 ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2306 ['YYYY-DDD', /\d{4}-\d{3}/],
2307 ['YYYY-MM', /\d{4}-\d\d/, false],
2308 ['YYYYYYMMDD', /[+-]\d{10}/],
2309 ['YYYYMMDD', /\d{8}/],
2310 ['GGGG[W]WWE', /\d{4}W\d{3}/],
2311 ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2312 ['YYYYDDD', /\d{7}/],
2313 ['YYYYMM', /\d{6}/, false],
2314 ['YYYY', /\d{4}/, false],
2316 // iso time formats and regexes
2318 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2319 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2320 ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2321 ['HH:mm', /\d\d:\d\d/],
2322 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2323 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2324 ['HHmmss', /\d\d\d\d\d\d/],
2325 ['HHmm', /\d\d\d\d/],
2328 aspNetJsonRegex
= /^\/?Date\((-?\d+)/i,
2329 // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2330 rfc2822
= /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,
2344 // date from iso format
2345 function configFromISO(config
) {
2349 match
= extendedIsoRegex
.exec(string
) || basicIsoRegex
.exec(string
),
2356 getParsingFlags(config
).iso
= true;
2358 for (i
= 0, l
= isoDates
.length
; i
< l
; i
++) {
2359 if (isoDates
[i
][1].exec(match
[1])) {
2360 dateFormat
= isoDates
[i
][0];
2361 allowTime
= isoDates
[i
][2] !== false;
2365 if (dateFormat
== null) {
2366 config
._isValid
= false;
2370 for (i
= 0, l
= isoTimes
.length
; i
< l
; i
++) {
2371 if (isoTimes
[i
][1].exec(match
[3])) {
2372 // match[2] should be 'T' or space
2373 timeFormat
= (match
[2] || ' ') + isoTimes
[i
][0];
2377 if (timeFormat
== null) {
2378 config
._isValid
= false;
2382 if (!allowTime
&& timeFormat
!= null) {
2383 config
._isValid
= false;
2387 if (tzRegex
.exec(match
[4])) {
2390 config
._isValid
= false;
2394 config
._f
= dateFormat
+ (timeFormat
|| '') + (tzFormat
|| '');
2395 configFromStringAndFormat(config
);
2397 config
._isValid
= false;
2401 function extractFromRFC2822Strings(
2410 untruncateYear(yearStr
),
2411 defaultLocaleMonthsShort
.indexOf(monthStr
),
2412 parseInt(dayStr
, 10),
2413 parseInt(hourStr
, 10),
2414 parseInt(minuteStr
, 10),
2418 result
.push(parseInt(secondStr
, 10));
2424 function untruncateYear(yearStr
) {
2425 var year
= parseInt(yearStr
, 10);
2428 } else if (year
<= 999) {
2434 function preprocessRFC2822(s
) {
2435 // Remove comments and folding whitespace and replace multiple-spaces with a single space
2437 .replace(/\([^)]*\)|[\n\t]/g, ' ')
2438 .replace(/(\s\s+)/g, ' ')
2439 .replace(/^\s\s*/, '')
2440 .replace(/\s\s*$/, '');
2443 function checkWeekday(weekdayStr
, parsedInput
, config
) {
2445 // TODO: Replace the vanilla JS Date object with an independent day-of-week check.
2446 var weekdayProvided
= defaultLocaleWeekdaysShort
.indexOf(weekdayStr
),
2447 weekdayActual
= new Date(
2452 if (weekdayProvided
!== weekdayActual
) {
2453 getParsingFlags(config
).weekdayMismatch
= true;
2454 config
._isValid
= false;
2461 function calculateOffset(obsOffset
, militaryOffset
, numOffset
) {
2463 return obsOffsets
[obsOffset
];
2464 } else if (militaryOffset
) {
2465 // the only allowed military tz is Z
2468 var hm
= parseInt(numOffset
, 10),
2475 // date and time from ref 2822 format
2476 function configFromRFC2822(config
) {
2477 var match
= rfc2822
.exec(preprocessRFC2822(config
._i
)),
2480 parsedArray
= extractFromRFC2822Strings(
2488 if (!checkWeekday(match
[1], parsedArray
, config
)) {
2492 config
._a
= parsedArray
;
2493 config
._tzm
= calculateOffset(match
[8], match
[9], match
[10]);
2495 config
._d
= createUTCDate
.apply(null, config
._a
);
2496 config
._d
.setUTCMinutes(config
._d
.getUTCMinutes() - config
._tzm
);
2498 getParsingFlags(config
).rfc2822
= true;
2500 config
._isValid
= false;
2504 // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
2505 function configFromString(config
) {
2506 var matched
= aspNetJsonRegex
.exec(config
._i
);
2507 if (matched
!== null) {
2508 config
._d
= new Date(+matched
[1]);
2512 configFromISO(config
);
2513 if (config
._isValid
=== false) {
2514 delete config
._isValid
;
2519 configFromRFC2822(config
);
2520 if (config
._isValid
=== false) {
2521 delete config
._isValid
;
2526 if (config
._strict
) {
2527 config
._isValid
= false;
2529 // Final attempt, use Input Fallback
2530 hooks
.createFromInputFallback(config
);
2534 hooks
.createFromInputFallback
= deprecate(
2535 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
2536 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
2537 'discouraged and will be removed in an upcoming major release. Please refer to ' +
2538 'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2540 config
._d
= new Date(config
._i
+ (config
._useUTC
? ' UTC' : ''));
2544 // Pick the first defined of two or three arguments.
2545 function defaults(a
, b
, c
) {
2555 function currentDateArray(config
) {
2556 // hooks is actually the exported moment object
2557 var nowValue
= new Date(hooks
.now());
2558 if (config
._useUTC
) {
2560 nowValue
.getUTCFullYear(),
2561 nowValue
.getUTCMonth(),
2562 nowValue
.getUTCDate(),
2565 return [nowValue
.getFullYear(), nowValue
.getMonth(), nowValue
.getDate()];
2568 // convert an array to a date.
2569 // the array should mirror the parameters below
2570 // note: all values past the year are optional and will default to the lowest possible value.
2571 // [year, month, day , hour, minute, second, millisecond]
2572 function configFromArray(config
) {
2584 currentDate
= currentDateArray(config
);
2586 //compute day of the year from weeks and weekdays
2587 if (config
._w
&& config
._a
[DATE
] == null && config
._a
[MONTH
] == null) {
2588 dayOfYearFromWeekInfo(config
);
2591 //if the day of the year is set, figure out what it is
2592 if (config
._dayOfYear
!= null) {
2593 yearToUse
= defaults(config
._a
[YEAR
], currentDate
[YEAR
]);
2596 config
._dayOfYear
> daysInYear(yearToUse
) ||
2597 config
._dayOfYear
=== 0
2599 getParsingFlags(config
)._overflowDayOfYear
= true;
2602 date
= createUTCDate(yearToUse
, 0, config
._dayOfYear
);
2603 config
._a
[MONTH
] = date
.getUTCMonth();
2604 config
._a
[DATE
] = date
.getUTCDate();
2607 // Default to current date.
2608 // * if no year, month, day of month are given, default to today
2609 // * if day of month is given, default month and year
2610 // * if month is given, default only year
2611 // * if year is given, don't default anything
2612 for (i
= 0; i
< 3 && config
._a
[i
] == null; ++i
) {
2613 config
._a
[i
] = input
[i
] = currentDate
[i
];
2616 // Zero out whatever was not defaulted, including time
2617 for (; i
< 7; i
++) {
2618 config
._a
[i
] = input
[i
] =
2619 config
._a
[i
] == null ? (i
=== 2 ? 1 : 0) : config
._a
[i
];
2622 // Check for 24:00:00.000
2624 config
._a
[HOUR
] === 24 &&
2625 config
._a
[MINUTE
] === 0 &&
2626 config
._a
[SECOND
] === 0 &&
2627 config
._a
[MILLISECOND
] === 0
2629 config
._nextDay
= true;
2630 config
._a
[HOUR
] = 0;
2633 config
._d
= (config
._useUTC
? createUTCDate
: createDate
).apply(
2637 expectedWeekday
= config
._useUTC
2638 ? config
._d
.getUTCDay()
2639 : config
._d
.getDay();
2641 // Apply timezone offset from input. The actual utcOffset can be changed
2643 if (config
._tzm
!= null) {
2644 config
._d
.setUTCMinutes(config
._d
.getUTCMinutes() - config
._tzm
);
2647 if (config
._nextDay
) {
2648 config
._a
[HOUR
] = 24;
2651 // check for mismatching day of week
2654 typeof config
._w
.d
!== 'undefined' &&
2655 config
._w
.d
!== expectedWeekday
2657 getParsingFlags(config
).weekdayMismatch
= true;
2661 function dayOfYearFromWeekInfo(config
) {
2662 var w
, weekYear
, week
, weekday
, dow
, doy
, temp
, weekdayOverflow
, curWeek
;
2665 if (w
.GG
!= null || w
.W
!= null || w
.E
!= null) {
2669 // TODO: We need to take the current isoWeekYear, but that depends on
2670 // how we interpret now (local, utc, fixed offset). So create
2671 // a now version of current config (take local/utc/offset flags, and
2673 weekYear
= defaults(
2676 weekOfYear(createLocal(), 1, 4).year
2678 week
= defaults(w
.W
, 1);
2679 weekday
= defaults(w
.E
, 1);
2680 if (weekday
< 1 || weekday
> 7) {
2681 weekdayOverflow
= true;
2684 dow
= config
._locale
._week
.dow
;
2685 doy
= config
._locale
._week
.doy
;
2687 curWeek
= weekOfYear(createLocal(), dow
, doy
);
2689 weekYear
= defaults(w
.gg
, config
._a
[YEAR
], curWeek
.year
);
2691 // Default to current week.
2692 week
= defaults(w
.w
, curWeek
.week
);
2695 // weekday -- low day numbers are considered next week
2697 if (weekday
< 0 || weekday
> 6) {
2698 weekdayOverflow
= true;
2700 } else if (w
.e
!= null) {
2701 // local weekday -- counting starts from beginning of week
2702 weekday
= w
.e
+ dow
;
2703 if (w
.e
< 0 || w
.e
> 6) {
2704 weekdayOverflow
= true;
2707 // default to beginning of week
2711 if (week
< 1 || week
> weeksInYear(weekYear
, dow
, doy
)) {
2712 getParsingFlags(config
)._overflowWeeks
= true;
2713 } else if (weekdayOverflow
!= null) {
2714 getParsingFlags(config
)._overflowWeekday
= true;
2716 temp
= dayOfYearFromWeeks(weekYear
, week
, weekday
, dow
, doy
);
2717 config
._a
[YEAR
] = temp
.year
;
2718 config
._dayOfYear
= temp
.dayOfYear
;
2722 // constant that refers to the ISO standard
2723 hooks
.ISO_8601 = function () {};
2725 // constant that refers to the RFC 2822 form
2726 hooks
.RFC_2822 = function () {};
2728 // date from string and format string
2729 function configFromStringAndFormat(config
) {
2730 // TODO: Move this to another part of the creation flow to prevent circular deps
2731 if (config
._f
=== hooks
.ISO_8601
) {
2732 configFromISO(config
);
2735 if (config
._f
=== hooks
.RFC_2822
) {
2736 configFromRFC2822(config
);
2740 getParsingFlags(config
).empty
= true;
2742 // This array is used to make a Date, either with `new Date` or `Date.UTC`
2743 var string
= '' + config
._i
,
2749 stringLength
= string
.length
,
2750 totalParsedInputLength
= 0,
2754 expandFormat(config
._f
, config
._locale
).match(formattingTokens
) || [];
2756 for (i
= 0; i
< tokens
.length
; i
++) {
2758 parsedInput
= (string
.match(getParseRegexForToken(token
, config
)) ||
2761 skipped
= string
.substr(0, string
.indexOf(parsedInput
));
2762 if (skipped
.length
> 0) {
2763 getParsingFlags(config
).unusedInput
.push(skipped
);
2765 string
= string
.slice(
2766 string
.indexOf(parsedInput
) + parsedInput
.length
2768 totalParsedInputLength
+= parsedInput
.length
;
2770 // don't parse if it's not a known token
2771 if (formatTokenFunctions
[token
]) {
2773 getParsingFlags(config
).empty
= false;
2775 getParsingFlags(config
).unusedTokens
.push(token
);
2777 addTimeToArrayFromToken(token
, parsedInput
, config
);
2778 } else if (config
._strict
&& !parsedInput
) {
2779 getParsingFlags(config
).unusedTokens
.push(token
);
2783 // add remaining unparsed input length to the string
2784 getParsingFlags(config
).charsLeftOver
=
2785 stringLength
- totalParsedInputLength
;
2786 if (string
.length
> 0) {
2787 getParsingFlags(config
).unusedInput
.push(string
);
2790 // clear _12h flag if hour is <= 12
2792 config
._a
[HOUR
] <= 12 &&
2793 getParsingFlags(config
).bigHour
=== true &&
2796 getParsingFlags(config
).bigHour
= undefined;
2799 getParsingFlags(config
).parsedDateParts
= config
._a
.slice(0);
2800 getParsingFlags(config
).meridiem
= config
._meridiem
;
2802 config
._a
[HOUR
] = meridiemFixWrap(
2809 era
= getParsingFlags(config
).era
;
2811 config
._a
[YEAR
] = config
._locale
.erasConvertYear(era
, config
._a
[YEAR
]);
2814 configFromArray(config
);
2815 checkOverflow(config
);
2818 function meridiemFixWrap(locale
, hour
, meridiem
) {
2821 if (meridiem
== null) {
2825 if (locale
.meridiemHour
!= null) {
2826 return locale
.meridiemHour(hour
, meridiem
);
2827 } else if (locale
.isPM
!= null) {
2829 isPm
= locale
.isPM(meridiem
);
2830 if (isPm
&& hour
< 12) {
2833 if (!isPm
&& hour
=== 12) {
2838 // this is not supposed to happen
2843 // date from string and array of format strings
2844 function configFromStringAndArray(config
) {
2851 bestFormatIsValid
= false;
2853 if (config
._f
.length
=== 0) {
2854 getParsingFlags(config
).invalidFormat
= true;
2855 config
._d
= new Date(NaN
);
2859 for (i
= 0; i
< config
._f
.length
; i
++) {
2861 validFormatFound
= false;
2862 tempConfig
= copyConfig({}, config
);
2863 if (config
._useUTC
!= null) {
2864 tempConfig
._useUTC
= config
._useUTC
;
2866 tempConfig
._f
= config
._f
[i
];
2867 configFromStringAndFormat(tempConfig
);
2869 if (isValid(tempConfig
)) {
2870 validFormatFound
= true;
2873 // if there is any input that was not parsed add a penalty for that format
2874 currentScore
+= getParsingFlags(tempConfig
).charsLeftOver
;
2877 currentScore
+= getParsingFlags(tempConfig
).unusedTokens
.length
* 10;
2879 getParsingFlags(tempConfig
).score
= currentScore
;
2881 if (!bestFormatIsValid
) {
2883 scoreToBeat
== null ||
2884 currentScore
< scoreToBeat
||
2887 scoreToBeat
= currentScore
;
2888 bestMoment
= tempConfig
;
2889 if (validFormatFound
) {
2890 bestFormatIsValid
= true;
2894 if (currentScore
< scoreToBeat
) {
2895 scoreToBeat
= currentScore
;
2896 bestMoment
= tempConfig
;
2901 extend(config
, bestMoment
|| tempConfig
);
2904 function configFromObject(config
) {
2909 var i
= normalizeObjectUnits(config
._i
),
2910 dayOrDate
= i
.day
=== undefined ? i
.date
: i
.day
;
2912 [i
.year
, i
.month
, dayOrDate
, i
.hour
, i
.minute
, i
.second
, i
.millisecond
],
2914 return obj
&& parseInt(obj
, 10);
2918 configFromArray(config
);
2921 function createFromConfig(config
) {
2922 var res
= new Moment(checkOverflow(prepareConfig(config
)));
2924 // Adding is smart enough around DST
2926 res
._nextDay
= undefined;
2932 function prepareConfig(config
) {
2933 var input
= config
._i
,
2936 config
._locale
= config
._locale
|| getLocale(config
._l
);
2938 if (input
=== null || (format
=== undefined && input
=== '')) {
2939 return createInvalid({ nullInput
: true });
2942 if (typeof input
=== 'string') {
2943 config
._i
= input
= config
._locale
.preparse(input
);
2946 if (isMoment(input
)) {
2947 return new Moment(checkOverflow(input
));
2948 } else if (isDate(input
)) {
2950 } else if (isArray(format
)) {
2951 configFromStringAndArray(config
);
2952 } else if (format
) {
2953 configFromStringAndFormat(config
);
2955 configFromInput(config
);
2958 if (!isValid(config
)) {
2965 function configFromInput(config
) {
2966 var input
= config
._i
;
2967 if (isUndefined(input
)) {
2968 config
._d
= new Date(hooks
.now());
2969 } else if (isDate(input
)) {
2970 config
._d
= new Date(input
.valueOf());
2971 } else if (typeof input
=== 'string') {
2972 configFromString(config
);
2973 } else if (isArray(input
)) {
2974 config
._a
= map(input
.slice(0), function (obj
) {
2975 return parseInt(obj
, 10);
2977 configFromArray(config
);
2978 } else if (isObject(input
)) {
2979 configFromObject(config
);
2980 } else if (isNumber(input
)) {
2981 // from milliseconds
2982 config
._d
= new Date(input
);
2984 hooks
.createFromInputFallback(config
);
2988 function createLocalOrUTC(input
, format
, locale
, strict
, isUTC
) {
2991 if (format
=== true || format
=== false) {
2996 if (locale
=== true || locale
=== false) {
3002 (isObject(input
) && isObjectEmpty(input
)) ||
3003 (isArray(input
) && input
.length
=== 0)
3007 // object construction must be done this way.
3008 // https://github.com/moment/moment/issues/1423
3009 c
._isAMomentObject
= true;
3010 c
._useUTC
= c
._isUTC
= isUTC
;
3016 return createFromConfig(c
);
3019 function createLocal(input
, format
, locale
, strict
) {
3020 return createLocalOrUTC(input
, format
, locale
, strict
, false);
3023 var prototypeMin
= deprecate(
3024 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
3026 var other
= createLocal
.apply(null, arguments
);
3027 if (this.isValid() && other
.isValid()) {
3028 return other
< this ? this : other
;
3030 return createInvalid();
3034 prototypeMax
= deprecate(
3035 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
3037 var other
= createLocal
.apply(null, arguments
);
3038 if (this.isValid() && other
.isValid()) {
3039 return other
> this ? this : other
;
3041 return createInvalid();
3046 // Pick a moment m from moments so that m[fn](other) is true for all
3047 // other. This relies on the function fn to be transitive.
3049 // moments should either be an array of moment objects or an array, whose
3050 // first element is an array of moment objects.
3051 function pickBy(fn
, moments
) {
3053 if (moments
.length
=== 1 && isArray(moments
[0])) {
3054 moments
= moments
[0];
3056 if (!moments
.length
) {
3057 return createLocal();
3060 for (i
= 1; i
< moments
.length
; ++i
) {
3061 if (!moments
[i
].isValid() || moments
[i
][fn
](res
)) {
3068 // TODO: Use [].sort instead?
3070 var args
= [].slice
.call(arguments
, 0);
3072 return pickBy('isBefore', args
);
3076 var args
= [].slice
.call(arguments
, 0);
3078 return pickBy('isAfter', args
);
3081 var now = function () {
3082 return Date
.now
? Date
.now() : +new Date();
3097 function isDurationValid(m
) {
3099 unitHasDecimal
= false,
3103 hasOwnProp(m
, key
) &&
3105 indexOf
.call(ordering
, key
) !== -1 &&
3106 (m
[key
] == null || !isNaN(m
[key
]))
3113 for (i
= 0; i
< ordering
.length
; ++i
) {
3114 if (m
[ordering
[i
]]) {
3115 if (unitHasDecimal
) {
3116 return false; // only allow non-integers for smallest unit
3118 if (parseFloat(m
[ordering
[i
]]) !== toInt(m
[ordering
[i
]])) {
3119 unitHasDecimal
= true;
3127 function isValid
$1() {
3128 return this._isValid
;
3131 function createInvalid
$1() {
3132 return createDuration(NaN
);
3135 function Duration(duration
) {
3136 var normalizedInput
= normalizeObjectUnits(duration
),
3137 years
= normalizedInput
.year
|| 0,
3138 quarters
= normalizedInput
.quarter
|| 0,
3139 months
= normalizedInput
.month
|| 0,
3140 weeks
= normalizedInput
.week
|| normalizedInput
.isoWeek
|| 0,
3141 days
= normalizedInput
.day
|| 0,
3142 hours
= normalizedInput
.hour
|| 0,
3143 minutes
= normalizedInput
.minute
|| 0,
3144 seconds
= normalizedInput
.second
|| 0,
3145 milliseconds
= normalizedInput
.millisecond
|| 0;
3147 this._isValid
= isDurationValid(normalizedInput
);
3149 // representation for dateAddRemove
3150 this._milliseconds
=
3152 seconds
* 1e3
+ // 1000
3153 minutes
* 6e4
+ // 1000 * 60
3154 hours
* 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
3155 // Because of dateAddRemove treats 24 hours as different from a
3156 // day when working around DST, we need to store them separately
3157 this._days
= +days
+ weeks
* 7;
3158 // It is impossible to translate months into days without knowing
3159 // which months you are are talking about, so we have to store
3161 this._months
= +months
+ quarters
* 3 + years
* 12;
3165 this._locale
= getLocale();
3170 function isDuration(obj
) {
3171 return obj
instanceof Duration
;
3174 function absRound(number
) {
3176 return Math
.round(-1 * number
) * -1;
3178 return Math
.round(number
);
3182 // compare two arrays, return the number of differences
3183 function compareArrays(array1
, array2
, dontConvert
) {
3184 var len
= Math
.min(array1
.length
, array2
.length
),
3185 lengthDiff
= Math
.abs(array1
.length
- array2
.length
),
3188 for (i
= 0; i
< len
; i
++) {
3190 (dontConvert
&& array1
[i
] !== array2
[i
]) ||
3191 (!dontConvert
&& toInt(array1
[i
]) !== toInt(array2
[i
]))
3196 return diffs
+ lengthDiff
;
3201 function offset(token
, separator
) {
3202 addFormatToken(token
, 0, 0, function () {
3203 var offset
= this.utcOffset(),
3211 zeroFill(~~(offset
/ 60), 2) +
3213 zeroFill(~~offset
% 60, 2)
3223 addRegexToken('Z', matchShortOffset
);
3224 addRegexToken('ZZ', matchShortOffset
);
3225 addParseToken(['Z', 'ZZ'], function (input
, array
, config
) {
3226 config
._useUTC
= true;
3227 config
._tzm
= offsetFromString(matchShortOffset
, input
);
3233 // '+10:00' > ['10', '00']
3234 // '-1530' > ['-15', '30']
3235 var chunkOffset
= /([\+\-]|\d\d)/gi;
3237 function offsetFromString(matcher
, string
) {
3238 var matches
= (string
|| '').match(matcher
),
3243 if (matches
=== null) {
3247 chunk
= matches
[matches
.length
- 1] || [];
3248 parts
= (chunk
+ '').match(chunkOffset
) || ['-', 0, 0];
3249 minutes
= +(parts
[1] * 60) + toInt(parts
[2]);
3251 return minutes
=== 0 ? 0 : parts
[0] === '+' ? minutes
: -minutes
;
3254 // Return a moment from input, that is local/utc/zone equivalent to model.
3255 function cloneWithOffset(input
, model
) {
3258 res
= model
.clone();
3260 (isMoment(input
) || isDate(input
)
3262 : createLocal(input
).valueOf()) - res
.valueOf();
3263 // Use low-level api, because this fn is low-level api.
3264 res
._d
.setTime(res
._d
.valueOf() + diff
);
3265 hooks
.updateOffset(res
, false);
3268 return createLocal(input
).local();
3272 function getDateOffset(m
) {
3273 // On Firefox.24 Date#getTimezoneOffset returns a floating point.
3274 // https://github.com/moment/moment/pull/1871
3275 return -Math
.round(m
._d
.getTimezoneOffset());
3280 // This function will be called whenever a moment is mutated.
3281 // It is intended to keep the offset in sync with the timezone.
3282 hooks
.updateOffset = function () {};
3286 // keepLocalTime = true means only change the timezone, without
3287 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
3288 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
3289 // +0200, so we adjust the time as needed, to be valid.
3291 // Keeping the time actually adds/subtracts (one hour)
3292 // from the actual represented time. That is why we call updateOffset
3293 // a second time. In case it wants us to change the offset again
3294 // _changeInProgress == true case, then we have to adjust, because
3295 // there is no such time in the given timezone.
3296 function getSetOffset(input
, keepLocalTime
, keepMinutes
) {
3297 var offset
= this._offset
|| 0,
3299 if (!this.isValid()) {
3300 return input
!= null ? this : NaN
;
3302 if (input
!= null) {
3303 if (typeof input
=== 'string') {
3304 input
= offsetFromString(matchShortOffset
, input
);
3305 if (input
=== null) {
3308 } else if (Math
.abs(input
) < 16 && !keepMinutes
) {
3311 if (!this._isUTC
&& keepLocalTime
) {
3312 localAdjust
= getDateOffset(this);
3314 this._offset
= input
;
3316 if (localAdjust
!= null) {
3317 this.add(localAdjust
, 'm');
3319 if (offset
!== input
) {
3320 if (!keepLocalTime
|| this._changeInProgress
) {
3323 createDuration(input
- offset
, 'm'),
3327 } else if (!this._changeInProgress
) {
3328 this._changeInProgress
= true;
3329 hooks
.updateOffset(this, true);
3330 this._changeInProgress
= null;
3335 return this._isUTC
? offset
: getDateOffset(this);
3339 function getSetZone(input
, keepLocalTime
) {
3340 if (input
!= null) {
3341 if (typeof input
!== 'string') {
3345 this.utcOffset(input
, keepLocalTime
);
3349 return -this.utcOffset();
3353 function setOffsetToUTC(keepLocalTime
) {
3354 return this.utcOffset(0, keepLocalTime
);
3357 function setOffsetToLocal(keepLocalTime
) {
3359 this.utcOffset(0, keepLocalTime
);
3360 this._isUTC
= false;
3362 if (keepLocalTime
) {
3363 this.subtract(getDateOffset(this), 'm');
3369 function setOffsetToParsedOffset() {
3370 if (this._tzm
!= null) {
3371 this.utcOffset(this._tzm
, false, true);
3372 } else if (typeof this._i
=== 'string') {
3373 var tZone
= offsetFromString(matchOffset
, this._i
);
3374 if (tZone
!= null) {
3375 this.utcOffset(tZone
);
3377 this.utcOffset(0, true);
3383 function hasAlignedHourOffset(input
) {
3384 if (!this.isValid()) {
3387 input
= input
? createLocal(input
).utcOffset() : 0;
3389 return (this.utcOffset() - input
) % 60 === 0;
3392 function isDaylightSavingTime() {
3394 this.utcOffset() > this.clone().month(0).utcOffset() ||
3395 this.utcOffset() > this.clone().month(5).utcOffset()
3399 function isDaylightSavingTimeShifted() {
3400 if (!isUndefined(this._isDSTShifted
)) {
3401 return this._isDSTShifted
;
3407 copyConfig(c
, this);
3408 c
= prepareConfig(c
);
3411 other
= c
._isUTC
? createUTC(c
._a
) : createLocal(c
._a
);
3412 this._isDSTShifted
=
3413 this.isValid() && compareArrays(c
._a
, other
.toArray()) > 0;
3415 this._isDSTShifted
= false;
3418 return this._isDSTShifted
;
3421 function isLocal() {
3422 return this.isValid() ? !this._isUTC
: false;
3425 function isUtcOffset() {
3426 return this.isValid() ? this._isUTC
: false;
3430 return this.isValid() ? this._isUTC
&& this._offset
=== 0 : false;
3433 // ASP.NET json date format regex
3434 var aspNetRegex
= /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,
3435 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
3436 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
3437 // and further modified to allow for strings containing both week and day
3438 isoRegex
= /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
3440 function createDuration(input
, key
) {
3441 var duration
= input
,
3442 // matching against regexp is expensive, do it on demand
3448 if (isDuration(input
)) {
3450 ms
: input
._milliseconds
,
3454 } else if (isNumber(input
) || !isNaN(+input
)) {
3457 duration
[key
] = +input
;
3459 duration
.milliseconds
= +input
;
3461 } else if ((match
= aspNetRegex
.exec(input
))) {
3462 sign
= match
[1] === '-' ? -1 : 1;
3465 d
: toInt(match
[DATE
]) * sign
,
3466 h
: toInt(match
[HOUR
]) * sign
,
3467 m
: toInt(match
[MINUTE
]) * sign
,
3468 s
: toInt(match
[SECOND
]) * sign
,
3469 ms
: toInt(absRound(match
[MILLISECOND
] * 1000)) * sign
, // the millisecond decimal point is included in the match
3471 } else if ((match
= isoRegex
.exec(input
))) {
3472 sign
= match
[1] === '-' ? -1 : 1;
3474 y
: parseIso(match
[2], sign
),
3475 M
: parseIso(match
[3], sign
),
3476 w
: parseIso(match
[4], sign
),
3477 d
: parseIso(match
[5], sign
),
3478 h
: parseIso(match
[6], sign
),
3479 m
: parseIso(match
[7], sign
),
3480 s
: parseIso(match
[8], sign
),
3482 } else if (duration
== null) {
3483 // checks for null or undefined
3486 typeof duration
=== 'object' &&
3487 ('from' in duration
|| 'to' in duration
)
3489 diffRes
= momentsDifference(
3490 createLocal(duration
.from),
3491 createLocal(duration
.to
)
3495 duration
.ms
= diffRes
.milliseconds
;
3496 duration
.M
= diffRes
.months
;
3499 ret
= new Duration(duration
);
3501 if (isDuration(input
) && hasOwnProp(input
, '_locale')) {
3502 ret
._locale
= input
._locale
;
3505 if (isDuration(input
) && hasOwnProp(input
, '_isValid')) {
3506 ret
._isValid
= input
._isValid
;
3512 createDuration
.fn
= Duration
.prototype;
3513 createDuration
.invalid
= createInvalid
$1;
3515 function parseIso(inp
, sign
) {
3516 // We'd normally use ~~inp for this, but unfortunately it also
3517 // converts floats to ints.
3518 // inp may be undefined, so careful calling replace on it.
3519 var res
= inp
&& parseFloat(inp
.replace(',', '.'));
3520 // apply sign while we're at it
3521 return (isNaN(res
) ? 0 : res
) * sign
;
3524 function positiveMomentsDifference(base
, other
) {
3528 other
.month() - base
.month() + (other
.year() - base
.year()) * 12;
3529 if (base
.clone().add(res
.months
, 'M').isAfter(other
)) {
3533 res
.milliseconds
= +other
- +base
.clone().add(res
.months
, 'M');
3538 function momentsDifference(base
, other
) {
3540 if (!(base
.isValid() && other
.isValid())) {
3541 return { milliseconds
: 0, months
: 0 };
3544 other
= cloneWithOffset(other
, base
);
3545 if (base
.isBefore(other
)) {
3546 res
= positiveMomentsDifference(base
, other
);
3548 res
= positiveMomentsDifference(other
, base
);
3549 res
.milliseconds
= -res
.milliseconds
;
3550 res
.months
= -res
.months
;
3556 // TODO: remove 'name' arg after deprecation is removed
3557 function createAdder(direction
, name
) {
3558 return function (val
, period
) {
3560 //invert the arguments, but complain about it
3561 if (period
!== null && !isNaN(+period
)) {
3566 '(period, number) is deprecated. Please use moment().' +
3568 '(number, period). ' +
3569 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'
3576 dur
= createDuration(val
, period
);
3577 addSubtract(this, dur
, direction
);
3582 function addSubtract(mom
, duration
, isAdding
, updateOffset
) {
3583 var milliseconds
= duration
._milliseconds
,
3584 days
= absRound(duration
._days
),
3585 months
= absRound(duration
._months
);
3587 if (!mom
.isValid()) {
3592 updateOffset
= updateOffset
== null ? true : updateOffset
;
3595 setMonth(mom
, get(mom
, 'Month') + months
* isAdding
);
3598 set$1(mom
, 'Date', get(mom
, 'Date') + days
* isAdding
);
3601 mom
._d
.setTime(mom
._d
.valueOf() + milliseconds
* isAdding
);
3604 hooks
.updateOffset(mom
, days
|| months
);
3608 var add
= createAdder(1, 'add'),
3609 subtract
= createAdder(-1, 'subtract');
3611 function isString(input
) {
3612 return typeof input
=== 'string' || input
instanceof String
;
3615 // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined
3616 function isMomentInput(input
) {
3622 isNumberOrStringArray(input
) ||
3623 isMomentInputObject(input
) ||
3629 function isMomentInputObject(input
) {
3630 var objectTest
= isObject(input
) && !isObjectEmpty(input
),
3631 propertyTest
= false,
3661 for (i
= 0; i
< properties
.length
; i
+= 1) {
3662 property
= properties
[i
];
3663 propertyTest
= propertyTest
|| hasOwnProp(input
, property
);
3666 return objectTest
&& propertyTest
;
3669 function isNumberOrStringArray(input
) {
3670 var arrayTest
= isArray(input
),
3671 dataTypeTest
= false;
3674 input
.filter(function (item
) {
3675 return !isNumber(item
) && isString(input
);
3678 return arrayTest
&& dataTypeTest
;
3681 function isCalendarSpec(input
) {
3682 var objectTest
= isObject(input
) && !isObjectEmpty(input
),
3683 propertyTest
= false,
3695 for (i
= 0; i
< properties
.length
; i
+= 1) {
3696 property
= properties
[i
];
3697 propertyTest
= propertyTest
|| hasOwnProp(input
, property
);
3700 return objectTest
&& propertyTest
;
3703 function getCalendarFormat(myMoment
, now
) {
3704 var diff
= myMoment
.diff(now
, 'days', true);
3720 function calendar
$1(time
, formats
) {
3721 // Support for single parameter, formats only overload to the calendar function
3722 if (arguments
.length
=== 1) {
3723 if (!arguments
[0]) {
3725 formats
= undefined;
3726 } else if (isMomentInput(arguments
[0])) {
3727 time
= arguments
[0];
3728 formats
= undefined;
3729 } else if (isCalendarSpec(arguments
[0])) {
3730 formats
= arguments
[0];
3734 // We want to compare the start of today, vs this.
3735 // Getting start-of-today depends on whether we're local/utc/offset or not.
3736 var now
= time
|| createLocal(),
3737 sod
= cloneWithOffset(now
, this).startOf('day'),
3738 format
= hooks
.calendarFormat(this, sod
) || 'sameElse',
3741 (isFunction(formats
[format
])
3742 ? formats
[format
].call(this, now
)
3746 output
|| this.localeData().calendar(format
, this, createLocal(now
))
3751 return new Moment(this);
3754 function isAfter(input
, units
) {
3755 var localInput
= isMoment(input
) ? input
: createLocal(input
);
3756 if (!(this.isValid() && localInput
.isValid())) {
3759 units
= normalizeUnits(units
) || 'millisecond';
3760 if (units
=== 'millisecond') {
3761 return this.valueOf() > localInput
.valueOf();
3763 return localInput
.valueOf() < this.clone().startOf(units
).valueOf();
3767 function isBefore(input
, units
) {
3768 var localInput
= isMoment(input
) ? input
: createLocal(input
);
3769 if (!(this.isValid() && localInput
.isValid())) {
3772 units
= normalizeUnits(units
) || 'millisecond';
3773 if (units
=== 'millisecond') {
3774 return this.valueOf() < localInput
.valueOf();
3776 return this.clone().endOf(units
).valueOf() < localInput
.valueOf();
3780 function isBetween(from, to
, units
, inclusivity
) {
3781 var localFrom
= isMoment(from) ? from : createLocal(from),
3782 localTo
= isMoment(to
) ? to
: createLocal(to
);
3783 if (!(this.isValid() && localFrom
.isValid() && localTo
.isValid())) {
3786 inclusivity
= inclusivity
|| '()';
3788 (inclusivity
[0] === '('
3789 ? this.isAfter(localFrom
, units
)
3790 : !this.isBefore(localFrom
, units
)) &&
3791 (inclusivity
[1] === ')'
3792 ? this.isBefore(localTo
, units
)
3793 : !this.isAfter(localTo
, units
))
3797 function isSame(input
, units
) {
3798 var localInput
= isMoment(input
) ? input
: createLocal(input
),
3800 if (!(this.isValid() && localInput
.isValid())) {
3803 units
= normalizeUnits(units
) || 'millisecond';
3804 if (units
=== 'millisecond') {
3805 return this.valueOf() === localInput
.valueOf();
3807 inputMs
= localInput
.valueOf();
3809 this.clone().startOf(units
).valueOf() <= inputMs
&&
3810 inputMs
<= this.clone().endOf(units
).valueOf()
3815 function isSameOrAfter(input
, units
) {
3816 return this.isSame(input
, units
) || this.isAfter(input
, units
);
3819 function isSameOrBefore(input
, units
) {
3820 return this.isSame(input
, units
) || this.isBefore(input
, units
);
3823 function diff(input
, units
, asFloat
) {
3824 var that
, zoneDelta
, output
;
3826 if (!this.isValid()) {
3830 that
= cloneWithOffset(input
, this);
3832 if (!that
.isValid()) {
3836 zoneDelta
= (that
.utcOffset() - this.utcOffset()) * 6e4
;
3838 units
= normalizeUnits(units
);
3842 output
= monthDiff(this, that
) / 12;
3845 output
= monthDiff(this, that
);
3848 output
= monthDiff(this, that
) / 3;
3851 output
= (this - that
) / 1e3
;
3854 output
= (this - that
) / 6e4
;
3857 output
= (this - that
) / 36e5
;
3858 break; // 1000 * 60 * 60
3860 output
= (this - that
- zoneDelta
) / 864e5
;
3861 break; // 1000 * 60 * 60 * 24, negate dst
3863 output
= (this - that
- zoneDelta
) / 6048e5
;
3864 break; // 1000 * 60 * 60 * 24 * 7, negate dst
3866 output
= this - that
;
3869 return asFloat
? output
: absFloor(output
);
3872 function monthDiff(a
, b
) {
3873 if (a
.date() < b
.date()) {
3874 // end-of-month calculations work correct when the start month has more
3875 // days than the end month.
3876 return -monthDiff(b
, a
);
3878 // difference in months
3879 var wholeMonthDiff
= (b
.year() - a
.year()) * 12 + (b
.month() - a
.month()),
3880 // b is in (anchor - 1 month, anchor + 1 month)
3881 anchor
= a
.clone().add(wholeMonthDiff
, 'months'),
3885 if (b
- anchor
< 0) {
3886 anchor2
= a
.clone().add(wholeMonthDiff
- 1, 'months');
3887 // linear across the month
3888 adjust
= (b
- anchor
) / (anchor
- anchor2
);
3890 anchor2
= a
.clone().add(wholeMonthDiff
+ 1, 'months');
3891 // linear across the month
3892 adjust
= (b
- anchor
) / (anchor2
- anchor
);
3895 //check for negative zero, return zero if negative zero
3896 return -(wholeMonthDiff
+ adjust
) || 0;
3899 hooks
.defaultFormat
= 'YYYY-MM-DDTHH:mm:ssZ';
3900 hooks
.defaultFormatUtc
= 'YYYY-MM-DDTHH:mm:ss[Z]';
3902 function toString() {
3903 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
3906 function toISOString(keepOffset
) {
3907 if (!this.isValid()) {
3910 var utc
= keepOffset
!== true,
3911 m
= utc
? this.clone().utc() : this;
3912 if (m
.year() < 0 || m
.year() > 9999) {
3913 return formatMoment(
3916 ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'
3917 : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'
3920 if (isFunction(Date
.prototype.toISOString
)) {
3921 // native implementation is ~50x faster, use it when we can
3923 return this.toDate().toISOString();
3925 return new Date(this.valueOf() + this.utcOffset() * 60 * 1000)
3927 .replace('Z', formatMoment(m
, 'Z'));
3930 return formatMoment(
3932 utc
? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'
3937 * Return a human readable representation of a moment that can
3938 * also be evaluated to get a new moment which is the same
3940 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
3942 function inspect() {
3943 if (!this.isValid()) {
3944 return 'moment.invalid(/* ' + this._i
+ ' */)';
3946 var func
= 'moment',
3952 if (!this.isLocal()) {
3953 func
= this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
3956 prefix
= '[' + func
+ '("]';
3957 year
= 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';
3958 datetime
= '-MM-DD[T]HH:mm:ss.SSS';
3959 suffix
= zone
+ '[")]';
3961 return this.format(prefix
+ year
+ datetime
+ suffix
);
3964 function format(inputString
) {
3966 inputString
= this.isUtc()
3967 ? hooks
.defaultFormatUtc
3968 : hooks
.defaultFormat
;
3970 var output
= formatMoment(this, inputString
);
3971 return this.localeData().postformat(output
);
3974 function from(time
, withoutSuffix
) {
3977 ((isMoment(time
) && time
.isValid()) || createLocal(time
).isValid())
3979 return createDuration({ to
: this, from: time
})
3980 .locale(this.locale())
3981 .humanize(!withoutSuffix
);
3983 return this.localeData().invalidDate();
3987 function fromNow(withoutSuffix
) {
3988 return this.from(createLocal(), withoutSuffix
);
3991 function to(time
, withoutSuffix
) {
3994 ((isMoment(time
) && time
.isValid()) || createLocal(time
).isValid())
3996 return createDuration({ from: this, to
: time
})
3997 .locale(this.locale())
3998 .humanize(!withoutSuffix
);
4000 return this.localeData().invalidDate();
4004 function toNow(withoutSuffix
) {
4005 return this.to(createLocal(), withoutSuffix
);
4008 // If passed a locale key, it will set the locale for this
4009 // instance. Otherwise, it will return the locale configuration
4010 // variables for this instance.
4011 function locale(key
) {
4014 if (key
=== undefined) {
4015 return this._locale
._abbr
;
4017 newLocaleData
= getLocale(key
);
4018 if (newLocaleData
!= null) {
4019 this._locale
= newLocaleData
;
4025 var lang
= deprecate(
4026 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
4028 if (key
=== undefined) {
4029 return this.localeData();
4031 return this.locale(key
);
4036 function localeData() {
4037 return this._locale
;
4040 var MS_PER_SECOND
= 1000,
4041 MS_PER_MINUTE
= 60 * MS_PER_SECOND
,
4042 MS_PER_HOUR
= 60 * MS_PER_MINUTE
,
4043 MS_PER_400_YEARS
= (365 * 400 + 97) * 24 * MS_PER_HOUR
;
4045 // actual modulo - handles negative numbers (for dates before 1970):
4046 function mod
$1(dividend
, divisor
) {
4047 return ((dividend
% divisor
) + divisor
) % divisor
;
4050 function localStartOfDate(y
, m
, d
) {
4051 // the date constructor remaps years 0-99 to 1900-1999
4052 if (y
< 100 && y
>= 0) {
4053 // preserve leap years using a full 400 year cycle, then reset
4054 return new Date(y
+ 400, m
, d
) - MS_PER_400_YEARS
;
4056 return new Date(y
, m
, d
).valueOf();
4060 function utcStartOfDate(y
, m
, d
) {
4061 // Date.UTC remaps years 0-99 to 1900-1999
4062 if (y
< 100 && y
>= 0) {
4063 // preserve leap years using a full 400 year cycle, then reset
4064 return Date
.UTC(y
+ 400, m
, d
) - MS_PER_400_YEARS
;
4066 return Date
.UTC(y
, m
, d
);
4070 function startOf(units
) {
4071 var time
, startOfDate
;
4072 units
= normalizeUnits(units
);
4073 if (units
=== undefined || units
=== 'millisecond' || !this.isValid()) {
4077 startOfDate
= this._isUTC
? utcStartOfDate
: localStartOfDate
;
4081 time
= startOfDate(this.year(), 0, 1);
4086 this.month() - (this.month() % 3),
4091 time
= startOfDate(this.year(), this.month(), 1);
4097 this.date() - this.weekday()
4104 this.date() - (this.isoWeekday() - 1)
4109 time
= startOfDate(this.year(), this.month(), this.date());
4112 time
= this._d
.valueOf();
4114 time
+ (this._isUTC
? 0 : this.utcOffset() * MS_PER_MINUTE
),
4119 time
= this._d
.valueOf();
4120 time
-= mod
$1(time
, MS_PER_MINUTE
);
4123 time
= this._d
.valueOf();
4124 time
-= mod
$1(time
, MS_PER_SECOND
);
4128 this._d
.setTime(time
);
4129 hooks
.updateOffset(this, true);
4133 function endOf(units
) {
4134 var time
, startOfDate
;
4135 units
= normalizeUnits(units
);
4136 if (units
=== undefined || units
=== 'millisecond' || !this.isValid()) {
4140 startOfDate
= this._isUTC
? utcStartOfDate
: localStartOfDate
;
4144 time
= startOfDate(this.year() + 1, 0, 1) - 1;
4150 this.month() - (this.month() % 3) + 3,
4155 time
= startOfDate(this.year(), this.month() + 1, 1) - 1;
4162 this.date() - this.weekday() + 7
4170 this.date() - (this.isoWeekday() - 1) + 7
4175 time
= startOfDate(this.year(), this.month(), this.date() + 1) - 1;
4178 time
= this._d
.valueOf();
4182 time
+ (this._isUTC
? 0 : this.utcOffset() * MS_PER_MINUTE
),
4188 time
= this._d
.valueOf();
4189 time
+= MS_PER_MINUTE
- mod
$1(time
, MS_PER_MINUTE
) - 1;
4192 time
= this._d
.valueOf();
4193 time
+= MS_PER_SECOND
- mod
$1(time
, MS_PER_SECOND
) - 1;
4197 this._d
.setTime(time
);
4198 hooks
.updateOffset(this, true);
4202 function valueOf() {
4203 return this._d
.valueOf() - (this._offset
|| 0) * 60000;
4207 return Math
.floor(this.valueOf() / 1000);
4211 return new Date(this.valueOf());
4214 function toArray() {
4227 function toObject() {
4234 minutes
: m
.minutes(),
4235 seconds
: m
.seconds(),
4236 milliseconds
: m
.milliseconds(),
4241 // new Date(NaN).toJSON() === null
4242 return this.isValid() ? this.toISOString() : null;
4245 function isValid
$2() {
4246 return isValid(this);
4249 function parsingFlags() {
4250 return extend({}, getParsingFlags(this));
4253 function invalidAt() {
4254 return getParsingFlags(this).overflow
;
4257 function creationData() {
4261 locale
: this._locale
,
4263 strict
: this._strict
,
4267 addFormatToken('N', 0, 0, 'eraAbbr');
4268 addFormatToken('NN', 0, 0, 'eraAbbr');
4269 addFormatToken('NNN', 0, 0, 'eraAbbr');
4270 addFormatToken('NNNN', 0, 0, 'eraName');
4271 addFormatToken('NNNNN', 0, 0, 'eraNarrow');
4273 addFormatToken('y', ['y', 1], 'yo', 'eraYear');
4274 addFormatToken('y', ['yy', 2], 0, 'eraYear');
4275 addFormatToken('y', ['yyy', 3], 0, 'eraYear');
4276 addFormatToken('y', ['yyyy', 4], 0, 'eraYear');
4278 addRegexToken('N', matchEraAbbr
);
4279 addRegexToken('NN', matchEraAbbr
);
4280 addRegexToken('NNN', matchEraAbbr
);
4281 addRegexToken('NNNN', matchEraName
);
4282 addRegexToken('NNNNN', matchEraNarrow
);
4284 addParseToken(['N', 'NN', 'NNN', 'NNNN', 'NNNNN'], function (
4290 var era
= config
._locale
.erasParse(input
, token
, config
._strict
);
4292 getParsingFlags(config
).era
= era
;
4294 getParsingFlags(config
).invalidEra
= input
;
4298 addRegexToken('y', matchUnsigned
);
4299 addRegexToken('yy', matchUnsigned
);
4300 addRegexToken('yyy', matchUnsigned
);
4301 addRegexToken('yyyy', matchUnsigned
);
4302 addRegexToken('yo', matchEraYearOrdinal
);
4304 addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR
);
4305 addParseToken(['yo'], function (input
, array
, config
, token
) {
4307 if (config
._locale
._eraYearOrdinalRegex
) {
4308 match
= input
.match(config
._locale
._eraYearOrdinalRegex
);
4311 if (config
._locale
.eraYearOrdinalParse
) {
4312 array
[YEAR
] = config
._locale
.eraYearOrdinalParse(input
, match
);
4314 array
[YEAR
] = parseInt(input
, 10);
4318 function localeEras(m
, format
) {
4322 eras
= this._eras
|| getLocale('en')._eras
;
4323 for (i
= 0, l
= eras
.length
; i
< l
; ++i
) {
4324 switch (typeof eras
[i
].since
) {
4327 date
= hooks(eras
[i
].since
).startOf('day');
4328 eras
[i
].since
= date
.valueOf();
4332 switch (typeof eras
[i
].until
) {
4334 eras
[i
].until
= +Infinity
;
4338 date
= hooks(eras
[i
].until
).startOf('day').valueOf();
4339 eras
[i
].until
= date
.valueOf();
4346 function localeErasParse(eraName
, format
, strict
) {
4353 eraName
= eraName
.toUpperCase();
4355 for (i
= 0, l
= eras
.length
; i
< l
; ++i
) {
4356 name
= eras
[i
].name
.toUpperCase();
4357 abbr
= eras
[i
].abbr
.toUpperCase();
4358 narrow
= eras
[i
].narrow
.toUpperCase();
4365 if (abbr
=== eraName
) {
4371 if (name
=== eraName
) {
4377 if (narrow
=== eraName
) {
4382 } else if ([name
, abbr
, narrow
].indexOf(eraName
) >= 0) {
4388 function localeErasConvertYear(era
, year
) {
4389 var dir
= era
.since
<= era
.until
? +1 : -1;
4390 if (year
=== undefined) {
4391 return hooks(era
.since
).year();
4393 return hooks(era
.since
).year() + (year
- era
.offset
) * dir
;
4397 function getEraName() {
4401 eras
= this.localeData().eras();
4402 for (i
= 0, l
= eras
.length
; i
< l
; ++i
) {
4404 val
= this.clone().startOf('day').valueOf();
4406 if (eras
[i
].since
<= val
&& val
<= eras
[i
].until
) {
4407 return eras
[i
].name
;
4409 if (eras
[i
].until
<= val
&& val
<= eras
[i
].since
) {
4410 return eras
[i
].name
;
4417 function getEraNarrow() {
4421 eras
= this.localeData().eras();
4422 for (i
= 0, l
= eras
.length
; i
< l
; ++i
) {
4424 val
= this.clone().startOf('day').valueOf();
4426 if (eras
[i
].since
<= val
&& val
<= eras
[i
].until
) {
4427 return eras
[i
].narrow
;
4429 if (eras
[i
].until
<= val
&& val
<= eras
[i
].since
) {
4430 return eras
[i
].narrow
;
4437 function getEraAbbr() {
4441 eras
= this.localeData().eras();
4442 for (i
= 0, l
= eras
.length
; i
< l
; ++i
) {
4444 val
= this.clone().startOf('day').valueOf();
4446 if (eras
[i
].since
<= val
&& val
<= eras
[i
].until
) {
4447 return eras
[i
].abbr
;
4449 if (eras
[i
].until
<= val
&& val
<= eras
[i
].since
) {
4450 return eras
[i
].abbr
;
4457 function getEraYear() {
4462 eras
= this.localeData().eras();
4463 for (i
= 0, l
= eras
.length
; i
< l
; ++i
) {
4464 dir
= eras
[i
].since
<= eras
[i
].until
? +1 : -1;
4467 val
= this.clone().startOf('day').valueOf();
4470 (eras
[i
].since
<= val
&& val
<= eras
[i
].until
) ||
4471 (eras
[i
].until
<= val
&& val
<= eras
[i
].since
)
4474 (this.year() - hooks(eras
[i
].since
).year()) * dir
+
4483 function erasNameRegex(isStrict
) {
4484 if (!hasOwnProp(this, '_erasNameRegex')) {
4485 computeErasParse
.call(this);
4487 return isStrict
? this._erasNameRegex
: this._erasRegex
;
4490 function erasAbbrRegex(isStrict
) {
4491 if (!hasOwnProp(this, '_erasAbbrRegex')) {
4492 computeErasParse
.call(this);
4494 return isStrict
? this._erasAbbrRegex
: this._erasRegex
;
4497 function erasNarrowRegex(isStrict
) {
4498 if (!hasOwnProp(this, '_erasNarrowRegex')) {
4499 computeErasParse
.call(this);
4501 return isStrict
? this._erasNarrowRegex
: this._erasRegex
;
4504 function matchEraAbbr(isStrict
, locale
) {
4505 return locale
.erasAbbrRegex(isStrict
);
4508 function matchEraName(isStrict
, locale
) {
4509 return locale
.erasNameRegex(isStrict
);
4512 function matchEraNarrow(isStrict
, locale
) {
4513 return locale
.erasNarrowRegex(isStrict
);
4516 function matchEraYearOrdinal(isStrict
, locale
) {
4517 return locale
._eraYearOrdinalRegex
|| matchUnsigned
;
4520 function computeErasParse() {
4521 var abbrPieces
= [],
4529 for (i
= 0, l
= eras
.length
; i
< l
; ++i
) {
4530 namePieces
.push(regexEscape(eras
[i
].name
));
4531 abbrPieces
.push(regexEscape(eras
[i
].abbr
));
4532 narrowPieces
.push(regexEscape(eras
[i
].narrow
));
4534 mixedPieces
.push(regexEscape(eras
[i
].name
));
4535 mixedPieces
.push(regexEscape(eras
[i
].abbr
));
4536 mixedPieces
.push(regexEscape(eras
[i
].narrow
));
4539 this._erasRegex
= new RegExp('^(' + mixedPieces
.join('|') + ')', 'i');
4540 this._erasNameRegex
= new RegExp('^(' + namePieces
.join('|') + ')', 'i');
4541 this._erasAbbrRegex
= new RegExp('^(' + abbrPieces
.join('|') + ')', 'i');
4542 this._erasNarrowRegex
= new RegExp(
4543 '^(' + narrowPieces
.join('|') + ')',
4550 addFormatToken(0, ['gg', 2], 0, function () {
4551 return this.weekYear() % 100;
4554 addFormatToken(0, ['GG', 2], 0, function () {
4555 return this.isoWeekYear() % 100;
4558 function addWeekYearFormatToken(token
, getter
) {
4559 addFormatToken(0, [token
, token
.length
], 0, getter
);
4562 addWeekYearFormatToken('gggg', 'weekYear');
4563 addWeekYearFormatToken('ggggg', 'weekYear');
4564 addWeekYearFormatToken('GGGG', 'isoWeekYear');
4565 addWeekYearFormatToken('GGGGG', 'isoWeekYear');
4569 addUnitAlias('weekYear', 'gg');
4570 addUnitAlias('isoWeekYear', 'GG');
4574 addUnitPriority('weekYear', 1);
4575 addUnitPriority('isoWeekYear', 1);
4579 addRegexToken('G', matchSigned
);
4580 addRegexToken('g', matchSigned
);
4581 addRegexToken('GG', match1to2
, match2
);
4582 addRegexToken('gg', match1to2
, match2
);
4583 addRegexToken('GGGG', match1to4
, match4
);
4584 addRegexToken('gggg', match1to4
, match4
);
4585 addRegexToken('GGGGG', match1to6
, match6
);
4586 addRegexToken('ggggg', match1to6
, match6
);
4588 addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (
4594 week
[token
.substr(0, 2)] = toInt(input
);
4597 addWeekParseToken(['gg', 'GG'], function (input
, week
, config
, token
) {
4598 week
[token
] = hooks
.parseTwoDigitYear(input
);
4603 function getSetWeekYear(input
) {
4604 return getSetWeekYearHelper
.call(
4609 this.localeData()._week
.dow
,
4610 this.localeData()._week
.doy
4614 function getSetISOWeekYear(input
) {
4615 return getSetWeekYearHelper
.call(
4625 function getISOWeeksInYear() {
4626 return weeksInYear(this.year(), 1, 4);
4629 function getISOWeeksInISOWeekYear() {
4630 return weeksInYear(this.isoWeekYear(), 1, 4);
4633 function getWeeksInYear() {
4634 var weekInfo
= this.localeData()._week
;
4635 return weeksInYear(this.year(), weekInfo
.dow
, weekInfo
.doy
);
4638 function getWeeksInWeekYear() {
4639 var weekInfo
= this.localeData()._week
;
4640 return weeksInYear(this.weekYear(), weekInfo
.dow
, weekInfo
.doy
);
4643 function getSetWeekYearHelper(input
, week
, weekday
, dow
, doy
) {
4645 if (input
== null) {
4646 return weekOfYear(this, dow
, doy
).year
;
4648 weeksTarget
= weeksInYear(input
, dow
, doy
);
4649 if (week
> weeksTarget
) {
4652 return setWeekAll
.call(this, input
, week
, weekday
, dow
, doy
);
4656 function setWeekAll(weekYear
, week
, weekday
, dow
, doy
) {
4657 var dayOfYearData
= dayOfYearFromWeeks(weekYear
, week
, weekday
, dow
, doy
),
4658 date
= createUTCDate(dayOfYearData
.year
, 0, dayOfYearData
.dayOfYear
);
4660 this.year(date
.getUTCFullYear());
4661 this.month(date
.getUTCMonth());
4662 this.date(date
.getUTCDate());
4668 addFormatToken('Q', 0, 'Qo', 'quarter');
4672 addUnitAlias('quarter', 'Q');
4676 addUnitPriority('quarter', 7);
4680 addRegexToken('Q', match1
);
4681 addParseToken('Q', function (input
, array
) {
4682 array
[MONTH
] = (toInt(input
) - 1) * 3;
4687 function getSetQuarter(input
) {
4688 return input
== null
4689 ? Math
.ceil((this.month() + 1) / 3)
4690 : this.month((input
- 1) * 3 + (this.month() % 3));
4695 addFormatToken('D', ['DD', 2], 'Do', 'date');
4699 addUnitAlias('date', 'D');
4702 addUnitPriority('date', 9);
4706 addRegexToken('D', match1to2
);
4707 addRegexToken('DD', match1to2
, match2
);
4708 addRegexToken('Do', function (isStrict
, locale
) {
4709 // TODO: Remove "ordinalParse" fallback in next major release.
4711 ? locale
._dayOfMonthOrdinalParse
|| locale
._ordinalParse
4712 : locale
._dayOfMonthOrdinalParseLenient
;
4715 addParseToken(['D', 'DD'], DATE
);
4716 addParseToken('Do', function (input
, array
) {
4717 array
[DATE
] = toInt(input
.match(match1to2
)[0]);
4722 var getSetDayOfMonth
= makeGetSet('Date', true);
4726 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
4730 addUnitAlias('dayOfYear', 'DDD');
4733 addUnitPriority('dayOfYear', 4);
4737 addRegexToken('DDD', match1to3
);
4738 addRegexToken('DDDD', match3
);
4739 addParseToken(['DDD', 'DDDD'], function (input
, array
, config
) {
4740 config
._dayOfYear
= toInt(input
);
4747 function getSetDayOfYear(input
) {
4750 (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5
4752 return input
== null ? dayOfYear
: this.add(input
- dayOfYear
, 'd');
4757 addFormatToken('m', ['mm', 2], 0, 'minute');
4761 addUnitAlias('minute', 'm');
4765 addUnitPriority('minute', 14);
4769 addRegexToken('m', match1to2
);
4770 addRegexToken('mm', match1to2
, match2
);
4771 addParseToken(['m', 'mm'], MINUTE
);
4775 var getSetMinute
= makeGetSet('Minutes', false);
4779 addFormatToken('s', ['ss', 2], 0, 'second');
4783 addUnitAlias('second', 's');
4787 addUnitPriority('second', 15);
4791 addRegexToken('s', match1to2
);
4792 addRegexToken('ss', match1to2
, match2
);
4793 addParseToken(['s', 'ss'], SECOND
);
4797 var getSetSecond
= makeGetSet('Seconds', false);
4801 addFormatToken('S', 0, 0, function () {
4802 return ~~(this.millisecond() / 100);
4805 addFormatToken(0, ['SS', 2], 0, function () {
4806 return ~~(this.millisecond() / 10);
4809 addFormatToken(0, ['SSS', 3], 0, 'millisecond');
4810 addFormatToken(0, ['SSSS', 4], 0, function () {
4811 return this.millisecond() * 10;
4813 addFormatToken(0, ['SSSSS', 5], 0, function () {
4814 return this.millisecond() * 100;
4816 addFormatToken(0, ['SSSSSS', 6], 0, function () {
4817 return this.millisecond() * 1000;
4819 addFormatToken(0, ['SSSSSSS', 7], 0, function () {
4820 return this.millisecond() * 10000;
4822 addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
4823 return this.millisecond() * 100000;
4825 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
4826 return this.millisecond() * 1000000;
4831 addUnitAlias('millisecond', 'ms');
4835 addUnitPriority('millisecond', 16);
4839 addRegexToken('S', match1to3
, match1
);
4840 addRegexToken('SS', match1to3
, match2
);
4841 addRegexToken('SSS', match1to3
, match3
);
4843 var token
, getSetMillisecond
;
4844 for (token
= 'SSSS'; token
.length
<= 9; token
+= 'S') {
4845 addRegexToken(token
, matchUnsigned
);
4848 function parseMs(input
, array
) {
4849 array
[MILLISECOND
] = toInt(('0.' + input
) * 1000);
4852 for (token
= 'S'; token
.length
<= 9; token
+= 'S') {
4853 addParseToken(token
, parseMs
);
4856 getSetMillisecond
= makeGetSet('Milliseconds', false);
4860 addFormatToken('z', 0, 0, 'zoneAbbr');
4861 addFormatToken('zz', 0, 0, 'zoneName');
4865 function getZoneAbbr() {
4866 return this._isUTC
? 'UTC' : '';
4869 function getZoneName() {
4870 return this._isUTC
? 'Coordinated Universal Time' : '';
4873 var proto
= Moment
.prototype;
4876 proto
.calendar
= calendar
$1;
4877 proto
.clone
= clone
;
4879 proto
.endOf
= endOf
;
4880 proto
.format
= format
;
4882 proto
.fromNow
= fromNow
;
4884 proto
.toNow
= toNow
;
4885 proto
.get = stringGet
;
4886 proto
.invalidAt
= invalidAt
;
4887 proto
.isAfter
= isAfter
;
4888 proto
.isBefore
= isBefore
;
4889 proto
.isBetween
= isBetween
;
4890 proto
.isSame
= isSame
;
4891 proto
.isSameOrAfter
= isSameOrAfter
;
4892 proto
.isSameOrBefore
= isSameOrBefore
;
4893 proto
.isValid
= isValid
$2;
4895 proto
.locale
= locale
;
4896 proto
.localeData
= localeData
;
4897 proto
.max
= prototypeMax
;
4898 proto
.min
= prototypeMin
;
4899 proto
.parsingFlags
= parsingFlags
;
4900 proto
.set = stringSet
;
4901 proto
.startOf
= startOf
;
4902 proto
.subtract
= subtract
;
4903 proto
.toArray
= toArray
;
4904 proto
.toObject
= toObject
;
4905 proto
.toDate
= toDate
;
4906 proto
.toISOString
= toISOString
;
4907 proto
.inspect
= inspect
;
4908 if (typeof Symbol
!== 'undefined' && Symbol
.for != null) {
4909 proto
[Symbol
.for('nodejs.util.inspect.custom')] = function () {
4910 return 'Moment<' + this.format() + '>';
4913 proto
.toJSON
= toJSON
;
4914 proto
.toString
= toString
;
4916 proto
.valueOf
= valueOf
;
4917 proto
.creationData
= creationData
;
4918 proto
.eraName
= getEraName
;
4919 proto
.eraNarrow
= getEraNarrow
;
4920 proto
.eraAbbr
= getEraAbbr
;
4921 proto
.eraYear
= getEraYear
;
4922 proto
.year
= getSetYear
;
4923 proto
.isLeapYear
= getIsLeapYear
;
4924 proto
.weekYear
= getSetWeekYear
;
4925 proto
.isoWeekYear
= getSetISOWeekYear
;
4926 proto
.quarter
= proto
.quarters
= getSetQuarter
;
4927 proto
.month
= getSetMonth
;
4928 proto
.daysInMonth
= getDaysInMonth
;
4929 proto
.week
= proto
.weeks
= getSetWeek
;
4930 proto
.isoWeek
= proto
.isoWeeks
= getSetISOWeek
;
4931 proto
.weeksInYear
= getWeeksInYear
;
4932 proto
.weeksInWeekYear
= getWeeksInWeekYear
;
4933 proto
.isoWeeksInYear
= getISOWeeksInYear
;
4934 proto
.isoWeeksInISOWeekYear
= getISOWeeksInISOWeekYear
;
4935 proto
.date
= getSetDayOfMonth
;
4936 proto
.day
= proto
.days
= getSetDayOfWeek
;
4937 proto
.weekday
= getSetLocaleDayOfWeek
;
4938 proto
.isoWeekday
= getSetISODayOfWeek
;
4939 proto
.dayOfYear
= getSetDayOfYear
;
4940 proto
.hour
= proto
.hours
= getSetHour
;
4941 proto
.minute
= proto
.minutes
= getSetMinute
;
4942 proto
.second
= proto
.seconds
= getSetSecond
;
4943 proto
.millisecond
= proto
.milliseconds
= getSetMillisecond
;
4944 proto
.utcOffset
= getSetOffset
;
4945 proto
.utc
= setOffsetToUTC
;
4946 proto
.local
= setOffsetToLocal
;
4947 proto
.parseZone
= setOffsetToParsedOffset
;
4948 proto
.hasAlignedHourOffset
= hasAlignedHourOffset
;
4949 proto
.isDST
= isDaylightSavingTime
;
4950 proto
.isLocal
= isLocal
;
4951 proto
.isUtcOffset
= isUtcOffset
;
4952 proto
.isUtc
= isUtc
;
4953 proto
.isUTC
= isUtc
;
4954 proto
.zoneAbbr
= getZoneAbbr
;
4955 proto
.zoneName
= getZoneName
;
4956 proto
.dates
= deprecate(
4957 'dates accessor is deprecated. Use date instead.',
4960 proto
.months
= deprecate(
4961 'months accessor is deprecated. Use month instead',
4964 proto
.years
= deprecate(
4965 'years accessor is deprecated. Use year instead',
4968 proto
.zone
= deprecate(
4969 'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
4972 proto
.isDSTShifted
= deprecate(
4973 'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
4974 isDaylightSavingTimeShifted
4977 function createUnix(input
) {
4978 return createLocal(input
* 1000);
4981 function createInZone() {
4982 return createLocal
.apply(null, arguments
).parseZone();
4985 function preParsePostFormat(string
) {
4989 var proto
$1 = Locale
.prototype;
4991 proto
$1.calendar
= calendar
;
4992 proto
$1.longDateFormat
= longDateFormat
;
4993 proto
$1.invalidDate
= invalidDate
;
4994 proto
$1.ordinal
= ordinal
;
4995 proto
$1.preparse
= preParsePostFormat
;
4996 proto
$1.postformat
= preParsePostFormat
;
4997 proto
$1.relativeTime
= relativeTime
;
4998 proto
$1.pastFuture
= pastFuture
;
5000 proto
$1.eras
= localeEras
;
5001 proto
$1.erasParse
= localeErasParse
;
5002 proto
$1.erasConvertYear
= localeErasConvertYear
;
5003 proto
$1.erasAbbrRegex
= erasAbbrRegex
;
5004 proto
$1.erasNameRegex
= erasNameRegex
;
5005 proto
$1.erasNarrowRegex
= erasNarrowRegex
;
5007 proto
$1.months
= localeMonths
;
5008 proto
$1.monthsShort
= localeMonthsShort
;
5009 proto
$1.monthsParse
= localeMonthsParse
;
5010 proto
$1.monthsRegex
= monthsRegex
;
5011 proto
$1.monthsShortRegex
= monthsShortRegex
;
5012 proto
$1.week
= localeWeek
;
5013 proto
$1.firstDayOfYear
= localeFirstDayOfYear
;
5014 proto
$1.firstDayOfWeek
= localeFirstDayOfWeek
;
5016 proto
$1.weekdays
= localeWeekdays
;
5017 proto
$1.weekdaysMin
= localeWeekdaysMin
;
5018 proto
$1.weekdaysShort
= localeWeekdaysShort
;
5019 proto
$1.weekdaysParse
= localeWeekdaysParse
;
5021 proto
$1.weekdaysRegex
= weekdaysRegex
;
5022 proto
$1.weekdaysShortRegex
= weekdaysShortRegex
;
5023 proto
$1.weekdaysMinRegex
= weekdaysMinRegex
;
5025 proto
$1.isPM
= localeIsPM
;
5026 proto
$1.meridiem
= localeMeridiem
;
5028 function get$1(format
, index
, field
, setter
) {
5029 var locale
= getLocale(),
5030 utc
= createUTC().set(setter
, index
);
5031 return locale
[field
](utc
, format
);
5034 function listMonthsImpl(format
, index
, field
) {
5035 if (isNumber(format
)) {
5040 format
= format
|| '';
5042 if (index
!= null) {
5043 return get$1(format
, index
, field
, 'month');
5048 for (i
= 0; i
< 12; i
++) {
5049 out
[i
] = get$1(format
, i
, field
, 'month');
5062 function listWeekdaysImpl(localeSorted
, format
, index
, field
) {
5063 if (typeof localeSorted
=== 'boolean') {
5064 if (isNumber(format
)) {
5069 format
= format
|| '';
5071 format
= localeSorted
;
5073 localeSorted
= false;
5075 if (isNumber(format
)) {
5080 format
= format
|| '';
5083 var locale
= getLocale(),
5084 shift
= localeSorted
? locale
._week
.dow
: 0,
5088 if (index
!= null) {
5089 return get$1(format
, (index
+ shift
) % 7, field
, 'day');
5092 for (i
= 0; i
< 7; i
++) {
5093 out
[i
] = get$1(format
, (i
+ shift
) % 7, field
, 'day');
5098 function listMonths(format
, index
) {
5099 return listMonthsImpl(format
, index
, 'months');
5102 function listMonthsShort(format
, index
) {
5103 return listMonthsImpl(format
, index
, 'monthsShort');
5106 function listWeekdays(localeSorted
, format
, index
) {
5107 return listWeekdaysImpl(localeSorted
, format
, index
, 'weekdays');
5110 function listWeekdaysShort(localeSorted
, format
, index
) {
5111 return listWeekdaysImpl(localeSorted
, format
, index
, 'weekdaysShort');
5114 function listWeekdaysMin(localeSorted
, format
, index
) {
5115 return listWeekdaysImpl(localeSorted
, format
, index
, 'weekdaysMin');
5118 getSetGlobalLocale('en', {
5121 since
: '0001-01-01',
5124 name
: 'Anno Domini',
5129 since
: '0000-12-31',
5132 name
: 'Before Christ',
5137 dayOfMonthOrdinalParse
: /\d{1,2}(th|st|nd|rd)/,
5138 ordinal: function (number
) {
5139 var b
= number
% 10,
5141 toInt((number
% 100) / 10) === 1
5150 return number
+ output
;
5154 // Side effect imports
5156 hooks
.lang
= deprecate(
5157 'moment.lang is deprecated. Use moment.locale instead.',
5160 hooks
.langData
= deprecate(
5161 'moment.langData is deprecated. Use moment.localeData instead.',
5165 var mathAbs
= Math
.abs
;
5168 var data
= this._data
;
5170 this._milliseconds
= mathAbs(this._milliseconds
);
5171 this._days
= mathAbs(this._days
);
5172 this._months
= mathAbs(this._months
);
5174 data
.milliseconds
= mathAbs(data
.milliseconds
);
5175 data
.seconds
= mathAbs(data
.seconds
);
5176 data
.minutes
= mathAbs(data
.minutes
);
5177 data
.hours
= mathAbs(data
.hours
);
5178 data
.months
= mathAbs(data
.months
);
5179 data
.years
= mathAbs(data
.years
);
5184 function addSubtract
$1(duration
, input
, value
, direction
) {
5185 var other
= createDuration(input
, value
);
5187 duration
._milliseconds
+= direction
* other
._milliseconds
;
5188 duration
._days
+= direction
* other
._days
;
5189 duration
._months
+= direction
* other
._months
;
5191 return duration
._bubble();
5194 // supports only 2.0-style add(1, 's') or add(duration)
5195 function add
$1(input
, value
) {
5196 return addSubtract
$1(this, input
, value
, 1);
5199 // supports only 2.0-style subtract(1, 's') or subtract(duration)
5200 function subtract
$1(input
, value
) {
5201 return addSubtract
$1(this, input
, value
, -1);
5204 function absCeil(number
) {
5206 return Math
.floor(number
);
5208 return Math
.ceil(number
);
5213 var milliseconds
= this._milliseconds
,
5215 months
= this._months
,
5223 // if we have a mix of positive and negative values, bubble down first
5224 // check: https://github.com/moment/moment/issues/2166
5227 (milliseconds
>= 0 && days
>= 0 && months
>= 0) ||
5228 (milliseconds
<= 0 && days
<= 0 && months
<= 0)
5231 milliseconds
+= absCeil(monthsToDays(months
) + days
) * 864e5
;
5236 // The following code bubbles up values, see the tests for
5237 // examples of what that means.
5238 data
.milliseconds
= milliseconds
% 1000;
5240 seconds
= absFloor(milliseconds
/ 1000);
5241 data
.seconds
= seconds
% 60;
5243 minutes
= absFloor(seconds
/ 60);
5244 data
.minutes
= minutes
% 60;
5246 hours
= absFloor(minutes
/ 60);
5247 data
.hours
= hours
% 24;
5249 days
+= absFloor(hours
/ 24);
5251 // convert days to months
5252 monthsFromDays
= absFloor(daysToMonths(days
));
5253 months
+= monthsFromDays
;
5254 days
-= absCeil(monthsToDays(monthsFromDays
));
5256 // 12 months -> 1 year
5257 years
= absFloor(months
/ 12);
5261 data
.months
= months
;
5267 function daysToMonths(days
) {
5268 // 400 years have 146097 days (taking into account leap year rules)
5269 // 400 years have 12 months === 4800
5270 return (days
* 4800) / 146097;
5273 function monthsToDays(months
) {
5274 // the reverse of daysToMonths
5275 return (months
* 146097) / 4800;
5278 function as(units
) {
5279 if (!this.isValid()) {
5284 milliseconds
= this._milliseconds
;
5286 units
= normalizeUnits(units
);
5288 if (units
=== 'month' || units
=== 'quarter' || units
=== 'year') {
5289 days
= this._days
+ milliseconds
/ 864e5
;
5290 months
= this._months
+ daysToMonths(days
);
5300 // handle milliseconds separately because of floating point math errors (issue #1867)
5301 days
= this._days
+ Math
.round(monthsToDays(this._months
));
5304 return days
/ 7 + milliseconds
/ 6048e5
;
5306 return days
+ milliseconds
/ 864e5
;
5308 return days
* 24 + milliseconds
/ 36e5
;
5310 return days
* 1440 + milliseconds
/ 6e4
;
5312 return days
* 86400 + milliseconds
/ 1000;
5313 // Math.floor prevents floating point math errors here
5315 return Math
.floor(days
* 864e5
) + milliseconds
;
5317 throw new Error('Unknown unit ' + units
);
5322 // TODO: Use this.as('ms')?
5323 function valueOf
$1() {
5324 if (!this.isValid()) {
5328 this._milliseconds
+
5329 this._days
* 864e5
+
5330 (this._months
% 12) * 2592e6
+
5331 toInt(this._months
/ 12) * 31536e6
5335 function makeAs(alias
) {
5336 return function () {
5337 return this.as(alias
);
5341 var asMilliseconds
= makeAs('ms'),
5342 asSeconds
= makeAs('s'),
5343 asMinutes
= makeAs('m'),
5344 asHours
= makeAs('h'),
5345 asDays
= makeAs('d'),
5346 asWeeks
= makeAs('w'),
5347 asMonths
= makeAs('M'),
5348 asQuarters
= makeAs('Q'),
5349 asYears
= makeAs('y');
5351 function clone
$1() {
5352 return createDuration(this);
5355 function get$2(units
) {
5356 units
= normalizeUnits(units
);
5357 return this.isValid() ? this[units
+ 's']() : NaN
;
5360 function makeGetter(name
) {
5361 return function () {
5362 return this.isValid() ? this._data
[name
] : NaN
;
5366 var milliseconds
= makeGetter('milliseconds'),
5367 seconds
= makeGetter('seconds'),
5368 minutes
= makeGetter('minutes'),
5369 hours
= makeGetter('hours'),
5370 days
= makeGetter('days'),
5371 months
= makeGetter('months'),
5372 years
= makeGetter('years');
5375 return absFloor(this.days() / 7);
5378 var round
= Math
.round
,
5380 ss
: 44, // a few seconds to seconds
5381 s
: 45, // seconds to minute
5382 m
: 45, // minutes to hour
5383 h
: 22, // hours to day
5384 d
: 26, // days to month/week
5385 w
: null, // weeks to month
5386 M
: 11, // months to year
5389 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
5390 function substituteTimeAgo(string
, number
, withoutSuffix
, isFuture
, locale
) {
5391 return locale
.relativeTime(number
|| 1, !!withoutSuffix
, string
, isFuture
);
5394 function relativeTime
$1(posNegDuration
, withoutSuffix
, thresholds
, locale
) {
5395 var duration
= createDuration(posNegDuration
).abs(),
5396 seconds
= round(duration
.as('s')),
5397 minutes
= round(duration
.as('m')),
5398 hours
= round(duration
.as('h')),
5399 days
= round(duration
.as('d')),
5400 months
= round(duration
.as('M')),
5401 weeks
= round(duration
.as('w')),
5402 years
= round(duration
.as('y')),
5404 (seconds
<= thresholds
.ss
&& ['s', seconds
]) ||
5405 (seconds
< thresholds
.s
&& ['ss', seconds
]) ||
5406 (minutes
<= 1 && ['m']) ||
5407 (minutes
< thresholds
.m
&& ['mm', minutes
]) ||
5408 (hours
<= 1 && ['h']) ||
5409 (hours
< thresholds
.h
&& ['hh', hours
]) ||
5410 (days
<= 1 && ['d']) ||
5411 (days
< thresholds
.d
&& ['dd', days
]);
5413 if (thresholds
.w
!= null) {
5416 (weeks
<= 1 && ['w']) ||
5417 (weeks
< thresholds
.w
&& ['ww', weeks
]);
5420 (months
<= 1 && ['M']) ||
5421 (months
< thresholds
.M
&& ['MM', months
]) ||
5422 (years
<= 1 && ['y']) || ['yy', years
];
5424 a
[2] = withoutSuffix
;
5425 a
[3] = +posNegDuration
> 0;
5427 return substituteTimeAgo
.apply(null, a
);
5430 // This function allows you to set the rounding function for relative time strings
5431 function getSetRelativeTimeRounding(roundingFunction
) {
5432 if (roundingFunction
=== undefined) {
5435 if (typeof roundingFunction
=== 'function') {
5436 round
= roundingFunction
;
5442 // This function allows you to set a threshold for relative time strings
5443 function getSetRelativeTimeThreshold(threshold
, limit
) {
5444 if (thresholds
[threshold
] === undefined) {
5447 if (limit
=== undefined) {
5448 return thresholds
[threshold
];
5450 thresholds
[threshold
] = limit
;
5451 if (threshold
=== 's') {
5452 thresholds
.ss
= limit
- 1;
5457 function humanize(argWithSuffix
, argThresholds
) {
5458 if (!this.isValid()) {
5459 return this.localeData().invalidDate();
5462 var withSuffix
= false,
5467 if (typeof argWithSuffix
=== 'object') {
5468 argThresholds
= argWithSuffix
;
5469 argWithSuffix
= false;
5471 if (typeof argWithSuffix
=== 'boolean') {
5472 withSuffix
= argWithSuffix
;
5474 if (typeof argThresholds
=== 'object') {
5475 th
= Object
.assign({}, thresholds
, argThresholds
);
5476 if (argThresholds
.s
!= null && argThresholds
.ss
== null) {
5477 th
.ss
= argThresholds
.s
- 1;
5481 locale
= this.localeData();
5482 output
= relativeTime
$1(this, !withSuffix
, th
, locale
);
5485 output
= locale
.pastFuture(+this, output
);
5488 return locale
.postformat(output
);
5491 var abs
$1 = Math
.abs
;
5494 return (x
> 0) - (x
< 0) || +x
;
5497 function toISOString
$1() {
5498 // for ISO strings we do not use the normal bubbling rules:
5499 // * milliseconds bubble up until they become hours
5500 // * days do not bubble at all
5501 // * months bubble up until they become years
5502 // This is because there is no context-free conversion between hours and days
5503 // (think of clock changes)
5504 // and also not between days and months (28-31 days per month)
5505 if (!this.isValid()) {
5506 return this.localeData().invalidDate();
5509 var seconds
= abs
$1(this._milliseconds
) / 1000,
5510 days
= abs
$1(this._days
),
5511 months
= abs
$1(this._months
),
5516 total
= this.asSeconds(),
5523 // this is the same as C#'s (Noda) and python (isodate)...
5524 // but not other JS (goog.date)
5528 // 3600 seconds -> 60 minutes -> 1 hour
5529 minutes
= absFloor(seconds
/ 60);
5530 hours
= absFloor(minutes
/ 60);
5534 // 12 months -> 1 year
5535 years
= absFloor(months
/ 12);
5538 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
5539 s
= seconds
? seconds
.toFixed(3).replace(/\.?0+$/, '') : '';
5541 totalSign
= total
< 0 ? '-' : '';
5542 ymSign
= sign(this._months
) !== sign(total
) ? '-' : '';
5543 daysSign
= sign(this._days
) !== sign(total
) ? '-' : '';
5544 hmsSign
= sign(this._milliseconds
) !== sign(total
) ? '-' : '';
5549 (years
? ymSign
+ years
+ 'Y' : '') +
5550 (months
? ymSign
+ months
+ 'M' : '') +
5551 (days
? daysSign
+ days
+ 'D' : '') +
5552 (hours
|| minutes
|| seconds
? 'T' : '') +
5553 (hours
? hmsSign
+ hours
+ 'H' : '') +
5554 (minutes
? hmsSign
+ minutes
+ 'M' : '') +
5555 (seconds
? hmsSign
+ s
+ 'S' : '')
5559 var proto
$2 = Duration
.prototype;
5561 proto
$2.isValid
= isValid
$1;
5563 proto
$2.add
= add
$1;
5564 proto
$2.subtract
= subtract
$1;
5566 proto
$2.asMilliseconds
= asMilliseconds
;
5567 proto
$2.asSeconds
= asSeconds
;
5568 proto
$2.asMinutes
= asMinutes
;
5569 proto
$2.asHours
= asHours
;
5570 proto
$2.asDays
= asDays
;
5571 proto
$2.asWeeks
= asWeeks
;
5572 proto
$2.asMonths
= asMonths
;
5573 proto
$2.asQuarters
= asQuarters
;
5574 proto
$2.asYears
= asYears
;
5575 proto
$2.valueOf
= valueOf
$1;
5576 proto
$2._bubble
= bubble
;
5577 proto
$2.clone
= clone
$1;
5578 proto
$2.get = get$2;
5579 proto
$2.milliseconds
= milliseconds
;
5580 proto
$2.seconds
= seconds
;
5581 proto
$2.minutes
= minutes
;
5582 proto
$2.hours
= hours
;
5583 proto
$2.days
= days
;
5584 proto
$2.weeks
= weeks
;
5585 proto
$2.months
= months
;
5586 proto
$2.years
= years
;
5587 proto
$2.humanize
= humanize
;
5588 proto
$2.toISOString
= toISOString
$1;
5589 proto
$2.toString
= toISOString
$1;
5590 proto
$2.toJSON
= toISOString
$1;
5591 proto
$2.locale
= locale
;
5592 proto
$2.localeData
= localeData
;
5594 proto
$2.toIsoString
= deprecate(
5595 'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
5598 proto
$2.lang
= lang
;
5602 addFormatToken('X', 0, 0, 'unix');
5603 addFormatToken('x', 0, 0, 'valueOf');
5607 addRegexToken('x', matchSigned
);
5608 addRegexToken('X', matchTimestamp
);
5609 addParseToken('X', function (input
, array
, config
) {
5610 config
._d
= new Date(parseFloat(input
) * 1000);
5612 addParseToken('x', function (input
, array
, config
) {
5613 config
._d
= new Date(toInt(input
));
5618 hooks
.version
= '2.29.0';
5620 setHookCallback(createLocal
);
5626 hooks
.utc
= createUTC
;
5627 hooks
.unix
= createUnix
;
5628 hooks
.months
= listMonths
;
5629 hooks
.isDate
= isDate
;
5630 hooks
.locale
= getSetGlobalLocale
;
5631 hooks
.invalid
= createInvalid
;
5632 hooks
.duration
= createDuration
;
5633 hooks
.isMoment
= isMoment
;
5634 hooks
.weekdays
= listWeekdays
;
5635 hooks
.parseZone
= createInZone
;
5636 hooks
.localeData
= getLocale
;
5637 hooks
.isDuration
= isDuration
;
5638 hooks
.monthsShort
= listMonthsShort
;
5639 hooks
.weekdaysMin
= listWeekdaysMin
;
5640 hooks
.defineLocale
= defineLocale
;
5641 hooks
.updateLocale
= updateLocale
;
5642 hooks
.locales
= listLocales
;
5643 hooks
.weekdaysShort
= listWeekdaysShort
;
5644 hooks
.normalizeUnits
= normalizeUnits
;
5645 hooks
.relativeTimeRounding
= getSetRelativeTimeRounding
;
5646 hooks
.relativeTimeThreshold
= getSetRelativeTimeThreshold
;
5647 hooks
.calendarFormat
= getCalendarFormat
;
5648 hooks
.prototype = proto
;
5650 // currently HTML5 input type only supports 24-hour formats
5652 DATETIME_LOCAL
: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" />
5653 DATETIME_LOCAL_SECONDS
: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" />
5654 DATETIME_LOCAL_MS
: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" />
5655 DATE
: 'YYYY-MM-DD', // <input type="date" />
5656 TIME
: 'HH:mm', // <input type="time" />
5657 TIME_SECONDS
: 'HH:mm:ss', // <input type="time" step="1" />
5658 TIME_MS
: 'HH:mm:ss.SSS', // <input type="time" step="0.001" />
5659 WEEK
: 'GGGG-[W]WW', // <input type="week" />
5660 MONTH
: 'YYYY-MM', // <input type="month" />
5663 //! moment.js locale configuration
5665 hooks
.defineLocale('af', {
5666 months
: 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split(
5669 monthsShort
: 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
5670 weekdays
: 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split(
5673 weekdaysShort
: 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
5674 weekdaysMin
: 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
5675 meridiemParse
: /vm|nm/i,
5676 isPM: function (input
) {
5677 return /^nm$/i.test(input
);
5679 meridiem: function (hours
, minutes
, isLower
) {
5681 return isLower
? 'vm' : 'VM';
5683 return isLower
? 'nm' : 'NM';
5691 LLL
: 'D MMMM YYYY HH:mm',
5692 LLLL
: 'dddd, D MMMM YYYY HH:mm',
5695 sameDay
: '[Vandag om] LT',
5696 nextDay
: '[Môre om] LT',
5697 nextWeek
: 'dddd [om] LT',
5698 lastDay
: '[Gister om] LT',
5699 lastWeek
: '[Laas] dddd [om] LT',
5705 s
: "'n paar sekondes",
5718 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
5719 ordinal: function (number
) {
5722 (number
=== 1 || number
=== 8 || number
>= 20 ? 'ste' : 'de')
5723 ); // Thanks to Joris Röling : https://github.com/jjupiter
5726 dow
: 1, // Maandag is die eerste dag van die week.
5727 doy
: 4, // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
5731 //! moment.js locale configuration
5733 var pluralForm = function (n
) {
5740 : n
% 100 >= 3 && n
% 100 <= 10
5750 ['ثانيتان', 'ثانيتين'],
5758 ['دقيقتان', 'دقيقتين'],
5766 ['ساعتان', 'ساعتين'],
5796 pluralize = function (u
) {
5797 return function (number
, withoutSuffix
, string
, isFuture
) {
5798 var f
= pluralForm(number
),
5799 str
= plurals
[u
][pluralForm(number
)];
5801 str
= str
[withoutSuffix
? 0 : 1];
5803 return str
.replace(/%d/i, number
);
5821 hooks
.defineLocale('ar-dz', {
5823 monthsShort
: months
$1,
5824 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5825 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
5826 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
5827 weekdaysParseExact
: true,
5831 L
: 'D/\u200FM/\u200FYYYY',
5833 LLL
: 'D MMMM YYYY HH:mm',
5834 LLLL
: 'dddd D MMMM YYYY HH:mm',
5836 meridiemParse
: /ص|م/,
5837 isPM: function (input
) {
5838 return 'م' === input
;
5840 meridiem: function (hour
, minute
, isLower
) {
5848 sameDay
: '[اليوم عند الساعة] LT',
5849 nextDay
: '[غدًا عند الساعة] LT',
5850 nextWeek
: 'dddd [عند الساعة] LT',
5851 lastDay
: '[أمس عند الساعة] LT',
5852 lastWeek
: 'dddd [عند الساعة] LT',
5871 postformat: function (string
) {
5872 return string
.replace(/,/g
, '،');
5875 dow
: 0, // Sunday is the first day of the week.
5876 doy
: 4, // The week that contains Jan 4th is the first week of the year.
5880 //! moment.js locale configuration
5882 hooks
.defineLocale('ar-kw', {
5883 months
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
5886 monthsShort
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
5889 weekdays
: 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5890 weekdaysShort
: 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
5891 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
5892 weekdaysParseExact
: true,
5898 LLL
: 'D MMMM YYYY HH:mm',
5899 LLLL
: 'dddd D MMMM YYYY HH:mm',
5902 sameDay
: '[اليوم على الساعة] LT',
5903 nextDay
: '[غدا على الساعة] LT',
5904 nextWeek
: 'dddd [على الساعة] LT',
5905 lastDay
: '[أمس على الساعة] LT',
5906 lastWeek
: 'dddd [على الساعة] LT',
5926 dow
: 0, // Sunday is the first day of the week.
5927 doy
: 12, // The week that contains Jan 12th is the first week of the year.
5931 //! moment.js locale configuration
5945 pluralForm
$1 = function (n
) {
5952 : n
% 100 >= 3 && n
% 100 <= 10
5962 ['ثانيتان', 'ثانيتين'],
5970 ['دقيقتان', 'دقيقتين'],
5978 ['ساعتان', 'ساعتين'],
6008 pluralize
$1 = function (u
) {
6009 return function (number
, withoutSuffix
, string
, isFuture
) {
6010 var f
= pluralForm
$1(number
),
6011 str
= plurals
$1[u
][pluralForm
$1(number
)];
6013 str
= str
[withoutSuffix
? 0 : 1];
6015 return str
.replace(/%d/i, number
);
6033 hooks
.defineLocale('ar-ly', {
6035 monthsShort
: months
$2,
6036 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
6037 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
6038 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
6039 weekdaysParseExact
: true,
6043 L
: 'D/\u200FM/\u200FYYYY',
6045 LLL
: 'D MMMM YYYY HH:mm',
6046 LLLL
: 'dddd D MMMM YYYY HH:mm',
6048 meridiemParse
: /ص|م/,
6049 isPM: function (input
) {
6050 return 'م' === input
;
6052 meridiem: function (hour
, minute
, isLower
) {
6060 sameDay
: '[اليوم عند الساعة] LT',
6061 nextDay
: '[غدًا عند الساعة] LT',
6062 nextWeek
: 'dddd [عند الساعة] LT',
6063 lastDay
: '[أمس عند الساعة] LT',
6064 lastWeek
: 'dddd [عند الساعة] LT',
6070 s
: pluralize
$1('s'),
6071 ss
: pluralize
$1('s'),
6072 m
: pluralize
$1('m'),
6073 mm
: pluralize
$1('m'),
6074 h
: pluralize
$1('h'),
6075 hh
: pluralize
$1('h'),
6076 d
: pluralize
$1('d'),
6077 dd
: pluralize
$1('d'),
6078 M
: pluralize
$1('M'),
6079 MM
: pluralize
$1('M'),
6080 y
: pluralize
$1('y'),
6081 yy
: pluralize
$1('y'),
6083 preparse: function (string
) {
6084 return string
.replace(/،/g, ',');
6086 postformat: function (string
) {
6088 .replace(/\d/g, function (match
) {
6089 return symbolMap
[match
];
6091 .replace(/,/g
, '،');
6094 dow
: 6, // Saturday is the first day of the week.
6095 doy
: 12, // The week that contains Jan 12th is the first week of the year.
6099 //! moment.js locale configuration
6101 hooks
.defineLocale('ar-ma', {
6102 months
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
6105 monthsShort
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split(
6108 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
6109 weekdaysShort
: 'احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
6110 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
6111 weekdaysParseExact
: true,
6117 LLL
: 'D MMMM YYYY HH:mm',
6118 LLLL
: 'dddd D MMMM YYYY HH:mm',
6121 sameDay
: '[اليوم على الساعة] LT',
6122 nextDay
: '[غدا على الساعة] LT',
6123 nextWeek
: 'dddd [على الساعة] LT',
6124 lastDay
: '[أمس على الساعة] LT',
6125 lastWeek
: 'dddd [على الساعة] LT',
6145 dow
: 1, // Monday is the first day of the week.
6146 doy
: 4, // The week that contains Jan 4th is the first week of the year.
6150 //! moment.js locale configuration
6177 hooks
.defineLocale('ar-sa', {
6178 months
: 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
6181 monthsShort
: 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
6184 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
6185 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
6186 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
6187 weekdaysParseExact
: true,
6193 LLL
: 'D MMMM YYYY HH:mm',
6194 LLLL
: 'dddd D MMMM YYYY HH:mm',
6196 meridiemParse
: /ص|م/,
6197 isPM: function (input
) {
6198 return 'م' === input
;
6200 meridiem: function (hour
, minute
, isLower
) {
6208 sameDay
: '[اليوم على الساعة] LT',
6209 nextDay
: '[غدا على الساعة] LT',
6210 nextWeek
: 'dddd [على الساعة] LT',
6211 lastDay
: '[أمس على الساعة] LT',
6212 lastWeek
: 'dddd [على الساعة] LT',
6231 preparse: function (string
) {
6233 .replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match
) {
6234 return numberMap
[match
];
6236 .replace(/،/g, ',');
6238 postformat: function (string
) {
6240 .replace(/\d/g, function (match
) {
6241 return symbolMap
$1[match
];
6243 .replace(/,/g
, '،');
6246 dow
: 0, // Sunday is the first day of the week.
6247 doy
: 6, // The week that contains Jan 6th is the first week of the year.
6251 //! moment.js locale configuration
6253 hooks
.defineLocale('ar-tn', {
6254 months
: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
6257 monthsShort
: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split(
6260 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
6261 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
6262 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
6263 weekdaysParseExact
: true,
6269 LLL
: 'D MMMM YYYY HH:mm',
6270 LLLL
: 'dddd D MMMM YYYY HH:mm',
6273 sameDay
: '[اليوم على الساعة] LT',
6274 nextDay
: '[غدا على الساعة] LT',
6275 nextWeek
: 'dddd [على الساعة] LT',
6276 lastDay
: '[أمس على الساعة] LT',
6277 lastWeek
: 'dddd [على الساعة] LT',
6297 dow
: 1, // Monday is the first day of the week.
6298 doy
: 4, // The week that contains Jan 4th is the first week of the year.
6302 //! moment.js locale configuration
6328 pluralForm
$2 = function (n
) {
6335 : n
% 100 >= 3 && n
% 100 <= 10
6345 ['ثانيتان', 'ثانيتين'],
6353 ['دقيقتان', 'دقيقتين'],
6361 ['ساعتان', 'ساعتين'],
6391 pluralize
$2 = function (u
) {
6392 return function (number
, withoutSuffix
, string
, isFuture
) {
6393 var f
= pluralForm
$2(number
),
6394 str
= plurals
$2[u
][pluralForm
$2(number
)];
6396 str
= str
[withoutSuffix
? 0 : 1];
6398 return str
.replace(/%d/i, number
);
6416 hooks
.defineLocale('ar', {
6418 monthsShort
: months
$3,
6419 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
6420 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
6421 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
6422 weekdaysParseExact
: true,
6426 L
: 'D/\u200FM/\u200FYYYY',
6428 LLL
: 'D MMMM YYYY HH:mm',
6429 LLLL
: 'dddd D MMMM YYYY HH:mm',
6431 meridiemParse
: /ص|م/,
6432 isPM: function (input
) {
6433 return 'م' === input
;
6435 meridiem: function (hour
, minute
, isLower
) {
6443 sameDay
: '[اليوم عند الساعة] LT',
6444 nextDay
: '[غدًا عند الساعة] LT',
6445 nextWeek
: 'dddd [عند الساعة] LT',
6446 lastDay
: '[أمس عند الساعة] LT',
6447 lastWeek
: 'dddd [عند الساعة] LT',
6453 s
: pluralize
$2('s'),
6454 ss
: pluralize
$2('s'),
6455 m
: pluralize
$2('m'),
6456 mm
: pluralize
$2('m'),
6457 h
: pluralize
$2('h'),
6458 hh
: pluralize
$2('h'),
6459 d
: pluralize
$2('d'),
6460 dd
: pluralize
$2('d'),
6461 M
: pluralize
$2('M'),
6462 MM
: pluralize
$2('M'),
6463 y
: pluralize
$2('y'),
6464 yy
: pluralize
$2('y'),
6466 preparse: function (string
) {
6468 .replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match
) {
6469 return numberMap
$1[match
];
6471 .replace(/،/g, ',');
6473 postformat: function (string
) {
6475 .replace(/\d/g, function (match
) {
6476 return symbolMap
$2[match
];
6478 .replace(/,/g
, '،');
6481 dow
: 6, // Saturday is the first day of the week.
6482 doy
: 12, // The week that contains Jan 12th is the first week of the year.
6486 //! moment.js locale configuration
6509 hooks
.defineLocale('az', {
6510 months
: 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split(
6513 monthsShort
: 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
6514 weekdays
: 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split(
6517 weekdaysShort
: 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
6518 weekdaysMin
: 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
6519 weekdaysParseExact
: true,
6525 LLL
: 'D MMMM YYYY HH:mm',
6526 LLLL
: 'dddd, D MMMM YYYY HH:mm',
6529 sameDay
: '[bugün saat] LT',
6530 nextDay
: '[sabah saat] LT',
6531 nextWeek
: '[gələn həftə] dddd [saat] LT',
6532 lastDay
: '[dünən] LT',
6533 lastWeek
: '[keçən həftə] dddd [saat] LT',
6539 s
: 'bir neçə saniyə',
6552 meridiemParse
: /gecə|səhər|gündüz|axşam/,
6553 isPM: function (input
) {
6554 return /^(gündüz|axşam)$/.test(input
);
6556 meridiem: function (hour
, minute
, isLower
) {
6559 } else if (hour
< 12) {
6561 } else if (hour
< 17) {
6567 dayOfMonthOrdinalParse
: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
6568 ordinal: function (number
) {
6570 // special case for zero
6571 return number
+ '-ıncı';
6573 var a
= number
% 10,
6574 b
= (number
% 100) - a
,
6575 c
= number
>= 100 ? 100 : null;
6576 return number
+ (suffixes
[a
] || suffixes
[b
] || suffixes
[c
]);
6579 dow
: 1, // Monday is the first day of the week.
6580 doy
: 7, // The week that contains Jan 7th is the first week of the year.
6584 //! moment.js locale configuration
6586 function plural(word
, num
) {
6587 var forms
= word
.split('_');
6588 return num
% 10 === 1 && num
% 100 !== 11
6590 : num
% 10 >= 2 && num
% 10 <= 4 && (num
% 100 < 10 || num
% 100 >= 20)
6594 function relativeTimeWithPlural(number
, withoutSuffix
, key
) {
6596 ss
: withoutSuffix
? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
6597 mm
: withoutSuffix
? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
6598 hh
: withoutSuffix
? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
6599 dd
: 'дзень_дні_дзён',
6600 MM
: 'месяц_месяцы_месяцаў',
6601 yy
: 'год_гады_гадоў',
6604 return withoutSuffix
? 'хвіліна' : 'хвіліну';
6605 } else if (key
=== 'h') {
6606 return withoutSuffix
? 'гадзіна' : 'гадзіну';
6608 return number
+ ' ' + plural(format
[key
], +number
);
6612 hooks
.defineLocale('be', {
6614 format
: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split(
6617 standalone
: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split(
6621 monthsShort
: 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split(
6625 format
: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split(
6628 standalone
: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split(
6631 isFormat
: /\[ ?[Ууў] ?(?:мінулую|наступную)? ?\] ?dddd/,
6633 weekdaysShort
: 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
6634 weekdaysMin
: 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
6639 LL
: 'D MMMM YYYY г.',
6640 LLL
: 'D MMMM YYYY г., HH:mm',
6641 LLLL
: 'dddd, D MMMM YYYY г., HH:mm',
6644 sameDay
: '[Сёння ў] LT',
6645 nextDay
: '[Заўтра ў] LT',
6646 lastDay
: '[Учора ў] LT',
6647 nextWeek: function () {
6648 return '[У] dddd [ў] LT';
6650 lastWeek: function () {
6651 switch (this.day()) {
6656 return '[У мінулую] dddd [ў] LT';
6660 return '[У мінулы] dddd [ў] LT';
6668 s
: 'некалькі секунд',
6669 m
: relativeTimeWithPlural
,
6670 mm
: relativeTimeWithPlural
,
6671 h
: relativeTimeWithPlural
,
6672 hh
: relativeTimeWithPlural
,
6674 dd
: relativeTimeWithPlural
,
6676 MM
: relativeTimeWithPlural
,
6678 yy
: relativeTimeWithPlural
,
6680 meridiemParse
: /ночы|раніцы|дня|вечара/,
6681 isPM: function (input
) {
6682 return /^(дня|вечара)$/.test(input
);
6684 meridiem: function (hour
, minute
, isLower
) {
6687 } else if (hour
< 12) {
6689 } else if (hour
< 17) {
6695 dayOfMonthOrdinalParse
: /\d{1,2}-(і|ы|га)/,
6696 ordinal: function (number
, period
) {
6703 return (number
% 10 === 2 || number
% 10 === 3) &&
6704 number
% 100 !== 12 &&
6709 return number
+ '-га';
6715 dow
: 1, // Monday is the first day of the week.
6716 doy
: 7, // The week that contains Jan 7th is the first week of the year.
6720 //! moment.js locale configuration
6722 hooks
.defineLocale('bg', {
6723 months
: 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split(
6726 monthsShort
: 'яну_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
6727 weekdays
: 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split(
6730 weekdaysShort
: 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
6731 weekdaysMin
: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
6737 LLL
: 'D MMMM YYYY H:mm',
6738 LLLL
: 'dddd, D MMMM YYYY H:mm',
6741 sameDay
: '[Днес в] LT',
6742 nextDay
: '[Утре в] LT',
6743 nextWeek
: 'dddd [в] LT',
6744 lastDay
: '[Вчера в] LT',
6745 lastWeek: function () {
6746 switch (this.day()) {
6750 return '[Миналата] dddd [в] LT';
6755 return '[Миналия] dddd [в] LT';
6763 s
: 'няколко секунди',
6778 dayOfMonthOrdinalParse
: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
6779 ordinal: function (number
) {
6780 var lastDigit
= number
% 10,
6781 last2Digits
= number
% 100;
6783 return number
+ '-ев';
6784 } else if (last2Digits
=== 0) {
6785 return number
+ '-ен';
6786 } else if (last2Digits
> 10 && last2Digits
< 20) {
6787 return number
+ '-ти';
6788 } else if (lastDigit
=== 1) {
6789 return number
+ '-ви';
6790 } else if (lastDigit
=== 2) {
6791 return number
+ '-ри';
6792 } else if (lastDigit
=== 7 || lastDigit
=== 8) {
6793 return number
+ '-ми';
6795 return number
+ '-ти';
6799 dow
: 1, // Monday is the first day of the week.
6800 doy
: 7, // The week that contains Jan 7th is the first week of the year.
6804 //! moment.js locale configuration
6806 hooks
.defineLocale('bm', {
6807 months
: 'Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo'.split(
6810 monthsShort
: 'Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des'.split('_'),
6811 weekdays
: 'Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri'.split('_'),
6812 weekdaysShort
: 'Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib'.split('_'),
6813 weekdaysMin
: 'Ka_Nt_Ta_Ar_Al_Ju_Si'.split('_'),
6818 LL
: 'MMMM [tile] D [san] YYYY',
6819 LLL
: 'MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm',
6820 LLLL
: 'dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm',
6823 sameDay
: '[Bi lɛrɛ] LT',
6824 nextDay
: '[Sini lɛrɛ] LT',
6825 nextWeek
: 'dddd [don lɛrɛ] LT',
6826 lastDay
: '[Kunu lɛrɛ] LT',
6827 lastWeek
: 'dddd [tɛmɛnen lɛrɛ] LT',
6833 s
: 'sanga dama dama',
6847 dow
: 1, // Monday is the first day of the week.
6848 doy
: 4, // The week that contains Jan 4th is the first week of the year.
6852 //! moment.js locale configuration
6879 hooks
.defineLocale('bn-bd', {
6880 months
: 'জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split(
6883 monthsShort
: 'জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে'.split(
6886 weekdays
: 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split(
6889 weekdaysShort
: 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
6890 weekdaysMin
: 'রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি'.split('_'),
6893 LTS
: 'A h:mm:ss সময়',
6896 LLL
: 'D MMMM YYYY, A h:mm সময়',
6897 LLLL
: 'dddd, D MMMM YYYY, A h:mm সময়',
6901 nextDay
: '[আগামীকাল] LT',
6902 nextWeek
: 'dddd, LT',
6903 lastDay
: '[গতকাল] LT',
6904 lastWeek
: '[গত] dddd, LT',
6923 preparse: function (string
) {
6924 return string
.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match
) {
6925 return numberMap
$2[match
];
6928 postformat: function (string
) {
6929 return string
.replace(/\d/g, function (match
) {
6930 return symbolMap
$3[match
];
6934 meridiemParse
: /রাত|ভোর|সকাল|দুপুর|বিকাল|সন্ধ্যা|রাত/,
6935 meridiemHour: function (hour
, meridiem
) {
6939 if (meridiem
=== 'রাত') {
6940 return hour
< 4 ? hour
: hour
+ 12;
6941 } else if (meridiem
=== 'ভোর') {
6943 } else if (meridiem
=== 'সকাল') {
6945 } else if (meridiem
=== 'দুপুর') {
6946 return hour
>= 3 ? hour
: hour
+ 12;
6947 } else if (meridiem
=== 'বিকাল') {
6949 } else if (meridiem
=== 'সন্ধ্যা') {
6954 meridiem: function (hour
, minute
, isLower
) {
6957 } else if (hour
< 6) {
6959 } else if (hour
< 12) {
6961 } else if (hour
< 15) {
6963 } else if (hour
< 18) {
6965 } else if (hour
< 20) {
6972 dow
: 0, // Sunday is the first day of the week.
6973 doy
: 6, // The week that contains Jan 6th is the first week of the year.
6977 //! moment.js locale configuration
7004 hooks
.defineLocale('bn', {
7005 months
: 'জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split(
7008 monthsShort
: 'জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে'.split(
7011 weekdays
: 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split(
7014 weekdaysShort
: 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
7015 weekdaysMin
: 'রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি'.split('_'),
7018 LTS
: 'A h:mm:ss সময়',
7021 LLL
: 'D MMMM YYYY, A h:mm সময়',
7022 LLLL
: 'dddd, D MMMM YYYY, A h:mm সময়',
7026 nextDay
: '[আগামীকাল] LT',
7027 nextWeek
: 'dddd, LT',
7028 lastDay
: '[গতকাল] LT',
7029 lastWeek
: '[গত] dddd, LT',
7048 preparse: function (string
) {
7049 return string
.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match
) {
7050 return numberMap
$3[match
];
7053 postformat: function (string
) {
7054 return string
.replace(/\d/g, function (match
) {
7055 return symbolMap
$4[match
];
7058 meridiemParse
: /রাত|সকাল|দুপুর|বিকাল|রাত/,
7059 meridiemHour: function (hour
, meridiem
) {
7064 (meridiem
=== 'রাত' && hour
>= 4) ||
7065 (meridiem
=== 'দুপুর' && hour
< 5) ||
7066 meridiem
=== 'বিকাল'
7073 meridiem: function (hour
, minute
, isLower
) {
7076 } else if (hour
< 10) {
7078 } else if (hour
< 17) {
7080 } else if (hour
< 20) {
7087 dow
: 0, // Sunday is the first day of the week.
7088 doy
: 6, // The week that contains Jan 6th is the first week of the year.
7092 //! moment.js locale configuration
7119 hooks
.defineLocale('bo', {
7120 months
: 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split(
7123 monthsShort
: 'ཟླ་1_ཟླ་2_ཟླ་3_ཟླ་4_ཟླ་5_ཟླ་6_ཟླ་7_ཟླ་8_ཟླ་9_ཟླ་10_ཟླ་11_ཟླ་12'.split(
7126 monthsShortRegex
: /^(ཟླ་\d{1,2})/,
7127 monthsParseExact
: true,
7128 weekdays
: 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split(
7131 weekdaysShort
: 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split(
7134 weekdaysMin
: 'ཉི_ཟླ_མིག_ལྷག_ཕུར_སངས_སྤེན'.split('_'),
7140 LLL
: 'D MMMM YYYY, A h:mm',
7141 LLLL
: 'dddd, D MMMM YYYY, A h:mm',
7144 sameDay
: '[དི་རིང] LT',
7145 nextDay
: '[སང་ཉིན] LT',
7146 nextWeek
: '[བདུན་ཕྲག་རྗེས་མ], LT',
7147 lastDay
: '[ཁ་སང] LT',
7148 lastWeek
: '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
7167 preparse: function (string
) {
7168 return string
.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match
) {
7169 return numberMap
$4[match
];
7172 postformat: function (string
) {
7173 return string
.replace(/\d/g, function (match
) {
7174 return symbolMap
$5[match
];
7177 meridiemParse
: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
7178 meridiemHour: function (hour
, meridiem
) {
7183 (meridiem
=== 'མཚན་མོ' && hour
>= 4) ||
7184 (meridiem
=== 'ཉིན་གུང' && hour
< 5) ||
7185 meridiem
=== 'དགོང་དག'
7192 meridiem: function (hour
, minute
, isLower
) {
7195 } else if (hour
< 10) {
7197 } else if (hour
< 17) {
7199 } else if (hour
< 20) {
7206 dow
: 0, // Sunday is the first day of the week.
7207 doy
: 6, // The week that contains Jan 6th is the first week of the year.
7211 //! moment.js locale configuration
7213 function relativeTimeWithMutation(number
, withoutSuffix
, key
) {
7219 return number
+ ' ' + mutation(format
[key
], number
);
7221 function specialMutationForYears(number
) {
7222 switch (lastNumber(number
)) {
7228 return number
+ ' bloaz';
7230 return number
+ ' vloaz';
7233 function lastNumber(number
) {
7235 return lastNumber(number
% 10);
7239 function mutation(text
, number
) {
7241 return softMutation(text
);
7245 function softMutation(text
) {
7246 var mutationTable
= {
7251 if (mutationTable
[text
.charAt(0)] === undefined) {
7254 return mutationTable
[text
.charAt(0)] + text
.substring(1);
7271 monthsRegex
$1 = /^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu|gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,
7272 monthsStrictRegex
= /^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu)/i,
7273 monthsShortStrictRegex
= /^(gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,
7274 fullWeekdaysParse
= [
7283 shortWeekdaysParse
= [
7292 minWeekdaysParse
= [
7302 hooks
.defineLocale('br', {
7303 months
: 'Genver_Cʼhwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split(
7306 monthsShort
: 'Gen_Cʼhwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
7307 weekdays
: 'Sul_Lun_Meurzh_Mercʼher_Yaou_Gwener_Sadorn'.split('_'),
7308 weekdaysShort
: 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
7309 weekdaysMin
: 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
7310 weekdaysParse
: minWeekdaysParse
,
7311 fullWeekdaysParse
: fullWeekdaysParse
,
7312 shortWeekdaysParse
: shortWeekdaysParse
,
7313 minWeekdaysParse
: minWeekdaysParse
,
7315 monthsRegex
: monthsRegex
$1,
7316 monthsShortRegex
: monthsRegex
$1,
7317 monthsStrictRegex
: monthsStrictRegex
,
7318 monthsShortStrictRegex
: monthsShortStrictRegex
,
7319 monthsParse
: monthsParse
,
7320 longMonthsParse
: monthsParse
,
7321 shortMonthsParse
: monthsParse
,
7327 LL
: 'D [a viz] MMMM YYYY',
7328 LLL
: 'D [a viz] MMMM YYYY HH:mm',
7329 LLLL
: 'dddd, D [a viz] MMMM YYYY HH:mm',
7332 sameDay
: '[Hiziv da] LT',
7333 nextDay
: '[Warcʼhoazh da] LT',
7334 nextWeek
: 'dddd [da] LT',
7335 lastDay
: '[Decʼh da] LT',
7336 lastWeek
: 'dddd [paset da] LT',
7340 future
: 'a-benn %s',
7342 s
: 'un nebeud segondennoù',
7345 mm
: relativeTimeWithMutation
,
7349 dd
: relativeTimeWithMutation
,
7351 MM
: relativeTimeWithMutation
,
7353 yy
: specialMutationForYears
,
7355 dayOfMonthOrdinalParse
: /\d{1,2}(añ|vet)/,
7356 ordinal: function (number
) {
7357 var output
= number
=== 1 ? 'añ' : 'vet';
7358 return number
+ output
;
7361 dow
: 1, // Monday is the first day of the week.
7362 doy
: 4, // The week that contains Jan 4th is the first week of the year.
7364 meridiemParse
: /a.m.|g.m./, // goude merenn | a-raok merenn
7365 isPM: function (token
) {
7366 return token
=== 'g.m.';
7368 meridiem: function (hour
, minute
, isLower
) {
7369 return hour
< 12 ? 'a.m.' : 'g.m.';
7373 //! moment.js locale configuration
7375 function translate(number
, withoutSuffix
, key
) {
7376 var result
= number
+ ' ';
7380 result
+= 'sekunda';
7381 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
7382 result
+= 'sekunde';
7384 result
+= 'sekundi';
7388 return withoutSuffix
? 'jedna minuta' : 'jedne minute';
7392 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
7399 return withoutSuffix
? 'jedan sat' : 'jednog sata';
7403 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
7419 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
7420 result
+= 'mjeseca';
7422 result
+= 'mjeseci';
7428 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
7437 hooks
.defineLocale('bs', {
7438 months
: 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split(
7441 monthsShort
: 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split(
7444 monthsParseExact
: true,
7445 weekdays
: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split(
7448 weekdaysShort
: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
7449 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
7450 weekdaysParseExact
: true,
7456 LLL
: 'D. MMMM YYYY H:mm',
7457 LLLL
: 'dddd, D. MMMM YYYY H:mm',
7460 sameDay
: '[danas u] LT',
7461 nextDay
: '[sutra u] LT',
7462 nextWeek: function () {
7463 switch (this.day()) {
7465 return '[u] [nedjelju] [u] LT';
7467 return '[u] [srijedu] [u] LT';
7469 return '[u] [subotu] [u] LT';
7474 return '[u] dddd [u] LT';
7477 lastDay
: '[jučer u] LT',
7478 lastWeek: function () {
7479 switch (this.day()) {
7482 return '[prošlu] dddd [u] LT';
7484 return '[prošle] [subote] [u] LT';
7489 return '[prošli] dddd [u] LT';
7510 dayOfMonthOrdinalParse
: /\d{1,2}\./,
7513 dow
: 1, // Monday is the first day of the week.
7514 doy
: 7, // The week that contains Jan 7th is the first week of the year.
7518 //! moment.js locale configuration
7520 hooks
.defineLocale('ca', {
7522 standalone
: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split(
7525 format
: "de gener_de febrer_de març_d'abril_de maig_de juny_de juliol_d'agost_de setembre_d'octubre_de novembre_de desembre".split(
7528 isFormat
: /D[oD]?(\s)+MMMM/,
7530 monthsShort
: 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split(
7533 monthsParseExact
: true,
7534 weekdays
: 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split(
7537 weekdaysShort
: 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
7538 weekdaysMin
: 'dg_dl_dt_dc_dj_dv_ds'.split('_'),
7539 weekdaysParseExact
: true,
7544 LL
: 'D MMMM [de] YYYY',
7546 LLL
: 'D MMMM [de] YYYY [a les] H:mm',
7547 lll
: 'D MMM YYYY, H:mm',
7548 LLLL
: 'dddd D MMMM [de] YYYY [a les] H:mm',
7549 llll
: 'ddd D MMM YYYY, H:mm',
7552 sameDay: function () {
7553 return '[avui a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
7555 nextDay: function () {
7556 return '[demà a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
7558 nextWeek: function () {
7559 return 'dddd [a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
7561 lastDay: function () {
7562 return '[ahir a ' + (this.hours() !== 1 ? 'les' : 'la') + '] LT';
7564 lastWeek: function () {
7566 '[el] dddd [passat a ' +
7567 (this.hours() !== 1 ? 'les' : 'la') +
7574 future
: "d'aquí %s",
7589 dayOfMonthOrdinalParse
: /\d{1,2}(r|n|t|è|a)/,
7590 ordinal: function (number
, period
) {
7601 if (period
=== 'w' || period
=== 'W') {
7604 return number
+ output
;
7607 dow
: 1, // Monday is the first day of the week.
7608 doy
: 4, // The week that contains Jan 4th is the first week of the year.
7612 //! moment.js locale configuration
7614 var months
$4 = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split(
7617 monthsShort
= 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_'),
7624 /^(čvn|červen$|června)/i,
7625 /^(čvc|červenec|července)/i,
7632 // NOTE: 'červen' is substring of 'červenec'; therefore 'červenec' must precede 'červen' in the regex to be fully matched.
7633 // Otherwise parser matches '1. červenec' as '1. červen' + 'ec'.
7634 monthsRegex
$2 = /^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;
7636 function plural
$1(n
) {
7637 return n
> 1 && n
< 5 && ~~(n
/ 10) !== 1;
7639 function translate
$1(number
, withoutSuffix
, key
, isFuture
) {
7640 var result
= number
+ ' ';
7642 case 's': // a few seconds / in a few seconds / a few seconds ago
7643 return withoutSuffix
|| isFuture
? 'pár sekund' : 'pár sekundami';
7644 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
7645 if (withoutSuffix
|| isFuture
) {
7646 return result
+ (plural
$1(number
) ? 'sekundy' : 'sekund');
7648 return result
+ 'sekundami';
7650 case 'm': // a minute / in a minute / a minute ago
7651 return withoutSuffix
? 'minuta' : isFuture
? 'minutu' : 'minutou';
7652 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
7653 if (withoutSuffix
|| isFuture
) {
7654 return result
+ (plural
$1(number
) ? 'minuty' : 'minut');
7656 return result
+ 'minutami';
7658 case 'h': // an hour / in an hour / an hour ago
7659 return withoutSuffix
? 'hodina' : isFuture
? 'hodinu' : 'hodinou';
7660 case 'hh': // 9 hours / in 9 hours / 9 hours ago
7661 if (withoutSuffix
|| isFuture
) {
7662 return result
+ (plural
$1(number
) ? 'hodiny' : 'hodin');
7664 return result
+ 'hodinami';
7666 case 'd': // a day / in a day / a day ago
7667 return withoutSuffix
|| isFuture
? 'den' : 'dnem';
7668 case 'dd': // 9 days / in 9 days / 9 days ago
7669 if (withoutSuffix
|| isFuture
) {
7670 return result
+ (plural
$1(number
) ? 'dny' : 'dní');
7672 return result
+ 'dny';
7674 case 'M': // a month / in a month / a month ago
7675 return withoutSuffix
|| isFuture
? 'měsíc' : 'měsícem';
7676 case 'MM': // 9 months / in 9 months / 9 months ago
7677 if (withoutSuffix
|| isFuture
) {
7678 return result
+ (plural
$1(number
) ? 'měsíce' : 'měsíců');
7680 return result
+ 'měsíci';
7682 case 'y': // a year / in a year / a year ago
7683 return withoutSuffix
|| isFuture
? 'rok' : 'rokem';
7684 case 'yy': // 9 years / in 9 years / 9 years ago
7685 if (withoutSuffix
|| isFuture
) {
7686 return result
+ (plural
$1(number
) ? 'roky' : 'let');
7688 return result
+ 'lety';
7693 hooks
.defineLocale('cs', {
7695 monthsShort
: monthsShort
,
7696 monthsRegex
: monthsRegex
$2,
7697 monthsShortRegex
: monthsRegex
$2,
7698 // NOTE: 'červen' is substring of 'červenec'; therefore 'červenec' must precede 'červen' in the regex to be fully matched.
7699 // Otherwise parser matches '1. červenec' as '1. červen' + 'ec'.
7700 monthsStrictRegex
: /^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,
7701 monthsShortStrictRegex
: /^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,
7702 monthsParse
: monthsParse
$1,
7703 longMonthsParse
: monthsParse
$1,
7704 shortMonthsParse
: monthsParse
$1,
7705 weekdays
: 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
7706 weekdaysShort
: 'ne_po_út_st_čt_pá_so'.split('_'),
7707 weekdaysMin
: 'ne_po_út_st_čt_pá_so'.split('_'),
7713 LLL
: 'D. MMMM YYYY H:mm',
7714 LLLL
: 'dddd D. MMMM YYYY H:mm',
7718 sameDay
: '[dnes v] LT',
7719 nextDay
: '[zítra v] LT',
7720 nextWeek: function () {
7721 switch (this.day()) {
7723 return '[v neděli v] LT';
7726 return '[v] dddd [v] LT';
7728 return '[ve středu v] LT';
7730 return '[ve čtvrtek v] LT';
7732 return '[v pátek v] LT';
7734 return '[v sobotu v] LT';
7737 lastDay
: '[včera v] LT',
7738 lastWeek: function () {
7739 switch (this.day()) {
7741 return '[minulou neděli v] LT';
7744 return '[minulé] dddd [v] LT';
7746 return '[minulou středu v] LT';
7749 return '[minulý] dddd [v] LT';
7751 return '[minulou sobotu v] LT';
7772 dayOfMonthOrdinalParse
: /\d{1,2}\./,
7775 dow
: 1, // Monday is the first day of the week.
7776 doy
: 4, // The week that contains Jan 4th is the first week of the year.
7780 //! moment.js locale configuration
7782 hooks
.defineLocale('cv', {
7783 months
: 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split(
7786 monthsShort
: 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
7787 weekdays
: 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split(
7790 weekdaysShort
: 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
7791 weekdaysMin
: 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
7796 LL
: 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
7797 LLL
: 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
7798 LLLL
: 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
7801 sameDay
: '[Паян] LT [сехетре]',
7802 nextDay
: '[Ыран] LT [сехетре]',
7803 lastDay
: '[Ӗнер] LT [сехетре]',
7804 nextWeek
: '[Ҫитес] dddd LT [сехетре]',
7805 lastWeek
: '[Иртнӗ] dddd LT [сехетре]',
7809 future: function (output
) {
7810 var affix
= /сехет$/i.exec(output
)
7812 : /ҫул$/i.exec(output
)
7815 return output
+ affix
;
7818 s
: 'пӗр-ик ҫеккунт',
7831 dayOfMonthOrdinalParse
: /\d{1,2}-мӗш/,
7834 dow
: 1, // Monday is the first day of the week.
7835 doy
: 7, // The week that contains Jan 7th is the first week of the year.
7839 //! moment.js locale configuration
7841 hooks
.defineLocale('cy', {
7842 months
: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split(
7845 monthsShort
: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split(
7848 weekdays
: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split(
7851 weekdaysShort
: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
7852 weekdaysMin
: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
7853 weekdaysParseExact
: true,
7854 // time formats are the same as en-gb
7860 LLL
: 'D MMMM YYYY HH:mm',
7861 LLLL
: 'dddd, D MMMM YYYY HH:mm',
7864 sameDay
: '[Heddiw am] LT',
7865 nextDay
: '[Yfory am] LT',
7866 nextWeek
: 'dddd [am] LT',
7867 lastDay
: '[Ddoe am] LT',
7868 lastWeek
: 'dddd [diwethaf am] LT',
7874 s
: 'ychydig eiliadau',
7887 dayOfMonthOrdinalParse
: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
7888 // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
7889 ordinal: function (number
) {
7903 'fed', // 1af to 10fed
7913 'fed', // 11eg to 20fed
7916 if (b
=== 40 || b
=== 50 || b
=== 60 || b
=== 80 || b
=== 100) {
7917 output
= 'fed'; // not 30ain, 70ain or 90ain
7924 return number
+ output
;
7927 dow
: 1, // Monday is the first day of the week.
7928 doy
: 4, // The week that contains Jan 4th is the first week of the year.
7932 //! moment.js locale configuration
7934 hooks
.defineLocale('da', {
7935 months
: 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split(
7938 monthsShort
: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
7939 weekdays
: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
7940 weekdaysShort
: 'søn_man_tir_ons_tor_fre_lør'.split('_'),
7941 weekdaysMin
: 'sø_ma_ti_on_to_fr_lø'.split('_'),
7947 LLL
: 'D. MMMM YYYY HH:mm',
7948 LLLL
: 'dddd [d.] D. MMMM YYYY [kl.] HH:mm',
7951 sameDay
: '[i dag kl.] LT',
7952 nextDay
: '[i morgen kl.] LT',
7953 nextWeek
: 'på dddd [kl.] LT',
7954 lastDay
: '[i går kl.] LT',
7955 lastWeek
: '[i] dddd[s kl.] LT',
7974 dayOfMonthOrdinalParse
: /\d{1,2}\./,
7977 dow
: 1, // Monday is the first day of the week.
7978 doy
: 4, // The week that contains Jan 4th is the first week of the year.
7982 //! moment.js locale configuration
7984 function processRelativeTime(number
, withoutSuffix
, key
, isFuture
) {
7986 m
: ['eine Minute', 'einer Minute'],
7987 h
: ['eine Stunde', 'einer Stunde'],
7988 d
: ['ein Tag', 'einem Tag'],
7989 dd
: [number
+ ' Tage', number
+ ' Tagen'],
7990 w
: ['eine Woche', 'einer Woche'],
7991 M
: ['ein Monat', 'einem Monat'],
7992 MM
: [number
+ ' Monate', number
+ ' Monaten'],
7993 y
: ['ein Jahr', 'einem Jahr'],
7994 yy
: [number
+ ' Jahre', number
+ ' Jahren'],
7996 return withoutSuffix
? format
[key
][0] : format
[key
][1];
7999 hooks
.defineLocale('de-at', {
8000 months
: 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split(
8003 monthsShort
: 'Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split(
8006 monthsParseExact
: true,
8007 weekdays
: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split(
8010 weekdaysShort
: 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
8011 weekdaysMin
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
8012 weekdaysParseExact
: true,
8018 LLL
: 'D. MMMM YYYY HH:mm',
8019 LLLL
: 'dddd, D. MMMM YYYY HH:mm',
8022 sameDay
: '[heute um] LT [Uhr]',
8024 nextDay
: '[morgen um] LT [Uhr]',
8025 nextWeek
: 'dddd [um] LT [Uhr]',
8026 lastDay
: '[gestern um] LT [Uhr]',
8027 lastWeek
: '[letzten] dddd [um] LT [Uhr]',
8032 s
: 'ein paar Sekunden',
8034 m
: processRelativeTime
,
8036 h
: processRelativeTime
,
8038 d
: processRelativeTime
,
8039 dd
: processRelativeTime
,
8040 w
: processRelativeTime
,
8042 M
: processRelativeTime
,
8043 MM
: processRelativeTime
,
8044 y
: processRelativeTime
,
8045 yy
: processRelativeTime
,
8047 dayOfMonthOrdinalParse
: /\d{1,2}\./,
8050 dow
: 1, // Monday is the first day of the week.
8051 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8055 //! moment.js locale configuration
8057 function processRelativeTime
$1(number
, withoutSuffix
, key
, isFuture
) {
8059 m
: ['eine Minute', 'einer Minute'],
8060 h
: ['eine Stunde', 'einer Stunde'],
8061 d
: ['ein Tag', 'einem Tag'],
8062 dd
: [number
+ ' Tage', number
+ ' Tagen'],
8063 w
: ['eine Woche', 'einer Woche'],
8064 M
: ['ein Monat', 'einem Monat'],
8065 MM
: [number
+ ' Monate', number
+ ' Monaten'],
8066 y
: ['ein Jahr', 'einem Jahr'],
8067 yy
: [number
+ ' Jahre', number
+ ' Jahren'],
8069 return withoutSuffix
? format
[key
][0] : format
[key
][1];
8072 hooks
.defineLocale('de-ch', {
8073 months
: 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split(
8076 monthsShort
: 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split(
8079 monthsParseExact
: true,
8080 weekdays
: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split(
8083 weekdaysShort
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
8084 weekdaysMin
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
8085 weekdaysParseExact
: true,
8091 LLL
: 'D. MMMM YYYY HH:mm',
8092 LLLL
: 'dddd, D. MMMM YYYY HH:mm',
8095 sameDay
: '[heute um] LT [Uhr]',
8097 nextDay
: '[morgen um] LT [Uhr]',
8098 nextWeek
: 'dddd [um] LT [Uhr]',
8099 lastDay
: '[gestern um] LT [Uhr]',
8100 lastWeek
: '[letzten] dddd [um] LT [Uhr]',
8105 s
: 'ein paar Sekunden',
8107 m
: processRelativeTime
$1,
8109 h
: processRelativeTime
$1,
8111 d
: processRelativeTime
$1,
8112 dd
: processRelativeTime
$1,
8113 w
: processRelativeTime
$1,
8115 M
: processRelativeTime
$1,
8116 MM
: processRelativeTime
$1,
8117 y
: processRelativeTime
$1,
8118 yy
: processRelativeTime
$1,
8120 dayOfMonthOrdinalParse
: /\d{1,2}\./,
8123 dow
: 1, // Monday is the first day of the week.
8124 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8128 //! moment.js locale configuration
8130 function processRelativeTime
$2(number
, withoutSuffix
, key
, isFuture
) {
8132 m
: ['eine Minute', 'einer Minute'],
8133 h
: ['eine Stunde', 'einer Stunde'],
8134 d
: ['ein Tag', 'einem Tag'],
8135 dd
: [number
+ ' Tage', number
+ ' Tagen'],
8136 w
: ['eine Woche', 'einer Woche'],
8137 M
: ['ein Monat', 'einem Monat'],
8138 MM
: [number
+ ' Monate', number
+ ' Monaten'],
8139 y
: ['ein Jahr', 'einem Jahr'],
8140 yy
: [number
+ ' Jahre', number
+ ' Jahren'],
8142 return withoutSuffix
? format
[key
][0] : format
[key
][1];
8145 hooks
.defineLocale('de', {
8146 months
: 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split(
8149 monthsShort
: 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split(
8152 monthsParseExact
: true,
8153 weekdays
: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split(
8156 weekdaysShort
: 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
8157 weekdaysMin
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
8158 weekdaysParseExact
: true,
8164 LLL
: 'D. MMMM YYYY HH:mm',
8165 LLLL
: 'dddd, D. MMMM YYYY HH:mm',
8168 sameDay
: '[heute um] LT [Uhr]',
8170 nextDay
: '[morgen um] LT [Uhr]',
8171 nextWeek
: 'dddd [um] LT [Uhr]',
8172 lastDay
: '[gestern um] LT [Uhr]',
8173 lastWeek
: '[letzten] dddd [um] LT [Uhr]',
8178 s
: 'ein paar Sekunden',
8180 m
: processRelativeTime
$2,
8182 h
: processRelativeTime
$2,
8184 d
: processRelativeTime
$2,
8185 dd
: processRelativeTime
$2,
8186 w
: processRelativeTime
$2,
8188 M
: processRelativeTime
$2,
8189 MM
: processRelativeTime
$2,
8190 y
: processRelativeTime
$2,
8191 yy
: processRelativeTime
$2,
8193 dayOfMonthOrdinalParse
: /\d{1,2}\./,
8196 dow
: 1, // Monday is the first day of the week.
8197 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8201 //! moment.js locale configuration
8227 hooks
.defineLocale('dv', {
8229 monthsShort
: months
$5,
8231 weekdaysShort
: weekdays
,
8232 weekdaysMin
: 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
8238 LLL
: 'D MMMM YYYY HH:mm',
8239 LLLL
: 'dddd D MMMM YYYY HH:mm',
8241 meridiemParse
: /މކ|މފ/,
8242 isPM: function (input
) {
8243 return 'މފ' === input
;
8245 meridiem: function (hour
, minute
, isLower
) {
8253 sameDay
: '[މިއަދު] LT',
8254 nextDay
: '[މާދަމާ] LT',
8255 nextWeek
: 'dddd LT',
8256 lastDay
: '[އިއްޔެ] LT',
8257 lastWeek
: '[ފާއިތުވި] dddd LT',
8261 future
: 'ތެރޭގައި %s',
8263 s
: 'ސިކުންތުކޮޅެއް',
8276 preparse: function (string
) {
8277 return string
.replace(/،/g, ',');
8279 postformat: function (string
) {
8280 return string
.replace(/,/g
, '،');
8283 dow
: 7, // Sunday is the first day of the week.
8284 doy
: 12, // The week that contains Jan 12th is the first week of the year.
8288 //! moment.js locale configuration
8290 function isFunction
$1(input
) {
8292 (typeof Function
!== 'undefined' && input
instanceof Function
) ||
8293 Object
.prototype.toString
.call(input
) === '[object Function]'
8297 hooks
.defineLocale('el', {
8298 monthsNominativeEl
: 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split(
8301 monthsGenitiveEl
: 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split(
8304 months: function (momentToFormat
, format
) {
8305 if (!momentToFormat
) {
8306 return this._monthsNominativeEl
;
8308 typeof format
=== 'string' &&
8309 /D
/.test(format
.substring(0, format
.indexOf('MMMM')))
8311 // if there is a day number before 'MMMM'
8312 return this._monthsGenitiveEl
[momentToFormat
.month()];
8314 return this._monthsNominativeEl
[momentToFormat
.month()];
8317 monthsShort
: 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
8318 weekdays
: 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split(
8321 weekdaysShort
: 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
8322 weekdaysMin
: 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
8323 meridiem: function (hours
, minutes
, isLower
) {
8325 return isLower
? 'μμ' : 'ΜΜ';
8327 return isLower
? 'πμ' : 'ΠΜ';
8330 isPM: function (input
) {
8331 return (input
+ '').toLowerCase()[0] === 'μ';
8333 meridiemParse
: /[ΠΜ]\.?Μ?\.?/i,
8339 LLL
: 'D MMMM YYYY h:mm A',
8340 LLLL
: 'dddd, D MMMM YYYY h:mm A',
8343 sameDay
: '[Σήμερα {}] LT',
8344 nextDay
: '[Αύριο {}] LT',
8345 nextWeek
: 'dddd [{}] LT',
8346 lastDay
: '[Χθες {}] LT',
8347 lastWeek: function () {
8348 switch (this.day()) {
8350 return '[το προηγούμενο] dddd [{}] LT';
8352 return '[την προηγούμενη] dddd [{}] LT';
8357 calendar: function (key
, mom
) {
8358 var output
= this._calendarEl
[key
],
8359 hours
= mom
&& mom
.hours();
8360 if (isFunction
$1(output
)) {
8361 output
= output
.apply(mom
);
8363 return output
.replace('{}', hours
% 12 === 1 ? 'στη' : 'στις');
8368 s
: 'λίγα δευτερόλεπτα',
8369 ss
: '%d δευτερόλεπτα',
8381 dayOfMonthOrdinalParse
: /\d{1,2}η/,
8384 dow
: 1, // Monday is the first day of the week.
8385 doy
: 4, // The week that contains Jan 4st is the first week of the year.
8389 //! moment.js locale configuration
8391 hooks
.defineLocale('en-au', {
8392 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8395 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8396 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8399 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8400 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8406 LLL
: 'D MMMM YYYY h:mm A',
8407 LLLL
: 'dddd, D MMMM YYYY h:mm A',
8410 sameDay
: '[Today at] LT',
8411 nextDay
: '[Tomorrow at] LT',
8412 nextWeek
: 'dddd [at] LT',
8413 lastDay
: '[Yesterday at] LT',
8414 lastWeek
: '[Last] dddd [at] LT',
8433 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8434 ordinal: function (number
) {
8435 var b
= number
% 10,
8437 ~~((number
% 100) / 10) === 1
8446 return number
+ output
;
8449 dow
: 0, // Sunday is the first day of the week.
8450 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8454 //! moment.js locale configuration
8456 hooks
.defineLocale('en-ca', {
8457 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8460 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8461 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8464 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8465 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8471 LLL
: 'MMMM D, YYYY h:mm A',
8472 LLLL
: 'dddd, MMMM D, YYYY h:mm A',
8475 sameDay
: '[Today at] LT',
8476 nextDay
: '[Tomorrow at] LT',
8477 nextWeek
: 'dddd [at] LT',
8478 lastDay
: '[Yesterday at] LT',
8479 lastWeek
: '[Last] dddd [at] LT',
8498 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8499 ordinal: function (number
) {
8500 var b
= number
% 10,
8502 ~~((number
% 100) / 10) === 1
8511 return number
+ output
;
8515 //! moment.js locale configuration
8517 hooks
.defineLocale('en-gb', {
8518 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8521 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8522 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8525 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8526 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8532 LLL
: 'D MMMM YYYY HH:mm',
8533 LLLL
: 'dddd, D MMMM YYYY HH:mm',
8536 sameDay
: '[Today at] LT',
8537 nextDay
: '[Tomorrow at] LT',
8538 nextWeek
: 'dddd [at] LT',
8539 lastDay
: '[Yesterday at] LT',
8540 lastWeek
: '[Last] dddd [at] LT',
8559 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8560 ordinal: function (number
) {
8561 var b
= number
% 10,
8563 ~~((number
% 100) / 10) === 1
8572 return number
+ output
;
8575 dow
: 1, // Monday is the first day of the week.
8576 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8580 //! moment.js locale configuration
8582 hooks
.defineLocale('en-ie', {
8583 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8586 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8587 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8590 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8591 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8597 LLL
: 'D MMMM YYYY HH:mm',
8598 LLLL
: 'dddd D MMMM YYYY HH:mm',
8601 sameDay
: '[Today at] LT',
8602 nextDay
: '[Tomorrow at] LT',
8603 nextWeek
: 'dddd [at] LT',
8604 lastDay
: '[Yesterday at] LT',
8605 lastWeek
: '[Last] dddd [at] LT',
8624 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8625 ordinal: function (number
) {
8626 var b
= number
% 10,
8628 ~~((number
% 100) / 10) === 1
8637 return number
+ output
;
8640 dow
: 1, // Monday is the first day of the week.
8641 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8645 //! moment.js locale configuration
8647 hooks
.defineLocale('en-il', {
8648 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8651 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8652 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8655 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8656 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8662 LLL
: 'D MMMM YYYY HH:mm',
8663 LLLL
: 'dddd, D MMMM YYYY HH:mm',
8666 sameDay
: '[Today at] LT',
8667 nextDay
: '[Tomorrow at] LT',
8668 nextWeek
: 'dddd [at] LT',
8669 lastDay
: '[Yesterday at] LT',
8670 lastWeek
: '[Last] dddd [at] LT',
8689 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8690 ordinal: function (number
) {
8691 var b
= number
% 10,
8693 ~~((number
% 100) / 10) === 1
8702 return number
+ output
;
8706 //! moment.js locale configuration
8708 hooks
.defineLocale('en-in', {
8709 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8712 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8713 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8716 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8717 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8723 LLL
: 'D MMMM YYYY h:mm A',
8724 LLLL
: 'dddd, D MMMM YYYY h:mm A',
8727 sameDay
: '[Today at] LT',
8728 nextDay
: '[Tomorrow at] LT',
8729 nextWeek
: 'dddd [at] LT',
8730 lastDay
: '[Yesterday at] LT',
8731 lastWeek
: '[Last] dddd [at] LT',
8750 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8751 ordinal: function (number
) {
8752 var b
= number
% 10,
8754 ~~((number
% 100) / 10) === 1
8763 return number
+ output
;
8766 dow
: 0, // Sunday is the first day of the week.
8767 doy
: 6, // The week that contains Jan 1st is the first week of the year.
8771 //! moment.js locale configuration
8773 hooks
.defineLocale('en-nz', {
8774 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8777 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8778 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8781 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8782 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8788 LLL
: 'D MMMM YYYY h:mm A',
8789 LLLL
: 'dddd, D MMMM YYYY h:mm A',
8792 sameDay
: '[Today at] LT',
8793 nextDay
: '[Tomorrow at] LT',
8794 nextWeek
: 'dddd [at] LT',
8795 lastDay
: '[Yesterday at] LT',
8796 lastWeek
: '[Last] dddd [at] LT',
8815 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8816 ordinal: function (number
) {
8817 var b
= number
% 10,
8819 ~~((number
% 100) / 10) === 1
8828 return number
+ output
;
8831 dow
: 1, // Monday is the first day of the week.
8832 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8836 //! moment.js locale configuration
8838 hooks
.defineLocale('en-sg', {
8839 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split(
8842 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
8843 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split(
8846 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
8847 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
8853 LLL
: 'D MMMM YYYY HH:mm',
8854 LLLL
: 'dddd, D MMMM YYYY HH:mm',
8857 sameDay
: '[Today at] LT',
8858 nextDay
: '[Tomorrow at] LT',
8859 nextWeek
: 'dddd [at] LT',
8860 lastDay
: '[Yesterday at] LT',
8861 lastWeek
: '[Last] dddd [at] LT',
8880 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
8881 ordinal: function (number
) {
8882 var b
= number
% 10,
8884 ~~((number
% 100) / 10) === 1
8893 return number
+ output
;
8896 dow
: 1, // Monday is the first day of the week.
8897 doy
: 4, // The week that contains Jan 4th is the first week of the year.
8901 //! moment.js locale configuration
8903 hooks
.defineLocale('eo', {
8904 months
: 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split(
8907 monthsShort
: 'jan_feb_mart_apr_maj_jun_jul_aŭg_sept_okt_nov_dec'.split('_'),
8908 weekdays
: 'dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato'.split('_'),
8909 weekdaysShort
: 'dim_lun_mard_merk_ĵaŭ_ven_sab'.split('_'),
8910 weekdaysMin
: 'di_lu_ma_me_ĵa_ve_sa'.split('_'),
8915 LL
: '[la] D[-an de] MMMM, YYYY',
8916 LLL
: '[la] D[-an de] MMMM, YYYY HH:mm',
8917 LLLL
: 'dddd[n], [la] D[-an de] MMMM, YYYY HH:mm',
8918 llll
: 'ddd, [la] D[-an de] MMM, YYYY HH:mm',
8920 meridiemParse
: /[ap]\.t\.m/i,
8921 isPM: function (input
) {
8922 return input
.charAt(0).toLowerCase() === 'p';
8924 meridiem: function (hours
, minutes
, isLower
) {
8926 return isLower
? 'p.t.m.' : 'P.T.M.';
8928 return isLower
? 'a.t.m.' : 'A.T.M.';
8932 sameDay
: '[Hodiaŭ je] LT',
8933 nextDay
: '[Morgaŭ je] LT',
8934 nextWeek
: 'dddd[n je] LT',
8935 lastDay
: '[Hieraŭ je] LT',
8936 lastWeek
: '[pasintan] dddd[n je] LT',
8942 s
: 'kelkaj sekundoj',
8948 d
: 'unu tago', //ne 'diurno', ĉar estas uzita por proksimumo
8955 dayOfMonthOrdinalParse
: /\d{1,2}a/,
8958 dow
: 1, // Monday is the first day of the week.
8959 doy
: 7, // The week that contains Jan 7th is the first week of the year.
8963 //! moment.js locale configuration
8965 var monthsShortDot
= 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
8968 monthsShort
$1 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
8983 monthsRegex
$3 = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
8985 hooks
.defineLocale('es-do', {
8986 months
: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
8989 monthsShort: function (m
, format
) {
8991 return monthsShortDot
;
8992 } else if (/-MMM-/.test(format
)) {
8993 return monthsShort
$1[m
.month()];
8995 return monthsShortDot
[m
.month()];
8998 monthsRegex
: monthsRegex
$3,
8999 monthsShortRegex
: monthsRegex
$3,
9000 monthsStrictRegex
: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
9001 monthsShortStrictRegex
: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
9002 monthsParse
: monthsParse
$2,
9003 longMonthsParse
: monthsParse
$2,
9004 shortMonthsParse
: monthsParse
$2,
9005 weekdays
: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
9006 weekdaysShort
: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
9007 weekdaysMin
: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
9008 weekdaysParseExact
: true,
9013 LL
: 'D [de] MMMM [de] YYYY',
9014 LLL
: 'D [de] MMMM [de] YYYY h:mm A',
9015 LLLL
: 'dddd, D [de] MMMM [de] YYYY h:mm A',
9018 sameDay: function () {
9019 return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9021 nextDay: function () {
9022 return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9024 nextWeek: function () {
9025 return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9027 lastDay: function () {
9028 return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9030 lastWeek: function () {
9032 '[el] dddd [pasado a la' +
9033 (this.hours() !== 1 ? 's' : '') +
9057 dayOfMonthOrdinalParse
: /\d{1,2}º/,
9060 dow
: 1, // Monday is the first day of the week.
9061 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9065 //! moment.js locale configuration
9067 var monthsShortDot
$1 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
9070 monthsShort
$2 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
9085 monthsRegex
$4 = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
9087 hooks
.defineLocale('es-mx', {
9088 months
: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
9091 monthsShort: function (m
, format
) {
9093 return monthsShortDot
$1;
9094 } else if (/-MMM-/.test(format
)) {
9095 return monthsShort
$2[m
.month()];
9097 return monthsShortDot
$1[m
.month()];
9100 monthsRegex
: monthsRegex
$4,
9101 monthsShortRegex
: monthsRegex
$4,
9102 monthsStrictRegex
: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
9103 monthsShortStrictRegex
: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
9104 monthsParse
: monthsParse
$3,
9105 longMonthsParse
: monthsParse
$3,
9106 shortMonthsParse
: monthsParse
$3,
9107 weekdays
: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
9108 weekdaysShort
: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
9109 weekdaysMin
: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
9110 weekdaysParseExact
: true,
9115 LL
: 'D [de] MMMM [de] YYYY',
9116 LLL
: 'D [de] MMMM [de] YYYY H:mm',
9117 LLLL
: 'dddd, D [de] MMMM [de] YYYY H:mm',
9120 sameDay: function () {
9121 return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9123 nextDay: function () {
9124 return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9126 nextWeek: function () {
9127 return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9129 lastDay: function () {
9130 return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9132 lastWeek: function () {
9134 '[el] dddd [pasado a la' +
9135 (this.hours() !== 1 ? 's' : '') +
9159 dayOfMonthOrdinalParse
: /\d{1,2}º/,
9162 dow
: 0, // Sunday is the first day of the week.
9163 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9165 invalidDate
: 'Fecha inválida',
9168 //! moment.js locale configuration
9170 var monthsShortDot
$2 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
9173 monthsShort
$3 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
9188 monthsRegex
$5 = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
9190 hooks
.defineLocale('es-us', {
9191 months
: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
9194 monthsShort: function (m
, format
) {
9196 return monthsShortDot
$2;
9197 } else if (/-MMM-/.test(format
)) {
9198 return monthsShort
$3[m
.month()];
9200 return monthsShortDot
$2[m
.month()];
9203 monthsRegex
: monthsRegex
$5,
9204 monthsShortRegex
: monthsRegex
$5,
9205 monthsStrictRegex
: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
9206 monthsShortStrictRegex
: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
9207 monthsParse
: monthsParse
$4,
9208 longMonthsParse
: monthsParse
$4,
9209 shortMonthsParse
: monthsParse
$4,
9210 weekdays
: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
9211 weekdaysShort
: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
9212 weekdaysMin
: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
9213 weekdaysParseExact
: true,
9218 LL
: 'D [de] MMMM [de] YYYY',
9219 LLL
: 'D [de] MMMM [de] YYYY h:mm A',
9220 LLLL
: 'dddd, D [de] MMMM [de] YYYY h:mm A',
9223 sameDay: function () {
9224 return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9226 nextDay: function () {
9227 return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9229 nextWeek: function () {
9230 return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9232 lastDay: function () {
9233 return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9235 lastWeek: function () {
9237 '[el] dddd [pasado a la' +
9238 (this.hours() !== 1 ? 's' : '') +
9262 dayOfMonthOrdinalParse
: /\d{1,2}º/,
9265 dow
: 0, // Sunday is the first day of the week.
9266 doy
: 6, // The week that contains Jan 6th is the first week of the year.
9270 //! moment.js locale configuration
9272 var monthsShortDot
$3 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split(
9275 monthsShort
$4 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_'),
9290 monthsRegex
$6 = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
9292 hooks
.defineLocale('es', {
9293 months
: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
9296 monthsShort: function (m
, format
) {
9298 return monthsShortDot
$3;
9299 } else if (/-MMM-/.test(format
)) {
9300 return monthsShort
$4[m
.month()];
9302 return monthsShortDot
$3[m
.month()];
9305 monthsRegex
: monthsRegex
$6,
9306 monthsShortRegex
: monthsRegex
$6,
9307 monthsStrictRegex
: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
9308 monthsShortStrictRegex
: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
9309 monthsParse
: monthsParse
$5,
9310 longMonthsParse
: monthsParse
$5,
9311 shortMonthsParse
: monthsParse
$5,
9312 weekdays
: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
9313 weekdaysShort
: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
9314 weekdaysMin
: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
9315 weekdaysParseExact
: true,
9320 LL
: 'D [de] MMMM [de] YYYY',
9321 LLL
: 'D [de] MMMM [de] YYYY H:mm',
9322 LLLL
: 'dddd, D [de] MMMM [de] YYYY H:mm',
9325 sameDay: function () {
9326 return '[hoy a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9328 nextDay: function () {
9329 return '[mañana a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9331 nextWeek: function () {
9332 return 'dddd [a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9334 lastDay: function () {
9335 return '[ayer a la' + (this.hours() !== 1 ? 's' : '') + '] LT';
9337 lastWeek: function () {
9339 '[el] dddd [pasado a la' +
9340 (this.hours() !== 1 ? 's' : '') +
9364 dayOfMonthOrdinalParse
: /\d{1,2}º/,
9367 dow
: 1, // Monday is the first day of the week.
9368 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9370 invalidDate
: 'Fecha inválida',
9373 //! moment.js locale configuration
9375 function processRelativeTime
$3(number
, withoutSuffix
, key
, isFuture
) {
9377 s
: ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
9378 ss
: [number
+ 'sekundi', number
+ 'sekundit'],
9379 m
: ['ühe minuti', 'üks minut'],
9380 mm
: [number
+ ' minuti', number
+ ' minutit'],
9381 h
: ['ühe tunni', 'tund aega', 'üks tund'],
9382 hh
: [number
+ ' tunni', number
+ ' tundi'],
9383 d
: ['ühe päeva', 'üks päev'],
9384 M
: ['kuu aja', 'kuu aega', 'üks kuu'],
9385 MM
: [number
+ ' kuu', number
+ ' kuud'],
9386 y
: ['ühe aasta', 'aasta', 'üks aasta'],
9387 yy
: [number
+ ' aasta', number
+ ' aastat'],
9389 if (withoutSuffix
) {
9390 return format
[key
][2] ? format
[key
][2] : format
[key
][1];
9392 return isFuture
? format
[key
][0] : format
[key
][1];
9395 hooks
.defineLocale('et', {
9396 months
: 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split(
9399 monthsShort
: 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split(
9402 weekdays
: 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split(
9405 weekdaysShort
: 'P_E_T_K_N_R_L'.split('_'),
9406 weekdaysMin
: 'P_E_T_K_N_R_L'.split('_'),
9412 LLL
: 'D. MMMM YYYY H:mm',
9413 LLLL
: 'dddd, D. MMMM YYYY H:mm',
9416 sameDay
: '[Täna,] LT',
9417 nextDay
: '[Homme,] LT',
9418 nextWeek
: '[Järgmine] dddd LT',
9419 lastDay
: '[Eile,] LT',
9420 lastWeek
: '[Eelmine] dddd LT',
9424 future
: '%s pärast',
9426 s
: processRelativeTime
$3,
9427 ss
: processRelativeTime
$3,
9428 m
: processRelativeTime
$3,
9429 mm
: processRelativeTime
$3,
9430 h
: processRelativeTime
$3,
9431 hh
: processRelativeTime
$3,
9432 d
: processRelativeTime
$3,
9434 M
: processRelativeTime
$3,
9435 MM
: processRelativeTime
$3,
9436 y
: processRelativeTime
$3,
9437 yy
: processRelativeTime
$3,
9439 dayOfMonthOrdinalParse
: /\d{1,2}\./,
9442 dow
: 1, // Monday is the first day of the week.
9443 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9447 //! moment.js locale configuration
9449 hooks
.defineLocale('eu', {
9450 months
: 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split(
9453 monthsShort
: 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split(
9456 monthsParseExact
: true,
9457 weekdays
: 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split(
9460 weekdaysShort
: 'ig._al._ar._az._og._ol._lr.'.split('_'),
9461 weekdaysMin
: 'ig_al_ar_az_og_ol_lr'.split('_'),
9462 weekdaysParseExact
: true,
9467 LL
: 'YYYY[ko] MMMM[ren] D[a]',
9468 LLL
: 'YYYY[ko] MMMM[ren] D[a] HH:mm',
9469 LLLL
: 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
9471 ll
: 'YYYY[ko] MMM D[a]',
9472 lll
: 'YYYY[ko] MMM D[a] HH:mm',
9473 llll
: 'ddd, YYYY[ko] MMM D[a] HH:mm',
9476 sameDay
: '[gaur] LT[etan]',
9477 nextDay
: '[bihar] LT[etan]',
9478 nextWeek
: 'dddd LT[etan]',
9479 lastDay
: '[atzo] LT[etan]',
9480 lastWeek
: '[aurreko] dddd LT[etan]',
9486 s
: 'segundo batzuk',
9499 dayOfMonthOrdinalParse
: /\d{1,2}\./,
9502 dow
: 1, // Monday is the first day of the week.
9503 doy
: 7, // The week that contains Jan 7th is the first week of the year.
9507 //! moment.js locale configuration
9534 hooks
.defineLocale('fa', {
9535 months
: 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split(
9538 monthsShort
: 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split(
9541 weekdays
: 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split(
9544 weekdaysShort
: 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split(
9547 weekdaysMin
: 'ی_د_س_چ_پ_ج_ش'.split('_'),
9548 weekdaysParseExact
: true,
9554 LLL
: 'D MMMM YYYY HH:mm',
9555 LLLL
: 'dddd, D MMMM YYYY HH:mm',
9557 meridiemParse
: /قبل از ظهر|بعد از ظهر/,
9558 isPM: function (input
) {
9559 return /بعد از ظهر/.test(input
);
9561 meridiem: function (hour
, minute
, isLower
) {
9563 return 'قبل از ظهر';
9565 return 'بعد از ظهر';
9569 sameDay
: '[امروز ساعت] LT',
9570 nextDay
: '[فردا ساعت] LT',
9571 nextWeek
: 'dddd [ساعت] LT',
9572 lastDay
: '[دیروز ساعت] LT',
9573 lastWeek
: 'dddd [پیش] [ساعت] LT',
9592 preparse: function (string
) {
9594 .replace(/[۰-۹]/g, function (match
) {
9595 return numberMap
$5[match
];
9597 .replace(/،/g, ',');
9599 postformat: function (string
) {
9601 .replace(/\d/g, function (match
) {
9602 return symbolMap
$6[match
];
9604 .replace(/,/g
, '،');
9606 dayOfMonthOrdinalParse
: /\d{1,2}م/,
9609 dow
: 6, // Saturday is the first day of the week.
9610 doy
: 12, // The week that contains Jan 12th is the first week of the year.
9614 //! moment.js locale configuration
9616 var numbersPast
= 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(
9631 function translate
$2(number
, withoutSuffix
, key
, isFuture
) {
9635 return isFuture
? 'muutaman sekunnin' : 'muutama sekunti';
9637 result
= isFuture
? 'sekunnin' : 'sekuntia';
9640 return isFuture
? 'minuutin' : 'minuutti';
9642 result
= isFuture
? 'minuutin' : 'minuuttia';
9645 return isFuture
? 'tunnin' : 'tunti';
9647 result
= isFuture
? 'tunnin' : 'tuntia';
9650 return isFuture
? 'päivän' : 'päivä';
9652 result
= isFuture
? 'päivän' : 'päivää';
9655 return isFuture
? 'kuukauden' : 'kuukausi';
9657 result
= isFuture
? 'kuukauden' : 'kuukautta';
9660 return isFuture
? 'vuoden' : 'vuosi';
9662 result
= isFuture
? 'vuoden' : 'vuotta';
9665 result
= verbalNumber(number
, isFuture
) + ' ' + result
;
9668 function verbalNumber(number
, isFuture
) {
9671 ? numbersFuture
[number
]
9672 : numbersPast
[number
]
9676 hooks
.defineLocale('fi', {
9677 months
: 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split(
9680 monthsShort
: 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split(
9683 weekdays
: 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split(
9686 weekdaysShort
: 'su_ma_ti_ke_to_pe_la'.split('_'),
9687 weekdaysMin
: 'su_ma_ti_ke_to_pe_la'.split('_'),
9692 LL
: 'Do MMMM[ta] YYYY',
9693 LLL
: 'Do MMMM[ta] YYYY, [klo] HH.mm',
9694 LLLL
: 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
9697 lll
: 'Do MMM YYYY, [klo] HH.mm',
9698 llll
: 'ddd, Do MMM YYYY, [klo] HH.mm',
9701 sameDay
: '[tänään] [klo] LT',
9702 nextDay
: '[huomenna] [klo] LT',
9703 nextWeek
: 'dddd [klo] LT',
9704 lastDay
: '[eilen] [klo] LT',
9705 lastWeek
: '[viime] dddd[na] [klo] LT',
9709 future
: '%s päästä',
9724 dayOfMonthOrdinalParse
: /\d{1,2}\./,
9727 dow
: 1, // Monday is the first day of the week.
9728 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9732 //! moment.js locale configuration
9734 hooks
.defineLocale('fil', {
9735 months
: 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split(
9738 monthsShort
: 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
9739 weekdays
: 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split(
9742 weekdaysShort
: 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
9743 weekdaysMin
: 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
9749 LLL
: 'MMMM D, YYYY HH:mm',
9750 LLLL
: 'dddd, MMMM DD, YYYY HH:mm',
9753 sameDay
: 'LT [ngayong araw]',
9754 nextDay
: '[Bukas ng] LT',
9755 nextWeek
: 'LT [sa susunod na] dddd',
9756 lastDay
: 'LT [kahapon]',
9757 lastWeek
: 'LT [noong nakaraang] dddd',
9761 future
: 'sa loob ng %s',
9762 past
: '%s ang nakalipas',
9776 dayOfMonthOrdinalParse
: /\d{1,2}/,
9777 ordinal: function (number
) {
9781 dow
: 1, // Monday is the first day of the week.
9782 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9786 //! moment.js locale configuration
9788 hooks
.defineLocale('fo', {
9789 months
: 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split(
9792 monthsShort
: 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
9793 weekdays
: 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split(
9796 weekdaysShort
: 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
9797 weekdaysMin
: 'su_má_tý_mi_hó_fr_le'.split('_'),
9803 LLL
: 'D MMMM YYYY HH:mm',
9804 LLLL
: 'dddd D. MMMM, YYYY HH:mm',
9807 sameDay
: '[Í dag kl.] LT',
9808 nextDay
: '[Í morgin kl.] LT',
9809 nextWeek
: 'dddd [kl.] LT',
9810 lastDay
: '[Í gjár kl.] LT',
9811 lastWeek
: '[síðstu] dddd [kl] LT',
9830 dayOfMonthOrdinalParse
: /\d{1,2}\./,
9833 dow
: 1, // Monday is the first day of the week.
9834 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9838 //! moment.js locale configuration
9840 hooks
.defineLocale('fr-ca', {
9841 months
: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split(
9844 monthsShort
: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split(
9847 monthsParseExact
: true,
9848 weekdays
: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
9849 weekdaysShort
: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
9850 weekdaysMin
: 'di_lu_ma_me_je_ve_sa'.split('_'),
9851 weekdaysParseExact
: true,
9857 LLL
: 'D MMMM YYYY HH:mm',
9858 LLLL
: 'dddd D MMMM YYYY HH:mm',
9861 sameDay
: '[Aujourd’hui à] LT',
9862 nextDay
: '[Demain à] LT',
9863 nextWeek
: 'dddd [à] LT',
9864 lastDay
: '[Hier à] LT',
9865 lastWeek
: 'dddd [dernier à] LT',
9871 s
: 'quelques secondes',
9884 dayOfMonthOrdinalParse
: /\d{1,2}(er|e)/,
9885 ordinal: function (number
, period
) {
9887 // Words with masculine grammatical gender: mois, trimestre, jour
9894 return number
+ (number
=== 1 ? 'er' : 'e');
9896 // Words with feminine grammatical gender: semaine
9899 return number
+ (number
=== 1 ? 're' : 'e');
9904 //! moment.js locale configuration
9906 hooks
.defineLocale('fr-ch', {
9907 months
: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split(
9910 monthsShort
: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split(
9913 monthsParseExact
: true,
9914 weekdays
: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
9915 weekdaysShort
: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
9916 weekdaysMin
: 'di_lu_ma_me_je_ve_sa'.split('_'),
9917 weekdaysParseExact
: true,
9923 LLL
: 'D MMMM YYYY HH:mm',
9924 LLLL
: 'dddd D MMMM YYYY HH:mm',
9927 sameDay
: '[Aujourd’hui à] LT',
9928 nextDay
: '[Demain à] LT',
9929 nextWeek
: 'dddd [à] LT',
9930 lastDay
: '[Hier à] LT',
9931 lastWeek
: 'dddd [dernier à] LT',
9937 s
: 'quelques secondes',
9950 dayOfMonthOrdinalParse
: /\d{1,2}(er|e)/,
9951 ordinal: function (number
, period
) {
9953 // Words with masculine grammatical gender: mois, trimestre, jour
9960 return number
+ (number
=== 1 ? 'er' : 'e');
9962 // Words with feminine grammatical gender: semaine
9965 return number
+ (number
=== 1 ? 're' : 'e');
9969 dow
: 1, // Monday is the first day of the week.
9970 doy
: 4, // The week that contains Jan 4th is the first week of the year.
9974 //! moment.js locale configuration
9976 var monthsStrictRegex
$1 = /^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,
9977 monthsShortStrictRegex
$1 = /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,
9978 monthsRegex
$7 = /(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,
9994 hooks
.defineLocale('fr', {
9995 months
: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split(
9998 monthsShort
: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split(
10001 monthsRegex
: monthsRegex
$7,
10002 monthsShortRegex
: monthsRegex
$7,
10003 monthsStrictRegex
: monthsStrictRegex
$1,
10004 monthsShortStrictRegex
: monthsShortStrictRegex
$1,
10005 monthsParse
: monthsParse
$6,
10006 longMonthsParse
: monthsParse
$6,
10007 shortMonthsParse
: monthsParse
$6,
10008 weekdays
: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
10009 weekdaysShort
: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
10010 weekdaysMin
: 'di_lu_ma_me_je_ve_sa'.split('_'),
10011 weekdaysParseExact
: true,
10017 LLL
: 'D MMMM YYYY HH:mm',
10018 LLLL
: 'dddd D MMMM YYYY HH:mm',
10021 sameDay
: '[Aujourd’hui à] LT',
10022 nextDay
: '[Demain à] LT',
10023 nextWeek
: 'dddd [à] LT',
10024 lastDay
: '[Hier à] LT',
10025 lastWeek
: 'dddd [dernier à] LT',
10031 s
: 'quelques secondes',
10046 dayOfMonthOrdinalParse
: /\d{1,2}(er|)/,
10047 ordinal: function (number
, period
) {
10049 // TODO: Return 'e' when day of month > 1. Move this case inside
10050 // block for masculine words below.
10051 // See https://github.com/moment/moment/issues/3375
10053 return number
+ (number
=== 1 ? 'er' : '');
10055 // Words with masculine grammatical gender: mois, trimestre, jour
10061 return number
+ (number
=== 1 ? 'er' : 'e');
10063 // Words with feminine grammatical gender: semaine
10066 return number
+ (number
=== 1 ? 're' : 'e');
10070 dow
: 1, // Monday is the first day of the week.
10071 doy
: 4, // The week that contains Jan 4th is the first week of the year.
10075 //! moment.js locale configuration
10077 var monthsShortWithDots
= 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split(
10080 monthsShortWithoutDots
= 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split(
10084 hooks
.defineLocale('fy', {
10085 months
: 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split(
10088 monthsShort: function (m
, format
) {
10090 return monthsShortWithDots
;
10091 } else if (/-MMM-/.test(format
)) {
10092 return monthsShortWithoutDots
[m
.month()];
10094 return monthsShortWithDots
[m
.month()];
10097 monthsParseExact
: true,
10098 weekdays
: 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split(
10101 weekdaysShort
: 'si._mo._ti._wo._to._fr._so.'.split('_'),
10102 weekdaysMin
: 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
10103 weekdaysParseExact
: true,
10109 LLL
: 'D MMMM YYYY HH:mm',
10110 LLLL
: 'dddd D MMMM YYYY HH:mm',
10113 sameDay
: '[hjoed om] LT',
10114 nextDay
: '[moarn om] LT',
10115 nextWeek
: 'dddd [om] LT',
10116 lastDay
: '[juster om] LT',
10117 lastWeek
: '[ôfrûne] dddd [om] LT',
10123 s
: 'in pear sekonden',
10136 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
10137 ordinal: function (number
) {
10140 (number
=== 1 || number
=== 8 || number
>= 20 ? 'ste' : 'de')
10144 dow
: 1, // Monday is the first day of the week.
10145 doy
: 4, // The week that contains Jan 4th is the first week of the year.
10149 //! moment.js locale configuration
10161 'Deireadh Fómhair',
10188 weekdaysShort
= ['Domh', 'Luan', 'Máirt', 'Céad', 'Déar', 'Aoine', 'Sath'],
10189 weekdaysMin
= ['Do', 'Lu', 'Má', 'Cé', 'Dé', 'A', 'Sa'];
10191 hooks
.defineLocale('ga', {
10193 monthsShort
: monthsShort
$5,
10194 monthsParseExact
: true,
10195 weekdays
: weekdays
$1,
10196 weekdaysShort
: weekdaysShort
,
10197 weekdaysMin
: weekdaysMin
,
10203 LLL
: 'D MMMM YYYY HH:mm',
10204 LLLL
: 'dddd, D MMMM YYYY HH:mm',
10207 sameDay
: '[Inniu ag] LT',
10208 nextDay
: '[Amárach ag] LT',
10209 nextWeek
: 'dddd [ag] LT',
10210 lastDay
: '[Inné ag] LT',
10211 lastWeek
: 'dddd [seo caite] [ag] LT',
10217 s
: 'cúpla soicind',
10221 h
: 'uair an chloig',
10222 hh
: '%d uair an chloig',
10230 dayOfMonthOrdinalParse
: /\d{1,2}(d|na|mh)/,
10231 ordinal: function (number
) {
10232 var output
= number
=== 1 ? 'd' : number
% 10 === 2 ? 'na' : 'mh';
10233 return number
+ output
;
10236 dow
: 1, // Monday is the first day of the week.
10237 doy
: 4, // The week that contains Jan 4th is the first week of the year.
10241 //! moment.js locale configuration
10280 weekdaysShort
$1 = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'],
10281 weekdaysMin
$1 = ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];
10283 hooks
.defineLocale('gd', {
10285 monthsShort
: monthsShort
$6,
10286 monthsParseExact
: true,
10287 weekdays
: weekdays
$2,
10288 weekdaysShort
: weekdaysShort
$1,
10289 weekdaysMin
: weekdaysMin
$1,
10295 LLL
: 'D MMMM YYYY HH:mm',
10296 LLLL
: 'dddd, D MMMM YYYY HH:mm',
10299 sameDay
: '[An-diugh aig] LT',
10300 nextDay
: '[A-màireach aig] LT',
10301 nextWeek
: 'dddd [aig] LT',
10302 lastDay
: '[An-dè aig] LT',
10303 lastWeek
: 'dddd [seo chaidh] [aig] LT',
10307 future
: 'ann an %s',
10308 past
: 'bho chionn %s',
10309 s
: 'beagan diogan',
10312 mm
: '%d mionaidean',
10322 dayOfMonthOrdinalParse
: /\d{1,2}(d|na|mh)/,
10323 ordinal: function (number
) {
10324 var output
= number
=== 1 ? 'd' : number
% 10 === 2 ? 'na' : 'mh';
10325 return number
+ output
;
10328 dow
: 1, // Monday is the first day of the week.
10329 doy
: 4, // The week that contains Jan 4th is the first week of the year.
10333 //! moment.js locale configuration
10335 hooks
.defineLocale('gl', {
10336 months
: 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split(
10339 monthsShort
: 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split(
10342 monthsParseExact
: true,
10343 weekdays
: 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'),
10344 weekdaysShort
: 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'),
10345 weekdaysMin
: 'do_lu_ma_mé_xo_ve_sá'.split('_'),
10346 weekdaysParseExact
: true,
10351 LL
: 'D [de] MMMM [de] YYYY',
10352 LLL
: 'D [de] MMMM [de] YYYY H:mm',
10353 LLLL
: 'dddd, D [de] MMMM [de] YYYY H:mm',
10356 sameDay: function () {
10357 return '[hoxe ' + (this.hours() !== 1 ? 'ás' : 'á') + '] LT';
10359 nextDay: function () {
10360 return '[mañá ' + (this.hours() !== 1 ? 'ás' : 'á') + '] LT';
10362 nextWeek: function () {
10363 return 'dddd [' + (this.hours() !== 1 ? 'ás' : 'a') + '] LT';
10365 lastDay: function () {
10366 return '[onte ' + (this.hours() !== 1 ? 'á' : 'a') + '] LT';
10368 lastWeek: function () {
10370 '[o] dddd [pasado ' + (this.hours() !== 1 ? 'ás' : 'a') + '] LT'
10376 future: function (str
) {
10377 if (str
.indexOf('un') === 0) {
10380 return 'en ' + str
;
10396 dayOfMonthOrdinalParse
: /\d{1,2}º/,
10399 dow
: 1, // Monday is the first day of the week.
10400 doy
: 4, // The week that contains Jan 4th is the first week of the year.
10404 //! moment.js locale configuration
10406 function processRelativeTime
$4(number
, withoutSuffix
, key
, isFuture
) {
10408 s
: ['थोडया सॅकंडांनी', 'थोडे सॅकंड'],
10409 ss
: [number
+ ' सॅकंडांनी', number
+ ' सॅकंड'],
10410 m
: ['एका मिणटान', 'एक मिनूट'],
10411 mm
: [number
+ ' मिणटांनी', number
+ ' मिणटां'],
10412 h
: ['एका वरान', 'एक वर'],
10413 hh
: [number
+ ' वरांनी', number
+ ' वरां'],
10414 d
: ['एका दिसान', 'एक दीस'],
10415 dd
: [number
+ ' दिसांनी', number
+ ' दीस'],
10416 M
: ['एका म्हयन्यान', 'एक म्हयनो'],
10417 MM
: [number
+ ' म्हयन्यानी', number
+ ' म्हयने'],
10418 y
: ['एका वर्सान', 'एक वर्स'],
10419 yy
: [number
+ ' वर्सांनी', number
+ ' वर्सां'],
10421 return isFuture
? format
[key
][0] : format
[key
][1];
10424 hooks
.defineLocale('gom-deva', {
10426 standalone
: 'जानेवारी_फेब्रुवारी_मार्च_एप्रील_मे_जून_जुलय_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split(
10429 format
: 'जानेवारीच्या_फेब्रुवारीच्या_मार्चाच्या_एप्रीलाच्या_मेयाच्या_जूनाच्या_जुलयाच्या_ऑगस्टाच्या_सप्टेंबराच्या_ऑक्टोबराच्या_नोव्हेंबराच्या_डिसेंबराच्या'.split(
10432 isFormat
: /MMMM(\s)+D[oD]?/,
10434 monthsShort
: 'जाने._फेब्रु._मार्च_एप्री._मे_जून_जुल._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split(
10437 monthsParseExact
: true,
10438 weekdays
: 'आयतार_सोमार_मंगळार_बुधवार_बिरेस्तार_सुक्रार_शेनवार'.split('_'),
10439 weekdaysShort
: 'आयत._सोम._मंगळ._बुध._ब्रेस्त._सुक्र._शेन.'.split('_'),
10440 weekdaysMin
: 'आ_सो_मं_बु_ब्रे_सु_शे'.split('_'),
10441 weekdaysParseExact
: true,
10443 LT
: 'A h:mm [वाजतां]',
10444 LTS
: 'A h:mm:ss [वाजतां]',
10447 LLL
: 'D MMMM YYYY A h:mm [वाजतां]',
10448 LLLL
: 'dddd, MMMM Do, YYYY, A h:mm [वाजतां]',
10449 llll
: 'ddd, D MMM YYYY, A h:mm [वाजतां]',
10452 sameDay
: '[आयज] LT',
10453 nextDay
: '[फाल्यां] LT',
10454 nextWeek
: '[फुडलो] dddd[,] LT',
10455 lastDay
: '[काल] LT',
10456 lastWeek
: '[फाटलो] dddd[,] LT',
10462 s
: processRelativeTime
$4,
10463 ss
: processRelativeTime
$4,
10464 m
: processRelativeTime
$4,
10465 mm
: processRelativeTime
$4,
10466 h
: processRelativeTime
$4,
10467 hh
: processRelativeTime
$4,
10468 d
: processRelativeTime
$4,
10469 dd
: processRelativeTime
$4,
10470 M
: processRelativeTime
$4,
10471 MM
: processRelativeTime
$4,
10472 y
: processRelativeTime
$4,
10473 yy
: processRelativeTime
$4,
10475 dayOfMonthOrdinalParse
: /\d{1,2}(वेर)/,
10476 ordinal: function (number
, period
) {
10478 // the ordinal 'वेर' only applies to day of the month
10480 return number
+ 'वेर';
10492 dow
: 0, // Sunday is the first day of the week
10493 doy
: 3, // The week that contains Jan 4th is the first week of the year (7 + 0 - 4)
10495 meridiemParse
: /राती|सकाळीं|दनपारां|सांजे/,
10496 meridiemHour: function (hour
, meridiem
) {
10500 if (meridiem
=== 'राती') {
10501 return hour
< 4 ? hour
: hour
+ 12;
10502 } else if (meridiem
=== 'सकाळीं') {
10504 } else if (meridiem
=== 'दनपारां') {
10505 return hour
> 12 ? hour
: hour
+ 12;
10506 } else if (meridiem
=== 'सांजे') {
10510 meridiem: function (hour
, minute
, isLower
) {
10513 } else if (hour
< 12) {
10515 } else if (hour
< 16) {
10517 } else if (hour
< 20) {
10525 //! moment.js locale configuration
10527 function processRelativeTime
$5(number
, withoutSuffix
, key
, isFuture
) {
10529 s
: ['thoddea sekondamni', 'thodde sekond'],
10530 ss
: [number
+ ' sekondamni', number
+ ' sekond'],
10531 m
: ['eka mintan', 'ek minut'],
10532 mm
: [number
+ ' mintamni', number
+ ' mintam'],
10533 h
: ['eka voran', 'ek vor'],
10534 hh
: [number
+ ' voramni', number
+ ' voram'],
10535 d
: ['eka disan', 'ek dis'],
10536 dd
: [number
+ ' disamni', number
+ ' dis'],
10537 M
: ['eka mhoinean', 'ek mhoino'],
10538 MM
: [number
+ ' mhoineamni', number
+ ' mhoine'],
10539 y
: ['eka vorsan', 'ek voros'],
10540 yy
: [number
+ ' vorsamni', number
+ ' vorsam'],
10542 return isFuture
? format
[key
][0] : format
[key
][1];
10545 hooks
.defineLocale('gom-latn', {
10547 standalone
: 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split(
10550 format
: 'Janerachea_Febrerachea_Marsachea_Abrilachea_Maiachea_Junachea_Julaiachea_Agostachea_Setembrachea_Otubrachea_Novembrachea_Dezembrachea'.split(
10553 isFormat
: /MMMM(\s)+D[oD]?/,
10555 monthsShort
: 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split(
10558 monthsParseExact
: true,
10559 weekdays
: "Aitar_Somar_Mongllar_Budhvar_Birestar_Sukrar_Son'var".split('_'),
10560 weekdaysShort
: 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'),
10561 weekdaysMin
: 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'),
10562 weekdaysParseExact
: true,
10564 LT
: 'A h:mm [vazta]',
10565 LTS
: 'A h:mm:ss [vazta]',
10568 LLL
: 'D MMMM YYYY A h:mm [vazta]',
10569 LLLL
: 'dddd, MMMM Do, YYYY, A h:mm [vazta]',
10570 llll
: 'ddd, D MMM YYYY, A h:mm [vazta]',
10573 sameDay
: '[Aiz] LT',
10574 nextDay
: '[Faleam] LT',
10575 nextWeek
: '[Fuddlo] dddd[,] LT',
10576 lastDay
: '[Kal] LT',
10577 lastWeek
: '[Fattlo] dddd[,] LT',
10583 s
: processRelativeTime
$5,
10584 ss
: processRelativeTime
$5,
10585 m
: processRelativeTime
$5,
10586 mm
: processRelativeTime
$5,
10587 h
: processRelativeTime
$5,
10588 hh
: processRelativeTime
$5,
10589 d
: processRelativeTime
$5,
10590 dd
: processRelativeTime
$5,
10591 M
: processRelativeTime
$5,
10592 MM
: processRelativeTime
$5,
10593 y
: processRelativeTime
$5,
10594 yy
: processRelativeTime
$5,
10596 dayOfMonthOrdinalParse
: /\d{1,2}(er)/,
10597 ordinal: function (number
, period
) {
10599 // the ordinal 'er' only applies to day of the month
10601 return number
+ 'er';
10613 dow
: 0, // Sunday is the first day of the week
10614 doy
: 3, // The week that contains Jan 4th is the first week of the year (7 + 0 - 4)
10616 meridiemParse
: /rati|sokallim|donparam|sanje/,
10617 meridiemHour: function (hour
, meridiem
) {
10621 if (meridiem
=== 'rati') {
10622 return hour
< 4 ? hour
: hour
+ 12;
10623 } else if (meridiem
=== 'sokallim') {
10625 } else if (meridiem
=== 'donparam') {
10626 return hour
> 12 ? hour
: hour
+ 12;
10627 } else if (meridiem
=== 'sanje') {
10631 meridiem: function (hour
, minute
, isLower
) {
10634 } else if (hour
< 12) {
10636 } else if (hour
< 16) {
10638 } else if (hour
< 20) {
10646 //! moment.js locale configuration
10648 var symbolMap
$7 = {
10673 hooks
.defineLocale('gu', {
10674 months
: 'જાન્યુઆરી_ફેબ્રુઆરી_માર્ચ_એપ્રિલ_મે_જૂન_જુલાઈ_ઑગસ્ટ_સપ્ટેમ્બર_ઑક્ટ્બર_નવેમ્બર_ડિસેમ્બર'.split(
10677 monthsShort
: 'જાન્યુ._ફેબ્રુ._માર્ચ_એપ્રિ._મે_જૂન_જુલા._ઑગ._સપ્ટે._ઑક્ટ્._નવે._ડિસે.'.split(
10680 monthsParseExact
: true,
10681 weekdays
: 'રવિવાર_સોમવાર_મંગળવાર_બુધ્વાર_ગુરુવાર_શુક્રવાર_શનિવાર'.split(
10684 weekdaysShort
: 'રવિ_સોમ_મંગળ_બુધ્_ગુરુ_શુક્ર_શનિ'.split('_'),
10685 weekdaysMin
: 'ર_સો_મં_બુ_ગુ_શુ_શ'.split('_'),
10687 LT
: 'A h:mm વાગ્યે',
10688 LTS
: 'A h:mm:ss વાગ્યે',
10691 LLL
: 'D MMMM YYYY, A h:mm વાગ્યે',
10692 LLLL
: 'dddd, D MMMM YYYY, A h:mm વાગ્યે',
10695 sameDay
: '[આજ] LT',
10696 nextDay
: '[કાલે] LT',
10697 nextWeek
: 'dddd, LT',
10698 lastDay
: '[ગઇકાલે] LT',
10699 lastWeek
: '[પાછલા] dddd, LT',
10718 preparse: function (string
) {
10719 return string
.replace(/[૧૨૩૪૫૬૭૮૯૦]/g, function (match
) {
10720 return numberMap
$6[match
];
10723 postformat: function (string
) {
10724 return string
.replace(/\d/g, function (match
) {
10725 return symbolMap
$7[match
];
10728 // Gujarati notation for meridiems are quite fuzzy in practice. While there exists
10729 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Gujarati.
10730 meridiemParse
: /રાત|બપોર|સવાર|સાંજ/,
10731 meridiemHour: function (hour
, meridiem
) {
10735 if (meridiem
=== 'રાત') {
10736 return hour
< 4 ? hour
: hour
+ 12;
10737 } else if (meridiem
=== 'સવાર') {
10739 } else if (meridiem
=== 'બપોર') {
10740 return hour
>= 10 ? hour
: hour
+ 12;
10741 } else if (meridiem
=== 'સાંજ') {
10745 meridiem: function (hour
, minute
, isLower
) {
10748 } else if (hour
< 10) {
10750 } else if (hour
< 17) {
10752 } else if (hour
< 20) {
10759 dow
: 0, // Sunday is the first day of the week.
10760 doy
: 6, // The week that contains Jan 6th is the first week of the year.
10764 //! moment.js locale configuration
10766 hooks
.defineLocale('he', {
10767 months
: 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split(
10770 monthsShort
: 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split(
10773 weekdays
: 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
10774 weekdaysShort
: 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
10775 weekdaysMin
: 'א_ב_ג_ד_ה_ו_ש'.split('_'),
10780 LL
: 'D [ב]MMMM YYYY',
10781 LLL
: 'D [ב]MMMM YYYY HH:mm',
10782 LLLL
: 'dddd, D [ב]MMMM YYYY HH:mm',
10785 lll
: 'D MMM YYYY HH:mm',
10786 llll
: 'ddd, D MMM YYYY HH:mm',
10789 sameDay
: '[היום ב־]LT',
10790 nextDay
: '[מחר ב־]LT',
10791 nextWeek
: 'dddd [בשעה] LT',
10792 lastDay
: '[אתמול ב־]LT',
10793 lastWeek
: '[ביום] dddd [האחרון בשעה] LT',
10804 hh: function (number
) {
10805 if (number
=== 2) {
10808 return number
+ ' שעות';
10811 dd: function (number
) {
10812 if (number
=== 2) {
10815 return number
+ ' ימים';
10818 MM: function (number
) {
10819 if (number
=== 2) {
10822 return number
+ ' חודשים';
10825 yy: function (number
) {
10826 if (number
=== 2) {
10828 } else if (number
% 10 === 0 && number
!== 10) {
10829 return number
+ ' שנה';
10831 return number
+ ' שנים';
10834 meridiemParse
: /אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,
10835 isPM: function (input
) {
10836 return /^(אחה"צ|אחרי הצהריים|בערב)$/.test(input
);
10838 meridiem: function (hour
, minute
, isLower
) {
10840 return 'לפנות בוקר';
10841 } else if (hour
< 10) {
10843 } else if (hour
< 12) {
10844 return isLower
? 'לפנה"צ' : 'לפני הצהריים';
10845 } else if (hour
< 18) {
10846 return isLower
? 'אחה"צ' : 'אחרי הצהריים';
10853 //! moment.js locale configuration
10855 var symbolMap
$8 = {
10880 hooks
.defineLocale('hi', {
10881 months
: 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split(
10884 monthsShort
: 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split(
10887 monthsParseExact
: true,
10888 weekdays
: 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
10889 weekdaysShort
: 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
10890 weekdaysMin
: 'र_सो_मं_बु_गु_शु_श'.split('_'),
10893 LTS
: 'A h:mm:ss बजे',
10896 LLL
: 'D MMMM YYYY, A h:mm बजे',
10897 LLLL
: 'dddd, D MMMM YYYY, A h:mm बजे',
10900 sameDay
: '[आज] LT',
10901 nextDay
: '[कल] LT',
10902 nextWeek
: 'dddd, LT',
10903 lastDay
: '[कल] LT',
10904 lastWeek
: '[पिछले] dddd, LT',
10923 preparse: function (string
) {
10924 return string
.replace(/[१२३४५६७८९०]/g, function (match
) {
10925 return numberMap
$7[match
];
10928 postformat: function (string
) {
10929 return string
.replace(/\d/g, function (match
) {
10930 return symbolMap
$8[match
];
10933 // Hindi notation for meridiems are quite fuzzy in practice. While there exists
10934 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
10935 meridiemParse
: /रात|सुबह|दोपहर|शाम/,
10936 meridiemHour: function (hour
, meridiem
) {
10940 if (meridiem
=== 'रात') {
10941 return hour
< 4 ? hour
: hour
+ 12;
10942 } else if (meridiem
=== 'सुबह') {
10944 } else if (meridiem
=== 'दोपहर') {
10945 return hour
>= 10 ? hour
: hour
+ 12;
10946 } else if (meridiem
=== 'शाम') {
10950 meridiem: function (hour
, minute
, isLower
) {
10953 } else if (hour
< 10) {
10955 } else if (hour
< 17) {
10957 } else if (hour
< 20) {
10964 dow
: 0, // Sunday is the first day of the week.
10965 doy
: 6, // The week that contains Jan 6th is the first week of the year.
10969 //! moment.js locale configuration
10971 function translate
$3(number
, withoutSuffix
, key
) {
10972 var result
= number
+ ' ';
10975 if (number
=== 1) {
10976 result
+= 'sekunda';
10977 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
10978 result
+= 'sekunde';
10980 result
+= 'sekundi';
10984 return withoutSuffix
? 'jedna minuta' : 'jedne minute';
10986 if (number
=== 1) {
10987 result
+= 'minuta';
10988 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
10989 result
+= 'minute';
10991 result
+= 'minuta';
10995 return withoutSuffix
? 'jedan sat' : 'jednog sata';
10997 if (number
=== 1) {
10999 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
11006 if (number
=== 1) {
11013 if (number
=== 1) {
11014 result
+= 'mjesec';
11015 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
11016 result
+= 'mjeseca';
11018 result
+= 'mjeseci';
11022 if (number
=== 1) {
11023 result
+= 'godina';
11024 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
11025 result
+= 'godine';
11027 result
+= 'godina';
11033 hooks
.defineLocale('hr', {
11035 format
: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split(
11038 standalone
: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split(
11042 monthsShort
: 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split(
11045 monthsParseExact
: true,
11046 weekdays
: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split(
11049 weekdaysShort
: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
11050 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
11051 weekdaysParseExact
: true,
11056 LL
: 'Do MMMM YYYY',
11057 LLL
: 'Do MMMM YYYY H:mm',
11058 LLLL
: 'dddd, Do MMMM YYYY H:mm',
11061 sameDay
: '[danas u] LT',
11062 nextDay
: '[sutra u] LT',
11063 nextWeek: function () {
11064 switch (this.day()) {
11066 return '[u] [nedjelju] [u] LT';
11068 return '[u] [srijedu] [u] LT';
11070 return '[u] [subotu] [u] LT';
11075 return '[u] dddd [u] LT';
11078 lastDay
: '[jučer u] LT',
11079 lastWeek: function () {
11080 switch (this.day()) {
11082 return '[prošlu] [nedjelju] [u] LT';
11084 return '[prošlu] [srijedu] [u] LT';
11086 return '[prošle] [subote] [u] LT';
11091 return '[prošli] dddd [u] LT';
11112 dayOfMonthOrdinalParse
: /\d{1,2}\./,
11115 dow
: 1, // Monday is the first day of the week.
11116 doy
: 7, // The week that contains Jan 7th is the first week of the year.
11120 //! moment.js locale configuration
11122 var weekEndings
= 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(
11125 function translate
$4(number
, withoutSuffix
, key
, isFuture
) {
11129 return isFuture
|| withoutSuffix
11130 ? 'néhány másodperc'
11131 : 'néhány másodperce';
11133 return num
+ (isFuture
|| withoutSuffix
)
11137 return 'egy' + (isFuture
|| withoutSuffix
? ' perc' : ' perce');
11139 return num
+ (isFuture
|| withoutSuffix
? ' perc' : ' perce');
11141 return 'egy' + (isFuture
|| withoutSuffix
? ' óra' : ' órája');
11143 return num
+ (isFuture
|| withoutSuffix
? ' óra' : ' órája');
11145 return 'egy' + (isFuture
|| withoutSuffix
? ' nap' : ' napja');
11147 return num
+ (isFuture
|| withoutSuffix
? ' nap' : ' napja');
11149 return 'egy' + (isFuture
|| withoutSuffix
? ' hónap' : ' hónapja');
11151 return num
+ (isFuture
|| withoutSuffix
? ' hónap' : ' hónapja');
11153 return 'egy' + (isFuture
|| withoutSuffix
? ' év' : ' éve');
11155 return num
+ (isFuture
|| withoutSuffix
? ' év' : ' éve');
11159 function week(isFuture
) {
11161 (isFuture
? '' : '[múlt] ') +
11163 weekEndings
[this.day()] +
11168 hooks
.defineLocale('hu', {
11169 months
: 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split(
11172 monthsShort
: 'jan._feb._márc._ápr._máj._jún._júl._aug._szept._okt._nov._dec.'.split(
11175 monthsParseExact
: true,
11176 weekdays
: 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
11177 weekdaysShort
: 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
11178 weekdaysMin
: 'v_h_k_sze_cs_p_szo'.split('_'),
11183 LL
: 'YYYY. MMMM D.',
11184 LLL
: 'YYYY. MMMM D. H:mm',
11185 LLLL
: 'YYYY. MMMM D., dddd H:mm',
11187 meridiemParse
: /de|du/i,
11188 isPM: function (input
) {
11189 return input
.charAt(1).toLowerCase() === 'u';
11191 meridiem: function (hours
, minutes
, isLower
) {
11193 return isLower
=== true ? 'de' : 'DE';
11195 return isLower
=== true ? 'du' : 'DU';
11199 sameDay
: '[ma] LT[-kor]',
11200 nextDay
: '[holnap] LT[-kor]',
11201 nextWeek: function () {
11202 return week
.call(this, true);
11204 lastDay
: '[tegnap] LT[-kor]',
11205 lastWeek: function () {
11206 return week
.call(this, false);
11211 future
: '%s múlva',
11226 dayOfMonthOrdinalParse
: /\d{1,2}\./,
11229 dow
: 1, // Monday is the first day of the week.
11230 doy
: 4, // The week that contains Jan 4th is the first week of the year.
11234 //! moment.js locale configuration
11236 hooks
.defineLocale('hy-am', {
11238 format
: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split(
11241 standalone
: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split(
11245 monthsShort
: 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
11246 weekdays
: 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split(
11249 weekdaysShort
: 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
11250 weekdaysMin
: 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
11255 LL
: 'D MMMM YYYY թ.',
11256 LLL
: 'D MMMM YYYY թ., HH:mm',
11257 LLLL
: 'dddd, D MMMM YYYY թ., HH:mm',
11260 sameDay
: '[այսօր] LT',
11261 nextDay
: '[վաղը] LT',
11262 lastDay
: '[երեկ] LT',
11263 nextWeek: function () {
11264 return 'dddd [օրը ժամը] LT';
11266 lastWeek: function () {
11267 return '[անցած] dddd [օրը ժամը] LT';
11274 s
: 'մի քանի վայրկյան',
11287 meridiemParse
: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
11288 isPM: function (input
) {
11289 return /^(ցերեկվա|երեկոյան)$/.test(input
);
11291 meridiem: function (hour
) {
11294 } else if (hour
< 12) {
11296 } else if (hour
< 17) {
11302 dayOfMonthOrdinalParse
: /\d{1,2}|\d{1,2}-(ին|րդ)/,
11303 ordinal: function (number
, period
) {
11309 if (number
=== 1) {
11310 return number
+ '-ին';
11312 return number
+ '-րդ';
11318 dow
: 1, // Monday is the first day of the week.
11319 doy
: 7, // The week that contains Jan 7th is the first week of the year.
11323 //! moment.js locale configuration
11325 hooks
.defineLocale('id', {
11326 months
: 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split(
11329 monthsShort
: 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des'.split('_'),
11330 weekdays
: 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
11331 weekdaysShort
: 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
11332 weekdaysMin
: 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
11338 LLL
: 'D MMMM YYYY [pukul] HH.mm',
11339 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm',
11341 meridiemParse
: /pagi|siang|sore|malam/,
11342 meridiemHour: function (hour
, meridiem
) {
11346 if (meridiem
=== 'pagi') {
11348 } else if (meridiem
=== 'siang') {
11349 return hour
>= 11 ? hour
: hour
+ 12;
11350 } else if (meridiem
=== 'sore' || meridiem
=== 'malam') {
11354 meridiem: function (hours
, minutes
, isLower
) {
11357 } else if (hours
< 15) {
11359 } else if (hours
< 19) {
11366 sameDay
: '[Hari ini pukul] LT',
11367 nextDay
: '[Besok pukul] LT',
11368 nextWeek
: 'dddd [pukul] LT',
11369 lastDay
: '[Kemarin pukul] LT',
11370 lastWeek
: 'dddd [lalu pukul] LT',
11374 future
: 'dalam %s',
11375 past
: '%s yang lalu',
11376 s
: 'beberapa detik',
11390 dow
: 0, // Sunday is the first day of the week.
11391 doy
: 6, // The week that contains Jan 6th is the first week of the year.
11395 //! moment.js locale configuration
11397 function plural
$2(n
) {
11398 if (n
% 100 === 11) {
11400 } else if (n
% 10 === 1) {
11405 function translate
$5(number
, withoutSuffix
, key
, isFuture
) {
11406 var result
= number
+ ' ';
11409 return withoutSuffix
|| isFuture
11410 ? 'nokkrar sekúndur'
11411 : 'nokkrum sekúndum';
11413 if (plural
$2(number
)) {
11416 (withoutSuffix
|| isFuture
? 'sekúndur' : 'sekúndum')
11419 return result
+ 'sekúnda';
11421 return withoutSuffix
? 'mínúta' : 'mínútu';
11423 if (plural
$2(number
)) {
11425 result
+ (withoutSuffix
|| isFuture
? 'mínútur' : 'mínútum')
11427 } else if (withoutSuffix
) {
11428 return result
+ 'mínúta';
11430 return result
+ 'mínútu';
11432 if (plural
$2(number
)) {
11435 (withoutSuffix
|| isFuture
11440 return result
+ 'klukkustund';
11442 if (withoutSuffix
) {
11445 return isFuture
? 'dag' : 'degi';
11447 if (plural
$2(number
)) {
11448 if (withoutSuffix
) {
11449 return result
+ 'dagar';
11451 return result
+ (isFuture
? 'daga' : 'dögum');
11452 } else if (withoutSuffix
) {
11453 return result
+ 'dagur';
11455 return result
+ (isFuture
? 'dag' : 'degi');
11457 if (withoutSuffix
) {
11460 return isFuture
? 'mánuð' : 'mánuði';
11462 if (plural
$2(number
)) {
11463 if (withoutSuffix
) {
11464 return result
+ 'mánuðir';
11466 return result
+ (isFuture
? 'mánuði' : 'mánuðum');
11467 } else if (withoutSuffix
) {
11468 return result
+ 'mánuður';
11470 return result
+ (isFuture
? 'mánuð' : 'mánuði');
11472 return withoutSuffix
|| isFuture
? 'ár' : 'ári';
11474 if (plural
$2(number
)) {
11475 return result
+ (withoutSuffix
|| isFuture
? 'ár' : 'árum');
11477 return result
+ (withoutSuffix
|| isFuture
? 'ár' : 'ári');
11481 hooks
.defineLocale('is', {
11482 months
: 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split(
11485 monthsShort
: 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
11486 weekdays
: 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split(
11489 weekdaysShort
: 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
11490 weekdaysMin
: 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
11495 LL
: 'D. MMMM YYYY',
11496 LLL
: 'D. MMMM YYYY [kl.] H:mm',
11497 LLLL
: 'dddd, D. MMMM YYYY [kl.] H:mm',
11500 sameDay
: '[í dag kl.] LT',
11501 nextDay
: '[á morgun kl.] LT',
11502 nextWeek
: 'dddd [kl.] LT',
11503 lastDay
: '[í gær kl.] LT',
11504 lastWeek
: '[síðasta] dddd [kl.] LT',
11508 future
: 'eftir %s',
11509 past
: 'fyrir %s síðan',
11523 dayOfMonthOrdinalParse
: /\d{1,2}\./,
11526 dow
: 1, // Monday is the first day of the week.
11527 doy
: 4, // The week that contains Jan 4th is the first week of the year.
11531 //! moment.js locale configuration
11533 hooks
.defineLocale('it-ch', {
11534 months
: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split(
11537 monthsShort
: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
11538 weekdays
: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split(
11541 weekdaysShort
: 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
11542 weekdaysMin
: 'do_lu_ma_me_gi_ve_sa'.split('_'),
11548 LLL
: 'D MMMM YYYY HH:mm',
11549 LLLL
: 'dddd D MMMM YYYY HH:mm',
11552 sameDay
: '[Oggi alle] LT',
11553 nextDay
: '[Domani alle] LT',
11554 nextWeek
: 'dddd [alle] LT',
11555 lastDay
: '[Ieri alle] LT',
11556 lastWeek: function () {
11557 switch (this.day()) {
11559 return '[la scorsa] dddd [alle] LT';
11561 return '[lo scorso] dddd [alle] LT';
11567 future: function (s
) {
11568 return (/^[0-9].+$/.test(s
) ? 'tra' : 'in') + ' ' + s
;
11571 s
: 'alcuni secondi',
11584 dayOfMonthOrdinalParse
: /\d{1,2}º/,
11587 dow
: 1, // Monday is the first day of the week.
11588 doy
: 4, // The week that contains Jan 4th is the first week of the year.
11592 //! moment.js locale configuration
11594 hooks
.defineLocale('it', {
11595 months
: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split(
11598 monthsShort
: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
11599 weekdays
: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split(
11602 weekdaysShort
: 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
11603 weekdaysMin
: 'do_lu_ma_me_gi_ve_sa'.split('_'),
11609 LLL
: 'D MMMM YYYY HH:mm',
11610 LLLL
: 'dddd D MMMM YYYY HH:mm',
11613 sameDay: function () {
11616 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
11620 nextDay: function () {
11623 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
11627 nextWeek: function () {
11630 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
11634 lastDay: function () {
11637 (this.hours() > 1 ? 'lle ' : this.hours() === 0 ? ' ' : "ll'") +
11641 lastWeek: function () {
11642 switch (this.day()) {
11645 '[La scorsa] dddd [a' +
11648 : this.hours() === 0
11655 '[Lo scorso] dddd [a' +
11658 : this.hours() === 0
11670 s
: 'alcuni secondi',
11678 w
: 'una settimana',
11679 ww
: '%d settimane',
11685 dayOfMonthOrdinalParse
: /\d{1,2}º/,
11688 dow
: 1, // Monday is the first day of the week.
11689 doy
: 4, // The week that contains Jan 4th is the first week of the year.
11693 //! moment.js locale configuration
11695 hooks
.defineLocale('ja', {
11698 since
: '2019-05-01',
11705 since
: '1989-01-08',
11706 until
: '2019-04-30',
11713 since
: '1926-12-25',
11714 until
: '1989-01-07',
11721 since
: '1912-07-30',
11722 until
: '1926-12-24',
11729 since
: '1873-01-01',
11730 until
: '1912-07-29',
11737 since
: '0001-01-01',
11738 until
: '1873-12-31',
11745 since
: '0000-12-31',
11753 eraYearOrdinalRegex
: /(元|\d+)年/,
11754 eraYearOrdinalParse: function (input
, match
) {
11755 return match
[1] === '元' ? 1 : parseInt(match
[1] || input
, 10);
11757 months
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
11758 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
11761 weekdays
: '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
11762 weekdaysShort
: '日_月_火_水_木_金_土'.split('_'),
11763 weekdaysMin
: '日_月_火_水_木_金_土'.split('_'),
11769 LLL
: 'YYYY年M月D日 HH:mm',
11770 LLLL
: 'YYYY年M月D日 dddd HH:mm',
11773 lll
: 'YYYY年M月D日 HH:mm',
11774 llll
: 'YYYY年M月D日(ddd) HH:mm',
11776 meridiemParse
: /午前|午後/i,
11777 isPM: function (input
) {
11778 return input
=== '午後';
11780 meridiem: function (hour
, minute
, isLower
) {
11788 sameDay
: '[今日] LT',
11789 nextDay
: '[明日] LT',
11790 nextWeek: function (now
) {
11791 if (now
.week() !== this.week()) {
11792 return '[来週]dddd LT';
11797 lastDay
: '[昨日] LT',
11798 lastWeek: function (now
) {
11799 if (this.week() !== now
.week()) {
11800 return '[先週]dddd LT';
11807 dayOfMonthOrdinalParse
: /\d{1,2}日/,
11808 ordinal: function (number
, period
) {
11811 return number
=== 1 ? '元年' : number
+ '年';
11815 return number
+ '日';
11838 //! moment.js locale configuration
11840 hooks
.defineLocale('jv', {
11841 months
: 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split(
11844 monthsShort
: 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
11845 weekdays
: 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
11846 weekdaysShort
: 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
11847 weekdaysMin
: 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
11853 LLL
: 'D MMMM YYYY [pukul] HH.mm',
11854 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm',
11856 meridiemParse
: /enjing|siyang|sonten|ndalu/,
11857 meridiemHour: function (hour
, meridiem
) {
11861 if (meridiem
=== 'enjing') {
11863 } else if (meridiem
=== 'siyang') {
11864 return hour
>= 11 ? hour
: hour
+ 12;
11865 } else if (meridiem
=== 'sonten' || meridiem
=== 'ndalu') {
11869 meridiem: function (hours
, minutes
, isLower
) {
11872 } else if (hours
< 15) {
11874 } else if (hours
< 19) {
11881 sameDay
: '[Dinten puniko pukul] LT',
11882 nextDay
: '[Mbenjang pukul] LT',
11883 nextWeek
: 'dddd [pukul] LT',
11884 lastDay
: '[Kala wingi pukul] LT',
11885 lastWeek
: 'dddd [kepengker pukul] LT',
11889 future
: 'wonten ing %s',
11890 past
: '%s ingkang kepengker',
11891 s
: 'sawetawis detik',
11893 m
: 'setunggal menit',
11895 h
: 'setunggal jam',
11905 dow
: 1, // Monday is the first day of the week.
11906 doy
: 7, // The week that contains Jan 7th is the first week of the year.
11910 //! moment.js locale configuration
11912 hooks
.defineLocale('ka', {
11913 months
: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split(
11916 monthsShort
: 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
11918 standalone
: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split(
11921 format
: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split(
11924 isFormat
: /(წინა|შემდეგ)/,
11926 weekdaysShort
: 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
11927 weekdaysMin
: 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
11933 LLL
: 'D MMMM YYYY HH:mm',
11934 LLLL
: 'dddd, D MMMM YYYY HH:mm',
11937 sameDay
: '[დღეს] LT[-ზე]',
11938 nextDay
: '[ხვალ] LT[-ზე]',
11939 lastDay
: '[გუშინ] LT[-ზე]',
11940 nextWeek
: '[შემდეგ] dddd LT[-ზე]',
11941 lastWeek
: '[წინა] dddd LT-ზე',
11945 future: function (s
) {
11946 return s
.replace(/(წამ|წუთ|საათ|წელ|დღ|თვ)(ი|ე)/, function (
11951 return $2 === 'ი' ? $1 + 'ში' : $1 + $2 + 'ში';
11954 past: function (s
) {
11955 if (/(წამი|წუთი|საათი|დღე|თვე)/.test(s
)) {
11956 return s
.replace(/(ი|ე)$/, 'ის წინ');
11958 if (/წელი/.test(s
)) {
11959 return s
.replace(/წელი$/, 'წლის წინ');
11963 s
: 'რამდენიმე წამი',
11976 dayOfMonthOrdinalParse
: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
11977 ordinal: function (number
) {
11978 if (number
=== 0) {
11981 if (number
=== 1) {
11982 return number
+ '-ლი';
11986 (number
<= 100 && number
% 20 === 0) ||
11989 return 'მე-' + number
;
11991 return number
+ '-ე';
11999 //! moment.js locale configuration
12024 hooks
.defineLocale('kk', {
12025 months
: 'қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан'.split(
12028 monthsShort
: 'қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
12029 weekdays
: 'жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі'.split(
12032 weekdaysShort
: 'жек_дүй_сей_сәр_бей_жұм_сен'.split('_'),
12033 weekdaysMin
: 'жк_дй_сй_ср_бй_жм_сн'.split('_'),
12039 LLL
: 'D MMMM YYYY HH:mm',
12040 LLLL
: 'dddd, D MMMM YYYY HH:mm',
12043 sameDay
: '[Бүгін сағат] LT',
12044 nextDay
: '[Ертең сағат] LT',
12045 nextWeek
: 'dddd [сағат] LT',
12046 lastDay
: '[Кеше сағат] LT',
12047 lastWeek
: '[Өткен аптаның] dddd [сағат] LT',
12051 future
: '%s ішінде',
12053 s
: 'бірнеше секунд',
12066 dayOfMonthOrdinalParse
: /\d{1,2}-(ші|шы)/,
12067 ordinal: function (number
) {
12068 var a
= number
% 10,
12069 b
= number
>= 100 ? 100 : null;
12070 return number
+ (suffixes
$1[number
] || suffixes
$1[a
] || suffixes
$1[b
]);
12073 dow
: 1, // Monday is the first day of the week.
12074 doy
: 7, // The week that contains Jan 7th is the first week of the year.
12078 //! moment.js locale configuration
12080 var symbolMap
$9 = {
12105 hooks
.defineLocale('km', {
12106 months
: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
12109 monthsShort
: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
12112 weekdays
: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
12113 weekdaysShort
: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
12114 weekdaysMin
: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
12115 weekdaysParseExact
: true,
12121 LLL
: 'D MMMM YYYY HH:mm',
12122 LLLL
: 'dddd, D MMMM YYYY HH:mm',
12124 meridiemParse
: /ព្រឹក|ល្ងាច/,
12125 isPM: function (input
) {
12126 return input
=== 'ល្ងាច';
12128 meridiem: function (hour
, minute
, isLower
) {
12136 sameDay
: '[ថ្ងៃនេះ ម៉ោង] LT',
12137 nextDay
: '[ស្អែក ម៉ោង] LT',
12138 nextWeek
: 'dddd [ម៉ោង] LT',
12139 lastDay
: '[ម្សិលមិញ ម៉ោង] LT',
12140 lastWeek
: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
12146 s
: 'ប៉ុន្មានវិនាទី',
12159 dayOfMonthOrdinalParse
: /ទី\d{1,2}/,
12161 preparse: function (string
) {
12162 return string
.replace(/[១២៣៤៥៦៧៨៩០]/g, function (match
) {
12163 return numberMap
$8[match
];
12166 postformat: function (string
) {
12167 return string
.replace(/\d/g, function (match
) {
12168 return symbolMap
$9[match
];
12172 dow
: 1, // Monday is the first day of the week.
12173 doy
: 4, // The week that contains Jan 4th is the first week of the year.
12177 //! moment.js locale configuration
12179 var symbolMap
$a
= {
12204 hooks
.defineLocale('kn', {
12205 months
: 'ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್'.split(
12208 monthsShort
: 'ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂ_ಅಕ್ಟೋ_ನವೆಂ_ಡಿಸೆಂ'.split(
12211 monthsParseExact
: true,
12212 weekdays
: 'ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ'.split(
12215 weekdaysShort
: 'ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ'.split('_'),
12216 weekdaysMin
: 'ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ'.split('_'),
12222 LLL
: 'D MMMM YYYY, A h:mm',
12223 LLLL
: 'dddd, D MMMM YYYY, A h:mm',
12226 sameDay
: '[ಇಂದು] LT',
12227 nextDay
: '[ನಾಳೆ] LT',
12228 nextWeek
: 'dddd, LT',
12229 lastDay
: '[ನಿನ್ನೆ] LT',
12230 lastWeek
: '[ಕೊನೆಯ] dddd, LT',
12236 s
: 'ಕೆಲವು ಕ್ಷಣಗಳು',
12237 ss
: '%d ಸೆಕೆಂಡುಗಳು',
12249 preparse: function (string
) {
12250 return string
.replace(/[೧೨೩೪೫೬೭೮೯೦]/g, function (match
) {
12251 return numberMap
$9[match
];
12254 postformat: function (string
) {
12255 return string
.replace(/\d/g, function (match
) {
12256 return symbolMap
$a
[match
];
12259 meridiemParse
: /ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,
12260 meridiemHour: function (hour
, meridiem
) {
12264 if (meridiem
=== 'ರಾತ್ರಿ') {
12265 return hour
< 4 ? hour
: hour
+ 12;
12266 } else if (meridiem
=== 'ಬೆಳಿಗ್ಗೆ') {
12268 } else if (meridiem
=== 'ಮಧ್ಯಾಹ್ನ') {
12269 return hour
>= 10 ? hour
: hour
+ 12;
12270 } else if (meridiem
=== 'ಸಂಜೆ') {
12274 meridiem: function (hour
, minute
, isLower
) {
12277 } else if (hour
< 10) {
12279 } else if (hour
< 17) {
12281 } else if (hour
< 20) {
12287 dayOfMonthOrdinalParse
: /\d{1,2}(ನೇ)/,
12288 ordinal: function (number
) {
12289 return number
+ 'ನೇ';
12292 dow
: 0, // Sunday is the first day of the week.
12293 doy
: 6, // The week that contains Jan 6th is the first week of the year.
12297 //! moment.js locale configuration
12299 hooks
.defineLocale('ko', {
12300 months
: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
12301 monthsShort
: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split(
12304 weekdays
: '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
12305 weekdaysShort
: '일_월_화_수_목_금_토'.split('_'),
12306 weekdaysMin
: '일_월_화_수_목_금_토'.split('_'),
12311 LL
: 'YYYY년 MMMM D일',
12312 LLL
: 'YYYY년 MMMM D일 A h:mm',
12313 LLLL
: 'YYYY년 MMMM D일 dddd A h:mm',
12315 ll
: 'YYYY년 MMMM D일',
12316 lll
: 'YYYY년 MMMM D일 A h:mm',
12317 llll
: 'YYYY년 MMMM D일 dddd A h:mm',
12322 nextWeek
: 'dddd LT',
12324 lastWeek
: '지난주 dddd LT',
12343 dayOfMonthOrdinalParse
: /\d{1,2}(일|월|주)/,
12344 ordinal: function (number
, period
) {
12349 return number
+ '일';
12351 return number
+ '월';
12354 return number
+ '주';
12359 meridiemParse
: /오전|오후/,
12360 isPM: function (token
) {
12361 return token
=== '오후';
12363 meridiem: function (hour
, minute
, isUpper
) {
12364 return hour
< 12 ? '오전' : '오후';
12368 //! moment.js locale configuration
12370 var symbolMap
$b
= {
12409 hooks
.defineLocale('ku', {
12411 monthsShort
: months
$8,
12412 weekdays
: 'یهكشهممه_دووشهممه_سێشهممه_چوارشهممه_پێنجشهممه_ههینی_شهممه'.split(
12415 weekdaysShort
: 'یهكشهم_دووشهم_سێشهم_چوارشهم_پێنجشهم_ههینی_شهممه'.split(
12418 weekdaysMin
: 'ی_د_س_چ_پ_ه_ش'.split('_'),
12419 weekdaysParseExact
: true,
12425 LLL
: 'D MMMM YYYY HH:mm',
12426 LLLL
: 'dddd, D MMMM YYYY HH:mm',
12428 meridiemParse
: /ئێواره|بهیانی/,
12429 isPM: function (input
) {
12430 return /ئێواره/.test(input
);
12432 meridiem: function (hour
, minute
, isLower
) {
12440 sameDay
: '[ئهمرۆ كاتژمێر] LT',
12441 nextDay
: '[بهیانی كاتژمێر] LT',
12442 nextWeek
: 'dddd [كاتژمێر] LT',
12443 lastDay
: '[دوێنێ كاتژمێر] LT',
12444 lastWeek
: 'dddd [كاتژمێر] LT',
12450 s
: 'چهند چركهیهك',
12463 preparse: function (string
) {
12465 .replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match
) {
12466 return numberMap
$a
[match
];
12468 .replace(/،/g, ',');
12470 postformat: function (string
) {
12472 .replace(/\d/g, function (match
) {
12473 return symbolMap
$b
[match
];
12475 .replace(/,/g
, '،');
12478 dow
: 6, // Saturday is the first day of the week.
12479 doy
: 12, // The week that contains Jan 12th is the first week of the year.
12483 //! moment.js locale configuration
12508 hooks
.defineLocale('ky', {
12509 months
: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split(
12512 monthsShort
: 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split(
12515 weekdays
: 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split(
12518 weekdaysShort
: 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
12519 weekdaysMin
: 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
12525 LLL
: 'D MMMM YYYY HH:mm',
12526 LLLL
: 'dddd, D MMMM YYYY HH:mm',
12529 sameDay
: '[Бүгүн саат] LT',
12530 nextDay
: '[Эртең саат] LT',
12531 nextWeek
: 'dddd [саат] LT',
12532 lastDay
: '[Кечээ саат] LT',
12533 lastWeek
: '[Өткөн аптанын] dddd [күнү] [саат] LT',
12537 future
: '%s ичинде',
12539 s
: 'бирнече секунд',
12552 dayOfMonthOrdinalParse
: /\d{1,2}-(чи|чы|чү|чу)/,
12553 ordinal: function (number
) {
12554 var a
= number
% 10,
12555 b
= number
>= 100 ? 100 : null;
12556 return number
+ (suffixes
$2[number
] || suffixes
$2[a
] || suffixes
$2[b
]);
12559 dow
: 1, // Monday is the first day of the week.
12560 doy
: 7, // The week that contains Jan 7th is the first week of the year.
12564 //! moment.js locale configuration
12566 function processRelativeTime
$6(number
, withoutSuffix
, key
, isFuture
) {
12568 m
: ['eng Minutt', 'enger Minutt'],
12569 h
: ['eng Stonn', 'enger Stonn'],
12570 d
: ['een Dag', 'engem Dag'],
12571 M
: ['ee Mount', 'engem Mount'],
12572 y
: ['ee Joer', 'engem Joer'],
12574 return withoutSuffix
? format
[key
][0] : format
[key
][1];
12576 function processFutureTime(string
) {
12577 var number
= string
.substr(0, string
.indexOf(' '));
12578 if (eifelerRegelAppliesToNumber(number
)) {
12579 return 'a ' + string
;
12581 return 'an ' + string
;
12583 function processPastTime(string
) {
12584 var number
= string
.substr(0, string
.indexOf(' '));
12585 if (eifelerRegelAppliesToNumber(number
)) {
12586 return 'viru ' + string
;
12588 return 'virun ' + string
;
12591 * Returns true if the word before the given number loses the '-n' ending.
12592 * e.g. 'an 10 Deeg' but 'a 5 Deeg'
12594 * @param number {integer}
12595 * @returns {boolean}
12597 function eifelerRegelAppliesToNumber(number
) {
12598 number
= parseInt(number
, 10);
12599 if (isNaN(number
)) {
12603 // Negative Number --> always true
12605 } else if (number
< 10) {
12607 if (4 <= number
&& number
<= 7) {
12611 } else if (number
< 100) {
12613 var lastDigit
= number
% 10,
12614 firstDigit
= number
/ 10;
12615 if (lastDigit
=== 0) {
12616 return eifelerRegelAppliesToNumber(firstDigit
);
12618 return eifelerRegelAppliesToNumber(lastDigit
);
12619 } else if (number
< 10000) {
12620 // 3 or 4 digits --> recursively check first digit
12621 while (number
>= 10) {
12622 number
= number
/ 10;
12624 return eifelerRegelAppliesToNumber(number
);
12626 // Anything larger than 4 digits: recursively check first n-3 digits
12627 number
= number
/ 1000;
12628 return eifelerRegelAppliesToNumber(number
);
12632 hooks
.defineLocale('lb', {
12633 months
: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split(
12636 monthsShort
: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split(
12639 monthsParseExact
: true,
12640 weekdays
: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split(
12643 weekdaysShort
: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
12644 weekdaysMin
: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
12645 weekdaysParseExact
: true,
12648 LTS
: 'H:mm:ss [Auer]',
12650 LL
: 'D. MMMM YYYY',
12651 LLL
: 'D. MMMM YYYY H:mm [Auer]',
12652 LLLL
: 'dddd, D. MMMM YYYY H:mm [Auer]',
12655 sameDay
: '[Haut um] LT',
12657 nextDay
: '[Muer um] LT',
12658 nextWeek
: 'dddd [um] LT',
12659 lastDay
: '[Gëschter um] LT',
12660 lastWeek: function () {
12661 // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
12662 switch (this.day()) {
12665 return '[Leschten] dddd [um] LT';
12667 return '[Leschte] dddd [um] LT';
12672 future
: processFutureTime
,
12673 past
: processPastTime
,
12674 s
: 'e puer Sekonnen',
12676 m
: processRelativeTime
$6,
12678 h
: processRelativeTime
$6,
12680 d
: processRelativeTime
$6,
12682 M
: processRelativeTime
$6,
12684 y
: processRelativeTime
$6,
12687 dayOfMonthOrdinalParse
: /\d{1,2}\./,
12690 dow
: 1, // Monday is the first day of the week.
12691 doy
: 4, // The week that contains Jan 4th is the first week of the year.
12695 //! moment.js locale configuration
12697 hooks
.defineLocale('lo', {
12698 months
: 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split(
12701 monthsShort
: 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split(
12704 weekdays
: 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
12705 weekdaysShort
: 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
12706 weekdaysMin
: 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
12707 weekdaysParseExact
: true,
12713 LLL
: 'D MMMM YYYY HH:mm',
12714 LLLL
: 'ວັນdddd D MMMM YYYY HH:mm',
12716 meridiemParse
: /ຕອນເຊົ້າ|ຕອນແລງ/,
12717 isPM: function (input
) {
12718 return input
=== 'ຕອນແລງ';
12720 meridiem: function (hour
, minute
, isLower
) {
12728 sameDay
: '[ມື້ນີ້ເວລາ] LT',
12729 nextDay
: '[ມື້ອື່ນເວລາ] LT',
12730 nextWeek
: '[ວັນ]dddd[ໜ້າເວລາ] LT',
12731 lastDay
: '[ມື້ວານນີ້ເວລາ] LT',
12732 lastWeek
: '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
12738 s
: 'ບໍ່ເທົ່າໃດວິນາທີ',
12751 dayOfMonthOrdinalParse
: /(ທີ່)\d{1,2}/,
12752 ordinal: function (number
) {
12753 return 'ທີ່' + number
;
12757 //! moment.js locale configuration
12760 ss
: 'sekundė_sekundžių_sekundes',
12761 m
: 'minutė_minutės_minutę',
12762 mm
: 'minutės_minučių_minutes',
12763 h
: 'valanda_valandos_valandą',
12764 hh
: 'valandos_valandų_valandas',
12765 d
: 'diena_dienos_dieną',
12766 dd
: 'dienos_dienų_dienas',
12767 M
: 'mėnuo_mėnesio_mėnesį',
12768 MM
: 'mėnesiai_mėnesių_mėnesius',
12769 y
: 'metai_metų_metus',
12770 yy
: 'metai_metų_metus',
12772 function translateSeconds(number
, withoutSuffix
, key
, isFuture
) {
12773 if (withoutSuffix
) {
12774 return 'kelios sekundės';
12776 return isFuture
? 'kelių sekundžių' : 'kelias sekundes';
12779 function translateSingular(number
, withoutSuffix
, key
, isFuture
) {
12780 return withoutSuffix
12786 function special(number
) {
12787 return number
% 10 === 0 || (number
> 10 && number
< 20);
12789 function forms(key
) {
12790 return units
[key
].split('_');
12792 function translate
$6(number
, withoutSuffix
, key
, isFuture
) {
12793 var result
= number
+ ' ';
12794 if (number
=== 1) {
12796 result
+ translateSingular(number
, withoutSuffix
, key
[0], isFuture
)
12798 } else if (withoutSuffix
) {
12799 return result
+ (special(number
) ? forms(key
)[1] : forms(key
)[0]);
12802 return result
+ forms(key
)[1];
12804 return result
+ (special(number
) ? forms(key
)[1] : forms(key
)[2]);
12808 hooks
.defineLocale('lt', {
12810 format
: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split(
12813 standalone
: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split(
12816 isFormat
: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/,
12818 monthsShort
: 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
12820 format
: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split(
12823 standalone
: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split(
12826 isFormat
: /dddd HH:mm/,
12828 weekdaysShort
: 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
12829 weekdaysMin
: 'S_P_A_T_K_Pn_Š'.split('_'),
12830 weekdaysParseExact
: true,
12835 LL
: 'YYYY [m.] MMMM D [d.]',
12836 LLL
: 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
12837 LLLL
: 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
12839 ll
: 'YYYY [m.] MMMM D [d.]',
12840 lll
: 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
12841 llll
: 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]',
12844 sameDay
: '[Šiandien] LT',
12845 nextDay
: '[Rytoj] LT',
12846 nextWeek
: 'dddd LT',
12847 lastDay
: '[Vakar] LT',
12848 lastWeek
: '[Praėjusį] dddd LT',
12854 s
: translateSeconds
,
12856 m
: translateSingular
,
12858 h
: translateSingular
,
12860 d
: translateSingular
,
12862 M
: translateSingular
,
12864 y
: translateSingular
,
12867 dayOfMonthOrdinalParse
: /\d{1,2}-oji/,
12868 ordinal: function (number
) {
12869 return number
+ '-oji';
12872 dow
: 1, // Monday is the first day of the week.
12873 doy
: 4, // The week that contains Jan 4th is the first week of the year.
12877 //! moment.js locale configuration
12880 ss
: 'sekundes_sekundēm_sekunde_sekundes'.split('_'),
12881 m
: 'minūtes_minūtēm_minūte_minūtes'.split('_'),
12882 mm
: 'minūtes_minūtēm_minūte_minūtes'.split('_'),
12883 h
: 'stundas_stundām_stunda_stundas'.split('_'),
12884 hh
: 'stundas_stundām_stunda_stundas'.split('_'),
12885 d
: 'dienas_dienām_diena_dienas'.split('_'),
12886 dd
: 'dienas_dienām_diena_dienas'.split('_'),
12887 M
: 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
12888 MM
: 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
12889 y
: 'gada_gadiem_gads_gadi'.split('_'),
12890 yy
: 'gada_gadiem_gads_gadi'.split('_'),
12893 * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
12895 function format
$1(forms
, number
, withoutSuffix
) {
12896 if (withoutSuffix
) {
12897 // E.g. "21 minūte", "3 minūtes".
12898 return number
% 10 === 1 && number
% 100 !== 11 ? forms
[2] : forms
[3];
12900 // E.g. "21 minūtes" as in "pēc 21 minūtes".
12901 // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
12902 return number
% 10 === 1 && number
% 100 !== 11 ? forms
[0] : forms
[1];
12905 function relativeTimeWithPlural
$1(number
, withoutSuffix
, key
) {
12906 return number
+ ' ' + format
$1(units
$1[key
], number
, withoutSuffix
);
12908 function relativeTimeWithSingular(number
, withoutSuffix
, key
) {
12909 return format
$1(units
$1[key
], number
, withoutSuffix
);
12911 function relativeSeconds(number
, withoutSuffix
) {
12912 return withoutSuffix
? 'dažas sekundes' : 'dažām sekundēm';
12915 hooks
.defineLocale('lv', {
12916 months
: 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split(
12919 monthsShort
: 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
12920 weekdays
: 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split(
12923 weekdaysShort
: 'Sv_P_O_T_C_Pk_S'.split('_'),
12924 weekdaysMin
: 'Sv_P_O_T_C_Pk_S'.split('_'),
12925 weekdaysParseExact
: true,
12930 LL
: 'YYYY. [gada] D. MMMM',
12931 LLL
: 'YYYY. [gada] D. MMMM, HH:mm',
12932 LLLL
: 'YYYY. [gada] D. MMMM, dddd, HH:mm',
12935 sameDay
: '[Šodien pulksten] LT',
12936 nextDay
: '[Rīt pulksten] LT',
12937 nextWeek
: 'dddd [pulksten] LT',
12938 lastDay
: '[Vakar pulksten] LT',
12939 lastWeek
: '[Pagājušā] dddd [pulksten] LT',
12945 s
: relativeSeconds
,
12946 ss
: relativeTimeWithPlural
$1,
12947 m
: relativeTimeWithSingular
,
12948 mm
: relativeTimeWithPlural
$1,
12949 h
: relativeTimeWithSingular
,
12950 hh
: relativeTimeWithPlural
$1,
12951 d
: relativeTimeWithSingular
,
12952 dd
: relativeTimeWithPlural
$1,
12953 M
: relativeTimeWithSingular
,
12954 MM
: relativeTimeWithPlural
$1,
12955 y
: relativeTimeWithSingular
,
12956 yy
: relativeTimeWithPlural
$1,
12958 dayOfMonthOrdinalParse
: /\d{1,2}\./,
12961 dow
: 1, // Monday is the first day of the week.
12962 doy
: 4, // The week that contains Jan 4th is the first week of the year.
12966 //! moment.js locale configuration
12970 //Different grammatical cases
12971 ss
: ['sekund', 'sekunda', 'sekundi'],
12972 m
: ['jedan minut', 'jednog minuta'],
12973 mm
: ['minut', 'minuta', 'minuta'],
12974 h
: ['jedan sat', 'jednog sata'],
12975 hh
: ['sat', 'sata', 'sati'],
12976 dd
: ['dan', 'dana', 'dana'],
12977 MM
: ['mjesec', 'mjeseca', 'mjeseci'],
12978 yy
: ['godina', 'godine', 'godina'],
12980 correctGrammaticalCase: function (number
, wordKey
) {
12981 return number
=== 1
12983 : number
>= 2 && number
<= 4
12987 translate: function (number
, withoutSuffix
, key
) {
12988 var wordKey
= translator
.words
[key
];
12989 if (key
.length
=== 1) {
12990 return withoutSuffix
? wordKey
[0] : wordKey
[1];
12995 translator
.correctGrammaticalCase(number
, wordKey
)
13001 hooks
.defineLocale('me', {
13002 months
: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split(
13005 monthsShort
: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split(
13008 monthsParseExact
: true,
13009 weekdays
: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split(
13012 weekdaysShort
: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
13013 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
13014 weekdaysParseExact
: true,
13019 LL
: 'D. MMMM YYYY',
13020 LLL
: 'D. MMMM YYYY H:mm',
13021 LLLL
: 'dddd, D. MMMM YYYY H:mm',
13024 sameDay
: '[danas u] LT',
13025 nextDay
: '[sjutra u] LT',
13027 nextWeek: function () {
13028 switch (this.day()) {
13030 return '[u] [nedjelju] [u] LT';
13032 return '[u] [srijedu] [u] LT';
13034 return '[u] [subotu] [u] LT';
13039 return '[u] dddd [u] LT';
13042 lastDay
: '[juče u] LT',
13043 lastWeek: function () {
13044 var lastWeekDays
= [
13045 '[prošle] [nedjelje] [u] LT',
13046 '[prošlog] [ponedjeljka] [u] LT',
13047 '[prošlog] [utorka] [u] LT',
13048 '[prošle] [srijede] [u] LT',
13049 '[prošlog] [četvrtka] [u] LT',
13050 '[prošlog] [petka] [u] LT',
13051 '[prošle] [subote] [u] LT',
13053 return lastWeekDays
[this.day()];
13060 s
: 'nekoliko sekundi',
13061 ss
: translator
.translate
,
13062 m
: translator
.translate
,
13063 mm
: translator
.translate
,
13064 h
: translator
.translate
,
13065 hh
: translator
.translate
,
13067 dd
: translator
.translate
,
13069 MM
: translator
.translate
,
13071 yy
: translator
.translate
,
13073 dayOfMonthOrdinalParse
: /\d{1,2}\./,
13076 dow
: 1, // Monday is the first day of the week.
13077 doy
: 7, // The week that contains Jan 7th is the first week of the year.
13081 //! moment.js locale configuration
13083 hooks
.defineLocale('mi', {
13084 months
: 'Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea'.split(
13087 monthsShort
: 'Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split(
13090 monthsRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
13091 monthsStrictRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
13092 monthsShortRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
13093 monthsShortStrictRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
13094 weekdays
: 'Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei'.split('_'),
13095 weekdaysShort
: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
13096 weekdaysMin
: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
13102 LLL
: 'D MMMM YYYY [i] HH:mm',
13103 LLLL
: 'dddd, D MMMM YYYY [i] HH:mm',
13106 sameDay
: '[i teie mahana, i] LT',
13107 nextDay
: '[apopo i] LT',
13108 nextWeek
: 'dddd [i] LT',
13109 lastDay
: '[inanahi i] LT',
13110 lastWeek
: 'dddd [whakamutunga i] LT',
13114 future
: 'i roto i %s',
13116 s
: 'te hēkona ruarua',
13129 dayOfMonthOrdinalParse
: /\d{1,2}º/,
13132 dow
: 1, // Monday is the first day of the week.
13133 doy
: 4, // The week that contains Jan 4th is the first week of the year.
13137 //! moment.js locale configuration
13139 hooks
.defineLocale('mk', {
13140 months
: 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split(
13143 monthsShort
: 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
13144 weekdays
: 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split(
13147 weekdaysShort
: 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
13148 weekdaysMin
: 'нe_пo_вт_ср_че_пе_сa'.split('_'),
13154 LLL
: 'D MMMM YYYY H:mm',
13155 LLLL
: 'dddd, D MMMM YYYY H:mm',
13158 sameDay
: '[Денес во] LT',
13159 nextDay
: '[Утре во] LT',
13160 nextWeek
: '[Во] dddd [во] LT',
13161 lastDay
: '[Вчера во] LT',
13162 lastWeek: function () {
13163 switch (this.day()) {
13167 return '[Изминатата] dddd [во] LT';
13172 return '[Изминатиот] dddd [во] LT';
13180 s
: 'неколку секунди',
13193 dayOfMonthOrdinalParse
: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
13194 ordinal: function (number
) {
13195 var lastDigit
= number
% 10,
13196 last2Digits
= number
% 100;
13197 if (number
=== 0) {
13198 return number
+ '-ев';
13199 } else if (last2Digits
=== 0) {
13200 return number
+ '-ен';
13201 } else if (last2Digits
> 10 && last2Digits
< 20) {
13202 return number
+ '-ти';
13203 } else if (lastDigit
=== 1) {
13204 return number
+ '-ви';
13205 } else if (lastDigit
=== 2) {
13206 return number
+ '-ри';
13207 } else if (lastDigit
=== 7 || lastDigit
=== 8) {
13208 return number
+ '-ми';
13210 return number
+ '-ти';
13214 dow
: 1, // Monday is the first day of the week.
13215 doy
: 7, // The week that contains Jan 7th is the first week of the year.
13219 //! moment.js locale configuration
13221 hooks
.defineLocale('ml', {
13222 months
: 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split(
13225 monthsShort
: 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split(
13228 monthsParseExact
: true,
13229 weekdays
: 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split(
13232 weekdaysShort
: 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
13233 weekdaysMin
: 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
13236 LTS
: 'A h:mm:ss -നു',
13239 LLL
: 'D MMMM YYYY, A h:mm -നു',
13240 LLLL
: 'dddd, D MMMM YYYY, A h:mm -നു',
13243 sameDay
: '[ഇന്ന്] LT',
13244 nextDay
: '[നാളെ] LT',
13245 nextWeek
: 'dddd, LT',
13246 lastDay
: '[ഇന്നലെ] LT',
13247 lastWeek
: '[കഴിഞ്ഞ] dddd, LT',
13251 future
: '%s കഴിഞ്ഞ്',
13253 s
: 'അൽപ നിമിഷങ്ങൾ',
13266 meridiemParse
: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
13267 meridiemHour: function (hour
, meridiem
) {
13272 (meridiem
=== 'രാത്രി' && hour
>= 4) ||
13273 meridiem
=== 'ഉച്ച കഴിഞ്ഞ്' ||
13274 meridiem
=== 'വൈകുന്നേരം'
13281 meridiem: function (hour
, minute
, isLower
) {
13284 } else if (hour
< 12) {
13286 } else if (hour
< 17) {
13287 return 'ഉച്ച കഴിഞ്ഞ്';
13288 } else if (hour
< 20) {
13289 return 'വൈകുന്നേരം';
13296 //! moment.js locale configuration
13298 function translate
$7(number
, withoutSuffix
, key
, isFuture
) {
13301 return withoutSuffix
? 'хэдхэн секунд' : 'хэдхэн секундын';
13303 return number
+ (withoutSuffix
? ' секунд' : ' секундын');
13306 return number
+ (withoutSuffix
? ' минут' : ' минутын');
13309 return number
+ (withoutSuffix
? ' цаг' : ' цагийн');
13312 return number
+ (withoutSuffix
? ' өдөр' : ' өдрийн');
13315 return number
+ (withoutSuffix
? ' сар' : ' сарын');
13318 return number
+ (withoutSuffix
? ' жил' : ' жилийн');
13324 hooks
.defineLocale('mn', {
13325 months
: 'Нэгдүгээр сар_Хоёрдугаар сар_Гуравдугаар сар_Дөрөвдүгээр сар_Тавдугаар сар_Зургадугаар сар_Долдугаар сар_Наймдугаар сар_Есдүгээр сар_Аравдугаар сар_Арван нэгдүгээр сар_Арван хоёрдугаар сар'.split(
13328 monthsShort
: '1 сар_2 сар_3 сар_4 сар_5 сар_6 сар_7 сар_8 сар_9 сар_10 сар_11 сар_12 сар'.split(
13331 monthsParseExact
: true,
13332 weekdays
: 'Ням_Даваа_Мягмар_Лхагва_Пүрэв_Баасан_Бямба'.split('_'),
13333 weekdaysShort
: 'Ням_Дав_Мяг_Лха_Пүр_Баа_Бям'.split('_'),
13334 weekdaysMin
: 'Ня_Да_Мя_Лх_Пү_Ба_Бя'.split('_'),
13335 weekdaysParseExact
: true,
13340 LL
: 'YYYY оны MMMMын D',
13341 LLL
: 'YYYY оны MMMMын D HH:mm',
13342 LLLL
: 'dddd, YYYY оны MMMMын D HH:mm',
13344 meridiemParse
: /ҮӨ|ҮХ/i,
13345 isPM: function (input
) {
13346 return input
=== 'ҮХ';
13348 meridiem: function (hour
, minute
, isLower
) {
13356 sameDay
: '[Өнөөдөр] LT',
13357 nextDay
: '[Маргааш] LT',
13358 nextWeek
: '[Ирэх] dddd LT',
13359 lastDay
: '[Өчигдөр] LT',
13360 lastWeek
: '[Өнгөрсөн] dddd LT',
13364 future
: '%s дараа',
13379 dayOfMonthOrdinalParse
: /\d{1,2} өдөр/,
13380 ordinal: function (number
, period
) {
13385 return number
+ ' өдөр';
13392 //! moment.js locale configuration
13394 var symbolMap
$c
= {
13419 function relativeTimeMr(number
, withoutSuffix
, string
, isFuture
) {
13421 if (withoutSuffix
) {
13424 output
= 'काही सेकंद';
13427 output
= '%d सेकंद';
13430 output
= 'एक मिनिट';
13433 output
= '%d मिनिटे';
13442 output
= 'एक दिवस';
13445 output
= '%d दिवस';
13448 output
= 'एक महिना';
13451 output
= '%d महिने';
13454 output
= 'एक वर्ष';
13457 output
= '%d वर्षे';
13463 output
= 'काही सेकंदां';
13466 output
= '%d सेकंदां';
13469 output
= 'एका मिनिटा';
13472 output
= '%d मिनिटां';
13475 output
= 'एका तासा';
13478 output
= '%d तासां';
13481 output
= 'एका दिवसा';
13484 output
= '%d दिवसां';
13487 output
= 'एका महिन्या';
13490 output
= '%d महिन्यां';
13493 output
= 'एका वर्षा';
13496 output
= '%d वर्षां';
13500 return output
.replace(/%d/i, number
);
13503 hooks
.defineLocale('mr', {
13504 months
: 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split(
13507 monthsShort
: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split(
13510 monthsParseExact
: true,
13511 weekdays
: 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
13512 weekdaysShort
: 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
13513 weekdaysMin
: 'र_सो_मं_बु_गु_शु_श'.split('_'),
13515 LT
: 'A h:mm वाजता',
13516 LTS
: 'A h:mm:ss वाजता',
13519 LLL
: 'D MMMM YYYY, A h:mm वाजता',
13520 LLLL
: 'dddd, D MMMM YYYY, A h:mm वाजता',
13523 sameDay
: '[आज] LT',
13524 nextDay
: '[उद्या] LT',
13525 nextWeek
: 'dddd, LT',
13526 lastDay
: '[काल] LT',
13527 lastWeek
: '[मागील] dddd, LT',
13534 ss
: relativeTimeMr
,
13536 mm
: relativeTimeMr
,
13538 hh
: relativeTimeMr
,
13540 dd
: relativeTimeMr
,
13542 MM
: relativeTimeMr
,
13544 yy
: relativeTimeMr
,
13546 preparse: function (string
) {
13547 return string
.replace(/[१२३४५६७८९०]/g, function (match
) {
13548 return numberMap
$b
[match
];
13551 postformat: function (string
) {
13552 return string
.replace(/\d/g, function (match
) {
13553 return symbolMap
$c
[match
];
13556 meridiemParse
: /पहाटे|सकाळी|दुपारी|सायंकाळी|रात्री/,
13557 meridiemHour: function (hour
, meridiem
) {
13561 if (meridiem
=== 'पहाटे' || meridiem
=== 'सकाळी') {
13564 meridiem
=== 'दुपारी' ||
13565 meridiem
=== 'सायंकाळी' ||
13566 meridiem
=== 'रात्री'
13568 return hour
>= 12 ? hour
: hour
+ 12;
13571 meridiem: function (hour
, minute
, isLower
) {
13572 if (hour
>= 0 && hour
< 6) {
13574 } else if (hour
< 12) {
13576 } else if (hour
< 17) {
13578 } else if (hour
< 20) {
13585 dow
: 0, // Sunday is the first day of the week.
13586 doy
: 6, // The week that contains Jan 6th is the first week of the year.
13590 //! moment.js locale configuration
13592 hooks
.defineLocale('ms-my', {
13593 months
: 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split(
13596 monthsShort
: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
13597 weekdays
: 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
13598 weekdaysShort
: 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
13599 weekdaysMin
: 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
13605 LLL
: 'D MMMM YYYY [pukul] HH.mm',
13606 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm',
13608 meridiemParse
: /pagi|tengahari|petang|malam/,
13609 meridiemHour: function (hour
, meridiem
) {
13613 if (meridiem
=== 'pagi') {
13615 } else if (meridiem
=== 'tengahari') {
13616 return hour
>= 11 ? hour
: hour
+ 12;
13617 } else if (meridiem
=== 'petang' || meridiem
=== 'malam') {
13621 meridiem: function (hours
, minutes
, isLower
) {
13624 } else if (hours
< 15) {
13625 return 'tengahari';
13626 } else if (hours
< 19) {
13633 sameDay
: '[Hari ini pukul] LT',
13634 nextDay
: '[Esok pukul] LT',
13635 nextWeek
: 'dddd [pukul] LT',
13636 lastDay
: '[Kelmarin pukul] LT',
13637 lastWeek
: 'dddd [lepas pukul] LT',
13641 future
: 'dalam %s',
13642 past
: '%s yang lepas',
13643 s
: 'beberapa saat',
13657 dow
: 1, // Monday is the first day of the week.
13658 doy
: 7, // The week that contains Jan 7th is the first week of the year.
13662 //! moment.js locale configuration
13664 hooks
.defineLocale('ms', {
13665 months
: 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split(
13668 monthsShort
: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
13669 weekdays
: 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
13670 weekdaysShort
: 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
13671 weekdaysMin
: 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
13677 LLL
: 'D MMMM YYYY [pukul] HH.mm',
13678 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm',
13680 meridiemParse
: /pagi|tengahari|petang|malam/,
13681 meridiemHour: function (hour
, meridiem
) {
13685 if (meridiem
=== 'pagi') {
13687 } else if (meridiem
=== 'tengahari') {
13688 return hour
>= 11 ? hour
: hour
+ 12;
13689 } else if (meridiem
=== 'petang' || meridiem
=== 'malam') {
13693 meridiem: function (hours
, minutes
, isLower
) {
13696 } else if (hours
< 15) {
13697 return 'tengahari';
13698 } else if (hours
< 19) {
13705 sameDay
: '[Hari ini pukul] LT',
13706 nextDay
: '[Esok pukul] LT',
13707 nextWeek
: 'dddd [pukul] LT',
13708 lastDay
: '[Kelmarin pukul] LT',
13709 lastWeek
: 'dddd [lepas pukul] LT',
13713 future
: 'dalam %s',
13714 past
: '%s yang lepas',
13715 s
: 'beberapa saat',
13729 dow
: 1, // Monday is the first day of the week.
13730 doy
: 7, // The week that contains Jan 7th is the first week of the year.
13734 //! moment.js locale configuration
13736 hooks
.defineLocale('mt', {
13737 months
: 'Jannar_Frar_Marzu_April_Mejju_Ġunju_Lulju_Awwissu_Settembru_Ottubru_Novembru_Diċembru'.split(
13740 monthsShort
: 'Jan_Fra_Mar_Apr_Mej_Ġun_Lul_Aww_Set_Ott_Nov_Diċ'.split('_'),
13741 weekdays
: 'Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ġimgħa_Is-Sibt'.split(
13744 weekdaysShort
: 'Ħad_Tne_Tli_Erb_Ħam_Ġim_Sib'.split('_'),
13745 weekdaysMin
: 'Ħa_Tn_Tl_Er_Ħa_Ġi_Si'.split('_'),
13751 LLL
: 'D MMMM YYYY HH:mm',
13752 LLLL
: 'dddd, D MMMM YYYY HH:mm',
13755 sameDay
: '[Illum fil-]LT',
13756 nextDay
: '[Għada fil-]LT',
13757 nextWeek
: 'dddd [fil-]LT',
13758 lastDay
: '[Il-bieraħ fil-]LT',
13759 lastWeek
: 'dddd [li għadda] [fil-]LT',
13778 dayOfMonthOrdinalParse
: /\d{1,2}º/,
13781 dow
: 1, // Monday is the first day of the week.
13782 doy
: 4, // The week that contains Jan 4th is the first week of the year.
13786 //! moment.js locale configuration
13788 var symbolMap
$d
= {
13813 hooks
.defineLocale('my', {
13814 months
: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split(
13817 monthsShort
: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
13818 weekdays
: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split(
13821 weekdaysShort
: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
13822 weekdaysMin
: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
13829 LLL
: 'D MMMM YYYY HH:mm',
13830 LLLL
: 'dddd D MMMM YYYY HH:mm',
13833 sameDay
: '[ယနေ.] LT [မှာ]',
13834 nextDay
: '[မနက်ဖြန်] LT [မှာ]',
13835 nextWeek
: 'dddd LT [မှာ]',
13836 lastDay
: '[မနေ.က] LT [မှာ]',
13837 lastWeek
: '[ပြီးခဲ့သော] dddd LT [မှာ]',
13841 future
: 'လာမည့် %s မှာ',
13842 past
: 'လွန်ခဲ့သော %s က',
13843 s
: 'စက္ကန်.အနည်းငယ်',
13856 preparse: function (string
) {
13857 return string
.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match
) {
13858 return numberMap
$c
[match
];
13861 postformat: function (string
) {
13862 return string
.replace(/\d/g, function (match
) {
13863 return symbolMap
$d
[match
];
13867 dow
: 1, // Monday is the first day of the week.
13868 doy
: 4, // The week that contains Jan 4th is the first week of the year.
13872 //! moment.js locale configuration
13874 hooks
.defineLocale('nb', {
13875 months
: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split(
13878 monthsShort
: 'jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.'.split(
13881 monthsParseExact
: true,
13882 weekdays
: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
13883 weekdaysShort
: 'sø._ma._ti._on._to._fr._lø.'.split('_'),
13884 weekdaysMin
: 'sø_ma_ti_on_to_fr_lø'.split('_'),
13885 weekdaysParseExact
: true,
13890 LL
: 'D. MMMM YYYY',
13891 LLL
: 'D. MMMM YYYY [kl.] HH:mm',
13892 LLLL
: 'dddd D. MMMM YYYY [kl.] HH:mm',
13895 sameDay
: '[i dag kl.] LT',
13896 nextDay
: '[i morgen kl.] LT',
13897 nextWeek
: 'dddd [kl.] LT',
13898 lastDay
: '[i går kl.] LT',
13899 lastWeek
: '[forrige] dddd [kl.] LT',
13905 s
: 'noen sekunder',
13920 dayOfMonthOrdinalParse
: /\d{1,2}\./,
13923 dow
: 1, // Monday is the first day of the week.
13924 doy
: 4, // The week that contains Jan 4th is the first week of the year.
13928 //! moment.js locale configuration
13930 var symbolMap
$e
= {
13955 hooks
.defineLocale('ne', {
13956 months
: 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split(
13959 monthsShort
: 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split(
13962 monthsParseExact
: true,
13963 weekdays
: 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split(
13966 weekdaysShort
: 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
13967 weekdaysMin
: 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
13968 weekdaysParseExact
: true,
13970 LT
: 'Aको h:mm बजे',
13971 LTS
: 'Aको h:mm:ss बजे',
13974 LLL
: 'D MMMM YYYY, Aको h:mm बजे',
13975 LLLL
: 'dddd, D MMMM YYYY, Aको h:mm बजे',
13977 preparse: function (string
) {
13978 return string
.replace(/[१२३४५६७८९०]/g, function (match
) {
13979 return numberMap
$d
[match
];
13982 postformat: function (string
) {
13983 return string
.replace(/\d/g, function (match
) {
13984 return symbolMap
$e
[match
];
13987 meridiemParse
: /राति|बिहान|दिउँसो|साँझ/,
13988 meridiemHour: function (hour
, meridiem
) {
13992 if (meridiem
=== 'राति') {
13993 return hour
< 4 ? hour
: hour
+ 12;
13994 } else if (meridiem
=== 'बिहान') {
13996 } else if (meridiem
=== 'दिउँसो') {
13997 return hour
>= 10 ? hour
: hour
+ 12;
13998 } else if (meridiem
=== 'साँझ') {
14002 meridiem: function (hour
, minute
, isLower
) {
14005 } else if (hour
< 12) {
14007 } else if (hour
< 16) {
14009 } else if (hour
< 20) {
14016 sameDay
: '[आज] LT',
14017 nextDay
: '[भोलि] LT',
14018 nextWeek
: '[आउँदो] dddd[,] LT',
14019 lastDay
: '[हिजो] LT',
14020 lastWeek
: '[गएको] dddd[,] LT',
14040 dow
: 0, // Sunday is the first day of the week.
14041 doy
: 6, // The week that contains Jan 6th is the first week of the year.
14045 //! moment.js locale configuration
14047 var monthsShortWithDots
$1 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split(
14050 monthsShortWithoutDots
$1 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split(
14067 monthsRegex
$8 = /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
14069 hooks
.defineLocale('nl-be', {
14070 months
: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split(
14073 monthsShort: function (m
, format
) {
14075 return monthsShortWithDots
$1;
14076 } else if (/-MMM-/.test(format
)) {
14077 return monthsShortWithoutDots
$1[m
.month()];
14079 return monthsShortWithDots
$1[m
.month()];
14083 monthsRegex
: monthsRegex
$8,
14084 monthsShortRegex
: monthsRegex
$8,
14085 monthsStrictRegex
: /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,
14086 monthsShortStrictRegex
: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
14088 monthsParse
: monthsParse
$7,
14089 longMonthsParse
: monthsParse
$7,
14090 shortMonthsParse
: monthsParse
$7,
14092 weekdays
: 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split(
14095 weekdaysShort
: 'zo._ma._di._wo._do._vr._za.'.split('_'),
14096 weekdaysMin
: 'zo_ma_di_wo_do_vr_za'.split('_'),
14097 weekdaysParseExact
: true,
14103 LLL
: 'D MMMM YYYY HH:mm',
14104 LLLL
: 'dddd D MMMM YYYY HH:mm',
14107 sameDay
: '[vandaag om] LT',
14108 nextDay
: '[morgen om] LT',
14109 nextWeek
: 'dddd [om] LT',
14110 lastDay
: '[gisteren om] LT',
14111 lastWeek
: '[afgelopen] dddd [om] LT',
14116 past
: '%s geleden',
14117 s
: 'een paar seconden',
14130 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
14131 ordinal: function (number
) {
14134 (number
=== 1 || number
=== 8 || number
>= 20 ? 'ste' : 'de')
14138 dow
: 1, // Monday is the first day of the week.
14139 doy
: 4, // The week that contains Jan 4th is the first week of the year.
14143 //! moment.js locale configuration
14145 var monthsShortWithDots
$2 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split(
14148 monthsShortWithoutDots
$2 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split(
14165 monthsRegex
$9 = /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
14167 hooks
.defineLocale('nl', {
14168 months
: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split(
14171 monthsShort: function (m
, format
) {
14173 return monthsShortWithDots
$2;
14174 } else if (/-MMM-/.test(format
)) {
14175 return monthsShortWithoutDots
$2[m
.month()];
14177 return monthsShortWithDots
$2[m
.month()];
14181 monthsRegex
: monthsRegex
$9,
14182 monthsShortRegex
: monthsRegex
$9,
14183 monthsStrictRegex
: /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,
14184 monthsShortStrictRegex
: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
14186 monthsParse
: monthsParse
$8,
14187 longMonthsParse
: monthsParse
$8,
14188 shortMonthsParse
: monthsParse
$8,
14190 weekdays
: 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split(
14193 weekdaysShort
: 'zo._ma._di._wo._do._vr._za.'.split('_'),
14194 weekdaysMin
: 'zo_ma_di_wo_do_vr_za'.split('_'),
14195 weekdaysParseExact
: true,
14201 LLL
: 'D MMMM YYYY HH:mm',
14202 LLLL
: 'dddd D MMMM YYYY HH:mm',
14205 sameDay
: '[vandaag om] LT',
14206 nextDay
: '[morgen om] LT',
14207 nextWeek
: 'dddd [om] LT',
14208 lastDay
: '[gisteren om] LT',
14209 lastWeek
: '[afgelopen] dddd [om] LT',
14214 past
: '%s geleden',
14215 s
: 'een paar seconden',
14230 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
14231 ordinal: function (number
) {
14234 (number
=== 1 || number
=== 8 || number
>= 20 ? 'ste' : 'de')
14238 dow
: 1, // Monday is the first day of the week.
14239 doy
: 4, // The week that contains Jan 4th is the first week of the year.
14243 //! moment.js locale configuration
14245 hooks
.defineLocale('nn', {
14246 months
: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split(
14249 monthsShort
: 'jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.'.split(
14252 monthsParseExact
: true,
14253 weekdays
: 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
14254 weekdaysShort
: 'su._må._ty._on._to._fr._lau.'.split('_'),
14255 weekdaysMin
: 'su_må_ty_on_to_fr_la'.split('_'),
14256 weekdaysParseExact
: true,
14261 LL
: 'D. MMMM YYYY',
14262 LLL
: 'D. MMMM YYYY [kl.] H:mm',
14263 LLLL
: 'dddd D. MMMM YYYY [kl.] HH:mm',
14266 sameDay
: '[I dag klokka] LT',
14267 nextDay
: '[I morgon klokka] LT',
14268 nextWeek
: 'dddd [klokka] LT',
14269 lastDay
: '[I går klokka] LT',
14270 lastWeek
: '[Føregåande] dddd [klokka] LT',
14291 dayOfMonthOrdinalParse
: /\d{1,2}\./,
14294 dow
: 1, // Monday is the first day of the week.
14295 doy
: 4, // The week that contains Jan 4th is the first week of the year.
14299 //! moment.js locale configuration
14301 hooks
.defineLocale('oc-lnc', {
14303 standalone
: 'genièr_febrièr_març_abril_mai_junh_julhet_agost_setembre_octòbre_novembre_decembre'.split(
14306 format
: "de genièr_de febrièr_de març_d'abril_de mai_de junh_de julhet_d'agost_de setembre_d'octòbre_de novembre_de decembre".split(
14309 isFormat
: /D[oD]?(\s)+MMMM/,
14311 monthsShort
: 'gen._febr._març_abr._mai_junh_julh._ago._set._oct._nov._dec.'.split(
14314 monthsParseExact
: true,
14315 weekdays
: 'dimenge_diluns_dimars_dimècres_dijòus_divendres_dissabte'.split(
14318 weekdaysShort
: 'dg._dl._dm._dc._dj._dv._ds.'.split('_'),
14319 weekdaysMin
: 'dg_dl_dm_dc_dj_dv_ds'.split('_'),
14320 weekdaysParseExact
: true,
14325 LL
: 'D MMMM [de] YYYY',
14327 LLL
: 'D MMMM [de] YYYY [a] H:mm',
14328 lll
: 'D MMM YYYY, H:mm',
14329 LLLL
: 'dddd D MMMM [de] YYYY [a] H:mm',
14330 llll
: 'ddd D MMM YYYY, H:mm',
14333 sameDay
: '[uèi a] LT',
14334 nextDay
: '[deman a] LT',
14335 nextWeek
: 'dddd [a] LT',
14336 lastDay
: '[ièr a] LT',
14337 lastWeek
: 'dddd [passat a] LT',
14341 future
: "d'aquí %s",
14343 s
: 'unas segondas',
14356 dayOfMonthOrdinalParse
: /\d{1,2}(r|n|t|è|a)/,
14357 ordinal: function (number
, period
) {
14368 if (period
=== 'w' || period
=== 'W') {
14371 return number
+ output
;
14374 dow
: 1, // Monday is the first day of the week.
14379 //! moment.js locale configuration
14381 var symbolMap
$f
= {
14406 hooks
.defineLocale('pa-in', {
14407 // There are months name as per Nanakshahi Calendar but they are not used as rigidly in modern Punjabi.
14408 months
: 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split(
14411 monthsShort
: 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split(
14414 weekdays
: 'ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ'.split(
14417 weekdaysShort
: 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
14418 weekdaysMin
: 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
14421 LTS
: 'A h:mm:ss ਵਜੇ',
14424 LLL
: 'D MMMM YYYY, A h:mm ਵਜੇ',
14425 LLLL
: 'dddd, D MMMM YYYY, A h:mm ਵਜੇ',
14428 sameDay
: '[ਅਜ] LT',
14429 nextDay
: '[ਕਲ] LT',
14430 nextWeek
: '[ਅਗਲਾ] dddd, LT',
14431 lastDay
: '[ਕਲ] LT',
14432 lastWeek
: '[ਪਿਛਲੇ] dddd, LT',
14451 preparse: function (string
) {
14452 return string
.replace(/[੧੨੩੪੫੬੭੮੯੦]/g, function (match
) {
14453 return numberMap
$e
[match
];
14456 postformat: function (string
) {
14457 return string
.replace(/\d/g, function (match
) {
14458 return symbolMap
$f
[match
];
14461 // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
14462 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
14463 meridiemParse
: /ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,
14464 meridiemHour: function (hour
, meridiem
) {
14468 if (meridiem
=== 'ਰਾਤ') {
14469 return hour
< 4 ? hour
: hour
+ 12;
14470 } else if (meridiem
=== 'ਸਵੇਰ') {
14472 } else if (meridiem
=== 'ਦੁਪਹਿਰ') {
14473 return hour
>= 10 ? hour
: hour
+ 12;
14474 } else if (meridiem
=== 'ਸ਼ਾਮ') {
14478 meridiem: function (hour
, minute
, isLower
) {
14481 } else if (hour
< 10) {
14483 } else if (hour
< 17) {
14485 } else if (hour
< 20) {
14492 dow
: 0, // Sunday is the first day of the week.
14493 doy
: 6, // The week that contains Jan 6th is the first week of the year.
14497 //! moment.js locale configuration
14499 var monthsNominative
= 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split(
14502 monthsSubjective
= 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split(
14519 function plural
$3(n
) {
14520 return n
% 10 < 5 && n
% 10 > 1 && ~~(n
/ 10) % 10 !== 1;
14522 function translate
$8(number
, withoutSuffix
, key
) {
14523 var result
= number
+ ' ';
14526 return result
+ (plural
$3(number
) ? 'sekundy' : 'sekund');
14528 return withoutSuffix
? 'minuta' : 'minutę';
14530 return result
+ (plural
$3(number
) ? 'minuty' : 'minut');
14532 return withoutSuffix
? 'godzina' : 'godzinę';
14534 return result
+ (plural
$3(number
) ? 'godziny' : 'godzin');
14536 return result
+ (plural
$3(number
) ? 'tygodnie' : 'tygodni');
14538 return result
+ (plural
$3(number
) ? 'miesiące' : 'miesięcy');
14540 return result
+ (plural
$3(number
) ? 'lata' : 'lat');
14544 hooks
.defineLocale('pl', {
14545 months: function (momentToFormat
, format
) {
14546 if (!momentToFormat
) {
14547 return monthsNominative
;
14548 } else if (/D MMMM/.test(format
)) {
14549 return monthsSubjective
[momentToFormat
.month()];
14551 return monthsNominative
[momentToFormat
.month()];
14554 monthsShort
: 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
14555 monthsParse
: monthsParse
$9,
14556 longMonthsParse
: monthsParse
$9,
14557 shortMonthsParse
: monthsParse
$9,
14558 weekdays
: 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split(
14561 weekdaysShort
: 'ndz_pon_wt_śr_czw_pt_sob'.split('_'),
14562 weekdaysMin
: 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
14568 LLL
: 'D MMMM YYYY HH:mm',
14569 LLLL
: 'dddd, D MMMM YYYY HH:mm',
14572 sameDay
: '[Dziś o] LT',
14573 nextDay
: '[Jutro o] LT',
14574 nextWeek: function () {
14575 switch (this.day()) {
14577 return '[W niedzielę o] LT';
14580 return '[We wtorek o] LT';
14583 return '[W środę o] LT';
14586 return '[W sobotę o] LT';
14589 return '[W] dddd [o] LT';
14592 lastDay
: '[Wczoraj o] LT',
14593 lastWeek: function () {
14594 switch (this.day()) {
14596 return '[W zeszłą niedzielę o] LT';
14598 return '[W zeszłą środę o] LT';
14600 return '[W zeszłą sobotę o] LT';
14602 return '[W zeszły] dddd [o] LT';
14625 dayOfMonthOrdinalParse
: /\d{1,2}\./,
14628 dow
: 1, // Monday is the first day of the week.
14629 doy
: 4, // The week that contains Jan 4th is the first week of the year.
14633 //! moment.js locale configuration
14635 hooks
.defineLocale('pt-br', {
14636 months
: 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split(
14639 monthsShort
: 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
14640 weekdays
: 'domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado'.split(
14643 weekdaysShort
: 'dom_seg_ter_qua_qui_sex_sáb'.split('_'),
14644 weekdaysMin
: 'do_2ª_3ª_4ª_5ª_6ª_sá'.split('_'),
14645 weekdaysParseExact
: true,
14650 LL
: 'D [de] MMMM [de] YYYY',
14651 LLL
: 'D [de] MMMM [de] YYYY [às] HH:mm',
14652 LLLL
: 'dddd, D [de] MMMM [de] YYYY [às] HH:mm',
14655 sameDay
: '[Hoje às] LT',
14656 nextDay
: '[Amanhã às] LT',
14657 nextWeek
: 'dddd [às] LT',
14658 lastDay
: '[Ontem às] LT',
14659 lastWeek: function () {
14660 return this.day() === 0 || this.day() === 6
14661 ? '[Último] dddd [às] LT' // Saturday + Sunday
14662 : '[Última] dddd [às] LT'; // Monday - Friday
14669 s
: 'poucos segundos',
14682 dayOfMonthOrdinalParse
: /\d{1,2}º/,
14684 invalidDate
: 'Data inválida',
14687 //! moment.js locale configuration
14689 hooks
.defineLocale('pt', {
14690 months
: 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split(
14693 monthsShort
: 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
14694 weekdays
: 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split(
14697 weekdaysShort
: 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
14698 weekdaysMin
: 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
14699 weekdaysParseExact
: true,
14704 LL
: 'D [de] MMMM [de] YYYY',
14705 LLL
: 'D [de] MMMM [de] YYYY HH:mm',
14706 LLLL
: 'dddd, D [de] MMMM [de] YYYY HH:mm',
14709 sameDay
: '[Hoje às] LT',
14710 nextDay
: '[Amanhã às] LT',
14711 nextWeek
: 'dddd [às] LT',
14712 lastDay
: '[Ontem às] LT',
14713 lastWeek: function () {
14714 return this.day() === 0 || this.day() === 6
14715 ? '[Último] dddd [às] LT' // Saturday + Sunday
14716 : '[Última] dddd [às] LT'; // Monday - Friday
14738 dayOfMonthOrdinalParse
: /\d{1,2}º/,
14741 dow
: 1, // Monday is the first day of the week.
14742 doy
: 4, // The week that contains Jan 4th is the first week of the year.
14746 //! moment.js locale configuration
14748 function relativeTimeWithPlural
$2(number
, withoutSuffix
, key
) {
14759 if (number
% 100 >= 20 || (number
>= 100 && number
% 100 === 0)) {
14760 separator
= ' de ';
14762 return number
+ separator
+ format
[key
];
14765 hooks
.defineLocale('ro', {
14766 months
: 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split(
14769 monthsShort
: 'ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split(
14772 monthsParseExact
: true,
14773 weekdays
: 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
14774 weekdaysShort
: 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
14775 weekdaysMin
: 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
14781 LLL
: 'D MMMM YYYY H:mm',
14782 LLLL
: 'dddd, D MMMM YYYY H:mm',
14785 sameDay
: '[azi la] LT',
14786 nextDay
: '[mâine la] LT',
14787 nextWeek
: 'dddd [la] LT',
14788 lastDay
: '[ieri la] LT',
14789 lastWeek
: '[fosta] dddd [la] LT',
14793 future
: 'peste %s',
14794 past
: '%s în urmă',
14795 s
: 'câteva secunde',
14796 ss
: relativeTimeWithPlural
$2,
14798 mm
: relativeTimeWithPlural
$2,
14800 hh
: relativeTimeWithPlural
$2,
14802 dd
: relativeTimeWithPlural
$2,
14804 ww
: relativeTimeWithPlural
$2,
14806 MM
: relativeTimeWithPlural
$2,
14808 yy
: relativeTimeWithPlural
$2,
14811 dow
: 1, // Monday is the first day of the week.
14812 doy
: 7, // The week that contains Jan 7th is the first week of the year.
14816 //! moment.js locale configuration
14818 function plural
$4(word
, num
) {
14819 var forms
= word
.split('_');
14820 return num
% 10 === 1 && num
% 100 !== 11
14822 : num
% 10 >= 2 && num
% 10 <= 4 && (num
% 100 < 10 || num
% 100 >= 20)
14826 function relativeTimeWithPlural
$3(number
, withoutSuffix
, key
) {
14828 ss
: withoutSuffix
? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
14829 mm
: withoutSuffix
? 'минута_минуты_минут' : 'минуту_минуты_минут',
14830 hh
: 'час_часа_часов',
14831 dd
: 'день_дня_дней',
14832 ww
: 'неделя_недели_недель',
14833 MM
: 'месяц_месяца_месяцев',
14834 yy
: 'год_года_лет',
14837 return withoutSuffix
? 'минута' : 'минуту';
14839 return number
+ ' ' + plural
$4(format
[key
], +number
);
14842 var monthsParse
$a
= [
14857 // http://new.gramota.ru/spravka/rules/139-prop : § 103
14858 // Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637
14859 // CLDR data: http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
14860 hooks
.defineLocale('ru', {
14862 format
: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split(
14865 standalone
: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split(
14870 // по CLDR именно "июл." и "июн.", но какой смысл менять букву на точку?
14871 format
: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split(
14874 standalone
: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split(
14879 standalone
: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split(
14882 format
: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split(
14885 isFormat
: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?] ?dddd/,
14887 weekdaysShort
: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
14888 weekdaysMin
: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
14889 monthsParse
: monthsParse
$a
,
14890 longMonthsParse
: monthsParse
$a
,
14891 shortMonthsParse
: monthsParse
$a
,
14893 // полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки
14894 monthsRegex
: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
14896 // копия предыдущего
14897 monthsShortRegex
: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
14899 // полные названия с падежами
14900 monthsStrictRegex
: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,
14902 // Выражение, которое соответствует только сокращённым формам
14903 monthsShortStrictRegex
: /^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,
14908 LL
: 'D MMMM YYYY г.',
14909 LLL
: 'D MMMM YYYY г., H:mm',
14910 LLLL
: 'dddd, D MMMM YYYY г., H:mm',
14913 sameDay
: '[Сегодня, в] LT',
14914 nextDay
: '[Завтра, в] LT',
14915 lastDay
: '[Вчера, в] LT',
14916 nextWeek: function (now
) {
14917 if (now
.week() !== this.week()) {
14918 switch (this.day()) {
14920 return '[В следующее] dddd, [в] LT';
14924 return '[В следующий] dddd, [в] LT';
14928 return '[В следующую] dddd, [в] LT';
14931 if (this.day() === 2) {
14932 return '[Во] dddd, [в] LT';
14934 return '[В] dddd, [в] LT';
14938 lastWeek: function (now
) {
14939 if (now
.week() !== this.week()) {
14940 switch (this.day()) {
14942 return '[В прошлое] dddd, [в] LT';
14946 return '[В прошлый] dddd, [в] LT';
14950 return '[В прошлую] dddd, [в] LT';
14953 if (this.day() === 2) {
14954 return '[Во] dddd, [в] LT';
14956 return '[В] dddd, [в] LT';
14963 future
: 'через %s',
14965 s
: 'несколько секунд',
14966 ss
: relativeTimeWithPlural
$3,
14967 m
: relativeTimeWithPlural
$3,
14968 mm
: relativeTimeWithPlural
$3,
14970 hh
: relativeTimeWithPlural
$3,
14972 dd
: relativeTimeWithPlural
$3,
14974 ww
: relativeTimeWithPlural
$3,
14976 MM
: relativeTimeWithPlural
$3,
14978 yy
: relativeTimeWithPlural
$3,
14980 meridiemParse
: /ночи|утра|дня|вечера/i,
14981 isPM: function (input
) {
14982 return /^(дня|вечера)$/.test(input
);
14984 meridiem: function (hour
, minute
, isLower
) {
14987 } else if (hour
< 12) {
14989 } else if (hour
< 17) {
14995 dayOfMonthOrdinalParse
: /\d{1,2}-(й|го|я)/,
14996 ordinal: function (number
, period
) {
15001 return number
+ '-й';
15003 return number
+ '-го';
15006 return number
+ '-я';
15012 dow
: 1, // Monday is the first day of the week.
15013 doy
: 4, // The week that contains Jan 4th is the first week of the year.
15017 //! moment.js locale configuration
15033 days
$1 = ['آچر', 'سومر', 'اڱارو', 'اربع', 'خميس', 'جمع', 'ڇنڇر'];
15035 hooks
.defineLocale('sd', {
15037 monthsShort
: months
$9,
15039 weekdaysShort
: days
$1,
15040 weekdaysMin
: days
$1,
15046 LLL
: 'D MMMM YYYY HH:mm',
15047 LLLL
: 'dddd، D MMMM YYYY HH:mm',
15049 meridiemParse
: /صبح|شام/,
15050 isPM: function (input
) {
15051 return 'شام' === input
;
15053 meridiem: function (hour
, minute
, isLower
) {
15060 sameDay
: '[اڄ] LT',
15061 nextDay
: '[سڀاڻي] LT',
15062 nextWeek
: 'dddd [اڳين هفتي تي] LT',
15063 lastDay
: '[ڪالهه] LT',
15064 lastWeek
: '[گزريل هفتي] dddd [تي] LT',
15083 preparse: function (string
) {
15084 return string
.replace(/،/g, ',');
15086 postformat: function (string
) {
15087 return string
.replace(/,/g
, '،');
15090 dow
: 1, // Monday is the first day of the week.
15091 doy
: 4, // The week that contains Jan 4th is the first week of the year.
15095 //! moment.js locale configuration
15097 hooks
.defineLocale('se', {
15098 months
: 'ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu'.split(
15101 monthsShort
: 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split(
15104 weekdays
: 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split(
15107 weekdaysShort
: 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
15108 weekdaysMin
: 's_v_m_g_d_b_L'.split('_'),
15113 LL
: 'MMMM D. [b.] YYYY',
15114 LLL
: 'MMMM D. [b.] YYYY [ti.] HH:mm',
15115 LLLL
: 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm',
15118 sameDay
: '[otne ti] LT',
15119 nextDay
: '[ihttin ti] LT',
15120 nextWeek
: 'dddd [ti] LT',
15121 lastDay
: '[ikte ti] LT',
15122 lastWeek
: '[ovddit] dddd [ti] LT',
15126 future
: '%s geažes',
15128 s
: 'moadde sekunddat',
15129 ss
: '%d sekunddat',
15141 dayOfMonthOrdinalParse
: /\d{1,2}\./,
15144 dow
: 1, // Monday is the first day of the week.
15145 doy
: 4, // The week that contains Jan 4th is the first week of the year.
15149 //! moment.js locale configuration
15152 hooks
.defineLocale('si', {
15153 months
: 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split(
15156 monthsShort
: 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split(
15159 weekdays
: 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split(
15162 weekdaysShort
: 'ඉරි_සඳු_අඟ_බදා_බ්රහ_සිකු_සෙන'.split('_'),
15163 weekdaysMin
: 'ඉ_ස_අ_බ_බ්ර_සි_සෙ'.split('_'),
15164 weekdaysParseExact
: true,
15170 LLL
: 'YYYY MMMM D, a h:mm',
15171 LLLL
: 'YYYY MMMM D [වැනි] dddd, a h:mm:ss',
15174 sameDay
: '[අද] LT[ට]',
15175 nextDay
: '[හෙට] LT[ට]',
15176 nextWeek
: 'dddd LT[ට]',
15177 lastDay
: '[ඊයේ] LT[ට]',
15178 lastWeek
: '[පසුගිය] dddd LT[ට]',
15197 dayOfMonthOrdinalParse
: /\d{1,2} වැනි/,
15198 ordinal: function (number
) {
15199 return number
+ ' වැනි';
15201 meridiemParse
: /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
15202 isPM: function (input
) {
15203 return input
=== 'ප.ව.' || input
=== 'පස් වරු';
15205 meridiem: function (hours
, minutes
, isLower
) {
15207 return isLower
? 'ප.ව.' : 'පස් වරු';
15209 return isLower
? 'පෙ.ව.' : 'පෙර වරු';
15214 //! moment.js locale configuration
15216 var months
$a
= 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split(
15219 monthsShort
$7 = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
15220 function plural
$5(n
) {
15221 return n
> 1 && n
< 5;
15223 function translate
$9(number
, withoutSuffix
, key
, isFuture
) {
15224 var result
= number
+ ' ';
15226 case 's': // a few seconds / in a few seconds / a few seconds ago
15227 return withoutSuffix
|| isFuture
? 'pár sekúnd' : 'pár sekundami';
15228 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
15229 if (withoutSuffix
|| isFuture
) {
15230 return result
+ (plural
$5(number
) ? 'sekundy' : 'sekúnd');
15232 return result
+ 'sekundami';
15234 case 'm': // a minute / in a minute / a minute ago
15235 return withoutSuffix
? 'minúta' : isFuture
? 'minútu' : 'minútou';
15236 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
15237 if (withoutSuffix
|| isFuture
) {
15238 return result
+ (plural
$5(number
) ? 'minúty' : 'minút');
15240 return result
+ 'minútami';
15242 case 'h': // an hour / in an hour / an hour ago
15243 return withoutSuffix
? 'hodina' : isFuture
? 'hodinu' : 'hodinou';
15244 case 'hh': // 9 hours / in 9 hours / 9 hours ago
15245 if (withoutSuffix
|| isFuture
) {
15246 return result
+ (plural
$5(number
) ? 'hodiny' : 'hodín');
15248 return result
+ 'hodinami';
15250 case 'd': // a day / in a day / a day ago
15251 return withoutSuffix
|| isFuture
? 'deň' : 'dňom';
15252 case 'dd': // 9 days / in 9 days / 9 days ago
15253 if (withoutSuffix
|| isFuture
) {
15254 return result
+ (plural
$5(number
) ? 'dni' : 'dní');
15256 return result
+ 'dňami';
15258 case 'M': // a month / in a month / a month ago
15259 return withoutSuffix
|| isFuture
? 'mesiac' : 'mesiacom';
15260 case 'MM': // 9 months / in 9 months / 9 months ago
15261 if (withoutSuffix
|| isFuture
) {
15262 return result
+ (plural
$5(number
) ? 'mesiace' : 'mesiacov');
15264 return result
+ 'mesiacmi';
15266 case 'y': // a year / in a year / a year ago
15267 return withoutSuffix
|| isFuture
? 'rok' : 'rokom';
15268 case 'yy': // 9 years / in 9 years / 9 years ago
15269 if (withoutSuffix
|| isFuture
) {
15270 return result
+ (plural
$5(number
) ? 'roky' : 'rokov');
15272 return result
+ 'rokmi';
15277 hooks
.defineLocale('sk', {
15279 monthsShort
: monthsShort
$7,
15280 weekdays
: 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
15281 weekdaysShort
: 'ne_po_ut_st_št_pi_so'.split('_'),
15282 weekdaysMin
: 'ne_po_ut_st_št_pi_so'.split('_'),
15287 LL
: 'D. MMMM YYYY',
15288 LLL
: 'D. MMMM YYYY H:mm',
15289 LLLL
: 'dddd D. MMMM YYYY H:mm',
15292 sameDay
: '[dnes o] LT',
15293 nextDay
: '[zajtra o] LT',
15294 nextWeek: function () {
15295 switch (this.day()) {
15297 return '[v nedeľu o] LT';
15300 return '[v] dddd [o] LT';
15302 return '[v stredu o] LT';
15304 return '[vo štvrtok o] LT';
15306 return '[v piatok o] LT';
15308 return '[v sobotu o] LT';
15311 lastDay
: '[včera o] LT',
15312 lastWeek: function () {
15313 switch (this.day()) {
15315 return '[minulú nedeľu o] LT';
15318 return '[minulý] dddd [o] LT';
15320 return '[minulú stredu o] LT';
15323 return '[minulý] dddd [o] LT';
15325 return '[minulú sobotu o] LT';
15346 dayOfMonthOrdinalParse
: /\d{1,2}\./,
15349 dow
: 1, // Monday is the first day of the week.
15350 doy
: 4, // The week that contains Jan 4th is the first week of the year.
15354 //! moment.js locale configuration
15356 function processRelativeTime
$7(number
, withoutSuffix
, key
, isFuture
) {
15357 var result
= number
+ ' ';
15360 return withoutSuffix
|| isFuture
15362 : 'nekaj sekundami';
15364 if (number
=== 1) {
15365 result
+= withoutSuffix
? 'sekundo' : 'sekundi';
15366 } else if (number
=== 2) {
15367 result
+= withoutSuffix
|| isFuture
? 'sekundi' : 'sekundah';
15368 } else if (number
< 5) {
15369 result
+= withoutSuffix
|| isFuture
? 'sekunde' : 'sekundah';
15371 result
+= 'sekund';
15375 return withoutSuffix
? 'ena minuta' : 'eno minuto';
15377 if (number
=== 1) {
15378 result
+= withoutSuffix
? 'minuta' : 'minuto';
15379 } else if (number
=== 2) {
15380 result
+= withoutSuffix
|| isFuture
? 'minuti' : 'minutama';
15381 } else if (number
< 5) {
15382 result
+= withoutSuffix
|| isFuture
? 'minute' : 'minutami';
15384 result
+= withoutSuffix
|| isFuture
? 'minut' : 'minutami';
15388 return withoutSuffix
? 'ena ura' : 'eno uro';
15390 if (number
=== 1) {
15391 result
+= withoutSuffix
? 'ura' : 'uro';
15392 } else if (number
=== 2) {
15393 result
+= withoutSuffix
|| isFuture
? 'uri' : 'urama';
15394 } else if (number
< 5) {
15395 result
+= withoutSuffix
|| isFuture
? 'ure' : 'urami';
15397 result
+= withoutSuffix
|| isFuture
? 'ur' : 'urami';
15401 return withoutSuffix
|| isFuture
? 'en dan' : 'enim dnem';
15403 if (number
=== 1) {
15404 result
+= withoutSuffix
|| isFuture
? 'dan' : 'dnem';
15405 } else if (number
=== 2) {
15406 result
+= withoutSuffix
|| isFuture
? 'dni' : 'dnevoma';
15408 result
+= withoutSuffix
|| isFuture
? 'dni' : 'dnevi';
15412 return withoutSuffix
|| isFuture
? 'en mesec' : 'enim mesecem';
15414 if (number
=== 1) {
15415 result
+= withoutSuffix
|| isFuture
? 'mesec' : 'mesecem';
15416 } else if (number
=== 2) {
15417 result
+= withoutSuffix
|| isFuture
? 'meseca' : 'mesecema';
15418 } else if (number
< 5) {
15419 result
+= withoutSuffix
|| isFuture
? 'mesece' : 'meseci';
15421 result
+= withoutSuffix
|| isFuture
? 'mesecev' : 'meseci';
15425 return withoutSuffix
|| isFuture
? 'eno leto' : 'enim letom';
15427 if (number
=== 1) {
15428 result
+= withoutSuffix
|| isFuture
? 'leto' : 'letom';
15429 } else if (number
=== 2) {
15430 result
+= withoutSuffix
|| isFuture
? 'leti' : 'letoma';
15431 } else if (number
< 5) {
15432 result
+= withoutSuffix
|| isFuture
? 'leta' : 'leti';
15434 result
+= withoutSuffix
|| isFuture
? 'let' : 'leti';
15440 hooks
.defineLocale('sl', {
15441 months
: 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split(
15444 monthsShort
: 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split(
15447 monthsParseExact
: true,
15448 weekdays
: 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
15449 weekdaysShort
: 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
15450 weekdaysMin
: 'ne_po_to_sr_če_pe_so'.split('_'),
15451 weekdaysParseExact
: true,
15456 LL
: 'D. MMMM YYYY',
15457 LLL
: 'D. MMMM YYYY H:mm',
15458 LLLL
: 'dddd, D. MMMM YYYY H:mm',
15461 sameDay
: '[danes ob] LT',
15462 nextDay
: '[jutri ob] LT',
15464 nextWeek: function () {
15465 switch (this.day()) {
15467 return '[v] [nedeljo] [ob] LT';
15469 return '[v] [sredo] [ob] LT';
15471 return '[v] [soboto] [ob] LT';
15476 return '[v] dddd [ob] LT';
15479 lastDay
: '[včeraj ob] LT',
15480 lastWeek: function () {
15481 switch (this.day()) {
15483 return '[prejšnjo] [nedeljo] [ob] LT';
15485 return '[prejšnjo] [sredo] [ob] LT';
15487 return '[prejšnjo] [soboto] [ob] LT';
15492 return '[prejšnji] dddd [ob] LT';
15500 s
: processRelativeTime
$7,
15501 ss
: processRelativeTime
$7,
15502 m
: processRelativeTime
$7,
15503 mm
: processRelativeTime
$7,
15504 h
: processRelativeTime
$7,
15505 hh
: processRelativeTime
$7,
15506 d
: processRelativeTime
$7,
15507 dd
: processRelativeTime
$7,
15508 M
: processRelativeTime
$7,
15509 MM
: processRelativeTime
$7,
15510 y
: processRelativeTime
$7,
15511 yy
: processRelativeTime
$7,
15513 dayOfMonthOrdinalParse
: /\d{1,2}\./,
15516 dow
: 1, // Monday is the first day of the week.
15517 doy
: 7, // The week that contains Jan 7th is the first week of the year.
15521 //! moment.js locale configuration
15523 hooks
.defineLocale('sq', {
15524 months
: 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split(
15527 monthsShort
: 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
15528 weekdays
: 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split(
15531 weekdaysShort
: 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
15532 weekdaysMin
: 'D_H_Ma_Më_E_P_Sh'.split('_'),
15533 weekdaysParseExact
: true,
15534 meridiemParse
: /PD|MD/,
15535 isPM: function (input
) {
15536 return input
.charAt(0) === 'M';
15538 meridiem: function (hours
, minutes
, isLower
) {
15539 return hours
< 12 ? 'PD' : 'MD';
15546 LLL
: 'D MMMM YYYY HH:mm',
15547 LLLL
: 'dddd, D MMMM YYYY HH:mm',
15550 sameDay
: '[Sot në] LT',
15551 nextDay
: '[Nesër në] LT',
15552 nextWeek
: 'dddd [në] LT',
15553 lastDay
: '[Dje në] LT',
15554 lastWeek
: 'dddd [e kaluar në] LT',
15559 past
: '%s më parë',
15573 dayOfMonthOrdinalParse
: /\d{1,2}\./,
15576 dow
: 1, // Monday is the first day of the week.
15577 doy
: 4, // The week that contains Jan 4th is the first week of the year.
15581 //! moment.js locale configuration
15583 var translator
$1 = {
15585 //Different grammatical cases
15586 ss
: ['секунда', 'секунде', 'секунди'],
15587 m
: ['један минут', 'једне минуте'],
15588 mm
: ['минут', 'минуте', 'минута'],
15589 h
: ['један сат', 'једног сата'],
15590 hh
: ['сат', 'сата', 'сати'],
15591 dd
: ['дан', 'дана', 'дана'],
15592 MM
: ['месец', 'месеца', 'месеци'],
15593 yy
: ['година', 'године', 'година'],
15595 correctGrammaticalCase: function (number
, wordKey
) {
15596 return number
=== 1
15598 : number
>= 2 && number
<= 4
15602 translate: function (number
, withoutSuffix
, key
) {
15603 var wordKey
= translator
$1.words
[key
];
15604 if (key
.length
=== 1) {
15605 return withoutSuffix
? wordKey
[0] : wordKey
[1];
15610 translator
$1.correctGrammaticalCase(number
, wordKey
)
15616 hooks
.defineLocale('sr-cyrl', {
15617 months
: 'јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар'.split(
15620 monthsShort
: 'јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.'.split(
15623 monthsParseExact
: true,
15624 weekdays
: 'недеља_понедељак_уторак_среда_четвртак_петак_субота'.split('_'),
15625 weekdaysShort
: 'нед._пон._уто._сре._чет._пет._суб.'.split('_'),
15626 weekdaysMin
: 'не_по_ут_ср_че_пе_су'.split('_'),
15627 weekdaysParseExact
: true,
15632 LL
: 'D. MMMM YYYY.',
15633 LLL
: 'D. MMMM YYYY. H:mm',
15634 LLLL
: 'dddd, D. MMMM YYYY. H:mm',
15637 sameDay
: '[данас у] LT',
15638 nextDay
: '[сутра у] LT',
15639 nextWeek: function () {
15640 switch (this.day()) {
15642 return '[у] [недељу] [у] LT';
15644 return '[у] [среду] [у] LT';
15646 return '[у] [суботу] [у] LT';
15651 return '[у] dddd [у] LT';
15654 lastDay
: '[јуче у] LT',
15655 lastWeek: function () {
15656 var lastWeekDays
= [
15657 '[прошле] [недеље] [у] LT',
15658 '[прошлог] [понедељка] [у] LT',
15659 '[прошлог] [уторка] [у] LT',
15660 '[прошле] [среде] [у] LT',
15661 '[прошлог] [четвртка] [у] LT',
15662 '[прошлог] [петка] [у] LT',
15663 '[прошле] [суботе] [у] LT',
15665 return lastWeekDays
[this.day()];
15672 s
: 'неколико секунди',
15673 ss
: translator
$1.translate
,
15674 m
: translator
$1.translate
,
15675 mm
: translator
$1.translate
,
15676 h
: translator
$1.translate
,
15677 hh
: translator
$1.translate
,
15679 dd
: translator
$1.translate
,
15681 MM
: translator
$1.translate
,
15683 yy
: translator
$1.translate
,
15685 dayOfMonthOrdinalParse
: /\d{1,2}\./,
15688 dow
: 1, // Monday is the first day of the week.
15689 doy
: 7, // The week that contains Jan 1st is the first week of the year.
15693 //! moment.js locale configuration
15695 var translator
$2 = {
15697 //Different grammatical cases
15698 ss
: ['sekunda', 'sekunde', 'sekundi'],
15699 m
: ['jedan minut', 'jedne minute'],
15700 mm
: ['minut', 'minute', 'minuta'],
15701 h
: ['jedan sat', 'jednog sata'],
15702 hh
: ['sat', 'sata', 'sati'],
15703 dd
: ['dan', 'dana', 'dana'],
15704 MM
: ['mesec', 'meseca', 'meseci'],
15705 yy
: ['godina', 'godine', 'godina'],
15707 correctGrammaticalCase: function (number
, wordKey
) {
15708 return number
=== 1
15710 : number
>= 2 && number
<= 4
15714 translate: function (number
, withoutSuffix
, key
) {
15715 var wordKey
= translator
$2.words
[key
];
15716 if (key
.length
=== 1) {
15717 return withoutSuffix
? wordKey
[0] : wordKey
[1];
15722 translator
$2.correctGrammaticalCase(number
, wordKey
)
15728 hooks
.defineLocale('sr', {
15729 months
: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split(
15732 monthsShort
: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split(
15735 monthsParseExact
: true,
15736 weekdays
: 'nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota'.split(
15739 weekdaysShort
: 'ned._pon._uto._sre._čet._pet._sub.'.split('_'),
15740 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
15741 weekdaysParseExact
: true,
15746 LL
: 'D. MMMM YYYY.',
15747 LLL
: 'D. MMMM YYYY. H:mm',
15748 LLLL
: 'dddd, D. MMMM YYYY. H:mm',
15751 sameDay
: '[danas u] LT',
15752 nextDay
: '[sutra u] LT',
15753 nextWeek: function () {
15754 switch (this.day()) {
15756 return '[u] [nedelju] [u] LT';
15758 return '[u] [sredu] [u] LT';
15760 return '[u] [subotu] [u] LT';
15765 return '[u] dddd [u] LT';
15768 lastDay
: '[juče u] LT',
15769 lastWeek: function () {
15770 var lastWeekDays
= [
15771 '[prošle] [nedelje] [u] LT',
15772 '[prošlog] [ponedeljka] [u] LT',
15773 '[prošlog] [utorka] [u] LT',
15774 '[prošle] [srede] [u] LT',
15775 '[prošlog] [četvrtka] [u] LT',
15776 '[prošlog] [petka] [u] LT',
15777 '[prošle] [subote] [u] LT',
15779 return lastWeekDays
[this.day()];
15786 s
: 'nekoliko sekundi',
15787 ss
: translator
$2.translate
,
15788 m
: translator
$2.translate
,
15789 mm
: translator
$2.translate
,
15790 h
: translator
$2.translate
,
15791 hh
: translator
$2.translate
,
15793 dd
: translator
$2.translate
,
15795 MM
: translator
$2.translate
,
15797 yy
: translator
$2.translate
,
15799 dayOfMonthOrdinalParse
: /\d{1,2}\./,
15802 dow
: 1, // Monday is the first day of the week.
15803 doy
: 7, // The week that contains Jan 7th is the first week of the year.
15807 //! moment.js locale configuration
15809 hooks
.defineLocale('ss', {
15810 months
: "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split(
15813 monthsShort
: 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
15814 weekdays
: 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split(
15817 weekdaysShort
: 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
15818 weekdaysMin
: 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
15819 weekdaysParseExact
: true,
15825 LLL
: 'D MMMM YYYY h:mm A',
15826 LLLL
: 'dddd, D MMMM YYYY h:mm A',
15829 sameDay
: '[Namuhla nga] LT',
15830 nextDay
: '[Kusasa nga] LT',
15831 nextWeek
: 'dddd [nga] LT',
15832 lastDay
: '[Itolo nga] LT',
15833 lastWeek
: 'dddd [leliphelile] [nga] LT',
15838 past
: 'wenteka nga %s',
15839 s
: 'emizuzwana lomcane',
15852 meridiemParse
: /ekuseni|emini|entsambama|ebusuku/,
15853 meridiem: function (hours
, minutes
, isLower
) {
15856 } else if (hours
< 15) {
15858 } else if (hours
< 19) {
15859 return 'entsambama';
15864 meridiemHour: function (hour
, meridiem
) {
15868 if (meridiem
=== 'ekuseni') {
15870 } else if (meridiem
=== 'emini') {
15871 return hour
>= 11 ? hour
: hour
+ 12;
15872 } else if (meridiem
=== 'entsambama' || meridiem
=== 'ebusuku') {
15879 dayOfMonthOrdinalParse
: /\d{1,2}/,
15882 dow
: 1, // Monday is the first day of the week.
15883 doy
: 4, // The week that contains Jan 4th is the first week of the year.
15887 //! moment.js locale configuration
15889 hooks
.defineLocale('sv', {
15890 months
: 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split(
15893 monthsShort
: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
15894 weekdays
: 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
15895 weekdaysShort
: 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
15896 weekdaysMin
: 'sö_må_ti_on_to_fr_lö'.split('_'),
15902 LLL
: 'D MMMM YYYY [kl.] HH:mm',
15903 LLLL
: 'dddd D MMMM YYYY [kl.] HH:mm',
15904 lll
: 'D MMM YYYY HH:mm',
15905 llll
: 'ddd D MMM YYYY HH:mm',
15908 sameDay
: '[Idag] LT',
15909 nextDay
: '[Imorgon] LT',
15910 lastDay
: '[Igår] LT',
15911 nextWeek
: '[På] dddd LT',
15912 lastWeek
: '[I] dddd[s] LT',
15917 past
: 'för %s sedan',
15918 s
: 'några sekunder',
15931 dayOfMonthOrdinalParse
: /\d{1,2}(\:e|\:a)/,
15932 ordinal: function (number
) {
15933 var b
= number
% 10,
15935 ~~((number
% 100) / 10) === 1
15944 return number
+ output
;
15947 dow
: 1, // Monday is the first day of the week.
15948 doy
: 4, // The week that contains Jan 4th is the first week of the year.
15952 //! moment.js locale configuration
15954 hooks
.defineLocale('sw', {
15955 months
: 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split(
15958 monthsShort
: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
15959 weekdays
: 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split(
15962 weekdaysShort
: 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
15963 weekdaysMin
: 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
15964 weekdaysParseExact
: true,
15970 LLL
: 'D MMMM YYYY HH:mm',
15971 LLLL
: 'dddd, D MMMM YYYY HH:mm',
15974 sameDay
: '[leo saa] LT',
15975 nextDay
: '[kesho saa] LT',
15976 nextWeek
: '[wiki ijayo] dddd [saat] LT',
15977 lastDay
: '[jana] LT',
15978 lastWeek
: '[wiki iliyopita] dddd [saat] LT',
15982 future
: '%s baadaye',
15998 dow
: 1, // Monday is the first day of the week.
15999 doy
: 7, // The week that contains Jan 7th is the first week of the year.
16003 //! moment.js locale configuration
16005 var symbolMap
$g
= {
16030 hooks
.defineLocale('ta', {
16031 months
: 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split(
16034 monthsShort
: 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split(
16037 weekdays
: 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split(
16040 weekdaysShort
: 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split(
16043 weekdaysMin
: 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
16049 LLL
: 'D MMMM YYYY, HH:mm',
16050 LLLL
: 'dddd, D MMMM YYYY, HH:mm',
16053 sameDay
: '[இன்று] LT',
16054 nextDay
: '[நாளை] LT',
16055 nextWeek
: 'dddd, LT',
16056 lastDay
: '[நேற்று] LT',
16057 lastWeek
: '[கடந்த வாரம்] dddd, LT',
16063 s
: 'ஒரு சில விநாடிகள்',
16064 ss
: '%d விநாடிகள்',
16066 mm
: '%d நிமிடங்கள்',
16067 h
: 'ஒரு மணி நேரம்',
16068 hh
: '%d மணி நேரம்',
16076 dayOfMonthOrdinalParse
: /\d{1,2}வது/,
16077 ordinal: function (number
) {
16078 return number
+ 'வது';
16080 preparse: function (string
) {
16081 return string
.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match
) {
16082 return numberMap
$f
[match
];
16085 postformat: function (string
) {
16086 return string
.replace(/\d/g, function (match
) {
16087 return symbolMap
$g
[match
];
16090 // refer http://ta.wikipedia.org/s/1er1
16091 meridiemParse
: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
16092 meridiem: function (hour
, minute
, isLower
) {
16095 } else if (hour
< 6) {
16096 return ' வைகறை'; // வைகறை
16097 } else if (hour
< 10) {
16098 return ' காலை'; // காலை
16099 } else if (hour
< 14) {
16100 return ' நண்பகல்'; // நண்பகல்
16101 } else if (hour
< 18) {
16102 return ' எற்பாடு'; // எற்பாடு
16103 } else if (hour
< 22) {
16104 return ' மாலை'; // மாலை
16109 meridiemHour: function (hour
, meridiem
) {
16113 if (meridiem
=== 'யாமம்') {
16114 return hour
< 2 ? hour
: hour
+ 12;
16115 } else if (meridiem
=== 'வைகறை' || meridiem
=== 'காலை') {
16117 } else if (meridiem
=== 'நண்பகல்') {
16118 return hour
>= 10 ? hour
: hour
+ 12;
16124 dow
: 0, // Sunday is the first day of the week.
16125 doy
: 6, // The week that contains Jan 6th is the first week of the year.
16129 //! moment.js locale configuration
16131 hooks
.defineLocale('te', {
16132 months
: 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జులై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split(
16135 monthsShort
: 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జులై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split(
16138 monthsParseExact
: true,
16139 weekdays
: 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split(
16142 weekdaysShort
: 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
16143 weekdaysMin
: 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
16149 LLL
: 'D MMMM YYYY, A h:mm',
16150 LLLL
: 'dddd, D MMMM YYYY, A h:mm',
16153 sameDay
: '[నేడు] LT',
16154 nextDay
: '[రేపు] LT',
16155 nextWeek
: 'dddd, LT',
16156 lastDay
: '[నిన్న] LT',
16157 lastWeek
: '[గత] dddd, LT',
16163 s
: 'కొన్ని క్షణాలు',
16174 yy
: '%d సంవత్సరాలు',
16176 dayOfMonthOrdinalParse
: /\d{1,2}వ/,
16178 meridiemParse
: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
16179 meridiemHour: function (hour
, meridiem
) {
16183 if (meridiem
=== 'రాత్రి') {
16184 return hour
< 4 ? hour
: hour
+ 12;
16185 } else if (meridiem
=== 'ఉదయం') {
16187 } else if (meridiem
=== 'మధ్యాహ్నం') {
16188 return hour
>= 10 ? hour
: hour
+ 12;
16189 } else if (meridiem
=== 'సాయంత్రం') {
16193 meridiem: function (hour
, minute
, isLower
) {
16196 } else if (hour
< 10) {
16198 } else if (hour
< 17) {
16199 return 'మధ్యాహ్నం';
16200 } else if (hour
< 20) {
16207 dow
: 0, // Sunday is the first day of the week.
16208 doy
: 6, // The week that contains Jan 6th is the first week of the year.
16212 //! moment.js locale configuration
16214 hooks
.defineLocale('tet', {
16215 months
: 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru'.split(
16218 monthsShort
: 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
16219 weekdays
: 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu'.split('_'),
16220 weekdaysShort
: 'Dom_Seg_Ters_Kua_Kint_Sest_Sab'.split('_'),
16221 weekdaysMin
: 'Do_Seg_Te_Ku_Ki_Ses_Sa'.split('_'),
16227 LLL
: 'D MMMM YYYY HH:mm',
16228 LLLL
: 'dddd, D MMMM YYYY HH:mm',
16231 sameDay
: '[Ohin iha] LT',
16232 nextDay
: '[Aban iha] LT',
16233 nextWeek
: 'dddd [iha] LT',
16234 lastDay
: '[Horiseik iha] LT',
16235 lastWeek
: 'dddd [semana kotuk] [iha] LT',
16241 s
: 'segundu balun',
16254 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
16255 ordinal: function (number
) {
16256 var b
= number
% 10,
16258 ~~((number
% 100) / 10) === 1
16267 return number
+ output
;
16270 dow
: 1, // Monday is the first day of the week.
16271 doy
: 4, // The week that contains Jan 4th is the first week of the year.
16275 //! moment.js locale configuration
16302 hooks
.defineLocale('tg', {
16304 format
: 'январи_феврали_марти_апрели_майи_июни_июли_августи_сентябри_октябри_ноябри_декабри'.split(
16307 standalone
: 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split(
16311 monthsShort
: 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
16312 weekdays
: 'якшанбе_душанбе_сешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе'.split(
16315 weekdaysShort
: 'яшб_дшб_сшб_чшб_пшб_ҷум_шнб'.split('_'),
16316 weekdaysMin
: 'яш_дш_сш_чш_пш_ҷм_шб'.split('_'),
16322 LLL
: 'D MMMM YYYY HH:mm',
16323 LLLL
: 'dddd, D MMMM YYYY HH:mm',
16326 sameDay
: '[Имрӯз соати] LT',
16327 nextDay
: '[Фардо соати] LT',
16328 lastDay
: '[Дирӯз соати] LT',
16329 nextWeek
: 'dddd[и] [ҳафтаи оянда соати] LT',
16330 lastWeek
: 'dddd[и] [ҳафтаи гузашта соати] LT',
16334 future
: 'баъди %s',
16348 meridiemParse
: /шаб|субҳ|рӯз|бегоҳ/,
16349 meridiemHour: function (hour
, meridiem
) {
16353 if (meridiem
=== 'шаб') {
16354 return hour
< 4 ? hour
: hour
+ 12;
16355 } else if (meridiem
=== 'субҳ') {
16357 } else if (meridiem
=== 'рӯз') {
16358 return hour
>= 11 ? hour
: hour
+ 12;
16359 } else if (meridiem
=== 'бегоҳ') {
16363 meridiem: function (hour
, minute
, isLower
) {
16366 } else if (hour
< 11) {
16368 } else if (hour
< 16) {
16370 } else if (hour
< 19) {
16376 dayOfMonthOrdinalParse
: /\d{1,2}-(ум|юм)/,
16377 ordinal: function (number
) {
16378 var a
= number
% 10,
16379 b
= number
>= 100 ? 100 : null;
16380 return number
+ (suffixes
$3[number
] || suffixes
$3[a
] || suffixes
$3[b
]);
16383 dow
: 1, // Monday is the first day of the week.
16384 doy
: 7, // The week that contains Jan 1th is the first week of the year.
16388 //! moment.js locale configuration
16390 hooks
.defineLocale('th', {
16391 months
: 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split(
16394 monthsShort
: 'ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.'.split(
16397 monthsParseExact
: true,
16398 weekdays
: 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
16399 weekdaysShort
: 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
16400 weekdaysMin
: 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
16401 weekdaysParseExact
: true,
16407 LLL
: 'D MMMM YYYY เวลา H:mm',
16408 LLLL
: 'วันddddที่ D MMMM YYYY เวลา H:mm',
16410 meridiemParse
: /ก่อนเที่ยง|หลังเที่ยง/,
16411 isPM: function (input
) {
16412 return input
=== 'หลังเที่ยง';
16414 meridiem: function (hour
, minute
, isLower
) {
16416 return 'ก่อนเที่ยง';
16418 return 'หลังเที่ยง';
16422 sameDay
: '[วันนี้ เวลา] LT',
16423 nextDay
: '[พรุ่งนี้ เวลา] LT',
16424 nextWeek
: 'dddd[หน้า เวลา] LT',
16425 lastDay
: '[เมื่อวานนี้ เวลา] LT',
16426 lastWeek
: '[วัน]dddd[ที่แล้ว เวลา] LT',
16449 //! moment.js locale configuration
16472 hooks
.defineLocale('tk', {
16473 months
: 'Ýanwar_Fewral_Mart_Aprel_Maý_Iýun_Iýul_Awgust_Sentýabr_Oktýabr_Noýabr_Dekabr'.split(
16476 monthsShort
: 'Ýan_Few_Mar_Apr_Maý_Iýn_Iýl_Awg_Sen_Okt_Noý_Dek'.split('_'),
16477 weekdays
: 'Ýekşenbe_Duşenbe_Sişenbe_Çarşenbe_Penşenbe_Anna_Şenbe'.split(
16480 weekdaysShort
: 'Ýek_Duş_Siş_Çar_Pen_Ann_Şen'.split('_'),
16481 weekdaysMin
: 'Ýk_Dş_Sş_Çr_Pn_An_Şn'.split('_'),
16487 LLL
: 'D MMMM YYYY HH:mm',
16488 LLLL
: 'dddd, D MMMM YYYY HH:mm',
16491 sameDay
: '[bugün sagat] LT',
16492 nextDay
: '[ertir sagat] LT',
16493 nextWeek
: '[indiki] dddd [sagat] LT',
16494 lastDay
: '[düýn] LT',
16495 lastWeek
: '[geçen] dddd [sagat] LT',
16501 s
: 'birnäçe sekunt',
16513 ordinal: function (number
, period
) {
16521 if (number
=== 0) {
16522 // special case for zero
16523 return number
+ "'unjy";
16525 var a
= number
% 10,
16526 b
= (number
% 100) - a
,
16527 c
= number
>= 100 ? 100 : null;
16528 return number
+ (suffixes
$4[a
] || suffixes
$4[b
] || suffixes
$4[c
]);
16532 dow
: 1, // Monday is the first day of the week.
16533 doy
: 7, // The week that contains Jan 7th is the first week of the year.
16537 //! moment.js locale configuration
16539 hooks
.defineLocale('tl-ph', {
16540 months
: 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split(
16543 monthsShort
: 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
16544 weekdays
: 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split(
16547 weekdaysShort
: 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
16548 weekdaysMin
: 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
16553 LL
: 'MMMM D, YYYY',
16554 LLL
: 'MMMM D, YYYY HH:mm',
16555 LLLL
: 'dddd, MMMM DD, YYYY HH:mm',
16558 sameDay
: 'LT [ngayong araw]',
16559 nextDay
: '[Bukas ng] LT',
16560 nextWeek
: 'LT [sa susunod na] dddd',
16561 lastDay
: 'LT [kahapon]',
16562 lastWeek
: 'LT [noong nakaraang] dddd',
16566 future
: 'sa loob ng %s',
16567 past
: '%s ang nakalipas',
16568 s
: 'ilang segundo',
16581 dayOfMonthOrdinalParse
: /\d{1,2}/,
16582 ordinal: function (number
) {
16586 dow
: 1, // Monday is the first day of the week.
16587 doy
: 4, // The week that contains Jan 4th is the first week of the year.
16591 //! moment.js locale configuration
16593 var numbersNouns
= 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
16595 function translateFuture(output
) {
16598 output
.indexOf('jaj') !== -1
16599 ? time
.slice(0, -3) + 'leS'
16600 : output
.indexOf('jar') !== -1
16601 ? time
.slice(0, -3) + 'waQ'
16602 : output
.indexOf('DIS') !== -1
16603 ? time
.slice(0, -3) + 'nem'
16608 function translatePast(output
) {
16611 output
.indexOf('jaj') !== -1
16612 ? time
.slice(0, -3) + 'Hu’'
16613 : output
.indexOf('jar') !== -1
16614 ? time
.slice(0, -3) + 'wen'
16615 : output
.indexOf('DIS') !== -1
16616 ? time
.slice(0, -3) + 'ben'
16621 function translate
$a(number
, withoutSuffix
, string
, isFuture
) {
16622 var numberNoun
= numberAsNoun(number
);
16625 return numberNoun
+ ' lup';
16627 return numberNoun
+ ' tup';
16629 return numberNoun
+ ' rep';
16631 return numberNoun
+ ' jaj';
16633 return numberNoun
+ ' jar';
16635 return numberNoun
+ ' DIS';
16639 function numberAsNoun(number
) {
16640 var hundred
= Math
.floor((number
% 1000) / 100),
16641 ten
= Math
.floor((number
% 100) / 10),
16645 word
+= numbersNouns
[hundred
] + 'vatlh';
16648 word
+= (word
!== '' ? ' ' : '') + numbersNouns
[ten
] + 'maH';
16651 word
+= (word
!== '' ? ' ' : '') + numbersNouns
[one
];
16653 return word
=== '' ? 'pagh' : word
;
16656 hooks
.defineLocale('tlh', {
16657 months
: 'tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’'.split(
16660 monthsShort
: 'jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’'.split(
16663 monthsParseExact
: true,
16664 weekdays
: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split(
16667 weekdaysShort
: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split(
16670 weekdaysMin
: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split(
16678 LLL
: 'D MMMM YYYY HH:mm',
16679 LLLL
: 'dddd, D MMMM YYYY HH:mm',
16682 sameDay
: '[DaHjaj] LT',
16683 nextDay
: '[wa’leS] LT',
16685 lastDay
: '[wa’Hu’] LT',
16690 future
: translateFuture
,
16691 past
: translatePast
,
16705 dayOfMonthOrdinalParse
: /\d{1,2}\./,
16708 dow
: 1, // Monday is the first day of the week.
16709 doy
: 4, // The week that contains Jan 4th is the first week of the year.
16713 //! moment.js locale configuration
16736 hooks
.defineLocale('tr', {
16737 months
: 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split(
16740 monthsShort
: 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
16741 weekdays
: 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split(
16744 weekdaysShort
: 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
16745 weekdaysMin
: 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
16746 meridiem: function (hours
, minutes
, isLower
) {
16748 return isLower
? 'öö' : 'ÖÖ';
16750 return isLower
? 'ös' : 'ÖS';
16753 meridiemParse
: /öö|ÖÖ|ös|ÖS/,
16754 isPM: function (input
) {
16755 return input
=== 'ös' || input
=== 'ÖS';
16762 LLL
: 'D MMMM YYYY HH:mm',
16763 LLLL
: 'dddd, D MMMM YYYY HH:mm',
16766 sameDay
: '[bugün saat] LT',
16767 nextDay
: '[yarın saat] LT',
16768 nextWeek
: '[gelecek] dddd [saat] LT',
16769 lastDay
: '[dün] LT',
16770 lastWeek
: '[geçen] dddd [saat] LT',
16774 future
: '%s sonra',
16776 s
: 'birkaç saniye',
16791 ordinal: function (number
, period
) {
16799 if (number
=== 0) {
16800 // special case for zero
16801 return number
+ "'ıncı";
16803 var a
= number
% 10,
16804 b
= (number
% 100) - a
,
16805 c
= number
>= 100 ? 100 : null;
16806 return number
+ (suffixes
$5[a
] || suffixes
$5[b
] || suffixes
$5[c
]);
16810 dow
: 1, // Monday is the first day of the week.
16811 doy
: 7, // The week that contains Jan 7th is the first week of the year.
16815 //! moment.js locale configuration
16817 // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
16818 // This is currently too difficult (maybe even impossible) to add.
16819 hooks
.defineLocale('tzl', {
16820 months
: 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split(
16823 monthsShort
: 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
16824 weekdays
: 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
16825 weekdaysShort
: 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
16826 weekdaysMin
: 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
16831 LL
: 'D. MMMM [dallas] YYYY',
16832 LLL
: 'D. MMMM [dallas] YYYY HH.mm',
16833 LLLL
: 'dddd, [li] D. MMMM [dallas] YYYY HH.mm',
16835 meridiemParse
: /d\'o|d\'a/i,
16836 isPM: function (input
) {
16837 return "d'o" === input
.toLowerCase();
16839 meridiem: function (hours
, minutes
, isLower
) {
16841 return isLower
? "d'o" : "D'O";
16843 return isLower
? "d'a" : "D'A";
16847 sameDay
: '[oxhi à] LT',
16848 nextDay
: '[demà à] LT',
16849 nextWeek
: 'dddd [à] LT',
16850 lastDay
: '[ieiri à] LT',
16851 lastWeek
: '[sür el] dddd [lasteu à] LT',
16855 future
: 'osprei %s',
16857 s
: processRelativeTime
$8,
16858 ss
: processRelativeTime
$8,
16859 m
: processRelativeTime
$8,
16860 mm
: processRelativeTime
$8,
16861 h
: processRelativeTime
$8,
16862 hh
: processRelativeTime
$8,
16863 d
: processRelativeTime
$8,
16864 dd
: processRelativeTime
$8,
16865 M
: processRelativeTime
$8,
16866 MM
: processRelativeTime
$8,
16867 y
: processRelativeTime
$8,
16868 yy
: processRelativeTime
$8,
16870 dayOfMonthOrdinalParse
: /\d{1,2}\./,
16873 dow
: 1, // Monday is the first day of the week.
16874 doy
: 4, // The week that contains Jan 4th is the first week of the year.
16878 function processRelativeTime
$8(number
, withoutSuffix
, key
, isFuture
) {
16880 s
: ['viensas secunds', "'iensas secunds"],
16881 ss
: [number
+ ' secunds', '' + number
+ ' secunds'],
16882 m
: ["'n míut", "'iens míut"],
16883 mm
: [number
+ ' míuts', '' + number
+ ' míuts'],
16884 h
: ["'n þora", "'iensa þora"],
16885 hh
: [number
+ ' þoras', '' + number
+ ' þoras'],
16886 d
: ["'n ziua", "'iensa ziua"],
16887 dd
: [number
+ ' ziuas', '' + number
+ ' ziuas'],
16888 M
: ["'n mes", "'iens mes"],
16889 MM
: [number
+ ' mesen', '' + number
+ ' mesen'],
16890 y
: ["'n ar", "'iens ar"],
16891 yy
: [number
+ ' ars', '' + number
+ ' ars'],
16900 //! moment.js locale configuration
16902 hooks
.defineLocale('tzm-latn', {
16903 months
: 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split(
16906 monthsShort
: 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split(
16909 weekdays
: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
16910 weekdaysShort
: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
16911 weekdaysMin
: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
16917 LLL
: 'D MMMM YYYY HH:mm',
16918 LLLL
: 'dddd D MMMM YYYY HH:mm',
16921 sameDay
: '[asdkh g] LT',
16922 nextDay
: '[aska g] LT',
16923 nextWeek
: 'dddd [g] LT',
16924 lastDay
: '[assant g] LT',
16925 lastWeek
: 'dddd [g] LT',
16929 future
: 'dadkh s yan %s',
16945 dow
: 6, // Saturday is the first day of the week.
16946 doy
: 12, // The week that contains Jan 12th is the first week of the year.
16950 //! moment.js locale configuration
16952 hooks
.defineLocale('tzm', {
16953 months
: 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split(
16956 monthsShort
: 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split(
16959 weekdays
: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
16960 weekdaysShort
: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
16961 weekdaysMin
: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
16967 LLL
: 'D MMMM YYYY HH:mm',
16968 LLLL
: 'dddd D MMMM YYYY HH:mm',
16971 sameDay
: '[ⴰⵙⴷⵅ ⴴ] LT',
16972 nextDay
: '[ⴰⵙⴽⴰ ⴴ] LT',
16973 nextWeek
: 'dddd [ⴴ] LT',
16974 lastDay
: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
16975 lastWeek
: 'dddd [ⴴ] LT',
16979 future
: 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
16995 dow
: 6, // Saturday is the first day of the week.
16996 doy
: 12, // The week that contains Jan 12th is the first week of the year.
17000 //! moment.js locale configuration
17002 hooks
.defineLocale('ug-cn', {
17003 months
: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
17006 monthsShort
: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
17009 weekdays
: 'يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە'.split(
17012 weekdaysShort
: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
17013 weekdaysMin
: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
17018 LL
: 'YYYY-يىلىM-ئاينىڭD-كۈنى',
17019 LLL
: 'YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm',
17020 LLLL
: 'dddd، YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm',
17022 meridiemParse
: /يېرىم كېچە|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن كېيىن|كەچ/,
17023 meridiemHour: function (hour
, meridiem
) {
17028 meridiem
=== 'يېرىم كېچە' ||
17029 meridiem
=== 'سەھەر' ||
17030 meridiem
=== 'چۈشتىن بۇرۇن'
17033 } else if (meridiem
=== 'چۈشتىن كېيىن' || meridiem
=== 'كەچ') {
17036 return hour
>= 11 ? hour
: hour
+ 12;
17039 meridiem: function (hour
, minute
, isLower
) {
17040 var hm
= hour
* 100 + minute
;
17042 return 'يېرىم كېچە';
17043 } else if (hm
< 900) {
17045 } else if (hm
< 1130) {
17046 return 'چۈشتىن بۇرۇن';
17047 } else if (hm
< 1230) {
17049 } else if (hm
< 1800) {
17050 return 'چۈشتىن كېيىن';
17056 sameDay
: '[بۈگۈن سائەت] LT',
17057 nextDay
: '[ئەتە سائەت] LT',
17058 nextWeek
: '[كېلەركى] dddd [سائەت] LT',
17059 lastDay
: '[تۆنۈگۈن] LT',
17060 lastWeek
: '[ئالدىنقى] dddd [سائەت] LT',
17064 future
: '%s كېيىن',
17080 dayOfMonthOrdinalParse
: /\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,
17081 ordinal: function (number
, period
) {
17086 return number
+ '-كۈنى';
17089 return number
+ '-ھەپتە';
17094 preparse: function (string
) {
17095 return string
.replace(/،/g, ',');
17097 postformat: function (string
) {
17098 return string
.replace(/,/g
, '،');
17101 // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
17102 dow
: 1, // Monday is the first day of the week.
17103 doy
: 7, // The week that contains Jan 1st is the first week of the year.
17107 //! moment.js locale configuration
17109 function plural
$6(word
, num
) {
17110 var forms
= word
.split('_');
17111 return num
% 10 === 1 && num
% 100 !== 11
17113 : num
% 10 >= 2 && num
% 10 <= 4 && (num
% 100 < 10 || num
% 100 >= 20)
17117 function relativeTimeWithPlural
$4(number
, withoutSuffix
, key
) {
17119 ss
: withoutSuffix
? 'секунда_секунди_секунд' : 'секунду_секунди_секунд',
17120 mm
: withoutSuffix
? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
17121 hh
: withoutSuffix
? 'година_години_годин' : 'годину_години_годин',
17122 dd
: 'день_дні_днів',
17123 MM
: 'місяць_місяці_місяців',
17124 yy
: 'рік_роки_років',
17127 return withoutSuffix
? 'хвилина' : 'хвилину';
17128 } else if (key
=== 'h') {
17129 return withoutSuffix
? 'година' : 'годину';
17131 return number
+ ' ' + plural
$6(format
[key
], +number
);
17134 function weekdaysCaseReplace(m
, format
) {
17136 nominative
: 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split(
17139 accusative
: 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split(
17142 genitive
: 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split(
17149 return weekdays
['nominative']
17151 .concat(weekdays
['nominative'].slice(0, 1));
17154 return weekdays
['nominative'];
17157 nounCase
= /(\[[ВвУу]\]) ?dddd/.test(format
)
17159 : /\[?(?:минулої|наступної)? ?\] ?dddd/.test(format
)
17162 return weekdays
[nounCase
][m
.day()];
17164 function processHoursFunction(str
) {
17165 return function () {
17166 return str
+ 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
17170 hooks
.defineLocale('uk', {
17172 format
: 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split(
17175 standalone
: 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split(
17179 monthsShort
: 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split(
17182 weekdays
: weekdaysCaseReplace
,
17183 weekdaysShort
: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
17184 weekdaysMin
: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
17189 LL
: 'D MMMM YYYY р.',
17190 LLL
: 'D MMMM YYYY р., HH:mm',
17191 LLLL
: 'dddd, D MMMM YYYY р., HH:mm',
17194 sameDay
: processHoursFunction('[Сьогодні '),
17195 nextDay
: processHoursFunction('[Завтра '),
17196 lastDay
: processHoursFunction('[Вчора '),
17197 nextWeek
: processHoursFunction('[У] dddd ['),
17198 lastWeek: function () {
17199 switch (this.day()) {
17204 return processHoursFunction('[Минулої] dddd [').call(this);
17208 return processHoursFunction('[Минулого] dddd [').call(this);
17216 s
: 'декілька секунд',
17217 ss
: relativeTimeWithPlural
$4,
17218 m
: relativeTimeWithPlural
$4,
17219 mm
: relativeTimeWithPlural
$4,
17221 hh
: relativeTimeWithPlural
$4,
17223 dd
: relativeTimeWithPlural
$4,
17225 MM
: relativeTimeWithPlural
$4,
17227 yy
: relativeTimeWithPlural
$4,
17229 // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
17230 meridiemParse
: /ночі|ранку|дня|вечора/,
17231 isPM: function (input
) {
17232 return /^(дня|вечора)$/.test(input
);
17234 meridiem: function (hour
, minute
, isLower
) {
17237 } else if (hour
< 12) {
17239 } else if (hour
< 17) {
17245 dayOfMonthOrdinalParse
: /\d{1,2}-(й|го)/,
17246 ordinal: function (number
, period
) {
17253 return number
+ '-й';
17255 return number
+ '-го';
17261 dow
: 1, // Monday is the first day of the week.
17262 doy
: 7, // The week that contains Jan 7th is the first week of the year.
17266 //! moment.js locale configuration
17282 days
$2 = ['اتوار', 'پیر', 'منگل', 'بدھ', 'جمعرات', 'جمعہ', 'ہفتہ'];
17284 hooks
.defineLocale('ur', {
17286 monthsShort
: months
$b
,
17288 weekdaysShort
: days
$2,
17289 weekdaysMin
: days
$2,
17295 LLL
: 'D MMMM YYYY HH:mm',
17296 LLLL
: 'dddd، D MMMM YYYY HH:mm',
17298 meridiemParse
: /صبح|شام/,
17299 isPM: function (input
) {
17300 return 'شام' === input
;
17302 meridiem: function (hour
, minute
, isLower
) {
17309 sameDay
: '[آج بوقت] LT',
17310 nextDay
: '[کل بوقت] LT',
17311 nextWeek
: 'dddd [بوقت] LT',
17312 lastDay
: '[گذشتہ روز بوقت] LT',
17313 lastWeek
: '[گذشتہ] dddd [بوقت] LT',
17332 preparse: function (string
) {
17333 return string
.replace(/،/g, ',');
17335 postformat: function (string
) {
17336 return string
.replace(/,/g
, '،');
17339 dow
: 1, // Monday is the first day of the week.
17340 doy
: 4, // The week that contains Jan 4th is the first week of the year.
17344 //! moment.js locale configuration
17346 hooks
.defineLocale('uz-latn', {
17347 months
: 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split(
17350 monthsShort
: 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'),
17351 weekdays
: 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split(
17354 weekdaysShort
: 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'),
17355 weekdaysMin
: 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'),
17361 LLL
: 'D MMMM YYYY HH:mm',
17362 LLLL
: 'D MMMM YYYY, dddd HH:mm',
17365 sameDay
: '[Bugun soat] LT [da]',
17366 nextDay
: '[Ertaga] LT [da]',
17367 nextWeek
: 'dddd [kuni soat] LT [da]',
17368 lastDay
: '[Kecha soat] LT [da]',
17369 lastWeek
: "[O'tgan] dddd [kuni soat] LT [da]",
17373 future
: 'Yaqin %s ichida',
17374 past
: 'Bir necha %s oldin',
17389 dow
: 1, // Monday is the first day of the week.
17390 doy
: 7, // The week that contains Jan 7th is the first week of the year.
17394 //! moment.js locale configuration
17396 hooks
.defineLocale('uz', {
17397 months
: 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split(
17400 monthsShort
: 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
17401 weekdays
: 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
17402 weekdaysShort
: 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
17403 weekdaysMin
: 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
17409 LLL
: 'D MMMM YYYY HH:mm',
17410 LLLL
: 'D MMMM YYYY, dddd HH:mm',
17413 sameDay
: '[Бугун соат] LT [да]',
17414 nextDay
: '[Эртага] LT [да]',
17415 nextWeek
: 'dddd [куни соат] LT [да]',
17416 lastDay
: '[Кеча соат] LT [да]',
17417 lastWeek
: '[Утган] dddd [куни соат] LT [да]',
17421 future
: 'Якин %s ичида',
17422 past
: 'Бир неча %s олдин',
17437 dow
: 1, // Monday is the first day of the week.
17438 doy
: 7, // The week that contains Jan 4th is the first week of the year.
17442 //! moment.js locale configuration
17444 hooks
.defineLocale('vi', {
17445 months
: 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split(
17448 monthsShort
: 'Thg 01_Thg 02_Thg 03_Thg 04_Thg 05_Thg 06_Thg 07_Thg 08_Thg 09_Thg 10_Thg 11_Thg 12'.split(
17451 monthsParseExact
: true,
17452 weekdays
: 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split(
17455 weekdaysShort
: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
17456 weekdaysMin
: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
17457 weekdaysParseExact
: true,
17458 meridiemParse
: /sa|ch/i,
17459 isPM: function (input
) {
17460 return /^ch$/i.test(input
);
17462 meridiem: function (hours
, minutes
, isLower
) {
17464 return isLower
? 'sa' : 'SA';
17466 return isLower
? 'ch' : 'CH';
17473 LL
: 'D MMMM [năm] YYYY',
17474 LLL
: 'D MMMM [năm] YYYY HH:mm',
17475 LLLL
: 'dddd, D MMMM [năm] YYYY HH:mm',
17478 lll
: 'D MMM YYYY HH:mm',
17479 llll
: 'ddd, D MMM YYYY HH:mm',
17482 sameDay
: '[Hôm nay lúc] LT',
17483 nextDay
: '[Ngày mai lúc] LT',
17484 nextWeek
: 'dddd [tuần tới lúc] LT',
17485 lastDay
: '[Hôm qua lúc] LT',
17486 lastWeek
: 'dddd [tuần trước lúc] LT',
17507 dayOfMonthOrdinalParse
: /\d{1,2}/,
17508 ordinal: function (number
) {
17512 dow
: 1, // Monday is the first day of the week.
17513 doy
: 4, // The week that contains Jan 4th is the first week of the year.
17517 //! moment.js locale configuration
17519 hooks
.defineLocale('x-pseudo', {
17520 months
: 'J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér'.split(
17523 monthsShort
: 'J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc'.split(
17526 monthsParseExact
: true,
17527 weekdays
: 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý'.split(
17530 weekdaysShort
: 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát'.split('_'),
17531 weekdaysMin
: 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
17532 weekdaysParseExact
: true,
17537 LLL
: 'D MMMM YYYY HH:mm',
17538 LLLL
: 'dddd, D MMMM YYYY HH:mm',
17541 sameDay
: '[T~ódá~ý át] LT',
17542 nextDay
: '[T~ómó~rró~w át] LT',
17543 nextWeek
: 'dddd [át] LT',
17544 lastDay
: '[Ý~ést~érdá~ý át] LT',
17545 lastWeek
: '[L~ást] dddd [át] LT',
17551 s
: 'á ~féw ~sécó~ñds',
17552 ss
: '%d s~écóñ~ds',
17554 mm
: '%d m~íñú~tés',
17564 dayOfMonthOrdinalParse
: /\d{1,2}(th|st|nd|rd)/,
17565 ordinal: function (number
) {
17566 var b
= number
% 10,
17568 ~~((number
% 100) / 10) === 1
17577 return number
+ output
;
17580 dow
: 1, // Monday is the first day of the week.
17581 doy
: 4, // The week that contains Jan 4th is the first week of the year.
17585 //! moment.js locale configuration
17587 hooks
.defineLocale('yo', {
17588 months
: 'Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀'.split(
17591 monthsShort
: 'Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀'.split('_'),
17592 weekdays
: 'Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta'.split('_'),
17593 weekdaysShort
: 'Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá'.split('_'),
17594 weekdaysMin
: 'Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb'.split('_'),
17600 LLL
: 'D MMMM YYYY h:mm A',
17601 LLLL
: 'dddd, D MMMM YYYY h:mm A',
17604 sameDay
: '[Ònì ni] LT',
17605 nextDay
: '[Ọ̀la ni] LT',
17606 nextWeek
: "dddd [Ọsẹ̀ tón'bọ] [ni] LT",
17607 lastDay
: '[Àna ni] LT',
17608 lastWeek
: 'dddd [Ọsẹ̀ tólọ́] [ni] LT',
17614 s
: 'ìsẹjú aayá die',
17627 dayOfMonthOrdinalParse
: /ọjọ́\s\d{1,2}/,
17628 ordinal
: 'ọjọ́ %d',
17630 dow
: 1, // Monday is the first day of the week.
17631 doy
: 4, // The week that contains Jan 4th is the first week of the year.
17635 //! moment.js locale configuration
17637 hooks
.defineLocale('zh-cn', {
17638 months
: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
17641 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
17644 weekdays
: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
17645 weekdaysShort
: '周日_周一_周二_周三_周四_周五_周六'.split('_'),
17646 weekdaysMin
: '日_一_二_三_四_五_六'.split('_'),
17652 LLL
: 'YYYY年M月D日Ah点mm分',
17653 LLLL
: 'YYYY年M月D日ddddAh点mm分',
17656 lll
: 'YYYY年M月D日 HH:mm',
17657 llll
: 'YYYY年M月D日dddd HH:mm',
17659 meridiemParse
: /凌晨|早上|上午|中午|下午|晚上/,
17660 meridiemHour: function (hour
, meridiem
) {
17664 if (meridiem
=== '凌晨' || meridiem
=== '早上' || meridiem
=== '上午') {
17666 } else if (meridiem
=== '下午' || meridiem
=== '晚上') {
17670 return hour
>= 11 ? hour
: hour
+ 12;
17673 meridiem: function (hour
, minute
, isLower
) {
17674 var hm
= hour
* 100 + minute
;
17677 } else if (hm
< 900) {
17679 } else if (hm
< 1130) {
17681 } else if (hm
< 1230) {
17683 } else if (hm
< 1800) {
17692 nextWeek: function (now
) {
17693 if (now
.week() !== this.week()) {
17700 lastWeek: function (now
) {
17701 if (this.week() !== now
.week()) {
17709 dayOfMonthOrdinalParse
: /\d{1,2}(日|月|周)/,
17710 ordinal: function (number
, period
) {
17715 return number
+ '日';
17717 return number
+ '月';
17720 return number
+ '周';
17744 // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
17745 dow
: 1, // Monday is the first day of the week.
17746 doy
: 4, // The week that contains Jan 4th is the first week of the year.
17750 //! moment.js locale configuration
17752 hooks
.defineLocale('zh-hk', {
17753 months
: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
17756 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
17759 weekdays
: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
17760 weekdaysShort
: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
17761 weekdaysMin
: '日_一_二_三_四_五_六'.split('_'),
17767 LLL
: 'YYYY年M月D日 HH:mm',
17768 LLLL
: 'YYYY年M月D日dddd HH:mm',
17771 lll
: 'YYYY年M月D日 HH:mm',
17772 llll
: 'YYYY年M月D日dddd HH:mm',
17774 meridiemParse
: /凌晨|早上|上午|中午|下午|晚上/,
17775 meridiemHour: function (hour
, meridiem
) {
17779 if (meridiem
=== '凌晨' || meridiem
=== '早上' || meridiem
=== '上午') {
17781 } else if (meridiem
=== '中午') {
17782 return hour
>= 11 ? hour
: hour
+ 12;
17783 } else if (meridiem
=== '下午' || meridiem
=== '晚上') {
17787 meridiem: function (hour
, minute
, isLower
) {
17788 var hm
= hour
* 100 + minute
;
17791 } else if (hm
< 900) {
17793 } else if (hm
< 1200) {
17795 } else if (hm
=== 1200) {
17797 } else if (hm
< 1800) {
17806 nextWeek
: '[下]ddddLT',
17808 lastWeek
: '[上]ddddLT',
17811 dayOfMonthOrdinalParse
: /\d{1,2}(日|月|週)/,
17812 ordinal: function (number
, period
) {
17817 return number
+ '日';
17819 return number
+ '月';
17822 return number
+ '週';
17845 //! moment.js locale configuration
17847 hooks
.defineLocale('zh-mo', {
17848 months
: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
17851 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
17854 weekdays
: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
17855 weekdaysShort
: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
17856 weekdaysMin
: '日_一_二_三_四_五_六'.split('_'),
17862 LLL
: 'YYYY年M月D日 HH:mm',
17863 LLLL
: 'YYYY年M月D日dddd HH:mm',
17866 lll
: 'YYYY年M月D日 HH:mm',
17867 llll
: 'YYYY年M月D日dddd HH:mm',
17869 meridiemParse
: /凌晨|早上|上午|中午|下午|晚上/,
17870 meridiemHour: function (hour
, meridiem
) {
17874 if (meridiem
=== '凌晨' || meridiem
=== '早上' || meridiem
=== '上午') {
17876 } else if (meridiem
=== '中午') {
17877 return hour
>= 11 ? hour
: hour
+ 12;
17878 } else if (meridiem
=== '下午' || meridiem
=== '晚上') {
17882 meridiem: function (hour
, minute
, isLower
) {
17883 var hm
= hour
* 100 + minute
;
17886 } else if (hm
< 900) {
17888 } else if (hm
< 1130) {
17890 } else if (hm
< 1230) {
17892 } else if (hm
< 1800) {
17899 sameDay
: '[今天] LT',
17900 nextDay
: '[明天] LT',
17901 nextWeek
: '[下]dddd LT',
17902 lastDay
: '[昨天] LT',
17903 lastWeek
: '[上]dddd LT',
17906 dayOfMonthOrdinalParse
: /\d{1,2}(日|月|週)/,
17907 ordinal: function (number
, period
) {
17912 return number
+ '日';
17914 return number
+ '月';
17917 return number
+ '週';
17940 //! moment.js locale configuration
17942 hooks
.defineLocale('zh-tw', {
17943 months
: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
17946 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split(
17949 weekdays
: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
17950 weekdaysShort
: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
17951 weekdaysMin
: '日_一_二_三_四_五_六'.split('_'),
17957 LLL
: 'YYYY年M月D日 HH:mm',
17958 LLLL
: 'YYYY年M月D日dddd HH:mm',
17961 lll
: 'YYYY年M月D日 HH:mm',
17962 llll
: 'YYYY年M月D日dddd HH:mm',
17964 meridiemParse
: /凌晨|早上|上午|中午|下午|晚上/,
17965 meridiemHour: function (hour
, meridiem
) {
17969 if (meridiem
=== '凌晨' || meridiem
=== '早上' || meridiem
=== '上午') {
17971 } else if (meridiem
=== '中午') {
17972 return hour
>= 11 ? hour
: hour
+ 12;
17973 } else if (meridiem
=== '下午' || meridiem
=== '晚上') {
17977 meridiem: function (hour
, minute
, isLower
) {
17978 var hm
= hour
* 100 + minute
;
17981 } else if (hm
< 900) {
17983 } else if (hm
< 1130) {
17985 } else if (hm
< 1230) {
17987 } else if (hm
< 1800) {
17994 sameDay
: '[今天] LT',
17995 nextDay
: '[明天] LT',
17996 nextWeek
: '[下]dddd LT',
17997 lastDay
: '[昨天] LT',
17998 lastWeek
: '[上]dddd LT',
18001 dayOfMonthOrdinalParse
: /\d{1,2}(日|月|週)/,
18002 ordinal: function (number
, period
) {
18007 return number
+ '日';
18009 return number
+ '月';
18012 return number
+ '週';
18035 hooks
.locale('en');