Mercurial > hg > NetworkVis

comparison d3s_examples/python-neo4jrestclient/static/platin/lib/momentjs/moment.js @ 8:18ef6948d689

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