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
) {
20 return input
instanceof Array
|| Object
.prototype.toString
.call(input
) === '[object Array]';
23 function isObject(input
) {
24 // IE8 will treat undefined and null as object if it wasn't for
26 return input
!= null && Object
.prototype.toString
.call(input
) === '[object Object]';
29 function isObjectEmpty(obj
) {
30 if (Object
.getOwnPropertyNames
) {
31 return (Object
.getOwnPropertyNames(obj
).length
=== 0);
35 if (obj
.hasOwnProperty(k
)) {
43 function isUndefined(input
) {
44 return input
=== void 0;
47 function isNumber(input
) {
48 return typeof input
=== 'number' || Object
.prototype.toString
.call(input
) === '[object Number]';
51 function isDate(input
) {
52 return input
instanceof Date
|| Object
.prototype.toString
.call(input
) === '[object Date]';
55 function map(arr
, fn
) {
57 for (i
= 0; i
< arr
.length
; ++i
) {
58 res
.push(fn(arr
[i
], i
));
63 function hasOwnProp(a
, b
) {
64 return Object
.prototype.hasOwnProperty
.call(a
, b
);
67 function extend(a
, b
) {
69 if (hasOwnProp(b
, i
)) {
74 if (hasOwnProp(b
, 'toString')) {
75 a
.toString
= b
.toString
;
78 if (hasOwnProp(b
, 'valueOf')) {
79 a
.valueOf
= b
.valueOf
;
85 function createUTC (input
, format
, locale
, strict
) {
86 return createLocalOrUTC(input
, format
, locale
, strict
, true).utc();
89 function defaultParsingFlags() {
90 // We need to deep clone this object.
99 invalidFormat
: false,
100 userInvalidated
: false,
102 parsedDateParts
: [],
105 weekdayMismatch
: false
109 function getParsingFlags(m
) {
111 m
._pf
= defaultParsingFlags();
117 if (Array
.prototype.some
) {
118 some
= Array
.prototype.some
;
120 some = function (fun
) {
121 var t
= Object(this);
122 var len
= t
.length
>>> 0;
124 for (var i
= 0; i
< len
; i
++) {
125 if (i
in t
&& fun
.call(this, t
[i
], i
, t
)) {
134 function isValid(m
) {
135 if (m
._isValid
== null) {
136 var flags
= getParsingFlags(m
);
137 var parsedParts
= some
.call(flags
.parsedDateParts
, function (i
) {
140 var isNowValid
= !isNaN(m
._d
.getTime()) &&
141 flags
.overflow
< 0 &&
143 !flags
.invalidMonth
&&
144 !flags
.invalidWeekday
&&
145 !flags
.weekdayMismatch
&&
147 !flags
.invalidFormat
&&
148 !flags
.userInvalidated
&&
149 (!flags
.meridiem
|| (flags
.meridiem
&& parsedParts
));
152 isNowValid
= isNowValid
&&
153 flags
.charsLeftOver
=== 0 &&
154 flags
.unusedTokens
.length
=== 0 &&
155 flags
.bigHour
=== undefined;
158 if (Object
.isFrozen
== null || !Object
.isFrozen(m
)) {
159 m
._isValid
= isNowValid
;
168 function createInvalid (flags
) {
169 var m
= createUTC(NaN
);
171 extend(getParsingFlags(m
), flags
);
174 getParsingFlags(m
).userInvalidated
= true;
180 // Plugins that add properties should also add the key here (null value),
181 // so we can properly clone ourselves.
182 var momentProperties
= hooks
.momentProperties
= [];
184 function copyConfig(to
, from) {
187 if (!isUndefined(from._isAMomentObject
)) {
188 to
._isAMomentObject
= from._isAMomentObject
;
190 if (!isUndefined(from._i
)) {
193 if (!isUndefined(from._f
)) {
196 if (!isUndefined(from._l
)) {
199 if (!isUndefined(from._strict
)) {
200 to
._strict
= from._strict
;
202 if (!isUndefined(from._tzm
)) {
205 if (!isUndefined(from._isUTC
)) {
206 to
._isUTC
= from._isUTC
;
208 if (!isUndefined(from._offset
)) {
209 to
._offset
= from._offset
;
211 if (!isUndefined(from._pf
)) {
212 to
._pf
= getParsingFlags(from);
214 if (!isUndefined(from._locale
)) {
215 to
._locale
= from._locale
;
218 if (momentProperties
.length
> 0) {
219 for (i
= 0; i
< momentProperties
.length
; i
++) {
220 prop
= momentProperties
[i
];
222 if (!isUndefined(val
)) {
231 var updateInProgress
= false;
233 // Moment prototype object
234 function Moment(config
) {
235 copyConfig(this, config
);
236 this._d
= new Date(config
._d
!= null ? config
._d
.getTime() : NaN
);
237 if (!this.isValid()) {
238 this._d
= new Date(NaN
);
240 // Prevent infinite loop in case updateOffset creates new moment
242 if (updateInProgress
=== false) {
243 updateInProgress
= true;
244 hooks
.updateOffset(this);
245 updateInProgress
= false;
249 function isMoment (obj
) {
250 return obj
instanceof Moment
|| (obj
!= null && obj
._isAMomentObject
!= null);
253 function absFloor (number
) {
256 return Math
.ceil(number
) || 0;
258 return Math
.floor(number
);
262 function toInt(argumentForCoercion
) {
263 var coercedNumber
= +argumentForCoercion
,
266 if (coercedNumber
!== 0 && isFinite(coercedNumber
)) {
267 value
= absFloor(coercedNumber
);
273 // compare two arrays, return the number of differences
274 function compareArrays(array1
, array2
, dontConvert
) {
275 var len
= Math
.min(array1
.length
, array2
.length
),
276 lengthDiff
= Math
.abs(array1
.length
- array2
.length
),
279 for (i
= 0; i
< len
; i
++) {
280 if ((dontConvert
&& array1
[i
] !== array2
[i
]) ||
281 (!dontConvert
&& toInt(array1
[i
]) !== toInt(array2
[i
]))) {
285 return diffs
+ lengthDiff
;
289 if (hooks
.suppressDeprecationWarnings
=== false &&
290 (typeof console
!== 'undefined') && console
.warn
) {
291 console
.warn('Deprecation warning: ' + msg
);
295 function deprecate(msg
, fn
) {
296 var firstTime
= true;
298 return extend(function () {
299 if (hooks
.deprecationHandler
!= null) {
300 hooks
.deprecationHandler(null, msg
);
305 for (var i
= 0; i
< arguments
.length
; i
++) {
307 if (typeof arguments
[i
] === 'object') {
308 arg
+= '\n[' + i
+ '] ';
309 for (var key
in arguments
[0]) {
310 arg
+= key
+ ': ' + arguments
[0][key
] + ', ';
312 arg
= arg
.slice(0, -2); // Remove trailing comma and space
318 warn(msg
+ '\nArguments: ' + Array
.prototype.slice
.call(args
).join('') + '\n' + (new Error()).stack
);
321 return fn
.apply(this, arguments
);
325 var deprecations
= {};
327 function deprecateSimple(name
, msg
) {
328 if (hooks
.deprecationHandler
!= null) {
329 hooks
.deprecationHandler(name
, msg
);
331 if (!deprecations
[name
]) {
333 deprecations
[name
] = true;
337 hooks
.suppressDeprecationWarnings
= false;
338 hooks
.deprecationHandler
= null;
340 function isFunction(input
) {
341 return input
instanceof Function
|| Object
.prototype.toString
.call(input
) === '[object Function]';
344 function set (config
) {
348 if (isFunction(prop
)) {
351 this['_' + i
] = prop
;
354 this._config
= config
;
355 // Lenient ordinal parsing accepts just a number in addition to
356 // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
357 // TODO: Remove "ordinalParse" fallback in next major release.
358 this._dayOfMonthOrdinalParseLenient
= new RegExp(
359 (this._dayOfMonthOrdinalParse
.source
|| this._ordinalParse
.source
) +
360 '|' + (/\d{1,2}/).source
);
363 function mergeConfigs(parentConfig
, childConfig
) {
364 var res
= extend({}, parentConfig
), prop
;
365 for (prop
in childConfig
) {
366 if (hasOwnProp(childConfig
, prop
)) {
367 if (isObject(parentConfig
[prop
]) && isObject(childConfig
[prop
])) {
369 extend(res
[prop
], parentConfig
[prop
]);
370 extend(res
[prop
], childConfig
[prop
]);
371 } else if (childConfig
[prop
] != null) {
372 res
[prop
] = childConfig
[prop
];
378 for (prop
in parentConfig
) {
379 if (hasOwnProp(parentConfig
, prop
) &&
380 !hasOwnProp(childConfig
, prop
) &&
381 isObject(parentConfig
[prop
])) {
382 // make sure changes to properties don't modify parent config
383 res
[prop
] = extend({}, res
[prop
]);
389 function Locale(config
) {
390 if (config
!= null) {
400 keys = function (obj
) {
403 if (hasOwnProp(obj
, i
)) {
411 var defaultCalendar
= {
412 sameDay
: '[Today at] LT',
413 nextDay
: '[Tomorrow at] LT',
414 nextWeek
: 'dddd [at] LT',
415 lastDay
: '[Yesterday at] LT',
416 lastWeek
: '[Last] dddd [at] LT',
420 function calendar (key
, mom
, now
) {
421 var output
= this._calendar
[key
] || this._calendar
['sameElse'];
422 return isFunction(output
) ? output
.call(mom
, now
) : output
;
425 var defaultLongDateFormat
= {
430 LLL
: 'MMMM D, YYYY h:mm A',
431 LLLL
: 'dddd, MMMM D, YYYY h:mm A'
434 function longDateFormat (key
) {
435 var format
= this._longDateFormat
[key
],
436 formatUpper
= this._longDateFormat
[key
.toUpperCase()];
438 if (format
|| !formatUpper
) {
442 this._longDateFormat
[key
] = formatUpper
.replace(/MMMM|MM|DD|dddd/g, function (val
) {
446 return this._longDateFormat
[key
];
449 var defaultInvalidDate
= 'Invalid date';
451 function invalidDate () {
452 return this._invalidDate
;
455 var defaultOrdinal
= '%d';
456 var defaultDayOfMonthOrdinalParse
= /\d{1,2}/;
458 function ordinal (number
) {
459 return this._ordinal
.replace('%d', number
);
462 var defaultRelativeTime
= {
479 function relativeTime (number
, withoutSuffix
, string
, isFuture
) {
480 var output
= this._relativeTime
[string
];
481 return (isFunction(output
)) ?
482 output(number
, withoutSuffix
, string
, isFuture
) :
483 output
.replace(/%d/i, number
);
486 function pastFuture (diff
, output
) {
487 var format
= this._relativeTime
[diff
> 0 ? 'future' : 'past'];
488 return isFunction(format
) ? format(output
) : format
.replace(/%s/i, output
);
493 function addUnitAlias (unit
, shorthand
) {
494 var lowerCase
= unit
.toLowerCase();
495 aliases
[lowerCase
] = aliases
[lowerCase
+ 's'] = aliases
[shorthand
] = unit
;
498 function normalizeUnits(units
) {
499 return typeof units
=== 'string' ? aliases
[units
] || aliases
[units
.toLowerCase()] : undefined;
502 function normalizeObjectUnits(inputObject
) {
503 var normalizedInput
= {},
507 for (prop
in inputObject
) {
508 if (hasOwnProp(inputObject
, prop
)) {
509 normalizedProp
= normalizeUnits(prop
);
510 if (normalizedProp
) {
511 normalizedInput
[normalizedProp
] = inputObject
[prop
];
516 return normalizedInput
;
521 function addUnitPriority(unit
, priority
) {
522 priorities
[unit
] = priority
;
525 function getPrioritizedUnits(unitsObj
) {
527 for (var u
in unitsObj
) {
528 units
.push({unit
: u
, priority
: priorities
[u
]});
530 units
.sort(function (a
, b
) {
531 return a
.priority
- b
.priority
;
536 function zeroFill(number
, targetLength
, forceSign
) {
537 var absNumber
= '' + Math
.abs(number
),
538 zerosToFill
= targetLength
- absNumber
.length
,
540 return (sign
? (forceSign
? '+' : '') : '-') +
541 Math
.pow(10, Math
.max(0, zerosToFill
)).toString().substr(1) + absNumber
;
544 var formattingTokens
= /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
546 var localFormattingTokens
= /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
548 var formatFunctions
= {};
550 var formatTokenFunctions
= {};
555 // callback: function () { this.month() + 1 }
556 function addFormatToken (token
, padded
, ordinal
, callback
) {
558 if (typeof callback
=== 'string') {
560 return this[callback
]();
564 formatTokenFunctions
[token
] = func
;
567 formatTokenFunctions
[padded
[0]] = function () {
568 return zeroFill(func
.apply(this, arguments
), padded
[1], padded
[2]);
572 formatTokenFunctions
[ordinal
] = function () {
573 return this.localeData().ordinal(func
.apply(this, arguments
), token
);
578 function removeFormattingTokens(input
) {
579 if (input
.match(/\[[\s\S]/)) {
580 return input
.replace(/^\[|\]$/g, '');
582 return input
.replace(/\\/g
, '');
585 function makeFormatFunction(format
) {
586 var array
= format
.match(formattingTokens
), i
, length
;
588 for (i
= 0, length
= array
.length
; i
< length
; i
++) {
589 if (formatTokenFunctions
[array
[i
]]) {
590 array
[i
] = formatTokenFunctions
[array
[i
]];
592 array
[i
] = removeFormattingTokens(array
[i
]);
596 return function (mom
) {
598 for (i
= 0; i
< length
; i
++) {
599 output
+= isFunction(array
[i
]) ? array
[i
].call(mom
, format
) : array
[i
];
605 // format date using native date object
606 function formatMoment(m
, format
) {
608 return m
.localeData().invalidDate();
611 format
= expandFormat(format
, m
.localeData());
612 formatFunctions
[format
] = formatFunctions
[format
] || makeFormatFunction(format
);
614 return formatFunctions
[format
](m
);
617 function expandFormat(format
, locale
) {
620 function replaceLongDateFormatTokens(input
) {
621 return locale
.longDateFormat(input
) || input
;
624 localFormattingTokens
.lastIndex
= 0;
625 while (i
>= 0 && localFormattingTokens
.test(format
)) {
626 format
= format
.replace(localFormattingTokens
, replaceLongDateFormatTokens
);
627 localFormattingTokens
.lastIndex
= 0;
634 var match1
= /\d/; // 0 - 9
635 var match2
= /\d\d/; // 00 - 99
636 var match3
= /\d{3}/; // 000 - 999
637 var match4
= /\d{4}/; // 0000 - 9999
638 var match6
= /[+-]?\d{6}/; // -999999 - 999999
639 var match1to2
= /\d\d?/; // 0 - 99
640 var match3to4
= /\d\d\d\d?/; // 999 - 9999
641 var match5to6
= /\d\d\d\d\d\d?/; // 99999 - 999999
642 var match1to3
= /\d{1,3}/; // 0 - 999
643 var match1to4
= /\d{1,4}/; // 0 - 9999
644 var match1to6
= /[+-]?\d{1,6}/; // -999999 - 999999
646 var matchUnsigned
= /\d+/; // 0 - inf
647 var matchSigned
= /[+-]?\d+/; // -inf - inf
649 var matchOffset
= /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
650 var matchShortOffset
= /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
652 var matchTimestamp
= /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
654 // any word (or two) characters or numbers including two/three word month in arabic.
655 // includes scottish gaelic two word and hyphenated months
656 var 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;
660 function addRegexToken (token
, regex
, strictRegex
) {
661 regexes
[token
] = isFunction(regex
) ? regex : function (isStrict
, localeData
) {
662 return (isStrict
&& strictRegex
) ? strictRegex
: regex
;
666 function getParseRegexForToken (token
, config
) {
667 if (!hasOwnProp(regexes
, token
)) {
668 return new RegExp(unescapeFormat(token
));
671 return regexes
[token
](config
._strict
, config
._locale
);
674 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
675 function unescapeFormat(s
) {
676 return regexEscape(s
.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched
, p1
, p2
, p3
, p4
) {
677 return p1
|| p2
|| p3
|| p4
;
681 function regexEscape(s
) {
682 return s
.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
687 function addParseToken (token
, callback
) {
688 var i
, func
= callback
;
689 if (typeof token
=== 'string') {
692 if (isNumber(callback
)) {
693 func = function (input
, array
) {
694 array
[callback
] = toInt(input
);
697 for (i
= 0; i
< token
.length
; i
++) {
698 tokens
[token
[i
]] = func
;
702 function addWeekParseToken (token
, callback
) {
703 addParseToken(token
, function (input
, array
, config
, token
) {
704 config
._w
= config
._w
|| {};
705 callback(input
, config
._w
, config
, token
);
709 function addTimeToArrayFromToken(token
, input
, config
) {
710 if (input
!= null && hasOwnProp(tokens
, token
)) {
711 tokens
[token
](input
, config
._a
, config
, token
);
727 addFormatToken('Y', 0, 0, function () {
729 return y
<= 9999 ? '' + y
: '+' + y
;
732 addFormatToken(0, ['YY', 2], 0, function () {
733 return this.year() % 100;
736 addFormatToken(0, ['YYYY', 4], 0, 'year');
737 addFormatToken(0, ['YYYYY', 5], 0, 'year');
738 addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
742 addUnitAlias('year', 'y');
746 addUnitPriority('year', 1);
750 addRegexToken('Y', matchSigned
);
751 addRegexToken('YY', match1to2
, match2
);
752 addRegexToken('YYYY', match1to4
, match4
);
753 addRegexToken('YYYYY', match1to6
, match6
);
754 addRegexToken('YYYYYY', match1to6
, match6
);
756 addParseToken(['YYYYY', 'YYYYYY'], YEAR
);
757 addParseToken('YYYY', function (input
, array
) {
758 array
[YEAR
] = input
.length
=== 2 ? hooks
.parseTwoDigitYear(input
) : toInt(input
);
760 addParseToken('YY', function (input
, array
) {
761 array
[YEAR
] = hooks
.parseTwoDigitYear(input
);
763 addParseToken('Y', function (input
, array
) {
764 array
[YEAR
] = parseInt(input
, 10);
769 function daysInYear(year
) {
770 return isLeapYear(year
) ? 366 : 365;
773 function isLeapYear(year
) {
774 return (year
% 4 === 0 && year
% 100 !== 0) || year
% 400 === 0;
779 hooks
.parseTwoDigitYear = function (input
) {
780 return toInt(input
) + (toInt(input
) > 68 ? 1900 : 2000);
785 var getSetYear
= makeGetSet('FullYear', true);
787 function getIsLeapYear () {
788 return isLeapYear(this.year());
791 function makeGetSet (unit
, keepTime
) {
792 return function (value
) {
794 set$1(this, unit
, value
);
795 hooks
.updateOffset(this, keepTime
);
798 return get(this, unit
);
803 function get (mom
, unit
) {
804 return mom
.isValid() ?
805 mom
._d
['get' + (mom
._isUTC
? 'UTC' : '') + unit
]() : NaN
;
808 function set$1 (mom
, unit
, value
) {
809 if (mom
.isValid() && !isNaN(value
)) {
810 if (unit
=== 'FullYear' && isLeapYear(mom
.year()) && mom
.month() === 1 && mom
.date() === 29) {
811 mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + unit
](value
, mom
.month(), daysInMonth(value
, mom
.month()));
814 mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + unit
](value
);
821 function stringGet (units
) {
822 units
= normalizeUnits(units
);
823 if (isFunction(this[units
])) {
824 return this[units
]();
830 function stringSet (units
, value
) {
831 if (typeof units
=== 'object') {
832 units
= normalizeObjectUnits(units
);
833 var prioritized
= getPrioritizedUnits(units
);
834 for (var i
= 0; i
< prioritized
.length
; i
++) {
835 this[prioritized
[i
].unit
](units
[prioritized
[i
].unit
]);
838 units
= normalizeUnits(units
);
839 if (isFunction(this[units
])) {
840 return this[units
](value
);
847 return ((n
% x
) + x
) % x
;
852 if (Array
.prototype.indexOf
) {
853 indexOf
= Array
.prototype.indexOf
;
855 indexOf = function (o
) {
858 for (i
= 0; i
< this.length
; ++i
) {
867 function daysInMonth(year
, month
) {
868 if (isNaN(year
) || isNaN(month
)) {
871 var modMonth
= mod(month
, 12);
872 year
+= (month
- modMonth
) / 12;
873 return modMonth
=== 1 ? (isLeapYear(year
) ? 29 : 28) : (31 - modMonth
% 7 % 2);
878 addFormatToken('M', ['MM', 2], 'Mo', function () {
879 return this.month() + 1;
882 addFormatToken('MMM', 0, 0, function (format
) {
883 return this.localeData().monthsShort(this, format
);
886 addFormatToken('MMMM', 0, 0, function (format
) {
887 return this.localeData().months(this, format
);
892 addUnitAlias('month', 'M');
896 addUnitPriority('month', 8);
900 addRegexToken('M', match1to2
);
901 addRegexToken('MM', match1to2
, match2
);
902 addRegexToken('MMM', function (isStrict
, locale
) {
903 return locale
.monthsShortRegex(isStrict
);
905 addRegexToken('MMMM', function (isStrict
, locale
) {
906 return locale
.monthsRegex(isStrict
);
909 addParseToken(['M', 'MM'], function (input
, array
) {
910 array
[MONTH
] = toInt(input
) - 1;
913 addParseToken(['MMM', 'MMMM'], function (input
, array
, config
, token
) {
914 var month
= config
._locale
.monthsParse(input
, token
, config
._strict
);
915 // if we didn't find a month name, mark the date as invalid.
917 array
[MONTH
] = month
;
919 getParsingFlags(config
).invalidMonth
= input
;
925 var MONTHS_IN_FORMAT
= /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
926 var defaultLocaleMonths
= 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
927 function localeMonths (m
, format
) {
929 return isArray(this._months
) ? this._months
:
930 this._months
['standalone'];
932 return isArray(this._months
) ? this._months
[m
.month()] :
933 this._months
[(this._months
.isFormat
|| MONTHS_IN_FORMAT
).test(format
) ? 'format' : 'standalone'][m
.month()];
936 var defaultLocaleMonthsShort
= 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
937 function localeMonthsShort (m
, format
) {
939 return isArray(this._monthsShort
) ? this._monthsShort
:
940 this._monthsShort
['standalone'];
942 return isArray(this._monthsShort
) ? this._monthsShort
[m
.month()] :
943 this._monthsShort
[MONTHS_IN_FORMAT
.test(format
) ? 'format' : 'standalone'][m
.month()];
946 function handleStrictParse(monthName
, format
, strict
) {
947 var i
, ii
, mom
, llc
= monthName
.toLocaleLowerCase();
948 if (!this._monthsParse
) {
950 this._monthsParse
= [];
951 this._longMonthsParse
= [];
952 this._shortMonthsParse
= [];
953 for (i
= 0; i
< 12; ++i
) {
954 mom
= createUTC([2000, i
]);
955 this._shortMonthsParse
[i
] = this.monthsShort(mom
, '').toLocaleLowerCase();
956 this._longMonthsParse
[i
] = this.months(mom
, '').toLocaleLowerCase();
961 if (format
=== 'MMM') {
962 ii
= indexOf
.call(this._shortMonthsParse
, llc
);
963 return ii
!== -1 ? ii
: null;
965 ii
= indexOf
.call(this._longMonthsParse
, llc
);
966 return ii
!== -1 ? ii
: null;
969 if (format
=== 'MMM') {
970 ii
= indexOf
.call(this._shortMonthsParse
, llc
);
974 ii
= indexOf
.call(this._longMonthsParse
, llc
);
975 return ii
!== -1 ? ii
: null;
977 ii
= indexOf
.call(this._longMonthsParse
, llc
);
981 ii
= indexOf
.call(this._shortMonthsParse
, llc
);
982 return ii
!== -1 ? ii
: null;
987 function localeMonthsParse (monthName
, format
, strict
) {
990 if (this._monthsParseExact
) {
991 return handleStrictParse
.call(this, monthName
, format
, strict
);
994 if (!this._monthsParse
) {
995 this._monthsParse
= [];
996 this._longMonthsParse
= [];
997 this._shortMonthsParse
= [];
1000 // TODO: add sorting
1001 // Sorting makes sure if one month (or abbr) is a prefix of another
1002 // see sorting in computeMonthsParse
1003 for (i
= 0; i
< 12; i
++) {
1004 // make the regex if we don't have it already
1005 mom
= createUTC([2000, i
]);
1006 if (strict
&& !this._longMonthsParse
[i
]) {
1007 this._longMonthsParse
[i
] = new RegExp('^' + this.months(mom
, '').replace('.', '') + '$', 'i');
1008 this._shortMonthsParse
[i
] = new RegExp('^' + this.monthsShort(mom
, '').replace('.', '') + '$', 'i');
1010 if (!strict
&& !this._monthsParse
[i
]) {
1011 regex
= '^' + this.months(mom
, '') + '|^' + this.monthsShort(mom
, '');
1012 this._monthsParse
[i
] = new RegExp(regex
.replace('.', ''), 'i');
1015 if (strict
&& format
=== 'MMMM' && this._longMonthsParse
[i
].test(monthName
)) {
1017 } else if (strict
&& format
=== 'MMM' && this._shortMonthsParse
[i
].test(monthName
)) {
1019 } else if (!strict
&& this._monthsParse
[i
].test(monthName
)) {
1027 function setMonth (mom
, value
) {
1030 if (!mom
.isValid()) {
1035 if (typeof value
=== 'string') {
1036 if (/^\d+$/.test(value
)) {
1037 value
= toInt(value
);
1039 value
= mom
.localeData().monthsParse(value
);
1040 // TODO: Another silent failure?
1041 if (!isNumber(value
)) {
1047 dayOfMonth
= Math
.min(mom
.date(), daysInMonth(mom
.year(), value
));
1048 mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + 'Month'](value
, dayOfMonth
);
1052 function getSetMonth (value
) {
1053 if (value
!= null) {
1054 setMonth(this, value
);
1055 hooks
.updateOffset(this, true);
1058 return get(this, 'Month');
1062 function getDaysInMonth () {
1063 return daysInMonth(this.year(), this.month());
1066 var defaultMonthsShortRegex
= matchWord
;
1067 function monthsShortRegex (isStrict
) {
1068 if (this._monthsParseExact
) {
1069 if (!hasOwnProp(this, '_monthsRegex')) {
1070 computeMonthsParse
.call(this);
1073 return this._monthsShortStrictRegex
;
1075 return this._monthsShortRegex
;
1078 if (!hasOwnProp(this, '_monthsShortRegex')) {
1079 this._monthsShortRegex
= defaultMonthsShortRegex
;
1081 return this._monthsShortStrictRegex
&& isStrict
?
1082 this._monthsShortStrictRegex
: this._monthsShortRegex
;
1086 var defaultMonthsRegex
= matchWord
;
1087 function monthsRegex (isStrict
) {
1088 if (this._monthsParseExact
) {
1089 if (!hasOwnProp(this, '_monthsRegex')) {
1090 computeMonthsParse
.call(this);
1093 return this._monthsStrictRegex
;
1095 return this._monthsRegex
;
1098 if (!hasOwnProp(this, '_monthsRegex')) {
1099 this._monthsRegex
= defaultMonthsRegex
;
1101 return this._monthsStrictRegex
&& isStrict
?
1102 this._monthsStrictRegex
: this._monthsRegex
;
1106 function computeMonthsParse () {
1107 function cmpLenRev(a
, b
) {
1108 return b
.length
- a
.length
;
1111 var shortPieces
= [], longPieces
= [], mixedPieces
= [],
1113 for (i
= 0; i
< 12; i
++) {
1114 // make the regex if we don't have it already
1115 mom
= createUTC([2000, i
]);
1116 shortPieces
.push(this.monthsShort(mom
, ''));
1117 longPieces
.push(this.months(mom
, ''));
1118 mixedPieces
.push(this.months(mom
, ''));
1119 mixedPieces
.push(this.monthsShort(mom
, ''));
1121 // Sorting makes sure if one month (or abbr) is a prefix of another it
1122 // will match the longer piece.
1123 shortPieces
.sort(cmpLenRev
);
1124 longPieces
.sort(cmpLenRev
);
1125 mixedPieces
.sort(cmpLenRev
);
1126 for (i
= 0; i
< 12; i
++) {
1127 shortPieces
[i
] = regexEscape(shortPieces
[i
]);
1128 longPieces
[i
] = regexEscape(longPieces
[i
]);
1130 for (i
= 0; i
< 24; i
++) {
1131 mixedPieces
[i
] = regexEscape(mixedPieces
[i
]);
1134 this._monthsRegex
= new RegExp('^(' + mixedPieces
.join('|') + ')', 'i');
1135 this._monthsShortRegex
= this._monthsRegex
;
1136 this._monthsStrictRegex
= new RegExp('^(' + longPieces
.join('|') + ')', 'i');
1137 this._monthsShortStrictRegex
= new RegExp('^(' + shortPieces
.join('|') + ')', 'i');
1140 function createDate (y
, m
, d
, h
, M
, s
, ms
) {
1141 // can't just apply() to create a date:
1142 // https://stackoverflow.com/q/181348
1143 var date
= new Date(y
, m
, d
, h
, M
, s
, ms
);
1145 // the date constructor remaps years 0-99 to 1900-1999
1146 if (y
< 100 && y
>= 0 && isFinite(date
.getFullYear())) {
1147 date
.setFullYear(y
);
1152 function createUTCDate (y
) {
1153 var date
= new Date(Date
.UTC
.apply(null, arguments
));
1155 // the Date.UTC function remaps years 0-99 to 1900-1999
1156 if (y
< 100 && y
>= 0 && isFinite(date
.getUTCFullYear())) {
1157 date
.setUTCFullYear(y
);
1162 // start-of-first-week - start-of-year
1163 function firstWeekOffset(year
, dow
, doy
) {
1164 var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1165 fwd
= 7 + dow
- doy
,
1166 // first-week day local weekday -- which local weekday is fwd
1167 fwdlw
= (7 + createUTCDate(year
, 0, fwd
).getUTCDay() - dow
) % 7;
1169 return -fwdlw
+ fwd
- 1;
1172 // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1173 function dayOfYearFromWeeks(year
, week
, weekday
, dow
, doy
) {
1174 var localWeekday
= (7 + weekday
- dow
) % 7,
1175 weekOffset
= firstWeekOffset(year
, dow
, doy
),
1176 dayOfYear
= 1 + 7 * (week
- 1) + localWeekday
+ weekOffset
,
1177 resYear
, resDayOfYear
;
1179 if (dayOfYear
<= 0) {
1181 resDayOfYear
= daysInYear(resYear
) + dayOfYear
;
1182 } else if (dayOfYear
> daysInYear(year
)) {
1184 resDayOfYear
= dayOfYear
- daysInYear(year
);
1187 resDayOfYear
= dayOfYear
;
1192 dayOfYear
: resDayOfYear
1196 function weekOfYear(mom
, dow
, doy
) {
1197 var weekOffset
= firstWeekOffset(mom
.year(), dow
, doy
),
1198 week
= Math
.floor((mom
.dayOfYear() - weekOffset
- 1) / 7) + 1,
1202 resYear
= mom
.year() - 1;
1203 resWeek
= week
+ weeksInYear(resYear
, dow
, doy
);
1204 } else if (week
> weeksInYear(mom
.year(), dow
, doy
)) {
1205 resWeek
= week
- weeksInYear(mom
.year(), dow
, doy
);
1206 resYear
= mom
.year() + 1;
1208 resYear
= mom
.year();
1218 function weeksInYear(year
, dow
, doy
) {
1219 var weekOffset
= firstWeekOffset(year
, dow
, doy
),
1220 weekOffsetNext
= firstWeekOffset(year
+ 1, dow
, doy
);
1221 return (daysInYear(year
) - weekOffset
+ weekOffsetNext
) / 7;
1226 addFormatToken('w', ['ww', 2], 'wo', 'week');
1227 addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1231 addUnitAlias('week', 'w');
1232 addUnitAlias('isoWeek', 'W');
1236 addUnitPriority('week', 5);
1237 addUnitPriority('isoWeek', 5);
1241 addRegexToken('w', match1to2
);
1242 addRegexToken('ww', match1to2
, match2
);
1243 addRegexToken('W', match1to2
);
1244 addRegexToken('WW', match1to2
, match2
);
1246 addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input
, week
, config
, token
) {
1247 week
[token
.substr(0, 1)] = toInt(input
);
1254 function localeWeek (mom
) {
1255 return weekOfYear(mom
, this._week
.dow
, this._week
.doy
).week
;
1258 var defaultLocaleWeek
= {
1259 dow
: 0, // Sunday is the first day of the week.
1260 doy
: 6 // The week that contains Jan 1st is the first week of the year.
1263 function localeFirstDayOfWeek () {
1264 return this._week
.dow
;
1267 function localeFirstDayOfYear () {
1268 return this._week
.doy
;
1273 function getSetWeek (input
) {
1274 var week
= this.localeData().week(this);
1275 return input
== null ? week
: this.add((input
- week
) * 7, 'd');
1278 function getSetISOWeek (input
) {
1279 var week
= weekOfYear(this, 1, 4).week
;
1280 return input
== null ? week
: this.add((input
- week
) * 7, 'd');
1285 addFormatToken('d', 0, 'do', 'day');
1287 addFormatToken('dd', 0, 0, function (format
) {
1288 return this.localeData().weekdaysMin(this, format
);
1291 addFormatToken('ddd', 0, 0, function (format
) {
1292 return this.localeData().weekdaysShort(this, format
);
1295 addFormatToken('dddd', 0, 0, function (format
) {
1296 return this.localeData().weekdays(this, format
);
1299 addFormatToken('e', 0, 0, 'weekday');
1300 addFormatToken('E', 0, 0, 'isoWeekday');
1304 addUnitAlias('day', 'd');
1305 addUnitAlias('weekday', 'e');
1306 addUnitAlias('isoWeekday', 'E');
1309 addUnitPriority('day', 11);
1310 addUnitPriority('weekday', 11);
1311 addUnitPriority('isoWeekday', 11);
1315 addRegexToken('d', match1to2
);
1316 addRegexToken('e', match1to2
);
1317 addRegexToken('E', match1to2
);
1318 addRegexToken('dd', function (isStrict
, locale
) {
1319 return locale
.weekdaysMinRegex(isStrict
);
1321 addRegexToken('ddd', function (isStrict
, locale
) {
1322 return locale
.weekdaysShortRegex(isStrict
);
1324 addRegexToken('dddd', function (isStrict
, locale
) {
1325 return locale
.weekdaysRegex(isStrict
);
1328 addWeekParseToken(['dd', 'ddd', 'dddd'], function (input
, week
, config
, token
) {
1329 var weekday
= config
._locale
.weekdaysParse(input
, token
, config
._strict
);
1330 // if we didn't get a weekday name, mark the date as invalid
1331 if (weekday
!= null) {
1334 getParsingFlags(config
).invalidWeekday
= input
;
1338 addWeekParseToken(['d', 'e', 'E'], function (input
, week
, config
, token
) {
1339 week
[token
] = toInt(input
);
1344 function parseWeekday(input
, locale
) {
1345 if (typeof input
!== 'string') {
1349 if (!isNaN(input
)) {
1350 return parseInt(input
, 10);
1353 input
= locale
.weekdaysParse(input
);
1354 if (typeof input
=== 'number') {
1361 function parseIsoWeekday(input
, locale
) {
1362 if (typeof input
=== 'string') {
1363 return locale
.weekdaysParse(input
) % 7 || 7;
1365 return isNaN(input
) ? null : input
;
1370 var defaultLocaleWeekdays
= 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
1371 function localeWeekdays (m
, format
) {
1373 return isArray(this._weekdays
) ? this._weekdays
:
1374 this._weekdays
['standalone'];
1376 return isArray(this._weekdays
) ? this._weekdays
[m
.day()] :
1377 this._weekdays
[this._weekdays
.isFormat
.test(format
) ? 'format' : 'standalone'][m
.day()];
1380 var defaultLocaleWeekdaysShort
= 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
1381 function localeWeekdaysShort (m
) {
1382 return (m
) ? this._weekdaysShort
[m
.day()] : this._weekdaysShort
;
1385 var defaultLocaleWeekdaysMin
= 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
1386 function localeWeekdaysMin (m
) {
1387 return (m
) ? this._weekdaysMin
[m
.day()] : this._weekdaysMin
;
1390 function handleStrictParse
$1(weekdayName
, format
, strict
) {
1391 var i
, ii
, mom
, llc
= weekdayName
.toLocaleLowerCase();
1392 if (!this._weekdaysParse
) {
1393 this._weekdaysParse
= [];
1394 this._shortWeekdaysParse
= [];
1395 this._minWeekdaysParse
= [];
1397 for (i
= 0; i
< 7; ++i
) {
1398 mom
= createUTC([2000, 1]).day(i
);
1399 this._minWeekdaysParse
[i
] = this.weekdaysMin(mom
, '').toLocaleLowerCase();
1400 this._shortWeekdaysParse
[i
] = this.weekdaysShort(mom
, '').toLocaleLowerCase();
1401 this._weekdaysParse
[i
] = this.weekdays(mom
, '').toLocaleLowerCase();
1406 if (format
=== 'dddd') {
1407 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1408 return ii
!== -1 ? ii
: null;
1409 } else if (format
=== 'ddd') {
1410 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1411 return ii
!== -1 ? ii
: null;
1413 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1414 return ii
!== -1 ? ii
: null;
1417 if (format
=== 'dddd') {
1418 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1422 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1426 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1427 return ii
!== -1 ? ii
: null;
1428 } else if (format
=== 'ddd') {
1429 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1433 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1437 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1438 return ii
!== -1 ? ii
: null;
1440 ii
= indexOf
.call(this._minWeekdaysParse
, llc
);
1444 ii
= indexOf
.call(this._weekdaysParse
, llc
);
1448 ii
= indexOf
.call(this._shortWeekdaysParse
, llc
);
1449 return ii
!== -1 ? ii
: null;
1454 function localeWeekdaysParse (weekdayName
, format
, strict
) {
1457 if (this._weekdaysParseExact
) {
1458 return handleStrictParse
$1.call(this, weekdayName
, format
, strict
);
1461 if (!this._weekdaysParse
) {
1462 this._weekdaysParse
= [];
1463 this._minWeekdaysParse
= [];
1464 this._shortWeekdaysParse
= [];
1465 this._fullWeekdaysParse
= [];
1468 for (i
= 0; i
< 7; i
++) {
1469 // make the regex if we don't have it already
1471 mom
= createUTC([2000, 1]).day(i
);
1472 if (strict
&& !this._fullWeekdaysParse
[i
]) {
1473 this._fullWeekdaysParse
[i
] = new RegExp('^' + this.weekdays(mom
, '').replace('.', '\\.?') + '$', 'i');
1474 this._shortWeekdaysParse
[i
] = new RegExp('^' + this.weekdaysShort(mom
, '').replace('.', '\\.?') + '$', 'i');
1475 this._minWeekdaysParse
[i
] = new RegExp('^' + this.weekdaysMin(mom
, '').replace('.', '\\.?') + '$', 'i');
1477 if (!this._weekdaysParse
[i
]) {
1478 regex
= '^' + this.weekdays(mom
, '') + '|^' + this.weekdaysShort(mom
, '') + '|^' + this.weekdaysMin(mom
, '');
1479 this._weekdaysParse
[i
] = new RegExp(regex
.replace('.', ''), 'i');
1482 if (strict
&& format
=== 'dddd' && this._fullWeekdaysParse
[i
].test(weekdayName
)) {
1484 } else if (strict
&& format
=== 'ddd' && this._shortWeekdaysParse
[i
].test(weekdayName
)) {
1486 } else if (strict
&& format
=== 'dd' && this._minWeekdaysParse
[i
].test(weekdayName
)) {
1488 } else if (!strict
&& this._weekdaysParse
[i
].test(weekdayName
)) {
1496 function getSetDayOfWeek (input
) {
1497 if (!this.isValid()) {
1498 return input
!= null ? this : NaN
;
1500 var day
= this._isUTC
? this._d
.getUTCDay() : this._d
.getDay();
1501 if (input
!= null) {
1502 input
= parseWeekday(input
, this.localeData());
1503 return this.add(input
- day
, 'd');
1509 function getSetLocaleDayOfWeek (input
) {
1510 if (!this.isValid()) {
1511 return input
!= null ? this : NaN
;
1513 var weekday
= (this.day() + 7 - this.localeData()._week
.dow
) % 7;
1514 return input
== null ? weekday
: this.add(input
- weekday
, 'd');
1517 function getSetISODayOfWeek (input
) {
1518 if (!this.isValid()) {
1519 return input
!= null ? this : NaN
;
1522 // behaves the same as moment#day except
1523 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1524 // as a setter, sunday should belong to the previous week.
1526 if (input
!= null) {
1527 var weekday
= parseIsoWeekday(input
, this.localeData());
1528 return this.day(this.day() % 7 ? weekday
: weekday
- 7);
1530 return this.day() || 7;
1534 var defaultWeekdaysRegex
= matchWord
;
1535 function weekdaysRegex (isStrict
) {
1536 if (this._weekdaysParseExact
) {
1537 if (!hasOwnProp(this, '_weekdaysRegex')) {
1538 computeWeekdaysParse
.call(this);
1541 return this._weekdaysStrictRegex
;
1543 return this._weekdaysRegex
;
1546 if (!hasOwnProp(this, '_weekdaysRegex')) {
1547 this._weekdaysRegex
= defaultWeekdaysRegex
;
1549 return this._weekdaysStrictRegex
&& isStrict
?
1550 this._weekdaysStrictRegex
: this._weekdaysRegex
;
1554 var defaultWeekdaysShortRegex
= matchWord
;
1555 function weekdaysShortRegex (isStrict
) {
1556 if (this._weekdaysParseExact
) {
1557 if (!hasOwnProp(this, '_weekdaysRegex')) {
1558 computeWeekdaysParse
.call(this);
1561 return this._weekdaysShortStrictRegex
;
1563 return this._weekdaysShortRegex
;
1566 if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1567 this._weekdaysShortRegex
= defaultWeekdaysShortRegex
;
1569 return this._weekdaysShortStrictRegex
&& isStrict
?
1570 this._weekdaysShortStrictRegex
: this._weekdaysShortRegex
;
1574 var defaultWeekdaysMinRegex
= matchWord
;
1575 function weekdaysMinRegex (isStrict
) {
1576 if (this._weekdaysParseExact
) {
1577 if (!hasOwnProp(this, '_weekdaysRegex')) {
1578 computeWeekdaysParse
.call(this);
1581 return this._weekdaysMinStrictRegex
;
1583 return this._weekdaysMinRegex
;
1586 if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1587 this._weekdaysMinRegex
= defaultWeekdaysMinRegex
;
1589 return this._weekdaysMinStrictRegex
&& isStrict
?
1590 this._weekdaysMinStrictRegex
: this._weekdaysMinRegex
;
1595 function computeWeekdaysParse () {
1596 function cmpLenRev(a
, b
) {
1597 return b
.length
- a
.length
;
1600 var minPieces
= [], shortPieces
= [], longPieces
= [], mixedPieces
= [],
1601 i
, mom
, minp
, shortp
, longp
;
1602 for (i
= 0; i
< 7; i
++) {
1603 // make the regex if we don't have it already
1604 mom
= createUTC([2000, 1]).day(i
);
1605 minp
= this.weekdaysMin(mom
, '');
1606 shortp
= this.weekdaysShort(mom
, '');
1607 longp
= this.weekdays(mom
, '');
1608 minPieces
.push(minp
);
1609 shortPieces
.push(shortp
);
1610 longPieces
.push(longp
);
1611 mixedPieces
.push(minp
);
1612 mixedPieces
.push(shortp
);
1613 mixedPieces
.push(longp
);
1615 // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1616 // will match the longer piece.
1617 minPieces
.sort(cmpLenRev
);
1618 shortPieces
.sort(cmpLenRev
);
1619 longPieces
.sort(cmpLenRev
);
1620 mixedPieces
.sort(cmpLenRev
);
1621 for (i
= 0; i
< 7; i
++) {
1622 shortPieces
[i
] = regexEscape(shortPieces
[i
]);
1623 longPieces
[i
] = regexEscape(longPieces
[i
]);
1624 mixedPieces
[i
] = regexEscape(mixedPieces
[i
]);
1627 this._weekdaysRegex
= new RegExp('^(' + mixedPieces
.join('|') + ')', 'i');
1628 this._weekdaysShortRegex
= this._weekdaysRegex
;
1629 this._weekdaysMinRegex
= this._weekdaysRegex
;
1631 this._weekdaysStrictRegex
= new RegExp('^(' + longPieces
.join('|') + ')', 'i');
1632 this._weekdaysShortStrictRegex
= new RegExp('^(' + shortPieces
.join('|') + ')', 'i');
1633 this._weekdaysMinStrictRegex
= new RegExp('^(' + minPieces
.join('|') + ')', 'i');
1638 function hFormat() {
1639 return this.hours() % 12 || 12;
1642 function kFormat() {
1643 return this.hours() || 24;
1646 addFormatToken('H', ['HH', 2], 0, 'hour');
1647 addFormatToken('h', ['hh', 2], 0, hFormat
);
1648 addFormatToken('k', ['kk', 2], 0, kFormat
);
1650 addFormatToken('hmm', 0, 0, function () {
1651 return '' + hFormat
.apply(this) + zeroFill(this.minutes(), 2);
1654 addFormatToken('hmmss', 0, 0, function () {
1655 return '' + hFormat
.apply(this) + zeroFill(this.minutes(), 2) +
1656 zeroFill(this.seconds(), 2);
1659 addFormatToken('Hmm', 0, 0, function () {
1660 return '' + this.hours() + zeroFill(this.minutes(), 2);
1663 addFormatToken('Hmmss', 0, 0, function () {
1664 return '' + this.hours() + zeroFill(this.minutes(), 2) +
1665 zeroFill(this.seconds(), 2);
1668 function meridiem (token
, lowercase
) {
1669 addFormatToken(token
, 0, 0, function () {
1670 return this.localeData().meridiem(this.hours(), this.minutes(), lowercase
);
1674 meridiem('a', true);
1675 meridiem('A', false);
1679 addUnitAlias('hour', 'h');
1682 addUnitPriority('hour', 13);
1686 function matchMeridiem (isStrict
, locale
) {
1687 return locale
._meridiemParse
;
1690 addRegexToken('a', matchMeridiem
);
1691 addRegexToken('A', matchMeridiem
);
1692 addRegexToken('H', match1to2
);
1693 addRegexToken('h', match1to2
);
1694 addRegexToken('k', match1to2
);
1695 addRegexToken('HH', match1to2
, match2
);
1696 addRegexToken('hh', match1to2
, match2
);
1697 addRegexToken('kk', match1to2
, match2
);
1699 addRegexToken('hmm', match3to4
);
1700 addRegexToken('hmmss', match5to6
);
1701 addRegexToken('Hmm', match3to4
);
1702 addRegexToken('Hmmss', match5to6
);
1704 addParseToken(['H', 'HH'], HOUR
);
1705 addParseToken(['k', 'kk'], function (input
, array
, config
) {
1706 var kInput
= toInt(input
);
1707 array
[HOUR
] = kInput
=== 24 ? 0 : kInput
;
1709 addParseToken(['a', 'A'], function (input
, array
, config
) {
1710 config
._isPm
= config
._locale
.isPM(input
);
1711 config
._meridiem
= input
;
1713 addParseToken(['h', 'hh'], function (input
, array
, config
) {
1714 array
[HOUR
] = toInt(input
);
1715 getParsingFlags(config
).bigHour
= true;
1717 addParseToken('hmm', function (input
, array
, config
) {
1718 var pos
= input
.length
- 2;
1719 array
[HOUR
] = toInt(input
.substr(0, pos
));
1720 array
[MINUTE
] = toInt(input
.substr(pos
));
1721 getParsingFlags(config
).bigHour
= true;
1723 addParseToken('hmmss', function (input
, array
, config
) {
1724 var pos1
= input
.length
- 4;
1725 var pos2
= input
.length
- 2;
1726 array
[HOUR
] = toInt(input
.substr(0, pos1
));
1727 array
[MINUTE
] = toInt(input
.substr(pos1
, 2));
1728 array
[SECOND
] = toInt(input
.substr(pos2
));
1729 getParsingFlags(config
).bigHour
= true;
1731 addParseToken('Hmm', function (input
, array
, config
) {
1732 var pos
= input
.length
- 2;
1733 array
[HOUR
] = toInt(input
.substr(0, pos
));
1734 array
[MINUTE
] = toInt(input
.substr(pos
));
1736 addParseToken('Hmmss', function (input
, array
, config
) {
1737 var pos1
= input
.length
- 4;
1738 var pos2
= input
.length
- 2;
1739 array
[HOUR
] = toInt(input
.substr(0, pos1
));
1740 array
[MINUTE
] = toInt(input
.substr(pos1
, 2));
1741 array
[SECOND
] = toInt(input
.substr(pos2
));
1746 function localeIsPM (input
) {
1747 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1748 // Using charAt should be more compatible.
1749 return ((input
+ '').toLowerCase().charAt(0) === 'p');
1752 var defaultLocaleMeridiemParse
= /[ap]\.?m?\.?/i;
1753 function localeMeridiem (hours
, minutes
, isLower
) {
1755 return isLower
? 'pm' : 'PM';
1757 return isLower
? 'am' : 'AM';
1764 // Setting the hour should keep the time, because the user explicitly
1765 // specified which hour they want. So trying to maintain the same hour (in
1766 // a new timezone) makes sense. Adding/subtracting hours does not follow
1768 var getSetHour
= makeGetSet('Hours', true);
1771 calendar
: defaultCalendar
,
1772 longDateFormat
: defaultLongDateFormat
,
1773 invalidDate
: defaultInvalidDate
,
1774 ordinal
: defaultOrdinal
,
1775 dayOfMonthOrdinalParse
: defaultDayOfMonthOrdinalParse
,
1776 relativeTime
: defaultRelativeTime
,
1778 months
: defaultLocaleMonths
,
1779 monthsShort
: defaultLocaleMonthsShort
,
1781 week
: defaultLocaleWeek
,
1783 weekdays
: defaultLocaleWeekdays
,
1784 weekdaysMin
: defaultLocaleWeekdaysMin
,
1785 weekdaysShort
: defaultLocaleWeekdaysShort
,
1787 meridiemParse
: defaultLocaleMeridiemParse
1790 // internal storage for locale config files
1792 var localeFamilies
= {};
1795 function normalizeLocale(key
) {
1796 return key
? key
.toLowerCase().replace('_', '-') : key
;
1799 // pick the locale from the array
1800 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
1801 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
1802 function chooseLocale(names
) {
1803 var i
= 0, j
, next
, locale
, split
;
1805 while (i
< names
.length
) {
1806 split
= normalizeLocale(names
[i
]).split('-');
1808 next
= normalizeLocale(names
[i
+ 1]);
1809 next
= next
? next
.split('-') : null;
1811 locale
= loadLocale(split
.slice(0, j
).join('-'));
1815 if (next
&& next
.length
>= j
&& compareArrays(split
, next
, true) >= j
- 1) {
1816 //the next array item is better than a shallower substring of this one
1823 return globalLocale
;
1826 function loadLocale(name
) {
1827 var oldLocale
= null;
1828 // TODO: Find a better way to register and load all the locales in Node
1829 if (!locales
[name
] && (typeof module
!== 'undefined') &&
1830 module
&& module
.exports
) {
1832 oldLocale
= globalLocale
._abbr
;
1833 var aliasedRequire
= require
;
1834 aliasedRequire('./locale/' + name
);
1835 getSetGlobalLocale(oldLocale
);
1838 return locales
[name
];
1841 // This function will load locale and then set the global locale. If
1842 // no arguments are passed in, it will simply return the current global
1844 function getSetGlobalLocale (key
, values
) {
1847 if (isUndefined(values
)) {
1848 data
= getLocale(key
);
1851 data
= defineLocale(key
, values
);
1855 // moment.duration._locale = moment._locale = data;
1856 globalLocale
= data
;
1859 if ((typeof console
!== 'undefined') && console
.warn
) {
1860 //warn user if arguments are passed but the locale could not be set
1861 console
.warn('Locale ' + key
+ ' not found. Did you forget to load it?');
1866 return globalLocale
._abbr
;
1869 function defineLocale (name
, config
) {
1870 if (config
!== null) {
1871 var locale
, parentConfig
= baseConfig
;
1873 if (locales
[name
] != null) {
1874 deprecateSimple('defineLocaleOverride',
1875 'use moment.updateLocale(localeName, config) to change ' +
1876 'an existing locale. moment.defineLocale(localeName, ' +
1877 'config) should only be used for creating a new locale ' +
1878 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
1879 parentConfig
= locales
[name
]._config
;
1880 } else if (config
.parentLocale
!= null) {
1881 if (locales
[config
.parentLocale
] != null) {
1882 parentConfig
= locales
[config
.parentLocale
]._config
;
1884 locale
= loadLocale(config
.parentLocale
);
1885 if (locale
!= null) {
1886 parentConfig
= locale
._config
;
1888 if (!localeFamilies
[config
.parentLocale
]) {
1889 localeFamilies
[config
.parentLocale
] = [];
1891 localeFamilies
[config
.parentLocale
].push({
1899 locales
[name
] = new Locale(mergeConfigs(parentConfig
, config
));
1901 if (localeFamilies
[name
]) {
1902 localeFamilies
[name
].forEach(function (x
) {
1903 defineLocale(x
.name
, x
.config
);
1907 // backwards compat for now: also set the locale
1908 // make sure we set the locale AFTER all child locales have been
1909 // created, so we won't end up with the child locale set.
1910 getSetGlobalLocale(name
);
1913 return locales
[name
];
1915 // useful for testing
1916 delete locales
[name
];
1921 function updateLocale(name
, config
) {
1922 if (config
!= null) {
1923 var locale
, tmpLocale
, parentConfig
= baseConfig
;
1925 tmpLocale
= loadLocale(name
);
1926 if (tmpLocale
!= null) {
1927 parentConfig
= tmpLocale
._config
;
1929 config
= mergeConfigs(parentConfig
, config
);
1930 locale
= new Locale(config
);
1931 locale
.parentLocale
= locales
[name
];
1932 locales
[name
] = locale
;
1934 // backwards compat for now: also set the locale
1935 getSetGlobalLocale(name
);
1937 // pass null for config to unupdate, useful for tests
1938 if (locales
[name
] != null) {
1939 if (locales
[name
].parentLocale
!= null) {
1940 locales
[name
] = locales
[name
].parentLocale
;
1941 } else if (locales
[name
] != null) {
1942 delete locales
[name
];
1946 return locales
[name
];
1949 // returns locale data
1950 function getLocale (key
) {
1953 if (key
&& key
._locale
&& key
._locale
._abbr
) {
1954 key
= key
._locale
._abbr
;
1958 return globalLocale
;
1961 if (!isArray(key
)) {
1962 //short-circuit everything else
1963 locale
= loadLocale(key
);
1970 return chooseLocale(key
);
1973 function listLocales() {
1974 return keys(locales
);
1977 function checkOverflow (m
) {
1981 if (a
&& getParsingFlags(m
).overflow
=== -2) {
1983 a
[MONTH
] < 0 || a
[MONTH
] > 11 ? MONTH
:
1984 a
[DATE
] < 1 || a
[DATE
] > daysInMonth(a
[YEAR
], a
[MONTH
]) ? DATE
:
1985 a
[HOUR
] < 0 || a
[HOUR
] > 24 || (a
[HOUR
] === 24 && (a
[MINUTE
] !== 0 || a
[SECOND
] !== 0 || a
[MILLISECOND
] !== 0)) ? HOUR
:
1986 a
[MINUTE
] < 0 || a
[MINUTE
] > 59 ? MINUTE
:
1987 a
[SECOND
] < 0 || a
[SECOND
] > 59 ? SECOND
:
1988 a
[MILLISECOND
] < 0 || a
[MILLISECOND
] > 999 ? MILLISECOND
:
1991 if (getParsingFlags(m
)._overflowDayOfYear
&& (overflow
< YEAR
|| overflow
> DATE
)) {
1994 if (getParsingFlags(m
)._overflowWeeks
&& overflow
=== -1) {
1997 if (getParsingFlags(m
)._overflowWeekday
&& overflow
=== -1) {
2001 getParsingFlags(m
).overflow
= overflow
;
2007 // Pick the first defined of two or three arguments.
2008 function defaults(a
, b
, c
) {
2018 function currentDateArray(config
) {
2019 // hooks is actually the exported moment object
2020 var nowValue
= new Date(hooks
.now());
2021 if (config
._useUTC
) {
2022 return [nowValue
.getUTCFullYear(), nowValue
.getUTCMonth(), nowValue
.getUTCDate()];
2024 return [nowValue
.getFullYear(), nowValue
.getMonth(), nowValue
.getDate()];
2027 // convert an array to a date.
2028 // the array should mirror the parameters below
2029 // note: all values past the year are optional and will default to the lowest possible value.
2030 // [year, month, day , hour, minute, second, millisecond]
2031 function configFromArray (config
) {
2032 var i
, date
, input
= [], currentDate
, expectedWeekday
, yearToUse
;
2038 currentDate
= currentDateArray(config
);
2040 //compute day of the year from weeks and weekdays
2041 if (config
._w
&& config
._a
[DATE
] == null && config
._a
[MONTH
] == null) {
2042 dayOfYearFromWeekInfo(config
);
2045 //if the day of the year is set, figure out what it is
2046 if (config
._dayOfYear
!= null) {
2047 yearToUse
= defaults(config
._a
[YEAR
], currentDate
[YEAR
]);
2049 if (config
._dayOfYear
> daysInYear(yearToUse
) || config
._dayOfYear
=== 0) {
2050 getParsingFlags(config
)._overflowDayOfYear
= true;
2053 date
= createUTCDate(yearToUse
, 0, config
._dayOfYear
);
2054 config
._a
[MONTH
] = date
.getUTCMonth();
2055 config
._a
[DATE
] = date
.getUTCDate();
2058 // Default to current date.
2059 // * if no year, month, day of month are given, default to today
2060 // * if day of month is given, default month and year
2061 // * if month is given, default only year
2062 // * if year is given, don't default anything
2063 for (i
= 0; i
< 3 && config
._a
[i
] == null; ++i
) {
2064 config
._a
[i
] = input
[i
] = currentDate
[i
];
2067 // Zero out whatever was not defaulted, including time
2068 for (; i
< 7; i
++) {
2069 config
._a
[i
] = input
[i
] = (config
._a
[i
] == null) ? (i
=== 2 ? 1 : 0) : config
._a
[i
];
2072 // Check for 24:00:00.000
2073 if (config
._a
[HOUR
] === 24 &&
2074 config
._a
[MINUTE
] === 0 &&
2075 config
._a
[SECOND
] === 0 &&
2076 config
._a
[MILLISECOND
] === 0) {
2077 config
._nextDay
= true;
2078 config
._a
[HOUR
] = 0;
2081 config
._d
= (config
._useUTC
? createUTCDate
: createDate
).apply(null, input
);
2082 expectedWeekday
= config
._useUTC
? config
._d
.getUTCDay() : config
._d
.getDay();
2084 // Apply timezone offset from input. The actual utcOffset can be changed
2086 if (config
._tzm
!= null) {
2087 config
._d
.setUTCMinutes(config
._d
.getUTCMinutes() - config
._tzm
);
2090 if (config
._nextDay
) {
2091 config
._a
[HOUR
] = 24;
2094 // check for mismatching day of week
2095 if (config
._w
&& typeof config
._w
.d
!== 'undefined' && config
._w
.d
!== expectedWeekday
) {
2096 getParsingFlags(config
).weekdayMismatch
= true;
2100 function dayOfYearFromWeekInfo(config
) {
2101 var w
, weekYear
, week
, weekday
, dow
, doy
, temp
, weekdayOverflow
;
2104 if (w
.GG
!= null || w
.W
!= null || w
.E
!= null) {
2108 // TODO: We need to take the current isoWeekYear, but that depends on
2109 // how we interpret now (local, utc, fixed offset). So create
2110 // a now version of current config (take local/utc/offset flags, and
2112 weekYear
= defaults(w
.GG
, config
._a
[YEAR
], weekOfYear(createLocal(), 1, 4).year
);
2113 week
= defaults(w
.W
, 1);
2114 weekday
= defaults(w
.E
, 1);
2115 if (weekday
< 1 || weekday
> 7) {
2116 weekdayOverflow
= true;
2119 dow
= config
._locale
._week
.dow
;
2120 doy
= config
._locale
._week
.doy
;
2122 var curWeek
= weekOfYear(createLocal(), dow
, doy
);
2124 weekYear
= defaults(w
.gg
, config
._a
[YEAR
], curWeek
.year
);
2126 // Default to current week.
2127 week
= defaults(w
.w
, curWeek
.week
);
2130 // weekday -- low day numbers are considered next week
2132 if (weekday
< 0 || weekday
> 6) {
2133 weekdayOverflow
= true;
2135 } else if (w
.e
!= null) {
2136 // local weekday -- counting starts from begining of week
2137 weekday
= w
.e
+ dow
;
2138 if (w
.e
< 0 || w
.e
> 6) {
2139 weekdayOverflow
= true;
2142 // default to begining of week
2146 if (week
< 1 || week
> weeksInYear(weekYear
, dow
, doy
)) {
2147 getParsingFlags(config
)._overflowWeeks
= true;
2148 } else if (weekdayOverflow
!= null) {
2149 getParsingFlags(config
)._overflowWeekday
= true;
2151 temp
= dayOfYearFromWeeks(weekYear
, week
, weekday
, dow
, doy
);
2152 config
._a
[YEAR
] = temp
.year
;
2153 config
._dayOfYear
= temp
.dayOfYear
;
2158 // 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)
2159 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)?)?$/;
2160 var 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)?)?$/;
2162 var tzRegex
= /Z|[+-]\d\d(?::?\d\d)?/;
2165 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2166 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2167 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2168 ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2169 ['YYYY-DDD', /\d{4}-\d{3}/],
2170 ['YYYY-MM', /\d{4}-\d\d/, false],
2171 ['YYYYYYMMDD', /[+-]\d{10}/],
2172 ['YYYYMMDD', /\d{8}/],
2173 // YYYYMM is NOT allowed by the standard
2174 ['GGGG[W]WWE', /\d{4}W\d{3}/],
2175 ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2176 ['YYYYDDD', /\d{7}/]
2179 // iso time formats and regexes
2181 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2182 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2183 ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2184 ['HH:mm', /\d\d:\d\d/],
2185 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2186 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2187 ['HHmmss', /\d\d\d\d\d\d/],
2188 ['HHmm', /\d\d\d\d/],
2192 var aspNetJsonRegex
= /^\/?Date\((\-?\d+)/i;
2194 // date from iso format
2195 function configFromISO(config
) {
2198 match
= extendedIsoRegex
.exec(string
) || basicIsoRegex
.exec(string
),
2199 allowTime
, dateFormat
, timeFormat
, tzFormat
;
2202 getParsingFlags(config
).iso
= true;
2204 for (i
= 0, l
= isoDates
.length
; i
< l
; i
++) {
2205 if (isoDates
[i
][1].exec(match
[1])) {
2206 dateFormat
= isoDates
[i
][0];
2207 allowTime
= isoDates
[i
][2] !== false;
2211 if (dateFormat
== null) {
2212 config
._isValid
= false;
2216 for (i
= 0, l
= isoTimes
.length
; i
< l
; i
++) {
2217 if (isoTimes
[i
][1].exec(match
[3])) {
2218 // match[2] should be 'T' or space
2219 timeFormat
= (match
[2] || ' ') + isoTimes
[i
][0];
2223 if (timeFormat
== null) {
2224 config
._isValid
= false;
2228 if (!allowTime
&& timeFormat
!= null) {
2229 config
._isValid
= false;
2233 if (tzRegex
.exec(match
[4])) {
2236 config
._isValid
= false;
2240 config
._f
= dateFormat
+ (timeFormat
|| '') + (tzFormat
|| '');
2241 configFromStringAndFormat(config
);
2243 config
._isValid
= false;
2247 // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2248 var 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}))$/;
2250 function extractFromRFC2822Strings(yearStr
, monthStr
, dayStr
, hourStr
, minuteStr
, secondStr
) {
2252 untruncateYear(yearStr
),
2253 defaultLocaleMonthsShort
.indexOf(monthStr
),
2254 parseInt(dayStr
, 10),
2255 parseInt(hourStr
, 10),
2256 parseInt(minuteStr
, 10)
2260 result
.push(parseInt(secondStr
, 10));
2266 function untruncateYear(yearStr
) {
2267 var year
= parseInt(yearStr
, 10);
2270 } else if (year
<= 999) {
2276 function preprocessRFC2822(s
) {
2277 // Remove comments and folding whitespace and replace multiple-spaces with a single space
2278 return s
.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, '');
2281 function checkWeekday(weekdayStr
, parsedInput
, config
) {
2283 // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
2284 var weekdayProvided
= defaultLocaleWeekdaysShort
.indexOf(weekdayStr
),
2285 weekdayActual
= new Date(parsedInput
[0], parsedInput
[1], parsedInput
[2]).getDay();
2286 if (weekdayProvided
!== weekdayActual
) {
2287 getParsingFlags(config
).weekdayMismatch
= true;
2288 config
._isValid
= false;
2308 function calculateOffset(obsOffset
, militaryOffset
, numOffset
) {
2310 return obsOffsets
[obsOffset
];
2311 } else if (militaryOffset
) {
2312 // the only allowed military tz is Z
2315 var hm
= parseInt(numOffset
, 10);
2316 var m
= hm
% 100, h
= (hm
- m
) / 100;
2321 // date and time from ref 2822 format
2322 function configFromRFC2822(config
) {
2323 var match
= rfc2822
.exec(preprocessRFC2822(config
._i
));
2325 var parsedArray
= extractFromRFC2822Strings(match
[4], match
[3], match
[2], match
[5], match
[6], match
[7]);
2326 if (!checkWeekday(match
[1], parsedArray
, config
)) {
2330 config
._a
= parsedArray
;
2331 config
._tzm
= calculateOffset(match
[8], match
[9], match
[10]);
2333 config
._d
= createUTCDate
.apply(null, config
._a
);
2334 config
._d
.setUTCMinutes(config
._d
.getUTCMinutes() - config
._tzm
);
2336 getParsingFlags(config
).rfc2822
= true;
2338 config
._isValid
= false;
2342 // date from iso format or fallback
2343 function configFromString(config
) {
2344 var matched
= aspNetJsonRegex
.exec(config
._i
);
2346 if (matched
!== null) {
2347 config
._d
= new Date(+matched
[1]);
2351 configFromISO(config
);
2352 if (config
._isValid
=== false) {
2353 delete config
._isValid
;
2358 configFromRFC2822(config
);
2359 if (config
._isValid
=== false) {
2360 delete config
._isValid
;
2365 // Final attempt, use Input Fallback
2366 hooks
.createFromInputFallback(config
);
2369 hooks
.createFromInputFallback
= deprecate(
2370 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
2371 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
2372 'discouraged and will be removed in an upcoming major release. Please refer to ' +
2373 'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2375 config
._d
= new Date(config
._i
+ (config
._useUTC
? ' UTC' : ''));
2379 // constant that refers to the ISO standard
2380 hooks
.ISO_8601 = function () {};
2382 // constant that refers to the RFC 2822 form
2383 hooks
.RFC_2822 = function () {};
2385 // date from string and format string
2386 function configFromStringAndFormat(config
) {
2387 // TODO: Move this to another part of the creation flow to prevent circular deps
2388 if (config
._f
=== hooks
.ISO_8601
) {
2389 configFromISO(config
);
2392 if (config
._f
=== hooks
.RFC_2822
) {
2393 configFromRFC2822(config
);
2397 getParsingFlags(config
).empty
= true;
2399 // This array is used to make a Date, either with `new Date` or `Date.UTC`
2400 var string
= '' + config
._i
,
2401 i
, parsedInput
, tokens
, token
, skipped
,
2402 stringLength
= string
.length
,
2403 totalParsedInputLength
= 0;
2405 tokens
= expandFormat(config
._f
, config
._locale
).match(formattingTokens
) || [];
2407 for (i
= 0; i
< tokens
.length
; i
++) {
2409 parsedInput
= (string
.match(getParseRegexForToken(token
, config
)) || [])[0];
2410 // console.log('token', token, 'parsedInput', parsedInput,
2411 // 'regex', getParseRegexForToken(token, config));
2413 skipped
= string
.substr(0, string
.indexOf(parsedInput
));
2414 if (skipped
.length
> 0) {
2415 getParsingFlags(config
).unusedInput
.push(skipped
);
2417 string
= string
.slice(string
.indexOf(parsedInput
) + parsedInput
.length
);
2418 totalParsedInputLength
+= parsedInput
.length
;
2420 // don't parse if it's not a known token
2421 if (formatTokenFunctions
[token
]) {
2423 getParsingFlags(config
).empty
= false;
2426 getParsingFlags(config
).unusedTokens
.push(token
);
2428 addTimeToArrayFromToken(token
, parsedInput
, config
);
2430 else if (config
._strict
&& !parsedInput
) {
2431 getParsingFlags(config
).unusedTokens
.push(token
);
2435 // add remaining unparsed input length to the string
2436 getParsingFlags(config
).charsLeftOver
= stringLength
- totalParsedInputLength
;
2437 if (string
.length
> 0) {
2438 getParsingFlags(config
).unusedInput
.push(string
);
2441 // clear _12h flag if hour is <= 12
2442 if (config
._a
[HOUR
] <= 12 &&
2443 getParsingFlags(config
).bigHour
=== true &&
2444 config
._a
[HOUR
] > 0) {
2445 getParsingFlags(config
).bigHour
= undefined;
2448 getParsingFlags(config
).parsedDateParts
= config
._a
.slice(0);
2449 getParsingFlags(config
).meridiem
= config
._meridiem
;
2451 config
._a
[HOUR
] = meridiemFixWrap(config
._locale
, config
._a
[HOUR
], config
._meridiem
);
2453 configFromArray(config
);
2454 checkOverflow(config
);
2458 function meridiemFixWrap (locale
, hour
, meridiem
) {
2461 if (meridiem
== null) {
2465 if (locale
.meridiemHour
!= null) {
2466 return locale
.meridiemHour(hour
, meridiem
);
2467 } else if (locale
.isPM
!= null) {
2469 isPm
= locale
.isPM(meridiem
);
2470 if (isPm
&& hour
< 12) {
2473 if (!isPm
&& hour
=== 12) {
2478 // this is not supposed to happen
2483 // date from string and array of format strings
2484 function configFromStringAndArray(config
) {
2492 if (config
._f
.length
=== 0) {
2493 getParsingFlags(config
).invalidFormat
= true;
2494 config
._d
= new Date(NaN
);
2498 for (i
= 0; i
< config
._f
.length
; i
++) {
2500 tempConfig
= copyConfig({}, config
);
2501 if (config
._useUTC
!= null) {
2502 tempConfig
._useUTC
= config
._useUTC
;
2504 tempConfig
._f
= config
._f
[i
];
2505 configFromStringAndFormat(tempConfig
);
2507 if (!isValid(tempConfig
)) {
2511 // if there is any input that was not parsed add a penalty for that format
2512 currentScore
+= getParsingFlags(tempConfig
).charsLeftOver
;
2515 currentScore
+= getParsingFlags(tempConfig
).unusedTokens
.length
* 10;
2517 getParsingFlags(tempConfig
).score
= currentScore
;
2519 if (scoreToBeat
== null || currentScore
< scoreToBeat
) {
2520 scoreToBeat
= currentScore
;
2521 bestMoment
= tempConfig
;
2525 extend(config
, bestMoment
|| tempConfig
);
2528 function configFromObject(config
) {
2533 var i
= normalizeObjectUnits(config
._i
);
2534 config
._a
= map([i
.year
, i
.month
, i
.day
|| i
.date
, i
.hour
, i
.minute
, i
.second
, i
.millisecond
], function (obj
) {
2535 return obj
&& parseInt(obj
, 10);
2538 configFromArray(config
);
2541 function createFromConfig (config
) {
2542 var res
= new Moment(checkOverflow(prepareConfig(config
)));
2544 // Adding is smart enough around DST
2546 res
._nextDay
= undefined;
2552 function prepareConfig (config
) {
2553 var input
= config
._i
,
2556 config
._locale
= config
._locale
|| getLocale(config
._l
);
2558 if (input
=== null || (format
=== undefined && input
=== '')) {
2559 return createInvalid({nullInput
: true});
2562 if (typeof input
=== 'string') {
2563 config
._i
= input
= config
._locale
.preparse(input
);
2566 if (isMoment(input
)) {
2567 return new Moment(checkOverflow(input
));
2568 } else if (isDate(input
)) {
2570 } else if (isArray(format
)) {
2571 configFromStringAndArray(config
);
2572 } else if (format
) {
2573 configFromStringAndFormat(config
);
2575 configFromInput(config
);
2578 if (!isValid(config
)) {
2585 function configFromInput(config
) {
2586 var input
= config
._i
;
2587 if (isUndefined(input
)) {
2588 config
._d
= new Date(hooks
.now());
2589 } else if (isDate(input
)) {
2590 config
._d
= new Date(input
.valueOf());
2591 } else if (typeof input
=== 'string') {
2592 configFromString(config
);
2593 } else if (isArray(input
)) {
2594 config
._a
= map(input
.slice(0), function (obj
) {
2595 return parseInt(obj
, 10);
2597 configFromArray(config
);
2598 } else if (isObject(input
)) {
2599 configFromObject(config
);
2600 } else if (isNumber(input
)) {
2601 // from milliseconds
2602 config
._d
= new Date(input
);
2604 hooks
.createFromInputFallback(config
);
2608 function createLocalOrUTC (input
, format
, locale
, strict
, isUTC
) {
2611 if (locale
=== true || locale
=== false) {
2616 if ((isObject(input
) && isObjectEmpty(input
)) ||
2617 (isArray(input
) && input
.length
=== 0)) {
2620 // object construction must be done this way.
2621 // https://github.com/moment/moment/issues/1423
2622 c
._isAMomentObject
= true;
2623 c
._useUTC
= c
._isUTC
= isUTC
;
2629 return createFromConfig(c
);
2632 function createLocal (input
, format
, locale
, strict
) {
2633 return createLocalOrUTC(input
, format
, locale
, strict
, false);
2636 var prototypeMin
= deprecate(
2637 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
2639 var other
= createLocal
.apply(null, arguments
);
2640 if (this.isValid() && other
.isValid()) {
2641 return other
< this ? this : other
;
2643 return createInvalid();
2648 var prototypeMax
= deprecate(
2649 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
2651 var other
= createLocal
.apply(null, arguments
);
2652 if (this.isValid() && other
.isValid()) {
2653 return other
> this ? this : other
;
2655 return createInvalid();
2660 // Pick a moment m from moments so that m[fn](other) is true for all
2661 // other. This relies on the function fn to be transitive.
2663 // moments should either be an array of moment objects or an array, whose
2664 // first element is an array of moment objects.
2665 function pickBy(fn
, moments
) {
2667 if (moments
.length
=== 1 && isArray(moments
[0])) {
2668 moments
= moments
[0];
2670 if (!moments
.length
) {
2671 return createLocal();
2674 for (i
= 1; i
< moments
.length
; ++i
) {
2675 if (!moments
[i
].isValid() || moments
[i
][fn
](res
)) {
2682 // TODO: Use [].sort instead?
2684 var args
= [].slice
.call(arguments
, 0);
2686 return pickBy('isBefore', args
);
2690 var args
= [].slice
.call(arguments
, 0);
2692 return pickBy('isAfter', args
);
2695 var now = function () {
2696 return Date
.now
? Date
.now() : +(new Date());
2699 var ordering
= ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
2701 function isDurationValid(m
) {
2702 for (var key
in m
) {
2703 if (!(indexOf
.call(ordering
, key
) !== -1 && (m
[key
] == null || !isNaN(m
[key
])))) {
2708 var unitHasDecimal
= false;
2709 for (var i
= 0; i
< ordering
.length
; ++i
) {
2710 if (m
[ordering
[i
]]) {
2711 if (unitHasDecimal
) {
2712 return false; // only allow non-integers for smallest unit
2714 if (parseFloat(m
[ordering
[i
]]) !== toInt(m
[ordering
[i
]])) {
2715 unitHasDecimal
= true;
2723 function isValid
$1() {
2724 return this._isValid
;
2727 function createInvalid
$1() {
2728 return createDuration(NaN
);
2731 function Duration (duration
) {
2732 var normalizedInput
= normalizeObjectUnits(duration
),
2733 years
= normalizedInput
.year
|| 0,
2734 quarters
= normalizedInput
.quarter
|| 0,
2735 months
= normalizedInput
.month
|| 0,
2736 weeks
= normalizedInput
.week
|| 0,
2737 days
= normalizedInput
.day
|| 0,
2738 hours
= normalizedInput
.hour
|| 0,
2739 minutes
= normalizedInput
.minute
|| 0,
2740 seconds
= normalizedInput
.second
|| 0,
2741 milliseconds
= normalizedInput
.millisecond
|| 0;
2743 this._isValid
= isDurationValid(normalizedInput
);
2745 // representation for dateAddRemove
2746 this._milliseconds
= +milliseconds
+
2747 seconds
* 1e3
+ // 1000
2748 minutes
* 6e4
+ // 1000 * 60
2749 hours
* 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
2750 // Because of dateAddRemove treats 24 hours as different from a
2751 // day when working around DST, we need to store them separately
2752 this._days
= +days
+
2754 // It is impossible to translate months into days without knowing
2755 // which months you are are talking about, so we have to store
2757 this._months
= +months
+
2763 this._locale
= getLocale();
2768 function isDuration (obj
) {
2769 return obj
instanceof Duration
;
2772 function absRound (number
) {
2774 return Math
.round(-1 * number
) * -1;
2776 return Math
.round(number
);
2782 function offset (token
, separator
) {
2783 addFormatToken(token
, 0, 0, function () {
2784 var offset
= this.utcOffset();
2790 return sign
+ zeroFill(~~(offset
/ 60), 2) + separator
+ zeroFill(~~(offset
) % 60, 2);
2799 addRegexToken('Z', matchShortOffset
);
2800 addRegexToken('ZZ', matchShortOffset
);
2801 addParseToken(['Z', 'ZZ'], function (input
, array
, config
) {
2802 config
._useUTC
= true;
2803 config
._tzm
= offsetFromString(matchShortOffset
, input
);
2809 // '+10:00' > ['10', '00']
2810 // '-1530' > ['-15', '30']
2811 var chunkOffset
= /([\+\-]|\d\d)/gi;
2813 function offsetFromString(matcher
, string
) {
2814 var matches
= (string
|| '').match(matcher
);
2816 if (matches
=== null) {
2820 var chunk
= matches
[matches
.length
- 1] || [];
2821 var parts
= (chunk
+ '').match(chunkOffset
) || ['-', 0, 0];
2822 var minutes
= +(parts
[1] * 60) + toInt(parts
[2]);
2824 return minutes
=== 0 ?
2826 parts
[0] === '+' ? minutes
: -minutes
;
2829 // Return a moment from input, that is local/utc/zone equivalent to model.
2830 function cloneWithOffset(input
, model
) {
2833 res
= model
.clone();
2834 diff
= (isMoment(input
) || isDate(input
) ? input
.valueOf() : createLocal(input
).valueOf()) - res
.valueOf();
2835 // Use low-level api, because this fn is low-level api.
2836 res
._d
.setTime(res
._d
.valueOf() + diff
);
2837 hooks
.updateOffset(res
, false);
2840 return createLocal(input
).local();
2844 function getDateOffset (m
) {
2845 // On Firefox.24 Date#getTimezoneOffset returns a floating point.
2846 // https://github.com/moment/moment/pull/1871
2847 return -Math
.round(m
._d
.getTimezoneOffset() / 15) * 15;
2852 // This function will be called whenever a moment is mutated.
2853 // It is intended to keep the offset in sync with the timezone.
2854 hooks
.updateOffset = function () {};
2858 // keepLocalTime = true means only change the timezone, without
2859 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
2860 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
2861 // +0200, so we adjust the time as needed, to be valid.
2863 // Keeping the time actually adds/subtracts (one hour)
2864 // from the actual represented time. That is why we call updateOffset
2865 // a second time. In case it wants us to change the offset again
2866 // _changeInProgress == true case, then we have to adjust, because
2867 // there is no such time in the given timezone.
2868 function getSetOffset (input
, keepLocalTime
, keepMinutes
) {
2869 var offset
= this._offset
|| 0,
2871 if (!this.isValid()) {
2872 return input
!= null ? this : NaN
;
2874 if (input
!= null) {
2875 if (typeof input
=== 'string') {
2876 input
= offsetFromString(matchShortOffset
, input
);
2877 if (input
=== null) {
2880 } else if (Math
.abs(input
) < 16 && !keepMinutes
) {
2883 if (!this._isUTC
&& keepLocalTime
) {
2884 localAdjust
= getDateOffset(this);
2886 this._offset
= input
;
2888 if (localAdjust
!= null) {
2889 this.add(localAdjust
, 'm');
2891 if (offset
!== input
) {
2892 if (!keepLocalTime
|| this._changeInProgress
) {
2893 addSubtract(this, createDuration(input
- offset
, 'm'), 1, false);
2894 } else if (!this._changeInProgress
) {
2895 this._changeInProgress
= true;
2896 hooks
.updateOffset(this, true);
2897 this._changeInProgress
= null;
2902 return this._isUTC
? offset
: getDateOffset(this);
2906 function getSetZone (input
, keepLocalTime
) {
2907 if (input
!= null) {
2908 if (typeof input
!== 'string') {
2912 this.utcOffset(input
, keepLocalTime
);
2916 return -this.utcOffset();
2920 function setOffsetToUTC (keepLocalTime
) {
2921 return this.utcOffset(0, keepLocalTime
);
2924 function setOffsetToLocal (keepLocalTime
) {
2926 this.utcOffset(0, keepLocalTime
);
2927 this._isUTC
= false;
2929 if (keepLocalTime
) {
2930 this.subtract(getDateOffset(this), 'm');
2936 function setOffsetToParsedOffset () {
2937 if (this._tzm
!= null) {
2938 this.utcOffset(this._tzm
, false, true);
2939 } else if (typeof this._i
=== 'string') {
2940 var tZone
= offsetFromString(matchOffset
, this._i
);
2941 if (tZone
!= null) {
2942 this.utcOffset(tZone
);
2945 this.utcOffset(0, true);
2951 function hasAlignedHourOffset (input
) {
2952 if (!this.isValid()) {
2955 input
= input
? createLocal(input
).utcOffset() : 0;
2957 return (this.utcOffset() - input
) % 60 === 0;
2960 function isDaylightSavingTime () {
2962 this.utcOffset() > this.clone().month(0).utcOffset() ||
2963 this.utcOffset() > this.clone().month(5).utcOffset()
2967 function isDaylightSavingTimeShifted () {
2968 if (!isUndefined(this._isDSTShifted
)) {
2969 return this._isDSTShifted
;
2974 copyConfig(c
, this);
2975 c
= prepareConfig(c
);
2978 var other
= c
._isUTC
? createUTC(c
._a
) : createLocal(c
._a
);
2979 this._isDSTShifted
= this.isValid() &&
2980 compareArrays(c
._a
, other
.toArray()) > 0;
2982 this._isDSTShifted
= false;
2985 return this._isDSTShifted
;
2988 function isLocal () {
2989 return this.isValid() ? !this._isUTC
: false;
2992 function isUtcOffset () {
2993 return this.isValid() ? this._isUTC
: false;
2997 return this.isValid() ? this._isUTC
&& this._offset
=== 0 : false;
3000 // ASP.NET json date format regex
3001 var aspNetRegex
= /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
3003 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
3004 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
3005 // and further modified to allow for strings containing both week and day
3006 var isoRegex
= /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
3008 function createDuration (input
, key
) {
3009 var duration
= input
,
3010 // matching against regexp is expensive, do it on demand
3016 if (isDuration(input
)) {
3018 ms
: input
._milliseconds
,
3022 } else if (isNumber(input
)) {
3025 duration
[key
] = input
;
3027 duration
.milliseconds
= input
;
3029 } else if (!!(match
= aspNetRegex
.exec(input
))) {
3030 sign
= (match
[1] === '-') ? -1 : 1;
3033 d
: toInt(match
[DATE
]) * sign
,
3034 h
: toInt(match
[HOUR
]) * sign
,
3035 m
: toInt(match
[MINUTE
]) * sign
,
3036 s
: toInt(match
[SECOND
]) * sign
,
3037 ms
: toInt(absRound(match
[MILLISECOND
] * 1000)) * sign
// the millisecond decimal point is included in the match
3039 } else if (!!(match
= isoRegex
.exec(input
))) {
3040 sign
= (match
[1] === '-') ? -1 : (match
[1] === '+') ? 1 : 1;
3042 y
: parseIso(match
[2], sign
),
3043 M
: parseIso(match
[3], sign
),
3044 w
: parseIso(match
[4], sign
),
3045 d
: parseIso(match
[5], sign
),
3046 h
: parseIso(match
[6], sign
),
3047 m
: parseIso(match
[7], sign
),
3048 s
: parseIso(match
[8], sign
)
3050 } else if (duration
== null) {// checks for null or undefined
3052 } else if (typeof duration
=== 'object' && ('from' in duration
|| 'to' in duration
)) {
3053 diffRes
= momentsDifference(createLocal(duration
.from), createLocal(duration
.to
));
3056 duration
.ms
= diffRes
.milliseconds
;
3057 duration
.M
= diffRes
.months
;
3060 ret
= new Duration(duration
);
3062 if (isDuration(input
) && hasOwnProp(input
, '_locale')) {
3063 ret
._locale
= input
._locale
;
3069 createDuration
.fn
= Duration
.prototype;
3070 createDuration
.invalid
= createInvalid
$1;
3072 function parseIso (inp
, sign
) {
3073 // We'd normally use ~~inp for this, but unfortunately it also
3074 // converts floats to ints.
3075 // inp may be undefined, so careful calling replace on it.
3076 var res
= inp
&& parseFloat(inp
.replace(',', '.'));
3077 // apply sign while we're at it
3078 return (isNaN(res
) ? 0 : res
) * sign
;
3081 function positiveMomentsDifference(base
, other
) {
3082 var res
= {milliseconds
: 0, months
: 0};
3084 res
.months
= other
.month() - base
.month() +
3085 (other
.year() - base
.year()) * 12;
3086 if (base
.clone().add(res
.months
, 'M').isAfter(other
)) {
3090 res
.milliseconds
= +other
- +(base
.clone().add(res
.months
, 'M'));
3095 function momentsDifference(base
, other
) {
3097 if (!(base
.isValid() && other
.isValid())) {
3098 return {milliseconds
: 0, months
: 0};
3101 other
= cloneWithOffset(other
, base
);
3102 if (base
.isBefore(other
)) {
3103 res
= positiveMomentsDifference(base
, other
);
3105 res
= positiveMomentsDifference(other
, base
);
3106 res
.milliseconds
= -res
.milliseconds
;
3107 res
.months
= -res
.months
;
3113 // TODO: remove 'name' arg after deprecation is removed
3114 function createAdder(direction
, name
) {
3115 return function (val
, period
) {
3117 //invert the arguments, but complain about it
3118 if (period
!== null && !isNaN(+period
)) {
3119 deprecateSimple(name
, 'moment().' + name
+ '(period, number) is deprecated. Please use moment().' + name
+ '(number, period). ' +
3120 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
3121 tmp
= val
; val
= period
; period
= tmp
;
3124 val
= typeof val
=== 'string' ? +val
: val
;
3125 dur
= createDuration(val
, period
);
3126 addSubtract(this, dur
, direction
);
3131 function addSubtract (mom
, duration
, isAdding
, updateOffset
) {
3132 var milliseconds
= duration
._milliseconds
,
3133 days
= absRound(duration
._days
),
3134 months
= absRound(duration
._months
);
3136 if (!mom
.isValid()) {
3141 updateOffset
= updateOffset
== null ? true : updateOffset
;
3144 setMonth(mom
, get(mom
, 'Month') + months
* isAdding
);
3147 set$1(mom
, 'Date', get(mom
, 'Date') + days
* isAdding
);
3150 mom
._d
.setTime(mom
._d
.valueOf() + milliseconds
* isAdding
);
3153 hooks
.updateOffset(mom
, days
|| months
);
3157 var add
= createAdder(1, 'add');
3158 var subtract
= createAdder(-1, 'subtract');
3160 function getCalendarFormat(myMoment
, now
) {
3161 var diff
= myMoment
.diff(now
, 'days', true);
3162 return diff
< -6 ? 'sameElse' :
3163 diff
< -1 ? 'lastWeek' :
3164 diff
< 0 ? 'lastDay' :
3165 diff
< 1 ? 'sameDay' :
3166 diff
< 2 ? 'nextDay' :
3167 diff
< 7 ? 'nextWeek' : 'sameElse';
3170 function calendar
$1 (time
, formats
) {
3171 // We want to compare the start of today, vs this.
3172 // Getting start-of-today depends on whether we're local/utc/offset or not.
3173 var now
= time
|| createLocal(),
3174 sod
= cloneWithOffset(now
, this).startOf('day'),
3175 format
= hooks
.calendarFormat(this, sod
) || 'sameElse';
3177 var output
= formats
&& (isFunction(formats
[format
]) ? formats
[format
].call(this, now
) : formats
[format
]);
3179 return this.format(output
|| this.localeData().calendar(format
, this, createLocal(now
)));
3183 return new Moment(this);
3186 function isAfter (input
, units
) {
3187 var localInput
= isMoment(input
) ? input
: createLocal(input
);
3188 if (!(this.isValid() && localInput
.isValid())) {
3191 units
= normalizeUnits(!isUndefined(units
) ? units
: 'millisecond');
3192 if (units
=== 'millisecond') {
3193 return this.valueOf() > localInput
.valueOf();
3195 return localInput
.valueOf() < this.clone().startOf(units
).valueOf();
3199 function isBefore (input
, units
) {
3200 var localInput
= isMoment(input
) ? input
: createLocal(input
);
3201 if (!(this.isValid() && localInput
.isValid())) {
3204 units
= normalizeUnits(!isUndefined(units
) ? units
: 'millisecond');
3205 if (units
=== 'millisecond') {
3206 return this.valueOf() < localInput
.valueOf();
3208 return this.clone().endOf(units
).valueOf() < localInput
.valueOf();
3212 function isBetween (from, to
, units
, inclusivity
) {
3213 inclusivity
= inclusivity
|| '()';
3214 return (inclusivity
[0] === '(' ? this.isAfter(from, units
) : !this.isBefore(from, units
)) &&
3215 (inclusivity
[1] === ')' ? this.isBefore(to
, units
) : !this.isAfter(to
, units
));
3218 function isSame (input
, units
) {
3219 var localInput
= isMoment(input
) ? input
: createLocal(input
),
3221 if (!(this.isValid() && localInput
.isValid())) {
3224 units
= normalizeUnits(units
|| 'millisecond');
3225 if (units
=== 'millisecond') {
3226 return this.valueOf() === localInput
.valueOf();
3228 inputMs
= localInput
.valueOf();
3229 return this.clone().startOf(units
).valueOf() <= inputMs
&& inputMs
<= this.clone().endOf(units
).valueOf();
3233 function isSameOrAfter (input
, units
) {
3234 return this.isSame(input
, units
) || this.isAfter(input
,units
);
3237 function isSameOrBefore (input
, units
) {
3238 return this.isSame(input
, units
) || this.isBefore(input
,units
);
3241 function diff (input
, units
, asFloat
) {
3246 if (!this.isValid()) {
3250 that
= cloneWithOffset(input
, this);
3252 if (!that
.isValid()) {
3256 zoneDelta
= (that
.utcOffset() - this.utcOffset()) * 6e4
;
3258 units
= normalizeUnits(units
);
3261 case 'year': output
= monthDiff(this, that
) / 12; break;
3262 case 'month': output
= monthDiff(this, that
); break;
3263 case 'quarter': output
= monthDiff(this, that
) / 3; break;
3264 case 'second': output
= (this - that
) / 1e3
; break; // 1000
3265 case 'minute': output
= (this - that
) / 6e4
; break; // 1000 * 60
3266 case 'hour': output
= (this - that
) / 36e5
; break; // 1000 * 60 * 60
3267 case 'day': output
= (this - that
- zoneDelta
) / 864e5
; break; // 1000 * 60 * 60 * 24, negate dst
3268 case 'week': output
= (this - that
- zoneDelta
) / 6048e5
; break; // 1000 * 60 * 60 * 24 * 7, negate dst
3269 default: output
= this - that
;
3272 return asFloat
? output
: absFloor(output
);
3275 function monthDiff (a
, b
) {
3276 // difference in months
3277 var wholeMonthDiff
= ((b
.year() - a
.year()) * 12) + (b
.month() - a
.month()),
3278 // b is in (anchor - 1 month, anchor + 1 month)
3279 anchor
= a
.clone().add(wholeMonthDiff
, 'months'),
3282 if (b
- anchor
< 0) {
3283 anchor2
= a
.clone().add(wholeMonthDiff
- 1, 'months');
3284 // linear across the month
3285 adjust
= (b
- anchor
) / (anchor
- anchor2
);
3287 anchor2
= a
.clone().add(wholeMonthDiff
+ 1, 'months');
3288 // linear across the month
3289 adjust
= (b
- anchor
) / (anchor2
- anchor
);
3292 //check for negative zero, return zero if negative zero
3293 return -(wholeMonthDiff
+ adjust
) || 0;
3296 hooks
.defaultFormat
= 'YYYY-MM-DDTHH:mm:ssZ';
3297 hooks
.defaultFormatUtc
= 'YYYY-MM-DDTHH:mm:ss[Z]';
3299 function toString () {
3300 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
3303 function toISOString(keepOffset
) {
3304 if (!this.isValid()) {
3307 var utc
= keepOffset
!== true;
3308 var m
= utc
? this.clone().utc() : this;
3309 if (m
.year() < 0 || m
.year() > 9999) {
3310 return formatMoment(m
, utc
? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
3312 if (isFunction(Date
.prototype.toISOString
)) {
3313 // native implementation is ~50x faster, use it when we can
3315 return this.toDate().toISOString();
3317 return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m
, 'Z'));
3320 return formatMoment(m
, utc
? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
3324 * Return a human readable representation of a moment that can
3325 * also be evaluated to get a new moment which is the same
3327 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
3329 function inspect () {
3330 if (!this.isValid()) {
3331 return 'moment.invalid(/* ' + this._i
+ ' */)';
3333 var func
= 'moment';
3335 if (!this.isLocal()) {
3336 func
= this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
3339 var prefix
= '[' + func
+ '("]';
3340 var year
= (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
3341 var datetime
= '-MM-DD[T]HH:mm:ss.SSS';
3342 var suffix
= zone
+ '[")]';
3344 return this.format(prefix
+ year
+ datetime
+ suffix
);
3347 function format (inputString
) {
3349 inputString
= this.isUtc() ? hooks
.defaultFormatUtc
: hooks
.defaultFormat
;
3351 var output
= formatMoment(this, inputString
);
3352 return this.localeData().postformat(output
);
3355 function from (time
, withoutSuffix
) {
3356 if (this.isValid() &&
3357 ((isMoment(time
) && time
.isValid()) ||
3358 createLocal(time
).isValid())) {
3359 return createDuration({to
: this, from: time
}).locale(this.locale()).humanize(!withoutSuffix
);
3361 return this.localeData().invalidDate();
3365 function fromNow (withoutSuffix
) {
3366 return this.from(createLocal(), withoutSuffix
);
3369 function to (time
, withoutSuffix
) {
3370 if (this.isValid() &&
3371 ((isMoment(time
) && time
.isValid()) ||
3372 createLocal(time
).isValid())) {
3373 return createDuration({from: this, to
: time
}).locale(this.locale()).humanize(!withoutSuffix
);
3375 return this.localeData().invalidDate();
3379 function toNow (withoutSuffix
) {
3380 return this.to(createLocal(), withoutSuffix
);
3383 // If passed a locale key, it will set the locale for this
3384 // instance. Otherwise, it will return the locale configuration
3385 // variables for this instance.
3386 function locale (key
) {
3389 if (key
=== undefined) {
3390 return this._locale
._abbr
;
3392 newLocaleData
= getLocale(key
);
3393 if (newLocaleData
!= null) {
3394 this._locale
= newLocaleData
;
3400 var lang
= deprecate(
3401 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
3403 if (key
=== undefined) {
3404 return this.localeData();
3406 return this.locale(key
);
3411 function localeData () {
3412 return this._locale
;
3415 function startOf (units
) {
3416 units
= normalizeUnits(units
);
3417 // the following switch intentionally omits break keywords
3418 // to utilize falling through the cases.
3440 this.milliseconds(0);
3443 // weeks are a special case
3444 if (units
=== 'week') {
3447 if (units
=== 'isoWeek') {
3451 // quarters are also special
3452 if (units
=== 'quarter') {
3453 this.month(Math
.floor(this.month() / 3) * 3);
3459 function endOf (units
) {
3460 units
= normalizeUnits(units
);
3461 if (units
=== undefined || units
=== 'millisecond') {
3465 // 'date' is an alias for 'day', so it should be considered as such.
3466 if (units
=== 'date') {
3470 return this.startOf(units
).add(1, (units
=== 'isoWeek' ? 'week' : units
)).subtract(1, 'ms');
3473 function valueOf () {
3474 return this._d
.valueOf() - ((this._offset
|| 0) * 60000);
3478 return Math
.floor(this.valueOf() / 1000);
3481 function toDate () {
3482 return new Date(this.valueOf());
3485 function toArray () {
3487 return [m
.year(), m
.month(), m
.date(), m
.hour(), m
.minute(), m
.second(), m
.millisecond()];
3490 function toObject () {
3497 minutes
: m
.minutes(),
3498 seconds
: m
.seconds(),
3499 milliseconds
: m
.milliseconds()
3503 function toJSON () {
3504 // new Date(NaN).toJSON() === null
3505 return this.isValid() ? this.toISOString() : null;
3508 function isValid
$2 () {
3509 return isValid(this);
3512 function parsingFlags () {
3513 return extend({}, getParsingFlags(this));
3516 function invalidAt () {
3517 return getParsingFlags(this).overflow
;
3520 function creationData() {
3524 locale
: this._locale
,
3526 strict
: this._strict
3532 addFormatToken(0, ['gg', 2], 0, function () {
3533 return this.weekYear() % 100;
3536 addFormatToken(0, ['GG', 2], 0, function () {
3537 return this.isoWeekYear() % 100;
3540 function addWeekYearFormatToken (token
, getter
) {
3541 addFormatToken(0, [token
, token
.length
], 0, getter
);
3544 addWeekYearFormatToken('gggg', 'weekYear');
3545 addWeekYearFormatToken('ggggg', 'weekYear');
3546 addWeekYearFormatToken('GGGG', 'isoWeekYear');
3547 addWeekYearFormatToken('GGGGG', 'isoWeekYear');
3551 addUnitAlias('weekYear', 'gg');
3552 addUnitAlias('isoWeekYear', 'GG');
3556 addUnitPriority('weekYear', 1);
3557 addUnitPriority('isoWeekYear', 1);
3562 addRegexToken('G', matchSigned
);
3563 addRegexToken('g', matchSigned
);
3564 addRegexToken('GG', match1to2
, match2
);
3565 addRegexToken('gg', match1to2
, match2
);
3566 addRegexToken('GGGG', match1to4
, match4
);
3567 addRegexToken('gggg', match1to4
, match4
);
3568 addRegexToken('GGGGG', match1to6
, match6
);
3569 addRegexToken('ggggg', match1to6
, match6
);
3571 addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input
, week
, config
, token
) {
3572 week
[token
.substr(0, 2)] = toInt(input
);
3575 addWeekParseToken(['gg', 'GG'], function (input
, week
, config
, token
) {
3576 week
[token
] = hooks
.parseTwoDigitYear(input
);
3581 function getSetWeekYear (input
) {
3582 return getSetWeekYearHelper
.call(this,
3586 this.localeData()._week
.dow
,
3587 this.localeData()._week
.doy
);
3590 function getSetISOWeekYear (input
) {
3591 return getSetWeekYearHelper
.call(this,
3592 input
, this.isoWeek(), this.isoWeekday(), 1, 4);
3595 function getISOWeeksInYear () {
3596 return weeksInYear(this.year(), 1, 4);
3599 function getWeeksInYear () {
3600 var weekInfo
= this.localeData()._week
;
3601 return weeksInYear(this.year(), weekInfo
.dow
, weekInfo
.doy
);
3604 function getSetWeekYearHelper(input
, week
, weekday
, dow
, doy
) {
3606 if (input
== null) {
3607 return weekOfYear(this, dow
, doy
).year
;
3609 weeksTarget
= weeksInYear(input
, dow
, doy
);
3610 if (week
> weeksTarget
) {
3613 return setWeekAll
.call(this, input
, week
, weekday
, dow
, doy
);
3617 function setWeekAll(weekYear
, week
, weekday
, dow
, doy
) {
3618 var dayOfYearData
= dayOfYearFromWeeks(weekYear
, week
, weekday
, dow
, doy
),
3619 date
= createUTCDate(dayOfYearData
.year
, 0, dayOfYearData
.dayOfYear
);
3621 this.year(date
.getUTCFullYear());
3622 this.month(date
.getUTCMonth());
3623 this.date(date
.getUTCDate());
3629 addFormatToken('Q', 0, 'Qo', 'quarter');
3633 addUnitAlias('quarter', 'Q');
3637 addUnitPriority('quarter', 7);
3641 addRegexToken('Q', match1
);
3642 addParseToken('Q', function (input
, array
) {
3643 array
[MONTH
] = (toInt(input
) - 1) * 3;
3648 function getSetQuarter (input
) {
3649 return input
== null ? Math
.ceil((this.month() + 1) / 3) : this.month((input
- 1) * 3 + this.month() % 3);
3654 addFormatToken('D', ['DD', 2], 'Do', 'date');
3658 addUnitAlias('date', 'D');
3661 addUnitPriority('date', 9);
3665 addRegexToken('D', match1to2
);
3666 addRegexToken('DD', match1to2
, match2
);
3667 addRegexToken('Do', function (isStrict
, locale
) {
3668 // TODO: Remove "ordinalParse" fallback in next major release.
3670 (locale
._dayOfMonthOrdinalParse
|| locale
._ordinalParse
) :
3671 locale
._dayOfMonthOrdinalParseLenient
;
3674 addParseToken(['D', 'DD'], DATE
);
3675 addParseToken('Do', function (input
, array
) {
3676 array
[DATE
] = toInt(input
.match(match1to2
)[0]);
3681 var getSetDayOfMonth
= makeGetSet('Date', true);
3685 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
3689 addUnitAlias('dayOfYear', 'DDD');
3692 addUnitPriority('dayOfYear', 4);
3696 addRegexToken('DDD', match1to3
);
3697 addRegexToken('DDDD', match3
);
3698 addParseToken(['DDD', 'DDDD'], function (input
, array
, config
) {
3699 config
._dayOfYear
= toInt(input
);
3706 function getSetDayOfYear (input
) {
3707 var dayOfYear
= Math
.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5
) + 1;
3708 return input
== null ? dayOfYear
: this.add((input
- dayOfYear
), 'd');
3713 addFormatToken('m', ['mm', 2], 0, 'minute');
3717 addUnitAlias('minute', 'm');
3721 addUnitPriority('minute', 14);
3725 addRegexToken('m', match1to2
);
3726 addRegexToken('mm', match1to2
, match2
);
3727 addParseToken(['m', 'mm'], MINUTE
);
3731 var getSetMinute
= makeGetSet('Minutes', false);
3735 addFormatToken('s', ['ss', 2], 0, 'second');
3739 addUnitAlias('second', 's');
3743 addUnitPriority('second', 15);
3747 addRegexToken('s', match1to2
);
3748 addRegexToken('ss', match1to2
, match2
);
3749 addParseToken(['s', 'ss'], SECOND
);
3753 var getSetSecond
= makeGetSet('Seconds', false);
3757 addFormatToken('S', 0, 0, function () {
3758 return ~~(this.millisecond() / 100);
3761 addFormatToken(0, ['SS', 2], 0, function () {
3762 return ~~(this.millisecond() / 10);
3765 addFormatToken(0, ['SSS', 3], 0, 'millisecond');
3766 addFormatToken(0, ['SSSS', 4], 0, function () {
3767 return this.millisecond() * 10;
3769 addFormatToken(0, ['SSSSS', 5], 0, function () {
3770 return this.millisecond() * 100;
3772 addFormatToken(0, ['SSSSSS', 6], 0, function () {
3773 return this.millisecond() * 1000;
3775 addFormatToken(0, ['SSSSSSS', 7], 0, function () {
3776 return this.millisecond() * 10000;
3778 addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
3779 return this.millisecond() * 100000;
3781 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
3782 return this.millisecond() * 1000000;
3788 addUnitAlias('millisecond', 'ms');
3792 addUnitPriority('millisecond', 16);
3796 addRegexToken('S', match1to3
, match1
);
3797 addRegexToken('SS', match1to3
, match2
);
3798 addRegexToken('SSS', match1to3
, match3
);
3801 for (token
= 'SSSS'; token
.length
<= 9; token
+= 'S') {
3802 addRegexToken(token
, matchUnsigned
);
3805 function parseMs(input
, array
) {
3806 array
[MILLISECOND
] = toInt(('0.' + input
) * 1000);
3809 for (token
= 'S'; token
.length
<= 9; token
+= 'S') {
3810 addParseToken(token
, parseMs
);
3814 var getSetMillisecond
= makeGetSet('Milliseconds', false);
3818 addFormatToken('z', 0, 0, 'zoneAbbr');
3819 addFormatToken('zz', 0, 0, 'zoneName');
3823 function getZoneAbbr () {
3824 return this._isUTC
? 'UTC' : '';
3827 function getZoneName () {
3828 return this._isUTC
? 'Coordinated Universal Time' : '';
3831 var proto
= Moment
.prototype;
3834 proto
.calendar
= calendar
$1;
3835 proto
.clone
= clone
;
3837 proto
.endOf
= endOf
;
3838 proto
.format
= format
;
3840 proto
.fromNow
= fromNow
;
3842 proto
.toNow
= toNow
;
3843 proto
.get = stringGet
;
3844 proto
.invalidAt
= invalidAt
;
3845 proto
.isAfter
= isAfter
;
3846 proto
.isBefore
= isBefore
;
3847 proto
.isBetween
= isBetween
;
3848 proto
.isSame
= isSame
;
3849 proto
.isSameOrAfter
= isSameOrAfter
;
3850 proto
.isSameOrBefore
= isSameOrBefore
;
3851 proto
.isValid
= isValid
$2;
3853 proto
.locale
= locale
;
3854 proto
.localeData
= localeData
;
3855 proto
.max
= prototypeMax
;
3856 proto
.min
= prototypeMin
;
3857 proto
.parsingFlags
= parsingFlags
;
3858 proto
.set = stringSet
;
3859 proto
.startOf
= startOf
;
3860 proto
.subtract
= subtract
;
3861 proto
.toArray
= toArray
;
3862 proto
.toObject
= toObject
;
3863 proto
.toDate
= toDate
;
3864 proto
.toISOString
= toISOString
;
3865 proto
.inspect
= inspect
;
3866 proto
.toJSON
= toJSON
;
3867 proto
.toString
= toString
;
3869 proto
.valueOf
= valueOf
;
3870 proto
.creationData
= creationData
;
3871 proto
.year
= getSetYear
;
3872 proto
.isLeapYear
= getIsLeapYear
;
3873 proto
.weekYear
= getSetWeekYear
;
3874 proto
.isoWeekYear
= getSetISOWeekYear
;
3875 proto
.quarter
= proto
.quarters
= getSetQuarter
;
3876 proto
.month
= getSetMonth
;
3877 proto
.daysInMonth
= getDaysInMonth
;
3878 proto
.week
= proto
.weeks
= getSetWeek
;
3879 proto
.isoWeek
= proto
.isoWeeks
= getSetISOWeek
;
3880 proto
.weeksInYear
= getWeeksInYear
;
3881 proto
.isoWeeksInYear
= getISOWeeksInYear
;
3882 proto
.date
= getSetDayOfMonth
;
3883 proto
.day
= proto
.days
= getSetDayOfWeek
;
3884 proto
.weekday
= getSetLocaleDayOfWeek
;
3885 proto
.isoWeekday
= getSetISODayOfWeek
;
3886 proto
.dayOfYear
= getSetDayOfYear
;
3887 proto
.hour
= proto
.hours
= getSetHour
;
3888 proto
.minute
= proto
.minutes
= getSetMinute
;
3889 proto
.second
= proto
.seconds
= getSetSecond
;
3890 proto
.millisecond
= proto
.milliseconds
= getSetMillisecond
;
3891 proto
.utcOffset
= getSetOffset
;
3892 proto
.utc
= setOffsetToUTC
;
3893 proto
.local
= setOffsetToLocal
;
3894 proto
.parseZone
= setOffsetToParsedOffset
;
3895 proto
.hasAlignedHourOffset
= hasAlignedHourOffset
;
3896 proto
.isDST
= isDaylightSavingTime
;
3897 proto
.isLocal
= isLocal
;
3898 proto
.isUtcOffset
= isUtcOffset
;
3899 proto
.isUtc
= isUtc
;
3900 proto
.isUTC
= isUtc
;
3901 proto
.zoneAbbr
= getZoneAbbr
;
3902 proto
.zoneName
= getZoneName
;
3903 proto
.dates
= deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth
);
3904 proto
.months
= deprecate('months accessor is deprecated. Use month instead', getSetMonth
);
3905 proto
.years
= deprecate('years accessor is deprecated. Use year instead', getSetYear
);
3906 proto
.zone
= deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone
);
3907 proto
.isDSTShifted
= deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted
);
3909 function createUnix (input
) {
3910 return createLocal(input
* 1000);
3913 function createInZone () {
3914 return createLocal
.apply(null, arguments
).parseZone();
3917 function preParsePostFormat (string
) {
3921 var proto
$1 = Locale
.prototype;
3923 proto
$1.calendar
= calendar
;
3924 proto
$1.longDateFormat
= longDateFormat
;
3925 proto
$1.invalidDate
= invalidDate
;
3926 proto
$1.ordinal
= ordinal
;
3927 proto
$1.preparse
= preParsePostFormat
;
3928 proto
$1.postformat
= preParsePostFormat
;
3929 proto
$1.relativeTime
= relativeTime
;
3930 proto
$1.pastFuture
= pastFuture
;
3933 proto
$1.months
= localeMonths
;
3934 proto
$1.monthsShort
= localeMonthsShort
;
3935 proto
$1.monthsParse
= localeMonthsParse
;
3936 proto
$1.monthsRegex
= monthsRegex
;
3937 proto
$1.monthsShortRegex
= monthsShortRegex
;
3938 proto
$1.week
= localeWeek
;
3939 proto
$1.firstDayOfYear
= localeFirstDayOfYear
;
3940 proto
$1.firstDayOfWeek
= localeFirstDayOfWeek
;
3942 proto
$1.weekdays
= localeWeekdays
;
3943 proto
$1.weekdaysMin
= localeWeekdaysMin
;
3944 proto
$1.weekdaysShort
= localeWeekdaysShort
;
3945 proto
$1.weekdaysParse
= localeWeekdaysParse
;
3947 proto
$1.weekdaysRegex
= weekdaysRegex
;
3948 proto
$1.weekdaysShortRegex
= weekdaysShortRegex
;
3949 proto
$1.weekdaysMinRegex
= weekdaysMinRegex
;
3951 proto
$1.isPM
= localeIsPM
;
3952 proto
$1.meridiem
= localeMeridiem
;
3954 function get$1 (format
, index
, field
, setter
) {
3955 var locale
= getLocale();
3956 var utc
= createUTC().set(setter
, index
);
3957 return locale
[field
](utc
, format
);
3960 function listMonthsImpl (format
, index
, field
) {
3961 if (isNumber(format
)) {
3966 format
= format
|| '';
3968 if (index
!= null) {
3969 return get$1(format
, index
, field
, 'month');
3974 for (i
= 0; i
< 12; i
++) {
3975 out
[i
] = get$1(format
, i
, field
, 'month');
3988 function listWeekdaysImpl (localeSorted
, format
, index
, field
) {
3989 if (typeof localeSorted
=== 'boolean') {
3990 if (isNumber(format
)) {
3995 format
= format
|| '';
3997 format
= localeSorted
;
3999 localeSorted
= false;
4001 if (isNumber(format
)) {
4006 format
= format
|| '';
4009 var locale
= getLocale(),
4010 shift
= localeSorted
? locale
._week
.dow
: 0;
4012 if (index
!= null) {
4013 return get$1(format
, (index
+ shift
) % 7, field
, 'day');
4018 for (i
= 0; i
< 7; i
++) {
4019 out
[i
] = get$1(format
, (i
+ shift
) % 7, field
, 'day');
4024 function listMonths (format
, index
) {
4025 return listMonthsImpl(format
, index
, 'months');
4028 function listMonthsShort (format
, index
) {
4029 return listMonthsImpl(format
, index
, 'monthsShort');
4032 function listWeekdays (localeSorted
, format
, index
) {
4033 return listWeekdaysImpl(localeSorted
, format
, index
, 'weekdays');
4036 function listWeekdaysShort (localeSorted
, format
, index
) {
4037 return listWeekdaysImpl(localeSorted
, format
, index
, 'weekdaysShort');
4040 function listWeekdaysMin (localeSorted
, format
, index
) {
4041 return listWeekdaysImpl(localeSorted
, format
, index
, 'weekdaysMin');
4044 getSetGlobalLocale('en', {
4045 dayOfMonthOrdinalParse
: /\d{1,2}(th|st|nd|rd)/,
4046 ordinal : function (number
) {
4047 var b
= number
% 10,
4048 output
= (toInt(number
% 100 / 10) === 1) ? 'th' :
4051 (b
=== 3) ? 'rd' : 'th';
4052 return number
+ output
;
4056 // Side effect imports
4058 hooks
.lang
= deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale
);
4059 hooks
.langData
= deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale
);
4061 var mathAbs
= Math
.abs
;
4064 var data
= this._data
;
4066 this._milliseconds
= mathAbs(this._milliseconds
);
4067 this._days
= mathAbs(this._days
);
4068 this._months
= mathAbs(this._months
);
4070 data
.milliseconds
= mathAbs(data
.milliseconds
);
4071 data
.seconds
= mathAbs(data
.seconds
);
4072 data
.minutes
= mathAbs(data
.minutes
);
4073 data
.hours
= mathAbs(data
.hours
);
4074 data
.months
= mathAbs(data
.months
);
4075 data
.years
= mathAbs(data
.years
);
4080 function addSubtract
$1 (duration
, input
, value
, direction
) {
4081 var other
= createDuration(input
, value
);
4083 duration
._milliseconds
+= direction
* other
._milliseconds
;
4084 duration
._days
+= direction
* other
._days
;
4085 duration
._months
+= direction
* other
._months
;
4087 return duration
._bubble();
4090 // supports only 2.0-style add(1, 's') or add(duration)
4091 function add
$1 (input
, value
) {
4092 return addSubtract
$1(this, input
, value
, 1);
4095 // supports only 2.0-style subtract(1, 's') or subtract(duration)
4096 function subtract
$1 (input
, value
) {
4097 return addSubtract
$1(this, input
, value
, -1);
4100 function absCeil (number
) {
4102 return Math
.floor(number
);
4104 return Math
.ceil(number
);
4108 function bubble () {
4109 var milliseconds
= this._milliseconds
;
4110 var days
= this._days
;
4111 var months
= this._months
;
4112 var data
= this._data
;
4113 var seconds
, minutes
, hours
, years
, monthsFromDays
;
4115 // if we have a mix of positive and negative values, bubble down first
4116 // check: https://github.com/moment/moment/issues/2166
4117 if (!((milliseconds
>= 0 && days
>= 0 && months
>= 0) ||
4118 (milliseconds
<= 0 && days
<= 0 && months
<= 0))) {
4119 milliseconds
+= absCeil(monthsToDays(months
) + days
) * 864e5
;
4124 // The following code bubbles up values, see the tests for
4125 // examples of what that means.
4126 data
.milliseconds
= milliseconds
% 1000;
4128 seconds
= absFloor(milliseconds
/ 1000);
4129 data
.seconds
= seconds
% 60;
4131 minutes
= absFloor(seconds
/ 60);
4132 data
.minutes
= minutes
% 60;
4134 hours
= absFloor(minutes
/ 60);
4135 data
.hours
= hours
% 24;
4137 days
+= absFloor(hours
/ 24);
4139 // convert days to months
4140 monthsFromDays
= absFloor(daysToMonths(days
));
4141 months
+= monthsFromDays
;
4142 days
-= absCeil(monthsToDays(monthsFromDays
));
4144 // 12 months -> 1 year
4145 years
= absFloor(months
/ 12);
4149 data
.months
= months
;
4155 function daysToMonths (days
) {
4156 // 400 years have 146097 days (taking into account leap year rules)
4157 // 400 years have 12 months === 4800
4158 return days
* 4800 / 146097;
4161 function monthsToDays (months
) {
4162 // the reverse of daysToMonths
4163 return months
* 146097 / 4800;
4166 function as (units
) {
4167 if (!this.isValid()) {
4172 var milliseconds
= this._milliseconds
;
4174 units
= normalizeUnits(units
);
4176 if (units
=== 'month' || units
=== 'year') {
4177 days
= this._days
+ milliseconds
/ 864e5
;
4178 months
= this._months
+ daysToMonths(days
);
4179 return units
=== 'month' ? months
: months
/ 12;
4181 // handle milliseconds separately because of floating point math errors (issue #1867)
4182 days
= this._days
+ Math
.round(monthsToDays(this._months
));
4184 case 'week' : return days
/ 7 + milliseconds
/ 6048e5
;
4185 case 'day' : return days
+ milliseconds
/ 864e5
;
4186 case 'hour' : return days
* 24 + milliseconds
/ 36e5
;
4187 case 'minute' : return days
* 1440 + milliseconds
/ 6e4
;
4188 case 'second' : return days
* 86400 + milliseconds
/ 1000;
4189 // Math.floor prevents floating point math errors here
4190 case 'millisecond': return Math
.floor(days
* 864e5
) + milliseconds
;
4191 default: throw new Error('Unknown unit ' + units
);
4196 // TODO: Use this.as('ms')?
4197 function valueOf
$1 () {
4198 if (!this.isValid()) {
4202 this._milliseconds
+
4203 this._days
* 864e5
+
4204 (this._months
% 12) * 2592e6
+
4205 toInt(this._months
/ 12) * 31536e6
4209 function makeAs (alias
) {
4210 return function () {
4211 return this.as(alias
);
4215 var asMilliseconds
= makeAs('ms');
4216 var asSeconds
= makeAs('s');
4217 var asMinutes
= makeAs('m');
4218 var asHours
= makeAs('h');
4219 var asDays
= makeAs('d');
4220 var asWeeks
= makeAs('w');
4221 var asMonths
= makeAs('M');
4222 var asYears
= makeAs('y');
4224 function clone
$1 () {
4225 return createDuration(this);
4228 function get$2 (units
) {
4229 units
= normalizeUnits(units
);
4230 return this.isValid() ? this[units
+ 's']() : NaN
;
4233 function makeGetter(name
) {
4234 return function () {
4235 return this.isValid() ? this._data
[name
] : NaN
;
4239 var milliseconds
= makeGetter('milliseconds');
4240 var seconds
= makeGetter('seconds');
4241 var minutes
= makeGetter('minutes');
4242 var hours
= makeGetter('hours');
4243 var days
= makeGetter('days');
4244 var months
= makeGetter('months');
4245 var years
= makeGetter('years');
4248 return absFloor(this.days() / 7);
4251 var round
= Math
.round
;
4253 ss
: 44, // a few seconds to seconds
4254 s
: 45, // seconds to minute
4255 m
: 45, // minutes to hour
4256 h
: 22, // hours to day
4257 d
: 26, // days to month
4258 M
: 11 // months to year
4261 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
4262 function substituteTimeAgo(string
, number
, withoutSuffix
, isFuture
, locale
) {
4263 return locale
.relativeTime(number
|| 1, !!withoutSuffix
, string
, isFuture
);
4266 function relativeTime
$1 (posNegDuration
, withoutSuffix
, locale
) {
4267 var duration
= createDuration(posNegDuration
).abs();
4268 var seconds
= round(duration
.as('s'));
4269 var minutes
= round(duration
.as('m'));
4270 var hours
= round(duration
.as('h'));
4271 var days
= round(duration
.as('d'));
4272 var months
= round(duration
.as('M'));
4273 var years
= round(duration
.as('y'));
4275 var a
= seconds
<= thresholds
.ss
&& ['s', seconds
] ||
4276 seconds
< thresholds
.s
&& ['ss', seconds
] ||
4277 minutes
<= 1 && ['m'] ||
4278 minutes
< thresholds
.m
&& ['mm', minutes
] ||
4279 hours
<= 1 && ['h'] ||
4280 hours
< thresholds
.h
&& ['hh', hours
] ||
4281 days
<= 1 && ['d'] ||
4282 days
< thresholds
.d
&& ['dd', days
] ||
4283 months
<= 1 && ['M'] ||
4284 months
< thresholds
.M
&& ['MM', months
] ||
4285 years
<= 1 && ['y'] || ['yy', years
];
4287 a
[2] = withoutSuffix
;
4288 a
[3] = +posNegDuration
> 0;
4290 return substituteTimeAgo
.apply(null, a
);
4293 // This function allows you to set the rounding function for relative time strings
4294 function getSetRelativeTimeRounding (roundingFunction
) {
4295 if (roundingFunction
=== undefined) {
4298 if (typeof(roundingFunction
) === 'function') {
4299 round
= roundingFunction
;
4305 // This function allows you to set a threshold for relative time strings
4306 function getSetRelativeTimeThreshold (threshold
, limit
) {
4307 if (thresholds
[threshold
] === undefined) {
4310 if (limit
=== undefined) {
4311 return thresholds
[threshold
];
4313 thresholds
[threshold
] = limit
;
4314 if (threshold
=== 's') {
4315 thresholds
.ss
= limit
- 1;
4320 function humanize (withSuffix
) {
4321 if (!this.isValid()) {
4322 return this.localeData().invalidDate();
4325 var locale
= this.localeData();
4326 var output
= relativeTime
$1(this, !withSuffix
, locale
);
4329 output
= locale
.pastFuture(+this, output
);
4332 return locale
.postformat(output
);
4335 var abs
$1 = Math
.abs
;
4338 return ((x
> 0) - (x
< 0)) || +x
;
4341 function toISOString
$1() {
4342 // for ISO strings we do not use the normal bubbling rules:
4343 // * milliseconds bubble up until they become hours
4344 // * days do not bubble at all
4345 // * months bubble up until they become years
4346 // This is because there is no context-free conversion between hours and days
4347 // (think of clock changes)
4348 // and also not between days and months (28-31 days per month)
4349 if (!this.isValid()) {
4350 return this.localeData().invalidDate();
4353 var seconds
= abs
$1(this._milliseconds
) / 1000;
4354 var days
= abs
$1(this._days
);
4355 var months
= abs
$1(this._months
);
4356 var minutes
, hours
, years
;
4358 // 3600 seconds -> 60 minutes -> 1 hour
4359 minutes
= absFloor(seconds
/ 60);
4360 hours
= absFloor(minutes
/ 60);
4364 // 12 months -> 1 year
4365 years
= absFloor(months
/ 12);
4369 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
4375 var s
= seconds
? seconds
.toFixed(3).replace(/\.?0+$/, '') : '';
4376 var total
= this.asSeconds();
4379 // this is the same as C#'s (Noda) and python (isodate)...
4380 // but not other JS (goog.date)
4384 var totalSign
= total
< 0 ? '-' : '';
4385 var ymSign
= sign(this._months
) !== sign(total
) ? '-' : '';
4386 var daysSign
= sign(this._days
) !== sign(total
) ? '-' : '';
4387 var hmsSign
= sign(this._milliseconds
) !== sign(total
) ? '-' : '';
4389 return totalSign
+ 'P' +
4390 (Y
? ymSign
+ Y
+ 'Y' : '') +
4391 (M
? ymSign
+ M
+ 'M' : '') +
4392 (D
? daysSign
+ D
+ 'D' : '') +
4393 ((h
|| m
|| s
) ? 'T' : '') +
4394 (h
? hmsSign
+ h
+ 'H' : '') +
4395 (m
? hmsSign
+ m
+ 'M' : '') +
4396 (s
? hmsSign
+ s
+ 'S' : '');
4399 var proto
$2 = Duration
.prototype;
4401 proto
$2.isValid
= isValid
$1;
4403 proto
$2.add
= add
$1;
4404 proto
$2.subtract
= subtract
$1;
4406 proto
$2.asMilliseconds
= asMilliseconds
;
4407 proto
$2.asSeconds
= asSeconds
;
4408 proto
$2.asMinutes
= asMinutes
;
4409 proto
$2.asHours
= asHours
;
4410 proto
$2.asDays
= asDays
;
4411 proto
$2.asWeeks
= asWeeks
;
4412 proto
$2.asMonths
= asMonths
;
4413 proto
$2.asYears
= asYears
;
4414 proto
$2.valueOf
= valueOf
$1;
4415 proto
$2._bubble
= bubble
;
4416 proto
$2.clone
= clone
$1;
4417 proto
$2.get = get$2;
4418 proto
$2.milliseconds
= milliseconds
;
4419 proto
$2.seconds
= seconds
;
4420 proto
$2.minutes
= minutes
;
4421 proto
$2.hours
= hours
;
4422 proto
$2.days
= days
;
4423 proto
$2.weeks
= weeks
;
4424 proto
$2.months
= months
;
4425 proto
$2.years
= years
;
4426 proto
$2.humanize
= humanize
;
4427 proto
$2.toISOString
= toISOString
$1;
4428 proto
$2.toString
= toISOString
$1;
4429 proto
$2.toJSON
= toISOString
$1;
4430 proto
$2.locale
= locale
;
4431 proto
$2.localeData
= localeData
;
4433 proto
$2.toIsoString
= deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString
$1);
4434 proto
$2.lang
= lang
;
4436 // Side effect imports
4440 addFormatToken('X', 0, 0, 'unix');
4441 addFormatToken('x', 0, 0, 'valueOf');
4445 addRegexToken('x', matchSigned
);
4446 addRegexToken('X', matchTimestamp
);
4447 addParseToken('X', function (input
, array
, config
) {
4448 config
._d
= new Date(parseFloat(input
, 10) * 1000);
4450 addParseToken('x', function (input
, array
, config
) {
4451 config
._d
= new Date(toInt(input
));
4454 // Side effect imports
4458 hooks
.version
= '2.22.2';
4460 setHookCallback(createLocal
);
4466 hooks
.utc
= createUTC
;
4467 hooks
.unix
= createUnix
;
4468 hooks
.months
= listMonths
;
4469 hooks
.isDate
= isDate
;
4470 hooks
.locale
= getSetGlobalLocale
;
4471 hooks
.invalid
= createInvalid
;
4472 hooks
.duration
= createDuration
;
4473 hooks
.isMoment
= isMoment
;
4474 hooks
.weekdays
= listWeekdays
;
4475 hooks
.parseZone
= createInZone
;
4476 hooks
.localeData
= getLocale
;
4477 hooks
.isDuration
= isDuration
;
4478 hooks
.monthsShort
= listMonthsShort
;
4479 hooks
.weekdaysMin
= listWeekdaysMin
;
4480 hooks
.defineLocale
= defineLocale
;
4481 hooks
.updateLocale
= updateLocale
;
4482 hooks
.locales
= listLocales
;
4483 hooks
.weekdaysShort
= listWeekdaysShort
;
4484 hooks
.normalizeUnits
= normalizeUnits
;
4485 hooks
.relativeTimeRounding
= getSetRelativeTimeRounding
;
4486 hooks
.relativeTimeThreshold
= getSetRelativeTimeThreshold
;
4487 hooks
.calendarFormat
= getCalendarFormat
;
4488 hooks
.prototype = proto
;
4490 // currently HTML5 input type only supports 24-hour formats
4492 DATETIME_LOCAL
: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" />
4493 DATETIME_LOCAL_SECONDS
: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" />
4494 DATETIME_LOCAL_MS
: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" />
4495 DATE
: 'YYYY-MM-DD', // <input type="date" />
4496 TIME
: 'HH:mm', // <input type="time" />
4497 TIME_SECONDS
: 'HH:mm:ss', // <input type="time" step="1" />
4498 TIME_MS
: 'HH:mm:ss.SSS', // <input type="time" step="0.001" />
4499 WEEK
: 'YYYY-[W]WW', // <input type="week" />
4500 MONTH
: 'YYYY-MM' // <input type="month" />
4503 //! moment.js locale configuration
4505 hooks
.defineLocale('af', {
4506 months
: 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
4507 monthsShort
: 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
4508 weekdays
: 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
4509 weekdaysShort
: 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
4510 weekdaysMin
: 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
4511 meridiemParse
: /vm|nm/i,
4512 isPM : function (input
) {
4513 return /^nm$/i.test(input
);
4515 meridiem : function (hours
, minutes
, isLower
) {
4517 return isLower
? 'vm' : 'VM';
4519 return isLower
? 'nm' : 'NM';
4527 LLL
: 'D MMMM YYYY HH:mm',
4528 LLLL
: 'dddd, D MMMM YYYY HH:mm'
4531 sameDay
: '[Vandag om] LT',
4532 nextDay
: '[Môre om] LT',
4533 nextWeek
: 'dddd [om] LT',
4534 lastDay
: '[Gister om] LT',
4535 lastWeek
: '[Laas] dddd [om] LT',
4541 s
: '\'n paar sekondes',
4554 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
4555 ordinal : function (number
) {
4556 return number
+ ((number
=== 1 || number
=== 8 || number
>= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
4559 dow
: 1, // Maandag is die eerste dag van die week.
4560 doy
: 4 // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
4564 //! moment.js locale configuration
4566 hooks
.defineLocale('ar-dz', {
4567 months
: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4568 monthsShort
: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4569 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4570 weekdaysShort
: 'احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4571 weekdaysMin
: 'أح_إث_ثلا_أر_خم_جم_سب'.split('_'),
4572 weekdaysParseExact
: true,
4578 LLL
: 'D MMMM YYYY HH:mm',
4579 LLLL
: 'dddd D MMMM YYYY HH:mm'
4582 sameDay
: '[اليوم على الساعة] LT',
4583 nextDay
: '[غدا على الساعة] LT',
4584 nextWeek
: 'dddd [على الساعة] LT',
4585 lastDay
: '[أمس على الساعة] LT',
4586 lastWeek
: 'dddd [على الساعة] LT',
4606 dow
: 0, // Sunday is the first day of the week.
4607 doy
: 4 // The week that contains Jan 1st is the first week of the year.
4611 //! moment.js locale configuration
4613 hooks
.defineLocale('ar-kw', {
4614 months
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4615 monthsShort
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4616 weekdays
: 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4617 weekdaysShort
: 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4618 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4619 weekdaysParseExact
: true,
4625 LLL
: 'D MMMM YYYY HH:mm',
4626 LLLL
: 'dddd D MMMM YYYY HH:mm'
4629 sameDay
: '[اليوم على الساعة] LT',
4630 nextDay
: '[غدا على الساعة] LT',
4631 nextWeek
: 'dddd [على الساعة] LT',
4632 lastDay
: '[أمس على الساعة] LT',
4633 lastWeek
: 'dddd [على الساعة] LT',
4653 dow
: 0, // Sunday is the first day of the week.
4654 doy
: 12 // The week that contains Jan 1st is the first week of the year.
4658 //! moment.js locale configuration
4671 }, pluralForm = function (n
) {
4672 return n
=== 0 ? 0 : n
=== 1 ? 1 : n
=== 2 ? 2 : n
% 100 >= 3 && n
% 100 <= 10 ? 3 : n
% 100 >= 11 ? 4 : 5;
4674 s
: ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
4675 m
: ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
4676 h
: ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
4677 d
: ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
4678 M
: ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
4679 y
: ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
4680 }, pluralize = function (u
) {
4681 return function (number
, withoutSuffix
, string
, isFuture
) {
4682 var f
= pluralForm(number
),
4683 str
= plurals
[u
][pluralForm(number
)];
4685 str
= str
[withoutSuffix
? 0 : 1];
4687 return str
.replace(/%d/i, number
);
4704 hooks
.defineLocale('ar-ly', {
4706 monthsShort
: months
$1,
4707 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4708 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4709 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4710 weekdaysParseExact
: true,
4714 L
: 'D/\u200FM/\u200FYYYY',
4716 LLL
: 'D MMMM YYYY HH:mm',
4717 LLLL
: 'dddd D MMMM YYYY HH:mm'
4719 meridiemParse
: /ص|م/,
4720 isPM : function (input
) {
4721 return 'م' === input
;
4723 meridiem : function (hour
, minute
, isLower
) {
4731 sameDay
: '[اليوم عند الساعة] LT',
4732 nextDay
: '[غدًا عند الساعة] LT',
4733 nextWeek
: 'dddd [عند الساعة] LT',
4734 lastDay
: '[أمس عند الساعة] LT',
4735 lastWeek
: 'dddd [عند الساعة] LT',
4742 ss
: pluralize('s'),
4744 mm
: pluralize('m'),
4746 hh
: pluralize('h'),
4748 dd
: pluralize('d'),
4750 MM
: pluralize('M'),
4754 preparse: function (string
) {
4755 return string
.replace(/،/g, ',');
4757 postformat: function (string
) {
4758 return string
.replace(/\d/g, function (match
) {
4759 return symbolMap
[match
];
4760 }).replace(/,/g
, '،');
4763 dow
: 6, // Saturday is the first day of the week.
4764 doy
: 12 // The week that contains Jan 1st is the first week of the year.
4768 //! moment.js locale configuration
4770 hooks
.defineLocale('ar-ma', {
4771 months
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4772 monthsShort
: 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4773 weekdays
: 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4774 weekdaysShort
: 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4775 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4776 weekdaysParseExact
: true,
4782 LLL
: 'D MMMM YYYY HH:mm',
4783 LLLL
: 'dddd D MMMM YYYY HH:mm'
4786 sameDay
: '[اليوم على الساعة] LT',
4787 nextDay
: '[غدا على الساعة] LT',
4788 nextWeek
: 'dddd [على الساعة] LT',
4789 lastDay
: '[أمس على الساعة] LT',
4790 lastWeek
: 'dddd [على الساعة] LT',
4810 dow
: 6, // Saturday is the first day of the week.
4811 doy
: 12 // The week that contains Jan 1st is the first week of the year.
4815 //! moment.js locale configuration
4841 hooks
.defineLocale('ar-sa', {
4842 months
: 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4843 monthsShort
: 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4844 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4845 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4846 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4847 weekdaysParseExact
: true,
4853 LLL
: 'D MMMM YYYY HH:mm',
4854 LLLL
: 'dddd D MMMM YYYY HH:mm'
4856 meridiemParse
: /ص|م/,
4857 isPM : function (input
) {
4858 return 'م' === input
;
4860 meridiem : function (hour
, minute
, isLower
) {
4868 sameDay
: '[اليوم على الساعة] LT',
4869 nextDay
: '[غدا على الساعة] LT',
4870 nextWeek
: 'dddd [على الساعة] LT',
4871 lastDay
: '[أمس على الساعة] LT',
4872 lastWeek
: 'dddd [على الساعة] LT',
4891 preparse: function (string
) {
4892 return string
.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match
) {
4893 return numberMap
[match
];
4894 }).replace(/،/g, ',');
4896 postformat: function (string
) {
4897 return string
.replace(/\d/g, function (match
) {
4898 return symbolMap
$1[match
];
4899 }).replace(/,/g
, '،');
4902 dow
: 0, // Sunday is the first day of the week.
4903 doy
: 6 // The week that contains Jan 1st is the first week of the year.
4907 //! moment.js locale configuration
4909 hooks
.defineLocale('ar-tn', {
4910 months
: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4911 monthsShort
: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4912 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4913 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4914 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4915 weekdaysParseExact
: true,
4921 LLL
: 'D MMMM YYYY HH:mm',
4922 LLLL
: 'dddd D MMMM YYYY HH:mm'
4925 sameDay
: '[اليوم على الساعة] LT',
4926 nextDay
: '[غدا على الساعة] LT',
4927 nextWeek
: 'dddd [على الساعة] LT',
4928 lastDay
: '[أمس على الساعة] LT',
4929 lastWeek
: 'dddd [على الساعة] LT',
4949 dow
: 1, // Monday is the first day of the week.
4950 doy
: 4 // The week that contains Jan 4th is the first week of the year.
4954 //! moment.js locale configuration
4978 }, pluralForm
$1 = function (n
) {
4979 return n
=== 0 ? 0 : n
=== 1 ? 1 : n
=== 2 ? 2 : n
% 100 >= 3 && n
% 100 <= 10 ? 3 : n
% 100 >= 11 ? 4 : 5;
4981 s
: ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
4982 m
: ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
4983 h
: ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
4984 d
: ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
4985 M
: ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
4986 y
: ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
4987 }, pluralize
$1 = function (u
) {
4988 return function (number
, withoutSuffix
, string
, isFuture
) {
4989 var f
= pluralForm
$1(number
),
4990 str
= plurals
$1[u
][pluralForm
$1(number
)];
4992 str
= str
[withoutSuffix
? 0 : 1];
4994 return str
.replace(/%d/i, number
);
5011 hooks
.defineLocale('ar', {
5013 monthsShort
: months
$2,
5014 weekdays
: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5015 weekdaysShort
: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
5016 weekdaysMin
: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
5017 weekdaysParseExact
: true,
5021 L
: 'D/\u200FM/\u200FYYYY',
5023 LLL
: 'D MMMM YYYY HH:mm',
5024 LLLL
: 'dddd D MMMM YYYY HH:mm'
5026 meridiemParse
: /ص|م/,
5027 isPM : function (input
) {
5028 return 'م' === input
;
5030 meridiem : function (hour
, minute
, isLower
) {
5038 sameDay
: '[اليوم عند الساعة] LT',
5039 nextDay
: '[غدًا عند الساعة] LT',
5040 nextWeek
: 'dddd [عند الساعة] LT',
5041 lastDay
: '[أمس عند الساعة] LT',
5042 lastWeek
: 'dddd [عند الساعة] LT',
5048 s
: pluralize
$1('s'),
5049 ss
: pluralize
$1('s'),
5050 m
: pluralize
$1('m'),
5051 mm
: pluralize
$1('m'),
5052 h
: pluralize
$1('h'),
5053 hh
: pluralize
$1('h'),
5054 d
: pluralize
$1('d'),
5055 dd
: pluralize
$1('d'),
5056 M
: pluralize
$1('M'),
5057 MM
: pluralize
$1('M'),
5058 y
: pluralize
$1('y'),
5059 yy
: pluralize
$1('y')
5061 preparse: function (string
) {
5062 return string
.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match
) {
5063 return numberMap
$1[match
];
5064 }).replace(/،/g, ',');
5066 postformat: function (string
) {
5067 return string
.replace(/\d/g, function (match
) {
5068 return symbolMap
$2[match
];
5069 }).replace(/,/g
, '،');
5072 dow
: 6, // Saturday is the first day of the week.
5073 doy
: 12 // The week that contains Jan 1st is the first week of the year.
5077 //! moment.js locale configuration
5100 hooks
.defineLocale('az', {
5101 months
: 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
5102 monthsShort
: 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
5103 weekdays
: 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
5104 weekdaysShort
: 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
5105 weekdaysMin
: 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
5106 weekdaysParseExact
: true,
5112 LLL
: 'D MMMM YYYY HH:mm',
5113 LLLL
: 'dddd, D MMMM YYYY HH:mm'
5116 sameDay
: '[bugün saat] LT',
5117 nextDay
: '[sabah saat] LT',
5118 nextWeek
: '[gələn həftə] dddd [saat] LT',
5119 lastDay
: '[dünən] LT',
5120 lastWeek
: '[keçən həftə] dddd [saat] LT',
5124 future
: '%s sonra',
5126 s
: 'birneçə saniyə',
5139 meridiemParse
: /gecə|səhər|gündüz|axşam/,
5140 isPM : function (input
) {
5141 return /^(gündüz|axşam)$/.test(input
);
5143 meridiem : function (hour
, minute
, isLower
) {
5146 } else if (hour
< 12) {
5148 } else if (hour
< 17) {
5154 dayOfMonthOrdinalParse
: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
5155 ordinal : function (number
) {
5156 if (number
=== 0) { // special case for zero
5157 return number
+ '-ıncı';
5159 var a
= number
% 10,
5160 b
= number
% 100 - a
,
5161 c
= number
>= 100 ? 100 : null;
5162 return number
+ (suffixes
[a
] || suffixes
[b
] || suffixes
[c
]);
5165 dow
: 1, // Monday is the first day of the week.
5166 doy
: 7 // The week that contains Jan 1st is the first week of the year.
5170 //! moment.js locale configuration
5172 function plural(word
, num
) {
5173 var forms
= word
.split('_');
5174 return num
% 10 === 1 && num
% 100 !== 11 ? forms
[0] : (num
% 10 >= 2 && num
% 10 <= 4 && (num
% 100 < 10 || num
% 100 >= 20) ? forms
[1] : forms
[2]);
5176 function relativeTimeWithPlural(number
, withoutSuffix
, key
) {
5178 'ss': withoutSuffix
? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
5179 'mm': withoutSuffix
? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
5180 'hh': withoutSuffix
? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
5181 'dd': 'дзень_дні_дзён',
5182 'MM': 'месяц_месяцы_месяцаў',
5183 'yy': 'год_гады_гадоў'
5186 return withoutSuffix
? 'хвіліна' : 'хвіліну';
5188 else if (key
=== 'h') {
5189 return withoutSuffix
? 'гадзіна' : 'гадзіну';
5192 return number
+ ' ' + plural(format
[key
], +number
);
5196 hooks
.defineLocale('be', {
5198 format
: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_'),
5199 standalone
: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_')
5201 monthsShort
: 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split('_'),
5203 format
: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_'),
5204 standalone
: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
5205 isFormat
: /\[ ?[Ууў] ?(?:мінулую|наступную)? ?\] ?dddd/
5207 weekdaysShort
: 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
5208 weekdaysMin
: 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
5213 LL
: 'D MMMM YYYY г.',
5214 LLL
: 'D MMMM YYYY г., HH:mm',
5215 LLLL
: 'dddd, D MMMM YYYY г., HH:mm'
5218 sameDay
: '[Сёння ў] LT',
5219 nextDay
: '[Заўтра ў] LT',
5220 lastDay
: '[Учора ў] LT',
5221 nextWeek: function () {
5222 return '[У] dddd [ў] LT';
5224 lastWeek: function () {
5225 switch (this.day()) {
5230 return '[У мінулую] dddd [ў] LT';
5234 return '[У мінулы] dddd [ў] LT';
5242 s
: 'некалькі секунд',
5243 m
: relativeTimeWithPlural
,
5244 mm
: relativeTimeWithPlural
,
5245 h
: relativeTimeWithPlural
,
5246 hh
: relativeTimeWithPlural
,
5248 dd
: relativeTimeWithPlural
,
5250 MM
: relativeTimeWithPlural
,
5252 yy
: relativeTimeWithPlural
5254 meridiemParse
: /ночы|раніцы|дня|вечара/,
5255 isPM : function (input
) {
5256 return /^(дня|вечара)$/.test(input
);
5258 meridiem : function (hour
, minute
, isLower
) {
5261 } else if (hour
< 12) {
5263 } else if (hour
< 17) {
5269 dayOfMonthOrdinalParse
: /\d{1,2}-(і|ы|га)/,
5270 ordinal: function (number
, period
) {
5277 return (number
% 10 === 2 || number
% 10 === 3) && (number
% 100 !== 12 && number
% 100 !== 13) ? number
+ '-і' : number
+ '-ы';
5279 return number
+ '-га';
5285 dow
: 1, // Monday is the first day of the week.
5286 doy
: 7 // The week that contains Jan 1st is the first week of the year.
5290 //! moment.js locale configuration
5292 hooks
.defineLocale('bg', {
5293 months
: 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
5294 monthsShort
: 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
5295 weekdays
: 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
5296 weekdaysShort
: 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
5297 weekdaysMin
: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
5303 LLL
: 'D MMMM YYYY H:mm',
5304 LLLL
: 'dddd, D MMMM YYYY H:mm'
5307 sameDay
: '[Днес в] LT',
5308 nextDay
: '[Утре в] LT',
5309 nextWeek
: 'dddd [в] LT',
5310 lastDay
: '[Вчера в] LT',
5311 lastWeek : function () {
5312 switch (this.day()) {
5316 return '[В изминалата] dddd [в] LT';
5321 return '[В изминалия] dddd [в] LT';
5329 s
: 'няколко секунди',
5342 dayOfMonthOrdinalParse
: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
5343 ordinal : function (number
) {
5344 var lastDigit
= number
% 10,
5345 last2Digits
= number
% 100;
5347 return number
+ '-ев';
5348 } else if (last2Digits
=== 0) {
5349 return number
+ '-ен';
5350 } else if (last2Digits
> 10 && last2Digits
< 20) {
5351 return number
+ '-ти';
5352 } else if (lastDigit
=== 1) {
5353 return number
+ '-ви';
5354 } else if (lastDigit
=== 2) {
5355 return number
+ '-ри';
5356 } else if (lastDigit
=== 7 || lastDigit
=== 8) {
5357 return number
+ '-ми';
5359 return number
+ '-ти';
5363 dow
: 1, // Monday is the first day of the week.
5364 doy
: 7 // The week that contains Jan 1st is the first week of the year.
5368 //! moment.js locale configuration
5370 hooks
.defineLocale('bm', {
5371 months
: 'Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo'.split('_'),
5372 monthsShort
: 'Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des'.split('_'),
5373 weekdays
: 'Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri'.split('_'),
5374 weekdaysShort
: 'Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib'.split('_'),
5375 weekdaysMin
: 'Ka_Nt_Ta_Ar_Al_Ju_Si'.split('_'),
5380 LL
: 'MMMM [tile] D [san] YYYY',
5381 LLL
: 'MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm',
5382 LLLL
: 'dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm'
5385 sameDay
: '[Bi lɛrɛ] LT',
5386 nextDay
: '[Sini lɛrɛ] LT',
5387 nextWeek
: 'dddd [don lɛrɛ] LT',
5388 lastDay
: '[Kunu lɛrɛ] LT',
5389 lastWeek
: 'dddd [tɛmɛnen lɛrɛ] LT',
5394 past
: 'a bɛ %s bɔ',
5395 s
: 'sanga dama dama',
5409 dow
: 1, // Monday is the first day of the week.
5410 doy
: 4 // The week that contains Jan 4th is the first week of the year.
5414 //! moment.js locale configuration
5441 hooks
.defineLocale('bn', {
5442 months
: 'জানুয়ারী_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split('_'),
5443 monthsShort
: 'জানু_ফেব_মার্চ_এপ্র_মে_জুন_জুল_আগ_সেপ্ট_অক্টো_নভে_ডিসে'.split('_'),
5444 weekdays
: 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split('_'),
5445 weekdaysShort
: 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
5446 weekdaysMin
: 'রবি_সোম_মঙ্গ_বুধ_বৃহঃ_শুক্র_শনি'.split('_'),
5449 LTS
: 'A h:mm:ss সময়',
5452 LLL
: 'D MMMM YYYY, A h:mm সময়',
5453 LLLL
: 'dddd, D MMMM YYYY, A h:mm সময়'
5456 sameDay
: '[আজ] LT',
5457 nextDay
: '[আগামীকাল] LT',
5458 nextWeek
: 'dddd, LT',
5459 lastDay
: '[গতকাল] LT',
5460 lastWeek
: '[গত] dddd, LT',
5479 preparse: function (string
) {
5480 return string
.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match
) {
5481 return numberMap
$2[match
];
5484 postformat: function (string
) {
5485 return string
.replace(/\d/g, function (match
) {
5486 return symbolMap
$3[match
];
5489 meridiemParse
: /রাত|সকাল|দুপুর|বিকাল|রাত/,
5490 meridiemHour : function (hour
, meridiem
) {
5494 if ((meridiem
=== 'রাত' && hour
>= 4) ||
5495 (meridiem
=== 'দুপুর' && hour
< 5) ||
5496 meridiem
=== 'বিকাল') {
5502 meridiem : function (hour
, minute
, isLower
) {
5505 } else if (hour
< 10) {
5507 } else if (hour
< 17) {
5509 } else if (hour
< 20) {
5516 dow
: 0, // Sunday is the first day of the week.
5517 doy
: 6 // The week that contains Jan 1st is the first week of the year.
5521 //! moment.js locale configuration
5548 hooks
.defineLocale('bo', {
5549 months
: 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
5550 monthsShort
: 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
5551 weekdays
: 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
5552 weekdaysShort
: 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
5553 weekdaysMin
: 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
5559 LLL
: 'D MMMM YYYY, A h:mm',
5560 LLLL
: 'dddd, D MMMM YYYY, A h:mm'
5563 sameDay
: '[དི་རིང] LT',
5564 nextDay
: '[སང་ཉིན] LT',
5565 nextWeek
: '[བདུན་ཕྲག་རྗེས་མ], LT',
5566 lastDay
: '[ཁ་སང] LT',
5567 lastWeek
: '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
5586 preparse: function (string
) {
5587 return string
.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match
) {
5588 return numberMap
$3[match
];
5591 postformat: function (string
) {
5592 return string
.replace(/\d/g, function (match
) {
5593 return symbolMap
$4[match
];
5596 meridiemParse
: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
5597 meridiemHour : function (hour
, meridiem
) {
5601 if ((meridiem
=== 'མཚན་མོ' && hour
>= 4) ||
5602 (meridiem
=== 'ཉིན་གུང' && hour
< 5) ||
5603 meridiem
=== 'དགོང་དག') {
5609 meridiem : function (hour
, minute
, isLower
) {
5612 } else if (hour
< 10) {
5614 } else if (hour
< 17) {
5616 } else if (hour
< 20) {
5623 dow
: 0, // Sunday is the first day of the week.
5624 doy
: 6 // The week that contains Jan 1st is the first week of the year.
5628 //! moment.js locale configuration
5630 function relativeTimeWithMutation(number
, withoutSuffix
, key
) {
5636 return number
+ ' ' + mutation(format
[key
], number
);
5638 function specialMutationForYears(number
) {
5639 switch (lastNumber(number
)) {
5645 return number
+ ' bloaz';
5647 return number
+ ' vloaz';
5650 function lastNumber(number
) {
5652 return lastNumber(number
% 10);
5656 function mutation(text
, number
) {
5658 return softMutation(text
);
5662 function softMutation(text
) {
5663 var mutationTable
= {
5668 if (mutationTable
[text
.charAt(0)] === undefined) {
5671 return mutationTable
[text
.charAt(0)] + text
.substring(1);
5674 hooks
.defineLocale('br', {
5675 months
: 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
5676 monthsShort
: 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
5677 weekdays
: 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
5678 weekdaysShort
: 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
5679 weekdaysMin
: 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
5680 weekdaysParseExact
: true,
5683 LTS
: 'h[e]mm:ss A',
5685 LL
: 'D [a viz] MMMM YYYY',
5686 LLL
: 'D [a viz] MMMM YYYY h[e]mm A',
5687 LLLL
: 'dddd, D [a viz] MMMM YYYY h[e]mm A'
5690 sameDay
: '[Hiziv da] LT',
5691 nextDay
: '[Warc\'hoazh da] LT',
5692 nextWeek
: 'dddd [da] LT',
5693 lastDay
: '[Dec\'h da] LT',
5694 lastWeek
: 'dddd [paset da] LT',
5698 future
: 'a-benn %s',
5700 s
: 'un nebeud segondennoù',
5703 mm
: relativeTimeWithMutation
,
5707 dd
: relativeTimeWithMutation
,
5709 MM
: relativeTimeWithMutation
,
5711 yy
: specialMutationForYears
5713 dayOfMonthOrdinalParse
: /\d{1,2}(añ|vet)/,
5714 ordinal : function (number
) {
5715 var output
= (number
=== 1) ? 'añ' : 'vet';
5716 return number
+ output
;
5719 dow
: 1, // Monday is the first day of the week.
5720 doy
: 4 // The week that contains Jan 4th is the first week of the year.
5724 //! moment.js locale configuration
5726 function translate(number
, withoutSuffix
, key
) {
5727 var result
= number
+ ' ';
5731 result
+= 'sekunda';
5732 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
5733 result
+= 'sekunde';
5735 result
+= 'sekundi';
5739 return withoutSuffix
? 'jedna minuta' : 'jedne minute';
5743 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
5750 return withoutSuffix
? 'jedan sat' : 'jednog sata';
5754 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
5770 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
5771 result
+= 'mjeseca';
5773 result
+= 'mjeseci';
5779 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
5788 hooks
.defineLocale('bs', {
5789 months
: 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
5790 monthsShort
: 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
5791 monthsParseExact
: true,
5792 weekdays
: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
5793 weekdaysShort
: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
5794 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
5795 weekdaysParseExact
: true,
5800 LL
: 'D. MMMM YYYY',
5801 LLL
: 'D. MMMM YYYY H:mm',
5802 LLLL
: 'dddd, D. MMMM YYYY H:mm'
5805 sameDay
: '[danas u] LT',
5806 nextDay
: '[sutra u] LT',
5807 nextWeek : function () {
5808 switch (this.day()) {
5810 return '[u] [nedjelju] [u] LT';
5812 return '[u] [srijedu] [u] LT';
5814 return '[u] [subotu] [u] LT';
5819 return '[u] dddd [u] LT';
5822 lastDay
: '[jučer u] LT',
5823 lastWeek : function () {
5824 switch (this.day()) {
5827 return '[prošlu] dddd [u] LT';
5829 return '[prošle] [subote] [u] LT';
5834 return '[prošli] dddd [u] LT';
5855 dayOfMonthOrdinalParse
: /\d{1,2}\./,
5858 dow
: 1, // Monday is the first day of the week.
5859 doy
: 7 // The week that contains Jan 1st is the first week of the year.
5863 //! moment.js locale configuration
5865 hooks
.defineLocale('ca', {
5867 standalone
: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
5868 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('_'),
5869 isFormat
: /D[oD]?(\s)+MMMM/
5871 monthsShort
: 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split('_'),
5872 monthsParseExact
: true,
5873 weekdays
: 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
5874 weekdaysShort
: 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
5875 weekdaysMin
: 'dg_dl_dt_dc_dj_dv_ds'.split('_'),
5876 weekdaysParseExact
: true,
5881 LL
: 'D MMMM [de] YYYY',
5883 LLL
: 'D MMMM [de] YYYY [a les] H:mm',
5884 lll
: 'D MMM YYYY, H:mm',
5885 LLLL
: 'dddd D MMMM [de] YYYY [a les] H:mm',
5886 llll
: 'ddd D MMM YYYY, H:mm'
5889 sameDay : function () {
5890 return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5892 nextDay : function () {
5893 return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5895 nextWeek : function () {
5896 return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5898 lastDay : function () {
5899 return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5901 lastWeek : function () {
5902 return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5907 future
: 'd\'aquí %s',
5922 dayOfMonthOrdinalParse
: /\d{1,2}(r|n|t|è|a)/,
5923 ordinal : function (number
, period
) {
5924 var output
= (number
=== 1) ? 'r' :
5925 (number
=== 2) ? 'n' :
5926 (number
=== 3) ? 'r' :
5927 (number
=== 4) ? 't' : 'è';
5928 if (period
=== 'w' || period
=== 'W') {
5931 return number
+ output
;
5934 dow
: 1, // Monday is the first day of the week.
5935 doy
: 4 // The week that contains Jan 4th is the first week of the year.
5939 //! moment.js locale configuration
5941 var months
$3 = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_'),
5942 monthsShort
= 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_');
5943 function plural
$1(n
) {
5944 return (n
> 1) && (n
< 5) && (~~(n
/ 10) !== 1);
5946 function translate
$1(number
, withoutSuffix
, key
, isFuture
) {
5947 var result
= number
+ ' ';
5949 case 's': // a few seconds / in a few seconds / a few seconds ago
5950 return (withoutSuffix
|| isFuture
) ? 'pár sekund' : 'pár sekundami';
5951 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
5952 if (withoutSuffix
|| isFuture
) {
5953 return result
+ (plural
$1(number
) ? 'sekundy' : 'sekund');
5955 return result
+ 'sekundami';
5958 case 'm': // a minute / in a minute / a minute ago
5959 return withoutSuffix
? 'minuta' : (isFuture
? 'minutu' : 'minutou');
5960 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
5961 if (withoutSuffix
|| isFuture
) {
5962 return result
+ (plural
$1(number
) ? 'minuty' : 'minut');
5964 return result
+ 'minutami';
5967 case 'h': // an hour / in an hour / an hour ago
5968 return withoutSuffix
? 'hodina' : (isFuture
? 'hodinu' : 'hodinou');
5969 case 'hh': // 9 hours / in 9 hours / 9 hours ago
5970 if (withoutSuffix
|| isFuture
) {
5971 return result
+ (plural
$1(number
) ? 'hodiny' : 'hodin');
5973 return result
+ 'hodinami';
5976 case 'd': // a day / in a day / a day ago
5977 return (withoutSuffix
|| isFuture
) ? 'den' : 'dnem';
5978 case 'dd': // 9 days / in 9 days / 9 days ago
5979 if (withoutSuffix
|| isFuture
) {
5980 return result
+ (plural
$1(number
) ? 'dny' : 'dní');
5982 return result
+ 'dny';
5985 case 'M': // a month / in a month / a month ago
5986 return (withoutSuffix
|| isFuture
) ? 'měsíc' : 'měsícem';
5987 case 'MM': // 9 months / in 9 months / 9 months ago
5988 if (withoutSuffix
|| isFuture
) {
5989 return result
+ (plural
$1(number
) ? 'měsíce' : 'měsíců');
5991 return result
+ 'měsíci';
5994 case 'y': // a year / in a year / a year ago
5995 return (withoutSuffix
|| isFuture
) ? 'rok' : 'rokem';
5996 case 'yy': // 9 years / in 9 years / 9 years ago
5997 if (withoutSuffix
|| isFuture
) {
5998 return result
+ (plural
$1(number
) ? 'roky' : 'let');
6000 return result
+ 'lety';
6006 hooks
.defineLocale('cs', {
6008 monthsShort
: monthsShort
,
6009 monthsParse
: (function (months
, monthsShort
) {
6010 var i
, _monthsParse
= [];
6011 for (i
= 0; i
< 12; i
++) {
6012 // use custom parser to solve problem with July (červenec)
6013 _monthsParse
[i
] = new RegExp('^' + months
[i
] + '$|^' + monthsShort
[i
] + '$', 'i');
6015 return _monthsParse
;
6016 }(months
$3, monthsShort
)),
6017 shortMonthsParse
: (function (monthsShort
) {
6018 var i
, _shortMonthsParse
= [];
6019 for (i
= 0; i
< 12; i
++) {
6020 _shortMonthsParse
[i
] = new RegExp('^' + monthsShort
[i
] + '$', 'i');
6022 return _shortMonthsParse
;
6024 longMonthsParse
: (function (months
) {
6025 var i
, _longMonthsParse
= [];
6026 for (i
= 0; i
< 12; i
++) {
6027 _longMonthsParse
[i
] = new RegExp('^' + months
[i
] + '$', 'i');
6029 return _longMonthsParse
;
6031 weekdays
: 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
6032 weekdaysShort
: 'ne_po_út_st_čt_pá_so'.split('_'),
6033 weekdaysMin
: 'ne_po_út_st_čt_pá_so'.split('_'),
6038 LL
: 'D. MMMM YYYY',
6039 LLL
: 'D. MMMM YYYY H:mm',
6040 LLLL
: 'dddd D. MMMM YYYY H:mm',
6044 sameDay
: '[dnes v] LT',
6045 nextDay
: '[zítra v] LT',
6046 nextWeek: function () {
6047 switch (this.day()) {
6049 return '[v neděli v] LT';
6052 return '[v] dddd [v] LT';
6054 return '[ve středu v] LT';
6056 return '[ve čtvrtek v] LT';
6058 return '[v pátek v] LT';
6060 return '[v sobotu v] LT';
6063 lastDay
: '[včera v] LT',
6064 lastWeek: function () {
6065 switch (this.day()) {
6067 return '[minulou neděli v] LT';
6070 return '[minulé] dddd [v] LT';
6072 return '[minulou středu v] LT';
6075 return '[minulý] dddd [v] LT';
6077 return '[minulou sobotu v] LT';
6098 dayOfMonthOrdinalParse
: /\d{1,2}\./,
6101 dow
: 1, // Monday is the first day of the week.
6102 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6106 //! moment.js locale configuration
6108 hooks
.defineLocale('cv', {
6109 months
: 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split('_'),
6110 monthsShort
: 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
6111 weekdays
: 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split('_'),
6112 weekdaysShort
: 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
6113 weekdaysMin
: 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
6118 LL
: 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
6119 LLL
: 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
6120 LLLL
: 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm'
6123 sameDay
: '[Паян] LT [сехетре]',
6124 nextDay
: '[Ыран] LT [сехетре]',
6125 lastDay
: '[Ӗнер] LT [сехетре]',
6126 nextWeek
: '[Ҫитес] dddd LT [сехетре]',
6127 lastWeek
: '[Иртнӗ] dddd LT [сехетре]',
6131 future : function (output
) {
6132 var affix
= /сехет$/i.exec(output
) ? 'рен' : /ҫул$/i.exec(output
) ? 'тан' : 'ран';
6133 return output
+ affix
;
6136 s
: 'пӗр-ик ҫеккунт',
6149 dayOfMonthOrdinalParse
: /\d{1,2}-мӗш/,
6152 dow
: 1, // Monday is the first day of the week.
6153 doy
: 7 // The week that contains Jan 1st is the first week of the year.
6157 //! moment.js locale configuration
6159 hooks
.defineLocale('cy', {
6160 months
: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
6161 monthsShort
: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
6162 weekdays
: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
6163 weekdaysShort
: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
6164 weekdaysMin
: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
6165 weekdaysParseExact
: true,
6166 // time formats are the same as en-gb
6172 LLL
: 'D MMMM YYYY HH:mm',
6173 LLLL
: 'dddd, D MMMM YYYY HH:mm'
6176 sameDay
: '[Heddiw am] LT',
6177 nextDay
: '[Yfory am] LT',
6178 nextWeek
: 'dddd [am] LT',
6179 lastDay
: '[Ddoe am] LT',
6180 lastWeek
: 'dddd [diwethaf am] LT',
6186 s
: 'ychydig eiliadau',
6199 dayOfMonthOrdinalParse
: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
6200 // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
6201 ordinal: function (number
) {
6205 '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
6206 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
6209 if (b
=== 40 || b
=== 50 || b
=== 60 || b
=== 80 || b
=== 100) {
6210 output
= 'fed'; // not 30ain, 70ain or 90ain
6217 return number
+ output
;
6220 dow
: 1, // Monday is the first day of the week.
6221 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6225 //! moment.js locale configuration
6227 hooks
.defineLocale('da', {
6228 months
: 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
6229 monthsShort
: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
6230 weekdays
: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
6231 weekdaysShort
: 'søn_man_tir_ons_tor_fre_lør'.split('_'),
6232 weekdaysMin
: 'sø_ma_ti_on_to_fr_lø'.split('_'),
6237 LL
: 'D. MMMM YYYY',
6238 LLL
: 'D. MMMM YYYY HH:mm',
6239 LLLL
: 'dddd [d.] D. MMMM YYYY [kl.] HH:mm'
6242 sameDay
: '[i dag kl.] LT',
6243 nextDay
: '[i morgen kl.] LT',
6244 nextWeek
: 'på dddd [kl.] LT',
6245 lastDay
: '[i går kl.] LT',
6246 lastWeek
: '[i] dddd[s kl.] LT',
6265 dayOfMonthOrdinalParse
: /\d{1,2}\./,
6268 dow
: 1, // Monday is the first day of the week.
6269 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6273 //! moment.js locale configuration
6275 function processRelativeTime(number
, withoutSuffix
, key
, isFuture
) {
6277 'm': ['eine Minute', 'einer Minute'],
6278 'h': ['eine Stunde', 'einer Stunde'],
6279 'd': ['ein Tag', 'einem Tag'],
6280 'dd': [number
+ ' Tage', number
+ ' Tagen'],
6281 'M': ['ein Monat', 'einem Monat'],
6282 'MM': [number
+ ' Monate', number
+ ' Monaten'],
6283 'y': ['ein Jahr', 'einem Jahr'],
6284 'yy': [number
+ ' Jahre', number
+ ' Jahren']
6286 return withoutSuffix
? format
[key
][0] : format
[key
][1];
6289 hooks
.defineLocale('de-at', {
6290 months
: 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6291 monthsShort
: 'Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6292 monthsParseExact
: true,
6293 weekdays
: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6294 weekdaysShort
: 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6295 weekdaysMin
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6296 weekdaysParseExact
: true,
6301 LL
: 'D. MMMM YYYY',
6302 LLL
: 'D. MMMM YYYY HH:mm',
6303 LLLL
: 'dddd, D. MMMM YYYY HH:mm'
6306 sameDay
: '[heute um] LT [Uhr]',
6308 nextDay
: '[morgen um] LT [Uhr]',
6309 nextWeek
: 'dddd [um] LT [Uhr]',
6310 lastDay
: '[gestern um] LT [Uhr]',
6311 lastWeek
: '[letzten] dddd [um] LT [Uhr]'
6316 s
: 'ein paar Sekunden',
6318 m
: processRelativeTime
,
6320 h
: processRelativeTime
,
6322 d
: processRelativeTime
,
6323 dd
: processRelativeTime
,
6324 M
: processRelativeTime
,
6325 MM
: processRelativeTime
,
6326 y
: processRelativeTime
,
6327 yy
: processRelativeTime
6329 dayOfMonthOrdinalParse
: /\d{1,2}\./,
6332 dow
: 1, // Monday is the first day of the week.
6333 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6337 //! moment.js locale configuration
6339 function processRelativeTime
$1(number
, withoutSuffix
, key
, isFuture
) {
6341 'm': ['eine Minute', 'einer Minute'],
6342 'h': ['eine Stunde', 'einer Stunde'],
6343 'd': ['ein Tag', 'einem Tag'],
6344 'dd': [number
+ ' Tage', number
+ ' Tagen'],
6345 'M': ['ein Monat', 'einem Monat'],
6346 'MM': [number
+ ' Monate', number
+ ' Monaten'],
6347 'y': ['ein Jahr', 'einem Jahr'],
6348 'yy': [number
+ ' Jahre', number
+ ' Jahren']
6350 return withoutSuffix
? format
[key
][0] : format
[key
][1];
6353 hooks
.defineLocale('de-ch', {
6354 months
: 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6355 monthsShort
: 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6356 monthsParseExact
: true,
6357 weekdays
: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6358 weekdaysShort
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6359 weekdaysMin
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6360 weekdaysParseExact
: true,
6365 LL
: 'D. MMMM YYYY',
6366 LLL
: 'D. MMMM YYYY HH:mm',
6367 LLLL
: 'dddd, D. MMMM YYYY HH:mm'
6370 sameDay
: '[heute um] LT [Uhr]',
6372 nextDay
: '[morgen um] LT [Uhr]',
6373 nextWeek
: 'dddd [um] LT [Uhr]',
6374 lastDay
: '[gestern um] LT [Uhr]',
6375 lastWeek
: '[letzten] dddd [um] LT [Uhr]'
6380 s
: 'ein paar Sekunden',
6382 m
: processRelativeTime
$1,
6384 h
: processRelativeTime
$1,
6386 d
: processRelativeTime
$1,
6387 dd
: processRelativeTime
$1,
6388 M
: processRelativeTime
$1,
6389 MM
: processRelativeTime
$1,
6390 y
: processRelativeTime
$1,
6391 yy
: processRelativeTime
$1
6393 dayOfMonthOrdinalParse
: /\d{1,2}\./,
6396 dow
: 1, // Monday is the first day of the week.
6397 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6401 //! moment.js locale configuration
6403 function processRelativeTime
$2(number
, withoutSuffix
, key
, isFuture
) {
6405 'm': ['eine Minute', 'einer Minute'],
6406 'h': ['eine Stunde', 'einer Stunde'],
6407 'd': ['ein Tag', 'einem Tag'],
6408 'dd': [number
+ ' Tage', number
+ ' Tagen'],
6409 'M': ['ein Monat', 'einem Monat'],
6410 'MM': [number
+ ' Monate', number
+ ' Monaten'],
6411 'y': ['ein Jahr', 'einem Jahr'],
6412 'yy': [number
+ ' Jahre', number
+ ' Jahren']
6414 return withoutSuffix
? format
[key
][0] : format
[key
][1];
6417 hooks
.defineLocale('de', {
6418 months
: 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6419 monthsShort
: 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6420 monthsParseExact
: true,
6421 weekdays
: 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6422 weekdaysShort
: 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6423 weekdaysMin
: 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6424 weekdaysParseExact
: true,
6429 LL
: 'D. MMMM YYYY',
6430 LLL
: 'D. MMMM YYYY HH:mm',
6431 LLLL
: 'dddd, D. MMMM YYYY HH:mm'
6434 sameDay
: '[heute um] LT [Uhr]',
6436 nextDay
: '[morgen um] LT [Uhr]',
6437 nextWeek
: 'dddd [um] LT [Uhr]',
6438 lastDay
: '[gestern um] LT [Uhr]',
6439 lastWeek
: '[letzten] dddd [um] LT [Uhr]'
6444 s
: 'ein paar Sekunden',
6446 m
: processRelativeTime
$2,
6448 h
: processRelativeTime
$2,
6450 d
: processRelativeTime
$2,
6451 dd
: processRelativeTime
$2,
6452 M
: processRelativeTime
$2,
6453 MM
: processRelativeTime
$2,
6454 y
: processRelativeTime
$2,
6455 yy
: processRelativeTime
$2
6457 dayOfMonthOrdinalParse
: /\d{1,2}\./,
6460 dow
: 1, // Monday is the first day of the week.
6461 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6465 //! moment.js locale configuration
6490 hooks
.defineLocale('dv', {
6492 monthsShort
: months
$4,
6493 weekdays
: weekdays
,
6494 weekdaysShort
: weekdays
,
6495 weekdaysMin
: 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
6502 LLL
: 'D MMMM YYYY HH:mm',
6503 LLLL
: 'dddd D MMMM YYYY HH:mm'
6505 meridiemParse
: /މކ|މފ/,
6506 isPM : function (input
) {
6507 return 'މފ' === input
;
6509 meridiem : function (hour
, minute
, isLower
) {
6517 sameDay
: '[މިއަދު] LT',
6518 nextDay
: '[މާދަމާ] LT',
6519 nextWeek
: 'dddd LT',
6520 lastDay
: '[އިއްޔެ] LT',
6521 lastWeek
: '[ފާއިތުވި] dddd LT',
6525 future
: 'ތެރޭގައި %s',
6527 s
: 'ސިކުންތުކޮޅެއް',
6540 preparse: function (string
) {
6541 return string
.replace(/،/g, ',');
6543 postformat: function (string
) {
6544 return string
.replace(/,/g
, '،');
6547 dow
: 7, // Sunday is the first day of the week.
6548 doy
: 12 // The week that contains Jan 1st is the first week of the year.
6552 //! moment.js locale configuration
6554 hooks
.defineLocale('el', {
6555 monthsNominativeEl
: 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
6556 monthsGenitiveEl
: 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split('_'),
6557 months : function (momentToFormat
, format
) {
6558 if (!momentToFormat
) {
6559 return this._monthsNominativeEl
;
6560 } else if (typeof format
=== 'string' && /D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before
'MMMM'
6561 return this._monthsGenitiveEl
[momentToFormat
.month()];
6563 return this._monthsNominativeEl
[momentToFormat
.month()];
6566 monthsShort
: 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
6567 weekdays
: 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split('_'),
6568 weekdaysShort
: 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
6569 weekdaysMin
: 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
6570 meridiem : function (hours
, minutes
, isLower
) {
6572 return isLower
? 'μμ' : 'ΜΜ';
6574 return isLower
? 'πμ' : 'ΠΜ';
6577 isPM : function (input
) {
6578 return ((input
+ '').toLowerCase()[0] === 'μ');
6580 meridiemParse
: /[ΠΜ]\.?Μ?\.?/i,
6586 LLL
: 'D MMMM YYYY h:mm A',
6587 LLLL
: 'dddd, D MMMM YYYY h:mm A'
6590 sameDay
: '[Σήμερα {}] LT',
6591 nextDay
: '[Αύριο {}] LT',
6592 nextWeek
: 'dddd [{}] LT',
6593 lastDay
: '[Χθες {}] LT',
6594 lastWeek : function () {
6595 switch (this.day()) {
6597 return '[το προηγούμενο] dddd [{}] LT';
6599 return '[την προηγούμενη] dddd [{}] LT';
6604 calendar : function (key
, mom
) {
6605 var output
= this._calendarEl
[key
],
6606 hours
= mom
&& mom
.hours();
6607 if (isFunction(output
)) {
6608 output
= output
.apply(mom
);
6610 return output
.replace('{}', (hours
% 12 === 1 ? 'στη' : 'στις'));
6615 s
: 'λίγα δευτερόλεπτα',
6616 ss
: '%d δευτερόλεπτα',
6628 dayOfMonthOrdinalParse
: /\d{1,2}η/,
6631 dow
: 1, // Monday is the first day of the week.
6632 doy
: 4 // The week that contains Jan 4st is the first week of the year.
6636 //! moment.js locale configuration
6638 hooks
.defineLocale('en-au', {
6639 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6640 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6641 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6642 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6643 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6649 LLL
: 'D MMMM YYYY h:mm A',
6650 LLLL
: 'dddd, D MMMM YYYY h:mm A'
6653 sameDay
: '[Today at] LT',
6654 nextDay
: '[Tomorrow at] LT',
6655 nextWeek
: 'dddd [at] LT',
6656 lastDay
: '[Yesterday at] LT',
6657 lastWeek
: '[Last] dddd [at] LT',
6663 s
: 'a few seconds',
6676 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
6677 ordinal : function (number
) {
6678 var b
= number
% 10,
6679 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
6682 (b
=== 3) ? 'rd' : 'th';
6683 return number
+ output
;
6686 dow
: 1, // Monday is the first day of the week.
6687 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6691 //! moment.js locale configuration
6693 hooks
.defineLocale('en-ca', {
6694 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6695 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6696 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6697 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6698 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6703 LL
: 'MMMM D, YYYY',
6704 LLL
: 'MMMM D, YYYY h:mm A',
6705 LLLL
: 'dddd, MMMM D, YYYY h:mm A'
6708 sameDay
: '[Today at] LT',
6709 nextDay
: '[Tomorrow at] LT',
6710 nextWeek
: 'dddd [at] LT',
6711 lastDay
: '[Yesterday at] LT',
6712 lastWeek
: '[Last] dddd [at] LT',
6718 s
: 'a few seconds',
6731 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
6732 ordinal : function (number
) {
6733 var b
= number
% 10,
6734 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
6737 (b
=== 3) ? 'rd' : 'th';
6738 return number
+ output
;
6742 //! moment.js locale configuration
6744 hooks
.defineLocale('en-gb', {
6745 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6746 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6747 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6748 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6749 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6755 LLL
: 'D MMMM YYYY HH:mm',
6756 LLLL
: 'dddd, D MMMM YYYY HH:mm'
6759 sameDay
: '[Today at] LT',
6760 nextDay
: '[Tomorrow at] LT',
6761 nextWeek
: 'dddd [at] LT',
6762 lastDay
: '[Yesterday at] LT',
6763 lastWeek
: '[Last] dddd [at] LT',
6769 s
: 'a few seconds',
6782 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
6783 ordinal : function (number
) {
6784 var b
= number
% 10,
6785 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
6788 (b
=== 3) ? 'rd' : 'th';
6789 return number
+ output
;
6792 dow
: 1, // Monday is the first day of the week.
6793 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6797 //! moment.js locale configuration
6799 hooks
.defineLocale('en-ie', {
6800 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6801 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6802 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6803 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6804 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6810 LLL
: 'D MMMM YYYY HH:mm',
6811 LLLL
: 'dddd D MMMM YYYY HH:mm'
6814 sameDay
: '[Today at] LT',
6815 nextDay
: '[Tomorrow at] LT',
6816 nextWeek
: 'dddd [at] LT',
6817 lastDay
: '[Yesterday at] LT',
6818 lastWeek
: '[Last] dddd [at] LT',
6824 s
: 'a few seconds',
6837 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
6838 ordinal : function (number
) {
6839 var b
= number
% 10,
6840 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
6843 (b
=== 3) ? 'rd' : 'th';
6844 return number
+ output
;
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
6854 hooks
.defineLocale('en-il', {
6855 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6856 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6857 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6858 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6859 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6865 LLL
: 'D MMMM YYYY HH:mm',
6866 LLLL
: 'dddd, D MMMM YYYY HH:mm'
6869 sameDay
: '[Today at] LT',
6870 nextDay
: '[Tomorrow at] LT',
6871 nextWeek
: 'dddd [at] LT',
6872 lastDay
: '[Yesterday at] LT',
6873 lastWeek
: '[Last] dddd [at] LT',
6879 s
: 'a few seconds',
6891 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
6892 ordinal : function (number
) {
6893 var b
= number
% 10,
6894 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
6897 (b
=== 3) ? 'rd' : 'th';
6898 return number
+ output
;
6902 //! moment.js locale configuration
6904 hooks
.defineLocale('en-nz', {
6905 months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6906 monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6907 weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6908 weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6909 weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6915 LLL
: 'D MMMM YYYY h:mm A',
6916 LLLL
: 'dddd, D MMMM YYYY h:mm A'
6919 sameDay
: '[Today at] LT',
6920 nextDay
: '[Tomorrow at] LT',
6921 nextWeek
: 'dddd [at] LT',
6922 lastDay
: '[Yesterday at] LT',
6923 lastWeek
: '[Last] dddd [at] LT',
6929 s
: 'a few seconds',
6942 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
6943 ordinal : function (number
) {
6944 var b
= number
% 10,
6945 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
6948 (b
=== 3) ? 'rd' : 'th';
6949 return number
+ output
;
6952 dow
: 1, // Monday is the first day of the week.
6953 doy
: 4 // The week that contains Jan 4th is the first week of the year.
6957 //! moment.js locale configuration
6959 hooks
.defineLocale('eo', {
6960 months
: 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
6961 monthsShort
: 'jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec'.split('_'),
6962 weekdays
: 'dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato'.split('_'),
6963 weekdaysShort
: 'dim_lun_mard_merk_ĵaŭ_ven_sab'.split('_'),
6964 weekdaysMin
: 'di_lu_ma_me_ĵa_ve_sa'.split('_'),
6969 LL
: 'D[-a de] MMMM, YYYY',
6970 LLL
: 'D[-a de] MMMM, YYYY HH:mm',
6971 LLLL
: 'dddd, [la] D[-a de] MMMM, YYYY HH:mm'
6973 meridiemParse
: /[ap]\.t\.m/i,
6974 isPM: function (input
) {
6975 return input
.charAt(0).toLowerCase() === 'p';
6977 meridiem : function (hours
, minutes
, isLower
) {
6979 return isLower
? 'p.t.m.' : 'P.T.M.';
6981 return isLower
? 'a.t.m.' : 'A.T.M.';
6985 sameDay
: '[Hodiaŭ je] LT',
6986 nextDay
: '[Morgaŭ je] LT',
6987 nextWeek
: 'dddd [je] LT',
6988 lastDay
: '[Hieraŭ je] LT',
6989 lastWeek
: '[pasinta] dddd [je] LT',
7001 d
: 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
7008 dayOfMonthOrdinalParse
: /\d{1,2}a/,
7011 dow
: 1, // Monday is the first day of the week.
7012 doy
: 7 // The week that contains Jan 1st is the first week of the year.
7016 //! moment.js locale configuration
7018 var monthsShortDot
= 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7019 monthsShort
$1 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7021 var monthsParse
= [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i];
7022 var monthsRegex
$1 = /^(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;
7024 hooks
.defineLocale('es-do', {
7025 months
: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7026 monthsShort : function (m
, format
) {
7028 return monthsShortDot
;
7029 } else if (/-MMM-/.test(format
)) {
7030 return monthsShort
$1[m
.month()];
7032 return monthsShortDot
[m
.month()];
7035 monthsRegex
: monthsRegex
$1,
7036 monthsShortRegex
: monthsRegex
$1,
7037 monthsStrictRegex
: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
7038 monthsShortStrictRegex
: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
7039 monthsParse
: monthsParse
,
7040 longMonthsParse
: monthsParse
,
7041 shortMonthsParse
: monthsParse
,
7042 weekdays
: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7043 weekdaysShort
: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7044 weekdaysMin
: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7045 weekdaysParseExact
: true,
7050 LL
: 'D [de] MMMM [de] YYYY',
7051 LLL
: 'D [de] MMMM [de] YYYY h:mm A',
7052 LLLL
: 'dddd, D [de] MMMM [de] YYYY h:mm A'
7055 sameDay : function () {
7056 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7058 nextDay : function () {
7059 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7061 nextWeek : function () {
7062 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7064 lastDay : function () {
7065 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7067 lastWeek : function () {
7068 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7075 s
: 'unos segundos',
7088 dayOfMonthOrdinalParse
: /\d{1,2}º/,
7091 dow
: 1, // Monday is the first day of the week.
7092 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7096 //! moment.js locale configuration
7098 var monthsShortDot
$1 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7099 monthsShort
$2 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7101 hooks
.defineLocale('es-us', {
7102 months
: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7103 monthsShort : function (m
, format
) {
7105 return monthsShortDot
$1;
7106 } else if (/-MMM-/.test(format
)) {
7107 return monthsShort
$2[m
.month()];
7109 return monthsShortDot
$1[m
.month()];
7112 monthsParseExact
: true,
7113 weekdays
: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7114 weekdaysShort
: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7115 weekdaysMin
: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7116 weekdaysParseExact
: true,
7121 LL
: 'MMMM [de] D [de] YYYY',
7122 LLL
: 'MMMM [de] D [de] YYYY h:mm A',
7123 LLLL
: 'dddd, MMMM [de] D [de] YYYY h:mm A'
7126 sameDay : function () {
7127 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7129 nextDay : function () {
7130 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7132 nextWeek : function () {
7133 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7135 lastDay : function () {
7136 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7138 lastWeek : function () {
7139 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7146 s
: 'unos segundos',
7159 dayOfMonthOrdinalParse
: /\d{1,2}º/,
7162 dow
: 0, // Sunday is the first day of the week.
7163 doy
: 6 // The week that contains Jan 1st is the first week of the year.
7167 //! moment.js locale configuration
7169 var monthsShortDot
$2 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7170 monthsShort
$3 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7172 var monthsParse
$1 = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i];
7173 var monthsRegex
$2 = /^(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;
7175 hooks
.defineLocale('es', {
7176 months
: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7177 monthsShort : function (m
, format
) {
7179 return monthsShortDot
$2;
7180 } else if (/-MMM-/.test(format
)) {
7181 return monthsShort
$3[m
.month()];
7183 return monthsShortDot
$2[m
.month()];
7186 monthsRegex
: monthsRegex
$2,
7187 monthsShortRegex
: monthsRegex
$2,
7188 monthsStrictRegex
: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
7189 monthsShortStrictRegex
: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
7190 monthsParse
: monthsParse
$1,
7191 longMonthsParse
: monthsParse
$1,
7192 shortMonthsParse
: monthsParse
$1,
7193 weekdays
: 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7194 weekdaysShort
: 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7195 weekdaysMin
: 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7196 weekdaysParseExact
: true,
7201 LL
: 'D [de] MMMM [de] YYYY',
7202 LLL
: 'D [de] MMMM [de] YYYY H:mm',
7203 LLLL
: 'dddd, D [de] MMMM [de] YYYY H:mm'
7206 sameDay : function () {
7207 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7209 nextDay : function () {
7210 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7212 nextWeek : function () {
7213 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7215 lastDay : function () {
7216 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7218 lastWeek : function () {
7219 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7226 s
: 'unos segundos',
7239 dayOfMonthOrdinalParse
: /\d{1,2}º/,
7242 dow
: 1, // Monday is the first day of the week.
7243 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7247 //! moment.js locale configuration
7249 function processRelativeTime
$3(number
, withoutSuffix
, key
, isFuture
) {
7251 's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
7252 'ss': [number
+ 'sekundi', number
+ 'sekundit'],
7253 'm' : ['ühe minuti', 'üks minut'],
7254 'mm': [number
+ ' minuti', number
+ ' minutit'],
7255 'h' : ['ühe tunni', 'tund aega', 'üks tund'],
7256 'hh': [number
+ ' tunni', number
+ ' tundi'],
7257 'd' : ['ühe päeva', 'üks päev'],
7258 'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
7259 'MM': [number
+ ' kuu', number
+ ' kuud'],
7260 'y' : ['ühe aasta', 'aasta', 'üks aasta'],
7261 'yy': [number
+ ' aasta', number
+ ' aastat']
7263 if (withoutSuffix
) {
7264 return format
[key
][2] ? format
[key
][2] : format
[key
][1];
7266 return isFuture
? format
[key
][0] : format
[key
][1];
7269 hooks
.defineLocale('et', {
7270 months
: 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
7271 monthsShort
: 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
7272 weekdays
: 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
7273 weekdaysShort
: 'P_E_T_K_N_R_L'.split('_'),
7274 weekdaysMin
: 'P_E_T_K_N_R_L'.split('_'),
7279 LL
: 'D. MMMM YYYY',
7280 LLL
: 'D. MMMM YYYY H:mm',
7281 LLLL
: 'dddd, D. MMMM YYYY H:mm'
7284 sameDay
: '[Täna,] LT',
7285 nextDay
: '[Homme,] LT',
7286 nextWeek
: '[Järgmine] dddd LT',
7287 lastDay
: '[Eile,] LT',
7288 lastWeek
: '[Eelmine] dddd LT',
7292 future
: '%s pärast',
7294 s
: processRelativeTime
$3,
7295 ss
: processRelativeTime
$3,
7296 m
: processRelativeTime
$3,
7297 mm
: processRelativeTime
$3,
7298 h
: processRelativeTime
$3,
7299 hh
: processRelativeTime
$3,
7300 d
: processRelativeTime
$3,
7302 M
: processRelativeTime
$3,
7303 MM
: processRelativeTime
$3,
7304 y
: processRelativeTime
$3,
7305 yy
: processRelativeTime
$3
7307 dayOfMonthOrdinalParse
: /\d{1,2}\./,
7310 dow
: 1, // Monday is the first day of the week.
7311 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7315 //! moment.js locale configuration
7317 hooks
.defineLocale('eu', {
7318 months
: 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
7319 monthsShort
: 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
7320 monthsParseExact
: true,
7321 weekdays
: 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
7322 weekdaysShort
: 'ig._al._ar._az._og._ol._lr.'.split('_'),
7323 weekdaysMin
: 'ig_al_ar_az_og_ol_lr'.split('_'),
7324 weekdaysParseExact
: true,
7329 LL
: 'YYYY[ko] MMMM[ren] D[a]',
7330 LLL
: 'YYYY[ko] MMMM[ren] D[a] HH:mm',
7331 LLLL
: 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
7333 ll
: 'YYYY[ko] MMM D[a]',
7334 lll
: 'YYYY[ko] MMM D[a] HH:mm',
7335 llll
: 'ddd, YYYY[ko] MMM D[a] HH:mm'
7338 sameDay
: '[gaur] LT[etan]',
7339 nextDay
: '[bihar] LT[etan]',
7340 nextWeek
: 'dddd LT[etan]',
7341 lastDay
: '[atzo] LT[etan]',
7342 lastWeek
: '[aurreko] dddd LT[etan]',
7346 future
: '%s barru',
7348 s
: 'segundo batzuk',
7361 dayOfMonthOrdinalParse
: /\d{1,2}\./,
7364 dow
: 1, // Monday is the first day of the week.
7365 doy
: 7 // The week that contains Jan 1st is the first week of the year.
7369 //! moment.js locale configuration
7395 hooks
.defineLocale('fa', {
7396 months
: 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
7397 monthsShort
: 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
7398 weekdays
: 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
7399 weekdaysShort
: 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
7400 weekdaysMin
: 'ی_د_س_چ_پ_ج_ش'.split('_'),
7401 weekdaysParseExact
: true,
7407 LLL
: 'D MMMM YYYY HH:mm',
7408 LLLL
: 'dddd, D MMMM YYYY HH:mm'
7410 meridiemParse
: /قبل از ظهر|بعد از ظهر/,
7411 isPM: function (input
) {
7412 return /بعد از ظهر/.test(input
);
7414 meridiem : function (hour
, minute
, isLower
) {
7416 return 'قبل از ظهر';
7418 return 'بعد از ظهر';
7422 sameDay
: '[امروز ساعت] LT',
7423 nextDay
: '[فردا ساعت] LT',
7424 nextWeek
: 'dddd [ساعت] LT',
7425 lastDay
: '[دیروز ساعت] LT',
7426 lastWeek
: 'dddd [پیش] [ساعت] LT',
7445 preparse: function (string
) {
7446 return string
.replace(/[۰-۹]/g, function (match
) {
7447 return numberMap
$4[match
];
7448 }).replace(/،/g, ',');
7450 postformat: function (string
) {
7451 return string
.replace(/\d/g, function (match
) {
7452 return symbolMap
$5[match
];
7453 }).replace(/,/g
, '،');
7455 dayOfMonthOrdinalParse
: /\d{1,2}م/,
7458 dow
: 6, // Saturday is the first day of the week.
7459 doy
: 12 // The week that contains Jan 1st is the first week of the year.
7463 //! moment.js locale configuration
7465 var numbersPast
= 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '),
7467 'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
7468 numbersPast
[7], numbersPast
[8], numbersPast
[9]
7470 function translate
$2(number
, withoutSuffix
, key
, isFuture
) {
7474 return isFuture
? 'muutaman sekunnin' : 'muutama sekunti';
7476 return isFuture
? 'sekunnin' : 'sekuntia';
7478 return isFuture
? 'minuutin' : 'minuutti';
7480 result
= isFuture
? 'minuutin' : 'minuuttia';
7483 return isFuture
? 'tunnin' : 'tunti';
7485 result
= isFuture
? 'tunnin' : 'tuntia';
7488 return isFuture
? 'päivän' : 'päivä';
7490 result
= isFuture
? 'päivän' : 'päivää';
7493 return isFuture
? 'kuukauden' : 'kuukausi';
7495 result
= isFuture
? 'kuukauden' : 'kuukautta';
7498 return isFuture
? 'vuoden' : 'vuosi';
7500 result
= isFuture
? 'vuoden' : 'vuotta';
7503 result
= verbalNumber(number
, isFuture
) + ' ' + result
;
7506 function verbalNumber(number
, isFuture
) {
7507 return number
< 10 ? (isFuture
? numbersFuture
[number
] : numbersPast
[number
]) : number
;
7510 hooks
.defineLocale('fi', {
7511 months
: 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
7512 monthsShort
: 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
7513 weekdays
: 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
7514 weekdaysShort
: 'su_ma_ti_ke_to_pe_la'.split('_'),
7515 weekdaysMin
: 'su_ma_ti_ke_to_pe_la'.split('_'),
7520 LL
: 'Do MMMM[ta] YYYY',
7521 LLL
: 'Do MMMM[ta] YYYY, [klo] HH.mm',
7522 LLLL
: 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
7525 lll
: 'Do MMM YYYY, [klo] HH.mm',
7526 llll
: 'ddd, Do MMM YYYY, [klo] HH.mm'
7529 sameDay
: '[tänään] [klo] LT',
7530 nextDay
: '[huomenna] [klo] LT',
7531 nextWeek
: 'dddd [klo] LT',
7532 lastDay
: '[eilen] [klo] LT',
7533 lastWeek
: '[viime] dddd[na] [klo] LT',
7537 future
: '%s päästä',
7552 dayOfMonthOrdinalParse
: /\d{1,2}\./,
7555 dow
: 1, // Monday is the first day of the week.
7556 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7560 //! moment.js locale configuration
7562 hooks
.defineLocale('fo', {
7563 months
: 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
7564 monthsShort
: 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
7565 weekdays
: 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
7566 weekdaysShort
: 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
7567 weekdaysMin
: 'su_má_tý_mi_hó_fr_le'.split('_'),
7573 LLL
: 'D MMMM YYYY HH:mm',
7574 LLLL
: 'dddd D. MMMM, YYYY HH:mm'
7577 sameDay
: '[Í dag kl.] LT',
7578 nextDay
: '[Í morgin kl.] LT',
7579 nextWeek
: 'dddd [kl.] LT',
7580 lastDay
: '[Í gjár kl.] LT',
7581 lastWeek
: '[síðstu] dddd [kl] LT',
7600 dayOfMonthOrdinalParse
: /\d{1,2}\./,
7603 dow
: 1, // Monday is the first day of the week.
7604 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7608 //! moment.js locale configuration
7610 hooks
.defineLocale('fr-ca', {
7611 months
: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
7612 monthsShort
: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
7613 monthsParseExact
: true,
7614 weekdays
: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7615 weekdaysShort
: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7616 weekdaysMin
: 'di_lu_ma_me_je_ve_sa'.split('_'),
7617 weekdaysParseExact
: true,
7623 LLL
: 'D MMMM YYYY HH:mm',
7624 LLLL
: 'dddd D MMMM YYYY HH:mm'
7627 sameDay
: '[Aujourd’hui à] LT',
7628 nextDay
: '[Demain à] LT',
7629 nextWeek
: 'dddd [à] LT',
7630 lastDay
: '[Hier à] LT',
7631 lastWeek
: 'dddd [dernier à] LT',
7637 s
: 'quelques secondes',
7650 dayOfMonthOrdinalParse
: /\d{1,2}(er|e)/,
7651 ordinal : function (number
, period
) {
7653 // Words with masculine grammatical gender: mois, trimestre, jour
7660 return number
+ (number
=== 1 ? 'er' : 'e');
7662 // Words with feminine grammatical gender: semaine
7665 return number
+ (number
=== 1 ? 're' : 'e');
7670 //! moment.js locale configuration
7672 hooks
.defineLocale('fr-ch', {
7673 months
: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
7674 monthsShort
: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
7675 monthsParseExact
: true,
7676 weekdays
: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7677 weekdaysShort
: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7678 weekdaysMin
: 'di_lu_ma_me_je_ve_sa'.split('_'),
7679 weekdaysParseExact
: true,
7685 LLL
: 'D MMMM YYYY HH:mm',
7686 LLLL
: 'dddd D MMMM YYYY HH:mm'
7689 sameDay
: '[Aujourd’hui à] LT',
7690 nextDay
: '[Demain à] LT',
7691 nextWeek
: 'dddd [à] LT',
7692 lastDay
: '[Hier à] LT',
7693 lastWeek
: 'dddd [dernier à] LT',
7699 s
: 'quelques secondes',
7712 dayOfMonthOrdinalParse
: /\d{1,2}(er|e)/,
7713 ordinal : function (number
, period
) {
7715 // Words with masculine grammatical gender: mois, trimestre, jour
7722 return number
+ (number
=== 1 ? 'er' : 'e');
7724 // Words with feminine grammatical gender: semaine
7727 return number
+ (number
=== 1 ? 're' : 'e');
7731 dow
: 1, // Monday is the first day of the week.
7732 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7736 //! moment.js locale configuration
7738 hooks
.defineLocale('fr', {
7739 months
: 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
7740 monthsShort
: 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
7741 monthsParseExact
: true,
7742 weekdays
: 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7743 weekdaysShort
: 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7744 weekdaysMin
: 'di_lu_ma_me_je_ve_sa'.split('_'),
7745 weekdaysParseExact
: true,
7751 LLL
: 'D MMMM YYYY HH:mm',
7752 LLLL
: 'dddd D MMMM YYYY HH:mm'
7755 sameDay
: '[Aujourd’hui à] LT',
7756 nextDay
: '[Demain à] LT',
7757 nextWeek
: 'dddd [à] LT',
7758 lastDay
: '[Hier à] LT',
7759 lastWeek
: 'dddd [dernier à] LT',
7765 s
: 'quelques secondes',
7778 dayOfMonthOrdinalParse
: /\d{1,2}(er|)/,
7779 ordinal : function (number
, period
) {
7781 // TODO: Return 'e' when day of month > 1. Move this case inside
7782 // block for masculine words below.
7783 // See https://github.com/moment/moment/issues/3375
7785 return number
+ (number
=== 1 ? 'er' : '');
7787 // Words with masculine grammatical gender: mois, trimestre, jour
7793 return number
+ (number
=== 1 ? 'er' : 'e');
7795 // Words with feminine grammatical gender: semaine
7798 return number
+ (number
=== 1 ? 're' : 'e');
7802 dow
: 1, // Monday is the first day of the week.
7803 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7807 //! moment.js locale configuration
7809 var monthsShortWithDots
= 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'),
7810 monthsShortWithoutDots
= 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
7812 hooks
.defineLocale('fy', {
7813 months
: 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
7814 monthsShort : function (m
, format
) {
7816 return monthsShortWithDots
;
7817 } else if (/-MMM-/.test(format
)) {
7818 return monthsShortWithoutDots
[m
.month()];
7820 return monthsShortWithDots
[m
.month()];
7823 monthsParseExact
: true,
7824 weekdays
: 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
7825 weekdaysShort
: 'si._mo._ti._wo._to._fr._so.'.split('_'),
7826 weekdaysMin
: 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
7827 weekdaysParseExact
: true,
7833 LLL
: 'D MMMM YYYY HH:mm',
7834 LLLL
: 'dddd D MMMM YYYY HH:mm'
7837 sameDay
: '[hjoed om] LT',
7838 nextDay
: '[moarn om] LT',
7839 nextWeek
: 'dddd [om] LT',
7840 lastDay
: '[juster om] LT',
7841 lastWeek
: '[ôfrûne] dddd [om] LT',
7847 s
: 'in pear sekonden',
7860 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
7861 ordinal : function (number
) {
7862 return number
+ ((number
=== 1 || number
=== 8 || number
>= 20) ? 'ste' : 'de');
7865 dow
: 1, // Monday is the first day of the week.
7866 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7870 //! moment.js locale configuration
7873 'Am Faoilleach', 'An Gearran', 'Am Màrt', 'An Giblean', 'An Cèitean', 'An t-Ògmhios', 'An t-Iuchar', 'An Lùnastal', 'An t-Sultain', 'An Dàmhair', 'An t-Samhain', 'An Dùbhlachd'
7876 var monthsShort
$4 = ['Faoi', 'Gear', 'Màrt', 'Gibl', 'Cèit', 'Ògmh', 'Iuch', 'Lùn', 'Sult', 'Dàmh', 'Samh', 'Dùbh'];
7878 var weekdays
$1 = ['Didòmhnaich', 'Diluain', 'Dimàirt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];
7880 var weekdaysShort
= ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];
7882 var weekdaysMin
= ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];
7884 hooks
.defineLocale('gd', {
7886 monthsShort
: monthsShort
$4,
7887 monthsParseExact
: true,
7888 weekdays
: weekdays
$1,
7889 weekdaysShort
: weekdaysShort
,
7890 weekdaysMin
: weekdaysMin
,
7896 LLL
: 'D MMMM YYYY HH:mm',
7897 LLLL
: 'dddd, D MMMM YYYY HH:mm'
7900 sameDay
: '[An-diugh aig] LT',
7901 nextDay
: '[A-màireach aig] LT',
7902 nextWeek
: 'dddd [aig] LT',
7903 lastDay
: '[An-dè aig] LT',
7904 lastWeek
: 'dddd [seo chaidh] [aig] LT',
7908 future
: 'ann an %s',
7909 past
: 'bho chionn %s',
7910 s
: 'beagan diogan',
7913 mm
: '%d mionaidean',
7923 dayOfMonthOrdinalParse
: /\d{1,2}(d|na|mh)/,
7924 ordinal : function (number
) {
7925 var output
= number
=== 1 ? 'd' : number
% 10 === 2 ? 'na' : 'mh';
7926 return number
+ output
;
7929 dow
: 1, // Monday is the first day of the week.
7930 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7934 //! moment.js locale configuration
7936 hooks
.defineLocale('gl', {
7937 months
: 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split('_'),
7938 monthsShort
: 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split('_'),
7939 monthsParseExact
: true,
7940 weekdays
: 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'),
7941 weekdaysShort
: 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'),
7942 weekdaysMin
: 'do_lu_ma_mé_xo_ve_sá'.split('_'),
7943 weekdaysParseExact
: true,
7948 LL
: 'D [de] MMMM [de] YYYY',
7949 LLL
: 'D [de] MMMM [de] YYYY H:mm',
7950 LLLL
: 'dddd, D [de] MMMM [de] YYYY H:mm'
7953 sameDay : function () {
7954 return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
7956 nextDay : function () {
7957 return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
7959 nextWeek : function () {
7960 return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
7962 lastDay : function () {
7963 return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
7965 lastWeek : function () {
7966 return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
7971 future : function (str
) {
7972 if (str
.indexOf('un') === 0) {
7991 dayOfMonthOrdinalParse
: /\d{1,2}º/,
7994 dow
: 1, // Monday is the first day of the week.
7995 doy
: 4 // The week that contains Jan 4th is the first week of the year.
7999 //! moment.js locale configuration
8001 function processRelativeTime
$4(number
, withoutSuffix
, key
, isFuture
) {
8003 's': ['thodde secondanim', 'thodde second'],
8004 'ss': [number
+ ' secondanim', number
+ ' second'],
8005 'm': ['eka mintan', 'ek minute'],
8006 'mm': [number
+ ' mintanim', number
+ ' mintam'],
8007 'h': ['eka horan', 'ek hor'],
8008 'hh': [number
+ ' horanim', number
+ ' horam'],
8009 'd': ['eka disan', 'ek dis'],
8010 'dd': [number
+ ' disanim', number
+ ' dis'],
8011 'M': ['eka mhoinean', 'ek mhoino'],
8012 'MM': [number
+ ' mhoineanim', number
+ ' mhoine'],
8013 'y': ['eka vorsan', 'ek voros'],
8014 'yy': [number
+ ' vorsanim', number
+ ' vorsam']
8016 return withoutSuffix
? format
[key
][0] : format
[key
][1];
8019 hooks
.defineLocale('gom-latn', {
8020 months
: 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split('_'),
8021 monthsShort
: 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split('_'),
8022 monthsParseExact
: true,
8023 weekdays
: 'Aitar_Somar_Mongllar_Budvar_Brestar_Sukrar_Son\'var'.split('_'),
8024 weekdaysShort
: 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'),
8025 weekdaysMin
: 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'),
8026 weekdaysParseExact
: true,
8028 LT
: 'A h:mm [vazta]',
8029 LTS
: 'A h:mm:ss [vazta]',
8032 LLL
: 'D MMMM YYYY A h:mm [vazta]',
8033 LLLL
: 'dddd, MMMM[achea] Do, YYYY, A h:mm [vazta]',
8034 llll
: 'ddd, D MMM YYYY, A h:mm [vazta]'
8037 sameDay
: '[Aiz] LT',
8038 nextDay
: '[Faleam] LT',
8039 nextWeek
: '[Ieta to] dddd[,] LT',
8040 lastDay
: '[Kal] LT',
8041 lastWeek
: '[Fatlo] dddd[,] LT',
8047 s
: processRelativeTime
$4,
8048 ss
: processRelativeTime
$4,
8049 m
: processRelativeTime
$4,
8050 mm
: processRelativeTime
$4,
8051 h
: processRelativeTime
$4,
8052 hh
: processRelativeTime
$4,
8053 d
: processRelativeTime
$4,
8054 dd
: processRelativeTime
$4,
8055 M
: processRelativeTime
$4,
8056 MM
: processRelativeTime
$4,
8057 y
: processRelativeTime
$4,
8058 yy
: processRelativeTime
$4
8060 dayOfMonthOrdinalParse
: /\d{1,2}(er)/,
8061 ordinal : function (number
, period
) {
8063 // the ordinal 'er' only applies to day of the month
8065 return number
+ 'er';
8077 dow
: 1, // Monday is the first day of the week.
8078 doy
: 4 // The week that contains Jan 4th is the first week of the year.
8080 meridiemParse
: /rati|sokalli|donparam|sanje/,
8081 meridiemHour : function (hour
, meridiem
) {
8085 if (meridiem
=== 'rati') {
8086 return hour
< 4 ? hour
: hour
+ 12;
8087 } else if (meridiem
=== 'sokalli') {
8089 } else if (meridiem
=== 'donparam') {
8090 return hour
> 12 ? hour
: hour
+ 12;
8091 } else if (meridiem
=== 'sanje') {
8095 meridiem : function (hour
, minute
, isLower
) {
8098 } else if (hour
< 12) {
8100 } else if (hour
< 16) {
8102 } else if (hour
< 20) {
8110 //! moment.js locale configuration
8137 hooks
.defineLocale('gu', {
8138 months
: 'જાન્યુઆરી_ફેબ્રુઆરી_માર્ચ_એપ્રિલ_મે_જૂન_જુલાઈ_ઑગસ્ટ_સપ્ટેમ્બર_ઑક્ટ્બર_નવેમ્બર_ડિસેમ્બર'.split('_'),
8139 monthsShort
: 'જાન્યુ._ફેબ્રુ._માર્ચ_એપ્રિ._મે_જૂન_જુલા._ઑગ._સપ્ટે._ઑક્ટ્._નવે._ડિસે.'.split('_'),
8140 monthsParseExact
: true,
8141 weekdays
: 'રવિવાર_સોમવાર_મંગળવાર_બુધ્વાર_ગુરુવાર_શુક્રવાર_શનિવાર'.split('_'),
8142 weekdaysShort
: 'રવિ_સોમ_મંગળ_બુધ્_ગુરુ_શુક્ર_શનિ'.split('_'),
8143 weekdaysMin
: 'ર_સો_મં_બુ_ગુ_શુ_શ'.split('_'),
8145 LT
: 'A h:mm વાગ્યે',
8146 LTS
: 'A h:mm:ss વાગ્યે',
8149 LLL
: 'D MMMM YYYY, A h:mm વાગ્યે',
8150 LLLL
: 'dddd, D MMMM YYYY, A h:mm વાગ્યે'
8154 nextDay
: '[કાલે] LT',
8155 nextWeek
: 'dddd, LT',
8156 lastDay
: '[ગઇકાલે] LT',
8157 lastWeek
: '[પાછલા] dddd, LT',
8176 preparse: function (string
) {
8177 return string
.replace(/[૧૨૩૪૫૬૭૮૯૦]/g, function (match
) {
8178 return numberMap
$5[match
];
8181 postformat: function (string
) {
8182 return string
.replace(/\d/g, function (match
) {
8183 return symbolMap
$6[match
];
8186 // Gujarati notation for meridiems are quite fuzzy in practice. While there exists
8187 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Gujarati.
8188 meridiemParse
: /રાત|બપોર|સવાર|સાંજ/,
8189 meridiemHour: function (hour
, meridiem
) {
8193 if (meridiem
=== 'રાત') {
8194 return hour
< 4 ? hour
: hour
+ 12;
8195 } else if (meridiem
=== 'સવાર') {
8197 } else if (meridiem
=== 'બપોર') {
8198 return hour
>= 10 ? hour
: hour
+ 12;
8199 } else if (meridiem
=== 'સાંજ') {
8203 meridiem: function (hour
, minute
, isLower
) {
8206 } else if (hour
< 10) {
8208 } else if (hour
< 17) {
8210 } else if (hour
< 20) {
8217 dow
: 0, // Sunday is the first day of the week.
8218 doy
: 6 // The week that contains Jan 1st is the first week of the year.
8222 //! moment.js locale configuration
8224 hooks
.defineLocale('he', {
8225 months
: 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
8226 monthsShort
: 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split('_'),
8227 weekdays
: 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
8228 weekdaysShort
: 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
8229 weekdaysMin
: 'א_ב_ג_ד_ה_ו_ש'.split('_'),
8234 LL
: 'D [ב]MMMM YYYY',
8235 LLL
: 'D [ב]MMMM YYYY HH:mm',
8236 LLLL
: 'dddd, D [ב]MMMM YYYY HH:mm',
8239 lll
: 'D MMM YYYY HH:mm',
8240 llll
: 'ddd, D MMM YYYY HH:mm'
8243 sameDay
: '[היום ב־]LT',
8244 nextDay
: '[מחר ב־]LT',
8245 nextWeek
: 'dddd [בשעה] LT',
8246 lastDay
: '[אתמול ב־]LT',
8247 lastWeek
: '[ביום] dddd [האחרון בשעה] LT',
8258 hh : function (number
) {
8262 return number
+ ' שעות';
8265 dd : function (number
) {
8269 return number
+ ' ימים';
8272 MM : function (number
) {
8276 return number
+ ' חודשים';
8279 yy : function (number
) {
8282 } else if (number
% 10 === 0 && number
!== 10) {
8283 return number
+ ' שנה';
8285 return number
+ ' שנים';
8288 meridiemParse
: /אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,
8289 isPM : function (input
) {
8290 return /^(אחה"צ|אחרי הצהריים|בערב)$/.test(input
);
8292 meridiem : function (hour
, minute
, isLower
) {
8294 return 'לפנות בוקר';
8295 } else if (hour
< 10) {
8297 } else if (hour
< 12) {
8298 return isLower
? 'לפנה"צ' : 'לפני הצהריים';
8299 } else if (hour
< 18) {
8300 return isLower
? 'אחה"צ' : 'אחרי הצהריים';
8307 //! moment.js locale configuration
8334 hooks
.defineLocale('hi', {
8335 months
: 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split('_'),
8336 monthsShort
: 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split('_'),
8337 monthsParseExact
: true,
8338 weekdays
: 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
8339 weekdaysShort
: 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
8340 weekdaysMin
: 'र_सो_मं_बु_गु_शु_श'.split('_'),
8343 LTS
: 'A h:mm:ss बजे',
8346 LLL
: 'D MMMM YYYY, A h:mm बजे',
8347 LLLL
: 'dddd, D MMMM YYYY, A h:mm बजे'
8350 sameDay
: '[आज] LT',
8351 nextDay
: '[कल] LT',
8352 nextWeek
: 'dddd, LT',
8353 lastDay
: '[कल] LT',
8354 lastWeek
: '[पिछले] dddd, LT',
8373 preparse: function (string
) {
8374 return string
.replace(/[१२३४५६७८९०]/g, function (match
) {
8375 return numberMap
$6[match
];
8378 postformat: function (string
) {
8379 return string
.replace(/\d/g, function (match
) {
8380 return symbolMap
$7[match
];
8383 // Hindi notation for meridiems are quite fuzzy in practice. While there exists
8384 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
8385 meridiemParse
: /रात|सुबह|दोपहर|शाम/,
8386 meridiemHour : function (hour
, meridiem
) {
8390 if (meridiem
=== 'रात') {
8391 return hour
< 4 ? hour
: hour
+ 12;
8392 } else if (meridiem
=== 'सुबह') {
8394 } else if (meridiem
=== 'दोपहर') {
8395 return hour
>= 10 ? hour
: hour
+ 12;
8396 } else if (meridiem
=== 'शाम') {
8400 meridiem : function (hour
, minute
, isLower
) {
8403 } else if (hour
< 10) {
8405 } else if (hour
< 17) {
8407 } else if (hour
< 20) {
8414 dow
: 0, // Sunday is the first day of the week.
8415 doy
: 6 // The week that contains Jan 1st is the first week of the year.
8419 //! moment.js locale configuration
8421 function translate
$3(number
, withoutSuffix
, key
) {
8422 var result
= number
+ ' ';
8426 result
+= 'sekunda';
8427 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
8428 result
+= 'sekunde';
8430 result
+= 'sekundi';
8434 return withoutSuffix
? 'jedna minuta' : 'jedne minute';
8438 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
8445 return withoutSuffix
? 'jedan sat' : 'jednog sata';
8449 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
8465 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
8466 result
+= 'mjeseca';
8468 result
+= 'mjeseci';
8474 } else if (number
=== 2 || number
=== 3 || number
=== 4) {
8483 hooks
.defineLocale('hr', {
8485 format
: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
8486 standalone
: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
8488 monthsShort
: 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
8489 monthsParseExact
: true,
8490 weekdays
: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
8491 weekdaysShort
: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
8492 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
8493 weekdaysParseExact
: true,
8498 LL
: 'D. MMMM YYYY',
8499 LLL
: 'D. MMMM YYYY H:mm',
8500 LLLL
: 'dddd, D. MMMM YYYY H:mm'
8503 sameDay
: '[danas u] LT',
8504 nextDay
: '[sutra u] LT',
8505 nextWeek : function () {
8506 switch (this.day()) {
8508 return '[u] [nedjelju] [u] LT';
8510 return '[u] [srijedu] [u] LT';
8512 return '[u] [subotu] [u] LT';
8517 return '[u] dddd [u] LT';
8520 lastDay
: '[jučer u] LT',
8521 lastWeek : function () {
8522 switch (this.day()) {
8525 return '[prošlu] dddd [u] LT';
8527 return '[prošle] [subote] [u] LT';
8532 return '[prošli] dddd [u] LT';
8553 dayOfMonthOrdinalParse
: /\d{1,2}\./,
8556 dow
: 1, // Monday is the first day of the week.
8557 doy
: 7 // The week that contains Jan 1st is the first week of the year.
8561 //! moment.js locale configuration
8563 var weekEndings
= 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');
8564 function translate
$4(number
, withoutSuffix
, key
, isFuture
) {
8568 return (isFuture
|| withoutSuffix
) ? 'néhány másodperc' : 'néhány másodperce';
8570 return num
+ (isFuture
|| withoutSuffix
) ? ' másodperc' : ' másodperce';
8572 return 'egy' + (isFuture
|| withoutSuffix
? ' perc' : ' perce');
8574 return num
+ (isFuture
|| withoutSuffix
? ' perc' : ' perce');
8576 return 'egy' + (isFuture
|| withoutSuffix
? ' óra' : ' órája');
8578 return num
+ (isFuture
|| withoutSuffix
? ' óra' : ' órája');
8580 return 'egy' + (isFuture
|| withoutSuffix
? ' nap' : ' napja');
8582 return num
+ (isFuture
|| withoutSuffix
? ' nap' : ' napja');
8584 return 'egy' + (isFuture
|| withoutSuffix
? ' hónap' : ' hónapja');
8586 return num
+ (isFuture
|| withoutSuffix
? ' hónap' : ' hónapja');
8588 return 'egy' + (isFuture
|| withoutSuffix
? ' év' : ' éve');
8590 return num
+ (isFuture
|| withoutSuffix
? ' év' : ' éve');
8594 function week(isFuture
) {
8595 return (isFuture
? '' : '[múlt] ') + '[' + weekEndings
[this.day()] + '] LT[-kor]';
8598 hooks
.defineLocale('hu', {
8599 months
: 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
8600 monthsShort
: 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
8601 weekdays
: 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
8602 weekdaysShort
: 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
8603 weekdaysMin
: 'v_h_k_sze_cs_p_szo'.split('_'),
8608 LL
: 'YYYY. MMMM D.',
8609 LLL
: 'YYYY. MMMM D. H:mm',
8610 LLLL
: 'YYYY. MMMM D., dddd H:mm'
8612 meridiemParse
: /de|du/i,
8613 isPM: function (input
) {
8614 return input
.charAt(1).toLowerCase() === 'u';
8616 meridiem : function (hours
, minutes
, isLower
) {
8618 return isLower
=== true ? 'de' : 'DE';
8620 return isLower
=== true ? 'du' : 'DU';
8624 sameDay
: '[ma] LT[-kor]',
8625 nextDay
: '[holnap] LT[-kor]',
8626 nextWeek : function () {
8627 return week
.call(this, true);
8629 lastDay
: '[tegnap] LT[-kor]',
8630 lastWeek : function () {
8631 return week
.call(this, false);
8636 future
: '%s múlva',
8651 dayOfMonthOrdinalParse
: /\d{1,2}\./,
8654 dow
: 1, // Monday is the first day of the week.
8655 doy
: 4 // The week that contains Jan 4th is the first week of the year.
8659 //! moment.js locale configuration
8661 hooks
.defineLocale('hy-am', {
8663 format
: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_'),
8664 standalone
: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_')
8666 monthsShort
: 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
8667 weekdays
: 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split('_'),
8668 weekdaysShort
: 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
8669 weekdaysMin
: 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
8674 LL
: 'D MMMM YYYY թ.',
8675 LLL
: 'D MMMM YYYY թ., HH:mm',
8676 LLLL
: 'dddd, D MMMM YYYY թ., HH:mm'
8679 sameDay
: '[այսօր] LT',
8680 nextDay
: '[վաղը] LT',
8681 lastDay
: '[երեկ] LT',
8682 nextWeek: function () {
8683 return 'dddd [օրը ժամը] LT';
8685 lastWeek: function () {
8686 return '[անցած] dddd [օրը ժամը] LT';
8693 s
: 'մի քանի վայրկյան',
8706 meridiemParse
: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
8707 isPM: function (input
) {
8708 return /^(ցերեկվա|երեկոյան)$/.test(input
);
8710 meridiem : function (hour
) {
8713 } else if (hour
< 12) {
8715 } else if (hour
< 17) {
8721 dayOfMonthOrdinalParse
: /\d{1,2}|\d{1,2}-(ին|րդ)/,
8722 ordinal: function (number
, period
) {
8729 return number
+ '-ին';
8731 return number
+ '-րդ';
8737 dow
: 1, // Monday is the first day of the week.
8738 doy
: 7 // The week that contains Jan 1st is the first week of the year.
8742 //! moment.js locale configuration
8744 hooks
.defineLocale('id', {
8745 months
: 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
8746 monthsShort
: 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des'.split('_'),
8747 weekdays
: 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
8748 weekdaysShort
: 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
8749 weekdaysMin
: 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
8755 LLL
: 'D MMMM YYYY [pukul] HH.mm',
8756 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm'
8758 meridiemParse
: /pagi|siang|sore|malam/,
8759 meridiemHour : function (hour
, meridiem
) {
8763 if (meridiem
=== 'pagi') {
8765 } else if (meridiem
=== 'siang') {
8766 return hour
>= 11 ? hour
: hour
+ 12;
8767 } else if (meridiem
=== 'sore' || meridiem
=== 'malam') {
8771 meridiem : function (hours
, minutes
, isLower
) {
8774 } else if (hours
< 15) {
8776 } else if (hours
< 19) {
8783 sameDay
: '[Hari ini pukul] LT',
8784 nextDay
: '[Besok pukul] LT',
8785 nextWeek
: 'dddd [pukul] LT',
8786 lastDay
: '[Kemarin pukul] LT',
8787 lastWeek
: 'dddd [lalu pukul] LT',
8791 future
: 'dalam %s',
8792 past
: '%s yang lalu',
8793 s
: 'beberapa detik',
8807 dow
: 1, // Monday is the first day of the week.
8808 doy
: 7 // The week that contains Jan 1st is the first week of the year.
8812 //! moment.js locale configuration
8814 function plural
$2(n
) {
8815 if (n
% 100 === 11) {
8817 } else if (n
% 10 === 1) {
8822 function translate
$5(number
, withoutSuffix
, key
, isFuture
) {
8823 var result
= number
+ ' ';
8826 return withoutSuffix
|| isFuture
? 'nokkrar sekúndur' : 'nokkrum sekúndum';
8828 if (plural
$2(number
)) {
8829 return result
+ (withoutSuffix
|| isFuture
? 'sekúndur' : 'sekúndum');
8831 return result
+ 'sekúnda';
8833 return withoutSuffix
? 'mínúta' : 'mínútu';
8835 if (plural
$2(number
)) {
8836 return result
+ (withoutSuffix
|| isFuture
? 'mínútur' : 'mínútum');
8837 } else if (withoutSuffix
) {
8838 return result
+ 'mínúta';
8840 return result
+ 'mínútu';
8842 if (plural
$2(number
)) {
8843 return result
+ (withoutSuffix
|| isFuture
? 'klukkustundir' : 'klukkustundum');
8845 return result
+ 'klukkustund';
8847 if (withoutSuffix
) {
8850 return isFuture
? 'dag' : 'degi';
8852 if (plural
$2(number
)) {
8853 if (withoutSuffix
) {
8854 return result
+ 'dagar';
8856 return result
+ (isFuture
? 'daga' : 'dögum');
8857 } else if (withoutSuffix
) {
8858 return result
+ 'dagur';
8860 return result
+ (isFuture
? 'dag' : 'degi');
8862 if (withoutSuffix
) {
8865 return isFuture
? 'mánuð' : 'mánuði';
8867 if (plural
$2(number
)) {
8868 if (withoutSuffix
) {
8869 return result
+ 'mánuðir';
8871 return result
+ (isFuture
? 'mánuði' : 'mánuðum');
8872 } else if (withoutSuffix
) {
8873 return result
+ 'mánuður';
8875 return result
+ (isFuture
? 'mánuð' : 'mánuði');
8877 return withoutSuffix
|| isFuture
? 'ár' : 'ári';
8879 if (plural
$2(number
)) {
8880 return result
+ (withoutSuffix
|| isFuture
? 'ár' : 'árum');
8882 return result
+ (withoutSuffix
|| isFuture
? 'ár' : 'ári');
8886 hooks
.defineLocale('is', {
8887 months
: 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split('_'),
8888 monthsShort
: 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
8889 weekdays
: 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
8890 weekdaysShort
: 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
8891 weekdaysMin
: 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
8896 LL
: 'D. MMMM YYYY',
8897 LLL
: 'D. MMMM YYYY [kl.] H:mm',
8898 LLLL
: 'dddd, D. MMMM YYYY [kl.] H:mm'
8901 sameDay
: '[í dag kl.] LT',
8902 nextDay
: '[á morgun kl.] LT',
8903 nextWeek
: 'dddd [kl.] LT',
8904 lastDay
: '[í gær kl.] LT',
8905 lastWeek
: '[síðasta] dddd [kl.] LT',
8909 future
: 'eftir %s',
8910 past
: 'fyrir %s síðan',
8924 dayOfMonthOrdinalParse
: /\d{1,2}\./,
8927 dow
: 1, // Monday is the first day of the week.
8928 doy
: 4 // The week that contains Jan 4th is the first week of the year.
8932 //! moment.js locale configuration
8934 hooks
.defineLocale('it', {
8935 months
: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
8936 monthsShort
: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
8937 weekdays
: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
8938 weekdaysShort
: 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
8939 weekdaysMin
: 'do_lu_ma_me_gi_ve_sa'.split('_'),
8945 LLL
: 'D MMMM YYYY HH:mm',
8946 LLLL
: 'dddd D MMMM YYYY HH:mm'
8949 sameDay
: '[Oggi alle] LT',
8950 nextDay
: '[Domani alle] LT',
8951 nextWeek
: 'dddd [alle] LT',
8952 lastDay
: '[Ieri alle] LT',
8953 lastWeek: function () {
8954 switch (this.day()) {
8956 return '[la scorsa] dddd [alle] LT';
8958 return '[lo scorso] dddd [alle] LT';
8964 future : function (s
) {
8965 return ((/^[0-9].+$/).test(s
) ? 'tra' : 'in') + ' ' + s
;
8968 s
: 'alcuni secondi',
8981 dayOfMonthOrdinalParse
: /\d{1,2}º/,
8984 dow
: 1, // Monday is the first day of the week.
8985 doy
: 4 // The week that contains Jan 4th is the first week of the year.
8989 //! moment.js locale configuration
8991 hooks
.defineLocale('ja', {
8992 months
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
8993 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
8994 weekdays
: '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
8995 weekdaysShort
: '日_月_火_水_木_金_土'.split('_'),
8996 weekdaysMin
: '日_月_火_水_木_金_土'.split('_'),
9002 LLL
: 'YYYY年M月D日 HH:mm',
9003 LLLL
: 'YYYY年M月D日 dddd HH:mm',
9006 lll
: 'YYYY年M月D日 HH:mm',
9007 llll
: 'YYYY年M月D日(ddd) HH:mm'
9009 meridiemParse
: /午前|午後/i,
9010 isPM : function (input
) {
9011 return input
=== '午後';
9013 meridiem : function (hour
, minute
, isLower
) {
9021 sameDay
: '[今日] LT',
9022 nextDay
: '[明日] LT',
9023 nextWeek : function (now
) {
9024 if (now
.week() < this.week()) {
9025 return '[来週]dddd LT';
9030 lastDay
: '[昨日] LT',
9031 lastWeek : function (now
) {
9032 if (this.week() < now
.week()) {
9033 return '[先週]dddd LT';
9040 dayOfMonthOrdinalParse
: /\d{1,2}日/,
9041 ordinal : function (number
, period
) {
9046 return number
+ '日';
9069 //! moment.js locale configuration
9071 hooks
.defineLocale('jv', {
9072 months
: 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
9073 monthsShort
: 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
9074 weekdays
: 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
9075 weekdaysShort
: 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
9076 weekdaysMin
: 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
9082 LLL
: 'D MMMM YYYY [pukul] HH.mm',
9083 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm'
9085 meridiemParse
: /enjing|siyang|sonten|ndalu/,
9086 meridiemHour : function (hour
, meridiem
) {
9090 if (meridiem
=== 'enjing') {
9092 } else if (meridiem
=== 'siyang') {
9093 return hour
>= 11 ? hour
: hour
+ 12;
9094 } else if (meridiem
=== 'sonten' || meridiem
=== 'ndalu') {
9098 meridiem : function (hours
, minutes
, isLower
) {
9101 } else if (hours
< 15) {
9103 } else if (hours
< 19) {
9110 sameDay
: '[Dinten puniko pukul] LT',
9111 nextDay
: '[Mbenjang pukul] LT',
9112 nextWeek
: 'dddd [pukul] LT',
9113 lastDay
: '[Kala wingi pukul] LT',
9114 lastWeek
: 'dddd [kepengker pukul] LT',
9118 future
: 'wonten ing %s',
9119 past
: '%s ingkang kepengker',
9120 s
: 'sawetawis detik',
9122 m
: 'setunggal menit',
9124 h
: 'setunggal jam',
9134 dow
: 1, // Monday is the first day of the week.
9135 doy
: 7 // The week that contains Jan 1st is the first week of the year.
9139 //! moment.js locale configuration
9141 hooks
.defineLocale('ka', {
9143 standalone
: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
9144 format
: 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
9146 monthsShort
: 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
9148 standalone
: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
9149 format
: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_'),
9150 isFormat
: /(წინა|შემდეგ)/
9152 weekdaysShort
: 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
9153 weekdaysMin
: 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
9159 LLL
: 'D MMMM YYYY h:mm A',
9160 LLLL
: 'dddd, D MMMM YYYY h:mm A'
9163 sameDay
: '[დღეს] LT[-ზე]',
9164 nextDay
: '[ხვალ] LT[-ზე]',
9165 lastDay
: '[გუშინ] LT[-ზე]',
9166 nextWeek
: '[შემდეგ] dddd LT[-ზე]',
9167 lastWeek
: '[წინა] dddd LT-ზე',
9171 future : function (s
) {
9172 return (/(წამი|წუთი|საათი|წელი)/).test(s
) ?
9173 s
.replace(/ი$/, 'ში') :
9176 past : function (s
) {
9177 if ((/(წამი|წუთი|საათი|დღე|თვე)/).test(s
)) {
9178 return s
.replace(/(ი|ე)$/, 'ის წინ');
9180 if ((/წელი/).test(s
)) {
9181 return s
.replace(/წელი$/, 'წლის წინ');
9184 s
: 'რამდენიმე წამი',
9197 dayOfMonthOrdinalParse
: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
9198 ordinal : function (number
) {
9203 return number
+ '-ლი';
9205 if ((number
< 20) || (number
<= 100 && (number
% 20 === 0)) || (number
% 100 === 0)) {
9206 return 'მე-' + number
;
9208 return number
+ '-ე';
9216 //! moment.js locale configuration
9241 hooks
.defineLocale('kk', {
9242 months
: 'қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан'.split('_'),
9243 monthsShort
: 'қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
9244 weekdays
: 'жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі'.split('_'),
9245 weekdaysShort
: 'жек_дүй_сей_сәр_бей_жұм_сен'.split('_'),
9246 weekdaysMin
: 'жк_дй_сй_ср_бй_жм_сн'.split('_'),
9252 LLL
: 'D MMMM YYYY HH:mm',
9253 LLLL
: 'dddd, D MMMM YYYY HH:mm'
9256 sameDay
: '[Бүгін сағат] LT',
9257 nextDay
: '[Ертең сағат] LT',
9258 nextWeek
: 'dddd [сағат] LT',
9259 lastDay
: '[Кеше сағат] LT',
9260 lastWeek
: '[Өткен аптаның] dddd [сағат] LT',
9264 future
: '%s ішінде',
9266 s
: 'бірнеше секунд',
9279 dayOfMonthOrdinalParse
: /\d{1,2}-(ші|шы)/,
9280 ordinal : function (number
) {
9281 var a
= number
% 10,
9282 b
= number
>= 100 ? 100 : null;
9283 return number
+ (suffixes
$1[number
] || suffixes
$1[a
] || suffixes
$1[b
]);
9286 dow
: 1, // Monday is the first day of the week.
9287 doy
: 7 // The week that contains Jan 1st is the first week of the year.
9291 //! moment.js locale configuration
9317 hooks
.defineLocale('km', {
9318 months
: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
9321 monthsShort
: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
9324 weekdays
: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
9325 weekdaysShort
: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
9326 weekdaysMin
: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
9327 weekdaysParseExact
: true,
9333 LLL
: 'D MMMM YYYY HH:mm',
9334 LLLL
: 'dddd, D MMMM YYYY HH:mm'
9336 meridiemParse
: /ព្រឹក|ល្ងាច/,
9337 isPM: function (input
) {
9338 return input
=== 'ល្ងាច';
9340 meridiem: function (hour
, minute
, isLower
) {
9348 sameDay
: '[ថ្ងៃនេះ ម៉ោង] LT',
9349 nextDay
: '[ស្អែក ម៉ោង] LT',
9350 nextWeek
: 'dddd [ម៉ោង] LT',
9351 lastDay
: '[ម្សិលមិញ ម៉ោង] LT',
9352 lastWeek
: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
9358 s
: 'ប៉ុន្មានវិនាទី',
9371 dayOfMonthOrdinalParse
: /ទី\d{1,2}/,
9373 preparse: function (string
) {
9374 return string
.replace(/[១២៣៤៥៦៧៨៩០]/g, function (match
) {
9375 return numberMap
$7[match
];
9378 postformat: function (string
) {
9379 return string
.replace(/\d/g, function (match
) {
9380 return symbolMap
$8[match
];
9384 dow
: 1, // Monday is the first day of the week.
9385 doy
: 4 // The week that contains Jan 4th is the first week of the year.
9389 //! moment.js locale configuration
9416 hooks
.defineLocale('kn', {
9417 months
: 'ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್'.split('_'),
9418 monthsShort
: 'ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂ_ಅಕ್ಟೋ_ನವೆಂ_ಡಿಸೆಂ'.split('_'),
9419 monthsParseExact
: true,
9420 weekdays
: 'ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ'.split('_'),
9421 weekdaysShort
: 'ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ'.split('_'),
9422 weekdaysMin
: 'ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ'.split('_'),
9428 LLL
: 'D MMMM YYYY, A h:mm',
9429 LLLL
: 'dddd, D MMMM YYYY, A h:mm'
9432 sameDay
: '[ಇಂದು] LT',
9433 nextDay
: '[ನಾಳೆ] LT',
9434 nextWeek
: 'dddd, LT',
9435 lastDay
: '[ನಿನ್ನೆ] LT',
9436 lastWeek
: '[ಕೊನೆಯ] dddd, LT',
9442 s
: 'ಕೆಲವು ಕ್ಷಣಗಳು',
9443 ss
: '%d ಸೆಕೆಂಡುಗಳು',
9455 preparse: function (string
) {
9456 return string
.replace(/[೧೨೩೪೫೬೭೮೯೦]/g, function (match
) {
9457 return numberMap
$8[match
];
9460 postformat: function (string
) {
9461 return string
.replace(/\d/g, function (match
) {
9462 return symbolMap
$9[match
];
9465 meridiemParse
: /ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,
9466 meridiemHour : function (hour
, meridiem
) {
9470 if (meridiem
=== 'ರಾತ್ರಿ') {
9471 return hour
< 4 ? hour
: hour
+ 12;
9472 } else if (meridiem
=== 'ಬೆಳಿಗ್ಗೆ') {
9474 } else if (meridiem
=== 'ಮಧ್ಯಾಹ್ನ') {
9475 return hour
>= 10 ? hour
: hour
+ 12;
9476 } else if (meridiem
=== 'ಸಂಜೆ') {
9480 meridiem : function (hour
, minute
, isLower
) {
9483 } else if (hour
< 10) {
9485 } else if (hour
< 17) {
9487 } else if (hour
< 20) {
9493 dayOfMonthOrdinalParse
: /\d{1,2}(ನೇ)/,
9494 ordinal : function (number
) {
9495 return number
+ 'ನೇ';
9498 dow
: 0, // Sunday is the first day of the week.
9499 doy
: 6 // The week that contains Jan 1st is the first week of the year.
9503 //! moment.js locale configuration
9505 hooks
.defineLocale('ko', {
9506 months
: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
9507 monthsShort
: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
9508 weekdays
: '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
9509 weekdaysShort
: '일_월_화_수_목_금_토'.split('_'),
9510 weekdaysMin
: '일_월_화_수_목_금_토'.split('_'),
9515 LL
: 'YYYY년 MMMM D일',
9516 LLL
: 'YYYY년 MMMM D일 A h:mm',
9517 LLLL
: 'YYYY년 MMMM D일 dddd A h:mm',
9519 ll
: 'YYYY년 MMMM D일',
9520 lll
: 'YYYY년 MMMM D일 A h:mm',
9521 llll
: 'YYYY년 MMMM D일 dddd A h:mm'
9526 nextWeek
: 'dddd LT',
9528 lastWeek
: '지난주 dddd LT',
9547 dayOfMonthOrdinalParse
: /\d{1,2}(일|월|주)/,
9548 ordinal : function (number
, period
) {
9553 return number
+ '일';
9555 return number
+ '월';
9558 return number
+ '주';
9563 meridiemParse
: /오전|오후/,
9564 isPM : function (token
) {
9565 return token
=== '오후';
9567 meridiem : function (hour
, minute
, isUpper
) {
9568 return hour
< 12 ? '오전' : '오후';
9572 //! moment.js locale configuration
9597 hooks
.defineLocale('ky', {
9598 months
: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
9599 monthsShort
: 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
9600 weekdays
: 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split('_'),
9601 weekdaysShort
: 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
9602 weekdaysMin
: 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
9608 LLL
: 'D MMMM YYYY HH:mm',
9609 LLLL
: 'dddd, D MMMM YYYY HH:mm'
9612 sameDay
: '[Бүгүн саат] LT',
9613 nextDay
: '[Эртең саат] LT',
9614 nextWeek
: 'dddd [саат] LT',
9615 lastDay
: '[Кече саат] LT',
9616 lastWeek
: '[Өткен аптанын] dddd [күнү] [саат] LT',
9620 future
: '%s ичинде',
9622 s
: 'бирнече секунд',
9635 dayOfMonthOrdinalParse
: /\d{1,2}-(чи|чы|чү|чу)/,
9636 ordinal : function (number
) {
9637 var a
= number
% 10,
9638 b
= number
>= 100 ? 100 : null;
9639 return number
+ (suffixes
$2[number
] || suffixes
$2[a
] || suffixes
$2[b
]);
9642 dow
: 1, // Monday is the first day of the week.
9643 doy
: 7 // The week that contains Jan 1st is the first week of the year.
9647 //! moment.js locale configuration
9649 function processRelativeTime
$5(number
, withoutSuffix
, key
, isFuture
) {
9651 'm': ['eng Minutt', 'enger Minutt'],
9652 'h': ['eng Stonn', 'enger Stonn'],
9653 'd': ['een Dag', 'engem Dag'],
9654 'M': ['ee Mount', 'engem Mount'],
9655 'y': ['ee Joer', 'engem Joer']
9657 return withoutSuffix
? format
[key
][0] : format
[key
][1];
9659 function processFutureTime(string
) {
9660 var number
= string
.substr(0, string
.indexOf(' '));
9661 if (eifelerRegelAppliesToNumber(number
)) {
9662 return 'a ' + string
;
9664 return 'an ' + string
;
9666 function processPastTime(string
) {
9667 var number
= string
.substr(0, string
.indexOf(' '));
9668 if (eifelerRegelAppliesToNumber(number
)) {
9669 return 'viru ' + string
;
9671 return 'virun ' + string
;
9674 * Returns true if the word before the given number loses the '-n' ending.
9675 * e.g. 'an 10 Deeg' but 'a 5 Deeg'
9677 * @param number {integer}
9678 * @returns {boolean}
9680 function eifelerRegelAppliesToNumber(number
) {
9681 number
= parseInt(number
, 10);
9682 if (isNaN(number
)) {
9686 // Negative Number --> always true
9688 } else if (number
< 10) {
9690 if (4 <= number
&& number
<= 7) {
9694 } else if (number
< 100) {
9696 var lastDigit
= number
% 10, firstDigit
= number
/ 10;
9697 if (lastDigit
=== 0) {
9698 return eifelerRegelAppliesToNumber(firstDigit
);
9700 return eifelerRegelAppliesToNumber(lastDigit
);
9701 } else if (number
< 10000) {
9702 // 3 or 4 digits --> recursively check first digit
9703 while (number
>= 10) {
9704 number
= number
/ 10;
9706 return eifelerRegelAppliesToNumber(number
);
9708 // Anything larger than 4 digits: recursively check first n-3 digits
9709 number
= number
/ 1000;
9710 return eifelerRegelAppliesToNumber(number
);
9714 hooks
.defineLocale('lb', {
9715 months
: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
9716 monthsShort
: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
9717 monthsParseExact
: true,
9718 weekdays
: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
9719 weekdaysShort
: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
9720 weekdaysMin
: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
9721 weekdaysParseExact
: true,
9724 LTS
: 'H:mm:ss [Auer]',
9727 LLL
: 'D. MMMM YYYY H:mm [Auer]',
9728 LLLL
: 'dddd, D. MMMM YYYY H:mm [Auer]'
9731 sameDay
: '[Haut um] LT',
9733 nextDay
: '[Muer um] LT',
9734 nextWeek
: 'dddd [um] LT',
9735 lastDay
: '[Gëschter um] LT',
9736 lastWeek: function () {
9737 // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
9738 switch (this.day()) {
9741 return '[Leschten] dddd [um] LT';
9743 return '[Leschte] dddd [um] LT';
9748 future
: processFutureTime
,
9749 past
: processPastTime
,
9750 s
: 'e puer Sekonnen',
9752 m
: processRelativeTime
$5,
9754 h
: processRelativeTime
$5,
9756 d
: processRelativeTime
$5,
9758 M
: processRelativeTime
$5,
9760 y
: processRelativeTime
$5,
9763 dayOfMonthOrdinalParse
: /\d{1,2}\./,
9766 dow
: 1, // Monday is the first day of the week.
9767 doy
: 4 // The week that contains Jan 4th is the first week of the year.
9771 //! moment.js locale configuration
9773 hooks
.defineLocale('lo', {
9774 months
: 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
9775 monthsShort
: 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
9776 weekdays
: 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
9777 weekdaysShort
: 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
9778 weekdaysMin
: 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
9779 weekdaysParseExact
: true,
9785 LLL
: 'D MMMM YYYY HH:mm',
9786 LLLL
: 'ວັນdddd D MMMM YYYY HH:mm'
9788 meridiemParse
: /ຕອນເຊົ້າ|ຕອນແລງ/,
9789 isPM: function (input
) {
9790 return input
=== 'ຕອນແລງ';
9792 meridiem : function (hour
, minute
, isLower
) {
9800 sameDay
: '[ມື້ນີ້ເວລາ] LT',
9801 nextDay
: '[ມື້ອື່ນເວລາ] LT',
9802 nextWeek
: '[ວັນ]dddd[ໜ້າເວລາ] LT',
9803 lastDay
: '[ມື້ວານນີ້ເວລາ] LT',
9804 lastWeek
: '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
9810 s
: 'ບໍ່ເທົ່າໃດວິນາທີ',
9823 dayOfMonthOrdinalParse
: /(ທີ່)\d{1,2}/,
9824 ordinal : function (number
) {
9825 return 'ທີ່' + number
;
9829 //! moment.js locale configuration
9832 'ss' : 'sekundė_sekundžių_sekundes',
9833 'm' : 'minutė_minutės_minutę',
9834 'mm': 'minutės_minučių_minutes',
9835 'h' : 'valanda_valandos_valandą',
9836 'hh': 'valandos_valandų_valandas',
9837 'd' : 'diena_dienos_dieną',
9838 'dd': 'dienos_dienų_dienas',
9839 'M' : 'mėnuo_mėnesio_mėnesį',
9840 'MM': 'mėnesiai_mėnesių_mėnesius',
9841 'y' : 'metai_metų_metus',
9842 'yy': 'metai_metų_metus'
9844 function translateSeconds(number
, withoutSuffix
, key
, isFuture
) {
9845 if (withoutSuffix
) {
9846 return 'kelios sekundės';
9848 return isFuture
? 'kelių sekundžių' : 'kelias sekundes';
9851 function translateSingular(number
, withoutSuffix
, key
, isFuture
) {
9852 return withoutSuffix
? forms(key
)[0] : (isFuture
? forms(key
)[1] : forms(key
)[2]);
9854 function special(number
) {
9855 return number
% 10 === 0 || (number
> 10 && number
< 20);
9857 function forms(key
) {
9858 return units
[key
].split('_');
9860 function translate
$6(number
, withoutSuffix
, key
, isFuture
) {
9861 var result
= number
+ ' ';
9863 return result
+ translateSingular(number
, withoutSuffix
, key
[0], isFuture
);
9864 } else if (withoutSuffix
) {
9865 return result
+ (special(number
) ? forms(key
)[1] : forms(key
)[0]);
9868 return result
+ forms(key
)[1];
9870 return result
+ (special(number
) ? forms(key
)[1] : forms(key
)[2]);
9874 hooks
.defineLocale('lt', {
9876 format
: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
9877 standalone
: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_'),
9878 isFormat
: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/
9880 monthsShort
: 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
9882 format
: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split('_'),
9883 standalone
: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split('_'),
9884 isFormat
: /dddd HH:mm/
9886 weekdaysShort
: 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
9887 weekdaysMin
: 'S_P_A_T_K_Pn_Š'.split('_'),
9888 weekdaysParseExact
: true,
9893 LL
: 'YYYY [m.] MMMM D [d.]',
9894 LLL
: 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
9895 LLLL
: 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
9897 ll
: 'YYYY [m.] MMMM D [d.]',
9898 lll
: 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
9899 llll
: 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
9902 sameDay
: '[Šiandien] LT',
9903 nextDay
: '[Rytoj] LT',
9904 nextWeek
: 'dddd LT',
9905 lastDay
: '[Vakar] LT',
9906 lastWeek
: '[Praėjusį] dddd LT',
9912 s
: translateSeconds
,
9914 m
: translateSingular
,
9916 h
: translateSingular
,
9918 d
: translateSingular
,
9920 M
: translateSingular
,
9922 y
: translateSingular
,
9925 dayOfMonthOrdinalParse
: /\d{1,2}-oji/,
9926 ordinal : function (number
) {
9927 return number
+ '-oji';
9930 dow
: 1, // Monday is the first day of the week.
9931 doy
: 4 // The week that contains Jan 4th is the first week of the year.
9935 //! moment.js locale configuration
9938 'ss': 'sekundes_sekundēm_sekunde_sekundes'.split('_'),
9939 'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
9940 'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
9941 'h': 'stundas_stundām_stunda_stundas'.split('_'),
9942 'hh': 'stundas_stundām_stunda_stundas'.split('_'),
9943 'd': 'dienas_dienām_diena_dienas'.split('_'),
9944 'dd': 'dienas_dienām_diena_dienas'.split('_'),
9945 'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
9946 'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
9947 'y': 'gada_gadiem_gads_gadi'.split('_'),
9948 'yy': 'gada_gadiem_gads_gadi'.split('_')
9951 * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
9953 function format
$1(forms
, number
, withoutSuffix
) {
9954 if (withoutSuffix
) {
9955 // E.g. "21 minūte", "3 minūtes".
9956 return number
% 10 === 1 && number
% 100 !== 11 ? forms
[2] : forms
[3];
9958 // E.g. "21 minūtes" as in "pēc 21 minūtes".
9959 // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
9960 return number
% 10 === 1 && number
% 100 !== 11 ? forms
[0] : forms
[1];
9963 function relativeTimeWithPlural
$1(number
, withoutSuffix
, key
) {
9964 return number
+ ' ' + format
$1(units
$1[key
], number
, withoutSuffix
);
9966 function relativeTimeWithSingular(number
, withoutSuffix
, key
) {
9967 return format
$1(units
$1[key
], number
, withoutSuffix
);
9969 function relativeSeconds(number
, withoutSuffix
) {
9970 return withoutSuffix
? 'dažas sekundes' : 'dažām sekundēm';
9973 hooks
.defineLocale('lv', {
9974 months
: 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
9975 monthsShort
: 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
9976 weekdays
: 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
9977 weekdaysShort
: 'Sv_P_O_T_C_Pk_S'.split('_'),
9978 weekdaysMin
: 'Sv_P_O_T_C_Pk_S'.split('_'),
9979 weekdaysParseExact
: true,
9984 LL
: 'YYYY. [gada] D. MMMM',
9985 LLL
: 'YYYY. [gada] D. MMMM, HH:mm',
9986 LLLL
: 'YYYY. [gada] D. MMMM, dddd, HH:mm'
9989 sameDay
: '[Šodien pulksten] LT',
9990 nextDay
: '[Rīt pulksten] LT',
9991 nextWeek
: 'dddd [pulksten] LT',
9992 lastDay
: '[Vakar pulksten] LT',
9993 lastWeek
: '[Pagājušā] dddd [pulksten] LT',
9999 s
: relativeSeconds
,
10000 ss
: relativeTimeWithPlural
$1,
10001 m
: relativeTimeWithSingular
,
10002 mm
: relativeTimeWithPlural
$1,
10003 h
: relativeTimeWithSingular
,
10004 hh
: relativeTimeWithPlural
$1,
10005 d
: relativeTimeWithSingular
,
10006 dd
: relativeTimeWithPlural
$1,
10007 M
: relativeTimeWithSingular
,
10008 MM
: relativeTimeWithPlural
$1,
10009 y
: relativeTimeWithSingular
,
10010 yy
: relativeTimeWithPlural
$1
10012 dayOfMonthOrdinalParse
: /\d{1,2}\./,
10015 dow
: 1, // Monday is the first day of the week.
10016 doy
: 4 // The week that contains Jan 4th is the first week of the year.
10020 //! moment.js locale configuration
10023 words
: { //Different grammatical cases
10024 ss
: ['sekund', 'sekunda', 'sekundi'],
10025 m
: ['jedan minut', 'jednog minuta'],
10026 mm
: ['minut', 'minuta', 'minuta'],
10027 h
: ['jedan sat', 'jednog sata'],
10028 hh
: ['sat', 'sata', 'sati'],
10029 dd
: ['dan', 'dana', 'dana'],
10030 MM
: ['mjesec', 'mjeseca', 'mjeseci'],
10031 yy
: ['godina', 'godine', 'godina']
10033 correctGrammaticalCase: function (number
, wordKey
) {
10034 return number
=== 1 ? wordKey
[0] : (number
>= 2 && number
<= 4 ? wordKey
[1] : wordKey
[2]);
10036 translate: function (number
, withoutSuffix
, key
) {
10037 var wordKey
= translator
.words
[key
];
10038 if (key
.length
=== 1) {
10039 return withoutSuffix
? wordKey
[0] : wordKey
[1];
10041 return number
+ ' ' + translator
.correctGrammaticalCase(number
, wordKey
);
10046 hooks
.defineLocale('me', {
10047 months
: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
10048 monthsShort
: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
10049 monthsParseExact
: true,
10050 weekdays
: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
10051 weekdaysShort
: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
10052 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
10053 weekdaysParseExact
: true,
10058 LL
: 'D. MMMM YYYY',
10059 LLL
: 'D. MMMM YYYY H:mm',
10060 LLLL
: 'dddd, D. MMMM YYYY H:mm'
10063 sameDay
: '[danas u] LT',
10064 nextDay
: '[sjutra u] LT',
10066 nextWeek: function () {
10067 switch (this.day()) {
10069 return '[u] [nedjelju] [u] LT';
10071 return '[u] [srijedu] [u] LT';
10073 return '[u] [subotu] [u] LT';
10078 return '[u] dddd [u] LT';
10081 lastDay
: '[juče u] LT',
10082 lastWeek : function () {
10083 var lastWeekDays
= [
10084 '[prošle] [nedjelje] [u] LT',
10085 '[prošlog] [ponedjeljka] [u] LT',
10086 '[prošlog] [utorka] [u] LT',
10087 '[prošle] [srijede] [u] LT',
10088 '[prošlog] [četvrtka] [u] LT',
10089 '[prošlog] [petka] [u] LT',
10090 '[prošle] [subote] [u] LT'
10092 return lastWeekDays
[this.day()];
10099 s
: 'nekoliko sekundi',
10100 ss
: translator
.translate
,
10101 m
: translator
.translate
,
10102 mm
: translator
.translate
,
10103 h
: translator
.translate
,
10104 hh
: translator
.translate
,
10106 dd
: translator
.translate
,
10108 MM
: translator
.translate
,
10110 yy
: translator
.translate
10112 dayOfMonthOrdinalParse
: /\d{1,2}\./,
10115 dow
: 1, // Monday is the first day of the week.
10116 doy
: 7 // The week that contains Jan 1st is the first week of the year.
10120 //! moment.js locale configuration
10122 hooks
.defineLocale('mi', {
10123 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('_'),
10124 monthsShort
: 'Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split('_'),
10125 monthsRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
10126 monthsStrictRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
10127 monthsShortRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
10128 monthsShortStrictRegex
: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
10129 weekdays
: 'Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei'.split('_'),
10130 weekdaysShort
: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
10131 weekdaysMin
: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
10137 LLL
: 'D MMMM YYYY [i] HH:mm',
10138 LLLL
: 'dddd, D MMMM YYYY [i] HH:mm'
10141 sameDay
: '[i teie mahana, i] LT',
10142 nextDay
: '[apopo i] LT',
10143 nextWeek
: 'dddd [i] LT',
10144 lastDay
: '[inanahi i] LT',
10145 lastWeek
: 'dddd [whakamutunga i] LT',
10149 future
: 'i roto i %s',
10151 s
: 'te hēkona ruarua',
10164 dayOfMonthOrdinalParse
: /\d{1,2}º/,
10167 dow
: 1, // Monday is the first day of the week.
10168 doy
: 4 // The week that contains Jan 4th is the first week of the year.
10172 //! moment.js locale configuration
10174 hooks
.defineLocale('mk', {
10175 months
: 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
10176 monthsShort
: 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
10177 weekdays
: 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
10178 weekdaysShort
: 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
10179 weekdaysMin
: 'нe_пo_вт_ср_че_пе_сa'.split('_'),
10184 LL
: 'D MMMM YYYY',
10185 LLL
: 'D MMMM YYYY H:mm',
10186 LLLL
: 'dddd, D MMMM YYYY H:mm'
10189 sameDay
: '[Денес во] LT',
10190 nextDay
: '[Утре во] LT',
10191 nextWeek
: '[Во] dddd [во] LT',
10192 lastDay
: '[Вчера во] LT',
10193 lastWeek : function () {
10194 switch (this.day()) {
10198 return '[Изминатата] dddd [во] LT';
10203 return '[Изминатиот] dddd [во] LT';
10209 future
: 'после %s',
10211 s
: 'неколку секунди',
10224 dayOfMonthOrdinalParse
: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
10225 ordinal : function (number
) {
10226 var lastDigit
= number
% 10,
10227 last2Digits
= number
% 100;
10228 if (number
=== 0) {
10229 return number
+ '-ев';
10230 } else if (last2Digits
=== 0) {
10231 return number
+ '-ен';
10232 } else if (last2Digits
> 10 && last2Digits
< 20) {
10233 return number
+ '-ти';
10234 } else if (lastDigit
=== 1) {
10235 return number
+ '-ви';
10236 } else if (lastDigit
=== 2) {
10237 return number
+ '-ри';
10238 } else if (lastDigit
=== 7 || lastDigit
=== 8) {
10239 return number
+ '-ми';
10241 return number
+ '-ти';
10245 dow
: 1, // Monday is the first day of the week.
10246 doy
: 7 // The week that contains Jan 1st is the first week of the year.
10250 //! moment.js locale configuration
10252 hooks
.defineLocale('ml', {
10253 months
: 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
10254 monthsShort
: 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split('_'),
10255 monthsParseExact
: true,
10256 weekdays
: 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split('_'),
10257 weekdaysShort
: 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
10258 weekdaysMin
: 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
10261 LTS
: 'A h:mm:ss -നു',
10263 LL
: 'D MMMM YYYY',
10264 LLL
: 'D MMMM YYYY, A h:mm -നു',
10265 LLLL
: 'dddd, D MMMM YYYY, A h:mm -നു'
10268 sameDay
: '[ഇന്ന്] LT',
10269 nextDay
: '[നാളെ] LT',
10270 nextWeek
: 'dddd, LT',
10271 lastDay
: '[ഇന്നലെ] LT',
10272 lastWeek
: '[കഴിഞ്ഞ] dddd, LT',
10276 future
: '%s കഴിഞ്ഞ്',
10278 s
: 'അൽപ നിമിഷങ്ങൾ',
10279 ss
: '%d സെക്കൻഡ്',
10280 m
: 'ഒരു മിനിറ്റ്',
10281 mm
: '%d മിനിറ്റ്',
10282 h
: 'ഒരു മണിക്കൂർ',
10283 hh
: '%d മണിക്കൂർ',
10291 meridiemParse
: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
10292 meridiemHour : function (hour
, meridiem
) {
10296 if ((meridiem
=== 'രാത്രി' && hour
>= 4) ||
10297 meridiem
=== 'ഉച്ച കഴിഞ്ഞ്' ||
10298 meridiem
=== 'വൈകുന്നേരം') {
10304 meridiem : function (hour
, minute
, isLower
) {
10307 } else if (hour
< 12) {
10309 } else if (hour
< 17) {
10310 return 'ഉച്ച കഴിഞ്ഞ്';
10311 } else if (hour
< 20) {
10312 return 'വൈകുന്നേരം';
10319 //! moment.js locale configuration
10321 function translate
$7(number
, withoutSuffix
, key
, isFuture
) {
10324 return withoutSuffix
? 'хэдхэн секунд' : 'хэдхэн секундын';
10326 return number
+ (withoutSuffix
? ' секунд' : ' секундын');
10329 return number
+ (withoutSuffix
? ' минут' : ' минутын');
10332 return number
+ (withoutSuffix
? ' цаг' : ' цагийн');
10335 return number
+ (withoutSuffix
? ' өдөр' : ' өдрийн');
10338 return number
+ (withoutSuffix
? ' сар' : ' сарын');
10341 return number
+ (withoutSuffix
? ' жил' : ' жилийн');
10347 hooks
.defineLocale('mn', {
10348 months
: 'Нэгдүгээр сар_Хоёрдугаар сар_Гуравдугаар сар_Дөрөвдүгээр сар_Тавдугаар сар_Зургадугаар сар_Долдугаар сар_Наймдугаар сар_Есдүгээр сар_Аравдугаар сар_Арван нэгдүгээр сар_Арван хоёрдугаар сар'.split('_'),
10349 monthsShort
: '1 сар_2 сар_3 сар_4 сар_5 сар_6 сар_7 сар_8 сар_9 сар_10 сар_11 сар_12 сар'.split('_'),
10350 monthsParseExact
: true,
10351 weekdays
: 'Ням_Даваа_Мягмар_Лхагва_Пүрэв_Баасан_Бямба'.split('_'),
10352 weekdaysShort
: 'Ням_Дав_Мяг_Лха_Пүр_Баа_Бям'.split('_'),
10353 weekdaysMin
: 'Ня_Да_Мя_Лх_Пү_Ба_Бя'.split('_'),
10354 weekdaysParseExact
: true,
10359 LL
: 'YYYY оны MMMMын D',
10360 LLL
: 'YYYY оны MMMMын D HH:mm',
10361 LLLL
: 'dddd, YYYY оны MMMMын D HH:mm'
10363 meridiemParse
: /ҮӨ|ҮХ/i,
10364 isPM : function (input
) {
10365 return input
=== 'ҮХ';
10367 meridiem : function (hour
, minute
, isLower
) {
10375 sameDay
: '[Өнөөдөр] LT',
10376 nextDay
: '[Маргааш] LT',
10377 nextWeek
: '[Ирэх] dddd LT',
10378 lastDay
: '[Өчигдөр] LT',
10379 lastWeek
: '[Өнгөрсөн] dddd LT',
10383 future
: '%s дараа',
10398 dayOfMonthOrdinalParse
: /\d{1,2} өдөр/,
10399 ordinal : function (number
, period
) {
10404 return number
+ ' өдөр';
10411 //! moment.js locale configuration
10413 var symbolMap
$a
= {
10438 function relativeTimeMr(number
, withoutSuffix
, string
, isFuture
)
10441 if (withoutSuffix
) {
10443 case 's': output
= 'काही सेकंद'; break;
10444 case 'ss': output
= '%d सेकंद'; break;
10445 case 'm': output
= 'एक मिनिट'; break;
10446 case 'mm': output
= '%d मिनिटे'; break;
10447 case 'h': output
= 'एक तास'; break;
10448 case 'hh': output
= '%d तास'; break;
10449 case 'd': output
= 'एक दिवस'; break;
10450 case 'dd': output
= '%d दिवस'; break;
10451 case 'M': output
= 'एक महिना'; break;
10452 case 'MM': output
= '%d महिने'; break;
10453 case 'y': output
= 'एक वर्ष'; break;
10454 case 'yy': output
= '%d वर्षे'; break;
10459 case 's': output
= 'काही सेकंदां'; break;
10460 case 'ss': output
= '%d सेकंदां'; break;
10461 case 'm': output
= 'एका मिनिटा'; break;
10462 case 'mm': output
= '%d मिनिटां'; break;
10463 case 'h': output
= 'एका तासा'; break;
10464 case 'hh': output
= '%d तासां'; break;
10465 case 'd': output
= 'एका दिवसा'; break;
10466 case 'dd': output
= '%d दिवसां'; break;
10467 case 'M': output
= 'एका महिन्या'; break;
10468 case 'MM': output
= '%d महिन्यां'; break;
10469 case 'y': output
= 'एका वर्षा'; break;
10470 case 'yy': output
= '%d वर्षां'; break;
10473 return output
.replace(/%d/i, number
);
10476 hooks
.defineLocale('mr', {
10477 months
: 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split('_'),
10478 monthsShort
: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split('_'),
10479 monthsParseExact
: true,
10480 weekdays
: 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
10481 weekdaysShort
: 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
10482 weekdaysMin
: 'र_सो_मं_बु_गु_शु_श'.split('_'),
10484 LT
: 'A h:mm वाजता',
10485 LTS
: 'A h:mm:ss वाजता',
10487 LL
: 'D MMMM YYYY',
10488 LLL
: 'D MMMM YYYY, A h:mm वाजता',
10489 LLLL
: 'dddd, D MMMM YYYY, A h:mm वाजता'
10492 sameDay
: '[आज] LT',
10493 nextDay
: '[उद्या] LT',
10494 nextWeek
: 'dddd, LT',
10495 lastDay
: '[काल] LT',
10496 lastWeek
: '[मागील] dddd, LT',
10503 ss
: relativeTimeMr
,
10505 mm
: relativeTimeMr
,
10507 hh
: relativeTimeMr
,
10509 dd
: relativeTimeMr
,
10511 MM
: relativeTimeMr
,
10515 preparse: function (string
) {
10516 return string
.replace(/[१२३४५६७८९०]/g, function (match
) {
10517 return numberMap
$9[match
];
10520 postformat: function (string
) {
10521 return string
.replace(/\d/g, function (match
) {
10522 return symbolMap
$a
[match
];
10525 meridiemParse
: /रात्री|सकाळी|दुपारी|सायंकाळी/,
10526 meridiemHour : function (hour
, meridiem
) {
10530 if (meridiem
=== 'रात्री') {
10531 return hour
< 4 ? hour
: hour
+ 12;
10532 } else if (meridiem
=== 'सकाळी') {
10534 } else if (meridiem
=== 'दुपारी') {
10535 return hour
>= 10 ? hour
: hour
+ 12;
10536 } else if (meridiem
=== 'सायंकाळी') {
10540 meridiem: function (hour
, minute
, isLower
) {
10543 } else if (hour
< 10) {
10545 } else if (hour
< 17) {
10547 } else if (hour
< 20) {
10554 dow
: 0, // Sunday is the first day of the week.
10555 doy
: 6 // The week that contains Jan 1st is the first week of the year.
10559 //! moment.js locale configuration
10561 hooks
.defineLocale('ms-my', {
10562 months
: 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
10563 monthsShort
: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
10564 weekdays
: 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
10565 weekdaysShort
: 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
10566 weekdaysMin
: 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
10571 LL
: 'D MMMM YYYY',
10572 LLL
: 'D MMMM YYYY [pukul] HH.mm',
10573 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm'
10575 meridiemParse
: /pagi|tengahari|petang|malam/,
10576 meridiemHour: function (hour
, meridiem
) {
10580 if (meridiem
=== 'pagi') {
10582 } else if (meridiem
=== 'tengahari') {
10583 return hour
>= 11 ? hour
: hour
+ 12;
10584 } else if (meridiem
=== 'petang' || meridiem
=== 'malam') {
10588 meridiem : function (hours
, minutes
, isLower
) {
10591 } else if (hours
< 15) {
10592 return 'tengahari';
10593 } else if (hours
< 19) {
10600 sameDay
: '[Hari ini pukul] LT',
10601 nextDay
: '[Esok pukul] LT',
10602 nextWeek
: 'dddd [pukul] LT',
10603 lastDay
: '[Kelmarin pukul] LT',
10604 lastWeek
: 'dddd [lepas pukul] LT',
10608 future
: 'dalam %s',
10609 past
: '%s yang lepas',
10610 s
: 'beberapa saat',
10624 dow
: 1, // Monday is the first day of the week.
10625 doy
: 7 // The week that contains Jan 1st is the first week of the year.
10629 //! moment.js locale configuration
10631 hooks
.defineLocale('ms', {
10632 months
: 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
10633 monthsShort
: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
10634 weekdays
: 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
10635 weekdaysShort
: 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
10636 weekdaysMin
: 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
10641 LL
: 'D MMMM YYYY',
10642 LLL
: 'D MMMM YYYY [pukul] HH.mm',
10643 LLLL
: 'dddd, D MMMM YYYY [pukul] HH.mm'
10645 meridiemParse
: /pagi|tengahari|petang|malam/,
10646 meridiemHour: function (hour
, meridiem
) {
10650 if (meridiem
=== 'pagi') {
10652 } else if (meridiem
=== 'tengahari') {
10653 return hour
>= 11 ? hour
: hour
+ 12;
10654 } else if (meridiem
=== 'petang' || meridiem
=== 'malam') {
10658 meridiem : function (hours
, minutes
, isLower
) {
10661 } else if (hours
< 15) {
10662 return 'tengahari';
10663 } else if (hours
< 19) {
10670 sameDay
: '[Hari ini pukul] LT',
10671 nextDay
: '[Esok pukul] LT',
10672 nextWeek
: 'dddd [pukul] LT',
10673 lastDay
: '[Kelmarin pukul] LT',
10674 lastWeek
: 'dddd [lepas pukul] LT',
10678 future
: 'dalam %s',
10679 past
: '%s yang lepas',
10680 s
: 'beberapa saat',
10694 dow
: 1, // Monday is the first day of the week.
10695 doy
: 7 // The week that contains Jan 1st is the first week of the year.
10699 //! moment.js locale configuration
10701 hooks
.defineLocale('mt', {
10702 months
: 'Jannar_Frar_Marzu_April_Mejju_Ġunju_Lulju_Awwissu_Settembru_Ottubru_Novembru_Diċembru'.split('_'),
10703 monthsShort
: 'Jan_Fra_Mar_Apr_Mej_Ġun_Lul_Aww_Set_Ott_Nov_Diċ'.split('_'),
10704 weekdays
: 'Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ġimgħa_Is-Sibt'.split('_'),
10705 weekdaysShort
: 'Ħad_Tne_Tli_Erb_Ħam_Ġim_Sib'.split('_'),
10706 weekdaysMin
: 'Ħa_Tn_Tl_Er_Ħa_Ġi_Si'.split('_'),
10711 LL
: 'D MMMM YYYY',
10712 LLL
: 'D MMMM YYYY HH:mm',
10713 LLLL
: 'dddd, D MMMM YYYY HH:mm'
10716 sameDay
: '[Illum fil-]LT',
10717 nextDay
: '[Għada fil-]LT',
10718 nextWeek
: 'dddd [fil-]LT',
10719 lastDay
: '[Il-bieraħ fil-]LT',
10720 lastWeek
: 'dddd [li għadda] [fil-]LT',
10726 s
: 'ftit sekondi',
10739 dayOfMonthOrdinalParse
: /\d{1,2}º/,
10742 dow
: 1, // Monday is the first day of the week.
10743 doy
: 4 // The week that contains Jan 4th is the first week of the year.
10747 //! moment.js locale configuration
10749 var symbolMap
$b
= {
10773 hooks
.defineLocale('my', {
10774 months
: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split('_'),
10775 monthsShort
: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
10776 weekdays
: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split('_'),
10777 weekdaysShort
: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
10778 weekdaysMin
: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
10785 LLL
: 'D MMMM YYYY HH:mm',
10786 LLLL
: 'dddd D MMMM YYYY HH:mm'
10789 sameDay
: '[ယနေ.] LT [မှာ]',
10790 nextDay
: '[မနက်ဖြန်] LT [မှာ]',
10791 nextWeek
: 'dddd LT [မှာ]',
10792 lastDay
: '[မနေ.က] LT [မှာ]',
10793 lastWeek
: '[ပြီးခဲ့သော] dddd LT [မှာ]',
10797 future
: 'လာမည့် %s မှာ',
10798 past
: 'လွန်ခဲ့သော %s က',
10799 s
: 'စက္ကန်.အနည်းငယ်',
10812 preparse: function (string
) {
10813 return string
.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match
) {
10814 return numberMap
$a
[match
];
10817 postformat: function (string
) {
10818 return string
.replace(/\d/g, function (match
) {
10819 return symbolMap
$b
[match
];
10823 dow
: 1, // Monday is the first day of the week.
10824 doy
: 4 // The week that contains Jan 1st is the first week of the year.
10828 //! moment.js locale configuration
10830 hooks
.defineLocale('nb', {
10831 months
: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
10832 monthsShort
: 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
10833 monthsParseExact
: true,
10834 weekdays
: 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
10835 weekdaysShort
: 'sø._ma._ti._on._to._fr._lø.'.split('_'),
10836 weekdaysMin
: 'sø_ma_ti_on_to_fr_lø'.split('_'),
10837 weekdaysParseExact
: true,
10842 LL
: 'D. MMMM YYYY',
10843 LLL
: 'D. MMMM YYYY [kl.] HH:mm',
10844 LLLL
: 'dddd D. MMMM YYYY [kl.] HH:mm'
10847 sameDay
: '[i dag kl.] LT',
10848 nextDay
: '[i morgen kl.] LT',
10849 nextWeek
: 'dddd [kl.] LT',
10850 lastDay
: '[i går kl.] LT',
10851 lastWeek
: '[forrige] dddd [kl.] LT',
10857 s
: 'noen sekunder',
10858 ss
: '%d sekunder',
10860 mm
: '%d minutter',
10870 dayOfMonthOrdinalParse
: /\d{1,2}\./,
10873 dow
: 1, // Monday is the first day of the week.
10874 doy
: 4 // The week that contains Jan 4th is the first week of the year.
10878 //! moment.js locale configuration
10880 var symbolMap
$c
= {
10905 hooks
.defineLocale('ne', {
10906 months
: 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split('_'),
10907 monthsShort
: 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split('_'),
10908 monthsParseExact
: true,
10909 weekdays
: 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split('_'),
10910 weekdaysShort
: 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
10911 weekdaysMin
: 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
10912 weekdaysParseExact
: true,
10914 LT
: 'Aको h:mm बजे',
10915 LTS
: 'Aको h:mm:ss बजे',
10917 LL
: 'D MMMM YYYY',
10918 LLL
: 'D MMMM YYYY, Aको h:mm बजे',
10919 LLLL
: 'dddd, D MMMM YYYY, Aको h:mm बजे'
10921 preparse: function (string
) {
10922 return string
.replace(/[१२३४५६७८९०]/g, function (match
) {
10923 return numberMap
$b
[match
];
10926 postformat: function (string
) {
10927 return string
.replace(/\d/g, function (match
) {
10928 return symbolMap
$c
[match
];
10931 meridiemParse
: /राति|बिहान|दिउँसो|साँझ/,
10932 meridiemHour : function (hour
, meridiem
) {
10936 if (meridiem
=== 'राति') {
10937 return hour
< 4 ? hour
: hour
+ 12;
10938 } else if (meridiem
=== 'बिहान') {
10940 } else if (meridiem
=== 'दिउँसो') {
10941 return hour
>= 10 ? hour
: hour
+ 12;
10942 } else if (meridiem
=== 'साँझ') {
10946 meridiem : function (hour
, minute
, isLower
) {
10949 } else if (hour
< 12) {
10951 } else if (hour
< 16) {
10953 } else if (hour
< 20) {
10960 sameDay
: '[आज] LT',
10961 nextDay
: '[भोलि] LT',
10962 nextWeek
: '[आउँदो] dddd[,] LT',
10963 lastDay
: '[हिजो] LT',
10964 lastWeek
: '[गएको] dddd[,] LT',
10984 dow
: 0, // Sunday is the first day of the week.
10985 doy
: 6 // The week that contains Jan 1st is the first week of the year.
10989 //! moment.js locale configuration
10991 var monthsShortWithDots
$1 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
10992 monthsShortWithoutDots
$1 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
10994 var monthsParse
$2 = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
10995 var monthsRegex
$3 = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
10997 hooks
.defineLocale('nl-be', {
10998 months
: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
10999 monthsShort : function (m
, format
) {
11001 return monthsShortWithDots
$1;
11002 } else if (/-MMM-/.test(format
)) {
11003 return monthsShortWithoutDots
$1[m
.month()];
11005 return monthsShortWithDots
$1[m
.month()];
11009 monthsRegex
: monthsRegex
$3,
11010 monthsShortRegex
: monthsRegex
$3,
11011 monthsStrictRegex
: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
11012 monthsShortStrictRegex
: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
11014 monthsParse
: monthsParse
$2,
11015 longMonthsParse
: monthsParse
$2,
11016 shortMonthsParse
: monthsParse
$2,
11018 weekdays
: 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
11019 weekdaysShort
: 'zo._ma._di._wo._do._vr._za.'.split('_'),
11020 weekdaysMin
: 'zo_ma_di_wo_do_vr_za'.split('_'),
11021 weekdaysParseExact
: true,
11026 LL
: 'D MMMM YYYY',
11027 LLL
: 'D MMMM YYYY HH:mm',
11028 LLLL
: 'dddd D MMMM YYYY HH:mm'
11031 sameDay
: '[vandaag om] LT',
11032 nextDay
: '[morgen om] LT',
11033 nextWeek
: 'dddd [om] LT',
11034 lastDay
: '[gisteren om] LT',
11035 lastWeek
: '[afgelopen] dddd [om] LT',
11039 future
: 'over %s',
11040 past
: '%s geleden',
11041 s
: 'een paar seconden',
11042 ss
: '%d seconden',
11054 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
11055 ordinal : function (number
) {
11056 return number
+ ((number
=== 1 || number
=== 8 || number
>= 20) ? 'ste' : 'de');
11059 dow
: 1, // Monday is the first day of the week.
11060 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11064 //! moment.js locale configuration
11066 var monthsShortWithDots
$2 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
11067 monthsShortWithoutDots
$2 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
11069 var monthsParse
$3 = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
11070 var monthsRegex
$4 = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
11072 hooks
.defineLocale('nl', {
11073 months
: 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
11074 monthsShort : function (m
, format
) {
11076 return monthsShortWithDots
$2;
11077 } else if (/-MMM-/.test(format
)) {
11078 return monthsShortWithoutDots
$2[m
.month()];
11080 return monthsShortWithDots
$2[m
.month()];
11084 monthsRegex
: monthsRegex
$4,
11085 monthsShortRegex
: monthsRegex
$4,
11086 monthsStrictRegex
: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
11087 monthsShortStrictRegex
: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
11089 monthsParse
: monthsParse
$3,
11090 longMonthsParse
: monthsParse
$3,
11091 shortMonthsParse
: monthsParse
$3,
11093 weekdays
: 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
11094 weekdaysShort
: 'zo._ma._di._wo._do._vr._za.'.split('_'),
11095 weekdaysMin
: 'zo_ma_di_wo_do_vr_za'.split('_'),
11096 weekdaysParseExact
: true,
11101 LL
: 'D MMMM YYYY',
11102 LLL
: 'D MMMM YYYY HH:mm',
11103 LLLL
: 'dddd D MMMM YYYY HH:mm'
11106 sameDay
: '[vandaag om] LT',
11107 nextDay
: '[morgen om] LT',
11108 nextWeek
: 'dddd [om] LT',
11109 lastDay
: '[gisteren om] LT',
11110 lastWeek
: '[afgelopen] dddd [om] LT',
11114 future
: 'over %s',
11115 past
: '%s geleden',
11116 s
: 'een paar seconden',
11117 ss
: '%d seconden',
11129 dayOfMonthOrdinalParse
: /\d{1,2}(ste|de)/,
11130 ordinal : function (number
) {
11131 return number
+ ((number
=== 1 || number
=== 8 || number
>= 20) ? 'ste' : 'de');
11134 dow
: 1, // Monday is the first day of the week.
11135 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11139 //! moment.js locale configuration
11141 hooks
.defineLocale('nn', {
11142 months
: 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
11143 monthsShort
: 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
11144 weekdays
: 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
11145 weekdaysShort
: 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
11146 weekdaysMin
: 'su_må_ty_on_to_fr_lø'.split('_'),
11151 LL
: 'D. MMMM YYYY',
11152 LLL
: 'D. MMMM YYYY [kl.] H:mm',
11153 LLLL
: 'dddd D. MMMM YYYY [kl.] HH:mm'
11156 sameDay
: '[I dag klokka] LT',
11157 nextDay
: '[I morgon klokka] LT',
11158 nextWeek
: 'dddd [klokka] LT',
11159 lastDay
: '[I går klokka] LT',
11160 lastWeek
: '[Føregåande] dddd [klokka] LT',
11166 s
: 'nokre sekund',
11179 dayOfMonthOrdinalParse
: /\d{1,2}\./,
11182 dow
: 1, // Monday is the first day of the week.
11183 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11187 //! moment.js locale configuration
11189 var symbolMap
$d
= {
11214 hooks
.defineLocale('pa-in', {
11215 // There are months name as per Nanakshahi Calender but they are not used as rigidly in modern Punjabi.
11216 months
: 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
11217 monthsShort
: 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
11218 weekdays
: 'ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ'.split('_'),
11219 weekdaysShort
: 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
11220 weekdaysMin
: 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
11223 LTS
: 'A h:mm:ss ਵਜੇ',
11225 LL
: 'D MMMM YYYY',
11226 LLL
: 'D MMMM YYYY, A h:mm ਵਜੇ',
11227 LLLL
: 'dddd, D MMMM YYYY, A h:mm ਵਜੇ'
11230 sameDay
: '[ਅਜ] LT',
11231 nextDay
: '[ਕਲ] LT',
11232 nextWeek
: '[ਅਗਲਾ] dddd, LT',
11233 lastDay
: '[ਕਲ] LT',
11234 lastWeek
: '[ਪਿਛਲੇ] dddd, LT',
11238 future
: '%s ਵਿੱਚ',
11253 preparse: function (string
) {
11254 return string
.replace(/[੧੨੩੪੫੬੭੮੯੦]/g, function (match
) {
11255 return numberMap
$c
[match
];
11258 postformat: function (string
) {
11259 return string
.replace(/\d/g, function (match
) {
11260 return symbolMap
$d
[match
];
11263 // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
11264 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
11265 meridiemParse
: /ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,
11266 meridiemHour : function (hour
, meridiem
) {
11270 if (meridiem
=== 'ਰਾਤ') {
11271 return hour
< 4 ? hour
: hour
+ 12;
11272 } else if (meridiem
=== 'ਸਵੇਰ') {
11274 } else if (meridiem
=== 'ਦੁਪਹਿਰ') {
11275 return hour
>= 10 ? hour
: hour
+ 12;
11276 } else if (meridiem
=== 'ਸ਼ਾਮ') {
11280 meridiem : function (hour
, minute
, isLower
) {
11283 } else if (hour
< 10) {
11285 } else if (hour
< 17) {
11287 } else if (hour
< 20) {
11294 dow
: 0, // Sunday is the first day of the week.
11295 doy
: 6 // The week that contains Jan 1st is the first week of the year.
11299 //! moment.js locale configuration
11301 var monthsNominative
= 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'),
11302 monthsSubjective
= 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');
11303 function plural
$3(n
) {
11304 return (n
% 10 < 5) && (n
% 10 > 1) && ((~~(n
/ 10) % 10) !== 1);
11306 function translate
$8(number
, withoutSuffix
, key
) {
11307 var result
= number
+ ' ';
11310 return result
+ (plural
$3(number
) ? 'sekundy' : 'sekund');
11312 return withoutSuffix
? 'minuta' : 'minutę';
11314 return result
+ (plural
$3(number
) ? 'minuty' : 'minut');
11316 return withoutSuffix
? 'godzina' : 'godzinę';
11318 return result
+ (plural
$3(number
) ? 'godziny' : 'godzin');
11320 return result
+ (plural
$3(number
) ? 'miesiące' : 'miesięcy');
11322 return result
+ (plural
$3(number
) ? 'lata' : 'lat');
11326 hooks
.defineLocale('pl', {
11327 months : function (momentToFormat
, format
) {
11328 if (!momentToFormat
) {
11329 return monthsNominative
;
11330 } else if (format
=== '') {
11331 // Hack: if format empty we know this is used to generate
11332 // RegExp by moment. Give then back both valid forms of months
11333 // in RegExp ready format.
11334 return '(' + monthsSubjective
[momentToFormat
.month()] + '|' + monthsNominative
[momentToFormat
.month()] + ')';
11335 } else if (/D MMMM/.test(format
)) {
11336 return monthsSubjective
[momentToFormat
.month()];
11338 return monthsNominative
[momentToFormat
.month()];
11341 monthsShort
: 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
11342 weekdays
: 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
11343 weekdaysShort
: 'ndz_pon_wt_śr_czw_pt_sob'.split('_'),
11344 weekdaysMin
: 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
11349 LL
: 'D MMMM YYYY',
11350 LLL
: 'D MMMM YYYY HH:mm',
11351 LLLL
: 'dddd, D MMMM YYYY HH:mm'
11354 sameDay
: '[Dziś o] LT',
11355 nextDay
: '[Jutro o] LT',
11356 nextWeek: function () {
11357 switch (this.day()) {
11359 return '[W niedzielę o] LT';
11362 return '[We wtorek o] LT';
11365 return '[W środę o] LT';
11368 return '[W sobotę o] LT';
11371 return '[W] dddd [o] LT';
11374 lastDay
: '[Wczoraj o] LT',
11375 lastWeek: function () {
11376 switch (this.day()) {
11378 return '[W zeszłą niedzielę o] LT';
11380 return '[W zeszłą środę o] LT';
11382 return '[W zeszłą sobotę o] LT';
11384 return '[W zeszły] dddd [o] LT';
11392 s
: 'kilka sekund',
11405 dayOfMonthOrdinalParse
: /\d{1,2}\./,
11408 dow
: 1, // Monday is the first day of the week.
11409 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11413 //! moment.js locale configuration
11415 hooks
.defineLocale('pt-br', {
11416 months
: 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
11417 monthsShort
: 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
11418 weekdays
: 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
11419 weekdaysShort
: 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
11420 weekdaysMin
: 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
11421 weekdaysParseExact
: true,
11426 LL
: 'D [de] MMMM [de] YYYY',
11427 LLL
: 'D [de] MMMM [de] YYYY [às] HH:mm',
11428 LLLL
: 'dddd, D [de] MMMM [de] YYYY [às] HH:mm'
11431 sameDay
: '[Hoje às] LT',
11432 nextDay
: '[Amanhã às] LT',
11433 nextWeek
: 'dddd [às] LT',
11434 lastDay
: '[Ontem às] LT',
11435 lastWeek: function () {
11436 return (this.day() === 0 || this.day() === 6) ?
11437 '[Último] dddd [às] LT' : // Saturday + Sunday
11438 '[Última] dddd [às] LT'; // Monday - Friday
11445 s
: 'poucos segundos',
11446 ss
: '%d segundos',
11458 dayOfMonthOrdinalParse
: /\d{1,2}º/,
11462 //! moment.js locale configuration
11464 hooks
.defineLocale('pt', {
11465 months
: 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
11466 monthsShort
: 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
11467 weekdays
: 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
11468 weekdaysShort
: 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
11469 weekdaysMin
: 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
11470 weekdaysParseExact
: true,
11475 LL
: 'D [de] MMMM [de] YYYY',
11476 LLL
: 'D [de] MMMM [de] YYYY HH:mm',
11477 LLLL
: 'dddd, D [de] MMMM [de] YYYY HH:mm'
11480 sameDay
: '[Hoje às] LT',
11481 nextDay
: '[Amanhã às] LT',
11482 nextWeek
: 'dddd [às] LT',
11483 lastDay
: '[Ontem às] LT',
11484 lastWeek: function () {
11485 return (this.day() === 0 || this.day() === 6) ?
11486 '[Último] dddd [às] LT' : // Saturday + Sunday
11487 '[Última] dddd [às] LT'; // Monday - Friday
11495 ss
: '%d segundos',
11507 dayOfMonthOrdinalParse
: /\d{1,2}º/,
11510 dow
: 1, // Monday is the first day of the week.
11511 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11515 //! moment.js locale configuration
11517 function relativeTimeWithPlural
$2(number
, withoutSuffix
, key
) {
11527 if (number
% 100 >= 20 || (number
>= 100 && number
% 100 === 0)) {
11528 separator
= ' de ';
11530 return number
+ separator
+ format
[key
];
11533 hooks
.defineLocale('ro', {
11534 months
: 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
11535 monthsShort
: 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
11536 monthsParseExact
: true,
11537 weekdays
: 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
11538 weekdaysShort
: 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
11539 weekdaysMin
: 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
11544 LL
: 'D MMMM YYYY',
11545 LLL
: 'D MMMM YYYY H:mm',
11546 LLLL
: 'dddd, D MMMM YYYY H:mm'
11549 sameDay
: '[azi la] LT',
11550 nextDay
: '[mâine la] LT',
11551 nextWeek
: 'dddd [la] LT',
11552 lastDay
: '[ieri la] LT',
11553 lastWeek
: '[fosta] dddd [la] LT',
11557 future
: 'peste %s',
11558 past
: '%s în urmă',
11559 s
: 'câteva secunde',
11560 ss
: relativeTimeWithPlural
$2,
11562 mm
: relativeTimeWithPlural
$2,
11564 hh
: relativeTimeWithPlural
$2,
11566 dd
: relativeTimeWithPlural
$2,
11568 MM
: relativeTimeWithPlural
$2,
11570 yy
: relativeTimeWithPlural
$2
11573 dow
: 1, // Monday is the first day of the week.
11574 doy
: 7 // The week that contains Jan 1st is the first week of the year.
11578 //! moment.js locale configuration
11580 function plural
$4(word
, num
) {
11581 var forms
= word
.split('_');
11582 return num
% 10 === 1 && num
% 100 !== 11 ? forms
[0] : (num
% 10 >= 2 && num
% 10 <= 4 && (num
% 100 < 10 || num
% 100 >= 20) ? forms
[1] : forms
[2]);
11584 function relativeTimeWithPlural
$3(number
, withoutSuffix
, key
) {
11586 'ss': withoutSuffix
? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
11587 'mm': withoutSuffix
? 'минута_минуты_минут' : 'минуту_минуты_минут',
11588 'hh': 'час_часа_часов',
11589 'dd': 'день_дня_дней',
11590 'MM': 'месяц_месяца_месяцев',
11591 'yy': 'год_года_лет'
11594 return withoutSuffix
? 'минута' : 'минуту';
11597 return number
+ ' ' + plural
$4(format
[key
], +number
);
11600 var monthsParse
$4 = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[йя]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];
11602 // http://new.gramota.ru/spravka/rules/139-prop : § 103
11603 // Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637
11604 // CLDR data: http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
11605 hooks
.defineLocale('ru', {
11607 format
: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_'),
11608 standalone
: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_')
11611 // по CLDR именно "июл." и "июн.", но какой смысл менять букву на точку ?
11612 format
: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split('_'),
11613 standalone
: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split('_')
11616 standalone
: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),
11617 format
: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_'),
11618 isFormat
: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
11620 weekdaysShort
: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
11621 weekdaysMin
: 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
11622 monthsParse
: monthsParse
$4,
11623 longMonthsParse
: monthsParse
$4,
11624 shortMonthsParse
: monthsParse
$4,
11626 // полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки
11627 monthsRegex
: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
11629 // копия предыдущего
11630 monthsShortRegex
: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
11632 // полные названия с падежами
11633 monthsStrictRegex
: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,
11635 // Выражение, которое соотвествует только сокращённым формам
11636 monthsShortStrictRegex
: /^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,
11641 LL
: 'D MMMM YYYY г.',
11642 LLL
: 'D MMMM YYYY г., H:mm',
11643 LLLL
: 'dddd, D MMMM YYYY г., H:mm'
11646 sameDay
: '[Сегодня, в] LT',
11647 nextDay
: '[Завтра, в] LT',
11648 lastDay
: '[Вчера, в] LT',
11649 nextWeek: function (now
) {
11650 if (now
.week() !== this.week()) {
11651 switch (this.day()) {
11653 return '[В следующее] dddd, [в] LT';
11657 return '[В следующий] dddd, [в] LT';
11661 return '[В следующую] dddd, [в] LT';
11664 if (this.day() === 2) {
11665 return '[Во] dddd, [в] LT';
11667 return '[В] dddd, [в] LT';
11671 lastWeek: function (now
) {
11672 if (now
.week() !== this.week()) {
11673 switch (this.day()) {
11675 return '[В прошлое] dddd, [в] LT';
11679 return '[В прошлый] dddd, [в] LT';
11683 return '[В прошлую] dddd, [в] LT';
11686 if (this.day() === 2) {
11687 return '[Во] dddd, [в] LT';
11689 return '[В] dddd, [в] LT';
11696 future
: 'через %s',
11698 s
: 'несколько секунд',
11699 ss
: relativeTimeWithPlural
$3,
11700 m
: relativeTimeWithPlural
$3,
11701 mm
: relativeTimeWithPlural
$3,
11703 hh
: relativeTimeWithPlural
$3,
11705 dd
: relativeTimeWithPlural
$3,
11707 MM
: relativeTimeWithPlural
$3,
11709 yy
: relativeTimeWithPlural
$3
11711 meridiemParse
: /ночи|утра|дня|вечера/i,
11712 isPM : function (input
) {
11713 return /^(дня|вечера)$/.test(input
);
11715 meridiem : function (hour
, minute
, isLower
) {
11718 } else if (hour
< 12) {
11720 } else if (hour
< 17) {
11726 dayOfMonthOrdinalParse
: /\d{1,2}-(й|го|я)/,
11727 ordinal: function (number
, period
) {
11732 return number
+ '-й';
11734 return number
+ '-го';
11737 return number
+ '-я';
11743 dow
: 1, // Monday is the first day of the week.
11744 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11748 //! moment.js locale configuration
11774 hooks
.defineLocale('sd', {
11776 monthsShort
: months
$6,
11778 weekdaysShort
: days
$1,
11779 weekdaysMin
: days
$1,
11784 LL
: 'D MMMM YYYY',
11785 LLL
: 'D MMMM YYYY HH:mm',
11786 LLLL
: 'dddd، D MMMM YYYY HH:mm'
11788 meridiemParse
: /صبح|شام/,
11789 isPM : function (input
) {
11790 return 'شام' === input
;
11792 meridiem : function (hour
, minute
, isLower
) {
11799 sameDay
: '[اڄ] LT',
11800 nextDay
: '[سڀاڻي] LT',
11801 nextWeek
: 'dddd [اڳين هفتي تي] LT',
11802 lastDay
: '[ڪالهه] LT',
11803 lastWeek
: '[گزريل هفتي] dddd [تي] LT',
11822 preparse: function (string
) {
11823 return string
.replace(/،/g, ',');
11825 postformat: function (string
) {
11826 return string
.replace(/,/g
, '،');
11829 dow
: 1, // Monday is the first day of the week.
11830 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11834 //! moment.js locale configuration
11836 hooks
.defineLocale('se', {
11837 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('_'),
11838 monthsShort
: 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split('_'),
11839 weekdays
: 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),
11840 weekdaysShort
: 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
11841 weekdaysMin
: 's_v_m_g_d_b_L'.split('_'),
11846 LL
: 'MMMM D. [b.] YYYY',
11847 LLL
: 'MMMM D. [b.] YYYY [ti.] HH:mm',
11848 LLLL
: 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
11851 sameDay
: '[otne ti] LT',
11852 nextDay
: '[ihttin ti] LT',
11853 nextWeek
: 'dddd [ti] LT',
11854 lastDay
: '[ikte ti] LT',
11855 lastWeek
: '[ovddit] dddd [ti] LT',
11859 future
: '%s geažes',
11861 s
: 'moadde sekunddat',
11862 ss
: '%d sekunddat',
11863 m
: 'okta minuhta',
11864 mm
: '%d minuhtat',
11868 dd
: '%d beaivvit',
11874 dayOfMonthOrdinalParse
: /\d{1,2}\./,
11877 dow
: 1, // Monday is the first day of the week.
11878 doy
: 4 // The week that contains Jan 4th is the first week of the year.
11882 //! moment.js locale configuration
11885 hooks
.defineLocale('si', {
11886 months
: 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split('_'),
11887 monthsShort
: 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split('_'),
11888 weekdays
: 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split('_'),
11889 weekdaysShort
: 'ඉරි_සඳු_අඟ_බදා_බ්රහ_සිකු_සෙන'.split('_'),
11890 weekdaysMin
: 'ඉ_ස_අ_බ_බ්ර_සි_සෙ'.split('_'),
11891 weekdaysParseExact
: true,
11896 LL
: 'YYYY MMMM D',
11897 LLL
: 'YYYY MMMM D, a h:mm',
11898 LLLL
: 'YYYY MMMM D [වැනි] dddd, a h:mm:ss'
11901 sameDay
: '[අද] LT[ට]',
11902 nextDay
: '[හෙට] LT[ට]',
11903 nextWeek
: 'dddd LT[ට]',
11904 lastDay
: '[ඊයේ] LT[ට]',
11905 lastWeek
: '[පසුගිය] dddd LT[ට]',
11911 s
: 'තත්පර කිහිපය',
11914 mm
: 'මිනිත්තු %d',
11924 dayOfMonthOrdinalParse
: /\d{1,2} වැනි/,
11925 ordinal : function (number
) {
11926 return number
+ ' වැනි';
11928 meridiemParse
: /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
11929 isPM : function (input
) {
11930 return input
=== 'ප.ව.' || input
=== 'පස් වරු';
11932 meridiem : function (hours
, minutes
, isLower
) {
11934 return isLower
? 'ප.ව.' : 'පස් වරු';
11936 return isLower
? 'පෙ.ව.' : 'පෙර වරු';
11941 //! moment.js locale configuration
11943 var months
$7 = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_'),
11944 monthsShort
$5 = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
11945 function plural
$5(n
) {
11946 return (n
> 1) && (n
< 5);
11948 function translate
$9(number
, withoutSuffix
, key
, isFuture
) {
11949 var result
= number
+ ' ';
11951 case 's': // a few seconds / in a few seconds / a few seconds ago
11952 return (withoutSuffix
|| isFuture
) ? 'pár sekúnd' : 'pár sekundami';
11953 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
11954 if (withoutSuffix
|| isFuture
) {
11955 return result
+ (plural
$5(number
) ? 'sekundy' : 'sekúnd');
11957 return result
+ 'sekundami';
11960 case 'm': // a minute / in a minute / a minute ago
11961 return withoutSuffix
? 'minúta' : (isFuture
? 'minútu' : 'minútou');
11962 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
11963 if (withoutSuffix
|| isFuture
) {
11964 return result
+ (plural
$5(number
) ? 'minúty' : 'minút');
11966 return result
+ 'minútami';
11969 case 'h': // an hour / in an hour / an hour ago
11970 return withoutSuffix
? 'hodina' : (isFuture
? 'hodinu' : 'hodinou');
11971 case 'hh': // 9 hours / in 9 hours / 9 hours ago
11972 if (withoutSuffix
|| isFuture
) {
11973 return result
+ (plural
$5(number
) ? 'hodiny' : 'hodín');
11975 return result
+ 'hodinami';
11978 case 'd': // a day / in a day / a day ago
11979 return (withoutSuffix
|| isFuture
) ? 'deň' : 'dňom';
11980 case 'dd': // 9 days / in 9 days / 9 days ago
11981 if (withoutSuffix
|| isFuture
) {
11982 return result
+ (plural
$5(number
) ? 'dni' : 'dní');
11984 return result
+ 'dňami';
11987 case 'M': // a month / in a month / a month ago
11988 return (withoutSuffix
|| isFuture
) ? 'mesiac' : 'mesiacom';
11989 case 'MM': // 9 months / in 9 months / 9 months ago
11990 if (withoutSuffix
|| isFuture
) {
11991 return result
+ (plural
$5(number
) ? 'mesiace' : 'mesiacov');
11993 return result
+ 'mesiacmi';
11996 case 'y': // a year / in a year / a year ago
11997 return (withoutSuffix
|| isFuture
) ? 'rok' : 'rokom';
11998 case 'yy': // 9 years / in 9 years / 9 years ago
11999 if (withoutSuffix
|| isFuture
) {
12000 return result
+ (plural
$5(number
) ? 'roky' : 'rokov');
12002 return result
+ 'rokmi';
12008 hooks
.defineLocale('sk', {
12010 monthsShort
: monthsShort
$5,
12011 weekdays
: 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
12012 weekdaysShort
: 'ne_po_ut_st_št_pi_so'.split('_'),
12013 weekdaysMin
: 'ne_po_ut_st_št_pi_so'.split('_'),
12018 LL
: 'D. MMMM YYYY',
12019 LLL
: 'D. MMMM YYYY H:mm',
12020 LLLL
: 'dddd D. MMMM YYYY H:mm'
12023 sameDay
: '[dnes o] LT',
12024 nextDay
: '[zajtra o] LT',
12025 nextWeek: function () {
12026 switch (this.day()) {
12028 return '[v nedeľu o] LT';
12031 return '[v] dddd [o] LT';
12033 return '[v stredu o] LT';
12035 return '[vo štvrtok o] LT';
12037 return '[v piatok o] LT';
12039 return '[v sobotu o] LT';
12042 lastDay
: '[včera o] LT',
12043 lastWeek: function () {
12044 switch (this.day()) {
12046 return '[minulú nedeľu o] LT';
12049 return '[minulý] dddd [o] LT';
12051 return '[minulú stredu o] LT';
12054 return '[minulý] dddd [o] LT';
12056 return '[minulú sobotu o] LT';
12077 dayOfMonthOrdinalParse
: /\d{1,2}\./,
12080 dow
: 1, // Monday is the first day of the week.
12081 doy
: 4 // The week that contains Jan 4th is the first week of the year.
12085 //! moment.js locale configuration
12087 function processRelativeTime
$6(number
, withoutSuffix
, key
, isFuture
) {
12088 var result
= number
+ ' ';
12091 return withoutSuffix
|| isFuture
? 'nekaj sekund' : 'nekaj sekundami';
12093 if (number
=== 1) {
12094 result
+= withoutSuffix
? 'sekundo' : 'sekundi';
12095 } else if (number
=== 2) {
12096 result
+= withoutSuffix
|| isFuture
? 'sekundi' : 'sekundah';
12097 } else if (number
< 5) {
12098 result
+= withoutSuffix
|| isFuture
? 'sekunde' : 'sekundah';
12100 result
+= withoutSuffix
|| isFuture
? 'sekund' : 'sekund';
12104 return withoutSuffix
? 'ena minuta' : 'eno minuto';
12106 if (number
=== 1) {
12107 result
+= withoutSuffix
? 'minuta' : 'minuto';
12108 } else if (number
=== 2) {
12109 result
+= withoutSuffix
|| isFuture
? 'minuti' : 'minutama';
12110 } else if (number
< 5) {
12111 result
+= withoutSuffix
|| isFuture
? 'minute' : 'minutami';
12113 result
+= withoutSuffix
|| isFuture
? 'minut' : 'minutami';
12117 return withoutSuffix
? 'ena ura' : 'eno uro';
12119 if (number
=== 1) {
12120 result
+= withoutSuffix
? 'ura' : 'uro';
12121 } else if (number
=== 2) {
12122 result
+= withoutSuffix
|| isFuture
? 'uri' : 'urama';
12123 } else if (number
< 5) {
12124 result
+= withoutSuffix
|| isFuture
? 'ure' : 'urami';
12126 result
+= withoutSuffix
|| isFuture
? 'ur' : 'urami';
12130 return withoutSuffix
|| isFuture
? 'en dan' : 'enim dnem';
12132 if (number
=== 1) {
12133 result
+= withoutSuffix
|| isFuture
? 'dan' : 'dnem';
12134 } else if (number
=== 2) {
12135 result
+= withoutSuffix
|| isFuture
? 'dni' : 'dnevoma';
12137 result
+= withoutSuffix
|| isFuture
? 'dni' : 'dnevi';
12141 return withoutSuffix
|| isFuture
? 'en mesec' : 'enim mesecem';
12143 if (number
=== 1) {
12144 result
+= withoutSuffix
|| isFuture
? 'mesec' : 'mesecem';
12145 } else if (number
=== 2) {
12146 result
+= withoutSuffix
|| isFuture
? 'meseca' : 'mesecema';
12147 } else if (number
< 5) {
12148 result
+= withoutSuffix
|| isFuture
? 'mesece' : 'meseci';
12150 result
+= withoutSuffix
|| isFuture
? 'mesecev' : 'meseci';
12154 return withoutSuffix
|| isFuture
? 'eno leto' : 'enim letom';
12156 if (number
=== 1) {
12157 result
+= withoutSuffix
|| isFuture
? 'leto' : 'letom';
12158 } else if (number
=== 2) {
12159 result
+= withoutSuffix
|| isFuture
? 'leti' : 'letoma';
12160 } else if (number
< 5) {
12161 result
+= withoutSuffix
|| isFuture
? 'leta' : 'leti';
12163 result
+= withoutSuffix
|| isFuture
? 'let' : 'leti';
12169 hooks
.defineLocale('sl', {
12170 months
: 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
12171 monthsShort
: 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
12172 monthsParseExact
: true,
12173 weekdays
: 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
12174 weekdaysShort
: 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
12175 weekdaysMin
: 'ne_po_to_sr_če_pe_so'.split('_'),
12176 weekdaysParseExact
: true,
12181 LL
: 'D. MMMM YYYY',
12182 LLL
: 'D. MMMM YYYY H:mm',
12183 LLLL
: 'dddd, D. MMMM YYYY H:mm'
12186 sameDay
: '[danes ob] LT',
12187 nextDay
: '[jutri ob] LT',
12189 nextWeek : function () {
12190 switch (this.day()) {
12192 return '[v] [nedeljo] [ob] LT';
12194 return '[v] [sredo] [ob] LT';
12196 return '[v] [soboto] [ob] LT';
12201 return '[v] dddd [ob] LT';
12204 lastDay
: '[včeraj ob] LT',
12205 lastWeek : function () {
12206 switch (this.day()) {
12208 return '[prejšnjo] [nedeljo] [ob] LT';
12210 return '[prejšnjo] [sredo] [ob] LT';
12212 return '[prejšnjo] [soboto] [ob] LT';
12217 return '[prejšnji] dddd [ob] LT';
12225 s
: processRelativeTime
$6,
12226 ss
: processRelativeTime
$6,
12227 m
: processRelativeTime
$6,
12228 mm
: processRelativeTime
$6,
12229 h
: processRelativeTime
$6,
12230 hh
: processRelativeTime
$6,
12231 d
: processRelativeTime
$6,
12232 dd
: processRelativeTime
$6,
12233 M
: processRelativeTime
$6,
12234 MM
: processRelativeTime
$6,
12235 y
: processRelativeTime
$6,
12236 yy
: processRelativeTime
$6
12238 dayOfMonthOrdinalParse
: /\d{1,2}\./,
12241 dow
: 1, // Monday is the first day of the week.
12242 doy
: 7 // The week that contains Jan 1st is the first week of the year.
12246 //! moment.js locale configuration
12248 hooks
.defineLocale('sq', {
12249 months
: 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
12250 monthsShort
: 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
12251 weekdays
: 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
12252 weekdaysShort
: 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
12253 weekdaysMin
: 'D_H_Ma_Më_E_P_Sh'.split('_'),
12254 weekdaysParseExact
: true,
12255 meridiemParse
: /PD|MD/,
12256 isPM: function (input
) {
12257 return input
.charAt(0) === 'M';
12259 meridiem : function (hours
, minutes
, isLower
) {
12260 return hours
< 12 ? 'PD' : 'MD';
12266 LL
: 'D MMMM YYYY',
12267 LLL
: 'D MMMM YYYY HH:mm',
12268 LLLL
: 'dddd, D MMMM YYYY HH:mm'
12271 sameDay
: '[Sot në] LT',
12272 nextDay
: '[Nesër në] LT',
12273 nextWeek
: 'dddd [në] LT',
12274 lastDay
: '[Dje në] LT',
12275 lastWeek
: 'dddd [e kaluar në] LT',
12280 past
: '%s më parë',
12281 s
: 'disa sekonda',
12294 dayOfMonthOrdinalParse
: /\d{1,2}\./,
12297 dow
: 1, // Monday is the first day of the week.
12298 doy
: 4 // The week that contains Jan 4th is the first week of the year.
12302 //! moment.js locale configuration
12304 var translator
$1 = {
12305 words
: { //Different grammatical cases
12306 ss
: ['секунда', 'секунде', 'секунди'],
12307 m
: ['један минут', 'једне минуте'],
12308 mm
: ['минут', 'минуте', 'минута'],
12309 h
: ['један сат', 'једног сата'],
12310 hh
: ['сат', 'сата', 'сати'],
12311 dd
: ['дан', 'дана', 'дана'],
12312 MM
: ['месец', 'месеца', 'месеци'],
12313 yy
: ['година', 'године', 'година']
12315 correctGrammaticalCase: function (number
, wordKey
) {
12316 return number
=== 1 ? wordKey
[0] : (number
>= 2 && number
<= 4 ? wordKey
[1] : wordKey
[2]);
12318 translate: function (number
, withoutSuffix
, key
) {
12319 var wordKey
= translator
$1.words
[key
];
12320 if (key
.length
=== 1) {
12321 return withoutSuffix
? wordKey
[0] : wordKey
[1];
12323 return number
+ ' ' + translator
$1.correctGrammaticalCase(number
, wordKey
);
12328 hooks
.defineLocale('sr-cyrl', {
12329 months
: 'јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар'.split('_'),
12330 monthsShort
: 'јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.'.split('_'),
12331 monthsParseExact
: true,
12332 weekdays
: 'недеља_понедељак_уторак_среда_четвртак_петак_субота'.split('_'),
12333 weekdaysShort
: 'нед._пон._уто._сре._чет._пет._суб.'.split('_'),
12334 weekdaysMin
: 'не_по_ут_ср_че_пе_су'.split('_'),
12335 weekdaysParseExact
: true,
12340 LL
: 'D. MMMM YYYY',
12341 LLL
: 'D. MMMM YYYY H:mm',
12342 LLLL
: 'dddd, D. MMMM YYYY H:mm'
12345 sameDay
: '[данас у] LT',
12346 nextDay
: '[сутра у] LT',
12347 nextWeek: function () {
12348 switch (this.day()) {
12350 return '[у] [недељу] [у] LT';
12352 return '[у] [среду] [у] LT';
12354 return '[у] [суботу] [у] LT';
12359 return '[у] dddd [у] LT';
12362 lastDay
: '[јуче у] LT',
12363 lastWeek : function () {
12364 var lastWeekDays
= [
12365 '[прошле] [недеље] [у] LT',
12366 '[прошлог] [понедељка] [у] LT',
12367 '[прошлог] [уторка] [у] LT',
12368 '[прошле] [среде] [у] LT',
12369 '[прошлог] [четвртка] [у] LT',
12370 '[прошлог] [петка] [у] LT',
12371 '[прошле] [суботе] [у] LT'
12373 return lastWeekDays
[this.day()];
12380 s
: 'неколико секунди',
12381 ss
: translator
$1.translate
,
12382 m
: translator
$1.translate
,
12383 mm
: translator
$1.translate
,
12384 h
: translator
$1.translate
,
12385 hh
: translator
$1.translate
,
12387 dd
: translator
$1.translate
,
12389 MM
: translator
$1.translate
,
12391 yy
: translator
$1.translate
12393 dayOfMonthOrdinalParse
: /\d{1,2}\./,
12396 dow
: 1, // Monday is the first day of the week.
12397 doy
: 7 // The week that contains Jan 1st is the first week of the year.
12401 //! moment.js locale configuration
12403 var translator
$2 = {
12404 words
: { //Different grammatical cases
12405 ss
: ['sekunda', 'sekunde', 'sekundi'],
12406 m
: ['jedan minut', 'jedne minute'],
12407 mm
: ['minut', 'minute', 'minuta'],
12408 h
: ['jedan sat', 'jednog sata'],
12409 hh
: ['sat', 'sata', 'sati'],
12410 dd
: ['dan', 'dana', 'dana'],
12411 MM
: ['mesec', 'meseca', 'meseci'],
12412 yy
: ['godina', 'godine', 'godina']
12414 correctGrammaticalCase: function (number
, wordKey
) {
12415 return number
=== 1 ? wordKey
[0] : (number
>= 2 && number
<= 4 ? wordKey
[1] : wordKey
[2]);
12417 translate: function (number
, withoutSuffix
, key
) {
12418 var wordKey
= translator
$2.words
[key
];
12419 if (key
.length
=== 1) {
12420 return withoutSuffix
? wordKey
[0] : wordKey
[1];
12422 return number
+ ' ' + translator
$2.correctGrammaticalCase(number
, wordKey
);
12427 hooks
.defineLocale('sr', {
12428 months
: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
12429 monthsShort
: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
12430 monthsParseExact
: true,
12431 weekdays
: 'nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota'.split('_'),
12432 weekdaysShort
: 'ned._pon._uto._sre._čet._pet._sub.'.split('_'),
12433 weekdaysMin
: 'ne_po_ut_sr_če_pe_su'.split('_'),
12434 weekdaysParseExact
: true,
12439 LL
: 'D. MMMM YYYY',
12440 LLL
: 'D. MMMM YYYY H:mm',
12441 LLLL
: 'dddd, D. MMMM YYYY H:mm'
12444 sameDay
: '[danas u] LT',
12445 nextDay
: '[sutra u] LT',
12446 nextWeek: function () {
12447 switch (this.day()) {
12449 return '[u] [nedelju] [u] LT';
12451 return '[u] [sredu] [u] LT';
12453 return '[u] [subotu] [u] LT';
12458 return '[u] dddd [u] LT';
12461 lastDay
: '[juče u] LT',
12462 lastWeek : function () {
12463 var lastWeekDays
= [
12464 '[prošle] [nedelje] [u] LT',
12465 '[prošlog] [ponedeljka] [u] LT',
12466 '[prošlog] [utorka] [u] LT',
12467 '[prošle] [srede] [u] LT',
12468 '[prošlog] [četvrtka] [u] LT',
12469 '[prošlog] [petka] [u] LT',
12470 '[prošle] [subote] [u] LT'
12472 return lastWeekDays
[this.day()];
12479 s
: 'nekoliko sekundi',
12480 ss
: translator
$2.translate
,
12481 m
: translator
$2.translate
,
12482 mm
: translator
$2.translate
,
12483 h
: translator
$2.translate
,
12484 hh
: translator
$2.translate
,
12486 dd
: translator
$2.translate
,
12488 MM
: translator
$2.translate
,
12490 yy
: translator
$2.translate
12492 dayOfMonthOrdinalParse
: /\d{1,2}\./,
12495 dow
: 1, // Monday is the first day of the week.
12496 doy
: 7 // The week that contains Jan 1st is the first week of the year.
12500 //! moment.js locale configuration
12502 hooks
.defineLocale('ss', {
12503 months
: "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'),
12504 monthsShort
: 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
12505 weekdays
: 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'),
12506 weekdaysShort
: 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
12507 weekdaysMin
: 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
12508 weekdaysParseExact
: true,
12513 LL
: 'D MMMM YYYY',
12514 LLL
: 'D MMMM YYYY h:mm A',
12515 LLLL
: 'dddd, D MMMM YYYY h:mm A'
12518 sameDay
: '[Namuhla nga] LT',
12519 nextDay
: '[Kusasa nga] LT',
12520 nextWeek
: 'dddd [nga] LT',
12521 lastDay
: '[Itolo nga] LT',
12522 lastWeek
: 'dddd [leliphelile] [nga] LT',
12527 past
: 'wenteka nga %s',
12528 s
: 'emizuzwana lomcane',
12529 ss
: '%d mzuzwana',
12535 dd
: '%d emalanga',
12537 MM
: '%d tinyanga',
12541 meridiemParse
: /ekuseni|emini|entsambama|ebusuku/,
12542 meridiem : function (hours
, minutes
, isLower
) {
12545 } else if (hours
< 15) {
12547 } else if (hours
< 19) {
12548 return 'entsambama';
12553 meridiemHour : function (hour
, meridiem
) {
12557 if (meridiem
=== 'ekuseni') {
12559 } else if (meridiem
=== 'emini') {
12560 return hour
>= 11 ? hour
: hour
+ 12;
12561 } else if (meridiem
=== 'entsambama' || meridiem
=== 'ebusuku') {
12568 dayOfMonthOrdinalParse
: /\d{1,2}/,
12571 dow
: 1, // Monday is the first day of the week.
12572 doy
: 4 // The week that contains Jan 4th is the first week of the year.
12576 //! moment.js locale configuration
12578 hooks
.defineLocale('sv', {
12579 months
: 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
12580 monthsShort
: 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
12581 weekdays
: 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
12582 weekdaysShort
: 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
12583 weekdaysMin
: 'sö_må_ti_on_to_fr_lö'.split('_'),
12588 LL
: 'D MMMM YYYY',
12589 LLL
: 'D MMMM YYYY [kl.] HH:mm',
12590 LLLL
: 'dddd D MMMM YYYY [kl.] HH:mm',
12591 lll
: 'D MMM YYYY HH:mm',
12592 llll
: 'ddd D MMM YYYY HH:mm'
12595 sameDay
: '[Idag] LT',
12596 nextDay
: '[Imorgon] LT',
12597 lastDay
: '[Igår] LT',
12598 nextWeek
: '[På] dddd LT',
12599 lastWeek
: '[I] dddd[s] LT',
12604 past
: 'för %s sedan',
12605 s
: 'några sekunder',
12606 ss
: '%d sekunder',
12618 dayOfMonthOrdinalParse
: /\d{1,2}(e|a)/,
12619 ordinal : function (number
) {
12620 var b
= number
% 10,
12621 output
= (~~(number
% 100 / 10) === 1) ? 'e' :
12624 (b
=== 3) ? 'e' : 'e';
12625 return number
+ output
;
12628 dow
: 1, // Monday is the first day of the week.
12629 doy
: 4 // The week that contains Jan 4th is the first week of the year.
12633 //! moment.js locale configuration
12635 hooks
.defineLocale('sw', {
12636 months
: 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
12637 monthsShort
: 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
12638 weekdays
: 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
12639 weekdaysShort
: 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
12640 weekdaysMin
: 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
12641 weekdaysParseExact
: true,
12646 LL
: 'D MMMM YYYY',
12647 LLL
: 'D MMMM YYYY HH:mm',
12648 LLLL
: 'dddd, D MMMM YYYY HH:mm'
12651 sameDay
: '[leo saa] LT',
12652 nextDay
: '[kesho saa] LT',
12653 nextWeek
: '[wiki ijayo] dddd [saat] LT',
12654 lastDay
: '[jana] LT',
12655 lastWeek
: '[wiki iliyopita] dddd [saat] LT',
12659 future
: '%s baadaye',
12675 dow
: 1, // Monday is the first day of the week.
12676 doy
: 7 // The week that contains Jan 1st is the first week of the year.
12680 //! moment.js locale configuration
12682 var symbolMap
$e
= {
12706 hooks
.defineLocale('ta', {
12707 months
: 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
12708 monthsShort
: 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
12709 weekdays
: 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split('_'),
12710 weekdaysShort
: 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split('_'),
12711 weekdaysMin
: 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
12716 LL
: 'D MMMM YYYY',
12717 LLL
: 'D MMMM YYYY, HH:mm',
12718 LLLL
: 'dddd, D MMMM YYYY, HH:mm'
12721 sameDay
: '[இன்று] LT',
12722 nextDay
: '[நாளை] LT',
12723 nextWeek
: 'dddd, LT',
12724 lastDay
: '[நேற்று] LT',
12725 lastWeek
: '[கடந்த வாரம்] dddd, LT',
12731 s
: 'ஒரு சில விநாடிகள்',
12732 ss
: '%d விநாடிகள்',
12734 mm
: '%d நிமிடங்கள்',
12735 h
: 'ஒரு மணி நேரம்',
12736 hh
: '%d மணி நேரம்',
12740 MM
: '%d மாதங்கள்',
12744 dayOfMonthOrdinalParse
: /\d{1,2}வது/,
12745 ordinal : function (number
) {
12746 return number
+ 'வது';
12748 preparse: function (string
) {
12749 return string
.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match
) {
12750 return numberMap
$d
[match
];
12753 postformat: function (string
) {
12754 return string
.replace(/\d/g, function (match
) {
12755 return symbolMap
$e
[match
];
12758 // refer http://ta.wikipedia.org/s/1er1
12759 meridiemParse
: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
12760 meridiem : function (hour
, minute
, isLower
) {
12763 } else if (hour
< 6) {
12764 return ' வைகறை'; // வைகறை
12765 } else if (hour
< 10) {
12766 return ' காலை'; // காலை
12767 } else if (hour
< 14) {
12768 return ' நண்பகல்'; // நண்பகல்
12769 } else if (hour
< 18) {
12770 return ' எற்பாடு'; // எற்பாடு
12771 } else if (hour
< 22) {
12772 return ' மாலை'; // மாலை
12777 meridiemHour : function (hour
, meridiem
) {
12781 if (meridiem
=== 'யாமம்') {
12782 return hour
< 2 ? hour
: hour
+ 12;
12783 } else if (meridiem
=== 'வைகறை' || meridiem
=== 'காலை') {
12785 } else if (meridiem
=== 'நண்பகல்') {
12786 return hour
>= 10 ? hour
: hour
+ 12;
12792 dow
: 0, // Sunday is the first day of the week.
12793 doy
: 6 // The week that contains Jan 1st is the first week of the year.
12797 //! moment.js locale configuration
12799 hooks
.defineLocale('te', {
12800 months
: 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జూలై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split('_'),
12801 monthsShort
: 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జూలై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split('_'),
12802 monthsParseExact
: true,
12803 weekdays
: 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split('_'),
12804 weekdaysShort
: 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
12805 weekdaysMin
: 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
12810 LL
: 'D MMMM YYYY',
12811 LLL
: 'D MMMM YYYY, A h:mm',
12812 LLLL
: 'dddd, D MMMM YYYY, A h:mm'
12815 sameDay
: '[నేడు] LT',
12816 nextDay
: '[రేపు] LT',
12817 nextWeek
: 'dddd, LT',
12818 lastDay
: '[నిన్న] LT',
12819 lastWeek
: '[గత] dddd, LT',
12824 past
: '%s క్రితం',
12825 s
: 'కొన్ని క్షణాలు',
12828 mm
: '%d నిమిషాలు',
12836 yy
: '%d సంవత్సరాలు'
12838 dayOfMonthOrdinalParse
: /\d{1,2}వ/,
12840 meridiemParse
: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
12841 meridiemHour : function (hour
, meridiem
) {
12845 if (meridiem
=== 'రాత్రి') {
12846 return hour
< 4 ? hour
: hour
+ 12;
12847 } else if (meridiem
=== 'ఉదయం') {
12849 } else if (meridiem
=== 'మధ్యాహ్నం') {
12850 return hour
>= 10 ? hour
: hour
+ 12;
12851 } else if (meridiem
=== 'సాయంత్రం') {
12855 meridiem : function (hour
, minute
, isLower
) {
12858 } else if (hour
< 10) {
12860 } else if (hour
< 17) {
12861 return 'మధ్యాహ్నం';
12862 } else if (hour
< 20) {
12869 dow
: 0, // Sunday is the first day of the week.
12870 doy
: 6 // The week that contains Jan 1st is the first week of the year.
12874 //! moment.js locale configuration
12876 hooks
.defineLocale('tet', {
12877 months
: 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru'.split('_'),
12878 monthsShort
: 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
12879 weekdays
: 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu'.split('_'),
12880 weekdaysShort
: 'Dom_Seg_Ters_Kua_Kint_Sest_Sab'.split('_'),
12881 weekdaysMin
: 'Do_Seg_Te_Ku_Ki_Ses_Sa'.split('_'),
12886 LL
: 'D MMMM YYYY',
12887 LLL
: 'D MMMM YYYY HH:mm',
12888 LLLL
: 'dddd, D MMMM YYYY HH:mm'
12891 sameDay
: '[Ohin iha] LT',
12892 nextDay
: '[Aban iha] LT',
12893 nextWeek
: 'dddd [iha] LT',
12894 lastDay
: '[Horiseik iha] LT',
12895 lastWeek
: 'dddd [semana kotuk] [iha] LT',
12901 s
: 'minutu balun',
12914 dayOfMonthOrdinalParse
: /\d{1,2}(st|nd|rd|th)/,
12915 ordinal : function (number
) {
12916 var b
= number
% 10,
12917 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
12920 (b
=== 3) ? 'rd' : 'th';
12921 return number
+ output
;
12924 dow
: 1, // Monday is the first day of the week.
12925 doy
: 4 // The week that contains Jan 4th is the first week of the year.
12929 //! moment.js locale configuration
12956 hooks
.defineLocale('tg', {
12957 months
: 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
12958 monthsShort
: 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
12959 weekdays
: 'якшанбе_душанбе_сешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе'.split('_'),
12960 weekdaysShort
: 'яшб_дшб_сшб_чшб_пшб_ҷум_шнб'.split('_'),
12961 weekdaysMin
: 'яш_дш_сш_чш_пш_ҷм_шб'.split('_'),
12966 LL
: 'D MMMM YYYY',
12967 LLL
: 'D MMMM YYYY HH:mm',
12968 LLLL
: 'dddd, D MMMM YYYY HH:mm'
12971 sameDay
: '[Имрӯз соати] LT',
12972 nextDay
: '[Пагоҳ соати] LT',
12973 lastDay
: '[Дирӯз соати] LT',
12974 nextWeek
: 'dddd[и] [ҳафтаи оянда соати] LT',
12975 lastWeek
: 'dddd[и] [ҳафтаи гузашта соати] LT',
12979 future
: 'баъди %s',
12981 s
: 'якчанд сония',
12993 meridiemParse
: /шаб|субҳ|рӯз|бегоҳ/,
12994 meridiemHour: function (hour
, meridiem
) {
12998 if (meridiem
=== 'шаб') {
12999 return hour
< 4 ? hour
: hour
+ 12;
13000 } else if (meridiem
=== 'субҳ') {
13002 } else if (meridiem
=== 'рӯз') {
13003 return hour
>= 11 ? hour
: hour
+ 12;
13004 } else if (meridiem
=== 'бегоҳ') {
13008 meridiem: function (hour
, minute
, isLower
) {
13011 } else if (hour
< 11) {
13013 } else if (hour
< 16) {
13015 } else if (hour
< 19) {
13021 dayOfMonthOrdinalParse
: /\d{1,2}-(ум|юм)/,
13022 ordinal: function (number
) {
13023 var a
= number
% 10,
13024 b
= number
>= 100 ? 100 : null;
13025 return number
+ (suffixes
$3[number
] || suffixes
$3[a
] || suffixes
$3[b
]);
13028 dow
: 1, // Monday is the first day of the week.
13029 doy
: 7 // The week that contains Jan 1th is the first week of the year.
13033 //! moment.js locale configuration
13035 hooks
.defineLocale('th', {
13036 months
: 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
13037 monthsShort
: 'ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.'.split('_'),
13038 monthsParseExact
: true,
13039 weekdays
: 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
13040 weekdaysShort
: 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
13041 weekdaysMin
: 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
13042 weekdaysParseExact
: true,
13047 LL
: 'D MMMM YYYY',
13048 LLL
: 'D MMMM YYYY เวลา H:mm',
13049 LLLL
: 'วันddddที่ D MMMM YYYY เวลา H:mm'
13051 meridiemParse
: /ก่อนเที่ยง|หลังเที่ยง/,
13052 isPM: function (input
) {
13053 return input
=== 'หลังเที่ยง';
13055 meridiem : function (hour
, minute
, isLower
) {
13057 return 'ก่อนเที่ยง';
13059 return 'หลังเที่ยง';
13063 sameDay
: '[วันนี้ เวลา] LT',
13064 nextDay
: '[พรุ่งนี้ เวลา] LT',
13065 nextWeek
: 'dddd[หน้า เวลา] LT',
13066 lastDay
: '[เมื่อวานนี้ เวลา] LT',
13067 lastWeek
: '[วัน]dddd[ที่แล้ว เวลา] LT',
13072 past
: '%sที่แล้ว',
13073 s
: 'ไม่กี่วินาที',
13088 //! moment.js locale configuration
13090 hooks
.defineLocale('tl-ph', {
13091 months
: 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
13092 monthsShort
: 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
13093 weekdays
: 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
13094 weekdaysShort
: 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
13095 weekdaysMin
: 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
13100 LL
: 'MMMM D, YYYY',
13101 LLL
: 'MMMM D, YYYY HH:mm',
13102 LLLL
: 'dddd, MMMM DD, YYYY HH:mm'
13105 sameDay
: 'LT [ngayong araw]',
13106 nextDay
: '[Bukas ng] LT',
13107 nextWeek
: 'LT [sa susunod na] dddd',
13108 lastDay
: 'LT [kahapon]',
13109 lastWeek
: 'LT [noong nakaraang] dddd',
13113 future
: 'sa loob ng %s',
13114 past
: '%s ang nakalipas',
13115 s
: 'ilang segundo',
13117 m
: 'isang minuto',
13128 dayOfMonthOrdinalParse
: /\d{1,2}/,
13129 ordinal : function (number
) {
13133 dow
: 1, // Monday is the first day of the week.
13134 doy
: 4 // The week that contains Jan 4th is the first week of the year.
13138 //! moment.js locale configuration
13140 var numbersNouns
= 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
13142 function translateFuture(output
) {
13144 time
= (output
.indexOf('jaj') !== -1) ?
13145 time
.slice(0, -3) + 'leS' :
13146 (output
.indexOf('jar') !== -1) ?
13147 time
.slice(0, -3) + 'waQ' :
13148 (output
.indexOf('DIS') !== -1) ?
13149 time
.slice(0, -3) + 'nem' :
13154 function translatePast(output
) {
13156 time
= (output
.indexOf('jaj') !== -1) ?
13157 time
.slice(0, -3) + 'Hu’' :
13158 (output
.indexOf('jar') !== -1) ?
13159 time
.slice(0, -3) + 'wen' :
13160 (output
.indexOf('DIS') !== -1) ?
13161 time
.slice(0, -3) + 'ben' :
13166 function translate
$a(number
, withoutSuffix
, string
, isFuture
) {
13167 var numberNoun
= numberAsNoun(number
);
13170 return numberNoun
+ ' lup';
13172 return numberNoun
+ ' tup';
13174 return numberNoun
+ ' rep';
13176 return numberNoun
+ ' jaj';
13178 return numberNoun
+ ' jar';
13180 return numberNoun
+ ' DIS';
13184 function numberAsNoun(number
) {
13185 var hundred
= Math
.floor((number
% 1000) / 100),
13186 ten
= Math
.floor((number
% 100) / 10),
13190 word
+= numbersNouns
[hundred
] + 'vatlh';
13193 word
+= ((word
!== '') ? ' ' : '') + numbersNouns
[ten
] + 'maH';
13196 word
+= ((word
!== '') ? ' ' : '') + numbersNouns
[one
];
13198 return (word
=== '') ? 'pagh' : word
;
13201 hooks
.defineLocale('tlh', {
13202 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('_'),
13203 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('_'),
13204 monthsParseExact
: true,
13205 weekdays
: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
13206 weekdaysShort
: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
13207 weekdaysMin
: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
13212 LL
: 'D MMMM YYYY',
13213 LLL
: 'D MMMM YYYY HH:mm',
13214 LLLL
: 'dddd, D MMMM YYYY HH:mm'
13217 sameDay
: '[DaHjaj] LT',
13218 nextDay
: '[wa’leS] LT',
13220 lastDay
: '[wa’Hu’] LT',
13225 future
: translateFuture
,
13226 past
: translatePast
,
13240 dayOfMonthOrdinalParse
: /\d{1,2}\./,
13243 dow
: 1, // Monday is the first day of the week.
13244 doy
: 4 // The week that contains Jan 4th is the first week of the year.
13269 hooks
.defineLocale('tr', {
13270 months
: 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
13271 monthsShort
: 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
13272 weekdays
: 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
13273 weekdaysShort
: 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
13274 weekdaysMin
: 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
13279 LL
: 'D MMMM YYYY',
13280 LLL
: 'D MMMM YYYY HH:mm',
13281 LLLL
: 'dddd, D MMMM YYYY HH:mm'
13284 sameDay
: '[bugün saat] LT',
13285 nextDay
: '[yarın saat] LT',
13286 nextWeek
: '[gelecek] dddd [saat] LT',
13287 lastDay
: '[dün] LT',
13288 lastWeek
: '[geçen] dddd [saat] LT',
13292 future
: '%s sonra',
13294 s
: 'birkaç saniye',
13307 ordinal: function (number
, period
) {
13315 if (number
=== 0) { // special case for zero
13316 return number
+ '\'ıncı';
13318 var a
= number
% 10,
13319 b
= number
% 100 - a
,
13320 c
= number
>= 100 ? 100 : null;
13321 return number
+ (suffixes
$4[a
] || suffixes
$4[b
] || suffixes
$4[c
]);
13325 dow
: 1, // Monday is the first day of the week.
13326 doy
: 7 // The week that contains Jan 1st is the first week of the year.
13330 //! moment.js locale configuration
13332 // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
13333 // This is currently too difficult (maybe even impossible) to add.
13334 hooks
.defineLocale('tzl', {
13335 months
: 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'),
13336 monthsShort
: 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
13337 weekdays
: 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
13338 weekdaysShort
: 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
13339 weekdaysMin
: 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
13344 LL
: 'D. MMMM [dallas] YYYY',
13345 LLL
: 'D. MMMM [dallas] YYYY HH.mm',
13346 LLLL
: 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
13348 meridiemParse
: /d\'o|d\'a/i,
13349 isPM : function (input
) {
13350 return 'd\'o' === input
.toLowerCase();
13352 meridiem : function (hours
, minutes
, isLower
) {
13354 return isLower
? 'd\'o' : 'D\'O';
13356 return isLower
? 'd\'a' : 'D\'A';
13360 sameDay
: '[oxhi à] LT',
13361 nextDay
: '[demà à] LT',
13362 nextWeek
: 'dddd [à] LT',
13363 lastDay
: '[ieiri à] LT',
13364 lastWeek
: '[sür el] dddd [lasteu à] LT',
13368 future
: 'osprei %s',
13370 s
: processRelativeTime
$7,
13371 ss
: processRelativeTime
$7,
13372 m
: processRelativeTime
$7,
13373 mm
: processRelativeTime
$7,
13374 h
: processRelativeTime
$7,
13375 hh
: processRelativeTime
$7,
13376 d
: processRelativeTime
$7,
13377 dd
: processRelativeTime
$7,
13378 M
: processRelativeTime
$7,
13379 MM
: processRelativeTime
$7,
13380 y
: processRelativeTime
$7,
13381 yy
: processRelativeTime
$7
13383 dayOfMonthOrdinalParse
: /\d{1,2}\./,
13386 dow
: 1, // Monday is the first day of the week.
13387 doy
: 4 // The week that contains Jan 4th is the first week of the year.
13391 function processRelativeTime
$7(number
, withoutSuffix
, key
, isFuture
) {
13393 's': ['viensas secunds', '\'iensas secunds'],
13394 'ss': [number
+ ' secunds', '' + number
+ ' secunds'],
13395 'm': ['\'n míut', '\'iens míut'],
13396 'mm': [number
+ ' míuts', '' + number
+ ' míuts'],
13397 'h': ['\'n þora', '\'iensa þora'],
13398 'hh': [number
+ ' þoras', '' + number
+ ' þoras'],
13399 'd': ['\'n ziua', '\'iensa ziua'],
13400 'dd': [number
+ ' ziuas', '' + number
+ ' ziuas'],
13401 'M': ['\'n mes', '\'iens mes'],
13402 'MM': [number
+ ' mesen', '' + number
+ ' mesen'],
13403 'y': ['\'n ar', '\'iens ar'],
13404 'yy': [number
+ ' ars', '' + number
+ ' ars']
13406 return isFuture
? format
[key
][0] : (withoutSuffix
? format
[key
][0] : format
[key
][1]);
13409 //! moment.js locale configuration
13411 hooks
.defineLocale('tzm-latn', {
13412 months
: 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
13413 monthsShort
: 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
13414 weekdays
: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
13415 weekdaysShort
: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
13416 weekdaysMin
: 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
13421 LL
: 'D MMMM YYYY',
13422 LLL
: 'D MMMM YYYY HH:mm',
13423 LLLL
: 'dddd D MMMM YYYY HH:mm'
13426 sameDay
: '[asdkh g] LT',
13427 nextDay
: '[aska g] LT',
13428 nextWeek
: 'dddd [g] LT',
13429 lastDay
: '[assant g] LT',
13430 lastWeek
: 'dddd [g] LT',
13434 future
: 'dadkh s yan %s',
13441 hh
: '%d tassaɛin',
13450 dow
: 6, // Saturday is the first day of the week.
13451 doy
: 12 // The week that contains Jan 1st is the first week of the year.
13455 //! moment.js locale configuration
13457 hooks
.defineLocale('tzm', {
13458 months
: 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
13459 monthsShort
: 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
13460 weekdays
: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
13461 weekdaysShort
: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
13462 weekdaysMin
: 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
13467 LL
: 'D MMMM YYYY',
13468 LLL
: 'D MMMM YYYY HH:mm',
13469 LLLL
: 'dddd D MMMM YYYY HH:mm'
13472 sameDay
: '[ⴰⵙⴷⵅ ⴴ] LT',
13473 nextDay
: '[ⴰⵙⴽⴰ ⴴ] LT',
13474 nextWeek
: 'dddd [ⴴ] LT',
13475 lastDay
: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
13476 lastWeek
: 'dddd [ⴴ] LT',
13480 future
: 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
13487 hh
: '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
13496 dow
: 6, // Saturday is the first day of the week.
13497 doy
: 12 // The week that contains Jan 1st is the first week of the year.
13501 //! moment.js language configuration
13503 hooks
.defineLocale('ug-cn', {
13504 months
: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
13507 monthsShort
: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
13510 weekdays
: 'يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە'.split(
13513 weekdaysShort
: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
13514 weekdaysMin
: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
13519 LL
: 'YYYY-يىلىM-ئاينىڭD-كۈنى',
13520 LLL
: 'YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm',
13521 LLLL
: 'dddd، YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm'
13523 meridiemParse
: /يېرىم كېچە|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن كېيىن|كەچ/,
13524 meridiemHour: function (hour
, meridiem
) {
13529 meridiem
=== 'يېرىم كېچە' ||
13530 meridiem
=== 'سەھەر' ||
13531 meridiem
=== 'چۈشتىن بۇرۇن'
13534 } else if (meridiem
=== 'چۈشتىن كېيىن' || meridiem
=== 'كەچ') {
13537 return hour
>= 11 ? hour
: hour
+ 12;
13540 meridiem: function (hour
, minute
, isLower
) {
13541 var hm
= hour
* 100 + minute
;
13543 return 'يېرىم كېچە';
13544 } else if (hm
< 900) {
13546 } else if (hm
< 1130) {
13547 return 'چۈشتىن بۇرۇن';
13548 } else if (hm
< 1230) {
13550 } else if (hm
< 1800) {
13551 return 'چۈشتىن كېيىن';
13557 sameDay
: '[بۈگۈن سائەت] LT',
13558 nextDay
: '[ئەتە سائەت] LT',
13559 nextWeek
: '[كېلەركى] dddd [سائەت] LT',
13560 lastDay
: '[تۆنۈگۈن] LT',
13561 lastWeek
: '[ئالدىنقى] dddd [سائەت] LT',
13565 future
: '%s كېيىن',
13581 dayOfMonthOrdinalParse
: /\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,
13582 ordinal: function (number
, period
) {
13587 return number
+ '-كۈنى';
13590 return number
+ '-ھەپتە';
13595 preparse: function (string
) {
13596 return string
.replace(/،/g, ',');
13598 postformat: function (string
) {
13599 return string
.replace(/,/g
, '،');
13602 // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
13603 dow
: 1, // Monday is the first day of the week.
13604 doy
: 7 // The week that contains Jan 1st is the first week of the year.
13608 //! moment.js locale configuration
13610 function plural
$6(word
, num
) {
13611 var forms
= word
.split('_');
13612 return num
% 10 === 1 && num
% 100 !== 11 ? forms
[0] : (num
% 10 >= 2 && num
% 10 <= 4 && (num
% 100 < 10 || num
% 100 >= 20) ? forms
[1] : forms
[2]);
13614 function relativeTimeWithPlural
$4(number
, withoutSuffix
, key
) {
13616 'ss': withoutSuffix
? 'секунда_секунди_секунд' : 'секунду_секунди_секунд',
13617 'mm': withoutSuffix
? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
13618 'hh': withoutSuffix
? 'година_години_годин' : 'годину_години_годин',
13619 'dd': 'день_дні_днів',
13620 'MM': 'місяць_місяці_місяців',
13621 'yy': 'рік_роки_років'
13624 return withoutSuffix
? 'хвилина' : 'хвилину';
13626 else if (key
=== 'h') {
13627 return withoutSuffix
? 'година' : 'годину';
13630 return number
+ ' ' + plural
$6(format
[key
], +number
);
13633 function weekdaysCaseReplace(m
, format
) {
13635 'nominative': 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
13636 'accusative': 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split('_'),
13637 'genitive': 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split('_')
13641 return weekdays
['nominative'];
13644 var nounCase
= (/(\[[ВвУу]\]) ?dddd/).test(format
) ?
13646 ((/\[?(?:минулої|наступної)? ?\] ?dddd/).test(format
) ?
13649 return weekdays
[nounCase
][m
.day()];
13651 function processHoursFunction(str
) {
13652 return function () {
13653 return str
+ 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
13657 hooks
.defineLocale('uk', {
13659 'format': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_'),
13660 'standalone': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_')
13662 monthsShort
: 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
13663 weekdays
: weekdaysCaseReplace
,
13664 weekdaysShort
: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
13665 weekdaysMin
: 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
13670 LL
: 'D MMMM YYYY р.',
13671 LLL
: 'D MMMM YYYY р., HH:mm',
13672 LLLL
: 'dddd, D MMMM YYYY р., HH:mm'
13675 sameDay
: processHoursFunction('[Сьогодні '),
13676 nextDay
: processHoursFunction('[Завтра '),
13677 lastDay
: processHoursFunction('[Вчора '),
13678 nextWeek
: processHoursFunction('[У] dddd ['),
13679 lastWeek: function () {
13680 switch (this.day()) {
13685 return processHoursFunction('[Минулої] dddd [').call(this);
13689 return processHoursFunction('[Минулого] dddd [').call(this);
13697 s
: 'декілька секунд',
13698 ss
: relativeTimeWithPlural
$4,
13699 m
: relativeTimeWithPlural
$4,
13700 mm
: relativeTimeWithPlural
$4,
13702 hh
: relativeTimeWithPlural
$4,
13704 dd
: relativeTimeWithPlural
$4,
13706 MM
: relativeTimeWithPlural
$4,
13708 yy
: relativeTimeWithPlural
$4
13710 // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
13711 meridiemParse
: /ночі|ранку|дня|вечора/,
13712 isPM: function (input
) {
13713 return /^(дня|вечора)$/.test(input
);
13715 meridiem : function (hour
, minute
, isLower
) {
13718 } else if (hour
< 12) {
13720 } else if (hour
< 17) {
13726 dayOfMonthOrdinalParse
: /\d{1,2}-(й|го)/,
13727 ordinal: function (number
, period
) {
13734 return number
+ '-й';
13736 return number
+ '-го';
13742 dow
: 1, // Monday is the first day of the week.
13743 doy
: 7 // The week that contains Jan 1st is the first week of the year.
13747 //! moment.js locale configuration
13773 hooks
.defineLocale('ur', {
13775 monthsShort
: months
$8,
13777 weekdaysShort
: days
$2,
13778 weekdaysMin
: days
$2,
13783 LL
: 'D MMMM YYYY',
13784 LLL
: 'D MMMM YYYY HH:mm',
13785 LLLL
: 'dddd، D MMMM YYYY HH:mm'
13787 meridiemParse
: /صبح|شام/,
13788 isPM : function (input
) {
13789 return 'شام' === input
;
13791 meridiem : function (hour
, minute
, isLower
) {
13798 sameDay
: '[آج بوقت] LT',
13799 nextDay
: '[کل بوقت] LT',
13800 nextWeek
: 'dddd [بوقت] LT',
13801 lastDay
: '[گذشتہ روز بوقت] LT',
13802 lastWeek
: '[گذشتہ] dddd [بوقت] LT',
13821 preparse: function (string
) {
13822 return string
.replace(/،/g, ',');
13824 postformat: function (string
) {
13825 return string
.replace(/,/g
, '،');
13828 dow
: 1, // Monday is the first day of the week.
13829 doy
: 4 // The week that contains Jan 4th is the first week of the year.
13833 //! moment.js locale configuration
13835 hooks
.defineLocale('uz-latn', {
13836 months
: 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split('_'),
13837 monthsShort
: 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'),
13838 weekdays
: 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split('_'),
13839 weekdaysShort
: 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'),
13840 weekdaysMin
: 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'),
13845 LL
: 'D MMMM YYYY',
13846 LLL
: 'D MMMM YYYY HH:mm',
13847 LLLL
: 'D MMMM YYYY, dddd HH:mm'
13850 sameDay
: '[Bugun soat] LT [da]',
13851 nextDay
: '[Ertaga] LT [da]',
13852 nextWeek
: 'dddd [kuni soat] LT [da]',
13853 lastDay
: '[Kecha soat] LT [da]',
13854 lastWeek
: '[O\'tgan] dddd [kuni soat] LT [da]',
13858 future
: 'Yaqin %s ichida',
13859 past
: 'Bir necha %s oldin',
13874 dow
: 1, // Monday is the first day of the week.
13875 doy
: 7 // The week that contains Jan 1st is the first week of the year.
13879 //! moment.js locale configuration
13881 hooks
.defineLocale('uz', {
13882 months
: 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
13883 monthsShort
: 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
13884 weekdays
: 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
13885 weekdaysShort
: 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
13886 weekdaysMin
: 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
13891 LL
: 'D MMMM YYYY',
13892 LLL
: 'D MMMM YYYY HH:mm',
13893 LLLL
: 'D MMMM YYYY, dddd HH:mm'
13896 sameDay
: '[Бугун соат] LT [да]',
13897 nextDay
: '[Эртага] LT [да]',
13898 nextWeek
: 'dddd [куни соат] LT [да]',
13899 lastDay
: '[Кеча соат] LT [да]',
13900 lastWeek
: '[Утган] dddd [куни соат] LT [да]',
13904 future
: 'Якин %s ичида',
13905 past
: 'Бир неча %s олдин',
13920 dow
: 1, // Monday is the first day of the week.
13921 doy
: 7 // The week that contains Jan 4th is the first week of the year.
13925 //! moment.js locale configuration
13927 hooks
.defineLocale('vi', {
13928 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('_'),
13929 monthsShort
: 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
13930 monthsParseExact
: true,
13931 weekdays
: 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
13932 weekdaysShort
: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
13933 weekdaysMin
: 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
13934 weekdaysParseExact
: true,
13935 meridiemParse
: /sa|ch/i,
13936 isPM : function (input
) {
13937 return /^ch$/i.test(input
);
13939 meridiem : function (hours
, minutes
, isLower
) {
13941 return isLower
? 'sa' : 'SA';
13943 return isLower
? 'ch' : 'CH';
13950 LL
: 'D MMMM [năm] YYYY',
13951 LLL
: 'D MMMM [năm] YYYY HH:mm',
13952 LLLL
: 'dddd, D MMMM [năm] YYYY HH:mm',
13955 lll
: 'D MMM YYYY HH:mm',
13956 llll
: 'ddd, D MMM YYYY HH:mm'
13959 sameDay
: '[Hôm nay lúc] LT',
13960 nextDay
: '[Ngày mai lúc] LT',
13961 nextWeek
: 'dddd [tuần tới lúc] LT',
13962 lastDay
: '[Hôm qua lúc] LT',
13963 lastWeek
: 'dddd [tuần rồi lúc] LT',
13982 dayOfMonthOrdinalParse
: /\d{1,2}/,
13983 ordinal : function (number
) {
13987 dow
: 1, // Monday is the first day of the week.
13988 doy
: 4 // The week that contains Jan 4th is the first week of the year.
13992 //! moment.js locale configuration
13994 hooks
.defineLocale('x-pseudo', {
13995 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('_'),
13996 monthsShort
: 'J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc'.split('_'),
13997 monthsParseExact
: true,
13998 weekdays
: 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý'.split('_'),
13999 weekdaysShort
: 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát'.split('_'),
14000 weekdaysMin
: 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
14001 weekdaysParseExact
: true,
14005 LL
: 'D MMMM YYYY',
14006 LLL
: 'D MMMM YYYY HH:mm',
14007 LLLL
: 'dddd, D MMMM YYYY HH:mm'
14010 sameDay
: '[T~ódá~ý át] LT',
14011 nextDay
: '[T~ómó~rró~w át] LT',
14012 nextWeek
: 'dddd [át] LT',
14013 lastDay
: '[Ý~ést~érdá~ý át] LT',
14014 lastWeek
: '[L~ást] dddd [át] LT',
14020 s
: 'á ~féw ~sécó~ñds',
14021 ss
: '%d s~écóñ~ds',
14023 mm
: '%d m~íñú~tés',
14029 MM
: '%d m~óñt~hs',
14033 dayOfMonthOrdinalParse
: /\d{1,2}(th|st|nd|rd)/,
14034 ordinal : function (number
) {
14035 var b
= number
% 10,
14036 output
= (~~(number
% 100 / 10) === 1) ? 'th' :
14039 (b
=== 3) ? 'rd' : 'th';
14040 return number
+ output
;
14043 dow
: 1, // Monday is the first day of the week.
14044 doy
: 4 // The week that contains Jan 4th is the first week of the year.
14048 //! moment.js locale configuration
14050 hooks
.defineLocale('yo', {
14051 months
: 'Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀'.split('_'),
14052 monthsShort
: 'Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀'.split('_'),
14053 weekdays
: 'Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta'.split('_'),
14054 weekdaysShort
: 'Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá'.split('_'),
14055 weekdaysMin
: 'Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb'.split('_'),
14060 LL
: 'D MMMM YYYY',
14061 LLL
: 'D MMMM YYYY h:mm A',
14062 LLLL
: 'dddd, D MMMM YYYY h:mm A'
14065 sameDay
: '[Ònì ni] LT',
14066 nextDay
: '[Ọ̀la ni] LT',
14067 nextWeek
: 'dddd [Ọsẹ̀ tón\'bọ] [ni] LT',
14068 lastDay
: '[Àna ni] LT',
14069 lastWeek
: 'dddd [Ọsẹ̀ tólọ́] [ni] LT',
14075 s
: 'ìsẹjú aayá die',
14088 dayOfMonthOrdinalParse
: /ọjọ́\s\d{1,2}/,
14089 ordinal
: 'ọjọ́ %d',
14091 dow
: 1, // Monday is the first day of the week.
14092 doy
: 4 // The week that contains Jan 4th is the first week of the year.
14096 //! moment.js locale configuration
14098 hooks
.defineLocale('zh-cn', {
14099 months
: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
14100 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
14101 weekdays
: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
14102 weekdaysShort
: '周日_周一_周二_周三_周四_周五_周六'.split('_'),
14103 weekdaysMin
: '日_一_二_三_四_五_六'.split('_'),
14109 LLL
: 'YYYY年M月D日Ah点mm分',
14110 LLLL
: 'YYYY年M月D日ddddAh点mm分',
14113 lll
: 'YYYY年M月D日 HH:mm',
14114 llll
: 'YYYY年M月D日dddd HH:mm'
14116 meridiemParse
: /凌晨|早上|上午|中午|下午|晚上/,
14117 meridiemHour: function (hour
, meridiem
) {
14121 if (meridiem
=== '凌晨' || meridiem
=== '早上' ||
14122 meridiem
=== '上午') {
14124 } else if (meridiem
=== '下午' || meridiem
=== '晚上') {
14128 return hour
>= 11 ? hour
: hour
+ 12;
14131 meridiem : function (hour
, minute
, isLower
) {
14132 var hm
= hour
* 100 + minute
;
14135 } else if (hm
< 900) {
14137 } else if (hm
< 1130) {
14139 } else if (hm
< 1230) {
14141 } else if (hm
< 1800) {
14148 sameDay
: '[今天]LT',
14149 nextDay
: '[明天]LT',
14150 nextWeek
: '[下]ddddLT',
14151 lastDay
: '[昨天]LT',
14152 lastWeek
: '[上]ddddLT',
14155 dayOfMonthOrdinalParse
: /\d{1,2}(日|月|周)/,
14156 ordinal : function (number
, period
) {
14161 return number
+ '日';
14163 return number
+ '月';
14166 return number
+ '周';
14188 // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
14189 dow
: 1, // Monday is the first day of the week.
14190 doy
: 4 // The week that contains Jan 4th is the first week of the year.
14194 //! moment.js locale configuration
14196 hooks
.defineLocale('zh-hk', {
14197 months
: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
14198 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
14199 weekdays
: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
14200 weekdaysShort
: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
14201 weekdaysMin
: '日_一_二_三_四_五_六'.split('_'),
14207 LLL
: 'YYYY年M月D日 HH:mm',
14208 LLLL
: 'YYYY年M月D日dddd HH:mm',
14211 lll
: 'YYYY年M月D日 HH:mm',
14212 llll
: 'YYYY年M月D日dddd HH:mm'
14214 meridiemParse
: /凌晨|早上|上午|中午|下午|晚上/,
14215 meridiemHour : function (hour
, meridiem
) {
14219 if (meridiem
=== '凌晨' || meridiem
=== '早上' || meridiem
=== '上午') {
14221 } else if (meridiem
=== '中午') {
14222 return hour
>= 11 ? hour
: hour
+ 12;
14223 } else if (meridiem
=== '下午' || meridiem
=== '晚上') {
14227 meridiem : function (hour
, minute
, isLower
) {
14228 var hm
= hour
* 100 + minute
;
14231 } else if (hm
< 900) {
14233 } else if (hm
< 1130) {
14235 } else if (hm
< 1230) {
14237 } else if (hm
< 1800) {
14244 sameDay
: '[今天]LT',
14245 nextDay
: '[明天]LT',
14246 nextWeek
: '[下]ddddLT',
14247 lastDay
: '[昨天]LT',
14248 lastWeek
: '[上]ddddLT',
14251 dayOfMonthOrdinalParse
: /\d{1,2}(日|月|週)/,
14252 ordinal : function (number
, period
) {
14257 return number
+ '日';
14259 return number
+ '月';
14262 return number
+ '週';
14285 //! moment.js locale configuration
14287 hooks
.defineLocale('zh-tw', {
14288 months
: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
14289 monthsShort
: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
14290 weekdays
: '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
14291 weekdaysShort
: '週日_週一_週二_週三_週四_週五_週六'.split('_'),
14292 weekdaysMin
: '日_一_二_三_四_五_六'.split('_'),
14298 LLL
: 'YYYY年M月D日 HH:mm',
14299 LLLL
: 'YYYY年M月D日dddd HH:mm',
14302 lll
: 'YYYY年M月D日 HH:mm',
14303 llll
: 'YYYY年M月D日dddd HH:mm'
14305 meridiemParse
: /凌晨|早上|上午|中午|下午|晚上/,
14306 meridiemHour : function (hour
, meridiem
) {
14310 if (meridiem
=== '凌晨' || meridiem
=== '早上' || meridiem
=== '上午') {
14312 } else if (meridiem
=== '中午') {
14313 return hour
>= 11 ? hour
: hour
+ 12;
14314 } else if (meridiem
=== '下午' || meridiem
=== '晚上') {
14318 meridiem : function (hour
, minute
, isLower
) {
14319 var hm
= hour
* 100 + minute
;
14322 } else if (hm
< 900) {
14324 } else if (hm
< 1130) {
14326 } else if (hm
< 1230) {
14328 } else if (hm
< 1800) {
14335 sameDay
: '[今天] LT',
14336 nextDay
: '[明天] LT',
14337 nextWeek
: '[下]dddd LT',
14338 lastDay
: '[昨天] LT',
14339 lastWeek
: '[上]dddd LT',
14342 dayOfMonthOrdinalParse
: /\d{1,2}(日|月|週)/,
14343 ordinal : function (number
, period
) {
14348 return number
+ '日';
14350 return number
+ '月';
14353 return number
+ '週';
14376 hooks
.locale('en');