src/ceph/src/pybind/mgr/dashboard/static/AdminLTE-2.3.7/plugins/daterangepicker/moment.js

   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 }));