js_stack 1.10.0 → 1.11.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (102) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +12 -0
  3. data/README.md +6 -6
  4. data/js_stack.gemspec +0 -1
  5. data/lib/js_stack/version.rb +1 -1
  6. data/lib/js_stack.rb +0 -1
  7. data/vendor/assets/javascripts/js_stack/base/backbone/1.2.3.js +1894 -0
  8. data/vendor/assets/javascripts/js_stack/base/backbone.js +1 -1
  9. data/vendor/assets/javascripts/js_stack/base/marionette/{2.4.1.js → 2.4.3.js} +265 -138
  10. data/vendor/assets/javascripts/js_stack/base/marionette.js +1 -1
  11. data/vendor/assets/javascripts/js_stack/plugins/backbone/stickit/{0.9.0.js → 0.9.2.js} +1 -1
  12. data/vendor/assets/javascripts/js_stack/plugins/backbone.stickit.js +1 -1
  13. data/vendor/assets/javascripts/js_stack/plugins/moment/2.10.6.js +3195 -0
  14. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/af.js +72 -0
  15. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ar-ma.js +58 -0
  16. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ar-sa.js +102 -0
  17. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ar-tn.js +56 -0
  18. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ar.js +135 -0
  19. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/az.js +103 -0
  20. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/be.js +146 -0
  21. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/bg.js +89 -0
  22. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/bn.js +112 -0
  23. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/bo.js +109 -0
  24. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/br.js +106 -0
  25. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/bs.js +140 -0
  26. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ca.js +78 -0
  27. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/cs.js +156 -0
  28. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/cv.js +62 -0
  29. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/cy.js +78 -0
  30. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/da.js +59 -0
  31. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/de-at.js +75 -0
  32. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/de.js +74 -0
  33. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/el.js +93 -0
  34. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/en-au.js +65 -0
  35. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/en-ca.js +62 -0
  36. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/en-gb.js +66 -0
  37. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/eo.js +72 -0
  38. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/es.js +78 -0
  39. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/et.js +79 -0
  40. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/eu.js +63 -0
  41. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/fa.js +104 -0
  42. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/fi.js +106 -0
  43. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/fo.js +59 -0
  44. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/fr-ca.js +57 -0
  45. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/fr.js +61 -0
  46. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/fy.js +70 -0
  47. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/gl.js +74 -0
  48. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/he.js +81 -0
  49. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/hi.js +122 -0
  50. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/hr.js +139 -0
  51. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/hu.js +108 -0
  52. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/hy-am.js +110 -0
  53. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/id.js +82 -0
  54. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/is.js +126 -0
  55. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/it.js +69 -0
  56. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ja.js +64 -0
  57. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/jv.js +82 -0
  58. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ka.js +102 -0
  59. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/km.js +57 -0
  60. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ko.js +67 -0
  61. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/lb.js +133 -0
  62. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/lt.js +124 -0
  63. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/lv.js +95 -0
  64. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/me.js +108 -0
  65. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/mk.js +89 -0
  66. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ml.js +70 -0
  67. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/mr.js +120 -0
  68. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ms-my.js +81 -0
  69. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ms.js +81 -0
  70. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/my.js +92 -0
  71. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/nb.js +60 -0
  72. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ne.js +122 -0
  73. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/nl.js +70 -0
  74. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/nn.js +59 -0
  75. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/pl.js +104 -0
  76. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/pt-br.js +59 -0
  77. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/pt.js +63 -0
  78. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ro.js +73 -0
  79. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ru.js +163 -0
  80. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/si.js +64 -0
  81. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/sk.js +157 -0
  82. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/sl.js +159 -0
  83. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/sq.js +68 -0
  84. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/sr-cyrl.js +107 -0
  85. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/sr.js +107 -0
  86. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/sv.js +66 -0
  87. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/ta.js +94 -0
  88. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/th.js +64 -0
  89. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/tl-ph.js +61 -0
  90. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/tr.js +89 -0
  91. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/tzl.js +84 -0
  92. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/tzm-latn.js +57 -0
  93. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/tzm.js +57 -0
  94. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/uk.js +152 -0
  95. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/uz.js +57 -0
  96. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/vi.js +65 -0
  97. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/zh-cn.js +126 -0
  98. data/vendor/assets/javascripts/js_stack/plugins/moment/locale/zh-tw.js +100 -0
  99. data/vendor/assets/javascripts/js_stack/plugins/moment.js +1 -1
  100. data/vendor/assets/javascripts/js_stack/plugins/underscore/string/3.2.2.js +1186 -0
  101. data/vendor/assets/javascripts/js_stack/plugins/underscore.string.js +1 -1
  102. metadata +93 -20
