volt-daterange 0.1.0

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