?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MWException: Don't send headers multiple times
[mediawiki.git] / resources / lib / moment / moment.js
blob257ee7ec1a545e1115658e445008f78f364807c3
1 //! moment.js
2 //! version : 2.6.0
3 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
4 //! license : MIT
5 //! momentjs.com
6
7 (function (undefined) {
8
9 /************************************
10 Constants
11 ************************************/
12
13 var moment,
14 VERSION = "2.6.0",
15 // the global-scope this is NOT the global object in Node.js
16 globalScope = typeof global !== 'undefined' ? global : this,
17 oldGlobalMoment,
18 round = Math.round,
19 i,
20
21 YEAR = 0,
22 MONTH = 1,
23 DATE = 2,
24 HOUR = 3,
25 MINUTE = 4,
26 SECOND = 5,
27 MILLISECOND = 6,
28
29 // internal storage for language config files
30 languages = {},
31
32 // moment internal properties
33 momentProperties = {
34 _isAMomentObject: null,
35 _i : null,
36 _f : null,
37 _l : null,
38 _strict : null,
39 _isUTC : null,
40 _offset : null, // optional. Combine with _isUTC
41 _pf : null,
42 _lang : null // optional
43 },
44
45 // check for nodeJS
46 hasModule = (typeof module !== 'undefined' && module.exports),
47
48 // ASP.NET json date format regex
49 aspNetJsonRegex = /^\/?Date\((\-?\d+)/i,
50 aspNetTimeSpanJsonRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/,
51
52 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
53 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
54 isoDurationRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/,
55
56 // format tokens
57 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,
58 localFormattingTokens = /(\[[^\[]*\])|(\\)?(LT|LL?L?L?|l{1,4})/g,
59
60 // parsing token regexes
61 parseTokenOneOrTwoDigits = /\d\d?/, // 0 - 99
62 parseTokenOneToThreeDigits = /\d{1,3}/, // 0 - 999
63 parseTokenOneToFourDigits = /\d{1,4}/, // 0 - 9999
64 parseTokenOneToSixDigits = /[+\-]?\d{1,6}/, // -999,999 - 999,999
65 parseTokenDigits = /\d+/, // nonzero number of digits
66 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.
67 parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
68 parseTokenT = /T/i, // T (ISO separator)
69 parseTokenTimestampMs = /[\+\-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
70 parseTokenOrdinal = /\d{1,2}/,
71
72 //strict parsing regexes
73 parseTokenOneDigit = /\d/, // 0 - 9
74 parseTokenTwoDigits = /\d\d/, // 00 - 99
75 parseTokenThreeDigits = /\d{3}/, // 000 - 999
76 parseTokenFourDigits = /\d{4}/, // 0000 - 9999
77 parseTokenSixDigits = /[+-]?\d{6}/, // -999,999 - 999,999
78 parseTokenSignedNumber = /[+-]?\d+/, // -inf - inf
79
80 // iso 8601 regex
81 // 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)
82 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)?)?$/,
83
84 isoFormat = 'YYYY-MM-DDTHH:mm:ssZ',
85
86 isoDates = [
87 ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
88 ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
89 ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
90 ['GGGG-[W]WW', /\d{4}-W\d{2}/],
91 ['YYYY-DDD', /\d{4}-\d{3}/]
92 ],
93
94 // iso time formats and regexes
95 isoTimes = [
96 ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
97 ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
98 ['HH:mm', /(T| )\d\d:\d\d/],
99 ['HH', /(T| )\d\d/]
100 ],
101
102 // timezone chunker "+10:00" > ["10", "00"] or "-1530" > ["-15", "30"]
103 parseTimezoneChunker = /([\+\-]|\d\d)/gi,
104
105 // getter and setter names
106 proxyGettersAndSetters = 'Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),
107 unitMillisecondFactors = {
108 'Milliseconds' : 1,
109 'Seconds' : 1e3,
110 'Minutes' : 6e4,
111 'Hours' : 36e5,
112 'Days' : 864e5,
113 'Months' : 2592e6,
114 'Years' : 31536e6
115 },
116
117 unitAliases = {
118 ms : 'millisecond',
119 s : 'second',
120 m : 'minute',
121 h : 'hour',
122 d : 'day',
123 D : 'date',
124 w : 'week',
125 W : 'isoWeek',
126 M : 'month',
127 Q : 'quarter',
128 y : 'year',
129 DDD : 'dayOfYear',
130 e : 'weekday',
131 E : 'isoWeekday',
132 gg: 'weekYear',
133 GG: 'isoWeekYear'
134 },
135
136 camelFunctions = {
137 dayofyear : 'dayOfYear',
138 isoweekday : 'isoWeekday',
139 isoweek : 'isoWeek',
140 weekyear : 'weekYear',
141 isoweekyear : 'isoWeekYear'
142 },
143
144 // format function strings
145 formatFunctions = {},
146
147 // tokens to ordinalize and pad
148 ordinalizeTokens = 'DDD w W M D d'.split(' '),
149 paddedTokens = 'M D H h m s w W'.split(' '),
150
151 formatTokenFunctions = {
152 M : function () {
153 return this.month() + 1;
154 },
155 MMM : function (format) {
156 return this.lang().monthsShort(this, format);
157 },
158 MMMM : function (format) {
159 return this.lang().months(this, format);
160 },
161 D : function () {
162 return this.date();
163 },
164 DDD : function () {
165 return this.dayOfYear();
166 },
167 d : function () {
168 return this.day();
169 },
170 dd : function (format) {
171 return this.lang().weekdaysMin(this, format);
172 },
173 ddd : function (format) {
174 return this.lang().weekdaysShort(this, format);
175 },
176 dddd : function (format) {
177 return this.lang().weekdays(this, format);
178 },
179 w : function () {
180 return this.week();
181 },
182 W : function () {
183 return this.isoWeek();
184 },
185 YY : function () {
186 return leftZeroFill(this.year() % 100, 2);
187 },
188 YYYY : function () {
189 return leftZeroFill(this.year(), 4);
190 },
191 YYYYY : function () {
192 return leftZeroFill(this.year(), 5);
193 },
194 YYYYYY : function () {
195 var y = this.year(), sign = y >= 0 ? '+' : '-';
196 return sign + leftZeroFill(Math.abs(y), 6);
197 },
198 gg : function () {
199 return leftZeroFill(this.weekYear() % 100, 2);
200 },
201 gggg : function () {
202 return leftZeroFill(this.weekYear(), 4);
203 },
204 ggggg : function () {
205 return leftZeroFill(this.weekYear(), 5);
206 },
207 GG : function () {
208 return leftZeroFill(this.isoWeekYear() % 100, 2);
209 },
210 GGGG : function () {
211 return leftZeroFill(this.isoWeekYear(), 4);
212 },
213 GGGGG : function () {
214 return leftZeroFill(this.isoWeekYear(), 5);
215 },
216 e : function () {
217 return this.weekday();
218 },
219 E : function () {
220 return this.isoWeekday();
221 },
222 a : function () {
223 return this.lang().meridiem(this.hours(), this.minutes(), true);
224 },
225 A : function () {
226 return this.lang().meridiem(this.hours(), this.minutes(), false);
227 },
228 H : function () {
229 return this.hours();
230 },
231 h : function () {
232 return this.hours() % 12 || 12;
233 },
234 m : function () {
235 return this.minutes();
236 },
237 s : function () {
238 return this.seconds();
239 },
240 S : function () {
241 return toInt(this.milliseconds() / 100);
242 },
243 SS : function () {
244 return leftZeroFill(toInt(this.milliseconds() / 10), 2);
245 },
246 SSS : function () {
247 return leftZeroFill(this.milliseconds(), 3);
248 },
249 SSSS : function () {
250 return leftZeroFill(this.milliseconds(), 3);
251 },
252 Z : function () {
253 var a = -this.zone(),
254 b = "+";
255 if (a < 0) {
256 a = -a;
257 b = "-";
258 }
259 return b + leftZeroFill(toInt(a / 60), 2) + ":" + leftZeroFill(toInt(a) % 60, 2);
260 },
261 ZZ : function () {
262 var a = -this.zone(),
263 b = "+";
264 if (a < 0) {
265 a = -a;
266 b = "-";
267 }
268 return b + leftZeroFill(toInt(a / 60), 2) + leftZeroFill(toInt(a) % 60, 2);
269 },
270 z : function () {
271 return this.zoneAbbr();
272 },
273 zz : function () {
274 return this.zoneName();
275 },
276 X : function () {
277 return this.unix();
278 },
279 Q : function () {
280 return this.quarter();
281 }
282 },
283
284 lists = ['months', 'monthsShort', 'weekdays', 'weekdaysShort', 'weekdaysMin'];
285
286 function defaultParsingFlags() {
287 // We need to deep clone this object, and es5 standard is not very
288 // helpful.
289 return {
290 empty : false,
291 unusedTokens : [],
292 unusedInput : [],
293 overflow : -2,
294 charsLeftOver : 0,
295 nullInput : false,
296 invalidMonth : null,
297 invalidFormat : false,
298 userInvalidated : false,
299 iso: false
300 };
301 }
302
303 function deprecate(msg, fn) {
304 var firstTime = true;
305 function printMsg() {
306 if (moment.suppressDeprecationWarnings === false &&
307 typeof console !== 'undefined' && console.warn) {
308 console.warn("Deprecation warning: " + msg);
309 }
310 }
311 return extend(function () {
312 if (firstTime) {
313 printMsg();
314 firstTime = false;
315 }
316 return fn.apply(this, arguments);
317 }, fn);
318 }
319
320 function padToken(func, count) {
321 return function (a) {
322 return leftZeroFill(func.call(this, a), count);
323 };
324 }
325 function ordinalizeToken(func, period) {
326 return function (a) {
327 return this.lang().ordinal(func.call(this, a), period);
328 };
329 }
330
331 while (ordinalizeTokens.length) {
332 i = ordinalizeTokens.pop();
333 formatTokenFunctions[i + 'o'] = ordinalizeToken(formatTokenFunctions[i], i);
334 }
335 while (paddedTokens.length) {
336 i = paddedTokens.pop();
337 formatTokenFunctions[i + i] = padToken(formatTokenFunctions[i], 2);
338 }
339 formatTokenFunctions.DDDD = padToken(formatTokenFunctions.DDD, 3);
340
341
342 /************************************
343 Constructors
344 ************************************/
345
346 function Language() {
347
348 }
349
350 // Moment prototype object
351 function Moment(config) {
352 checkOverflow(config);
353 extend(this, config);
354 }
355
356 // Duration Constructor
357 function Duration(duration) {
358 var normalizedInput = normalizeObjectUnits(duration),
359 years = normalizedInput.year || 0,
360 quarters = normalizedInput.quarter || 0,
361 months = normalizedInput.month || 0,
362 weeks = normalizedInput.week || 0,
363 days = normalizedInput.day || 0,
364 hours = normalizedInput.hour || 0,
365 minutes = normalizedInput.minute || 0,
366 seconds = normalizedInput.second || 0,
367 milliseconds = normalizedInput.millisecond || 0;
368
369 // representation for dateAddRemove
370 this._milliseconds = +milliseconds +
371 seconds * 1e3 + // 1000
372 minutes * 6e4 + // 1000 * 60
373 hours * 36e5; // 1000 * 60 * 60
374 // Because of dateAddRemove treats 24 hours as different from a
375 // day when working around DST, we need to store them separately
376 this._days = +days +
377 weeks * 7;
378 // It is impossible translate months into days without knowing
379 // which months you are are talking about, so we have to store
380 // it separately.
381 this._months = +months +
382 quarters * 3 +
383 years * 12;
384
385 this._data = {};
386
387 this._bubble();
388 }
389
390 /************************************
391 Helpers
392 ************************************/
393
394
395 function extend(a, b) {
396 for (var i in b) {
397 if (b.hasOwnProperty(i)) {
398 a[i] = b[i];
399 }
400 }
401
402 if (b.hasOwnProperty("toString")) {
403 a.toString = b.toString;
404 }
405
406 if (b.hasOwnProperty("valueOf")) {
407 a.valueOf = b.valueOf;
408 }
409
410 return a;
411 }
412
413 function cloneMoment(m) {
414 var result = {}, i;
415 for (i in m) {
416 if (m.hasOwnProperty(i) && momentProperties.hasOwnProperty(i)) {
417 result[i] = m[i];
418 }
419 }
420
421 return result;
422 }
423
424 function absRound(number) {
425 if (number < 0) {
426 return Math.ceil(number);
427 } else {
428 return Math.floor(number);
429 }
430 }
431
432 // left zero fill a number
433 // see http://jsperf.com/left-zero-filling for performance comparison
434 function leftZeroFill(number, targetLength, forceSign) {
435 var output = '' + Math.abs(number),
436 sign = number >= 0;
437
438 while (output.length < targetLength) {
439 output = '0' + output;
440 }
441 return (sign ? (forceSign ? '+' : '') : '-') + output;
442 }
443
444 // helper function for _.addTime and _.subtractTime
445 function addOrSubtractDurationFromMoment(mom, duration, isAdding, updateOffset) {
446 var milliseconds = duration._milliseconds,
447 days = duration._days,
448 months = duration._months;
449 updateOffset = updateOffset == null ? true : updateOffset;
450
451 if (milliseconds) {
452 mom._d.setTime(+mom._d + milliseconds * isAdding);
453 }
454 if (days) {
455 rawSetter(mom, 'Date', rawGetter(mom, 'Date') + days * isAdding);
456 }
457 if (months) {
458 rawMonthSetter(mom, rawGetter(mom, 'Month') + months * isAdding);
459 }
460 if (updateOffset) {
461 moment.updateOffset(mom, days || months);
462 }
463 }
464
465 // check if is an array
466 function isArray(input) {
467 return Object.prototype.toString.call(input) === '[object Array]';
468 }
469
470 function isDate(input) {
471 return Object.prototype.toString.call(input) === '[object Date]' ||
472 input instanceof Date;
473 }
474
475 // compare two arrays, return the number of differences
476 function compareArrays(array1, array2, dontConvert) {
477 var len = Math.min(array1.length, array2.length),
478 lengthDiff = Math.abs(array1.length - array2.length),
479 diffs = 0,
480 i;
481 for (i = 0; i < len; i++) {
482 if ((dontConvert && array1[i] !== array2[i]) ||
483 (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
484 diffs++;
485 }
486 }
487 return diffs + lengthDiff;
488 }
489
490 function normalizeUnits(units) {
491 if (units) {
492 var lowered = units.toLowerCase().replace(/(.)s$/, '$1');
493 units = unitAliases[units] || camelFunctions[lowered] || lowered;
494 }
495 return units;
496 }
497
498 function normalizeObjectUnits(inputObject) {
499 var normalizedInput = {},
500 normalizedProp,
501 prop;
502
503 for (prop in inputObject) {
504 if (inputObject.hasOwnProperty(prop)) {
505 normalizedProp = normalizeUnits(prop);
506 if (normalizedProp) {
507 normalizedInput[normalizedProp] = inputObject[prop];
508 }
509 }
510 }
511
512 return normalizedInput;
513 }
514
515 function makeList(field) {
516 var count, setter;
517
518 if (field.indexOf('week') === 0) {
519 count = 7;
520 setter = 'day';
521 }
522 else if (field.indexOf('month') === 0) {
523 count = 12;
524 setter = 'month';
525 }
526 else {
527 return;
528 }
529
530 moment[field] = function (format, index) {
531 var i, getter,
532 method = moment.fn._lang[field],
533 results = [];
534
535 if (typeof format === 'number') {
536 index = format;
537 format = undefined;
538 }
539
540 getter = function (i) {
541 var m = moment().utc().set(setter, i);
542 return method.call(moment.fn._lang, m, format || '');
543 };
544
545 if (index != null) {
546 return getter(index);
547 }
548 else {
549 for (i = 0; i < count; i++) {
550 results.push(getter(i));
551 }
552 return results;
553 }
554 };
555 }
556
557 function toInt(argumentForCoercion) {
558 var coercedNumber = +argumentForCoercion,
559 value = 0;
560
561 if (coercedNumber !== 0 && isFinite(coercedNumber)) {
562 if (coercedNumber >= 0) {
563 value = Math.floor(coercedNumber);
564 } else {
565 value = Math.ceil(coercedNumber);
566 }
567 }
568
569 return value;
570 }
571
572 function daysInMonth(year, month) {
573 return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
574 }
575
576 function weeksInYear(year, dow, doy) {
577 return weekOfYear(moment([year, 11, 31 + dow - doy]), dow, doy).week;
578 }
579
580 function daysInYear(year) {
581 return isLeapYear(year) ? 366 : 365;
582 }
583
584 function isLeapYear(year) {
585 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
586 }
587
588 function checkOverflow(m) {
589 var overflow;
590 if (m._a && m._pf.overflow === -2) {
591 overflow =
592 m._a[MONTH] < 0 || m._a[MONTH] > 11 ? MONTH :
593 m._a[DATE] < 1 || m._a[DATE] > daysInMonth(m._a[YEAR], m._a[MONTH]) ? DATE :
594 m._a[HOUR] < 0 || m._a[HOUR] > 23 ? HOUR :
595 m._a[MINUTE] < 0 || m._a[MINUTE] > 59 ? MINUTE :
596 m._a[SECOND] < 0 || m._a[SECOND] > 59 ? SECOND :
597 m._a[MILLISECOND] < 0 || m._a[MILLISECOND] > 999 ? MILLISECOND :
598 -1;
599
600 if (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
601 overflow = DATE;
602 }
603
604 m._pf.overflow = overflow;
605 }
606 }
607
608 function isValid(m) {
609 if (m._isValid == null) {
610 m._isValid = !isNaN(m._d.getTime()) &&
611 m._pf.overflow < 0 &&
612 !m._pf.empty &&
613 !m._pf.invalidMonth &&
614 !m._pf.nullInput &&
615 !m._pf.invalidFormat &&
616 !m._pf.userInvalidated;
617
618 if (m._strict) {
619 m._isValid = m._isValid &&
620 m._pf.charsLeftOver === 0 &&
621 m._pf.unusedTokens.length === 0;
622 }
623 }
624 return m._isValid;
625 }
626
627 function normalizeLanguage(key) {
628 return key ? key.toLowerCase().replace('_', '-') : key;
629 }
630
631 // Return a moment from input, that is local/utc/zone equivalent to model.
632 function makeAs(input, model) {
633 return model._isUTC ? moment(input).zone(model._offset || 0) :
634 moment(input).local();
635 }
636
637 /************************************
638 Languages
639 ************************************/
640
641
642 extend(Language.prototype, {
643
644 set : function (config) {
645 var prop, i;
646 for (i in config) {
647 prop = config[i];
648 if (typeof prop === 'function') {
649 this[i] = prop;
650 } else {
651 this['_' + i] = prop;
652 }
653 }
654 },
655
656 _months : "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
657 months : function (m) {
658 return this._months[m.month()];
659 },
660
661 _monthsShort : "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
662 monthsShort : function (m) {
663 return this._monthsShort[m.month()];
664 },
665
666 monthsParse : function (monthName) {
667 var i, mom, regex;
668
669 if (!this._monthsParse) {
670 this._monthsParse = [];
671 }
672
673 for (i = 0; i < 12; i++) {
674 // make the regex if we don't have it already
675 if (!this._monthsParse[i]) {
676 mom = moment.utc([2000, i]);
677 regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
678 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
679 }
680 // test the regex
681 if (this._monthsParse[i].test(monthName)) {
682 return i;
683 }
684 }
685 },
686
687 _weekdays : "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
688 weekdays : function (m) {
689 return this._weekdays[m.day()];
690 },
691
692 _weekdaysShort : "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
693 weekdaysShort : function (m) {
694 return this._weekdaysShort[m.day()];
695 },
696
697 _weekdaysMin : "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
698 weekdaysMin : function (m) {
699 return this._weekdaysMin[m.day()];
700 },
701
702 weekdaysParse : function (weekdayName) {
703 var i, mom, regex;
704
705 if (!this._weekdaysParse) {
706 this._weekdaysParse = [];
707 }
708
709 for (i = 0; i < 7; i++) {
710 // make the regex if we don't have it already
711 if (!this._weekdaysParse[i]) {
712 mom = moment([2000, 1]).day(i);
713 regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
714 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
715 }
716 // test the regex
717 if (this._weekdaysParse[i].test(weekdayName)) {
718 return i;
719 }
720 }
721 },
722
723 _longDateFormat : {
724 LT : "h:mm A",
725 L : "MM/DD/YYYY",
726 LL : "MMMM D YYYY",
727 LLL : "MMMM D YYYY LT",
728 LLLL : "dddd, MMMM D YYYY LT"
729 },
730 longDateFormat : function (key) {
731 var output = this._longDateFormat[key];
732 if (!output && this._longDateFormat[key.toUpperCase()]) {
733 output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {
734 return val.slice(1);
735 });
736 this._longDateFormat[key] = output;
737 }
738 return output;
739 },
740
741 isPM : function (input) {
742 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
743 // Using charAt should be more compatible.
744 return ((input + '').toLowerCase().charAt(0) === 'p');
745 },
746
747 _meridiemParse : /[ap]\.?m?\.?/i,
748 meridiem : function (hours, minutes, isLower) {
749 if (hours > 11) {
750 return isLower ? 'pm' : 'PM';
751 } else {
752 return isLower ? 'am' : 'AM';
753 }
754 },
755
756 _calendar : {
757 sameDay : '[Today at] LT',
758 nextDay : '[Tomorrow at] LT',
759 nextWeek : 'dddd [at] LT',
760 lastDay : '[Yesterday at] LT',
761 lastWeek : '[Last] dddd [at] LT',
762 sameElse : 'L'
763 },
764 calendar : function (key, mom) {
765 var output = this._calendar[key];
766 return typeof output === 'function' ? output.apply(mom) : output;
767 },
768
769 _relativeTime : {
770 future : "in %s",
771 past : "%s ago",
772 s : "a few seconds",
773 m : "a minute",
774 mm : "%d minutes",
775 h : "an hour",
776 hh : "%d hours",
777 d : "a day",
778 dd : "%d days",
779 M : "a month",
780 MM : "%d months",
781 y : "a year",
782 yy : "%d years"
783 },
784 relativeTime : function (number, withoutSuffix, string, isFuture) {
785 var output = this._relativeTime[string];
786 return (typeof output === 'function') ?
787 output(number, withoutSuffix, string, isFuture) :
788 output.replace(/%d/i, number);
789 },
790 pastFuture : function (diff, output) {
791 var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
792 return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
793 },
794
795 ordinal : function (number) {
796 return this._ordinal.replace("%d", number);
797 },
798 _ordinal : "%d",
799
800 preparse : function (string) {
801 return string;
802 },
803
804 postformat : function (string) {
805 return string;
806 },
807
808 week : function (mom) {
809 return weekOfYear(mom, this._week.dow, this._week.doy).week;
810 },
811
812 _week : {
813 dow : 0, // Sunday is the first day of the week.
814 doy : 6 // The week that contains Jan 1st is the first week of the year.
815 },
816
817 _invalidDate: 'Invalid date',
818 invalidDate: function () {
819 return this._invalidDate;
820 }
821 });
822
823 // Loads a language definition into the `languages` cache. The function
824 // takes a key and optionally values. If not in the browser and no values
825 // are provided, it will load the language file module. As a convenience,
826 // this function also returns the language values.
827 function loadLang(key, values) {
828 values.abbr = key;
829 if (!languages[key]) {
830 languages[key] = new Language();
831 }
832 languages[key].set(values);
833 return languages[key];
834 }
835
836 // Remove a language from the `languages` cache. Mostly useful in tests.
837 function unloadLang(key) {
838 delete languages[key];
839 }
840
841 // Determines which language definition to use and returns it.
842 //
843 // With no parameters, it will return the global language. If you
844 // pass in a language key, such as 'en', it will return the
845 // definition for 'en', so long as 'en' has already been loaded using
846 // moment.lang.
847 function getLangDefinition(key) {
848 var i = 0, j, lang, next, split,
849 get = function (k) {
850 if (!languages[k] && hasModule) {
851 try {
852 require('./lang/' + k);
853 } catch (e) { }
854 }
855 return languages[k];
856 };
857
858 if (!key) {
859 return moment.fn._lang;
860 }
861
862 if (!isArray(key)) {
863 //short-circuit everything else
864 lang = get(key);
865 if (lang) {
866 return lang;
867 }
868 key = [key];
869 }
870
871 //pick the language from the array
872 //try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
873 //substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
874 while (i < key.length) {
875 split = normalizeLanguage(key[i]).split('-');
876 j = split.length;
877 next = normalizeLanguage(key[i + 1]);
878 next = next ? next.split('-') : null;
879 while (j > 0) {
880 lang = get(split.slice(0, j).join('-'));
881 if (lang) {
882 return lang;
883 }
884 if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
885 //the next array item is better than a shallower substring of this one
886 break;
887 }
888 j--;
889 }
890 i++;
891 }
892 return moment.fn._lang;
893 }
894
895 /************************************
896 Formatting
897 ************************************/
898
899
900 function removeFormattingTokens(input) {
901 if (input.match(/\[[\s\S]/)) {
902 return input.replace(/^\[|\]$/g, "");
903 }
904 return input.replace(/\\/g, "");
905 }
906
907 function makeFormatFunction(format) {
908 var array = format.match(formattingTokens), i, length;
909
910 for (i = 0, length = array.length; i < length; i++) {
911 if (formatTokenFunctions[array[i]]) {
912 array[i] = formatTokenFunctions[array[i]];
913 } else {
914 array[i] = removeFormattingTokens(array[i]);
915 }
916 }
917
918 return function (mom) {
919 var output = "";
920 for (i = 0; i < length; i++) {
921 output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
922 }
923 return output;
924 };
925 }
926
927 // format date using native date object
928 function formatMoment(m, format) {
929
930 if (!m.isValid()) {
931 return m.lang().invalidDate();
932 }
933
934 format = expandFormat(format, m.lang());
935
936 if (!formatFunctions[format]) {
937 formatFunctions[format] = makeFormatFunction(format);
938 }
939
940 return formatFunctions[format](m);
941 }
942
943 function expandFormat(format, lang) {
944 var i = 5;
945
946 function replaceLongDateFormatTokens(input) {
947 return lang.longDateFormat(input) || input;
948 }
949
950 localFormattingTokens.lastIndex = 0;
951 while (i >= 0 && localFormattingTokens.test(format)) {
952 format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
953 localFormattingTokens.lastIndex = 0;
954 i -= 1;
955 }
956
957 return format;
958 }
959
960
961 /************************************
962 Parsing
963 ************************************/
964
965
966 // get the regex to find the next token
967 function getParseRegexForToken(token, config) {
968 var a, strict = config._strict;
969 switch (token) {
970 case 'Q':
971 return parseTokenOneDigit;
972 case 'DDDD':
973 return parseTokenThreeDigits;
974 case 'YYYY':
975 case 'GGGG':
976 case 'gggg':
977 return strict ? parseTokenFourDigits : parseTokenOneToFourDigits;
978 case 'Y':
979 case 'G':
980 case 'g':
981 return parseTokenSignedNumber;
982 case 'YYYYYY':
983 case 'YYYYY':
984 case 'GGGGG':
985 case 'ggggg':
986 return strict ? parseTokenSixDigits : parseTokenOneToSixDigits;
987 case 'S':
988 if (strict) { return parseTokenOneDigit; }
989 /* falls through */
990 case 'SS':
991 if (strict) { return parseTokenTwoDigits; }
992 /* falls through */
993 case 'SSS':
994 if (strict) { return parseTokenThreeDigits; }
995 /* falls through */
996 case 'DDD':
997 return parseTokenOneToThreeDigits;
998 case 'MMM':
999 case 'MMMM':
1000 case 'dd':
1001 case 'ddd':
1002 case 'dddd':
1003 return parseTokenWord;
1004 case 'a':
1005 case 'A':
1006 return getLangDefinition(config._l)._meridiemParse;
1007 case 'X':
1008 return parseTokenTimestampMs;
1009 case 'Z':
1010 case 'ZZ':
1011 return parseTokenTimezone;
1012 case 'T':
1013 return parseTokenT;
1014 case 'SSSS':
1015 return parseTokenDigits;
1016 case 'MM':
1017 case 'DD':
1018 case 'YY':
1019 case 'GG':
1020 case 'gg':
1021 case 'HH':
1022 case 'hh':
1023 case 'mm':
1024 case 'ss':
1025 case 'ww':
1026 case 'WW':
1027 return strict ? parseTokenTwoDigits : parseTokenOneOrTwoDigits;
1028 case 'M':
1029 case 'D':
1030 case 'd':
1031 case 'H':
1032 case 'h':
1033 case 'm':
1034 case 's':
1035 case 'w':
1036 case 'W':
1037 case 'e':
1038 case 'E':
1039 return parseTokenOneOrTwoDigits;
1040 case 'Do':
1041 return parseTokenOrdinal;
1042 default :
1043 a = new RegExp(regexpEscape(unescapeFormat(token.replace('\\', '')), "i"));
1044 return a;
1045 }
1046 }
1047
1048 function timezoneMinutesFromString(string) {
1049 string = string || "";
1050 var possibleTzMatches = (string.match(parseTokenTimezone) || []),
1051 tzChunk = possibleTzMatches[possibleTzMatches.length - 1] || [],
1052 parts = (tzChunk + '').match(parseTimezoneChunker) || ['-', 0, 0],
1053 minutes = +(parts[1] * 60) + toInt(parts[2]);
1054
1055 return parts[0] === '+' ? -minutes : minutes;
1056 }
1057
1058 // function to convert string input to date
1059 function addTimeToArrayFromToken(token, input, config) {
1060 var a, datePartArray = config._a;
1061
1062 switch (token) {
1063 // QUARTER
1064 case 'Q':
1065 if (input != null) {
1066 datePartArray[MONTH] = (toInt(input) - 1) * 3;
1067 }
1068 break;
1069 // MONTH
1070 case 'M' : // fall through to MM
1071 case 'MM' :
1072 if (input != null) {
1073 datePartArray[MONTH] = toInt(input) - 1;
1074 }
1075 break;
1076 case 'MMM' : // fall through to MMMM
1077 case 'MMMM' :
1078 a = getLangDefinition(config._l).monthsParse(input);
1079 // if we didn't find a month name, mark the date as invalid.
1080 if (a != null) {
1081 datePartArray[MONTH] = a;
1082 } else {
1083 config._pf.invalidMonth = input;
1084 }
1085 break;
1086 // DAY OF MONTH
1087 case 'D' : // fall through to DD
1088 case 'DD' :
1089 if (input != null) {
1090 datePartArray[DATE] = toInt(input);
1091 }
1092 break;
1093 case 'Do' :
1094 if (input != null) {
1095 datePartArray[DATE] = toInt(parseInt(input, 10));
1096 }
1097 break;
1098 // DAY OF YEAR
1099 case 'DDD' : // fall through to DDDD
1100 case 'DDDD' :
1101 if (input != null) {
1102 config._dayOfYear = toInt(input);
1103 }
1104
1105 break;
1106 // YEAR
1107 case 'YY' :
1108 datePartArray[YEAR] = moment.parseTwoDigitYear(input);
1109 break;
1110 case 'YYYY' :
1111 case 'YYYYY' :
1112 case 'YYYYYY' :
1113 datePartArray[YEAR] = toInt(input);
1114 break;
1115 // AM / PM
1116 case 'a' : // fall through to A
1117 case 'A' :
1118 config._isPm = getLangDefinition(config._l).isPM(input);
1119 break;
1120 // 24 HOUR
1121 case 'H' : // fall through to hh
1122 case 'HH' : // fall through to hh
1123 case 'h' : // fall through to hh
1124 case 'hh' :
1125 datePartArray[HOUR] = toInt(input);
1126 break;
1127 // MINUTE
1128 case 'm' : // fall through to mm
1129 case 'mm' :
1130 datePartArray[MINUTE] = toInt(input);
1131 break;
1132 // SECOND
1133 case 's' : // fall through to ss
1134 case 'ss' :
1135 datePartArray[SECOND] = toInt(input);
1136 break;
1137 // MILLISECOND
1138 case 'S' :
1139 case 'SS' :
1140 case 'SSS' :
1141 case 'SSSS' :
1142 datePartArray[MILLISECOND] = toInt(('0.' + input) * 1000);
1143 break;
1144 // UNIX TIMESTAMP WITH MS
1145 case 'X':
1146 config._d = new Date(parseFloat(input) * 1000);
1147 break;
1148 // TIMEZONE
1149 case 'Z' : // fall through to ZZ
1150 case 'ZZ' :
1151 config._useUTC = true;
1152 config._tzm = timezoneMinutesFromString(input);
1153 break;
1154 case 'w':
1155 case 'ww':
1156 case 'W':
1157 case 'WW':
1158 case 'd':
1159 case 'dd':
1160 case 'ddd':
1161 case 'dddd':
1162 case 'e':
1163 case 'E':
1164 token = token.substr(0, 1);
1165 /* falls through */
1166 case 'gg':
1167 case 'gggg':
1168 case 'GG':
1169 case 'GGGG':
1170 case 'GGGGG':
1171 token = token.substr(0, 2);
1172 if (input) {
1173 config._w = config._w || {};
1174 config._w[token] = input;
1175 }
1176 break;
1177 }
1178 }
1179
1180 // convert an array to a date.
1181 // the array should mirror the parameters below
1182 // note: all values past the year are optional and will default to the lowest possible value.
1183 // [year, month, day , hour, minute, second, millisecond]
1184 function dateFromConfig(config) {
1185 var i, date, input = [], currentDate,
1186 yearToUse, fixYear, w, temp, lang, weekday, week;
1187
1188 if (config._d) {
1189 return;
1190 }
1191
1192 currentDate = currentDateArray(config);
1193
1194 //compute day of the year from weeks and weekdays
1195 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
1196 fixYear = function (val) {
1197 var intVal = parseInt(val, 10);
1198 return val ?
1199 (val.length < 3 ? (intVal > 68 ? 1900 + intVal : 2000 + intVal) : intVal) :
1200 (config._a[YEAR] == null ? moment().weekYear() : config._a[YEAR]);
1201 };
1202
1203 w = config._w;
1204 if (w.GG != null || w.W != null || w.E != null) {
1205 temp = dayOfYearFromWeeks(fixYear(w.GG), w.W || 1, w.E, 4, 1);
1206 }
1207 else {
1208 lang = getLangDefinition(config._l);
1209 weekday = w.d != null ? parseWeekday(w.d, lang) :
1210 (w.e != null ? parseInt(w.e, 10) + lang._week.dow : 0);
1211
1212 week = parseInt(w.w, 10) || 1;
1213
1214 //if we're parsing 'd', then the low day numbers may be next week
1215 if (w.d != null && weekday < lang._week.dow) {
1216 week++;
1217 }
1218
1219 temp = dayOfYearFromWeeks(fixYear(w.gg), week, weekday, lang._week.doy, lang._week.dow);
1220 }
1221
1222 config._a[YEAR] = temp.year;
1223 config._dayOfYear = temp.dayOfYear;
1224 }
1225
1226 //if the day of the year is set, figure out what it is
1227 if (config._dayOfYear) {
1228 yearToUse = config._a[YEAR] == null ? currentDate[YEAR] : config._a[YEAR];
1229
1230 if (config._dayOfYear > daysInYear(yearToUse)) {
1231 config._pf._overflowDayOfYear = true;
1232 }
1233
1234 date = makeUTCDate(yearToUse, 0, config._dayOfYear);
1235 config._a[MONTH] = date.getUTCMonth();
1236 config._a[DATE] = date.getUTCDate();
1237 }
1238
1239 // Default to current date.
1240 // * if no year, month, day of month are given, default to today
1241 // * if day of month is given, default month and year
1242 // * if month is given, default only year
1243 // * if year is given, don't default anything
1244 for (i = 0; i < 3 && config._a[i] == null; ++i) {
1245 config._a[i] = input[i] = currentDate[i];
1246 }
1247
1248 // Zero out whatever was not defaulted, including time
1249 for (; i < 7; i++) {
1250 config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
1251 }
1252
1253 // add the offsets to the time to be parsed so that we can have a clean array for checking isValid
1254 input[HOUR] += toInt((config._tzm || 0) / 60);
1255 input[MINUTE] += toInt((config._tzm || 0) % 60);
1256
1257 config._d = (config._useUTC ? makeUTCDate : makeDate).apply(null, input);
1258 }
1259
1260 function dateFromObject(config) {
1261 var normalizedInput;
1262
1263 if (config._d) {
1264 return;
1265 }
1266
1267 normalizedInput = normalizeObjectUnits(config._i);
1268 config._a = [
1269 normalizedInput.year,
1270 normalizedInput.month,
1271 normalizedInput.day,
1272 normalizedInput.hour,
1273 normalizedInput.minute,
1274 normalizedInput.second,
1275 normalizedInput.millisecond
1276 ];
1277
1278 dateFromConfig(config);
1279 }
1280
1281 function currentDateArray(config) {
1282 var now = new Date();
1283 if (config._useUTC) {
1284 return [
1285 now.getUTCFullYear(),
1286 now.getUTCMonth(),
1287 now.getUTCDate()
1288 ];
1289 } else {
1290 return [now.getFullYear(), now.getMonth(), now.getDate()];
1291 }
1292 }
1293
1294 // date from string and format string
1295 function makeDateFromStringAndFormat(config) {
1296
1297 config._a = [];
1298 config._pf.empty = true;
1299
1300 // This array is used to make a Date, either with `new Date` or `Date.UTC`
1301 var lang = getLangDefinition(config._l),
1302 string = '' + config._i,
1303 i, parsedInput, tokens, token, skipped,
1304 stringLength = string.length,
1305 totalParsedInputLength = 0;
1306
1307 tokens = expandFormat(config._f, lang).match(formattingTokens) || [];
1308
1309 for (i = 0; i < tokens.length; i++) {
1310 token = tokens[i];
1311 parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
1312 if (parsedInput) {
1313 skipped = string.substr(0, string.indexOf(parsedInput));
1314 if (skipped.length > 0) {
1315 config._pf.unusedInput.push(skipped);
1316 }
1317 string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
1318 totalParsedInputLength += parsedInput.length;
1319 }
1320 // don't parse if it's not a known token
1321 if (formatTokenFunctions[token]) {
1322 if (parsedInput) {
1323 config._pf.empty = false;
1324 }
1325 else {
1326 config._pf.unusedTokens.push(token);
1327 }
1328 addTimeToArrayFromToken(token, parsedInput, config);
1329 }
1330 else if (config._strict && !parsedInput) {
1331 config._pf.unusedTokens.push(token);
1332 }
1333 }
1334
1335 // add remaining unparsed input length to the string
1336 config._pf.charsLeftOver = stringLength - totalParsedInputLength;
1337 if (string.length > 0) {
1338 config._pf.unusedInput.push(string);
1339 }
1340
1341 // handle am pm
1342 if (config._isPm && config._a[HOUR] < 12) {
1343 config._a[HOUR] += 12;
1344 }
1345 // if is 12 am, change hours to 0
1346 if (config._isPm === false && config._a[HOUR] === 12) {
1347 config._a[HOUR] = 0;
1348 }
1349
1350 dateFromConfig(config);
1351 checkOverflow(config);
1352 }
1353
1354 function unescapeFormat(s) {
1355 return s.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
1356 return p1 || p2 || p3 || p4;
1357 });
1358 }
1359
1360 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
1361 function regexpEscape(s) {
1362 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
1363 }
1364
1365 // date from string and array of format strings
1366 function makeDateFromStringAndArray(config) {
1367 var tempConfig,
1368 bestMoment,
1369
1370 scoreToBeat,
1371 i,
1372 currentScore;
1373
1374 if (config._f.length === 0) {
1375 config._pf.invalidFormat = true;
1376 config._d = new Date(NaN);
1377 return;
1378 }
1379
1380 for (i = 0; i < config._f.length; i++) {
1381 currentScore = 0;
1382 tempConfig = extend({}, config);
1383 tempConfig._pf = defaultParsingFlags();
1384 tempConfig._f = config._f[i];
1385 makeDateFromStringAndFormat(tempConfig);
1386
1387 if (!isValid(tempConfig)) {
1388 continue;
1389 }
1390
1391 // if there is any input that was not parsed add a penalty for that format
1392 currentScore += tempConfig._pf.charsLeftOver;
1393
1394 //or tokens
1395 currentScore += tempConfig._pf.unusedTokens.length * 10;
1396
1397 tempConfig._pf.score = currentScore;
1398
1399 if (scoreToBeat == null || currentScore < scoreToBeat) {
1400 scoreToBeat = currentScore;
1401 bestMoment = tempConfig;
1402 }
1403 }
1404
1405 extend(config, bestMoment || tempConfig);
1406 }
1407
1408 // date from iso format
1409 function makeDateFromString(config) {
1410 var i, l,
1411 string = config._i,
1412 match = isoRegex.exec(string);
1413
1414 if (match) {
1415 config._pf.iso = true;
1416 for (i = 0, l = isoDates.length; i < l; i++) {
1417 if (isoDates[i][1].exec(string)) {
1418 // match[5] should be "T" or undefined
1419 config._f = isoDates[i][0] + (match[6] || " ");
1420 break;
1421 }
1422 }
1423 for (i = 0, l = isoTimes.length; i < l; i++) {
1424 if (isoTimes[i][1].exec(string)) {
1425 config._f += isoTimes[i][0];
1426 break;
1427 }
1428 }
1429 if (string.match(parseTokenTimezone)) {
1430 config._f += "Z";
1431 }
1432 makeDateFromStringAndFormat(config);
1433 }
1434 else {
1435 moment.createFromInputFallback(config);
1436 }
1437 }
1438
1439 function makeDateFromInput(config) {
1440 var input = config._i,
1441 matched = aspNetJsonRegex.exec(input);
1442
1443 if (input === undefined) {
1444 config._d = new Date();
1445 } else if (matched) {
1446 config._d = new Date(+matched[1]);
1447 } else if (typeof input === 'string') {
1448 makeDateFromString(config);
1449 } else if (isArray(input)) {
1450 config._a = input.slice(0);
1451 dateFromConfig(config);
1452 } else if (isDate(input)) {
1453 config._d = new Date(+input);
1454 } else if (typeof(input) === 'object') {
1455 dateFromObject(config);
1456 } else if (typeof(input) === 'number') {
1457 // from milliseconds
1458 config._d = new Date(input);
1459 } else {
1460 moment.createFromInputFallback(config);
1461 }
1462 }
1463
1464 function makeDate(y, m, d, h, M, s, ms) {
1465 //can't just apply() to create a date:
1466 //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
1467 var date = new Date(y, m, d, h, M, s, ms);
1468
1469 //the date constructor doesn't accept years < 1970
1470 if (y < 1970) {
1471 date.setFullYear(y);
1472 }
1473 return date;
1474 }
1475
1476 function makeUTCDate(y) {
1477 var date = new Date(Date.UTC.apply(null, arguments));
1478 if (y < 1970) {
1479 date.setUTCFullYear(y);
1480 }
1481 return date;
1482 }
1483
1484 function parseWeekday(input, language) {
1485 if (typeof input === 'string') {
1486 if (!isNaN(input)) {
1487 input = parseInt(input, 10);
1488 }
1489 else {
1490 input = language.weekdaysParse(input);
1491 if (typeof input !== 'number') {
1492 return null;
1493 }
1494 }
1495 }
1496 return input;
1497 }
1498
1499 /************************************
1500 Relative Time
1501 ************************************/
1502
1503
1504 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
1505 function substituteTimeAgo(string, number, withoutSuffix, isFuture, lang) {
1506 return lang.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
1507 }
1508
1509 function relativeTime(milliseconds, withoutSuffix, lang) {
1510 var seconds = round(Math.abs(milliseconds) / 1000),
1511 minutes = round(seconds / 60),
1512 hours = round(minutes / 60),
1513 days = round(hours / 24),
1514 years = round(days / 365),
1515 args = seconds < 45 && ['s', seconds] ||
1516 minutes === 1 && ['m'] ||
1517 minutes < 45 && ['mm', minutes] ||
1518 hours === 1 && ['h'] ||
1519 hours < 22 && ['hh', hours] ||
1520 days === 1 && ['d'] ||
1521 days <= 25 && ['dd', days] ||
1522 days <= 45 && ['M'] ||
1523 days < 345 && ['MM', round(days / 30)] ||
1524 years === 1 && ['y'] || ['yy', years];
1525 args[2] = withoutSuffix;
1526 args[3] = milliseconds > 0;
1527 args[4] = lang;
1528 return substituteTimeAgo.apply({}, args);
1529 }
1530
1531
1532 /************************************
1533 Week of Year
1534 ************************************/
1535
1536
1537 // firstDayOfWeek 0 = sun, 6 = sat
1538 // the day of the week that starts the week
1539 // (usually sunday or monday)
1540 // firstDayOfWeekOfYear 0 = sun, 6 = sat
1541 // the first week is the week that contains the first
1542 // of this day of the week
1543 // (eg. ISO weeks use thursday (4))
1544 function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
1545 var end = firstDayOfWeekOfYear - firstDayOfWeek,
1546 daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
1547 adjustedMoment;
1548
1549
1550 if (daysToDayOfWeek > end) {
1551 daysToDayOfWeek -= 7;
1552 }
1553
1554 if (daysToDayOfWeek < end - 7) {
1555 daysToDayOfWeek += 7;
1556 }
1557
1558 adjustedMoment = moment(mom).add('d', daysToDayOfWeek);
1559 return {
1560 week: Math.ceil(adjustedMoment.dayOfYear() / 7),
1561 year: adjustedMoment.year()
1562 };
1563 }
1564
1565 //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1566 function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
1567 var d = makeUTCDate(year, 0, 1).getUTCDay(), daysToAdd, dayOfYear;
1568
1569 weekday = weekday != null ? weekday : firstDayOfWeek;
1570 daysToAdd = firstDayOfWeek - d + (d > firstDayOfWeekOfYear ? 7 : 0) - (d < firstDayOfWeek ? 7 : 0);
1571 dayOfYear = 7 * (week - 1) + (weekday - firstDayOfWeek) + daysToAdd + 1;
1572
1573 return {
1574 year: dayOfYear > 0 ? year : year - 1,
1575 dayOfYear: dayOfYear > 0 ? dayOfYear : daysInYear(year - 1) + dayOfYear
1576 };
1577 }
1578
1579 /************************************
1580 Top Level Functions
1581 ************************************/
1582
1583 function makeMoment(config) {
1584 var input = config._i,
1585 format = config._f;
1586
1587 if (input === null || (format === undefined && input === '')) {
1588 return moment.invalid({nullInput: true});
1589 }
1590
1591 if (typeof input === 'string') {
1592 config._i = input = getLangDefinition().preparse(input);
1593 }
1594
1595 if (moment.isMoment(input)) {
1596 config = cloneMoment(input);
1597
1598 config._d = new Date(+input._d);
1599 } else if (format) {
1600 if (isArray(format)) {
1601 makeDateFromStringAndArray(config);
1602 } else {
1603 makeDateFromStringAndFormat(config);
1604 }
1605 } else {
1606 makeDateFromInput(config);
1607 }
1608
1609 return new Moment(config);
1610 }
1611
1612 moment = function (input, format, lang, strict) {
1613 var c;
1614
1615 if (typeof(lang) === "boolean") {
1616 strict = lang;
1617 lang = undefined;
1618 }
1619 // object construction must be done this way.
1620 // https://github.com/moment/moment/issues/1423
1621 c = {};
1622 c._isAMomentObject = true;
1623 c._i = input;
1624 c._f = format;
1625 c._l = lang;
1626 c._strict = strict;
1627 c._isUTC = false;
1628 c._pf = defaultParsingFlags();
1629
1630 return makeMoment(c);
1631 };
1632
1633 moment.suppressDeprecationWarnings = false;
1634
1635 moment.createFromInputFallback = deprecate(
1636 "moment construction falls back to js Date. This is " +
1637 "discouraged and will be removed in upcoming major " +
1638 "release. Please refer to " +
1639 "https://github.com/moment/moment/issues/1407 for more info.",
1640 function (config) {
1641 config._d = new Date(config._i);
1642 });
1643
1644 // creating with utc
1645 moment.utc = function (input, format, lang, strict) {
1646 var c;
1647
1648 if (typeof(lang) === "boolean") {
1649 strict = lang;
1650 lang = undefined;
1651 }
1652 // object construction must be done this way.
1653 // https://github.com/moment/moment/issues/1423
1654 c = {};
1655 c._isAMomentObject = true;
1656 c._useUTC = true;
1657 c._isUTC = true;
1658 c._l = lang;
1659 c._i = input;
1660 c._f = format;
1661 c._strict = strict;
1662 c._pf = defaultParsingFlags();
1663
1664 return makeMoment(c).utc();
1665 };
1666
1667 // creating with unix timestamp (in seconds)
1668 moment.unix = function (input) {
1669 return moment(input * 1000);
1670 };
1671
1672 // duration
1673 moment.duration = function (input, key) {
1674 var duration = input,
1675 // matching against regexp is expensive, do it on demand
1676 match = null,
1677 sign,
1678 ret,
1679 parseIso;
1680
1681 if (moment.isDuration(input)) {
1682 duration = {
1683 ms: input._milliseconds,
1684 d: input._days,
1685 M: input._months
1686 };
1687 } else if (typeof input === 'number') {
1688 duration = {};
1689 if (key) {
1690 duration[key] = input;
1691 } else {
1692 duration.milliseconds = input;
1693 }
1694 } else if (!!(match = aspNetTimeSpanJsonRegex.exec(input))) {
1695 sign = (match[1] === "-") ? -1 : 1;
1696 duration = {
1697 y: 0,
1698 d: toInt(match[DATE]) * sign,
1699 h: toInt(match[HOUR]) * sign,
1700 m: toInt(match[MINUTE]) * sign,
1701 s: toInt(match[SECOND]) * sign,
1702 ms: toInt(match[MILLISECOND]) * sign
1703 };
1704 } else if (!!(match = isoDurationRegex.exec(input))) {
1705 sign = (match[1] === "-") ? -1 : 1;
1706 parseIso = function (inp) {
1707 // We'd normally use ~~inp for this, but unfortunately it also
1708 // converts floats to ints.
1709 // inp may be undefined, so careful calling replace on it.
1710 var res = inp && parseFloat(inp.replace(',', '.'));
1711 // apply sign while we're at it
1712 return (isNaN(res) ? 0 : res) * sign;
1713 };
1714 duration = {
1715 y: parseIso(match[2]),
1716 M: parseIso(match[3]),
1717 d: parseIso(match[4]),
1718 h: parseIso(match[5]),
1719 m: parseIso(match[6]),
1720 s: parseIso(match[7]),
1721 w: parseIso(match[8])
1722 };
1723 }
1724
1725 ret = new Duration(duration);
1726
1727 if (moment.isDuration(input) && input.hasOwnProperty('_lang')) {
1728 ret._lang = input._lang;
1729 }
1730
1731 return ret;
1732 };
1733
1734 // version number
1735 moment.version = VERSION;
1736
1737 // default format
1738 moment.defaultFormat = isoFormat;
1739
1740 // Plugins that add properties should also add the key here (null value),
1741 // so we can properly clone ourselves.
1742 moment.momentProperties = momentProperties;
1743
1744 // This function will be called whenever a moment is mutated.
1745 // It is intended to keep the offset in sync with the timezone.
1746 moment.updateOffset = function () {};
1747
1748 // This function will load languages and then set the global language. If
1749 // no arguments are passed in, it will simply return the current global
1750 // language key.
1751 moment.lang = function (key, values) {
1752 var r;
1753 if (!key) {
1754 return moment.fn._lang._abbr;
1755 }
1756 if (values) {
1757 loadLang(normalizeLanguage(key), values);
1758 } else if (values === null) {
1759 unloadLang(key);
1760 key = 'en';
1761 } else if (!languages[key]) {
1762 getLangDefinition(key);
1763 }
1764 r = moment.duration.fn._lang = moment.fn._lang = getLangDefinition(key);
1765 return r._abbr;
1766 };
1767
1768 // returns language data
1769 moment.langData = function (key) {
1770 if (key && key._lang && key._lang._abbr) {
1771 key = key._lang._abbr;
1772 }
1773 return getLangDefinition(key);
1774 };
1775
1776 // compare moment object
1777 moment.isMoment = function (obj) {
1778 return obj instanceof Moment ||
1779 (obj != null && obj.hasOwnProperty('_isAMomentObject'));
1780 };
1781
1782 // for typechecking Duration objects
1783 moment.isDuration = function (obj) {
1784 return obj instanceof Duration;
1785 };
1786
1787 for (i = lists.length - 1; i >= 0; --i) {
1788 makeList(lists[i]);
1789 }
1790
1791 moment.normalizeUnits = function (units) {
1792 return normalizeUnits(units);
1793 };
1794
1795 moment.invalid = function (flags) {
1796 var m = moment.utc(NaN);
1797 if (flags != null) {
1798 extend(m._pf, flags);
1799 }
1800 else {
1801 m._pf.userInvalidated = true;
1802 }
1803
1804 return m;
1805 };
1806
1807 moment.parseZone = function () {
1808 return moment.apply(null, arguments).parseZone();
1809 };
1810
1811 moment.parseTwoDigitYear = function (input) {
1812 return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
1813 };
1814
1815 /************************************
1816 Moment Prototype
1817 ************************************/
1818
1819
1820 extend(moment.fn = Moment.prototype, {
1821
1822 clone : function () {
1823 return moment(this);
1824 },
1825
1826 valueOf : function () {
1827 return +this._d + ((this._offset || 0) * 60000);
1828 },
1829
1830 unix : function () {
1831 return Math.floor(+this / 1000);
1832 },
1833
1834 toString : function () {
1835 return this.clone().lang('en').format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
1836 },
1837
1838 toDate : function () {
1839 return this._offset ? new Date(+this) : this._d;
1840 },
1841
1842 toISOString : function () {
1843 var m = moment(this).utc();
1844 if (0 < m.year() && m.year() <= 9999) {
1845 return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
1846 } else {
1847 return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
1848 }
1849 },
1850
1851 toArray : function () {
1852 var m = this;
1853 return [
1854 m.year(),
1855 m.month(),
1856 m.date(),
1857 m.hours(),
1858 m.minutes(),
1859 m.seconds(),
1860 m.milliseconds()
1861 ];
1862 },
1863
1864 isValid : function () {
1865 return isValid(this);
1866 },
1867
1868 isDSTShifted : function () {
1869
1870 if (this._a) {
1871 return this.isValid() && compareArrays(this._a, (this._isUTC ? moment.utc(this._a) : moment(this._a)).toArray()) > 0;
1872 }
1873
1874 return false;
1875 },
1876
1877 parsingFlags : function () {
1878 return extend({}, this._pf);
1879 },
1880
1881 invalidAt: function () {
1882 return this._pf.overflow;
1883 },
1884
1885 utc : function () {
1886 return this.zone(0);
1887 },
1888
1889 local : function () {
1890 this.zone(0);
1891 this._isUTC = false;
1892 return this;
1893 },
1894
1895 format : function (inputString) {
1896 var output = formatMoment(this, inputString || moment.defaultFormat);
1897 return this.lang().postformat(output);
1898 },
1899
1900 add : function (input, val) {
1901 var dur;
1902 // switch args to support add('s', 1) and add(1, 's')
1903 if (typeof input === 'string') {
1904 dur = moment.duration(+val, input);
1905 } else {
1906 dur = moment.duration(input, val);
1907 }
1908 addOrSubtractDurationFromMoment(this, dur, 1);
1909 return this;
1910 },
1911
1912 subtract : function (input, val) {
1913 var dur;
1914 // switch args to support subtract('s', 1) and subtract(1, 's')
1915 if (typeof input === 'string') {
1916 dur = moment.duration(+val, input);
1917 } else {
1918 dur = moment.duration(input, val);
1919 }
1920 addOrSubtractDurationFromMoment(this, dur, -1);
1921 return this;
1922 },
1923
1924 diff : function (input, units, asFloat) {
1925 var that = makeAs(input, this),
1926 zoneDiff = (this.zone() - that.zone()) * 6e4,
1927 diff, output;
1928
1929 units = normalizeUnits(units);
1930
1931 if (units === 'year' || units === 'month') {
1932 // average number of days in the months in the given dates
1933 diff = (this.daysInMonth() + that.daysInMonth()) * 432e5; // 24 * 60 * 60 * 1000 / 2
1934 // difference in months
1935 output = ((this.year() - that.year()) * 12) + (this.month() - that.month());
1936 // adjust by taking difference in days, average number of days
1937 // and dst in the given months.
1938 output += ((this - moment(this).startOf('month')) -
1939 (that - moment(that).startOf('month'))) / diff;
1940 // same as above but with zones, to negate all dst
1941 output -= ((this.zone() - moment(this).startOf('month').zone()) -
1942 (that.zone() - moment(that).startOf('month').zone())) * 6e4 / diff;
1943 if (units === 'year') {
1944 output = output / 12;
1945 }
1946 } else {
1947 diff = (this - that);
1948 output = units === 'second' ? diff / 1e3 : // 1000
1949 units === 'minute' ? diff / 6e4 : // 1000 * 60
1950 units === 'hour' ? diff / 36e5 : // 1000 * 60 * 60
1951 units === 'day' ? (diff - zoneDiff) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
1952 units === 'week' ? (diff - zoneDiff) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
1953 diff;
1954 }
1955 return asFloat ? output : absRound(output);
1956 },
1957
1958 from : function (time, withoutSuffix) {
1959 return moment.duration(this.diff(time)).lang(this.lang()._abbr).humanize(!withoutSuffix);
1960 },
1961
1962 fromNow : function (withoutSuffix) {
1963 return this.from(moment(), withoutSuffix);
1964 },
1965
1966 calendar : function () {
1967 // We want to compare the start of today, vs this.
1968 // Getting start-of-today depends on whether we're zone'd or not.
1969 var sod = makeAs(moment(), this).startOf('day'),
1970 diff = this.diff(sod, 'days', true),
1971 format = diff < -6 ? 'sameElse' :
1972 diff < -1 ? 'lastWeek' :
1973 diff < 0 ? 'lastDay' :
1974 diff < 1 ? 'sameDay' :
1975 diff < 2 ? 'nextDay' :
1976 diff < 7 ? 'nextWeek' : 'sameElse';
1977 return this.format(this.lang().calendar(format, this));
1978 },
1979
1980 isLeapYear : function () {
1981 return isLeapYear(this.year());
1982 },
1983
1984 isDST : function () {
1985 return (this.zone() < this.clone().month(0).zone() ||
1986 this.zone() < this.clone().month(5).zone());
1987 },
1988
1989 day : function (input) {
1990 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1991 if (input != null) {
1992 input = parseWeekday(input, this.lang());
1993 return this.add({ d : input - day });
1994 } else {
1995 return day;
1996 }
1997 },
1998
1999 month : makeAccessor('Month', true),
2000
2001 startOf: function (units) {
2002 units = normalizeUnits(units);
2003 // the following switch intentionally omits break keywords
2004 // to utilize falling through the cases.
2005 switch (units) {
2006 case 'year':
2007 this.month(0);
2008 /* falls through */
2009 case 'quarter':
2010 case 'month':
2011 this.date(1);
2012 /* falls through */
2013 case 'week':
2014 case 'isoWeek':
2015 case 'day':
2016 this.hours(0);
2017 /* falls through */
2018 case 'hour':
2019 this.minutes(0);
2020 /* falls through */
2021 case 'minute':
2022 this.seconds(0);
2023 /* falls through */
2024 case 'second':
2025 this.milliseconds(0);
2026 /* falls through */
2027 }
2028
2029 // weeks are a special case
2030 if (units === 'week') {
2031 this.weekday(0);
2032 } else if (units === 'isoWeek') {
2033 this.isoWeekday(1);
2034 }
2035
2036 // quarters are also special
2037 if (units === 'quarter') {
2038 this.month(Math.floor(this.month() / 3) * 3);
2039 }
2040
2041 return this;
2042 },
2043
2044 endOf: function (units) {
2045 units = normalizeUnits(units);
2046 return this.startOf(units).add((units === 'isoWeek' ? 'week' : units), 1).subtract('ms', 1);
2047 },
2048
2049 isAfter: function (input, units) {
2050 units = typeof units !== 'undefined' ? units : 'millisecond';
2051 return +this.clone().startOf(units) > +moment(input).startOf(units);
2052 },
2053
2054 isBefore: function (input, units) {
2055 units = typeof units !== 'undefined' ? units : 'millisecond';
2056 return +this.clone().startOf(units) < +moment(input).startOf(units);
2057 },
2058
2059 isSame: function (input, units) {
2060 units = units || 'ms';
2061 return +this.clone().startOf(units) === +makeAs(input, this).startOf(units);
2062 },
2063
2064 min: function (other) {
2065 other = moment.apply(null, arguments);
2066 return other < this ? this : other;
2067 },
2068
2069 max: function (other) {
2070 other = moment.apply(null, arguments);
2071 return other > this ? this : other;
2072 },
2073
2074 // keepTime = true means only change the timezone, without affecting
2075 // the local hour. So 5:31:26 +0300 --[zone(2, true)]--> 5:31:26 +0200
2076 // It is possible that 5:31:26 doesn't exist int zone +0200, so we
2077 // adjust the time as needed, to be valid.
2078 //
2079 // Keeping the time actually adds/subtracts (one hour)
2080 // from the actual represented time. That is why we call updateOffset
2081 // a second time. In case it wants us to change the offset again
2082 // _changeInProgress == true case, then we have to adjust, because
2083 // there is no such time in the given timezone.
2084 zone : function (input, keepTime) {
2085 var offset = this._offset || 0;
2086 if (input != null) {
2087 if (typeof input === "string") {
2088 input = timezoneMinutesFromString(input);
2089 }
2090 if (Math.abs(input) < 16) {
2091 input = input * 60;
2092 }
2093 this._offset = input;
2094 this._isUTC = true;
2095 if (offset !== input) {
2096 if (!keepTime || this._changeInProgress) {
2097 addOrSubtractDurationFromMoment(this,
2098 moment.duration(offset - input, 'm'), 1, false);
2099 } else if (!this._changeInProgress) {
2100 this._changeInProgress = true;
2101 moment.updateOffset(this, true);
2102 this._changeInProgress = null;
2103 }
2104 }
2105 } else {
2106 return this._isUTC ? offset : this._d.getTimezoneOffset();
2107 }
2108 return this;
2109 },
2110
2111 zoneAbbr : function () {
2112 return this._isUTC ? "UTC" : "";
2113 },
2114
2115 zoneName : function () {
2116 return this._isUTC ? "Coordinated Universal Time" : "";
2117 },
2118
2119 parseZone : function () {
2120 if (this._tzm) {
2121 this.zone(this._tzm);
2122 } else if (typeof this._i === 'string') {
2123 this.zone(this._i);
2124 }
2125 return this;
2126 },
2127
2128 hasAlignedHourOffset : function (input) {
2129 if (!input) {
2130 input = 0;
2131 }
2132 else {
2133 input = moment(input).zone();
2134 }
2135
2136 return (this.zone() - input) % 60 === 0;
2137 },
2138
2139 daysInMonth : function () {
2140 return daysInMonth(this.year(), this.month());
2141 },
2142
2143 dayOfYear : function (input) {
2144 var dayOfYear = round((moment(this).startOf('day') - moment(this).startOf('year')) / 864e5) + 1;
2145 return input == null ? dayOfYear : this.add("d", (input - dayOfYear));
2146 },
2147
2148 quarter : function (input) {
2149 return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
2150 },
2151
2152 weekYear : function (input) {
2153 var year = weekOfYear(this, this.lang()._week.dow, this.lang()._week.doy).year;
2154 return input == null ? year : this.add("y", (input - year));
2155 },
2156
2157 isoWeekYear : function (input) {
2158 var year = weekOfYear(this, 1, 4).year;
2159 return input == null ? year : this.add("y", (input - year));
2160 },
2161
2162 week : function (input) {
2163 var week = this.lang().week(this);
2164 return input == null ? week : this.add("d", (input - week) * 7);
2165 },
2166
2167 isoWeek : function (input) {
2168 var week = weekOfYear(this, 1, 4).week;
2169 return input == null ? week : this.add("d", (input - week) * 7);
2170 },
2171
2172 weekday : function (input) {
2173 var weekday = (this.day() + 7 - this.lang()._week.dow) % 7;
2174 return input == null ? weekday : this.add("d", input - weekday);
2175 },
2176
2177 isoWeekday : function (input) {
2178 // behaves the same as moment#day except
2179 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
2180 // as a setter, sunday should belong to the previous week.
2181 return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
2182 },
2183
2184 isoWeeksInYear : function () {
2185 return weeksInYear(this.year(), 1, 4);
2186 },
2187
2188 weeksInYear : function () {
2189 var weekInfo = this._lang._week;
2190 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
2191 },
2192
2193 get : function (units) {
2194 units = normalizeUnits(units);
2195 return this[units]();
2196 },
2197
2198 set : function (units, value) {
2199 units = normalizeUnits(units);
2200 if (typeof this[units] === 'function') {
2201 this[units](value);
2202 }
2203 return this;
2204 },
2205
2206 // If passed a language key, it will set the language for this
2207 // instance. Otherwise, it will return the language configuration
2208 // variables for this instance.
2209 lang : function (key) {
2210 if (key === undefined) {
2211 return this._lang;
2212 } else {
2213 this._lang = getLangDefinition(key);
2214 return this;
2215 }
2216 }
2217 });
2218
2219 function rawMonthSetter(mom, value) {
2220 var dayOfMonth;
2221
2222 // TODO: Move this out of here!
2223 if (typeof value === 'string') {
2224 value = mom.lang().monthsParse(value);
2225 // TODO: Another silent failure?
2226 if (typeof value !== 'number') {
2227 return mom;
2228 }
2229 }
2230
2231 dayOfMonth = Math.min(mom.date(),
2232 daysInMonth(mom.year(), value));
2233 mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
2234 return mom;
2235 }
2236
2237 function rawGetter(mom, unit) {
2238 return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
2239 }
2240
2241 function rawSetter(mom, unit, value) {
2242 if (unit === 'Month') {
2243 return rawMonthSetter(mom, value);
2244 } else {
2245 return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
2246 }
2247 }
2248
2249 function makeAccessor(unit, keepTime) {
2250 return function (value) {
2251 if (value != null) {
2252 rawSetter(this, unit, value);
2253 moment.updateOffset(this, keepTime);
2254 return this;
2255 } else {
2256 return rawGetter(this, unit);
2257 }
2258 };
2259 }
2260
2261 moment.fn.millisecond = moment.fn.milliseconds = makeAccessor('Milliseconds', false);
2262 moment.fn.second = moment.fn.seconds = makeAccessor('Seconds', false);
2263 moment.fn.minute = moment.fn.minutes = makeAccessor('Minutes', false);
2264 // Setting the hour should keep the time, because the user explicitly
2265 // specified which hour he wants. So trying to maintain the same hour (in
2266 // a new timezone) makes sense. Adding/subtracting hours does not follow
2267 // this rule.
2268 moment.fn.hour = moment.fn.hours = makeAccessor('Hours', true);
2269 // moment.fn.month is defined separately
2270 moment.fn.date = makeAccessor('Date', true);
2271 moment.fn.dates = deprecate("dates accessor is deprecated. Use date instead.", makeAccessor('Date', true));
2272 moment.fn.year = makeAccessor('FullYear', true);
2273 moment.fn.years = deprecate("years accessor is deprecated. Use year instead.", makeAccessor('FullYear', true));
2274
2275 // add plural methods
2276 moment.fn.days = moment.fn.day;
2277 moment.fn.months = moment.fn.month;
2278 moment.fn.weeks = moment.fn.week;
2279 moment.fn.isoWeeks = moment.fn.isoWeek;
2280 moment.fn.quarters = moment.fn.quarter;
2281
2282 // add aliased format methods
2283 moment.fn.toJSON = moment.fn.toISOString;
2284
2285 /************************************
2286 Duration Prototype
2287 ************************************/
2288
2289
2290 extend(moment.duration.fn = Duration.prototype, {
2291
2292 _bubble : function () {
2293 var milliseconds = this._milliseconds,
2294 days = this._days,
2295 months = this._months,
2296 data = this._data,
2297 seconds, minutes, hours, years;
2298
2299 // The following code bubbles up values, see the tests for
2300 // examples of what that means.
2301 data.milliseconds = milliseconds % 1000;
2302
2303 seconds = absRound(milliseconds / 1000);
2304 data.seconds = seconds % 60;
2305
2306 minutes = absRound(seconds / 60);
2307 data.minutes = minutes % 60;
2308
2309 hours = absRound(minutes / 60);
2310 data.hours = hours % 24;
2311
2312 days += absRound(hours / 24);
2313 data.days = days % 30;
2314
2315 months += absRound(days / 30);
2316 data.months = months % 12;
2317
2318 years = absRound(months / 12);
2319 data.years = years;
2320 },
2321
2322 weeks : function () {
2323 return absRound(this.days() / 7);
2324 },
2325
2326 valueOf : function () {
2327 return this._milliseconds +
2328 this._days * 864e5 +
2329 (this._months % 12) * 2592e6 +
2330 toInt(this._months / 12) * 31536e6;
2331 },
2332
2333 humanize : function (withSuffix) {
2334 var difference = +this,
2335 output = relativeTime(difference, !withSuffix, this.lang());
2336
2337 if (withSuffix) {
2338 output = this.lang().pastFuture(difference, output);
2339 }
2340
2341 return this.lang().postformat(output);
2342 },
2343
2344 add : function (input, val) {
2345 // supports only 2.0-style add(1, 's') or add(moment)
2346 var dur = moment.duration(input, val);
2347
2348 this._milliseconds += dur._milliseconds;
2349 this._days += dur._days;
2350 this._months += dur._months;
2351
2352 this._bubble();
2353
2354 return this;
2355 },
2356
2357 subtract : function (input, val) {
2358 var dur = moment.duration(input, val);
2359
2360 this._milliseconds -= dur._milliseconds;
2361 this._days -= dur._days;
2362 this._months -= dur._months;
2363
2364 this._bubble();
2365
2366 return this;
2367 },
2368
2369 get : function (units) {
2370 units = normalizeUnits(units);
2371 return this[units.toLowerCase() + 's']();
2372 },
2373
2374 as : function (units) {
2375 units = normalizeUnits(units);
2376 return this['as' + units.charAt(0).toUpperCase() + units.slice(1) + 's']();
2377 },
2378
2379 lang : moment.fn.lang,
2380
2381 toIsoString : function () {
2382 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
2383 var years = Math.abs(this.years()),
2384 months = Math.abs(this.months()),
2385 days = Math.abs(this.days()),
2386 hours = Math.abs(this.hours()),
2387 minutes = Math.abs(this.minutes()),
2388 seconds = Math.abs(this.seconds() + this.milliseconds() / 1000);
2389
2390 if (!this.asSeconds()) {
2391 // this is the same as C#'s (Noda) and python (isodate)...
2392 // but not other JS (goog.date)
2393 return 'P0D';
2394 }
2395
2396 return (this.asSeconds() < 0 ? '-' : '') +
2397 'P' +
2398 (years ? years + 'Y' : '') +
2399 (months ? months + 'M' : '') +
2400 (days ? days + 'D' : '') +
2401 ((hours || minutes || seconds) ? 'T' : '') +
2402 (hours ? hours + 'H' : '') +
2403 (minutes ? minutes + 'M' : '') +
2404 (seconds ? seconds + 'S' : '');
2405 }
2406 });
2407
2408 function makeDurationGetter(name) {
2409 moment.duration.fn[name] = function () {
2410 return this._data[name];
2411 };
2412 }
2413
2414 function makeDurationAsGetter(name, factor) {
2415 moment.duration.fn['as' + name] = function () {
2416 return +this / factor;
2417 };
2418 }
2419
2420 for (i in unitMillisecondFactors) {
2421 if (unitMillisecondFactors.hasOwnProperty(i)) {
2422 makeDurationAsGetter(i, unitMillisecondFactors[i]);
2423 makeDurationGetter(i.toLowerCase());
2424 }
2425 }
2426
2427 makeDurationAsGetter('Weeks', 6048e5);
2428 moment.duration.fn.asMonths = function () {
2429 return (+this - this.years() * 31536e6) / 2592e6 + this.years() * 12;
2430 };
2431
2432
2433 /************************************
2434 Default Lang
2435 ************************************/
2436
2437
2438 // Set default language, other languages will inherit from English.
2439 moment.lang('en', {
2440 ordinal : function (number) {
2441 var b = number % 10,
2442 output = (toInt(number % 100 / 10) === 1) ? 'th' :
2443 (b === 1) ? 'st' :
2444 (b === 2) ? 'nd' :
2445 (b === 3) ? 'rd' : 'th';
2446 return number + output;
2447 }
2448 });
2449
2450 /* EMBED_LANGUAGES */
2451
2452 /************************************
2453 Exposing Moment
2454 ************************************/
2455
2456 function makeGlobal(shouldDeprecate) {
2457 /*global ender:false */
2458 if (typeof ender !== 'undefined') {
2459 return;
2460 }
2461 oldGlobalMoment = globalScope.moment;
2462 if (shouldDeprecate) {
2463 globalScope.moment = deprecate(
2464 "Accessing Moment through the global scope is " +
2465 "deprecated, and will be removed in an upcoming " +
2466 "release.",
2467 moment);
2468 } else {
2469 globalScope.moment = moment;
2470 }
2471 }
2472
2473 // CommonJS module is defined
2474 if (hasModule) {
2475 module.exports = moment;
2476 } else if (typeof define === "function" && define.amd) {
2477 define("moment", function (require, exports, module) {
2478 if (module.config && module.config() && module.config().noGlobal === true) {
2479 // release the global variable
2480 globalScope.moment = oldGlobalMoment;
2481 }
2482
2483 return moment;
2484 });
2485 makeGlobal(true);
2486 } else {
2487 makeGlobal();
2488 }
2489 }).call(this);
MediaWiki Core