@@ -0,0 +1,3195 @@
1
+ //! moment.js
2
+ //! version : 2.10.6
3
+ //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
4
+ //! license : MIT
5
+ //! momentjs.com
6
+
7
+ (function (global, factory) {
8
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
9
+ typeof define === 'function' && define.amd ? define(factory) :
10
+ global.moment = factory()
11
+ }(this, function () { 'use strict';
12
+
13
+ var hookCallback;
14
+
15
+ function utils_hooks__hooks () {
16
+ return hookCallback.apply(null, arguments);
17
+ }
18
+
19
+ // This is done to register the method called with moment()
20
+ // without creating circular dependencies.
21
+ function setHookCallback (callback) {
22
+ hookCallback = callback;
23
+ }
24
+
25
+ function isArray(input) {
26
+ return Object.prototype.toString.call(input) === '[object Array]';
27
+ }
28
+
29
+ function isDate(input) {
30
+ return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
31
+ }
32
+
33
+ function map(arr, fn) {
34
+ var res = [], i;
35
+ for (i = 0; i < arr.length; ++i) {
36
+ res.push(fn(arr[i], i));
37
+ }
38
+ return res;
39
+ }
40
+
41
+ function hasOwnProp(a, b) {
42
+ return Object.prototype.hasOwnProperty.call(a, b);
43
+ }
44
+
45
+ function extend(a, b) {
46
+ for (var i in b) {
47
+ if (hasOwnProp(b, i)) {
48
+ a[i] = b[i];
49
+ }
50
+ }
51
+
52
+ if (hasOwnProp(b, 'toString')) {
53
+ a.toString = b.toString;
54
+ }
55
+
56
+ if (hasOwnProp(b, 'valueOf')) {
57
+ a.valueOf = b.valueOf;
58
+ }
59
+
60
+ return a;
61
+ }
62
+
63
+ function create_utc__createUTC (input, format, locale, strict) {
64
+ return createLocalOrUTC(input, format, locale, strict, true).utc();
65
+ }
66
+
67
+ function defaultParsingFlags() {
68
+ // We need to deep clone this object.
69
+ return {
70
+ empty : false,
71
+ unusedTokens : [],
72
+ unusedInput : [],
73
+ overflow : -2,
74
+ charsLeftOver : 0,
75
+ nullInput : false,
76
+ invalidMonth : null,
77
+ invalidFormat : false,
78
+ userInvalidated : false,
79
+ iso : false
80
+ };
81
+ }
82
+
83
+ function getParsingFlags(m) {
84
+ if (m._pf == null) {
85
+ m._pf = defaultParsingFlags();
86
+ }
87
+ return m._pf;
88
+ }
89
+
90
+ function valid__isValid(m) {
91
+ if (m._isValid == null) {
92
+ var flags = getParsingFlags(m);
93
+ m._isValid = !isNaN(m._d.getTime()) &&
94
+ flags.overflow < 0 &&
95
+ !flags.empty &&
96
+ !flags.invalidMonth &&
97
+ !flags.invalidWeekday &&
98
+ !flags.nullInput &&
99
+ !flags.invalidFormat &&
100
+ !flags.userInvalidated;
101
+
102
+ if (m._strict) {
103
+ m._isValid = m._isValid &&
104
+ flags.charsLeftOver === 0 &&
105
+ flags.unusedTokens.length === 0 &&
106
+ flags.bigHour === undefined;
107
+ }
108
+ }
109
+ return m._isValid;
110
+ }
111
+
112
+ function valid__createInvalid (flags) {
113
+ var m = create_utc__createUTC(NaN);
114
+ if (flags != null) {
115
+ extend(getParsingFlags(m), flags);
116
+ }
117
+ else {
118
+ getParsingFlags(m).userInvalidated = true;
119
+ }
120
+
121
+ return m;
122
+ }
123
+
124
+ var momentProperties = utils_hooks__hooks.momentProperties = [];
125
+
126
+ function copyConfig(to, from) {
127
+ var i, prop, val;
128
+
129
+ if (typeof from._isAMomentObject !== 'undefined') {
130
+ to._isAMomentObject = from._isAMomentObject;
131
+ }
132
+ if (typeof from._i !== 'undefined') {
133
+ to._i = from._i;
134
+ }
135
+ if (typeof from._f !== 'undefined') {
136
+ to._f = from._f;
137
+ }
138
+ if (typeof from._l !== 'undefined') {
139
+ to._l = from._l;
140
+ }
141
+ if (typeof from._strict !== 'undefined') {
142
+ to._strict = from._strict;
143
+ }
144
+ if (typeof from._tzm !== 'undefined') {
145
+ to._tzm = from._tzm;
146
+ }
147
+ if (typeof from._isUTC !== 'undefined') {
148
+ to._isUTC = from._isUTC;
149
+ }
150
+ if (typeof from._offset !== 'undefined') {
151
+ to._offset = from._offset;
152
+ }
153
+ if (typeof from._pf !== 'undefined') {
154
+ to._pf = getParsingFlags(from);
155
+ }
156
+ if (typeof from._locale !== 'undefined') {
157
+ to._locale = from._locale;
158
+ }
159
+
160
+ if (momentProperties.length > 0) {
161
+ for (i in momentProperties) {
162
+ prop = momentProperties[i];
163
+ val = from[prop];
164
+ if (typeof val !== 'undefined') {
165
+ to[prop] = val;
166
+ }
167
+ }
168
+ }
169
+
170
+ return to;
171
+ }
172
+
173
+ var updateInProgress = false;
174
+
175
+ // Moment prototype object
176
+ function Moment(config) {
177
+ copyConfig(this, config);
178
+ this._d = new Date(config._d != null ? config._d.getTime() : NaN);
179
+ // Prevent infinite loop in case updateOffset creates new moment
180
+ // objects.
181
+ if (updateInProgress === false) {
182
+ updateInProgress = true;
183
+ utils_hooks__hooks.updateOffset(this);
184
+ updateInProgress = false;
185
+ }
186
+ }
187
+
188
+ function isMoment (obj) {
189
+ return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
190
+ }
191
+
192
+ function absFloor (number) {
193
+ if (number < 0) {
194
+ return Math.ceil(number);
195
+ } else {
196
+ return Math.floor(number);
197
+ }
198
+ }
199
+
200
+ function toInt(argumentForCoercion) {
201
+ var coercedNumber = +argumentForCoercion,
202
+ value = 0;
203
+
204
+ if (coercedNumber !== 0 && isFinite(coercedNumber)) {
205
+ value = absFloor(coercedNumber);
206
+ }
207
+
208
+ return value;
209
+ }
210
+
211
+ function compareArrays(array1, array2, dontConvert) {
212
+ var len = Math.min(array1.length, array2.length),
213
+ lengthDiff = Math.abs(array1.length - array2.length),
214
+ diffs = 0,
215
+ i;
216
+ for (i = 0; i < len; i++) {
217
+ if ((dontConvert && array1[i] !== array2[i]) ||
218
+ (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
219
+ diffs++;
220
+ }
221
+ }
222
+ return diffs + lengthDiff;
223
+ }
224
+
225
+ function Locale() {
226
+ }
227
+
228
+ var locales = {};
229
+ var globalLocale;
230
+
231
+ function normalizeLocale(key) {
232
+ return key ? key.toLowerCase().replace('_', '-') : key;
233
+ }
234
+
235
+ // pick the locale from the array
236
+ // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
237
+ // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
238
+ function chooseLocale(names) {
239
+ var i = 0, j, next, locale, split;
240
+
241
+ while (i < names.length) {
242
+ split = normalizeLocale(names[i]).split('-');
243
+ j = split.length;
244
+ next = normalizeLocale(names[i + 1]);
245
+ next = next ? next.split('-') : null;
246
+ while (j > 0) {
247
+ locale = loadLocale(split.slice(0, j).join('-'));
248
+ if (locale) {
249
+ return locale;
250
+ }
251
+ if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
252
+ //the next array item is better than a shallower substring of this one
253
+ break;
254
+ }
255
+ j--;
256
+ }
257
+ i++;
258
+ }
259
+ return null;
260
+ }
261
+
262
+ function loadLocale(name) {
263
+ var oldLocale = null;
264
+ // TODO: Find a better way to register and load all the locales in Node
265
+ if (!locales[name] && typeof module !== 'undefined' &&
266
+ module && module.exports) {
267
+ try {
268
+ oldLocale = globalLocale._abbr;
269
+ require('./locale/' + name);
270
+ // because defineLocale currently also sets the global locale, we
271
+ // want to undo that for lazy loaded locales
272
+ locale_locales__getSetGlobalLocale(oldLocale);
273
+ } catch (e) { }
274
+ }
275
+ return locales[name];
276
+ }
277
+
278
+ // This function will load locale and then set the global locale. If
279
+ // no arguments are passed in, it will simply return the current global
280
+ // locale key.
281
+ function locale_locales__getSetGlobalLocale (key, values) {
282
+ var data;
283
+ if (key) {
284
+ if (typeof values === 'undefined') {
285
+ data = locale_locales__getLocale(key);
286
+ }
287
+ else {
288
+ data = defineLocale(key, values);
289
+ }
290
+
291
+ if (data) {
292
+ // moment.duration._locale = moment._locale = data;
293
+ globalLocale = data;
294
+ }
295
+ }
296
+
297
+ return globalLocale._abbr;
298
+ }
299
+
300
+ function defineLocale (name, values) {
301
+ if (values !== null) {
302
+ values.abbr = name;
303
+ locales[name] = locales[name] || new Locale();
304
+ locales[name].set(values);
305
+
306
+ // backwards compat for now: also set the locale
307
+ locale_locales__getSetGlobalLocale(name);
308
+
309
+ return locales[name];
310
+ } else {
311
+ // useful for testing
312
+ delete locales[name];
313
+ return null;
314
+ }
315
+ }
316
+
317
+ // returns locale data
318
+ function locale_locales__getLocale (key) {
319
+ var locale;
320
+
321
+ if (key && key._locale && key._locale._abbr) {
322
+ key = key._locale._abbr;
323
+ }
324
+
325
+ if (!key) {
326
+ return globalLocale;
327
+ }
328
+
329
+ if (!isArray(key)) {
330
+ //short-circuit everything else
331
+ locale = loadLocale(key);
332
+ if (locale) {
333
+ return locale;
334
+ }
335
+ key = [key];
336
+ }
337
+
338
+ return chooseLocale(key);
339
+ }
340
+
341
+ var aliases = {};
342
+
343
+ function addUnitAlias (unit, shorthand) {
344
+ var lowerCase = unit.toLowerCase();
345
+ aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
346
+ }
347
+
348
+ function normalizeUnits(units) {
349
+ return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
350
+ }
351
+
352
+ function normalizeObjectUnits(inputObject) {
353
+ var normalizedInput = {},
354
+ normalizedProp,
355
+ prop;
356
+
357
+ for (prop in inputObject) {
358
+ if (hasOwnProp(inputObject, prop)) {
359
+ normalizedProp = normalizeUnits(prop);
360
+ if (normalizedProp) {
361
+ normalizedInput[normalizedProp] = inputObject[prop];
362
+ }
363
+ }
364
+ }
365
+
366
+ return normalizedInput;
367
+ }
368
+
369
+ function makeGetSet (unit, keepTime) {
370
+ return function (value) {
371
+ if (value != null) {
372
+ get_set__set(this, unit, value);
373
+ utils_hooks__hooks.updateOffset(this, keepTime);
374
+ return this;
375
+ } else {
376
+ return get_set__get(this, unit);
377
+ }
378
+ };
379
+ }
380
+
381
+ function get_set__get (mom, unit) {
382
+ return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
383
+ }
384
+
385
+ function get_set__set (mom, unit, value) {
386
+ return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
387
+ }
388
+
389
+ // MOMENTS
390
+
391
+ function getSet (units, value) {
392
+ var unit;
393
+ if (typeof units === 'object') {
394
+ for (unit in units) {
395
+ this.set(unit, units[unit]);
396
+ }
397
+ } else {
398
+ units = normalizeUnits(units);
399
+ if (typeof this[units] === 'function') {
400
+ return this[units](value);
401
+ }
402
+ }
403
+ return this;
404
+ }
405
+
406
+ function zeroFill(number, targetLength, forceSign) {
407
+ var absNumber = '' + Math.abs(number),
408
+ zerosToFill = targetLength - absNumber.length,
409
+ sign = number >= 0;
410
+ return (sign ? (forceSign ? '+' : '') : '-') +
411
+ Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
412
+ }
413
+
414
+ var 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,9}|x|X|zz?|ZZ?|.)/g;
415
+
416
+ var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
417
+
418
+ var formatFunctions = {};
419
+
420
+ var formatTokenFunctions = {};
421
+
422
+ // token: 'M'
423
+ // padded: ['MM', 2]
424
+ // ordinal: 'Mo'
425
+ // callback: function () { this.month() + 1 }
426
+ function addFormatToken (token, padded, ordinal, callback) {
427
+ var func = callback;
428
+ if (typeof callback === 'string') {
429
+ func = function () {
430
+ return this[callback]();
431
+ };
432
+ }
433
+ if (token) {
434
+ formatTokenFunctions[token] = func;
435
+ }
436
+ if (padded) {
437
+ formatTokenFunctions[padded[0]] = function () {
438
+ return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
439
+ };
440
+ }
441
+ if (ordinal) {
442
+ formatTokenFunctions[ordinal] = function () {
443
+ return this.localeData().ordinal(func.apply(this, arguments), token);
444
+ };
445
+ }
446
+ }
447
+
448
+ function removeFormattingTokens(input) {
449
+ if (input.match(/\[[\s\S]/)) {
450
+ return input.replace(/^\[|\]$/g, '');
451
+ }
452
+ return input.replace(/\\/g, '');
453
+ }
454
+
455
+ function makeFormatFunction(format) {
456
+ var array = format.match(formattingTokens), i, length;
457
+
458
+ for (i = 0, length = array.length; i < length; i++) {
459
+ if (formatTokenFunctions[array[i]]) {
460
+ array[i] = formatTokenFunctions[array[i]];
461
+ } else {
462
+ array[i] = removeFormattingTokens(array[i]);
463
+ }
464
+ }
465
+
466
+ return function (mom) {
467
+ var output = '';
468
+ for (i = 0; i < length; i++) {
469
+ output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
470
+ }
471
+ return output;
472
+ };
473
+ }
474
+
475
+ // format date using native date object
476
+ function formatMoment(m, format) {
477
+ if (!m.isValid()) {
478
+ return m.localeData().invalidDate();
479
+ }
480
+
481
+ format = expandFormat(format, m.localeData());
482
+ formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
483
+
484
+ return formatFunctions[format](m);
485
+ }
486
+
487
+ function expandFormat(format, locale) {
488
+ var i = 5;
489
+
490
+ function replaceLongDateFormatTokens(input) {
491
+ return locale.longDateFormat(input) || input;
492
+ }
493
+
494
+ localFormattingTokens.lastIndex = 0;
495
+ while (i >= 0 && localFormattingTokens.test(format)) {
496
+ format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
497
+ localFormattingTokens.lastIndex = 0;
498
+ i -= 1;
499
+ }
500
+
501
+ return format;
502
+ }
503
+
504
+ var match1 = /\d/; // 0 - 9
505
+ var match2 = /\d\d/; // 00 - 99
506
+ var match3 = /\d{3}/; // 000 - 999
507
+ var match4 = /\d{4}/; // 0000 - 9999
508
+ var match6 = /[+-]?\d{6}/; // -999999 - 999999
509
+ var match1to2 = /\d\d?/; // 0 - 99
510
+ var match1to3 = /\d{1,3}/; // 0 - 999
511
+ var match1to4 = /\d{1,4}/; // 0 - 9999
512
+ var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
513
+
514
+ var matchUnsigned = /\d+/; // 0 - inf
515
+ var matchSigned = /[+-]?\d+/; // -inf - inf
516
+
517
+ var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
518
+
519
+ var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
520
+
521
+ // any word (or two) characters or numbers including two/three word month in arabic.
522
+ var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
523
+
524
+ var regexes = {};
525
+
526
+ function isFunction (sth) {
527
+ // https://github.com/moment/moment/issues/2325
528
+ return typeof sth === 'function' &&
529
+ Object.prototype.toString.call(sth) === '[object Function]';
530
+ }
531
+
532
+
533
+ function addRegexToken (token, regex, strictRegex) {
534
+ regexes[token] = isFunction(regex) ? regex : function (isStrict) {
535
+ return (isStrict && strictRegex) ? strictRegex : regex;
536
+ };
537
+ }
538
+
539
+ function getParseRegexForToken (token, config) {
540
+ if (!hasOwnProp(regexes, token)) {
541
+ return new RegExp(unescapeFormat(token));
542
+ }
543
+
544
+ return regexes[token](config._strict, config._locale);
545
+ }
546
+
547
+ // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
548
+ function unescapeFormat(s) {
549
+ return s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
550
+ return p1 || p2 || p3 || p4;
551
+ }).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
552
+ }
553
+
554
+ var tokens = {};
555
+
556
+ function addParseToken (token, callback) {
557
+ var i, func = callback;
558
+ if (typeof token === 'string') {
559
+ token = [token];
560
+ }
561
+ if (typeof callback === 'number') {
562
+ func = function (input, array) {
563
+ array[callback] = toInt(input);
564
+ };
565
+ }
566
+ for (i = 0; i < token.length; i++) {
567
+ tokens[token[i]] = func;
568
+ }
569
+ }
570
+
571
+ function addWeekParseToken (token, callback) {
572
+ addParseToken(token, function (input, array, config, token) {
573
+ config._w = config._w || {};
574
+ callback(input, config._w, config, token);
575
+ });
576
+ }
577
+
578
+ function addTimeToArrayFromToken(token, input, config) {
579
+ if (input != null && hasOwnProp(tokens, token)) {
580
+ tokens[token](input, config._a, config, token);
581
+ }
582
+ }
583
+
584
+ var YEAR = 0;
585
+ var MONTH = 1;
586
+ var DATE = 2;
587
+ var HOUR = 3;
588
+ var MINUTE = 4;
589
+ var SECOND = 5;
590
+ var MILLISECOND = 6;
591
+
592
+ function daysInMonth(year, month) {
593
+ return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
594
+ }
595
+
596
+ // FORMATTING
597
+
598
+ addFormatToken('M', ['MM', 2], 'Mo', function () {
599
+ return this.month() + 1;
600
+ });
601
+
602
+ addFormatToken('MMM', 0, 0, function (format) {
603
+ return this.localeData().monthsShort(this, format);
604
+ });
605
+
606
+ addFormatToken('MMMM', 0, 0, function (format) {
607
+ return this.localeData().months(this, format);
608
+ });
609
+
610
+ // ALIASES
611
+
612
+ addUnitAlias('month', 'M');
613
+
614
+ // PARSING
615
+
616
+ addRegexToken('M', match1to2);
617
+ addRegexToken('MM', match1to2, match2);
618
+ addRegexToken('MMM', matchWord);
619
+ addRegexToken('MMMM', matchWord);
620
+
621
+ addParseToken(['M', 'MM'], function (input, array) {
622
+ array[MONTH] = toInt(input) - 1;
623
+ });
624
+
625
+ addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
626
+ var month = config._locale.monthsParse(input, token, config._strict);
627
+ // if we didn't find a month name, mark the date as invalid.
628
+ if (month != null) {
629
+ array[MONTH] = month;
630
+ } else {
631
+ getParsingFlags(config).invalidMonth = input;
632
+ }
633
+ });
634
+
635
+ // LOCALES
636
+
637
+ var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
638
+ function localeMonths (m) {
639
+ return this._months[m.month()];
640
+ }
641
+
642
+ var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
643
+ function localeMonthsShort (m) {
644
+ return this._monthsShort[m.month()];
645
+ }
646
+
647
+ function localeMonthsParse (monthName, format, strict) {
648
+ var i, mom, regex;
649
+
650
+ if (!this._monthsParse) {
651
+ this._monthsParse = [];
652
+ this._longMonthsParse = [];
653
+ this._shortMonthsParse = [];
654
+ }
655
+
656
+ for (i = 0; i < 12; i++) {
657
+ // make the regex if we don't have it already
658
+ mom = create_utc__createUTC([2000, i]);
659
+ if (strict && !this._longMonthsParse[i]) {
660
+ this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
661
+ this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
662
+ }
663
+ if (!strict && !this._monthsParse[i]) {
664
+ regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
665
+ this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
666
+ }
667
+ // test the regex
668
+ if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
669
+ return i;
670
+ } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
671
+ return i;
672
+ } else if (!strict && this._monthsParse[i].test(monthName)) {
673
+ return i;
674
+ }
675
+ }
676
+ }
677
+
678
+ // MOMENTS
679
+
680
+ function setMonth (mom, value) {
681
+ var dayOfMonth;
682
+
683
+ // TODO: Move this out of here!
684
+ if (typeof value === 'string') {
685
+ value = mom.localeData().monthsParse(value);
686
+ // TODO: Another silent failure?
687
+ if (typeof value !== 'number') {
688
+ return mom;
689
+ }
690
+ }
691
+
692
+ dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
693
+ mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
694
+ return mom;
695
+ }
696
+
697
+ function getSetMonth (value) {
698
+ if (value != null) {
699
+ setMonth(this, value);
700
+ utils_hooks__hooks.updateOffset(this, true);
701
+ return this;
702
+ } else {
703
+ return get_set__get(this, 'Month');
704
+ }
705
+ }
706
+
707
+ function getDaysInMonth () {
708
+ return daysInMonth(this.year(), this.month());
709
+ }
710
+
711
+ function checkOverflow (m) {
712
+ var overflow;
713
+ var a = m._a;
714
+
715
+ if (a && getParsingFlags(m).overflow === -2) {
716
+ overflow =
717
+ a[MONTH] < 0 || a[MONTH] > 11 ? MONTH :
718
+ a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
719
+ a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
720
+ a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE :
721
+ a[SECOND] < 0 || a[SECOND] > 59 ? SECOND :
722
+ a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
723
+ -1;
724
+
725
+ if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
726
+ overflow = DATE;
727
+ }
728
+
729
+ getParsingFlags(m).overflow = overflow;
730
+ }
731
+
732
+ return m;
733
+ }
734
+
735
+ function warn(msg) {
736
+ if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
737
+ console.warn('Deprecation warning: ' + msg);
738
+ }
739
+ }
740
+
741
+ function deprecate(msg, fn) {
742
+ var firstTime = true;
743
+
744
+ return extend(function () {
745
+ if (firstTime) {
746
+ warn(msg + '\n' + (new Error()).stack);
747
+ firstTime = false;
748
+ }
749
+ return fn.apply(this, arguments);
750
+ }, fn);
751
+ }
752
+
753
+ var deprecations = {};
754
+
755
+ function deprecateSimple(name, msg) {
756
+ if (!deprecations[name]) {
757
+ warn(msg);
758
+ deprecations[name] = true;
759
+ }
760
+ }
761
+
762
+ utils_hooks__hooks.suppressDeprecationWarnings = false;
763
+
764
+ var from_string__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)?)?$/;
765
+
766
+ var isoDates = [
767
+ ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
768
+ ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
769
+ ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
770
+ ['GGGG-[W]WW', /\d{4}-W\d{2}/],
771
+ ['YYYY-DDD', /\d{4}-\d{3}/]
772
+ ];
773
+
774
+ // iso time formats and regexes
775
+ var isoTimes = [
776
+ ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
777
+ ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
778
+ ['HH:mm', /(T| )\d\d:\d\d/],
779
+ ['HH', /(T| )\d\d/]
780
+ ];
781
+
782
+ var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
783
+
784
+ // date from iso format
785
+ function configFromISO(config) {
786
+ var i, l,
787
+ string = config._i,
788
+ match = from_string__isoRegex.exec(string);
789
+
790
+ if (match) {
791
+ getParsingFlags(config).iso = true;
792
+ for (i = 0, l = isoDates.length; i < l; i++) {
793
+ if (isoDates[i][1].exec(string)) {
794
+ config._f = isoDates[i][0];
795
+ break;
796
+ }
797
+ }
798
+ for (i = 0, l = isoTimes.length; i < l; i++) {
799
+ if (isoTimes[i][1].exec(string)) {
800
+ // match[6] should be 'T' or space
801
+ config._f += (match[6] || ' ') + isoTimes[i][0];
802
+ break;
803
+ }
804
+ }
805
+ if (string.match(matchOffset)) {
806
+ config._f += 'Z';
807
+ }
808
+ configFromStringAndFormat(config);
809
+ } else {
810
+ config._isValid = false;
811
+ }
812
+ }
813
+
814
+ // date from iso format or fallback
815
+ function configFromString(config) {
816
+ var matched = aspNetJsonRegex.exec(config._i);
817
+
818
+ if (matched !== null) {
819
+ config._d = new Date(+matched[1]);
820
+ return;
821
+ }
822
+
823
+ configFromISO(config);
824
+ if (config._isValid === false) {
825
+ delete config._isValid;
826
+ utils_hooks__hooks.createFromInputFallback(config);
827
+ }
828
+ }
829
+
830
+ utils_hooks__hooks.createFromInputFallback = deprecate(
831
+ 'moment construction falls back to js Date. This is ' +
832
+ 'discouraged and will be removed in upcoming major ' +
833
+ 'release. Please refer to ' +
834
+ 'https://github.com/moment/moment/issues/1407 for more info.',
835
+ function (config) {
836
+ config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
837
+ }
838
+ );
839
+
840
+ function createDate (y, m, d, h, M, s, ms) {
841
+ //can't just apply() to create a date:
842
+ //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
843
+ var date = new Date(y, m, d, h, M, s, ms);
844
+
845
+ //the date constructor doesn't accept years < 1970
846
+ if (y < 1970) {
847
+ date.setFullYear(y);
848
+ }
849
+ return date;
850
+ }
851
+
852
+ function createUTCDate (y) {
853
+ var date = new Date(Date.UTC.apply(null, arguments));
854
+ if (y < 1970) {
855
+ date.setUTCFullYear(y);
856
+ }
857
+ return date;
858
+ }
859
+
860
+ addFormatToken(0, ['YY', 2], 0, function () {
861
+ return this.year() % 100;
862
+ });
863
+
864
+ addFormatToken(0, ['YYYY', 4], 0, 'year');
865
+ addFormatToken(0, ['YYYYY', 5], 0, 'year');
866
+ addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
867
+
868
+ // ALIASES
869
+
870
+ addUnitAlias('year', 'y');
871
+
872
+ // PARSING
873
+
874
+ addRegexToken('Y', matchSigned);
875
+ addRegexToken('YY', match1to2, match2);
876
+ addRegexToken('YYYY', match1to4, match4);
877
+ addRegexToken('YYYYY', match1to6, match6);
878
+ addRegexToken('YYYYYY', match1to6, match6);
879
+
880
+ addParseToken(['YYYYY', 'YYYYYY'], YEAR);
881
+ addParseToken('YYYY', function (input, array) {
882
+ array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input);
883
+ });
884
+ addParseToken('YY', function (input, array) {
885
+ array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
886
+ });
887
+
888
+ // HELPERS
889
+
890
+ function daysInYear(year) {
891
+ return isLeapYear(year) ? 366 : 365;
892
+ }
893
+
894
+ function isLeapYear(year) {
895
+ return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
896
+ }
897
+
898
+ // HOOKS
899
+
900
+ utils_hooks__hooks.parseTwoDigitYear = function (input) {
901
+ return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
902
+ };
903
+
904
+ // MOMENTS
905
+
906
+ var getSetYear = makeGetSet('FullYear', false);
907
+
908
+ function getIsLeapYear () {
909
+ return isLeapYear(this.year());
910
+ }
911
+
912
+ addFormatToken('w', ['ww', 2], 'wo', 'week');
913
+ addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
914
+
915
+ // ALIASES
916
+
917
+ addUnitAlias('week', 'w');
918
+ addUnitAlias('isoWeek', 'W');
919
+
920
+ // PARSING
921
+
922
+ addRegexToken('w', match1to2);
923
+ addRegexToken('ww', match1to2, match2);
924
+ addRegexToken('W', match1to2);
925
+ addRegexToken('WW', match1to2, match2);
926
+
927
+ addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
928
+ week[token.substr(0, 1)] = toInt(input);
929
+ });
930
+
931
+ // HELPERS
932
+
933
+ // firstDayOfWeek 0 = sun, 6 = sat
934
+ // the day of the week that starts the week
935
+ // (usually sunday or monday)
936
+ // firstDayOfWeekOfYear 0 = sun, 6 = sat
937
+ // the first week is the week that contains the first
938
+ // of this day of the week
939
+ // (eg. ISO weeks use thursday (4))
940
+ function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
941
+ var end = firstDayOfWeekOfYear - firstDayOfWeek,
942
+ daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
943
+ adjustedMoment;
944
+
945
+
946
+ if (daysToDayOfWeek > end) {
947
+ daysToDayOfWeek -= 7;
948
+ }
949
+
950
+ if (daysToDayOfWeek < end - 7) {
951
+ daysToDayOfWeek += 7;
952
+ }
953
+
954
+ adjustedMoment = local__createLocal(mom).add(daysToDayOfWeek, 'd');
955
+ return {
956
+ week: Math.ceil(adjustedMoment.dayOfYear() / 7),
957
+ year: adjustedMoment.year()
958
+ };
959
+ }
960
+
961
+ // LOCALES
962
+
963
+ function localeWeek (mom) {
964
+ return weekOfYear(mom, this._week.dow, this._week.doy).week;
965
+ }
966
+
967
+ var defaultLocaleWeek = {
968
+ dow : 0, // Sunday is the first day of the week.
969
+ doy : 6 // The week that contains Jan 1st is the first week of the year.
970
+ };
971
+
972
+ function localeFirstDayOfWeek () {
973
+ return this._week.dow;
974
+ }
975
+
976
+ function localeFirstDayOfYear () {
977
+ return this._week.doy;
978
+ }
979
+
980
+ // MOMENTS
981
+
982
+ function getSetWeek (input) {
983
+ var week = this.localeData().week(this);
984
+ return input == null ? week : this.add((input - week) * 7, 'd');
985
+ }
986
+
987
+ function getSetISOWeek (input) {
988
+ var week = weekOfYear(this, 1, 4).week;
989
+ return input == null ? week : this.add((input - week) * 7, 'd');
990
+ }
991
+
992
+ addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
993
+
994
+ // ALIASES
995
+
996
+ addUnitAlias('dayOfYear', 'DDD');
997
+
998
+ // PARSING
999
+
1000
+ addRegexToken('DDD', match1to3);
1001
+ addRegexToken('DDDD', match3);
1002
+ addParseToken(['DDD', 'DDDD'], function (input, array, config) {
1003
+ config._dayOfYear = toInt(input);
1004
+ });
1005
+
1006
+ // HELPERS
1007
+
1008
+ //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1009
+ function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
1010
+ var week1Jan = 6 + firstDayOfWeek - firstDayOfWeekOfYear, janX = createUTCDate(year, 0, 1 + week1Jan), d = janX.getUTCDay(), dayOfYear;
1011
+ if (d < firstDayOfWeek) {
1012
+ d += 7;
1013
+ }
1014
+
1015
+ weekday = weekday != null ? 1 * weekday : firstDayOfWeek;
1016
+
1017
+ dayOfYear = 1 + week1Jan + 7 * (week - 1) - d + weekday;
1018
+
1019
+ return {
1020
+ year: dayOfYear > 0 ? year : year - 1,
1021
+ dayOfYear: dayOfYear > 0 ? dayOfYear : daysInYear(year - 1) + dayOfYear
1022
+ };
1023
+ }
1024
+
1025
+ // MOMENTS
1026
+
1027
+ function getSetDayOfYear (input) {
1028
+ var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
1029
+ return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
1030
+ }
1031
+
1032
+ // Pick the first defined of two or three arguments.
1033
+ function defaults(a, b, c) {
1034
+ if (a != null) {
1035
+ return a;
1036
+ }
1037
+ if (b != null) {
1038
+ return b;
1039
+ }
1040
+ return c;
1041
+ }
1042
+
1043
+ function currentDateArray(config) {
1044
+ var now = new Date();
1045
+ if (config._useUTC) {
1046
+ return [now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()];
1047
+ }
1048
+ return [now.getFullYear(), now.getMonth(), now.getDate()];
1049
+ }
1050
+
1051
+ // convert an array to a date.
1052
+ // the array should mirror the parameters below
1053
+ // note: all values past the year are optional and will default to the lowest possible value.
1054
+ // [year, month, day , hour, minute, second, millisecond]
1055
+ function configFromArray (config) {
1056
+ var i, date, input = [], currentDate, yearToUse;
1057
+
1058
+ if (config._d) {
1059
+ return;
1060
+ }
1061
+
1062
+ currentDate = currentDateArray(config);
1063
+
1064
+ //compute day of the year from weeks and weekdays
1065
+ if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
1066
+ dayOfYearFromWeekInfo(config);
1067
+ }
1068
+
1069
+ //if the day of the year is set, figure out what it is
1070
+ if (config._dayOfYear) {
1071
+ yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
1072
+
1073
+ if (config._dayOfYear > daysInYear(yearToUse)) {
1074
+ getParsingFlags(config)._overflowDayOfYear = true;
1075
+ }
1076
+
1077
+ date = createUTCDate(yearToUse, 0, config._dayOfYear);
1078
+ config._a[MONTH] = date.getUTCMonth();
1079
+ config._a[DATE] = date.getUTCDate();
1080
+ }
1081
+
1082
+ // Default to current date.
1083
+ // * if no year, month, day of month are given, default to today
1084
+ // * if day of month is given, default month and year
1085
+ // * if month is given, default only year
1086
+ // * if year is given, don't default anything
1087
+ for (i = 0; i < 3 && config._a[i] == null; ++i) {
1088
+ config._a[i] = input[i] = currentDate[i];
1089
+ }
1090
+
1091
+ // Zero out whatever was not defaulted, including time
1092
+ for (; i < 7; i++) {
1093
+ config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
1094
+ }
1095
+
1096
+ // Check for 24:00:00.000
1097
+ if (config._a[HOUR] === 24 &&
1098
+ config._a[MINUTE] === 0 &&
1099
+ config._a[SECOND] === 0 &&
1100
+ config._a[MILLISECOND] === 0) {
1101
+ config._nextDay = true;
1102
+ config._a[HOUR] = 0;
1103
+ }
1104
+
1105
+ config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
1106
+ // Apply timezone offset from input. The actual utcOffset can be changed
1107
+ // with parseZone.
1108
+ if (config._tzm != null) {
1109
+ config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
1110
+ }
1111
+
1112
+ if (config._nextDay) {
1113
+ config._a[HOUR] = 24;
1114
+ }
1115
+ }
1116
+
1117
+ function dayOfYearFromWeekInfo(config) {
1118
+ var w, weekYear, week, weekday, dow, doy, temp;
1119
+
1120
+ w = config._w;
1121
+ if (w.GG != null || w.W != null || w.E != null) {
1122
+ dow = 1;
1123
+ doy = 4;
1124
+
1125
+ // TODO: We need to take the current isoWeekYear, but that depends on
1126
+ // how we interpret now (local, utc, fixed offset). So create
1127
+ // a now version of current config (take local/utc/offset flags, and
1128
+ // create now).
1129
+ weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
1130
+ week = defaults(w.W, 1);
1131
+ weekday = defaults(w.E, 1);
1132
+ } else {
1133
+ dow = config._locale._week.dow;
1134
+ doy = config._locale._week.doy;
1135
+
1136
+ weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
1137
+ week = defaults(w.w, 1);
1138
+
1139
+ if (w.d != null) {
1140
+ // weekday -- low day numbers are considered next week
1141
+ weekday = w.d;
1142
+ if (weekday < dow) {
1143
+ ++week;
1144
+ }
1145
+ } else if (w.e != null) {
1146
+ // local weekday -- counting starts from begining of week
1147
+ weekday = w.e + dow;
1148
+ } else {
1149
+ // default to begining of week
1150
+ weekday = dow;
1151
+ }
1152
+ }
1153
+ temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
1154
+
1155
+ config._a[YEAR] = temp.year;
1156
+ config._dayOfYear = temp.dayOfYear;
1157
+ }
1158
+
1159
+ utils_hooks__hooks.ISO_8601 = function () {};
1160
+
1161
+ // date from string and format string
1162
+ function configFromStringAndFormat(config) {
1163
+ // TODO: Move this to another part of the creation flow to prevent circular deps
1164
+ if (config._f === utils_hooks__hooks.ISO_8601) {
1165
+ configFromISO(config);
1166
+ return;
1167
+ }
1168
+
1169
+ config._a = [];
1170
+ getParsingFlags(config).empty = true;
1171
+
1172
+ // This array is used to make a Date, either with `new Date` or `Date.UTC`
1173
+ var string = '' + config._i,
1174
+ i, parsedInput, tokens, token, skipped,
1175
+ stringLength = string.length,
1176
+ totalParsedInputLength = 0;
1177
+
1178
+ tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
1179
+
1180
+ for (i = 0; i < tokens.length; i++) {
1181
+ token = tokens[i];
1182
+ parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
1183
+ if (parsedInput) {
1184
+ skipped = string.substr(0, string.indexOf(parsedInput));
1185
+ if (skipped.length > 0) {
1186
+ getParsingFlags(config).unusedInput.push(skipped);
1187
+ }
1188
+ string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
1189
+ totalParsedInputLength += parsedInput.length;
1190
+ }
1191
+ // don't parse if it's not a known token
1192
+ if (formatTokenFunctions[token]) {
1193
+ if (parsedInput) {
1194
+ getParsingFlags(config).empty = false;
1195
+ }
1196
+ else {
1197
+ getParsingFlags(config).unusedTokens.push(token);
1198
+ }
1199
+ addTimeToArrayFromToken(token, parsedInput, config);
1200
+ }
1201
+ else if (config._strict && !parsedInput) {
1202
+ getParsingFlags(config).unusedTokens.push(token);
1203
+ }
1204
+ }
1205
+
1206
+ // add remaining unparsed input length to the string
1207
+ getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
1208
+ if (string.length > 0) {
1209
+ getParsingFlags(config).unusedInput.push(string);
1210
+ }
1211
+
1212
+ // clear _12h flag if hour is <= 12
1213
+ if (getParsingFlags(config).bigHour === true &&
1214
+ config._a[HOUR] <= 12 &&
1215
+ config._a[HOUR] > 0) {
1216
+ getParsingFlags(config).bigHour = undefined;
1217
+ }
1218
+ // handle meridiem
1219
+ config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
1220
+
1221
+ configFromArray(config);
1222
+ checkOverflow(config);
1223
+ }
1224
+
1225
+
1226
+ function meridiemFixWrap (locale, hour, meridiem) {
1227
+ var isPm;
1228
+
1229
+ if (meridiem == null) {
1230
+ // nothing to do
1231
+ return hour;
1232
+ }
1233
+ if (locale.meridiemHour != null) {
1234
+ return locale.meridiemHour(hour, meridiem);
1235
+ } else if (locale.isPM != null) {
1236
+ // Fallback
1237
+ isPm = locale.isPM(meridiem);
1238
+ if (isPm && hour < 12) {
1239
+ hour += 12;
1240
+ }
1241
+ if (!isPm && hour === 12) {
1242
+ hour = 0;
1243
+ }
1244
+ return hour;
1245
+ } else {
1246
+ // this is not supposed to happen
1247
+ return hour;
1248
+ }
1249
+ }
1250
+
1251
+ function configFromStringAndArray(config) {
1252
+ var tempConfig,
1253
+ bestMoment,
1254
+
1255
+ scoreToBeat,
1256
+ i,
1257
+ currentScore;
1258
+
1259
+ if (config._f.length === 0) {
1260
+ getParsingFlags(config).invalidFormat = true;
1261
+ config._d = new Date(NaN);
1262
+ return;
1263
+ }
1264
+
1265
+ for (i = 0; i < config._f.length; i++) {
1266
+ currentScore = 0;
1267
+ tempConfig = copyConfig({}, config);
1268
+ if (config._useUTC != null) {
1269
+ tempConfig._useUTC = config._useUTC;
1270
+ }
1271
+ tempConfig._f = config._f[i];
1272
+ configFromStringAndFormat(tempConfig);
1273
+
1274
+ if (!valid__isValid(tempConfig)) {
1275
+ continue;
1276
+ }
1277
+
1278
+ // if there is any input that was not parsed add a penalty for that format
1279
+ currentScore += getParsingFlags(tempConfig).charsLeftOver;
1280
+
1281
+ //or tokens
1282
+ currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
1283
+
1284
+ getParsingFlags(tempConfig).score = currentScore;
1285
+
1286
+ if (scoreToBeat == null || currentScore < scoreToBeat) {
1287
+ scoreToBeat = currentScore;
1288
+ bestMoment = tempConfig;
1289
+ }
1290
+ }
1291
+
1292
+ extend(config, bestMoment || tempConfig);
1293
+ }
1294
+
1295
+ function configFromObject(config) {
1296
+ if (config._d) {
1297
+ return;
1298
+ }
1299
+
1300
+ var i = normalizeObjectUnits(config._i);
1301
+ config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond];
1302
+
1303
+ configFromArray(config);
1304
+ }
1305
+
1306
+ function createFromConfig (config) {
1307
+ var res = new Moment(checkOverflow(prepareConfig(config)));
1308
+ if (res._nextDay) {
1309
+ // Adding is smart enough around DST
1310
+ res.add(1, 'd');
1311
+ res._nextDay = undefined;
1312
+ }
1313
+
1314
+ return res;
1315
+ }
1316
+
1317
+ function prepareConfig (config) {
1318
+ var input = config._i,
1319
+ format = config._f;
1320
+
1321
+ config._locale = config._locale || locale_locales__getLocale(config._l);
1322
+
1323
+ if (input === null || (format === undefined && input === '')) {
1324
+ return valid__createInvalid({nullInput: true});
1325
+ }
1326
+
1327
+ if (typeof input === 'string') {
1328
+ config._i = input = config._locale.preparse(input);
1329
+ }
1330
+
1331
+ if (isMoment(input)) {
1332
+ return new Moment(checkOverflow(input));
1333
+ } else if (isArray(format)) {
1334
+ configFromStringAndArray(config);
1335
+ } else if (format) {
1336
+ configFromStringAndFormat(config);
1337
+ } else if (isDate(input)) {
1338
+ config._d = input;
1339
+ } else {
1340
+ configFromInput(config);
1341
+ }
1342
+
1343
+ return config;
1344
+ }
1345
+
1346
+ function configFromInput(config) {
1347
+ var input = config._i;
1348
+ if (input === undefined) {
1349
+ config._d = new Date();
1350
+ } else if (isDate(input)) {
1351
+ config._d = new Date(+input);
1352
+ } else if (typeof input === 'string') {
1353
+ configFromString(config);
1354
+ } else if (isArray(input)) {
1355
+ config._a = map(input.slice(0), function (obj) {
1356
+ return parseInt(obj, 10);
1357
+ });
1358
+ configFromArray(config);
1359
+ } else if (typeof(input) === 'object') {
1360
+ configFromObject(config);
1361
+ } else if (typeof(input) === 'number') {
1362
+ // from milliseconds
1363
+ config._d = new Date(input);
1364
+ } else {
1365
+ utils_hooks__hooks.createFromInputFallback(config);
1366
+ }
1367
+ }
1368
+
1369
+ function createLocalOrUTC (input, format, locale, strict, isUTC) {
1370
+ var c = {};
1371
+
1372
+ if (typeof(locale) === 'boolean') {
1373
+ strict = locale;
1374
+ locale = undefined;
1375
+ }
1376
+ // object construction must be done this way.
1377
+ // https://github.com/moment/moment/issues/1423
1378
+ c._isAMomentObject = true;
1379
+ c._useUTC = c._isUTC = isUTC;
1380
+ c._l = locale;
1381
+ c._i = input;
1382
+ c._f = format;
1383
+ c._strict = strict;
1384
+
1385
+ return createFromConfig(c);
1386
+ }
1387
+
1388
+ function local__createLocal (input, format, locale, strict) {
1389
+ return createLocalOrUTC(input, format, locale, strict, false);
1390
+ }
1391
+
1392
+ var prototypeMin = deprecate(
1393
+ 'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
1394
+ function () {
1395
+ var other = local__createLocal.apply(null, arguments);
1396
+ return other < this ? this : other;
1397
+ }
1398
+ );
1399
+
1400
+ var prototypeMax = deprecate(
1401
+ 'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
1402
+ function () {
1403
+ var other = local__createLocal.apply(null, arguments);
1404
+ return other > this ? this : other;
1405
+ }
1406
+ );
1407
+
1408
+ // Pick a moment m from moments so that m[fn](other) is true for all
1409
+ // other. This relies on the function fn to be transitive.
1410
+ //
1411
+ // moments should either be an array of moment objects or an array, whose
1412
+ // first element is an array of moment objects.
1413
+ function pickBy(fn, moments) {
1414
+ var res, i;
1415
+ if (moments.length === 1 && isArray(moments[0])) {
1416
+ moments = moments[0];
1417
+ }
1418
+ if (!moments.length) {
1419
+ return local__createLocal();
1420
+ }
1421
+ res = moments[0];
1422
+ for (i = 1; i < moments.length; ++i) {
1423
+ if (!moments[i].isValid() || moments[i][fn](res)) {
1424
+ res = moments[i];
1425
+ }
1426
+ }
1427
+ return res;
1428
+ }
1429
+
1430
+ // TODO: Use [].sort instead?
1431
+ function min () {
1432
+ var args = [].slice.call(arguments, 0);
1433
+
1434
+ return pickBy('isBefore', args);
1435
+ }
1436
+
1437
+ function max () {
1438
+ var args = [].slice.call(arguments, 0);
1439
+
1440
+ return pickBy('isAfter', args);
1441
+ }
1442
+
1443
+ function Duration (duration) {
1444
+ var normalizedInput = normalizeObjectUnits(duration),
1445
+ years = normalizedInput.year || 0,
1446
+ quarters = normalizedInput.quarter || 0,
1447
+ months = normalizedInput.month || 0,
1448
+ weeks = normalizedInput.week || 0,
1449
+ days = normalizedInput.day || 0,
1450
+ hours = normalizedInput.hour || 0,
1451
+ minutes = normalizedInput.minute || 0,
1452
+ seconds = normalizedInput.second || 0,
1453
+ milliseconds = normalizedInput.millisecond || 0;
1454
+
1455
+ // representation for dateAddRemove
1456
+ this._milliseconds = +milliseconds +
1457
+ seconds * 1e3 + // 1000
1458
+ minutes * 6e4 + // 1000 * 60
1459
+ hours * 36e5; // 1000 * 60 * 60
1460
+ // Because of dateAddRemove treats 24 hours as different from a
1461
+ // day when working around DST, we need to store them separately
1462
+ this._days = +days +
1463
+ weeks * 7;
1464
+ // It is impossible translate months into days without knowing
1465
+ // which months you are are talking about, so we have to store
1466
+ // it separately.
1467
+ this._months = +months +
1468
+ quarters * 3 +
1469
+ years * 12;
1470
+
1471
+ this._data = {};
1472
+
1473
+ this._locale = locale_locales__getLocale();
1474
+
1475
+ this._bubble();
1476
+ }
1477
+
1478
+ function isDuration (obj) {
1479
+ return obj instanceof Duration;
1480
+ }
1481
+
1482
+ function offset (token, separator) {
1483
+ addFormatToken(token, 0, 0, function () {
1484
+ var offset = this.utcOffset();
1485
+ var sign = '+';
1486
+ if (offset < 0) {
1487
+ offset = -offset;
1488
+ sign = '-';
1489
+ }
1490
+ return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
1491
+ });
1492
+ }
1493
+
1494
+ offset('Z', ':');
1495
+ offset('ZZ', '');
1496
+
1497
+ // PARSING
1498
+
1499
+ addRegexToken('Z', matchOffset);
1500
+ addRegexToken('ZZ', matchOffset);
1501
+ addParseToken(['Z', 'ZZ'], function (input, array, config) {
1502
+ config._useUTC = true;
1503
+ config._tzm = offsetFromString(input);
1504
+ });
1505
+
1506
+ // HELPERS
1507
+
1508
+ // timezone chunker
1509
+ // '+10:00' > ['10', '00']
1510
+ // '-1530' > ['-15', '30']
1511
+ var chunkOffset = /([\+\-]|\d\d)/gi;
1512
+
1513
+ function offsetFromString(string) {
1514
+ var matches = ((string || '').match(matchOffset) || []);
1515
+ var chunk = matches[matches.length - 1] || [];
1516
+ var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
1517
+ var minutes = +(parts[1] * 60) + toInt(parts[2]);
1518
+
1519
+ return parts[0] === '+' ? minutes : -minutes;
1520
+ }
1521
+
1522
+ // Return a moment from input, that is local/utc/zone equivalent to model.
1523
+ function cloneWithOffset(input, model) {
1524
+ var res, diff;
1525
+ if (model._isUTC) {
1526
+ res = model.clone();
1527
+ diff = (isMoment(input) || isDate(input) ? +input : +local__createLocal(input)) - (+res);
1528
+ // Use low-level api, because this fn is low-level api.
1529
+ res._d.setTime(+res._d + diff);
1530
+ utils_hooks__hooks.updateOffset(res, false);
1531
+ return res;
1532
+ } else {
1533
+ return local__createLocal(input).local();
1534
+ }
1535
+ }
1536
+
1537
+ function getDateOffset (m) {
1538
+ // On Firefox.24 Date#getTimezoneOffset returns a floating point.
1539
+ // https://github.com/moment/moment/pull/1871
1540
+ return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
1541
+ }
1542
+
1543
+ // HOOKS
1544
+
1545
+ // This function will be called whenever a moment is mutated.
1546
+ // It is intended to keep the offset in sync with the timezone.
1547
+ utils_hooks__hooks.updateOffset = function () {};
1548
+
1549
+ // MOMENTS
1550
+
1551
+ // keepLocalTime = true means only change the timezone, without
1552
+ // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
1553
+ // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
1554
+ // +0200, so we adjust the time as needed, to be valid.
1555
+ //
1556
+ // Keeping the time actually adds/subtracts (one hour)
1557
+ // from the actual represented time. That is why we call updateOffset
1558
+ // a second time. In case it wants us to change the offset again
1559
+ // _changeInProgress == true case, then we have to adjust, because
1560
+ // there is no such time in the given timezone.
1561
+ function getSetOffset (input, keepLocalTime) {
1562
+ var offset = this._offset || 0,
1563
+ localAdjust;
1564
+ if (input != null) {
1565
+ if (typeof input === 'string') {
1566
+ input = offsetFromString(input);
1567
+ }
1568
+ if (Math.abs(input) < 16) {
1569
+ input = input * 60;
1570
+ }
1571
+ if (!this._isUTC && keepLocalTime) {
1572
+ localAdjust = getDateOffset(this);
1573
+ }
1574
+ this._offset = input;
1575
+ this._isUTC = true;
1576
+ if (localAdjust != null) {
1577
+ this.add(localAdjust, 'm');
1578
+ }
1579
+ if (offset !== input) {
1580
+ if (!keepLocalTime || this._changeInProgress) {
1581
+ add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
1582
+ } else if (!this._changeInProgress) {
1583
+ this._changeInProgress = true;
1584
+ utils_hooks__hooks.updateOffset(this, true);
1585
+ this._changeInProgress = null;
1586
+ }
1587
+ }
1588
+ return this;
1589
+ } else {
1590
+ return this._isUTC ? offset : getDateOffset(this);
1591
+ }
1592
+ }
1593
+
1594
+ function getSetZone (input, keepLocalTime) {
1595
+ if (input != null) {
1596
+ if (typeof input !== 'string') {
1597
+ input = -input;
1598
+ }
1599
+
1600
+ this.utcOffset(input, keepLocalTime);
1601
+
1602
+ return this;
1603
+ } else {
1604
+ return -this.utcOffset();
1605
+ }
1606
+ }
1607
+
1608
+ function setOffsetToUTC (keepLocalTime) {
1609
+ return this.utcOffset(0, keepLocalTime);
1610
+ }
1611
+
1612
+ function setOffsetToLocal (keepLocalTime) {
1613
+ if (this._isUTC) {
1614
+ this.utcOffset(0, keepLocalTime);
1615
+ this._isUTC = false;
1616
+
1617
+ if (keepLocalTime) {
1618
+ this.subtract(getDateOffset(this), 'm');
1619
+ }
1620
+ }
1621
+ return this;
1622
+ }
1623
+
1624
+ function setOffsetToParsedOffset () {
1625
+ if (this._tzm) {
1626
+ this.utcOffset(this._tzm);
1627
+ } else if (typeof this._i === 'string') {
1628
+ this.utcOffset(offsetFromString(this._i));
1629
+ }
1630
+ return this;
1631
+ }
1632
+
1633
+ function hasAlignedHourOffset (input) {
1634
+ input = input ? local__createLocal(input).utcOffset() : 0;
1635
+
1636
+ return (this.utcOffset() - input) % 60 === 0;
1637
+ }
1638
+
1639
+ function isDaylightSavingTime () {
1640
+ return (
1641
+ this.utcOffset() > this.clone().month(0).utcOffset() ||
1642
+ this.utcOffset() > this.clone().month(5).utcOffset()
1643
+ );
1644
+ }
1645
+
1646
+ function isDaylightSavingTimeShifted () {
1647
+ if (typeof this._isDSTShifted !== 'undefined') {
1648
+ return this._isDSTShifted;
1649
+ }
1650
+
1651
+ var c = {};
1652
+
1653
+ copyConfig(c, this);
1654
+ c = prepareConfig(c);
1655
+
1656
+ if (c._a) {
1657
+ var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
1658
+ this._isDSTShifted = this.isValid() &&
1659
+ compareArrays(c._a, other.toArray()) > 0;
1660
+ } else {
1661
+ this._isDSTShifted = false;
1662
+ }
1663
+
1664
+ return this._isDSTShifted;
1665
+ }
1666
+
1667
+ function isLocal () {
1668
+ return !this._isUTC;
1669
+ }
1670
+
1671
+ function isUtcOffset () {
1672
+ return this._isUTC;
1673
+ }
1674
+
1675
+ function isUtc () {
1676
+ return this._isUTC && this._offset === 0;
1677
+ }
1678
+
1679
+ var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
1680
+
1681
+ // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
1682
+ // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
1683
+ var create__isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
1684
+
1685
+ function create__createDuration (input, key) {
1686
+ var duration = input,
1687
+ // matching against regexp is expensive, do it on demand
1688
+ match = null,
1689
+ sign,
1690
+ ret,
1691
+ diffRes;
1692
+
1693
+ if (isDuration(input)) {
1694
+ duration = {
1695
+ ms : input._milliseconds,
1696
+ d : input._days,
1697
+ M : input._months
1698
+ };
1699
+ } else if (typeof input === 'number') {
1700
+ duration = {};
1701
+ if (key) {
1702
+ duration[key] = input;
1703
+ } else {
1704
+ duration.milliseconds = input;
1705
+ }
1706
+ } else if (!!(match = aspNetRegex.exec(input))) {
1707
+ sign = (match[1] === '-') ? -1 : 1;
1708
+ duration = {
1709
+ y : 0,
1710
+ d : toInt(match[DATE]) * sign,
1711
+ h : toInt(match[HOUR]) * sign,
1712
+ m : toInt(match[MINUTE]) * sign,
1713
+ s : toInt(match[SECOND]) * sign,
1714
+ ms : toInt(match[MILLISECOND]) * sign
1715
+ };
1716
+ } else if (!!(match = create__isoRegex.exec(input))) {
1717
+ sign = (match[1] === '-') ? -1 : 1;
1718
+ duration = {
1719
+ y : parseIso(match[2], sign),
1720
+ M : parseIso(match[3], sign),
1721
+ d : parseIso(match[4], sign),
1722
+ h : parseIso(match[5], sign),
1723
+ m : parseIso(match[6], sign),
1724
+ s : parseIso(match[7], sign),
1725
+ w : parseIso(match[8], sign)
1726
+ };
1727
+ } else if (duration == null) {// checks for null or undefined
1728
+ duration = {};
1729
+ } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
1730
+ diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
1731
+
1732
+ duration = {};
1733
+ duration.ms = diffRes.milliseconds;
1734
+ duration.M = diffRes.months;
1735
+ }
1736
+
1737
+ ret = new Duration(duration);
1738
+
1739
+ if (isDuration(input) && hasOwnProp(input, '_locale')) {
1740
+ ret._locale = input._locale;
1741
+ }
1742
+
1743
+ return ret;
1744
+ }
1745
+
1746
+ create__createDuration.fn = Duration.prototype;
1747
+
1748
+ function parseIso (inp, sign) {
1749
+ // We'd normally use ~~inp for this, but unfortunately it also
1750
+ // converts floats to ints.
1751
+ // inp may be undefined, so careful calling replace on it.
1752
+ var res = inp && parseFloat(inp.replace(',', '.'));
1753
+ // apply sign while we're at it
1754
+ return (isNaN(res) ? 0 : res) * sign;
1755
+ }
1756
+
1757
+ function positiveMomentsDifference(base, other) {
1758
+ var res = {milliseconds: 0, months: 0};
1759
+
1760
+ res.months = other.month() - base.month() +
1761
+ (other.year() - base.year()) * 12;
1762
+ if (base.clone().add(res.months, 'M').isAfter(other)) {
1763
+ --res.months;
1764
+ }
1765
+
1766
+ res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
1767
+
1768
+ return res;
1769
+ }
1770
+
1771
+ function momentsDifference(base, other) {
1772
+ var res;
1773
+ other = cloneWithOffset(other, base);
1774
+ if (base.isBefore(other)) {
1775
+ res = positiveMomentsDifference(base, other);
1776
+ } else {
1777
+ res = positiveMomentsDifference(other, base);
1778
+ res.milliseconds = -res.milliseconds;
1779
+ res.months = -res.months;
1780
+ }
1781
+
1782
+ return res;
1783
+ }
1784
+
1785
+ function createAdder(direction, name) {
1786
+ return function (val, period) {
1787
+ var dur, tmp;
1788
+ //invert the arguments, but complain about it
1789
+ if (period !== null && !isNaN(+period)) {
1790
+ deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
1791
+ tmp = val; val = period; period = tmp;
1792
+ }
1793
+
1794
+ val = typeof val === 'string' ? +val : val;
1795
+ dur = create__createDuration(val, period);
1796
+ add_subtract__addSubtract(this, dur, direction);
1797
+ return this;
1798
+ };
1799
+ }
1800
+
1801
+ function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
1802
+ var milliseconds = duration._milliseconds,
1803
+ days = duration._days,
1804
+ months = duration._months;
1805
+ updateOffset = updateOffset == null ? true : updateOffset;
1806
+
1807
+ if (milliseconds) {
1808
+ mom._d.setTime(+mom._d + milliseconds * isAdding);
1809
+ }
1810
+ if (days) {
1811
+ get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
1812
+ }
1813
+ if (months) {
1814
+ setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
1815
+ }
1816
+ if (updateOffset) {
1817
+ utils_hooks__hooks.updateOffset(mom, days || months);
1818
+ }
1819
+ }
1820
+
1821
+ var add_subtract__add = createAdder(1, 'add');
1822
+ var add_subtract__subtract = createAdder(-1, 'subtract');
1823
+
1824
+ function moment_calendar__calendar (time, formats) {
1825
+ // We want to compare the start of today, vs this.
1826
+ // Getting start-of-today depends on whether we're local/utc/offset or not.
1827
+ var now = time || local__createLocal(),
1828
+ sod = cloneWithOffset(now, this).startOf('day'),
1829
+ diff = this.diff(sod, 'days', true),
1830
+ format = diff < -6 ? 'sameElse' :
1831
+ diff < -1 ? 'lastWeek' :
1832
+ diff < 0 ? 'lastDay' :
1833
+ diff < 1 ? 'sameDay' :
1834
+ diff < 2 ? 'nextDay' :
1835
+ diff < 7 ? 'nextWeek' : 'sameElse';
1836
+ return this.format(formats && formats[format] || this.localeData().calendar(format, this, local__createLocal(now)));
1837
+ }
1838
+
1839
+ function clone () {
1840
+ return new Moment(this);
1841
+ }
1842
+
1843
+ function isAfter (input, units) {
1844
+ var inputMs;
1845
+ units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
1846
+ if (units === 'millisecond') {
1847
+ input = isMoment(input) ? input : local__createLocal(input);
1848
+ return +this > +input;
1849
+ } else {
1850
+ inputMs = isMoment(input) ? +input : +local__createLocal(input);
1851
+ return inputMs < +this.clone().startOf(units);
1852
+ }
1853
+ }
1854
+
1855
+ function isBefore (input, units) {
1856
+ var inputMs;
1857
+ units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
1858
+ if (units === 'millisecond') {
1859
+ input = isMoment(input) ? input : local__createLocal(input);
1860
+ return +this < +input;
1861
+ } else {
1862
+ inputMs = isMoment(input) ? +input : +local__createLocal(input);
1863
+ return +this.clone().endOf(units) < inputMs;
1864
+ }
1865
+ }
1866
+
1867
+ function isBetween (from, to, units) {
1868
+ return this.isAfter(from, units) && this.isBefore(to, units);
1869
+ }
1870
+
1871
+ function isSame (input, units) {
1872
+ var inputMs;
1873
+ units = normalizeUnits(units || 'millisecond');
1874
+ if (units === 'millisecond') {
1875
+ input = isMoment(input) ? input : local__createLocal(input);
1876
+ return +this === +input;
1877
+ } else {
1878
+ inputMs = +local__createLocal(input);
1879
+ return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units));
1880
+ }
1881
+ }
1882
+
1883
+ function diff (input, units, asFloat) {
1884
+ var that = cloneWithOffset(input, this),
1885
+ zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4,
1886
+ delta, output;
1887
+
1888
+ units = normalizeUnits(units);
1889
+
1890
+ if (units === 'year' || units === 'month' || units === 'quarter') {
1891
+ output = monthDiff(this, that);
1892
+ if (units === 'quarter') {
1893
+ output = output / 3;
1894
+ } else if (units === 'year') {
1895
+ output = output / 12;
1896
+ }
1897
+ } else {
1898
+ delta = this - that;
1899
+ output = units === 'second' ? delta / 1e3 : // 1000
1900
+ units === 'minute' ? delta / 6e4 : // 1000 * 60
1901
+ units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
1902
+ units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
1903
+ units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
1904
+ delta;
1905
+ }
1906
+ return asFloat ? output : absFloor(output);
1907
+ }
1908
+
1909
+ function monthDiff (a, b) {
1910
+ // difference in months
1911
+ var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
1912
+ // b is in (anchor - 1 month, anchor + 1 month)
1913
+ anchor = a.clone().add(wholeMonthDiff, 'months'),
1914
+ anchor2, adjust;
1915
+
1916
+ if (b - anchor < 0) {
1917
+ anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
1918
+ // linear across the month
1919
+ adjust = (b - anchor) / (anchor - anchor2);
1920
+ } else {
1921
+ anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
1922
+ // linear across the month
1923
+ adjust = (b - anchor) / (anchor2 - anchor);
1924
+ }
1925
+
1926
+ return -(wholeMonthDiff + adjust);
1927
+ }
1928
+
1929
+ utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
1930
+
1931
+ function toString () {
1932
+ return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
1933
+ }
1934
+
1935
+ function moment_format__toISOString () {
1936
+ var m = this.clone().utc();
1937
+ if (0 < m.year() && m.year() <= 9999) {
1938
+ if ('function' === typeof Date.prototype.toISOString) {
1939
+ // native implementation is ~50x faster, use it when we can
1940
+ return this.toDate().toISOString();
1941
+ } else {
1942
+ return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
1943
+ }
1944
+ } else {
1945
+ return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
1946
+ }
1947
+ }
1948
+
1949
+ function format (inputString) {
1950
+ var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);
1951
+ return this.localeData().postformat(output);
1952
+ }
1953
+
1954
+ function from (time, withoutSuffix) {
1955
+ if (!this.isValid()) {
1956
+ return this.localeData().invalidDate();
1957
+ }
1958
+ return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
1959
+ }
1960
+
1961
+ function fromNow (withoutSuffix) {
1962
+ return this.from(local__createLocal(), withoutSuffix);
1963
+ }
1964
+
1965
+ function to (time, withoutSuffix) {
1966
+ if (!this.isValid()) {
1967
+ return this.localeData().invalidDate();
1968
+ }
1969
+ return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
1970
+ }
1971
+
1972
+ function toNow (withoutSuffix) {
1973
+ return this.to(local__createLocal(), withoutSuffix);
1974
+ }
1975
+
1976
+ function locale (key) {
1977
+ var newLocaleData;
1978
+
1979
+ if (key === undefined) {
1980
+ return this._locale._abbr;
1981
+ } else {
1982
+ newLocaleData = locale_locales__getLocale(key);
1983
+ if (newLocaleData != null) {
1984
+ this._locale = newLocaleData;
1985
+ }
1986
+ return this;
1987
+ }
1988
+ }
1989
+
1990
+ var lang = deprecate(
1991
+ 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
1992
+ function (key) {
1993
+ if (key === undefined) {
1994
+ return this.localeData();
1995
+ } else {
1996
+ return this.locale(key);
1997
+ }
1998
+ }
1999
+ );
2000
+
2001
+ function localeData () {
2002
+ return this._locale;
2003
+ }
2004
+
2005
+ function startOf (units) {
2006
+ units = normalizeUnits(units);
2007
+ // the following switch intentionally omits break keywords
2008
+ // to utilize falling through the cases.
2009
+ switch (units) {
2010
+ case 'year':
2011
+ this.month(0);
2012
+ /* falls through */
2013
+ case 'quarter':
2014
+ case 'month':
2015
+ this.date(1);
2016
+ /* falls through */
2017
+ case 'week':
2018
+ case 'isoWeek':
2019
+ case 'day':
2020
+ this.hours(0);
2021
+ /* falls through */
2022
+ case 'hour':
2023
+ this.minutes(0);
2024
+ /* falls through */
2025
+ case 'minute':
2026
+ this.seconds(0);
2027
+ /* falls through */
2028
+ case 'second':
2029
+ this.milliseconds(0);
2030
+ }
2031
+
2032
+ // weeks are a special case
2033
+ if (units === 'week') {
2034
+ this.weekday(0);
2035
+ }
2036
+ if (units === 'isoWeek') {
2037
+ this.isoWeekday(1);
2038
+ }
2039
+
2040
+ // quarters are also special
2041
+ if (units === 'quarter') {
2042
+ this.month(Math.floor(this.month() / 3) * 3);
2043
+ }
2044
+
2045
+ return this;
2046
+ }
2047
+
2048
+ function endOf (units) {
2049
+ units = normalizeUnits(units);
2050
+ if (units === undefined || units === 'millisecond') {
2051
+ return this;
2052
+ }
2053
+ return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
2054
+ }
2055
+
2056
+ function to_type__valueOf () {
2057
+ return +this._d - ((this._offset || 0) * 60000);
2058
+ }
2059
+
2060
+ function unix () {
2061
+ return Math.floor(+this / 1000);
2062
+ }
2063
+
2064
+ function toDate () {
2065
+ return this._offset ? new Date(+this) : this._d;
2066
+ }
2067
+
2068
+ function toArray () {
2069
+ var m = this;
2070
+ return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
2071
+ }
2072
+
2073
+ function toObject () {
2074
+ var m = this;
2075
+ return {
2076
+ years: m.year(),
2077
+ months: m.month(),
2078
+ date: m.date(),
2079
+ hours: m.hours(),
2080
+ minutes: m.minutes(),
2081
+ seconds: m.seconds(),
2082
+ milliseconds: m.milliseconds()
2083
+ };
2084
+ }
2085
+
2086
+ function moment_valid__isValid () {
2087
+ return valid__isValid(this);
2088
+ }
2089
+
2090
+ function parsingFlags () {
2091
+ return extend({}, getParsingFlags(this));
2092
+ }
2093
+
2094
+ function invalidAt () {
2095
+ return getParsingFlags(this).overflow;
2096
+ }
2097
+
2098
+ addFormatToken(0, ['gg', 2], 0, function () {
2099
+ return this.weekYear() % 100;
2100
+ });
2101
+
2102
+ addFormatToken(0, ['GG', 2], 0, function () {
2103
+ return this.isoWeekYear() % 100;
2104
+ });
2105
+
2106
+ function addWeekYearFormatToken (token, getter) {
2107
+ addFormatToken(0, [token, token.length], 0, getter);
2108
+ }
2109
+
2110
+ addWeekYearFormatToken('gggg', 'weekYear');
2111
+ addWeekYearFormatToken('ggggg', 'weekYear');
2112
+ addWeekYearFormatToken('GGGG', 'isoWeekYear');
2113
+ addWeekYearFormatToken('GGGGG', 'isoWeekYear');
2114
+
2115
+ // ALIASES
2116
+
2117
+ addUnitAlias('weekYear', 'gg');
2118
+ addUnitAlias('isoWeekYear', 'GG');
2119
+
2120
+ // PARSING
2121
+
2122
+ addRegexToken('G', matchSigned);
2123
+ addRegexToken('g', matchSigned);
2124
+ addRegexToken('GG', match1to2, match2);
2125
+ addRegexToken('gg', match1to2, match2);
2126
+ addRegexToken('GGGG', match1to4, match4);
2127
+ addRegexToken('gggg', match1to4, match4);
2128
+ addRegexToken('GGGGG', match1to6, match6);
2129
+ addRegexToken('ggggg', match1to6, match6);
2130
+
2131
+ addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
2132
+ week[token.substr(0, 2)] = toInt(input);
2133
+ });
2134
+
2135
+ addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
2136
+ week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
2137
+ });
2138
+
2139
+ // HELPERS
2140
+
2141
+ function weeksInYear(year, dow, doy) {
2142
+ return weekOfYear(local__createLocal([year, 11, 31 + dow - doy]), dow, doy).week;
2143
+ }
2144
+
2145
+ // MOMENTS
2146
+
2147
+ function getSetWeekYear (input) {
2148
+ var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
2149
+ return input == null ? year : this.add((input - year), 'y');
2150
+ }
2151
+
2152
+ function getSetISOWeekYear (input) {
2153
+ var year = weekOfYear(this, 1, 4).year;
2154
+ return input == null ? year : this.add((input - year), 'y');
2155
+ }
2156
+
2157
+ function getISOWeeksInYear () {
2158
+ return weeksInYear(this.year(), 1, 4);
2159
+ }
2160
+
2161
+ function getWeeksInYear () {
2162
+ var weekInfo = this.localeData()._week;
2163
+ return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
2164
+ }
2165
+
2166
+ addFormatToken('Q', 0, 0, 'quarter');
2167
+
2168
+ // ALIASES
2169
+
2170
+ addUnitAlias('quarter', 'Q');
2171
+
2172
+ // PARSING
2173
+
2174
+ addRegexToken('Q', match1);
2175
+ addParseToken('Q', function (input, array) {
2176
+ array[MONTH] = (toInt(input) - 1) * 3;
2177
+ });
2178
+
2179
+ // MOMENTS
2180
+
2181
+ function getSetQuarter (input) {
2182
+ return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
2183
+ }
2184
+
2185
+ addFormatToken('D', ['DD', 2], 'Do', 'date');
2186
+
2187
+ // ALIASES
2188
+
2189
+ addUnitAlias('date', 'D');
2190
+
2191
+ // PARSING
2192
+
2193
+ addRegexToken('D', match1to2);
2194
+ addRegexToken('DD', match1to2, match2);
2195
+ addRegexToken('Do', function (isStrict, locale) {
2196
+ return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
2197
+ });
2198
+
2199
+ addParseToken(['D', 'DD'], DATE);
2200
+ addParseToken('Do', function (input, array) {
2201
+ array[DATE] = toInt(input.match(match1to2)[0], 10);
2202
+ });
2203
+
2204
+ // MOMENTS
2205
+
2206
+ var getSetDayOfMonth = makeGetSet('Date', true);
2207
+
2208
+ addFormatToken('d', 0, 'do', 'day');
2209
+
2210
+ addFormatToken('dd', 0, 0, function (format) {
2211
+ return this.localeData().weekdaysMin(this, format);
2212
+ });
2213
+
2214
+ addFormatToken('ddd', 0, 0, function (format) {
2215
+ return this.localeData().weekdaysShort(this, format);
2216
+ });
2217
+
2218
+ addFormatToken('dddd', 0, 0, function (format) {
2219
+ return this.localeData().weekdays(this, format);
2220
+ });
2221
+
2222
+ addFormatToken('e', 0, 0, 'weekday');
2223
+ addFormatToken('E', 0, 0, 'isoWeekday');
2224
+
2225
+ // ALIASES
2226
+
2227
+ addUnitAlias('day', 'd');
2228
+ addUnitAlias('weekday', 'e');
2229
+ addUnitAlias('isoWeekday', 'E');
2230
+
2231
+ // PARSING
2232
+
2233
+ addRegexToken('d', match1to2);
2234
+ addRegexToken('e', match1to2);
2235
+ addRegexToken('E', match1to2);
2236
+ addRegexToken('dd', matchWord);
2237
+ addRegexToken('ddd', matchWord);
2238
+ addRegexToken('dddd', matchWord);
2239
+
2240
+ addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) {
2241
+ var weekday = config._locale.weekdaysParse(input);
2242
+ // if we didn't get a weekday name, mark the date as invalid
2243
+ if (weekday != null) {
2244
+ week.d = weekday;
2245
+ } else {
2246
+ getParsingFlags(config).invalidWeekday = input;
2247
+ }
2248
+ });
2249
+
2250
+ addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
2251
+ week[token] = toInt(input);
2252
+ });
2253
+
2254
+ // HELPERS
2255
+
2256
+ function parseWeekday(input, locale) {
2257
+ if (typeof input !== 'string') {
2258
+ return input;
2259
+ }
2260
+
2261
+ if (!isNaN(input)) {
2262
+ return parseInt(input, 10);
2263
+ }
2264
+
2265
+ input = locale.weekdaysParse(input);
2266
+ if (typeof input === 'number') {
2267
+ return input;
2268
+ }
2269
+
2270
+ return null;
2271
+ }
2272
+
2273
+ // LOCALES
2274
+
2275
+ var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
2276
+ function localeWeekdays (m) {
2277
+ return this._weekdays[m.day()];
2278
+ }
2279
+
2280
+ var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
2281
+ function localeWeekdaysShort (m) {
2282
+ return this._weekdaysShort[m.day()];
2283
+ }
2284
+
2285
+ var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
2286
+ function localeWeekdaysMin (m) {
2287
+ return this._weekdaysMin[m.day()];
2288
+ }
2289
+
2290
+ function localeWeekdaysParse (weekdayName) {
2291
+ var i, mom, regex;
2292
+
2293
+ this._weekdaysParse = this._weekdaysParse || [];
2294
+
2295
+ for (i = 0; i < 7; i++) {
2296
+ // make the regex if we don't have it already
2297
+ if (!this._weekdaysParse[i]) {
2298
+ mom = local__createLocal([2000, 1]).day(i);
2299
+ regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
2300
+ this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
2301
+ }
2302
+ // test the regex
2303
+ if (this._weekdaysParse[i].test(weekdayName)) {
2304
+ return i;
2305
+ }
2306
+ }
2307
+ }
2308
+
2309
+ // MOMENTS
2310
+
2311
+ function getSetDayOfWeek (input) {
2312
+ var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
2313
+ if (input != null) {
2314
+ input = parseWeekday(input, this.localeData());
2315
+ return this.add(input - day, 'd');
2316
+ } else {
2317
+ return day;
2318
+ }
2319
+ }
2320
+
2321
+ function getSetLocaleDayOfWeek (input) {
2322
+ var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
2323
+ return input == null ? weekday : this.add(input - weekday, 'd');
2324
+ }
2325
+
2326
+ function getSetISODayOfWeek (input) {
2327
+ // behaves the same as moment#day except
2328
+ // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
2329
+ // as a setter, sunday should belong to the previous week.
2330
+ return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
2331
+ }
2332
+
2333
+ addFormatToken('H', ['HH', 2], 0, 'hour');
2334
+ addFormatToken('h', ['hh', 2], 0, function () {
2335
+ return this.hours() % 12 || 12;
2336
+ });
2337
+
2338
+ function meridiem (token, lowercase) {
2339
+ addFormatToken(token, 0, 0, function () {
2340
+ return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
2341
+ });
2342
+ }
2343
+
2344
+ meridiem('a', true);
2345
+ meridiem('A', false);
2346
+
2347
+ // ALIASES
2348
+
2349
+ addUnitAlias('hour', 'h');
2350
+
2351
+ // PARSING
2352
+
2353
+ function matchMeridiem (isStrict, locale) {
2354
+ return locale._meridiemParse;
2355
+ }
2356
+
2357
+ addRegexToken('a', matchMeridiem);
2358
+ addRegexToken('A', matchMeridiem);
2359
+ addRegexToken('H', match1to2);
2360
+ addRegexToken('h', match1to2);
2361
+ addRegexToken('HH', match1to2, match2);
2362
+ addRegexToken('hh', match1to2, match2);
2363
+
2364
+ addParseToken(['H', 'HH'], HOUR);
2365
+ addParseToken(['a', 'A'], function (input, array, config) {
2366
+ config._isPm = config._locale.isPM(input);
2367
+ config._meridiem = input;
2368
+ });
2369
+ addParseToken(['h', 'hh'], function (input, array, config) {
2370
+ array[HOUR] = toInt(input);
2371
+ getParsingFlags(config).bigHour = true;
2372
+ });
2373
+
2374
+ // LOCALES
2375
+
2376
+ function localeIsPM (input) {
2377
+ // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
2378
+ // Using charAt should be more compatible.
2379
+ return ((input + '').toLowerCase().charAt(0) === 'p');
2380
+ }
2381
+
2382
+ var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
2383
+ function localeMeridiem (hours, minutes, isLower) {
2384
+ if (hours > 11) {
2385
+ return isLower ? 'pm' : 'PM';
2386
+ } else {
2387
+ return isLower ? 'am' : 'AM';
2388
+ }
2389
+ }
2390
+
2391
+
2392
+ // MOMENTS
2393
+
2394
+ // Setting the hour should keep the time, because the user explicitly
2395
+ // specified which hour he wants. So trying to maintain the same hour (in
2396
+ // a new timezone) makes sense. Adding/subtracting hours does not follow
2397
+ // this rule.
2398
+ var getSetHour = makeGetSet('Hours', true);
2399
+
2400
+ addFormatToken('m', ['mm', 2], 0, 'minute');
2401
+
2402
+ // ALIASES
2403
+
2404
+ addUnitAlias('minute', 'm');
2405
+
2406
+ // PARSING
2407
+
2408
+ addRegexToken('m', match1to2);
2409
+ addRegexToken('mm', match1to2, match2);
2410
+ addParseToken(['m', 'mm'], MINUTE);
2411
+
2412
+ // MOMENTS
2413
+
2414
+ var getSetMinute = makeGetSet('Minutes', false);
2415
+
2416
+ addFormatToken('s', ['ss', 2], 0, 'second');
2417
+
2418
+ // ALIASES
2419
+
2420
+ addUnitAlias('second', 's');
2421
+
2422
+ // PARSING
2423
+
2424
+ addRegexToken('s', match1to2);
2425
+ addRegexToken('ss', match1to2, match2);
2426
+ addParseToken(['s', 'ss'], SECOND);
2427
+
2428
+ // MOMENTS
2429
+
2430
+ var getSetSecond = makeGetSet('Seconds', false);
2431
+
2432
+ addFormatToken('S', 0, 0, function () {
2433
+ return ~~(this.millisecond() / 100);
2434
+ });
2435
+
2436
+ addFormatToken(0, ['SS', 2], 0, function () {
2437
+ return ~~(this.millisecond() / 10);
2438
+ });
2439
+
2440
+ addFormatToken(0, ['SSS', 3], 0, 'millisecond');
2441
+ addFormatToken(0, ['SSSS', 4], 0, function () {
2442
+ return this.millisecond() * 10;
2443
+ });
2444
+ addFormatToken(0, ['SSSSS', 5], 0, function () {
2445
+ return this.millisecond() * 100;
2446
+ });
2447
+ addFormatToken(0, ['SSSSSS', 6], 0, function () {
2448
+ return this.millisecond() * 1000;
2449
+ });
2450
+ addFormatToken(0, ['SSSSSSS', 7], 0, function () {
2451
+ return this.millisecond() * 10000;
2452
+ });
2453
+ addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
2454
+ return this.millisecond() * 100000;
2455
+ });
2456
+ addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
2457
+ return this.millisecond() * 1000000;
2458
+ });
2459
+
2460
+
2461
+ // ALIASES
2462
+
2463
+ addUnitAlias('millisecond', 'ms');
2464
+
2465
+ // PARSING
2466
+
2467
+ addRegexToken('S', match1to3, match1);
2468
+ addRegexToken('SS', match1to3, match2);
2469
+ addRegexToken('SSS', match1to3, match3);
2470
+
2471
+ var token;
2472
+ for (token = 'SSSS'; token.length <= 9; token += 'S') {
2473
+ addRegexToken(token, matchUnsigned);
2474
+ }
2475
+
2476
+ function parseMs(input, array) {
2477
+ array[MILLISECOND] = toInt(('0.' + input) * 1000);
2478
+ }
2479
+
2480
+ for (token = 'S'; token.length <= 9; token += 'S') {
2481
+ addParseToken(token, parseMs);
2482
+ }
2483
+ // MOMENTS
2484
+
2485
+ var getSetMillisecond = makeGetSet('Milliseconds', false);
2486
+
2487
+ addFormatToken('z', 0, 0, 'zoneAbbr');
2488
+ addFormatToken('zz', 0, 0, 'zoneName');
2489
+
2490
+ // MOMENTS
2491
+
2492
+ function getZoneAbbr () {
2493
+ return this._isUTC ? 'UTC' : '';
2494
+ }
2495
+
2496
+ function getZoneName () {
2497
+ return this._isUTC ? 'Coordinated Universal Time' : '';
2498
+ }
2499
+
2500
+ var momentPrototype__proto = Moment.prototype;
2501
+
2502
+ momentPrototype__proto.add = add_subtract__add;
2503
+ momentPrototype__proto.calendar = moment_calendar__calendar;
2504
+ momentPrototype__proto.clone = clone;
2505
+ momentPrototype__proto.diff = diff;
2506
+ momentPrototype__proto.endOf = endOf;
2507
+ momentPrototype__proto.format = format;
2508
+ momentPrototype__proto.from = from;
2509
+ momentPrototype__proto.fromNow = fromNow;
2510
+ momentPrototype__proto.to = to;
2511
+ momentPrototype__proto.toNow = toNow;
2512
+ momentPrototype__proto.get = getSet;
2513
+ momentPrototype__proto.invalidAt = invalidAt;
2514
+ momentPrototype__proto.isAfter = isAfter;
2515
+ momentPrototype__proto.isBefore = isBefore;
2516
+ momentPrototype__proto.isBetween = isBetween;
2517
+ momentPrototype__proto.isSame = isSame;
2518
+ momentPrototype__proto.isValid = moment_valid__isValid;
2519
+ momentPrototype__proto.lang = lang;
2520
+ momentPrototype__proto.locale = locale;
2521
+ momentPrototype__proto.localeData = localeData;
2522
+ momentPrototype__proto.max = prototypeMax;
2523
+ momentPrototype__proto.min = prototypeMin;
2524
+ momentPrototype__proto.parsingFlags = parsingFlags;
2525
+ momentPrototype__proto.set = getSet;
2526
+ momentPrototype__proto.startOf = startOf;
2527
+ momentPrototype__proto.subtract = add_subtract__subtract;
2528
+ momentPrototype__proto.toArray = toArray;
2529
+ momentPrototype__proto.toObject = toObject;
2530
+ momentPrototype__proto.toDate = toDate;
2531
+ momentPrototype__proto.toISOString = moment_format__toISOString;
2532
+ momentPrototype__proto.toJSON = moment_format__toISOString;
2533
+ momentPrototype__proto.toString = toString;
2534
+ momentPrototype__proto.unix = unix;
2535
+ momentPrototype__proto.valueOf = to_type__valueOf;
2536
+
2537
+ // Year
2538
+ momentPrototype__proto.year = getSetYear;
2539
+ momentPrototype__proto.isLeapYear = getIsLeapYear;
2540
+
2541
+ // Week Year
2542
+ momentPrototype__proto.weekYear = getSetWeekYear;
2543
+ momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
2544
+
2545
+ // Quarter
2546
+ momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
2547
+
2548
+ // Month
2549
+ momentPrototype__proto.month = getSetMonth;
2550
+ momentPrototype__proto.daysInMonth = getDaysInMonth;
2551
+
2552
+ // Week
2553
+ momentPrototype__proto.week = momentPrototype__proto.weeks = getSetWeek;
2554
+ momentPrototype__proto.isoWeek = momentPrototype__proto.isoWeeks = getSetISOWeek;
2555
+ momentPrototype__proto.weeksInYear = getWeeksInYear;
2556
+ momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
2557
+
2558
+ // Day
2559
+ momentPrototype__proto.date = getSetDayOfMonth;
2560
+ momentPrototype__proto.day = momentPrototype__proto.days = getSetDayOfWeek;
2561
+ momentPrototype__proto.weekday = getSetLocaleDayOfWeek;
2562
+ momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
2563
+ momentPrototype__proto.dayOfYear = getSetDayOfYear;
2564
+
2565
+ // Hour
2566
+ momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
2567
+
2568
+ // Minute
2569
+ momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
2570
+
2571
+ // Second
2572
+ momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
2573
+
2574
+ // Millisecond
2575
+ momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
2576
+
2577
+ // Offset
2578
+ momentPrototype__proto.utcOffset = getSetOffset;
2579
+ momentPrototype__proto.utc = setOffsetToUTC;
2580
+ momentPrototype__proto.local = setOffsetToLocal;
2581
+ momentPrototype__proto.parseZone = setOffsetToParsedOffset;
2582
+ momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
2583
+ momentPrototype__proto.isDST = isDaylightSavingTime;
2584
+ momentPrototype__proto.isDSTShifted = isDaylightSavingTimeShifted;
2585
+ momentPrototype__proto.isLocal = isLocal;
2586
+ momentPrototype__proto.isUtcOffset = isUtcOffset;
2587
+ momentPrototype__proto.isUtc = isUtc;
2588
+ momentPrototype__proto.isUTC = isUtc;
2589
+
2590
+ // Timezone
2591
+ momentPrototype__proto.zoneAbbr = getZoneAbbr;
2592
+ momentPrototype__proto.zoneName = getZoneName;
2593
+
2594
+ // Deprecations
2595
+ momentPrototype__proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
2596
+ momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
2597
+ momentPrototype__proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
2598
+ momentPrototype__proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
2599
+
2600
+ var momentPrototype = momentPrototype__proto;
2601
+
2602
+ function moment__createUnix (input) {
2603
+ return local__createLocal(input * 1000);
2604
+ }
2605
+
2606
+ function moment__createInZone () {
2607
+ return local__createLocal.apply(null, arguments).parseZone();
2608
+ }
2609
+
2610
+ var defaultCalendar = {
2611
+ sameDay : '[Today at] LT',
2612
+ nextDay : '[Tomorrow at] LT',
2613
+ nextWeek : 'dddd [at] LT',
2614
+ lastDay : '[Yesterday at] LT',
2615
+ lastWeek : '[Last] dddd [at] LT',
2616
+ sameElse : 'L'
2617
+ };
2618
+
2619
+ function locale_calendar__calendar (key, mom, now) {
2620
+ var output = this._calendar[key];
2621
+ return typeof output === 'function' ? output.call(mom, now) : output;
2622
+ }
2623
+
2624
+ var defaultLongDateFormat = {
2625
+ LTS : 'h:mm:ss A',
2626
+ LT : 'h:mm A',
2627
+ L : 'MM/DD/YYYY',
2628
+ LL : 'MMMM D, YYYY',
2629
+ LLL : 'MMMM D, YYYY h:mm A',
2630
+ LLLL : 'dddd, MMMM D, YYYY h:mm A'
2631
+ };
2632
+
2633
+ function longDateFormat (key) {
2634
+ var format = this._longDateFormat[key],
2635
+ formatUpper = this._longDateFormat[key.toUpperCase()];
2636
+
2637
+ if (format || !formatUpper) {
2638
+ return format;
2639
+ }
2640
+
2641
+ this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
2642
+ return val.slice(1);
2643
+ });
2644
+
2645
+ return this._longDateFormat[key];
2646
+ }
2647
+
2648
+ var defaultInvalidDate = 'Invalid date';
2649
+
2650
+ function invalidDate () {
2651
+ return this._invalidDate;
2652
+ }
2653
+
2654
+ var defaultOrdinal = '%d';
2655
+ var defaultOrdinalParse = /\d{1,2}/;
2656
+
2657
+ function ordinal (number) {
2658
+ return this._ordinal.replace('%d', number);
2659
+ }
2660
+
2661
+ function preParsePostFormat (string) {
2662
+ return string;
2663
+ }
2664
+
2665
+ var defaultRelativeTime = {
2666
+ future : 'in %s',
2667
+ past : '%s ago',
2668
+ s : 'a few seconds',
2669
+ m : 'a minute',
2670
+ mm : '%d minutes',
2671
+ h : 'an hour',
2672
+ hh : '%d hours',
2673
+ d : 'a day',
2674
+ dd : '%d days',
2675
+ M : 'a month',
2676
+ MM : '%d months',
2677
+ y : 'a year',
2678
+ yy : '%d years'
2679
+ };
2680
+
2681
+ function relative__relativeTime (number, withoutSuffix, string, isFuture) {
2682
+ var output = this._relativeTime[string];
2683
+ return (typeof output === 'function') ?
2684
+ output(number, withoutSuffix, string, isFuture) :
2685
+ output.replace(/%d/i, number);
2686
+ }
2687
+
2688
+ function pastFuture (diff, output) {
2689
+ var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
2690
+ return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
2691
+ }
2692
+
2693
+ function locale_set__set (config) {
2694
+ var prop, i;
2695
+ for (i in config) {
2696
+ prop = config[i];
2697
+ if (typeof prop === 'function') {
2698
+ this[i] = prop;
2699
+ } else {
2700
+ this['_' + i] = prop;
2701
+ }
2702
+ }
2703
+ // Lenient ordinal parsing accepts just a number in addition to
2704
+ // number + (possibly) stuff coming from _ordinalParseLenient.
2705
+ this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
2706
+ }
2707
+
2708
+ var prototype__proto = Locale.prototype;
2709
+
2710
+ prototype__proto._calendar = defaultCalendar;
2711
+ prototype__proto.calendar = locale_calendar__calendar;
2712
+ prototype__proto._longDateFormat = defaultLongDateFormat;
2713
+ prototype__proto.longDateFormat = longDateFormat;
2714
+ prototype__proto._invalidDate = defaultInvalidDate;
2715
+ prototype__proto.invalidDate = invalidDate;
2716
+ prototype__proto._ordinal = defaultOrdinal;
2717
+ prototype__proto.ordinal = ordinal;
2718
+ prototype__proto._ordinalParse = defaultOrdinalParse;
2719
+ prototype__proto.preparse = preParsePostFormat;
2720
+ prototype__proto.postformat = preParsePostFormat;
2721
+ prototype__proto._relativeTime = defaultRelativeTime;
2722
+ prototype__proto.relativeTime = relative__relativeTime;
2723
+ prototype__proto.pastFuture = pastFuture;
2724
+ prototype__proto.set = locale_set__set;
2725
+
2726
+ // Month
2727
+ prototype__proto.months = localeMonths;
2728
+ prototype__proto._months = defaultLocaleMonths;
2729
+ prototype__proto.monthsShort = localeMonthsShort;
2730
+ prototype__proto._monthsShort = defaultLocaleMonthsShort;
2731
+ prototype__proto.monthsParse = localeMonthsParse;
2732
+
2733
+ // Week
2734
+ prototype__proto.week = localeWeek;
2735
+ prototype__proto._week = defaultLocaleWeek;
2736
+ prototype__proto.firstDayOfYear = localeFirstDayOfYear;
2737
+ prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
2738
+
2739
+ // Day of Week
2740
+ prototype__proto.weekdays = localeWeekdays;
2741
+ prototype__proto._weekdays = defaultLocaleWeekdays;
2742
+ prototype__proto.weekdaysMin = localeWeekdaysMin;
2743
+ prototype__proto._weekdaysMin = defaultLocaleWeekdaysMin;
2744
+ prototype__proto.weekdaysShort = localeWeekdaysShort;
2745
+ prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
2746
+ prototype__proto.weekdaysParse = localeWeekdaysParse;
2747
+
2748
+ // Hours
2749
+ prototype__proto.isPM = localeIsPM;
2750
+ prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
2751
+ prototype__proto.meridiem = localeMeridiem;
2752
+
2753
+ function lists__get (format, index, field, setter) {
2754
+ var locale = locale_locales__getLocale();
2755
+ var utc = create_utc__createUTC().set(setter, index);
2756
+ return locale[field](utc, format);
2757
+ }
2758
+
2759
+ function list (format, index, field, count, setter) {
2760
+ if (typeof format === 'number') {
2761
+ index = format;
2762
+ format = undefined;
2763
+ }
2764
+
2765
+ format = format || '';
2766
+
2767
+ if (index != null) {
2768
+ return lists__get(format, index, field, setter);
2769
+ }
2770
+
2771
+ var i;
2772
+ var out = [];
2773
+ for (i = 0; i < count; i++) {
2774
+ out[i] = lists__get(format, i, field, setter);
2775
+ }
2776
+ return out;
2777
+ }
2778
+
2779
+ function lists__listMonths (format, index) {
2780
+ return list(format, index, 'months', 12, 'month');
2781
+ }
2782
+
2783
+ function lists__listMonthsShort (format, index) {
2784
+ return list(format, index, 'monthsShort', 12, 'month');
2785
+ }
2786
+
2787
+ function lists__listWeekdays (format, index) {
2788
+ return list(format, index, 'weekdays', 7, 'day');
2789
+ }
2790
+
2791
+ function lists__listWeekdaysShort (format, index) {
2792
+ return list(format, index, 'weekdaysShort', 7, 'day');
2793
+ }
2794
+
2795
+ function lists__listWeekdaysMin (format, index) {
2796
+ return list(format, index, 'weekdaysMin', 7, 'day');
2797
+ }
2798
+
2799
+ locale_locales__getSetGlobalLocale('en', {
2800
+ ordinalParse: /\d{1,2}(th|st|nd|rd)/,
2801
+ ordinal : function (number) {
2802
+ var b = number % 10,
2803
+ output = (toInt(number % 100 / 10) === 1) ? 'th' :
2804
+ (b === 1) ? 'st' :
2805
+ (b === 2) ? 'nd' :
2806
+ (b === 3) ? 'rd' : 'th';
2807
+ return number + output;
2808
+ }
2809
+ });
2810
+
2811
+ // Side effect imports
2812
+ utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
2813
+ utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
2814
+
2815
+ var mathAbs = Math.abs;
2816
+
2817
+ function duration_abs__abs () {
2818
+ var data = this._data;
2819
+
2820
+ this._milliseconds = mathAbs(this._milliseconds);
2821
+ this._days = mathAbs(this._days);
2822
+ this._months = mathAbs(this._months);
2823
+
2824
+ data.milliseconds = mathAbs(data.milliseconds);
2825
+ data.seconds = mathAbs(data.seconds);
2826
+ data.minutes = mathAbs(data.minutes);
2827
+ data.hours = mathAbs(data.hours);
2828
+ data.months = mathAbs(data.months);
2829
+ data.years = mathAbs(data.years);
2830
+
2831
+ return this;
2832
+ }
2833
+
2834
+ function duration_add_subtract__addSubtract (duration, input, value, direction) {
2835
+ var other = create__createDuration(input, value);
2836
+
2837
+ duration._milliseconds += direction * other._milliseconds;
2838
+ duration._days += direction * other._days;
2839
+ duration._months += direction * other._months;
2840
+
2841
+ return duration._bubble();
2842
+ }
2843
+
2844
+ // supports only 2.0-style add(1, 's') or add(duration)
2845
+ function duration_add_subtract__add (input, value) {
2846
+ return duration_add_subtract__addSubtract(this, input, value, 1);
2847
+ }
2848
+
2849
+ // supports only 2.0-style subtract(1, 's') or subtract(duration)
2850
+ function duration_add_subtract__subtract (input, value) {
2851
+ return duration_add_subtract__addSubtract(this, input, value, -1);
2852
+ }
2853
+
2854
+ function absCeil (number) {
2855
+ if (number < 0) {
2856
+ return Math.floor(number);
2857
+ } else {
2858
+ return Math.ceil(number);
2859
+ }
2860
+ }
2861
+
2862
+ function bubble () {
2863
+ var milliseconds = this._milliseconds;
2864
+ var days = this._days;
2865
+ var months = this._months;
2866
+ var data = this._data;
2867
+ var seconds, minutes, hours, years, monthsFromDays;
2868
+
2869
+ // if we have a mix of positive and negative values, bubble down first
2870
+ // check: https://github.com/moment/moment/issues/2166
2871
+ if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
2872
+ (milliseconds <= 0 && days <= 0 && months <= 0))) {
2873
+ milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
2874
+ days = 0;
2875
+ months = 0;
2876
+ }
2877
+
2878
+ // The following code bubbles up values, see the tests for
2879
+ // examples of what that means.
2880
+ data.milliseconds = milliseconds % 1000;
2881
+
2882
+ seconds = absFloor(milliseconds / 1000);
2883
+ data.seconds = seconds % 60;
2884
+
2885
+ minutes = absFloor(seconds / 60);
2886
+ data.minutes = minutes % 60;
2887
+
2888
+ hours = absFloor(minutes / 60);
2889
+ data.hours = hours % 24;
2890
+
2891
+ days += absFloor(hours / 24);
2892
+
2893
+ // convert days to months
2894
+ monthsFromDays = absFloor(daysToMonths(days));
2895
+ months += monthsFromDays;
2896
+ days -= absCeil(monthsToDays(monthsFromDays));
2897
+
2898
+ // 12 months -> 1 year
2899
+ years = absFloor(months / 12);
2900
+ months %= 12;
2901
+
2902
+ data.days = days;
2903
+ data.months = months;
2904
+ data.years = years;
2905
+
2906
+ return this;
2907
+ }
2908
+
2909
+ function daysToMonths (days) {
2910
+ // 400 years have 146097 days (taking into account leap year rules)
2911
+ // 400 years have 12 months === 4800
2912
+ return days * 4800 / 146097;
2913
+ }
2914
+
2915
+ function monthsToDays (months) {
2916
+ // the reverse of daysToMonths
2917
+ return months * 146097 / 4800;
2918
+ }
2919
+
2920
+ function as (units) {
2921
+ var days;
2922
+ var months;
2923
+ var milliseconds = this._milliseconds;
2924
+
2925
+ units = normalizeUnits(units);
2926
+
2927
+ if (units === 'month' || units === 'year') {
2928
+ days = this._days + milliseconds / 864e5;
2929
+ months = this._months + daysToMonths(days);
2930
+ return units === 'month' ? months : months / 12;
2931
+ } else {
2932
+ // handle milliseconds separately because of floating point math errors (issue #1867)
2933
+ days = this._days + Math.round(monthsToDays(this._months));
2934
+ switch (units) {
2935
+ case 'week' : return days / 7 + milliseconds / 6048e5;
2936
+ case 'day' : return days + milliseconds / 864e5;
2937
+ case 'hour' : return days * 24 + milliseconds / 36e5;
2938
+ case 'minute' : return days * 1440 + milliseconds / 6e4;
2939
+ case 'second' : return days * 86400 + milliseconds / 1000;
2940
+ // Math.floor prevents floating point math errors here
2941
+ case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
2942
+ default: throw new Error('Unknown unit ' + units);
2943
+ }
2944
+ }
2945
+ }
2946
+
2947
+ // TODO: Use this.as('ms')?
2948
+ function duration_as__valueOf () {
2949
+ return (
2950
+ this._milliseconds +
2951
+ this._days * 864e5 +
2952
+ (this._months % 12) * 2592e6 +
2953
+ toInt(this._months / 12) * 31536e6
2954
+ );
2955
+ }
2956
+
2957
+ function makeAs (alias) {
2958
+ return function () {
2959
+ return this.as(alias);
2960
+ };
2961
+ }
2962
+
2963
+ var asMilliseconds = makeAs('ms');
2964
+ var asSeconds = makeAs('s');
2965
+ var asMinutes = makeAs('m');
2966
+ var asHours = makeAs('h');
2967
+ var asDays = makeAs('d');
2968
+ var asWeeks = makeAs('w');
2969
+ var asMonths = makeAs('M');
2970
+ var asYears = makeAs('y');
2971
+
2972
+ function duration_get__get (units) {
2973
+ units = normalizeUnits(units);
2974
+ return this[units + 's']();
2975
+ }
2976
+
2977
+ function makeGetter(name) {
2978
+ return function () {
2979
+ return this._data[name];
2980
+ };
2981
+ }
2982
+
2983
+ var milliseconds = makeGetter('milliseconds');
2984
+ var seconds = makeGetter('seconds');
2985
+ var minutes = makeGetter('minutes');
2986
+ var hours = makeGetter('hours');
2987
+ var days = makeGetter('days');
2988
+ var months = makeGetter('months');
2989
+ var years = makeGetter('years');
2990
+
2991
+ function weeks () {
2992
+ return absFloor(this.days() / 7);
2993
+ }
2994
+
2995
+ var round = Math.round;
2996
+ var thresholds = {
2997
+ s: 45, // seconds to minute
2998
+ m: 45, // minutes to hour
2999
+ h: 22, // hours to day
3000
+ d: 26, // days to month
3001
+ M: 11 // months to year
3002
+ };
3003
+
3004
+ // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
3005
+ function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
3006
+ return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
3007
+ }
3008
+
3009
+ function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
3010
+ var duration = create__createDuration(posNegDuration).abs();
3011
+ var seconds = round(duration.as('s'));
3012
+ var minutes = round(duration.as('m'));
3013
+ var hours = round(duration.as('h'));
3014
+ var days = round(duration.as('d'));
3015
+ var months = round(duration.as('M'));
3016
+ var years = round(duration.as('y'));
3017
+
3018
+ var a = seconds < thresholds.s && ['s', seconds] ||
3019
+ minutes === 1 && ['m'] ||
3020
+ minutes < thresholds.m && ['mm', minutes] ||
3021
+ hours === 1 && ['h'] ||
3022
+ hours < thresholds.h && ['hh', hours] ||
3023
+ days === 1 && ['d'] ||
3024
+ days < thresholds.d && ['dd', days] ||
3025
+ months === 1 && ['M'] ||
3026
+ months < thresholds.M && ['MM', months] ||
3027
+ years === 1 && ['y'] || ['yy', years];
3028
+
3029
+ a[2] = withoutSuffix;
3030
+ a[3] = +posNegDuration > 0;
3031
+ a[4] = locale;
3032
+ return substituteTimeAgo.apply(null, a);
3033
+ }
3034
+
3035
+ // This function allows you to set a threshold for relative time strings
3036
+ function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
3037
+ if (thresholds[threshold] === undefined) {
3038
+ return false;
3039
+ }
3040
+ if (limit === undefined) {
3041
+ return thresholds[threshold];
3042
+ }
3043
+ thresholds[threshold] = limit;
3044
+ return true;
3045
+ }
3046
+
3047
+ function humanize (withSuffix) {
3048
+ var locale = this.localeData();
3049
+ var output = duration_humanize__relativeTime(this, !withSuffix, locale);
3050
+
3051
+ if (withSuffix) {
3052
+ output = locale.pastFuture(+this, output);
3053
+ }
3054
+
3055
+ return locale.postformat(output);
3056
+ }
3057
+
3058
+ var iso_string__abs = Math.abs;
3059
+
3060
+ function iso_string__toISOString() {
3061
+ // for ISO strings we do not use the normal bubbling rules:
3062
+ // * milliseconds bubble up until they become hours
3063
+ // * days do not bubble at all
3064
+ // * months bubble up until they become years
3065
+ // This is because there is no context-free conversion between hours and days
3066
+ // (think of clock changes)
3067
+ // and also not between days and months (28-31 days per month)
3068
+ var seconds = iso_string__abs(this._milliseconds) / 1000;
3069
+ var days = iso_string__abs(this._days);
3070
+ var months = iso_string__abs(this._months);
3071
+ var minutes, hours, years;
3072
+
3073
+ // 3600 seconds -> 60 minutes -> 1 hour
3074
+ minutes = absFloor(seconds / 60);
3075
+ hours = absFloor(minutes / 60);
3076
+ seconds %= 60;
3077
+ minutes %= 60;
3078
+
3079
+ // 12 months -> 1 year
3080
+ years = absFloor(months / 12);
3081
+ months %= 12;
3082
+
3083
+
3084
+ // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
3085
+ var Y = years;
3086
+ var M = months;
3087
+ var D = days;
3088
+ var h = hours;
3089
+ var m = minutes;
3090
+ var s = seconds;
3091
+ var total = this.asSeconds();
3092
+
3093
+ if (!total) {
3094
+ // this is the same as C#'s (Noda) and python (isodate)...
3095
+ // but not other JS (goog.date)
3096
+ return 'P0D';
3097
+ }
3098
+
3099
+ return (total < 0 ? '-' : '') +
3100
+ 'P' +
3101
+ (Y ? Y + 'Y' : '') +
3102
+ (M ? M + 'M' : '') +
3103
+ (D ? D + 'D' : '') +
3104
+ ((h || m || s) ? 'T' : '') +
3105
+ (h ? h + 'H' : '') +
3106
+ (m ? m + 'M' : '') +
3107
+ (s ? s + 'S' : '');
3108
+ }
3109
+
3110
+ var duration_prototype__proto = Duration.prototype;
3111
+
3112
+ duration_prototype__proto.abs = duration_abs__abs;
3113
+ duration_prototype__proto.add = duration_add_subtract__add;
3114
+ duration_prototype__proto.subtract = duration_add_subtract__subtract;
3115
+ duration_prototype__proto.as = as;
3116
+ duration_prototype__proto.asMilliseconds = asMilliseconds;
3117
+ duration_prototype__proto.asSeconds = asSeconds;
3118
+ duration_prototype__proto.asMinutes = asMinutes;
3119
+ duration_prototype__proto.asHours = asHours;
3120
+ duration_prototype__proto.asDays = asDays;
3121
+ duration_prototype__proto.asWeeks = asWeeks;
3122
+ duration_prototype__proto.asMonths = asMonths;
3123
+ duration_prototype__proto.asYears = asYears;
3124
+ duration_prototype__proto.valueOf = duration_as__valueOf;
3125
+ duration_prototype__proto._bubble = bubble;
3126
+ duration_prototype__proto.get = duration_get__get;
3127
+ duration_prototype__proto.milliseconds = milliseconds;
3128
+ duration_prototype__proto.seconds = seconds;
3129
+ duration_prototype__proto.minutes = minutes;
3130
+ duration_prototype__proto.hours = hours;
3131
+ duration_prototype__proto.days = days;
3132
+ duration_prototype__proto.weeks = weeks;
3133
+ duration_prototype__proto.months = months;
3134
+ duration_prototype__proto.years = years;
3135
+ duration_prototype__proto.humanize = humanize;
3136
+ duration_prototype__proto.toISOString = iso_string__toISOString;
3137
+ duration_prototype__proto.toString = iso_string__toISOString;
3138
+ duration_prototype__proto.toJSON = iso_string__toISOString;
3139
+ duration_prototype__proto.locale = locale;
3140
+ duration_prototype__proto.localeData = localeData;
3141
+
3142
+ // Deprecations
3143
+ duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
3144
+ duration_prototype__proto.lang = lang;
3145
+
3146
+ // Side effect imports
3147
+
3148
+ addFormatToken('X', 0, 0, 'unix');
3149
+ addFormatToken('x', 0, 0, 'valueOf');
3150
+
3151
+ // PARSING
3152
+
3153
+ addRegexToken('x', matchSigned);
3154
+ addRegexToken('X', matchTimestamp);
3155
+ addParseToken('X', function (input, array, config) {
3156
+ config._d = new Date(parseFloat(input, 10) * 1000);
3157
+ });
3158
+ addParseToken('x', function (input, array, config) {
3159
+ config._d = new Date(toInt(input));
3160
+ });
3161
+
3162
+ // Side effect imports
3163
+
3164
+
3165
+ utils_hooks__hooks.version = '2.10.6';
3166
+
3167
+ setHookCallback(local__createLocal);
3168
+
3169
+ utils_hooks__hooks.fn = momentPrototype;
3170
+ utils_hooks__hooks.min = min;
3171
+ utils_hooks__hooks.max = max;
3172
+ utils_hooks__hooks.utc = create_utc__createUTC;
3173
+ utils_hooks__hooks.unix = moment__createUnix;
3174
+ utils_hooks__hooks.months = lists__listMonths;
3175
+ utils_hooks__hooks.isDate = isDate;
3176
+ utils_hooks__hooks.locale = locale_locales__getSetGlobalLocale;
3177
+ utils_hooks__hooks.invalid = valid__createInvalid;
3178
+ utils_hooks__hooks.duration = create__createDuration;
3179
+ utils_hooks__hooks.isMoment = isMoment;
3180
+ utils_hooks__hooks.weekdays = lists__listWeekdays;
3181
+ utils_hooks__hooks.parseZone = moment__createInZone;
3182
+ utils_hooks__hooks.localeData = locale_locales__getLocale;
3183
+ utils_hooks__hooks.isDuration = isDuration;
3184
+ utils_hooks__hooks.monthsShort = lists__listMonthsShort;
3185
+ utils_hooks__hooks.weekdaysMin = lists__listWeekdaysMin;
3186
+ utils_hooks__hooks.defineLocale = defineLocale;
3187
+ utils_hooks__hooks.weekdaysShort = lists__listWeekdaysShort;
3188
+ utils_hooks__hooks.normalizeUnits = normalizeUnits;
3189
+ utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
3190
+
3191
+ var _moment = utils_hooks__hooks;
3192
+
3193
+ return _moment;
3194
+
3195
+ }));