3 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
7 (function (undefined) {
8 /************************************
10 ************************************/
14 // the global-scope this is NOT the global object in Node.js
15 globalScope
= typeof global
!== 'undefined' ? global
: this,
18 hasOwnProperty
= Object
.prototype.hasOwnProperty
,
29 // internal storage for locale config files
32 // extra moment internal properties (plugins register props here)
33 momentProperties
= [],
36 hasModule
= (typeof module
!== 'undefined' && module
.exports
),
38 // ASP.NET json date format regex
39 aspNetJsonRegex
= /^\/?Date\((\-?\d+)/i,
40 aspNetTimeSpanJsonRegex
= /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/,
42 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
43 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
44 isoDurationRegex
= /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/,
47 formattingTokens
= /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|X|zz?|ZZ?|.)/g,
48 localFormattingTokens
= /(\[[^\[]*\])|(\\)?(LT|LL?L?L?|l{1,4})/g,
50 // parsing token regexes
51 parseTokenOneOrTwoDigits
= /\d\d?/, // 0 - 99
52 parseTokenOneToThreeDigits
= /\d{1,3}/, // 0 - 999
53 parseTokenOneToFourDigits
= /\d{1,4}/, // 0 - 9999
54 parseTokenOneToSixDigits
= /[+\-]?\d{1,6}/, // -999,999 - 999,999
55 parseTokenDigits
= /\d+/, // nonzero number of digits
56 parseTokenWord
= /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i, // any word (or two) characters or numbers including two/three word month in arabic.
57 parseTokenTimezone
= /Z|[\+\-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
58 parseTokenT
= /T/i, // T (ISO separator
)
59 parseTokenTimestampMs
= /[\+\-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
60 parseTokenOrdinal
= /\d{1,2}/,
62 //strict parsing regexes
63 parseTokenOneDigit
= /\d/, // 0 - 9
64 parseTokenTwoDigits
= /\d\d/, // 00 - 99
65 parseTokenThreeDigits
= /\d{3}/, // 000 - 999
66 parseTokenFourDigits
= /\d{4}/, // 0000 - 9999
67 parseTokenSixDigits
= /[+-]?\d{6}/, // -999,999 - 999,999
68 parseTokenSignedNumber
= /[+-]?\d+/, // -inf - inf
71 // 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)
72 isoRegex
= /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
74 isoFormat
= 'YYYY-MM-DDTHH:mm:ssZ',
77 ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
78 ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
79 ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
80 ['GGGG-[W]WW', /\d{4}-W\d{2}/],
81 ['YYYY-DDD', /\d{4}-\d{3}/]
84 // iso time formats and regexes
86 ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
87 ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
88 ['HH:mm', /(T| )\d\d:\d\d/],
92 // timezone chunker '+10:00' > ['10', '00'] or '-1530' > ['-15', '30']
93 parseTimezoneChunker
= /([\+\-]|\d\d)/gi,
95 // getter and setter names
96 proxyGettersAndSetters
= 'Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),
97 unitMillisecondFactors
= {
127 dayofyear
: 'dayOfYear',
128 isoweekday
: 'isoWeekday',
130 weekyear
: 'weekYear',
131 isoweekyear
: 'isoWeekYear'
134 // format function strings
135 formatFunctions
= {},
137 // default relative time thresholds
138 relativeTimeThresholds
= {
139 s
: 45, // seconds to minute
140 m
: 45, // minutes to hour
141 h
: 22, // hours to day
142 d
: 26, // days to month
143 M
: 11 // months to year
146 // tokens to ordinalize and pad
147 ordinalizeTokens
= 'DDD w W M D d'.split(' '),
148 paddedTokens
= 'M D H h m s w W'.split(' '),
150 formatTokenFunctions
= {
152 return this.month() + 1;
154 MMM : function (format
) {
155 return this.localeData().monthsShort(this, format
);
157 MMMM : function (format
) {
158 return this.localeData().months(this, format
);
164 return this.dayOfYear();
169 dd : function (format
) {
170 return this.localeData().weekdaysMin(this, format
);
172 ddd : function (format
) {
173 return this.localeData().weekdaysShort(this, format
);
175 dddd : function (format
) {
176 return this.localeData().weekdays(this, format
);
182 return this.isoWeek();
185 return leftZeroFill(this.year() % 100, 2);
188 return leftZeroFill(this.year(), 4);
190 YYYYY : function () {
191 return leftZeroFill(this.year(), 5);
193 YYYYYY : function () {
194 var y
= this.year(), sign
= y
>= 0 ? '+' : '-';
195 return sign
+ leftZeroFill(Math
.abs(y
), 6);
198 return leftZeroFill(this.weekYear() % 100, 2);
201 return leftZeroFill(this.weekYear(), 4);
203 ggggg : function () {
204 return leftZeroFill(this.weekYear(), 5);
207 return leftZeroFill(this.isoWeekYear() % 100, 2);
210 return leftZeroFill(this.isoWeekYear(), 4);
212 GGGGG : function () {
213 return leftZeroFill(this.isoWeekYear(), 5);
216 return this.weekday();
219 return this.isoWeekday();
222 return this.localeData().meridiem(this.hours(), this.minutes(), true);
225 return this.localeData().meridiem(this.hours(), this.minutes(), false);
231 return this.hours() % 12 || 12;
234 return this.minutes();
237 return this.seconds();
240 return toInt(this.milliseconds() / 100);
243 return leftZeroFill(toInt(this.milliseconds() / 10), 2);
246 return leftZeroFill(this.milliseconds(), 3);
249 return leftZeroFill(this.milliseconds(), 3);
252 var a
= -this.zone(),
258 return b
+ leftZeroFill(toInt(a
/ 60), 2) + ':' + leftZeroFill(toInt(a
) % 60, 2);
261 var a
= -this.zone(),
267 return b
+ leftZeroFill(toInt(a
/ 60), 2) + leftZeroFill(toInt(a
) % 60, 2);
270 return this.zoneAbbr();
273 return this.zoneName();
279 return this.quarter();
285 lists
= ['months', 'monthsShort', 'weekdays', 'weekdaysShort', 'weekdaysMin'];
287 // Pick the first defined of two or three arguments. dfl comes from
289 function dfl(a
, b
, c
) {
290 switch (arguments
.length
) {
291 case 2: return a
!= null ? a
: b
;
292 case 3: return a
!= null ? a
: b
!= null ? b
: c
;
293 default: throw new Error('Implement me');
297 function hasOwnProp(a
, b
) {
298 return hasOwnProperty
.call(a
, b
);
301 function defaultParsingFlags() {
302 // We need to deep clone this object, and es5 standard is not very
312 invalidFormat
: false,
313 userInvalidated
: false,
318 function printMsg(msg
) {
319 if (moment
.suppressDeprecationWarnings
=== false &&
320 typeof console
!== 'undefined' && console
.warn
) {
321 console
.warn('Deprecation warning: ' + msg
);
325 function deprecate(msg
, fn
) {
326 var firstTime
= true;
327 return extend(function () {
332 return fn
.apply(this, arguments
);
336 function deprecateSimple(name
, msg
) {
337 if (!deprecations
[name
]) {
339 deprecations
[name
] = true;
343 function padToken(func
, count
) {
344 return function (a
) {
345 return leftZeroFill(func
.call(this, a
), count
);
348 function ordinalizeToken(func
, period
) {
349 return function (a
) {
350 return this.localeData().ordinal(func
.call(this, a
), period
);
354 while (ordinalizeTokens
.length
) {
355 i
= ordinalizeTokens
.pop();
356 formatTokenFunctions
[i
+ 'o'] = ordinalizeToken(formatTokenFunctions
[i
], i
);
358 while (paddedTokens
.length
) {
359 i
= paddedTokens
.pop();
360 formatTokenFunctions
[i
+ i
] = padToken(formatTokenFunctions
[i
], 2);
362 formatTokenFunctions
.DDDD
= padToken(formatTokenFunctions
.DDD
, 3);
365 /************************************
367 ************************************/
372 // Moment prototype object
373 function Moment(config
, skipOverflow
) {
374 if (skipOverflow
!== false) {
375 checkOverflow(config
);
377 copyConfig(this, config
);
378 this._d
= new Date(+config
._d
);
381 // Duration Constructor
382 function Duration(duration
) {
383 var normalizedInput
= normalizeObjectUnits(duration
),
384 years
= normalizedInput
.year
|| 0,
385 quarters
= normalizedInput
.quarter
|| 0,
386 months
= normalizedInput
.month
|| 0,
387 weeks
= normalizedInput
.week
|| 0,
388 days
= normalizedInput
.day
|| 0,
389 hours
= normalizedInput
.hour
|| 0,
390 minutes
= normalizedInput
.minute
|| 0,
391 seconds
= normalizedInput
.second
|| 0,
392 milliseconds
= normalizedInput
.millisecond
|| 0;
394 // representation for dateAddRemove
395 this._milliseconds
= +milliseconds
+
396 seconds
* 1e3
+ // 1000
397 minutes
* 6e4
+ // 1000 * 60
398 hours
* 36e5
; // 1000 * 60 * 60
399 // Because of dateAddRemove treats 24 hours as different from a
400 // day when working around DST, we need to store them separately
403 // It is impossible translate months into days without knowing
404 // which months you are are talking about, so we have to store
406 this._months
= +months
+
412 this._locale
= moment
.localeData();
417 /************************************
419 ************************************/
422 function extend(a
, b
) {
424 if (hasOwnProp(b
, i
)) {
429 if (hasOwnProp(b
, 'toString')) {
430 a
.toString
= b
.toString
;
433 if (hasOwnProp(b
, 'valueOf')) {
434 a
.valueOf
= b
.valueOf
;
440 function copyConfig(to
, from) {
443 if (typeof from._isAMomentObject
!== 'undefined') {
444 to
._isAMomentObject
= from._isAMomentObject
;
446 if (typeof from._i
!== 'undefined') {
449 if (typeof from._f
!== 'undefined') {
452 if (typeof from._l
!== 'undefined') {
455 if (typeof from._strict
!== 'undefined') {
456 to
._strict
= from._strict
;
458 if (typeof from._tzm
!== 'undefined') {
461 if (typeof from._isUTC
!== 'undefined') {
462 to
._isUTC
= from._isUTC
;
464 if (typeof from._offset
!== 'undefined') {
465 to
._offset
= from._offset
;
467 if (typeof from._pf
!== 'undefined') {
470 if (typeof from._locale
!== 'undefined') {
471 to
._locale
= from._locale
;
474 if (momentProperties
.length
> 0) {
475 for (i
in momentProperties
) {
476 prop
= momentProperties
[i
];
478 if (typeof val
!== 'undefined') {
487 function absRound(number
) {
489 return Math
.ceil(number
);
491 return Math
.floor(number
);
495 // left zero fill a number
496 // see http://jsperf.com/left-zero-filling for performance comparison
497 function leftZeroFill(number
, targetLength
, forceSign
) {
498 var output
= '' + Math
.abs(number
),
501 while (output
.length
< targetLength
) {
502 output
= '0' + output
;
504 return (sign
? (forceSign
? '+' : '') : '-') + output
;
507 function positiveMomentsDifference(base
, other
) {
508 var res
= {milliseconds
: 0, months
: 0};
510 res
.months
= other
.month() - base
.month() +
511 (other
.year() - base
.year()) * 12;
512 if (base
.clone().add(res
.months
, 'M').isAfter(other
)) {
516 res
.milliseconds
= +other
- +(base
.clone().add(res
.months
, 'M'));
521 function momentsDifference(base
, other
) {
523 other
= makeAs(other
, base
);
524 if (base
.isBefore(other
)) {
525 res
= positiveMomentsDifference(base
, other
);
527 res
= positiveMomentsDifference(other
, base
);
528 res
.milliseconds
= -res
.milliseconds
;
529 res
.months
= -res
.months
;
535 // TODO: remove 'name' arg after deprecation is removed
536 function createAdder(direction
, name
) {
537 return function (val
, period
) {
539 //invert the arguments, but complain about it
540 if (period
!== null && !isNaN(+period
)) {
541 deprecateSimple(name
, 'moment().' + name
+ '(period, number) is deprecated. Please use moment().' + name
+ '(number, period).');
542 tmp
= val
; val
= period
; period
= tmp
;
545 val
= typeof val
=== 'string' ? +val
: val
;
546 dur
= moment
.duration(val
, period
);
547 addOrSubtractDurationFromMoment(this, dur
, direction
);
552 function addOrSubtractDurationFromMoment(mom
, duration
, isAdding
, updateOffset
) {
553 var milliseconds
= duration
._milliseconds
,
554 days
= duration
._days
,
555 months
= duration
._months
;
556 updateOffset
= updateOffset
== null ? true : updateOffset
;
559 mom
._d
.setTime(+mom
._d
+ milliseconds
* isAdding
);
562 rawSetter(mom
, 'Date', rawGetter(mom
, 'Date') + days
* isAdding
);
565 rawMonthSetter(mom
, rawGetter(mom
, 'Month') + months
* isAdding
);
568 moment
.updateOffset(mom
, days
|| months
);
572 // check if is an array
573 function isArray(input
) {
574 return Object
.prototype.toString
.call(input
) === '[object Array]';
577 function isDate(input
) {
578 return Object
.prototype.toString
.call(input
) === '[object Date]' ||
579 input
instanceof Date
;
582 // compare two arrays, return the number of differences
583 function compareArrays(array1
, array2
, dontConvert
) {
584 var len
= Math
.min(array1
.length
, array2
.length
),
585 lengthDiff
= Math
.abs(array1
.length
- array2
.length
),
588 for (i
= 0; i
< len
; i
++) {
589 if ((dontConvert
&& array1
[i
] !== array2
[i
]) ||
590 (!dontConvert
&& toInt(array1
[i
]) !== toInt(array2
[i
]))) {
594 return diffs
+ lengthDiff
;
597 function normalizeUnits(units
) {
599 var lowered
= units
.toLowerCase().replace(/(.)s$/, '$1');
600 units
= unitAliases
[units
] || camelFunctions
[lowered
] || lowered
;
605 function normalizeObjectUnits(inputObject
) {
606 var normalizedInput
= {},
610 for (prop
in inputObject
) {
611 if (hasOwnProp(inputObject
, prop
)) {
612 normalizedProp
= normalizeUnits(prop
);
613 if (normalizedProp
) {
614 normalizedInput
[normalizedProp
] = inputObject
[prop
];
619 return normalizedInput
;
622 function makeList(field
) {
625 if (field
.indexOf('week') === 0) {
629 else if (field
.indexOf('month') === 0) {
637 moment
[field
] = function (format
, index
) {
639 method
= moment
._locale
[field
],
642 if (typeof format
=== 'number') {
647 getter = function (i
) {
648 var m
= moment().utc().set(setter
, i
);
649 return method
.call(moment
._locale
, m
, format
|| '');
653 return getter(index
);
656 for (i
= 0; i
< count
; i
++) {
657 results
.push(getter(i
));
664 function toInt(argumentForCoercion
) {
665 var coercedNumber
= +argumentForCoercion
,
668 if (coercedNumber
!== 0 && isFinite(coercedNumber
)) {
669 if (coercedNumber
>= 0) {
670 value
= Math
.floor(coercedNumber
);
672 value
= Math
.ceil(coercedNumber
);
679 function daysInMonth(year
, month
) {
680 return new Date(Date
.UTC(year
, month
+ 1, 0)).getUTCDate();
683 function weeksInYear(year
, dow
, doy
) {
684 return weekOfYear(moment([year
, 11, 31 + dow
- doy
]), dow
, doy
).week
;
687 function daysInYear(year
) {
688 return isLeapYear(year
) ? 366 : 365;
691 function isLeapYear(year
) {
692 return (year
% 4 === 0 && year
% 100 !== 0) || year
% 400 === 0;
695 function checkOverflow(m
) {
697 if (m
._a
&& m
._pf
.overflow
=== -2) {
699 m
._a
[MONTH
] < 0 || m
._a
[MONTH
] > 11 ? MONTH
:
700 m
._a
[DATE
] < 1 || m
._a
[DATE
] > daysInMonth(m
._a
[YEAR
], m
._a
[MONTH
]) ? DATE
:
701 m
._a
[HOUR
] < 0 || m
._a
[HOUR
] > 23 ? HOUR
:
702 m
._a
[MINUTE
] < 0 || m
._a
[MINUTE
] > 59 ? MINUTE
:
703 m
._a
[SECOND
] < 0 || m
._a
[SECOND
] > 59 ? SECOND
:
704 m
._a
[MILLISECOND
] < 0 || m
._a
[MILLISECOND
] > 999 ? MILLISECOND
:
707 if (m
._pf
._overflowDayOfYear
&& (overflow
< YEAR
|| overflow
> DATE
)) {
711 m
._pf
.overflow
= overflow
;
715 function isValid(m
) {
716 if (m
._isValid
== null) {
717 m
._isValid
= !isNaN(m
._d
.getTime()) &&
718 m
._pf
.overflow
< 0 &&
720 !m
._pf
.invalidMonth
&&
722 !m
._pf
.invalidFormat
&&
723 !m
._pf
.userInvalidated
;
726 m
._isValid
= m
._isValid
&&
727 m
._pf
.charsLeftOver
=== 0 &&
728 m
._pf
.unusedTokens
.length
=== 0;
734 function normalizeLocale(key
) {
735 return key
? key
.toLowerCase().replace('_', '-') : key
;
738 // pick the locale from the array
739 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
740 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
741 function chooseLocale(names
) {
742 var i
= 0, j
, next
, locale
, split
;
744 while (i
< names
.length
) {
745 split
= normalizeLocale(names
[i
]).split('-');
747 next
= normalizeLocale(names
[i
+ 1]);
748 next
= next
? next
.split('-') : null;
750 locale
= loadLocale(split
.slice(0, j
).join('-'));
754 if (next
&& next
.length
>= j
&& compareArrays(split
, next
, true) >= j
- 1) {
755 //the next array item is better than a shallower substring of this one
765 function loadLocale(name
) {
766 var oldLocale
= null;
767 if (!locales
[name
] && hasModule
) {
769 oldLocale
= moment
.locale();
770 require('./locale/' + name
);
771 // because defineLocale currently also sets the global locale, we want to undo that for lazy loaded locales
772 moment
.locale(oldLocale
);
775 return locales
[name
];
778 // Return a moment from input, that is local/utc/zone equivalent to model.
779 function makeAs(input
, model
) {
780 return model
._isUTC
? moment(input
).zone(model
._offset
|| 0) :
781 moment(input
).local();
784 /************************************
786 ************************************/
789 extend(Locale
.prototype, {
791 set : function (config
) {
795 if (typeof prop
=== 'function') {
798 this['_' + i
] = prop
;
803 _months
: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
804 months : function (m
) {
805 return this._months
[m
.month()];
808 _monthsShort
: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
809 monthsShort : function (m
) {
810 return this._monthsShort
[m
.month()];
813 monthsParse : function (monthName
) {
816 if (!this._monthsParse
) {
817 this._monthsParse
= [];
820 for (i
= 0; i
< 12; i
++) {
821 // make the regex if we don't have it already
822 if (!this._monthsParse
[i
]) {
823 mom
= moment
.utc([2000, i
]);
824 regex
= '^' + this.months(mom
, '') + '|^' + this.monthsShort(mom
, '');
825 this._monthsParse
[i
] = new RegExp(regex
.replace('.', ''), 'i');
828 if (this._monthsParse
[i
].test(monthName
)) {
834 _weekdays
: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
835 weekdays : function (m
) {
836 return this._weekdays
[m
.day()];
839 _weekdaysShort
: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
840 weekdaysShort : function (m
) {
841 return this._weekdaysShort
[m
.day()];
844 _weekdaysMin
: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
845 weekdaysMin : function (m
) {
846 return this._weekdaysMin
[m
.day()];
849 weekdaysParse : function (weekdayName
) {
852 if (!this._weekdaysParse
) {
853 this._weekdaysParse
= [];
856 for (i
= 0; i
< 7; i
++) {
857 // make the regex if we don't have it already
858 if (!this._weekdaysParse
[i
]) {
859 mom
= moment([2000, 1]).day(i
);
860 regex
= '^' + this.weekdays(mom
, '') + '|^' + this.weekdaysShort(mom
, '') + '|^' + this.weekdaysMin(mom
, '');
861 this._weekdaysParse
[i
] = new RegExp(regex
.replace('.', ''), 'i');
864 if (this._weekdaysParse
[i
].test(weekdayName
)) {
874 LLL
: 'MMMM D, YYYY LT',
875 LLLL
: 'dddd, MMMM D, YYYY LT'
877 longDateFormat : function (key
) {
878 var output
= this._longDateFormat
[key
];
879 if (!output
&& this._longDateFormat
[key
.toUpperCase()]) {
880 output
= this._longDateFormat
[key
.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val
) {
883 this._longDateFormat
[key
] = output
;
888 isPM : function (input
) {
889 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
890 // Using charAt should be more compatible.
891 return ((input
+ '').toLowerCase().charAt(0) === 'p');
894 _meridiemParse
: /[ap]\.?m?\.?/i,
895 meridiem : function (hours
, minutes
, isLower
) {
897 return isLower
? 'pm' : 'PM';
899 return isLower
? 'am' : 'AM';
904 sameDay
: '[Today at] LT',
905 nextDay
: '[Tomorrow at] LT',
906 nextWeek
: 'dddd [at] LT',
907 lastDay
: '[Yesterday at] LT',
908 lastWeek
: '[Last] dddd [at] LT',
911 calendar : function (key
, mom
) {
912 var output
= this._calendar
[key
];
913 return typeof output
=== 'function' ? output
.apply(mom
) : output
;
932 relativeTime : function (number
, withoutSuffix
, string
, isFuture
) {
933 var output
= this._relativeTime
[string
];
934 return (typeof output
=== 'function') ?
935 output(number
, withoutSuffix
, string
, isFuture
) :
936 output
.replace(/%d/i, number
);
939 pastFuture : function (diff
, output
) {
940 var format
= this._relativeTime
[diff
> 0 ? 'future' : 'past'];
941 return typeof format
=== 'function' ? format(output
) : format
.replace(/%s/i, output
);
944 ordinal : function (number
) {
945 return this._ordinal
.replace('%d', number
);
949 preparse : function (string
) {
953 postformat : function (string
) {
957 week : function (mom
) {
958 return weekOfYear(mom
, this._week
.dow
, this._week
.doy
).week
;
962 dow
: 0, // Sunday is the first day of the week.
963 doy
: 6 // The week that contains Jan 1st is the first week of the year.
966 _invalidDate
: 'Invalid date',
967 invalidDate: function () {
968 return this._invalidDate
;
972 /************************************
974 ************************************/
977 function removeFormattingTokens(input
) {
978 if (input
.match(/\[[\s\S]/)) {
979 return input
.replace(/^\[|\]$/g, '');
981 return input
.replace(/\\/g
, '');
984 function makeFormatFunction(format
) {
985 var array
= format
.match(formattingTokens
), i
, length
;
987 for (i
= 0, length
= array
.length
; i
< length
; i
++) {
988 if (formatTokenFunctions
[array
[i
]]) {
989 array
[i
] = formatTokenFunctions
[array
[i
]];
991 array
[i
] = removeFormattingTokens(array
[i
]);
995 return function (mom
) {
997 for (i
= 0; i
< length
; i
++) {
998 output
+= array
[i
] instanceof Function
? array
[i
].call(mom
, format
) : array
[i
];
1004 // format date using native date object
1005 function formatMoment(m
, format
) {
1007 return m
.localeData().invalidDate();
1010 format
= expandFormat(format
, m
.localeData());
1012 if (!formatFunctions
[format
]) {
1013 formatFunctions
[format
] = makeFormatFunction(format
);
1016 return formatFunctions
[format
](m
);
1019 function expandFormat(format
, locale
) {
1022 function replaceLongDateFormatTokens(input
) {
1023 return locale
.longDateFormat(input
) || input
;
1026 localFormattingTokens
.lastIndex
= 0;
1027 while (i
>= 0 && localFormattingTokens
.test(format
)) {
1028 format
= format
.replace(localFormattingTokens
, replaceLongDateFormatTokens
);
1029 localFormattingTokens
.lastIndex
= 0;
1037 /************************************
1039 ************************************/
1042 // get the regex to find the next token
1043 function getParseRegexForToken(token
, config
) {
1044 var a
, strict
= config
._strict
;
1047 return parseTokenOneDigit
;
1049 return parseTokenThreeDigits
;
1053 return strict
? parseTokenFourDigits
: parseTokenOneToFourDigits
;
1057 return parseTokenSignedNumber
;
1062 return strict
? parseTokenSixDigits
: parseTokenOneToSixDigits
;
1065 return parseTokenOneDigit
;
1070 return parseTokenTwoDigits
;
1075 return parseTokenThreeDigits
;
1079 return parseTokenOneToThreeDigits
;
1085 return parseTokenWord
;
1088 return config
._locale
._meridiemParse
;
1090 return parseTokenTimestampMs
;
1093 return parseTokenTimezone
;
1097 return parseTokenDigits
;
1109 return strict
? parseTokenTwoDigits
: parseTokenOneOrTwoDigits
;
1121 return parseTokenOneOrTwoDigits
;
1123 return parseTokenOrdinal
;
1125 a
= new RegExp(regexpEscape(unescapeFormat(token
.replace('\\', '')), 'i'));
1130 function timezoneMinutesFromString(string
) {
1131 string
= string
|| '';
1132 var possibleTzMatches
= (string
.match(parseTokenTimezone
) || []),
1133 tzChunk
= possibleTzMatches
[possibleTzMatches
.length
- 1] || [],
1134 parts
= (tzChunk
+ '').match(parseTimezoneChunker
) || ['-', 0, 0],
1135 minutes
= +(parts
[1] * 60) + toInt(parts
[2]);
1137 return parts
[0] === '+' ? -minutes
: minutes
;
1140 // function to convert string input to date
1141 function addTimeToArrayFromToken(token
, input
, config
) {
1142 var a
, datePartArray
= config
._a
;
1147 if (input
!= null) {
1148 datePartArray
[MONTH
] = (toInt(input
) - 1) * 3;
1152 case 'M' : // fall through to MM
1154 if (input
!= null) {
1155 datePartArray
[MONTH
] = toInt(input
) - 1;
1158 case 'MMM' : // fall through to MMMM
1160 a
= config
._locale
.monthsParse(input
);
1161 // if we didn't find a month name, mark the date as invalid.
1163 datePartArray
[MONTH
] = a
;
1165 config
._pf
.invalidMonth
= input
;
1169 case 'D' : // fall through to DD
1171 if (input
!= null) {
1172 datePartArray
[DATE
] = toInt(input
);
1176 if (input
!= null) {
1177 datePartArray
[DATE
] = toInt(parseInt(input
, 10));
1181 case 'DDD' : // fall through to DDDD
1183 if (input
!= null) {
1184 config
._dayOfYear
= toInt(input
);
1190 datePartArray
[YEAR
] = moment
.parseTwoDigitYear(input
);
1195 datePartArray
[YEAR
] = toInt(input
);
1198 case 'a' : // fall through to A
1200 config
._isPm
= config
._locale
.isPM(input
);
1203 case 'H' : // fall through to hh
1204 case 'HH' : // fall through to hh
1205 case 'h' : // fall through to hh
1207 datePartArray
[HOUR
] = toInt(input
);
1210 case 'm' : // fall through to mm
1212 datePartArray
[MINUTE
] = toInt(input
);
1215 case 's' : // fall through to ss
1217 datePartArray
[SECOND
] = toInt(input
);
1224 datePartArray
[MILLISECOND
] = toInt(('0.' + input
) * 1000);
1226 // UNIX TIMESTAMP WITH MS
1228 config
._d
= new Date(parseFloat(input
) * 1000);
1231 case 'Z' : // fall through to ZZ
1233 config
._useUTC
= true;
1234 config
._tzm
= timezoneMinutesFromString(input
);
1240 a
= config
._locale
.weekdaysParse(input
);
1241 // if we didn't get a weekday name, mark the date as invalid
1243 config
._w
= config
._w
|| {};
1246 config
._pf
.invalidWeekday
= input
;
1249 // WEEK, WEEK DAY - numeric
1257 token
= token
.substr(0, 1);
1262 token
= token
.substr(0, 2);
1264 config
._w
= config
._w
|| {};
1265 config
._w
[token
] = toInt(input
);
1270 config
._w
= config
._w
|| {};
1271 config
._w
[token
] = moment
.parseTwoDigitYear(input
);
1275 function dayOfYearFromWeekInfo(config
) {
1276 var w
, weekYear
, week
, weekday
, dow
, doy
, temp
;
1279 if (w
.GG
!= null || w
.W
!= null || w
.E
!= null) {
1283 // TODO: We need to take the current isoWeekYear, but that depends on
1284 // how we interpret now (local, utc, fixed offset). So create
1285 // a now version of current config (take local/utc/offset flags, and
1287 weekYear
= dfl(w
.GG
, config
._a
[YEAR
], weekOfYear(moment(), 1, 4).year
);
1289 weekday
= dfl(w
.E
, 1);
1291 dow
= config
._locale
._week
.dow
;
1292 doy
= config
._locale
._week
.doy
;
1294 weekYear
= dfl(w
.gg
, config
._a
[YEAR
], weekOfYear(moment(), dow
, doy
).year
);
1298 // weekday -- low day numbers are considered next week
1300 if (weekday
< dow
) {
1303 } else if (w
.e
!= null) {
1304 // local weekday -- counting starts from begining of week
1305 weekday
= w
.e
+ dow
;
1307 // default to begining of week
1311 temp
= dayOfYearFromWeeks(weekYear
, week
, weekday
, doy
, dow
);
1313 config
._a
[YEAR
] = temp
.year
;
1314 config
._dayOfYear
= temp
.dayOfYear
;
1317 // convert an array to a date.
1318 // the array should mirror the parameters below
1319 // note: all values past the year are optional and will default to the lowest possible value.
1320 // [year, month, day , hour, minute, second, millisecond]
1321 function dateFromConfig(config
) {
1322 var i
, date
, input
= [], currentDate
, yearToUse
;
1328 currentDate
= currentDateArray(config
);
1330 //compute day of the year from weeks and weekdays
1331 if (config
._w
&& config
._a
[DATE
] == null && config
._a
[MONTH
] == null) {
1332 dayOfYearFromWeekInfo(config
);
1335 //if the day of the year is set, figure out what it is
1336 if (config
._dayOfYear
) {
1337 yearToUse
= dfl(config
._a
[YEAR
], currentDate
[YEAR
]);
1339 if (config
._dayOfYear
> daysInYear(yearToUse
)) {
1340 config
._pf
._overflowDayOfYear
= true;
1343 date
= makeUTCDate(yearToUse
, 0, config
._dayOfYear
);
1344 config
._a
[MONTH
] = date
.getUTCMonth();
1345 config
._a
[DATE
] = date
.getUTCDate();
1348 // Default to current date.
1349 // * if no year, month, day of month are given, default to today
1350 // * if day of month is given, default month and year
1351 // * if month is given, default only year
1352 // * if year is given, don't default anything
1353 for (i
= 0; i
< 3 && config
._a
[i
] == null; ++i
) {
1354 config
._a
[i
] = input
[i
] = currentDate
[i
];
1357 // Zero out whatever was not defaulted, including time
1358 for (; i
< 7; i
++) {
1359 config
._a
[i
] = input
[i
] = (config
._a
[i
] == null) ? (i
=== 2 ? 1 : 0) : config
._a
[i
];
1362 config
._d
= (config
._useUTC
? makeUTCDate
: makeDate
).apply(null, input
);
1363 // Apply timezone offset from input. The actual zone can be changed
1365 if (config
._tzm
!= null) {
1366 config
._d
.setUTCMinutes(config
._d
.getUTCMinutes() + config
._tzm
);
1370 function dateFromObject(config
) {
1371 var normalizedInput
;
1377 normalizedInput
= normalizeObjectUnits(config
._i
);
1379 normalizedInput
.year
,
1380 normalizedInput
.month
,
1381 normalizedInput
.day
,
1382 normalizedInput
.hour
,
1383 normalizedInput
.minute
,
1384 normalizedInput
.second
,
1385 normalizedInput
.millisecond
1388 dateFromConfig(config
);
1391 function currentDateArray(config
) {
1392 var now
= new Date();
1393 if (config
._useUTC
) {
1395 now
.getUTCFullYear(),
1400 return [now
.getFullYear(), now
.getMonth(), now
.getDate()];
1404 // date from string and format string
1405 function makeDateFromStringAndFormat(config
) {
1406 if (config
._f
=== moment
.ISO_8601
) {
1412 config
._pf
.empty
= true;
1414 // This array is used to make a Date, either with `new Date` or `Date.UTC`
1415 var string
= '' + config
._i
,
1416 i
, parsedInput
, tokens
, token
, skipped
,
1417 stringLength
= string
.length
,
1418 totalParsedInputLength
= 0;
1420 tokens
= expandFormat(config
._f
, config
._locale
).match(formattingTokens
) || [];
1422 for (i
= 0; i
< tokens
.length
; i
++) {
1424 parsedInput
= (string
.match(getParseRegexForToken(token
, config
)) || [])[0];
1426 skipped
= string
.substr(0, string
.indexOf(parsedInput
));
1427 if (skipped
.length
> 0) {
1428 config
._pf
.unusedInput
.push(skipped
);
1430 string
= string
.slice(string
.indexOf(parsedInput
) + parsedInput
.length
);
1431 totalParsedInputLength
+= parsedInput
.length
;
1433 // don't parse if it's not a known token
1434 if (formatTokenFunctions
[token
]) {
1436 config
._pf
.empty
= false;
1439 config
._pf
.unusedTokens
.push(token
);
1441 addTimeToArrayFromToken(token
, parsedInput
, config
);
1443 else if (config
._strict
&& !parsedInput
) {
1444 config
._pf
.unusedTokens
.push(token
);
1448 // add remaining unparsed input length to the string
1449 config
._pf
.charsLeftOver
= stringLength
- totalParsedInputLength
;
1450 if (string
.length
> 0) {
1451 config
._pf
.unusedInput
.push(string
);
1455 if (config
._isPm
&& config
._a
[HOUR
] < 12) {
1456 config
._a
[HOUR
] += 12;
1458 // if is 12 am, change hours to 0
1459 if (config
._isPm
=== false && config
._a
[HOUR
] === 12) {
1460 config
._a
[HOUR
] = 0;
1463 dateFromConfig(config
);
1464 checkOverflow(config
);
1467 function unescapeFormat(s
) {
1468 return s
.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched
, p1
, p2
, p3
, p4
) {
1469 return p1
|| p2
|| p3
|| p4
;
1473 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
1474 function regexpEscape(s
) {
1475 return s
.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
1478 // date from string and array of format strings
1479 function makeDateFromStringAndArray(config
) {
1487 if (config
._f
.length
=== 0) {
1488 config
._pf
.invalidFormat
= true;
1489 config
._d
= new Date(NaN
);
1493 for (i
= 0; i
< config
._f
.length
; i
++) {
1495 tempConfig
= copyConfig({}, config
);
1496 if (config
._useUTC
!= null) {
1497 tempConfig
._useUTC
= config
._useUTC
;
1499 tempConfig
._pf
= defaultParsingFlags();
1500 tempConfig
._f
= config
._f
[i
];
1501 makeDateFromStringAndFormat(tempConfig
);
1503 if (!isValid(tempConfig
)) {
1507 // if there is any input that was not parsed add a penalty for that format
1508 currentScore
+= tempConfig
._pf
.charsLeftOver
;
1511 currentScore
+= tempConfig
._pf
.unusedTokens
.length
* 10;
1513 tempConfig
._pf
.score
= currentScore
;
1515 if (scoreToBeat
== null || currentScore
< scoreToBeat
) {
1516 scoreToBeat
= currentScore
;
1517 bestMoment
= tempConfig
;
1521 extend(config
, bestMoment
|| tempConfig
);
1524 // date from iso format
1525 function parseISO(config
) {
1528 match
= isoRegex
.exec(string
);
1531 config
._pf
.iso
= true;
1532 for (i
= 0, l
= isoDates
.length
; i
< l
; i
++) {
1533 if (isoDates
[i
][1].exec(string
)) {
1534 // match[5] should be 'T' or undefined
1535 config
._f
= isoDates
[i
][0] + (match
[6] || ' ');
1539 for (i
= 0, l
= isoTimes
.length
; i
< l
; i
++) {
1540 if (isoTimes
[i
][1].exec(string
)) {
1541 config
._f
+= isoTimes
[i
][0];
1545 if (string
.match(parseTokenTimezone
)) {
1548 makeDateFromStringAndFormat(config
);
1550 config
._isValid
= false;
1554 // date from iso format or fallback
1555 function makeDateFromString(config
) {
1557 if (config
._isValid
=== false) {
1558 delete config
._isValid
;
1559 moment
.createFromInputFallback(config
);
1563 function map(arr
, fn
) {
1565 for (i
= 0; i
< arr
.length
; ++i
) {
1566 res
.push(fn(arr
[i
], i
));
1571 function makeDateFromInput(config
) {
1572 var input
= config
._i
, matched
;
1573 if (input
=== undefined) {
1574 config
._d
= new Date();
1575 } else if (isDate(input
)) {
1576 config
._d
= new Date(+input
);
1577 } else if ((matched
= aspNetJsonRegex
.exec(input
)) !== null) {
1578 config
._d
= new Date(+matched
[1]);
1579 } else if (typeof input
=== 'string') {
1580 makeDateFromString(config
);
1581 } else if (isArray(input
)) {
1582 config
._a
= map(input
.slice(0), function (obj
) {
1583 return parseInt(obj
, 10);
1585 dateFromConfig(config
);
1586 } else if (typeof(input
) === 'object') {
1587 dateFromObject(config
);
1588 } else if (typeof(input
) === 'number') {
1589 // from milliseconds
1590 config
._d
= new Date(input
);
1592 moment
.createFromInputFallback(config
);
1596 function makeDate(y
, m
, d
, h
, M
, s
, ms
) {
1597 //can't just apply() to create a date:
1598 //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
1599 var date
= new Date(y
, m
, d
, h
, M
, s
, ms
);
1601 //the date constructor doesn't accept years < 1970
1603 date
.setFullYear(y
);
1608 function makeUTCDate(y
) {
1609 var date
= new Date(Date
.UTC
.apply(null, arguments
));
1611 date
.setUTCFullYear(y
);
1616 function parseWeekday(input
, locale
) {
1617 if (typeof input
=== 'string') {
1618 if (!isNaN(input
)) {
1619 input
= parseInt(input
, 10);
1622 input
= locale
.weekdaysParse(input
);
1623 if (typeof input
!== 'number') {
1631 /************************************
1633 ************************************/
1636 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
1637 function substituteTimeAgo(string
, number
, withoutSuffix
, isFuture
, locale
) {
1638 return locale
.relativeTime(number
|| 1, !!withoutSuffix
, string
, isFuture
);
1641 function relativeTime(posNegDuration
, withoutSuffix
, locale
) {
1642 var duration
= moment
.duration(posNegDuration
).abs(),
1643 seconds
= round(duration
.as('s')),
1644 minutes
= round(duration
.as('m')),
1645 hours
= round(duration
.as('h')),
1646 days
= round(duration
.as('d')),
1647 months
= round(duration
.as('M')),
1648 years
= round(duration
.as('y')),
1650 args
= seconds
< relativeTimeThresholds
.s
&& ['s', seconds
] ||
1651 minutes
=== 1 && ['m'] ||
1652 minutes
< relativeTimeThresholds
.m
&& ['mm', minutes
] ||
1653 hours
=== 1 && ['h'] ||
1654 hours
< relativeTimeThresholds
.h
&& ['hh', hours
] ||
1655 days
=== 1 && ['d'] ||
1656 days
< relativeTimeThresholds
.d
&& ['dd', days
] ||
1657 months
=== 1 && ['M'] ||
1658 months
< relativeTimeThresholds
.M
&& ['MM', months
] ||
1659 years
=== 1 && ['y'] || ['yy', years
];
1661 args
[2] = withoutSuffix
;
1662 args
[3] = +posNegDuration
> 0;
1664 return substituteTimeAgo
.apply({}, args
);
1668 /************************************
1670 ************************************/
1673 // firstDayOfWeek 0 = sun, 6 = sat
1674 // the day of the week that starts the week
1675 // (usually sunday or monday)
1676 // firstDayOfWeekOfYear 0 = sun, 6 = sat
1677 // the first week is the week that contains the first
1678 // of this day of the week
1679 // (eg. ISO weeks use thursday (4))
1680 function weekOfYear(mom
, firstDayOfWeek
, firstDayOfWeekOfYear
) {
1681 var end
= firstDayOfWeekOfYear
- firstDayOfWeek
,
1682 daysToDayOfWeek
= firstDayOfWeekOfYear
- mom
.day(),
1686 if (daysToDayOfWeek
> end
) {
1687 daysToDayOfWeek
-= 7;
1690 if (daysToDayOfWeek
< end
- 7) {
1691 daysToDayOfWeek
+= 7;
1694 adjustedMoment
= moment(mom
).add(daysToDayOfWeek
, 'd');
1696 week
: Math
.ceil(adjustedMoment
.dayOfYear() / 7),
1697 year
: adjustedMoment
.year()
1701 //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1702 function dayOfYearFromWeeks(year
, week
, weekday
, firstDayOfWeekOfYear
, firstDayOfWeek
) {
1703 var d
= makeUTCDate(year
, 0, 1).getUTCDay(), daysToAdd
, dayOfYear
;
1705 d
= d
=== 0 ? 7 : d
;
1706 weekday
= weekday
!= null ? weekday
: firstDayOfWeek
;
1707 daysToAdd
= firstDayOfWeek
- d
+ (d
> firstDayOfWeekOfYear
? 7 : 0) - (d
< firstDayOfWeek
? 7 : 0);
1708 dayOfYear
= 7 * (week
- 1) + (weekday
- firstDayOfWeek
) + daysToAdd
+ 1;
1711 year
: dayOfYear
> 0 ? year
: year
- 1,
1712 dayOfYear
: dayOfYear
> 0 ? dayOfYear
: daysInYear(year
- 1) + dayOfYear
1716 /************************************
1718 ************************************/
1720 function makeMoment(config
) {
1721 var input
= config
._i
,
1724 config
._locale
= config
._locale
|| moment
.localeData(config
._l
);
1726 if (input
=== null || (format
=== undefined && input
=== '')) {
1727 return moment
.invalid({nullInput
: true});
1730 if (typeof input
=== 'string') {
1731 config
._i
= input
= config
._locale
.preparse(input
);
1734 if (moment
.isMoment(input
)) {
1735 return new Moment(input
, true);
1736 } else if (format
) {
1737 if (isArray(format
)) {
1738 makeDateFromStringAndArray(config
);
1740 makeDateFromStringAndFormat(config
);
1743 makeDateFromInput(config
);
1746 return new Moment(config
);
1749 moment = function (input
, format
, locale
, strict
) {
1752 if (typeof(locale
) === 'boolean') {
1756 // object construction must be done this way.
1757 // https://github.com/moment/moment/issues/1423
1759 c
._isAMomentObject
= true;
1765 c
._pf
= defaultParsingFlags();
1767 return makeMoment(c
);
1770 moment
.suppressDeprecationWarnings
= false;
1772 moment
.createFromInputFallback
= deprecate(
1773 'moment construction falls back to js Date. This is ' +
1774 'discouraged and will be removed in upcoming major ' +
1775 'release. Please refer to ' +
1776 'https://github.com/moment/moment/issues/1407 for more info.',
1778 config
._d
= new Date(config
._i
);
1782 // Pick a moment m from moments so that m[fn](other) is true for all
1783 // other. This relies on the function fn to be transitive.
1785 // moments should either be an array of moment objects or an array, whose
1786 // first element is an array of moment objects.
1787 function pickBy(fn
, moments
) {
1789 if (moments
.length
=== 1 && isArray(moments
[0])) {
1790 moments
= moments
[0];
1792 if (!moments
.length
) {
1796 for (i
= 1; i
< moments
.length
; ++i
) {
1797 if (moments
[i
][fn
](res
)) {
1804 moment
.min = function () {
1805 var args
= [].slice
.call(arguments
, 0);
1807 return pickBy('isBefore', args
);
1810 moment
.max = function () {
1811 var args
= [].slice
.call(arguments
, 0);
1813 return pickBy('isAfter', args
);
1816 // creating with utc
1817 moment
.utc = function (input
, format
, locale
, strict
) {
1820 if (typeof(locale
) === 'boolean') {
1824 // object construction must be done this way.
1825 // https://github.com/moment/moment/issues/1423
1827 c
._isAMomentObject
= true;
1834 c
._pf
= defaultParsingFlags();
1836 return makeMoment(c
).utc();
1839 // creating with unix timestamp (in seconds)
1840 moment
.unix = function (input
) {
1841 return moment(input
* 1000);
1845 moment
.duration = function (input
, key
) {
1846 var duration
= input
,
1847 // matching against regexp is expensive, do it on demand
1854 if (moment
.isDuration(input
)) {
1856 ms
: input
._milliseconds
,
1860 } else if (typeof input
=== 'number') {
1863 duration
[key
] = input
;
1865 duration
.milliseconds
= input
;
1867 } else if (!!(match
= aspNetTimeSpanJsonRegex
.exec(input
))) {
1868 sign
= (match
[1] === '-') ? -1 : 1;
1871 d
: toInt(match
[DATE
]) * sign
,
1872 h
: toInt(match
[HOUR
]) * sign
,
1873 m
: toInt(match
[MINUTE
]) * sign
,
1874 s
: toInt(match
[SECOND
]) * sign
,
1875 ms
: toInt(match
[MILLISECOND
]) * sign
1877 } else if (!!(match
= isoDurationRegex
.exec(input
))) {
1878 sign
= (match
[1] === '-') ? -1 : 1;
1879 parseIso = function (inp
) {
1880 // We'd normally use ~~inp for this, but unfortunately it also
1881 // converts floats to ints.
1882 // inp may be undefined, so careful calling replace on it.
1883 var res
= inp
&& parseFloat(inp
.replace(',', '.'));
1884 // apply sign while we're at it
1885 return (isNaN(res
) ? 0 : res
) * sign
;
1888 y
: parseIso(match
[2]),
1889 M
: parseIso(match
[3]),
1890 d
: parseIso(match
[4]),
1891 h
: parseIso(match
[5]),
1892 m
: parseIso(match
[6]),
1893 s
: parseIso(match
[7]),
1894 w
: parseIso(match
[8])
1896 } else if (typeof duration
=== 'object' &&
1897 ('from' in duration
|| 'to' in duration
)) {
1898 diffRes
= momentsDifference(moment(duration
.from), moment(duration
.to
));
1901 duration
.ms
= diffRes
.milliseconds
;
1902 duration
.M
= diffRes
.months
;
1905 ret
= new Duration(duration
);
1907 if (moment
.isDuration(input
) && hasOwnProp(input
, '_locale')) {
1908 ret
._locale
= input
._locale
;
1915 moment
.version
= VERSION
;
1918 moment
.defaultFormat
= isoFormat
;
1920 // constant that refers to the ISO standard
1921 moment
.ISO_8601 = function () {};
1923 // Plugins that add properties should also add the key here (null value),
1924 // so we can properly clone ourselves.
1925 moment
.momentProperties
= momentProperties
;
1927 // This function will be called whenever a moment is mutated.
1928 // It is intended to keep the offset in sync with the timezone.
1929 moment
.updateOffset = function () {};
1931 // This function allows you to set a threshold for relative time strings
1932 moment
.relativeTimeThreshold = function (threshold
, limit
) {
1933 if (relativeTimeThresholds
[threshold
] === undefined) {
1936 if (limit
=== undefined) {
1937 return relativeTimeThresholds
[threshold
];
1939 relativeTimeThresholds
[threshold
] = limit
;
1943 moment
.lang
= deprecate(
1944 'moment.lang is deprecated. Use moment.locale instead.',
1945 function (key
, value
) {
1946 return moment
.locale(key
, value
);
1950 // This function will load locale and then set the global locale. If
1951 // no arguments are passed in, it will simply return the current global
1953 moment
.locale = function (key
, values
) {
1956 if (typeof(values
) !== 'undefined') {
1957 data
= moment
.defineLocale(key
, values
);
1960 data
= moment
.localeData(key
);
1964 moment
.duration
._locale
= moment
._locale
= data
;
1968 return moment
._locale
._abbr
;
1971 moment
.defineLocale = function (name
, values
) {
1972 if (values
!== null) {
1974 if (!locales
[name
]) {
1975 locales
[name
] = new Locale();
1977 locales
[name
].set(values
);
1979 // backwards compat for now: also set the locale
1980 moment
.locale(name
);
1982 return locales
[name
];
1984 // useful for testing
1985 delete locales
[name
];
1990 moment
.langData
= deprecate(
1991 'moment.langData is deprecated. Use moment.localeData instead.',
1993 return moment
.localeData(key
);
1997 // returns locale data
1998 moment
.localeData = function (key
) {
2001 if (key
&& key
._locale
&& key
._locale
._abbr
) {
2002 key
= key
._locale
._abbr
;
2006 return moment
._locale
;
2009 if (!isArray(key
)) {
2010 //short-circuit everything else
2011 locale
= loadLocale(key
);
2018 return chooseLocale(key
);
2021 // compare moment object
2022 moment
.isMoment = function (obj
) {
2023 return obj
instanceof Moment
||
2024 (obj
!= null && hasOwnProp(obj
, '_isAMomentObject'));
2027 // for typechecking Duration objects
2028 moment
.isDuration = function (obj
) {
2029 return obj
instanceof Duration
;
2032 for (i
= lists
.length
- 1; i
>= 0; --i
) {
2036 moment
.normalizeUnits = function (units
) {
2037 return normalizeUnits(units
);
2040 moment
.invalid = function (flags
) {
2041 var m
= moment
.utc(NaN
);
2042 if (flags
!= null) {
2043 extend(m
._pf
, flags
);
2046 m
._pf
.userInvalidated
= true;
2052 moment
.parseZone = function () {
2053 return moment
.apply(null, arguments
).parseZone();
2056 moment
.parseTwoDigitYear = function (input
) {
2057 return toInt(input
) + (toInt(input
) > 68 ? 1900 : 2000);
2060 /************************************
2062 ************************************/
2065 extend(moment
.fn
= Moment
.prototype, {
2067 clone : function () {
2068 return moment(this);
2071 valueOf : function () {
2072 return +this._d
+ ((this._offset
|| 0) * 60000);
2075 unix : function () {
2076 return Math
.floor(+this / 1000);
2079 toString : function () {
2080 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
2083 toDate : function () {
2084 return this._offset
? new Date(+this) : this._d
;
2087 toISOString : function () {
2088 var m
= moment(this).utc();
2089 if (0 < m
.year() && m
.year() <= 9999) {
2090 return formatMoment(m
, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
2092 return formatMoment(m
, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
2096 toArray : function () {
2109 isValid : function () {
2110 return isValid(this);
2113 isDSTShifted : function () {
2115 return this.isValid() && compareArrays(this._a
, (this._isUTC
? moment
.utc(this._a
) : moment(this._a
)).toArray()) > 0;
2121 parsingFlags : function () {
2122 return extend({}, this._pf
);
2125 invalidAt: function () {
2126 return this._pf
.overflow
;
2129 utc : function (keepLocalTime
) {
2130 return this.zone(0, keepLocalTime
);
2133 local : function (keepLocalTime
) {
2135 this.zone(0, keepLocalTime
);
2136 this._isUTC
= false;
2138 if (keepLocalTime
) {
2139 this.add(this._dateTzOffset(), 'm');
2145 format : function (inputString
) {
2146 var output
= formatMoment(this, inputString
|| moment
.defaultFormat
);
2147 return this.localeData().postformat(output
);
2150 add
: createAdder(1, 'add'),
2152 subtract
: createAdder(-1, 'subtract'),
2154 diff : function (input
, units
, asFloat
) {
2155 var that
= makeAs(input
, this),
2156 zoneDiff
= (this.zone() - that
.zone()) * 6e4
,
2157 diff
, output
, daysAdjust
;
2159 units
= normalizeUnits(units
);
2161 if (units
=== 'year' || units
=== 'month') {
2162 // average number of days in the months in the given dates
2163 diff
= (this.daysInMonth() + that
.daysInMonth()) * 432e5
; // 24 * 60 * 60 * 1000 / 2
2164 // difference in months
2165 output
= ((this.year() - that
.year()) * 12) + (this.month() - that
.month());
2166 // adjust by taking difference in days, average number of days
2167 // and dst in the given months.
2168 daysAdjust
= (this - moment(this).startOf('month')) -
2169 (that
- moment(that
).startOf('month'));
2170 // same as above but with zones, to negate all dst
2171 daysAdjust
-= ((this.zone() - moment(this).startOf('month').zone()) -
2172 (that
.zone() - moment(that
).startOf('month').zone())) * 6e4
;
2173 output
+= daysAdjust
/ diff
;
2174 if (units
=== 'year') {
2175 output
= output
/ 12;
2178 diff
= (this - that
);
2179 output
= units
=== 'second' ? diff
/ 1e3
: // 1000
2180 units
=== 'minute' ? diff
/ 6e4
: // 1000 * 60
2181 units
=== 'hour' ? diff
/ 36e5
: // 1000 * 60 * 60
2182 units
=== 'day' ? (diff
- zoneDiff
) / 864e5
: // 1000 * 60 * 60 * 24, negate dst
2183 units
=== 'week' ? (diff
- zoneDiff
) / 6048e5
: // 1000 * 60 * 60 * 24 * 7, negate dst
2186 return asFloat
? output
: absRound(output
);
2189 from : function (time
, withoutSuffix
) {
2190 return moment
.duration({to
: this, from: time
}).locale(this.locale()).humanize(!withoutSuffix
);
2193 fromNow : function (withoutSuffix
) {
2194 return this.from(moment(), withoutSuffix
);
2197 calendar : function (time
) {
2198 // We want to compare the start of today, vs this.
2199 // Getting start-of-today depends on whether we're zone'd or not.
2200 var now
= time
|| moment(),
2201 sod
= makeAs(now
, this).startOf('day'),
2202 diff
= this.diff(sod
, 'days', true),
2203 format
= diff
< -6 ? 'sameElse' :
2204 diff
< -1 ? 'lastWeek' :
2205 diff
< 0 ? 'lastDay' :
2206 diff
< 1 ? 'sameDay' :
2207 diff
< 2 ? 'nextDay' :
2208 diff
< 7 ? 'nextWeek' : 'sameElse';
2209 return this.format(this.localeData().calendar(format
, this));
2212 isLeapYear : function () {
2213 return isLeapYear(this.year());
2216 isDST : function () {
2217 return (this.zone() < this.clone().month(0).zone() ||
2218 this.zone() < this.clone().month(5).zone());
2221 day : function (input
) {
2222 var day
= this._isUTC
? this._d
.getUTCDay() : this._d
.getDay();
2223 if (input
!= null) {
2224 input
= parseWeekday(input
, this.localeData());
2225 return this.add(input
- day
, 'd');
2231 month
: makeAccessor('Month', true),
2233 startOf : function (units
) {
2234 units
= normalizeUnits(units
);
2235 // the following switch intentionally omits break keywords
2236 // to utilize falling through the cases.
2257 this.milliseconds(0);
2261 // weeks are a special case
2262 if (units
=== 'week') {
2264 } else if (units
=== 'isoWeek') {
2268 // quarters are also special
2269 if (units
=== 'quarter') {
2270 this.month(Math
.floor(this.month() / 3) * 3);
2276 endOf: function (units
) {
2277 units
= normalizeUnits(units
);
2278 return this.startOf(units
).add(1, (units
=== 'isoWeek' ? 'week' : units
)).subtract(1, 'ms');
2281 isAfter: function (input
, units
) {
2282 units
= normalizeUnits(typeof units
!== 'undefined' ? units
: 'millisecond');
2283 if (units
=== 'millisecond') {
2284 input
= moment
.isMoment(input
) ? input
: moment(input
);
2285 return +this > +input
;
2287 return +this.clone().startOf(units
) > +moment(input
).startOf(units
);
2291 isBefore: function (input
, units
) {
2292 units
= normalizeUnits(typeof units
!== 'undefined' ? units
: 'millisecond');
2293 if (units
=== 'millisecond') {
2294 input
= moment
.isMoment(input
) ? input
: moment(input
);
2295 return +this < +input
;
2297 return +this.clone().startOf(units
) < +moment(input
).startOf(units
);
2301 isSame: function (input
, units
) {
2302 units
= normalizeUnits(units
|| 'millisecond');
2303 if (units
=== 'millisecond') {
2304 input
= moment
.isMoment(input
) ? input
: moment(input
);
2305 return +this === +input
;
2307 return +this.clone().startOf(units
) === +makeAs(input
, this).startOf(units
);
2312 'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
2314 other
= moment
.apply(null, arguments
);
2315 return other
< this ? this : other
;
2320 'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
2322 other
= moment
.apply(null, arguments
);
2323 return other
> this ? this : other
;
2327 // keepLocalTime = true means only change the timezone, without
2328 // affecting the local hour. So 5:31:26 +0300 --[zone(2, true)]-->
2329 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist int zone
2330 // +0200, so we adjust the time as needed, to be valid.
2332 // Keeping the time actually adds/subtracts (one hour)
2333 // from the actual represented time. That is why we call updateOffset
2334 // a second time. In case it wants us to change the offset again
2335 // _changeInProgress == true case, then we have to adjust, because
2336 // there is no such time in the given timezone.
2337 zone : function (input
, keepLocalTime
) {
2338 var offset
= this._offset
|| 0,
2340 if (input
!= null) {
2341 if (typeof input
=== 'string') {
2342 input
= timezoneMinutesFromString(input
);
2344 if (Math
.abs(input
) < 16) {
2347 if (!this._isUTC
&& keepLocalTime
) {
2348 localAdjust
= this._dateTzOffset();
2350 this._offset
= input
;
2352 if (localAdjust
!= null) {
2353 this.subtract(localAdjust
, 'm');
2355 if (offset
!== input
) {
2356 if (!keepLocalTime
|| this._changeInProgress
) {
2357 addOrSubtractDurationFromMoment(this,
2358 moment
.duration(offset
- input
, 'm'), 1, false);
2359 } else if (!this._changeInProgress
) {
2360 this._changeInProgress
= true;
2361 moment
.updateOffset(this, true);
2362 this._changeInProgress
= null;
2366 return this._isUTC
? offset
: this._dateTzOffset();
2371 zoneAbbr : function () {
2372 return this._isUTC
? 'UTC' : '';
2375 zoneName : function () {
2376 return this._isUTC
? 'Coordinated Universal Time' : '';
2379 parseZone : function () {
2381 this.zone(this._tzm
);
2382 } else if (typeof this._i
=== 'string') {
2388 hasAlignedHourOffset : function (input
) {
2393 input
= moment(input
).zone();
2396 return (this.zone() - input
) % 60 === 0;
2399 daysInMonth : function () {
2400 return daysInMonth(this.year(), this.month());
2403 dayOfYear : function (input
) {
2404 var dayOfYear
= round((moment(this).startOf('day') - moment(this).startOf('year')) / 864e5
) + 1;
2405 return input
== null ? dayOfYear
: this.add((input
- dayOfYear
), 'd');
2408 quarter : function (input
) {
2409 return input
== null ? Math
.ceil((this.month() + 1) / 3) : this.month((input
- 1) * 3 + this.month() % 3);
2412 weekYear : function (input
) {
2413 var year
= weekOfYear(this, this.localeData()._week
.dow
, this.localeData()._week
.doy
).year
;
2414 return input
== null ? year
: this.add((input
- year
), 'y');
2417 isoWeekYear : function (input
) {
2418 var year
= weekOfYear(this, 1, 4).year
;
2419 return input
== null ? year
: this.add((input
- year
), 'y');
2422 week : function (input
) {
2423 var week
= this.localeData().week(this);
2424 return input
== null ? week
: this.add((input
- week
) * 7, 'd');
2427 isoWeek : function (input
) {
2428 var week
= weekOfYear(this, 1, 4).week
;
2429 return input
== null ? week
: this.add((input
- week
) * 7, 'd');
2432 weekday : function (input
) {
2433 var weekday
= (this.day() + 7 - this.localeData()._week
.dow
) % 7;
2434 return input
== null ? weekday
: this.add(input
- weekday
, 'd');
2437 isoWeekday : function (input
) {
2438 // behaves the same as moment#day except
2439 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
2440 // as a setter, sunday should belong to the previous week.
2441 return input
== null ? this.day() || 7 : this.day(this.day() % 7 ? input
: input
- 7);
2444 isoWeeksInYear : function () {
2445 return weeksInYear(this.year(), 1, 4);
2448 weeksInYear : function () {
2449 var weekInfo
= this.localeData()._week
;
2450 return weeksInYear(this.year(), weekInfo
.dow
, weekInfo
.doy
);
2453 get : function (units
) {
2454 units
= normalizeUnits(units
);
2455 return this[units
]();
2458 set : function (units
, value
) {
2459 units
= normalizeUnits(units
);
2460 if (typeof this[units
] === 'function') {
2466 // If passed a locale key, it will set the locale for this
2467 // instance. Otherwise, it will return the locale configuration
2468 // variables for this instance.
2469 locale : function (key
) {
2472 if (key
=== undefined) {
2473 return this._locale
._abbr
;
2475 newLocaleData
= moment
.localeData(key
);
2476 if (newLocaleData
!= null) {
2477 this._locale
= newLocaleData
;
2484 'moment().lang() is deprecated. Use moment().localeData() instead.',
2486 if (key
=== undefined) {
2487 return this.localeData();
2489 return this.locale(key
);
2494 localeData : function () {
2495 return this._locale
;
2498 _dateTzOffset : function () {
2499 // On Firefox.24 Date#getTimezoneOffset returns a floating point.
2500 // https://github.com/moment/moment/pull/1871
2501 return Math
.round(this._d
.getTimezoneOffset() / 15) * 15;
2505 function rawMonthSetter(mom
, value
) {
2508 // TODO: Move this out of here!
2509 if (typeof value
=== 'string') {
2510 value
= mom
.localeData().monthsParse(value
);
2511 // TODO: Another silent failure?
2512 if (typeof value
!== 'number') {
2517 dayOfMonth
= Math
.min(mom
.date(),
2518 daysInMonth(mom
.year(), value
));
2519 mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + 'Month'](value
, dayOfMonth
);
2523 function rawGetter(mom
, unit
) {
2524 return mom
._d
['get' + (mom
._isUTC
? 'UTC' : '') + unit
]();
2527 function rawSetter(mom
, unit
, value
) {
2528 if (unit
=== 'Month') {
2529 return rawMonthSetter(mom
, value
);
2531 return mom
._d
['set' + (mom
._isUTC
? 'UTC' : '') + unit
](value
);
2535 function makeAccessor(unit
, keepTime
) {
2536 return function (value
) {
2537 if (value
!= null) {
2538 rawSetter(this, unit
, value
);
2539 moment
.updateOffset(this, keepTime
);
2542 return rawGetter(this, unit
);
2547 moment
.fn
.millisecond
= moment
.fn
.milliseconds
= makeAccessor('Milliseconds', false);
2548 moment
.fn
.second
= moment
.fn
.seconds
= makeAccessor('Seconds', false);
2549 moment
.fn
.minute
= moment
.fn
.minutes
= makeAccessor('Minutes', false);
2550 // Setting the hour should keep the time, because the user explicitly
2551 // specified which hour he wants. So trying to maintain the same hour (in
2552 // a new timezone) makes sense. Adding/subtracting hours does not follow
2554 moment
.fn
.hour
= moment
.fn
.hours
= makeAccessor('Hours', true);
2555 // moment.fn.month is defined separately
2556 moment
.fn
.date
= makeAccessor('Date', true);
2557 moment
.fn
.dates
= deprecate('dates accessor is deprecated. Use date instead.', makeAccessor('Date', true));
2558 moment
.fn
.year
= makeAccessor('FullYear', true);
2559 moment
.fn
.years
= deprecate('years accessor is deprecated. Use year instead.', makeAccessor('FullYear', true));
2561 // add plural methods
2562 moment
.fn
.days
= moment
.fn
.day
;
2563 moment
.fn
.months
= moment
.fn
.month
;
2564 moment
.fn
.weeks
= moment
.fn
.week
;
2565 moment
.fn
.isoWeeks
= moment
.fn
.isoWeek
;
2566 moment
.fn
.quarters
= moment
.fn
.quarter
;
2568 // add aliased format methods
2569 moment
.fn
.toJSON
= moment
.fn
.toISOString
;
2571 /************************************
2573 ************************************/
2576 function daysToYears (days
) {
2577 // 400 years have 146097 days (taking into account leap year rules)
2578 return days
* 400 / 146097;
2581 function yearsToDays (years
) {
2582 // years * 365 + absRound(years / 4) -
2583 // absRound(years / 100) + absRound(years / 400);
2584 return years
* 146097 / 400;
2587 extend(moment
.duration
.fn
= Duration
.prototype, {
2589 _bubble : function () {
2590 var milliseconds
= this._milliseconds
,
2592 months
= this._months
,
2594 seconds
, minutes
, hours
, years
= 0;
2596 // The following code bubbles up values, see the tests for
2597 // examples of what that means.
2598 data
.milliseconds
= milliseconds
% 1000;
2600 seconds
= absRound(milliseconds
/ 1000);
2601 data
.seconds
= seconds
% 60;
2603 minutes
= absRound(seconds
/ 60);
2604 data
.minutes
= minutes
% 60;
2606 hours
= absRound(minutes
/ 60);
2607 data
.hours
= hours
% 24;
2609 days
+= absRound(hours
/ 24);
2611 // Accurately convert days to years, assume start from year 0.
2612 years
= absRound(daysToYears(days
));
2613 days
-= absRound(yearsToDays(years
));
2615 // 30 days to a month
2616 // TODO (iskren): Use anchor date (like 1st Jan) to compute this.
2617 months
+= absRound(days
/ 30);
2620 // 12 months -> 1 year
2621 years
+= absRound(months
/ 12);
2625 data
.months
= months
;
2630 this._milliseconds
= Math
.abs(this._milliseconds
);
2631 this._days
= Math
.abs(this._days
);
2632 this._months
= Math
.abs(this._months
);
2634 this._data
.milliseconds
= Math
.abs(this._data
.milliseconds
);
2635 this._data
.seconds
= Math
.abs(this._data
.seconds
);
2636 this._data
.minutes
= Math
.abs(this._data
.minutes
);
2637 this._data
.hours
= Math
.abs(this._data
.hours
);
2638 this._data
.months
= Math
.abs(this._data
.months
);
2639 this._data
.years
= Math
.abs(this._data
.years
);
2644 weeks : function () {
2645 return absRound(this.days() / 7);
2648 valueOf : function () {
2649 return this._milliseconds
+
2650 this._days
* 864e5
+
2651 (this._months
% 12) * 2592e6
+
2652 toInt(this._months
/ 12) * 31536e6
;
2655 humanize : function (withSuffix
) {
2656 var output
= relativeTime(this, !withSuffix
, this.localeData());
2659 output
= this.localeData().pastFuture(+this, output
);
2662 return this.localeData().postformat(output
);
2665 add : function (input
, val
) {
2666 // supports only 2.0-style add(1, 's') or add(moment)
2667 var dur
= moment
.duration(input
, val
);
2669 this._milliseconds
+= dur
._milliseconds
;
2670 this._days
+= dur
._days
;
2671 this._months
+= dur
._months
;
2678 subtract : function (input
, val
) {
2679 var dur
= moment
.duration(input
, val
);
2681 this._milliseconds
-= dur
._milliseconds
;
2682 this._days
-= dur
._days
;
2683 this._months
-= dur
._months
;
2690 get : function (units
) {
2691 units
= normalizeUnits(units
);
2692 return this[units
.toLowerCase() + 's']();
2695 as : function (units
) {
2697 units
= normalizeUnits(units
);
2699 if (units
=== 'month' || units
=== 'year') {
2700 days
= this._days
+ this._milliseconds
/ 864e5
;
2701 months
= this._months
+ daysToYears(days
) * 12;
2702 return units
=== 'month' ? months
: months
/ 12;
2704 // handle milliseconds separately because of floating point math errors (issue #1867)
2705 days
= this._days
+ yearsToDays(this._months
/ 12);
2707 case 'week': return days
/ 7 + this._milliseconds
/ 6048e5
;
2708 case 'day': return days
+ this._milliseconds
/ 864e5
;
2709 case 'hour': return days
* 24 + this._milliseconds
/ 36e5
;
2710 case 'minute': return days
* 24 * 60 + this._milliseconds
/ 6e4
;
2711 case 'second': return days
* 24 * 60 * 60 + this._milliseconds
/ 1000;
2712 // Math.floor prevents floating point math errors here
2713 case 'millisecond': return Math
.floor(days
* 24 * 60 * 60 * 1000) + this._milliseconds
;
2714 default: throw new Error('Unknown unit ' + units
);
2719 lang
: moment
.fn
.lang
,
2720 locale
: moment
.fn
.locale
,
2722 toIsoString
: deprecate(
2723 'toIsoString() is deprecated. Please use toISOString() instead ' +
2724 '(notice the capitals)',
2726 return this.toISOString();
2730 toISOString : function () {
2731 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
2732 var years
= Math
.abs(this.years()),
2733 months
= Math
.abs(this.months()),
2734 days
= Math
.abs(this.days()),
2735 hours
= Math
.abs(this.hours()),
2736 minutes
= Math
.abs(this.minutes()),
2737 seconds
= Math
.abs(this.seconds() + this.milliseconds() / 1000);
2739 if (!this.asSeconds()) {
2740 // this is the same as C#'s (Noda) and python (isodate)...
2741 // but not other JS (goog.date)
2745 return (this.asSeconds() < 0 ? '-' : '') +
2747 (years
? years
+ 'Y' : '') +
2748 (months
? months
+ 'M' : '') +
2749 (days
? days
+ 'D' : '') +
2750 ((hours
|| minutes
|| seconds
) ? 'T' : '') +
2751 (hours
? hours
+ 'H' : '') +
2752 (minutes
? minutes
+ 'M' : '') +
2753 (seconds
? seconds
+ 'S' : '');
2756 localeData : function () {
2757 return this._locale
;
2761 moment
.duration
.fn
.toString
= moment
.duration
.fn
.toISOString
;
2763 function makeDurationGetter(name
) {
2764 moment
.duration
.fn
[name
] = function () {
2765 return this._data
[name
];
2769 for (i
in unitMillisecondFactors
) {
2770 if (hasOwnProp(unitMillisecondFactors
, i
)) {
2771 makeDurationGetter(i
.toLowerCase());
2775 moment
.duration
.fn
.asMilliseconds = function () {
2776 return this.as('ms');
2778 moment
.duration
.fn
.asSeconds = function () {
2779 return this.as('s');
2781 moment
.duration
.fn
.asMinutes = function () {
2782 return this.as('m');
2784 moment
.duration
.fn
.asHours = function () {
2785 return this.as('h');
2787 moment
.duration
.fn
.asDays = function () {
2788 return this.as('d');
2790 moment
.duration
.fn
.asWeeks = function () {
2791 return this.as('weeks');
2793 moment
.duration
.fn
.asMonths = function () {
2794 return this.as('M');
2796 moment
.duration
.fn
.asYears = function () {
2797 return this.as('y');
2800 /************************************
2802 ************************************/
2805 // Set default locale, other locale will inherit from English.
2806 moment
.locale('en', {
2807 ordinal : function (number
) {
2808 var b
= number
% 10,
2809 output
= (toInt(number
% 100 / 10) === 1) ? 'th' :
2812 (b
=== 3) ? 'rd' : 'th';
2813 return number
+ output
;
2819 /************************************
2821 ************************************/
2823 function makeGlobal(shouldDeprecate
) {
2824 /*global ender:false */
2825 if (typeof ender
!== 'undefined') {
2828 oldGlobalMoment
= globalScope
.moment
;
2829 if (shouldDeprecate
) {
2830 globalScope
.moment
= deprecate(
2831 'Accessing Moment through the global scope is ' +
2832 'deprecated, and will be removed in an upcoming ' +
2836 globalScope
.moment
= moment
;
2840 // CommonJS module is defined
2842 module
.exports
= moment
;
2843 } else if (typeof define
=== 'function' && define
.amd
) {
2844 define('moment', function (require
, exports
, module
) {
2845 if (module
.config
&& module
.config() && module
.config().noGlobal
=== true) {
2846 // release the global variable
2847 globalScope
.moment
= oldGlobalMoment
;