[ Index ]

PHP Cross Reference of BuddyPress

title

Body

[close]

/src/bp-core/js/vendor/moment-js/ -> moment.js (source)

   1  //! moment.js
   2  //! version : 2.15.1
   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 input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
  27      }
  28  
  29      function isObject(input) {
  30          // IE8 will treat undefined and null as object if it wasn't for
  31          // input != null
  32          return input != null && Object.prototype.toString.call(input) === '[object Object]';
  33      }
  34  
  35      function isObjectEmpty(obj) {
  36          var k;
  37          for (k in obj) {
  38              // even if its not own property I'd still call it non-empty
  39              return false;
  40          }
  41          return true;
  42      }
  43  
  44      function isDate(input) {
  45          return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
  46      }
  47  
  48      function map(arr, fn) {
  49          var res = [], i;
  50          for (i = 0; i < arr.length; ++i) {
  51              res.push(fn(arr[i], i));
  52          }
  53          return res;
  54      }
  55  
  56      function hasOwnProp(a, b) {
  57          return Object.prototype.hasOwnProperty.call(a, b);
  58      }
  59  
  60      function extend(a, b) {
  61          for (var i in b) {
  62              if (hasOwnProp(b, i)) {
  63                  a[i] = b[i];
  64              }
  65          }
  66  
  67          if (hasOwnProp(b, 'toString')) {
  68              a.toString = b.toString;
  69          }
  70  
  71          if (hasOwnProp(b, 'valueOf')) {
  72              a.valueOf = b.valueOf;
  73          }
  74  
  75          return a;
  76      }
  77  
  78      function create_utc__createUTC (input, format, locale, strict) {
  79          return createLocalOrUTC(input, format, locale, strict, true).utc();
  80      }
  81  
  82      function defaultParsingFlags() {
  83          // We need to deep clone this object.
  84          return {
  85              empty           : false,
  86              unusedTokens    : [],
  87              unusedInput     : [],
  88              overflow        : -2,
  89              charsLeftOver   : 0,
  90              nullInput       : false,
  91              invalidMonth    : null,
  92              invalidFormat   : false,
  93              userInvalidated : false,
  94              iso             : false,
  95              parsedDateParts : [],
  96              meridiem        : null
  97          };
  98      }
  99  
 100      function getParsingFlags(m) {
 101          if (m._pf == null) {
 102              m._pf = defaultParsingFlags();
 103          }
 104          return m._pf;
 105      }
 106  
 107      var some;
 108      if (Array.prototype.some) {
 109          some = Array.prototype.some;
 110      } else {
 111          some = function (fun) {
 112              var t = Object(this);
 113              var len = t.length >>> 0;
 114  
 115              for (var i = 0; i < len; i++) {
 116                  if (i in t && fun.call(this, t[i], i, t)) {
 117                      return true;
 118                  }
 119              }
 120  
 121              return false;
 122          };
 123      }
 124  
 125      function valid__isValid(m) {
 126          if (m._isValid == null) {
 127              var flags = getParsingFlags(m);
 128              var parsedParts = some.call(flags.parsedDateParts, function (i) {
 129                  return i != null;
 130              });
 131              var isNowValid = !isNaN(m._d.getTime()) &&
 132                  flags.overflow < 0 &&
 133                  !flags.empty &&
 134                  !flags.invalidMonth &&
 135                  !flags.invalidWeekday &&
 136                  !flags.nullInput &&
 137                  !flags.invalidFormat &&
 138                  !flags.userInvalidated &&
 139                  (!flags.meridiem || (flags.meridiem && parsedParts));
 140  
 141              if (m._strict) {
 142                  isNowValid = isNowValid &&
 143                      flags.charsLeftOver === 0 &&
 144                      flags.unusedTokens.length === 0 &&
 145                      flags.bigHour === undefined;
 146              }
 147  
 148              if (Object.isFrozen == null || !Object.isFrozen(m)) {
 149                  m._isValid = isNowValid;
 150              }
 151              else {
 152                  return isNowValid;
 153              }
 154          }
 155          return m._isValid;
 156      }
 157  
 158      function valid__createInvalid (flags) {
 159          var m = create_utc__createUTC(NaN);
 160          if (flags != null) {
 161              extend(getParsingFlags(m), flags);
 162          }
 163          else {
 164              getParsingFlags(m).userInvalidated = true;
 165          }
 166  
 167          return m;
 168      }
 169  
 170      function isUndefined(input) {
 171          return input === void 0;
 172      }
 173  
 174      // Plugins that add properties should also add the key here (null value),
 175      // so we can properly clone ourselves.
 176      var momentProperties = utils_hooks__hooks.momentProperties = [];
 177  
 178      function copyConfig(to, from) {
 179          var i, prop, val;
 180  
 181          if (!isUndefined(from._isAMomentObject)) {
 182              to._isAMomentObject = from._isAMomentObject;
 183          }
 184          if (!isUndefined(from._i)) {
 185              to._i = from._i;
 186          }
 187          if (!isUndefined(from._f)) {
 188              to._f = from._f;
 189          }
 190          if (!isUndefined(from._l)) {
 191              to._l = from._l;
 192          }
 193          if (!isUndefined(from._strict)) {
 194              to._strict = from._strict;
 195          }
 196          if (!isUndefined(from._tzm)) {
 197              to._tzm = from._tzm;
 198          }
 199          if (!isUndefined(from._isUTC)) {
 200              to._isUTC = from._isUTC;
 201          }
 202          if (!isUndefined(from._offset)) {
 203              to._offset = from._offset;
 204          }
 205          if (!isUndefined(from._pf)) {
 206              to._pf = getParsingFlags(from);
 207          }
 208          if (!isUndefined(from._locale)) {
 209              to._locale = from._locale;
 210          }
 211  
 212          if (momentProperties.length > 0) {
 213              for (i in momentProperties) {
 214                  prop = momentProperties[i];
 215                  val = from[prop];
 216                  if (!isUndefined(val)) {
 217                      to[prop] = val;
 218                  }
 219              }
 220          }
 221  
 222          return to;
 223      }
 224  
 225      var updateInProgress = false;
 226  
 227      // Moment prototype object
 228      function Moment(config) {
 229          copyConfig(this, config);
 230          this._d = new Date(config._d != null ? config._d.getTime() : NaN);
 231          // Prevent infinite loop in case updateOffset creates new moment
 232          // objects.
 233          if (updateInProgress === false) {
 234              updateInProgress = true;
 235              utils_hooks__hooks.updateOffset(this);
 236              updateInProgress = false;
 237          }
 238      }
 239  
 240      function isMoment (obj) {
 241          return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
 242      }
 243  
 244      function absFloor (number) {
 245          if (number < 0) {
 246              // -0 -> 0
 247              return Math.ceil(number) || 0;
 248          } else {
 249              return Math.floor(number);
 250          }
 251      }
 252  
 253      function toInt(argumentForCoercion) {
 254          var coercedNumber = +argumentForCoercion,
 255              value = 0;
 256  
 257          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
 258              value = absFloor(coercedNumber);
 259          }
 260  
 261          return value;
 262      }
 263  
 264      // compare two arrays, return the number of differences
 265      function compareArrays(array1, array2, dontConvert) {
 266          var len = Math.min(array1.length, array2.length),
 267              lengthDiff = Math.abs(array1.length - array2.length),
 268              diffs = 0,
 269              i;
 270          for (i = 0; i < len; i++) {
 271              if ((dontConvert && array1[i] !== array2[i]) ||
 272                  (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
 273                  diffs++;
 274              }
 275          }
 276          return diffs + lengthDiff;
 277      }
 278  
 279      function warn(msg) {
 280          if (utils_hooks__hooks.suppressDeprecationWarnings === false &&
 281                  (typeof console !==  'undefined') && console.warn) {
 282              console.warn('Deprecation warning: ' + msg);
 283          }
 284      }
 285  
 286      function deprecate(msg, fn) {
 287          var firstTime = true;
 288  
 289          return extend(function () {
 290              if (utils_hooks__hooks.deprecationHandler != null) {
 291                  utils_hooks__hooks.deprecationHandler(null, msg);
 292              }
 293              if (firstTime) {
 294                  var args = [];
 295                  var arg;
 296                  for (var i = 0; i < arguments.length; i++) {
 297                      arg = '';
 298                      if (typeof arguments[i] === 'object') {
 299                          arg += '\n[' + i + '] ';
 300                          for (var key in arguments[0]) {
 301                              arg += key + ': ' + arguments[0][key] + ', ';
 302                          }
 303                          arg = arg.slice(0, -2); // Remove trailing comma and space
 304                      } else {
 305                          arg = arguments[i];
 306                      }
 307                      args.push(arg);
 308                  }
 309                  warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
 310                  firstTime = false;
 311              }
 312              return fn.apply(this, arguments);
 313          }, fn);
 314      }
 315  
 316      var deprecations = {};
 317  
 318      function deprecateSimple(name, msg) {
 319          if (utils_hooks__hooks.deprecationHandler != null) {
 320              utils_hooks__hooks.deprecationHandler(name, msg);
 321          }
 322          if (!deprecations[name]) {
 323              warn(msg);
 324              deprecations[name] = true;
 325          }
 326      }
 327  
 328      utils_hooks__hooks.suppressDeprecationWarnings = false;
 329      utils_hooks__hooks.deprecationHandler = null;
 330  
 331      function isFunction(input) {
 332          return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
 333      }
 334  
 335      function locale_set__set (config) {
 336          var prop, i;
 337          for (i in config) {
 338              prop = config[i];
 339              if (isFunction(prop)) {
 340                  this[i] = prop;
 341              } else {
 342                  this['_' + i] = prop;
 343              }
 344          }
 345          this._config = config;
 346          // Lenient ordinal parsing accepts just a number in addition to
 347          // number + (possibly) stuff coming from _ordinalParseLenient.
 348          this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
 349      }
 350  
 351      function mergeConfigs(parentConfig, childConfig) {
 352          var res = extend({}, parentConfig), prop;
 353          for (prop in childConfig) {
 354              if (hasOwnProp(childConfig, prop)) {
 355                  if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
 356                      res[prop] = {};
 357                      extend(res[prop], parentConfig[prop]);
 358                      extend(res[prop], childConfig[prop]);
 359                  } else if (childConfig[prop] != null) {
 360                      res[prop] = childConfig[prop];
 361                  } else {
 362                      delete res[prop];
 363                  }
 364              }
 365          }
 366          for (prop in parentConfig) {
 367              if (hasOwnProp(parentConfig, prop) &&
 368                      !hasOwnProp(childConfig, prop) &&
 369                      isObject(parentConfig[prop])) {
 370                  // make sure changes to properties don't modify parent config
 371                  res[prop] = extend({}, res[prop]);
 372              }
 373          }
 374          return res;
 375      }
 376  
 377      function Locale(config) {
 378          if (config != null) {
 379              this.set(config);
 380          }
 381      }
 382  
 383      var keys;
 384  
 385      if (Object.keys) {
 386          keys = Object.keys;
 387      } else {
 388          keys = function (obj) {
 389              var i, res = [];
 390              for (i in obj) {
 391                  if (hasOwnProp(obj, i)) {
 392                      res.push(i);
 393                  }
 394              }
 395              return res;
 396          };
 397      }
 398  
 399      var defaultCalendar = {
 400          sameDay : '[Today at] LT',
 401          nextDay : '[Tomorrow at] LT',
 402          nextWeek : 'dddd [at] LT',
 403          lastDay : '[Yesterday at] LT',
 404          lastWeek : '[Last] dddd [at] LT',
 405          sameElse : 'L'
 406      };
 407  
 408      function locale_calendar__calendar (key, mom, now) {
 409          var output = this._calendar[key] || this._calendar['sameElse'];
 410          return isFunction(output) ? output.call(mom, now) : output;
 411      }
 412  
 413      var defaultLongDateFormat = {
 414          LTS  : 'h:mm:ss A',
 415          LT   : 'h:mm A',
 416          L    : 'MM/DD/YYYY',
 417          LL   : 'MMMM D, YYYY',
 418          LLL  : 'MMMM D, YYYY h:mm A',
 419          LLLL : 'dddd, MMMM D, YYYY h:mm A'
 420      };
 421  
 422      function longDateFormat (key) {
 423          var format = this._longDateFormat[key],
 424              formatUpper = this._longDateFormat[key.toUpperCase()];
 425  
 426          if (format || !formatUpper) {
 427              return format;
 428          }
 429  
 430          this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
 431              return val.slice(1);
 432          });
 433  
 434          return this._longDateFormat[key];
 435      }
 436  
 437      var defaultInvalidDate = 'Invalid date';
 438  
 439      function invalidDate () {
 440          return this._invalidDate;
 441      }
 442  
 443      var defaultOrdinal = '%d';
 444      var defaultOrdinalParse = /\d{1,2}/;
 445  
 446      function ordinal (number) {
 447          return this._ordinal.replace('%d', number);
 448      }
 449  
 450      var defaultRelativeTime = {
 451          future : 'in %s',
 452          past   : '%s ago',
 453          s  : 'a few seconds',
 454          m  : 'a minute',
 455          mm : '%d minutes',
 456          h  : 'an hour',
 457          hh : '%d hours',
 458          d  : 'a day',
 459          dd : '%d days',
 460          M  : 'a month',
 461          MM : '%d months',
 462          y  : 'a year',
 463          yy : '%d years'
 464      };
 465  
 466      function relative__relativeTime (number, withoutSuffix, string, isFuture) {
 467          var output = this._relativeTime[string];
 468          return (isFunction(output)) ?
 469              output(number, withoutSuffix, string, isFuture) :
 470              output.replace(/%d/i, number);
 471      }
 472  
 473      function pastFuture (diff, output) {
 474          var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
 475          return isFunction(format) ? format(output) : format.replace(/%s/i, output);
 476      }
 477  
 478      var aliases = {};
 479  
 480      function addUnitAlias (unit, shorthand) {
 481          var lowerCase = unit.toLowerCase();
 482          aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
 483      }
 484  
 485      function normalizeUnits(units) {
 486          return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
 487      }
 488  
 489      function normalizeObjectUnits(inputObject) {
 490          var normalizedInput = {},
 491              normalizedProp,
 492              prop;
 493  
 494          for (prop in inputObject) {
 495              if (hasOwnProp(inputObject, prop)) {
 496                  normalizedProp = normalizeUnits(prop);
 497                  if (normalizedProp) {
 498                      normalizedInput[normalizedProp] = inputObject[prop];
 499                  }
 500              }
 501          }
 502  
 503          return normalizedInput;
 504      }
 505  
 506      var priorities = {};
 507  
 508      function addUnitPriority(unit, priority) {
 509          priorities[unit] = priority;
 510      }
 511  
 512      function getPrioritizedUnits(unitsObj) {
 513          var units = [];
 514          for (var u in unitsObj) {
 515              units.push({unit: u, priority: priorities[u]});
 516          }
 517          units.sort(function (a, b) {
 518              return a.priority - b.priority;
 519          });
 520          return units;
 521      }
 522  
 523      function makeGetSet (unit, keepTime) {
 524          return function (value) {
 525              if (value != null) {
 526                  get_set__set(this, unit, value);
 527                  utils_hooks__hooks.updateOffset(this, keepTime);
 528                  return this;
 529              } else {
 530                  return get_set__get(this, unit);
 531              }
 532          };
 533      }
 534  
 535      function get_set__get (mom, unit) {
 536          return mom.isValid() ?
 537              mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
 538      }
 539  
 540      function get_set__set (mom, unit, value) {
 541          if (mom.isValid()) {
 542              mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
 543          }
 544      }
 545  
 546      // MOMENTS
 547  
 548      function stringGet (units) {
 549          units = normalizeUnits(units);
 550          if (isFunction(this[units])) {
 551              return this[units]();
 552          }
 553          return this;
 554      }
 555  
 556  
 557      function stringSet (units, value) {
 558          if (typeof units === 'object') {
 559              units = normalizeObjectUnits(units);
 560              var prioritized = getPrioritizedUnits(units);
 561              for (var i = 0; i < prioritized.length; i++) {
 562                  this[prioritized[i].unit](units[prioritized[i].unit]);
 563              }
 564          } else {
 565              units = normalizeUnits(units);
 566              if (isFunction(this[units])) {
 567                  return this[units](value);
 568              }
 569          }
 570          return this;
 571      }
 572  
 573      function zeroFill(number, targetLength, forceSign) {
 574          var absNumber = '' + Math.abs(number),
 575              zerosToFill = targetLength - absNumber.length,
 576              sign = number >= 0;
 577          return (sign ? (forceSign ? '+' : '') : '-') +
 578              Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
 579      }
 580  
 581      var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
 582  
 583      var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
 584  
 585      var formatFunctions = {};
 586  
 587      var formatTokenFunctions = {};
 588  
 589      // token:    'M'
 590      // padded:   ['MM', 2]
 591      // ordinal:  'Mo'
 592      // callback: function () { this.month() + 1 }
 593      function addFormatToken (token, padded, ordinal, callback) {
 594          var func = callback;
 595          if (typeof callback === 'string') {
 596              func = function () {
 597                  return this[callback]();
 598              };
 599          }
 600          if (token) {
 601              formatTokenFunctions[token] = func;
 602          }
 603          if (padded) {
 604              formatTokenFunctions[padded[0]] = function () {
 605                  return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
 606              };
 607          }
 608          if (ordinal) {
 609              formatTokenFunctions[ordinal] = function () {
 610                  return this.localeData().ordinal(func.apply(this, arguments), token);
 611              };
 612          }
 613      }
 614  
 615      function removeFormattingTokens(input) {
 616          if (input.match(/\[[\s\S]/)) {
 617              return input.replace(/^\[|\]$/g, '');
 618          }
 619          return input.replace(/\\/g, '');
 620      }
 621  
 622      function makeFormatFunction(format) {
 623          var array = format.match(formattingTokens), i, length;
 624  
 625          for (i = 0, length = array.length; i < length; i++) {
 626              if (formatTokenFunctions[array[i]]) {
 627                  array[i] = formatTokenFunctions[array[i]];
 628              } else {
 629                  array[i] = removeFormattingTokens(array[i]);
 630              }
 631          }
 632  
 633          return function (mom) {
 634              var output = '', i;
 635              for (i = 0; i < length; i++) {
 636                  output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
 637              }
 638              return output;
 639          };
 640      }
 641  
 642      // format date using native date object
 643      function formatMoment(m, format) {
 644          if (!m.isValid()) {
 645              return m.localeData().invalidDate();
 646          }
 647  
 648          format = expandFormat(format, m.localeData());
 649          formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
 650  
 651          return formatFunctions[format](m);
 652      }
 653  
 654      function expandFormat(format, locale) {
 655          var i = 5;
 656  
 657          function replaceLongDateFormatTokens(input) {
 658              return locale.longDateFormat(input) || input;
 659          }
 660  
 661          localFormattingTokens.lastIndex = 0;
 662          while (i >= 0 && localFormattingTokens.test(format)) {
 663              format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
 664              localFormattingTokens.lastIndex = 0;
 665              i -= 1;
 666          }
 667  
 668          return format;
 669      }
 670  
 671      var match1         = /\d/;            //       0 - 9
 672      var match2         = /\d\d/;          //      00 - 99
 673      var match3         = /\d{3}/;         //     000 - 999
 674      var match4         = /\d{4}/;         //    0000 - 9999
 675      var match6         = /[+-]?\d{6}/;    // -999999 - 999999
 676      var match1to2      = /\d\d?/;         //       0 - 99
 677      var match3to4      = /\d\d\d\d?/;     //     999 - 9999
 678      var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
 679      var match1to3      = /\d{1,3}/;       //       0 - 999
 680      var match1to4      = /\d{1,4}/;       //       0 - 9999
 681      var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
 682  
 683      var matchUnsigned  = /\d+/;           //       0 - inf
 684      var matchSigned    = /[+-]?\d+/;      //    -inf - inf
 685  
 686      var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
 687      var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
 688  
 689      var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
 690  
 691      // any word (or two) characters or numbers including two/three word month in arabic.
 692      // includes scottish gaelic two word and hyphenated months
 693      var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
 694  
 695  
 696      var regexes = {};
 697  
 698      function addRegexToken (token, regex, strictRegex) {
 699          regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
 700              return (isStrict && strictRegex) ? strictRegex : regex;
 701          };
 702      }
 703  
 704      function getParseRegexForToken (token, config) {
 705          if (!hasOwnProp(regexes, token)) {
 706              return new RegExp(unescapeFormat(token));
 707          }
 708  
 709          return regexes[token](config._strict, config._locale);
 710      }
 711  
 712      // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
 713      function unescapeFormat(s) {
 714          return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
 715              return p1 || p2 || p3 || p4;
 716          }));
 717      }
 718  
 719      function regexEscape(s) {
 720          return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
 721      }
 722  
 723      var tokens = {};
 724  
 725      function addParseToken (token, callback) {
 726          var i, func = callback;
 727          if (typeof token === 'string') {
 728              token = [token];
 729          }
 730          if (typeof callback === 'number') {
 731              func = function (input, array) {
 732                  array[callback] = toInt(input);
 733              };
 734          }
 735          for (i = 0; i < token.length; i++) {
 736              tokens[token[i]] = func;
 737          }
 738      }
 739  
 740      function addWeekParseToken (token, callback) {
 741          addParseToken(token, function (input, array, config, token) {
 742              config._w = config._w || {};
 743              callback(input, config._w, config, token);
 744          });
 745      }
 746  
 747      function addTimeToArrayFromToken(token, input, config) {
 748          if (input != null && hasOwnProp(tokens, token)) {
 749              tokens[token](input, config._a, config, token);
 750          }
 751      }
 752  
 753      var YEAR = 0;
 754      var MONTH = 1;
 755      var DATE = 2;
 756      var HOUR = 3;
 757      var MINUTE = 4;
 758      var SECOND = 5;
 759      var MILLISECOND = 6;
 760      var WEEK = 7;
 761      var WEEKDAY = 8;
 762  
 763      var indexOf;
 764  
 765      if (Array.prototype.indexOf) {
 766          indexOf = Array.prototype.indexOf;
 767      } else {
 768          indexOf = function (o) {
 769              // I know
 770              var i;
 771              for (i = 0; i < this.length; ++i) {
 772                  if (this[i] === o) {
 773                      return i;
 774                  }
 775              }
 776              return -1;
 777          };
 778      }
 779  
 780      function daysInMonth(year, month) {
 781          return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
 782      }
 783  
 784      // FORMATTING
 785  
 786      addFormatToken('M', ['MM', 2], 'Mo', function () {
 787          return this.month() + 1;
 788      });
 789  
 790      addFormatToken('MMM', 0, 0, function (format) {
 791          return this.localeData().monthsShort(this, format);
 792      });
 793  
 794      addFormatToken('MMMM', 0, 0, function (format) {
 795          return this.localeData().months(this, format);
 796      });
 797  
 798      // ALIASES
 799  
 800      addUnitAlias('month', 'M');
 801  
 802      // PRIORITY
 803  
 804      addUnitPriority('month', 8);
 805  
 806      // PARSING
 807  
 808      addRegexToken('M',    match1to2);
 809      addRegexToken('MM',   match1to2, match2);
 810      addRegexToken('MMM',  function (isStrict, locale) {
 811          return locale.monthsShortRegex(isStrict);
 812      });
 813      addRegexToken('MMMM', function (isStrict, locale) {
 814          return locale.monthsRegex(isStrict);
 815      });
 816  
 817      addParseToken(['M', 'MM'], function (input, array) {
 818          array[MONTH] = toInt(input) - 1;
 819      });
 820  
 821      addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
 822          var month = config._locale.monthsParse(input, token, config._strict);
 823          // if we didn't find a month name, mark the date as invalid.
 824          if (month != null) {
 825              array[MONTH] = month;
 826          } else {
 827              getParsingFlags(config).invalidMonth = input;
 828          }
 829      });
 830  
 831      // LOCALES
 832  
 833      var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/;
 834      var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
 835      function localeMonths (m, format) {
 836          if (!m) {
 837              return this._months;
 838          }
 839          return isArray(this._months) ? this._months[m.month()] :
 840              this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
 841      }
 842  
 843      var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
 844      function localeMonthsShort (m, format) {
 845          if (!m) {
 846              return this._monthsShort;
 847          }
 848          return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
 849              this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
 850      }
 851  
 852      function units_month__handleStrictParse(monthName, format, strict) {
 853          var i, ii, mom, llc = monthName.toLocaleLowerCase();
 854          if (!this._monthsParse) {
 855              // this is not used
 856              this._monthsParse = [];
 857              this._longMonthsParse = [];
 858              this._shortMonthsParse = [];
 859              for (i = 0; i < 12; ++i) {
 860                  mom = create_utc__createUTC([2000, i]);
 861                  this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
 862                  this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
 863              }
 864          }
 865  
 866          if (strict) {
 867              if (format === 'MMM') {
 868                  ii = indexOf.call(this._shortMonthsParse, llc);
 869                  return ii !== -1 ? ii : null;
 870              } else {
 871                  ii = indexOf.call(this._longMonthsParse, llc);
 872                  return ii !== -1 ? ii : null;
 873              }
 874          } else {
 875              if (format === 'MMM') {
 876                  ii = indexOf.call(this._shortMonthsParse, llc);
 877                  if (ii !== -1) {
 878                      return ii;
 879                  }
 880                  ii = indexOf.call(this._longMonthsParse, llc);
 881                  return ii !== -1 ? ii : null;
 882              } else {
 883                  ii = indexOf.call(this._longMonthsParse, llc);
 884                  if (ii !== -1) {
 885                      return ii;
 886                  }
 887                  ii = indexOf.call(this._shortMonthsParse, llc);
 888                  return ii !== -1 ? ii : null;
 889              }
 890          }
 891      }
 892  
 893      function localeMonthsParse (monthName, format, strict) {
 894          var i, mom, regex;
 895  
 896          if (this._monthsParseExact) {
 897              return units_month__handleStrictParse.call(this, monthName, format, strict);
 898          }
 899  
 900          if (!this._monthsParse) {
 901              this._monthsParse = [];
 902              this._longMonthsParse = [];
 903              this._shortMonthsParse = [];
 904          }
 905  
 906          // TODO: add sorting
 907          // Sorting makes sure if one month (or abbr) is a prefix of another
 908          // see sorting in computeMonthsParse
 909          for (i = 0; i < 12; i++) {
 910              // make the regex if we don't have it already
 911              mom = create_utc__createUTC([2000, i]);
 912              if (strict && !this._longMonthsParse[i]) {
 913                  this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
 914                  this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
 915              }
 916              if (!strict && !this._monthsParse[i]) {
 917                  regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
 918                  this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
 919              }
 920              // test the regex
 921              if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
 922                  return i;
 923              } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
 924                  return i;
 925              } else if (!strict && this._monthsParse[i].test(monthName)) {
 926                  return i;
 927              }
 928          }
 929      }
 930  
 931      // MOMENTS
 932  
 933      function setMonth (mom, value) {
 934          var dayOfMonth;
 935  
 936          if (!mom.isValid()) {
 937              // No op
 938              return mom;
 939          }
 940  
 941          if (typeof value === 'string') {
 942              if (/^\d+$/.test(value)) {
 943                  value = toInt(value);
 944              } else {
 945                  value = mom.localeData().monthsParse(value);
 946                  // TODO: Another silent failure?
 947                  if (typeof value !== 'number') {
 948                      return mom;
 949                  }
 950              }
 951          }
 952  
 953          dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
 954          mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
 955          return mom;
 956      }
 957  
 958      function getSetMonth (value) {
 959          if (value != null) {
 960              setMonth(this, value);
 961              utils_hooks__hooks.updateOffset(this, true);
 962              return this;
 963          } else {
 964              return get_set__get(this, 'Month');
 965          }
 966      }
 967  
 968      function getDaysInMonth () {
 969          return daysInMonth(this.year(), this.month());
 970      }
 971  
 972      var defaultMonthsShortRegex = matchWord;
 973      function monthsShortRegex (isStrict) {
 974          if (this._monthsParseExact) {
 975              if (!hasOwnProp(this, '_monthsRegex')) {
 976                  computeMonthsParse.call(this);
 977              }
 978              if (isStrict) {
 979                  return this._monthsShortStrictRegex;
 980              } else {
 981                  return this._monthsShortRegex;
 982              }
 983          } else {
 984              if (!hasOwnProp(this, '_monthsShortRegex')) {
 985                  this._monthsShortRegex = defaultMonthsShortRegex;
 986              }
 987              return this._monthsShortStrictRegex && isStrict ?
 988                  this._monthsShortStrictRegex : this._monthsShortRegex;
 989          }
 990      }
 991  
 992      var defaultMonthsRegex = matchWord;
 993      function monthsRegex (isStrict) {
 994          if (this._monthsParseExact) {
 995              if (!hasOwnProp(this, '_monthsRegex')) {
 996                  computeMonthsParse.call(this);
 997              }
 998              if (isStrict) {
 999                  return this._monthsStrictRegex;
1000              } else {
1001                  return this._monthsRegex;
1002              }
1003          } else {
1004              if (!hasOwnProp(this, '_monthsRegex')) {
1005                  this._monthsRegex = defaultMonthsRegex;
1006              }
1007              return this._monthsStrictRegex && isStrict ?
1008                  this._monthsStrictRegex : this._monthsRegex;
1009          }
1010      }
1011  
1012      function computeMonthsParse () {
1013          function cmpLenRev(a, b) {
1014              return b.length - a.length;
1015          }
1016  
1017          var shortPieces = [], longPieces = [], mixedPieces = [],
1018              i, mom;
1019          for (i = 0; i < 12; i++) {
1020              // make the regex if we don't have it already
1021              mom = create_utc__createUTC([2000, i]);
1022              shortPieces.push(this.monthsShort(mom, ''));
1023              longPieces.push(this.months(mom, ''));
1024              mixedPieces.push(this.months(mom, ''));
1025              mixedPieces.push(this.monthsShort(mom, ''));
1026          }
1027          // Sorting makes sure if one month (or abbr) is a prefix of another it
1028          // will match the longer piece.
1029          shortPieces.sort(cmpLenRev);
1030          longPieces.sort(cmpLenRev);
1031          mixedPieces.sort(cmpLenRev);
1032          for (i = 0; i < 12; i++) {
1033              shortPieces[i] = regexEscape(shortPieces[i]);
1034              longPieces[i] = regexEscape(longPieces[i]);
1035          }
1036          for (i = 0; i < 24; i++) {
1037              mixedPieces[i] = regexEscape(mixedPieces[i]);
1038          }
1039  
1040          this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1041          this._monthsShortRegex = this._monthsRegex;
1042          this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1043          this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1044      }
1045  
1046      // FORMATTING
1047  
1048      addFormatToken('Y', 0, 0, function () {
1049          var y = this.year();
1050          return y <= 9999 ? '' + y : '+' + y;
1051      });
1052  
1053      addFormatToken(0, ['YY', 2], 0, function () {
1054          return this.year() % 100;
1055      });
1056  
1057      addFormatToken(0, ['YYYY',   4],       0, 'year');
1058      addFormatToken(0, ['YYYYY',  5],       0, 'year');
1059      addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
1060  
1061      // ALIASES
1062  
1063      addUnitAlias('year', 'y');
1064  
1065      // PRIORITIES
1066  
1067      addUnitPriority('year', 1);
1068  
1069      // PARSING
1070  
1071      addRegexToken('Y',      matchSigned);
1072      addRegexToken('YY',     match1to2, match2);
1073      addRegexToken('YYYY',   match1to4, match4);
1074      addRegexToken('YYYYY',  match1to6, match6);
1075      addRegexToken('YYYYYY', match1to6, match6);
1076  
1077      addParseToken(['YYYYY', 'YYYYYY'], YEAR);
1078      addParseToken('YYYY', function (input, array) {
1079          array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input);
1080      });
1081      addParseToken('YY', function (input, array) {
1082          array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
1083      });
1084      addParseToken('Y', function (input, array) {
1085          array[YEAR] = parseInt(input, 10);
1086      });
1087  
1088      // HELPERS
1089  
1090      function daysInYear(year) {
1091          return isLeapYear(year) ? 366 : 365;
1092      }
1093  
1094      function isLeapYear(year) {
1095          return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
1096      }
1097  
1098      // HOOKS
1099  
1100      utils_hooks__hooks.parseTwoDigitYear = function (input) {
1101          return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
1102      };
1103  
1104      // MOMENTS
1105  
1106      var getSetYear = makeGetSet('FullYear', true);
1107  
1108      function getIsLeapYear () {
1109          return isLeapYear(this.year());
1110      }
1111  
1112      function createDate (y, m, d, h, M, s, ms) {
1113          //can't just apply() to create a date:
1114          //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
1115          var date = new Date(y, m, d, h, M, s, ms);
1116  
1117          //the date constructor remaps years 0-99 to 1900-1999
1118          if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
1119              date.setFullYear(y);
1120          }
1121          return date;
1122      }
1123  
1124      function createUTCDate (y) {
1125          var date = new Date(Date.UTC.apply(null, arguments));
1126  
1127          //the Date.UTC function remaps years 0-99 to 1900-1999
1128          if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
1129              date.setUTCFullYear(y);
1130          }
1131          return date;
1132      }
1133  
1134      // start-of-first-week - start-of-year
1135      function firstWeekOffset(year, dow, doy) {
1136          var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1137              fwd = 7 + dow - doy,
1138              // first-week day local weekday -- which local weekday is fwd
1139              fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1140  
1141          return -fwdlw + fwd - 1;
1142      }
1143  
1144      //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1145      function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1146          var localWeekday = (7 + weekday - dow) % 7,
1147              weekOffset = firstWeekOffset(year, dow, doy),
1148              dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1149              resYear, resDayOfYear;
1150  
1151          if (dayOfYear <= 0) {
1152              resYear = year - 1;
1153              resDayOfYear = daysInYear(resYear) + dayOfYear;
1154          } else if (dayOfYear > daysInYear(year)) {
1155              resYear = year + 1;
1156              resDayOfYear = dayOfYear - daysInYear(year);
1157          } else {
1158              resYear = year;
1159              resDayOfYear = dayOfYear;
1160          }
1161  
1162          return {
1163              year: resYear,
1164              dayOfYear: resDayOfYear
1165          };
1166      }
1167  
1168      function weekOfYear(mom, dow, doy) {
1169          var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1170              week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1171              resWeek, resYear;
1172  
1173          if (week < 1) {
1174              resYear = mom.year() - 1;
1175              resWeek = week + weeksInYear(resYear, dow, doy);
1176          } else if (week > weeksInYear(mom.year(), dow, doy)) {
1177              resWeek = week - weeksInYear(mom.year(), dow, doy);
1178              resYear = mom.year() + 1;
1179          } else {
1180              resYear = mom.year();
1181              resWeek = week;
1182          }
1183  
1184          return {
1185              week: resWeek,
1186              year: resYear
1187          };
1188      }
1189  
1190      function weeksInYear(year, dow, doy) {
1191          var weekOffset = firstWeekOffset(year, dow, doy),
1192              weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1193          return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1194      }
1195  
1196      // FORMATTING
1197  
1198      addFormatToken('w', ['ww', 2], 'wo', 'week');
1199      addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1200  
1201      // ALIASES
1202  
1203      addUnitAlias('week', 'w');
1204      addUnitAlias('isoWeek', 'W');
1205  
1206      // PRIORITIES
1207  
1208      addUnitPriority('week', 5);
1209      addUnitPriority('isoWeek', 5);
1210  
1211      // PARSING
1212  
1213      addRegexToken('w',  match1to2);
1214      addRegexToken('ww', match1to2, match2);
1215      addRegexToken('W',  match1to2);
1216      addRegexToken('WW', match1to2, match2);
1217  
1218      addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
1219          week[token.substr(0, 1)] = toInt(input);
1220      });
1221  
1222      // HELPERS
1223  
1224      // LOCALES
1225  
1226      function localeWeek (mom) {
1227          return weekOfYear(mom, this._week.dow, this._week.doy).week;
1228      }
1229  
1230      var defaultLocaleWeek = {
1231          dow : 0, // Sunday is the first day of the week.
1232          doy : 6  // The week that contains Jan 1st is the first week of the year.
1233      };
1234  
1235      function localeFirstDayOfWeek () {
1236          return this._week.dow;
1237      }
1238  
1239      function localeFirstDayOfYear () {
1240          return this._week.doy;
1241      }
1242  
1243      // MOMENTS
1244  
1245      function getSetWeek (input) {
1246          var week = this.localeData().week(this);
1247          return input == null ? week : this.add((input - week) * 7, 'd');
1248      }
1249  
1250      function getSetISOWeek (input) {
1251          var week = weekOfYear(this, 1, 4).week;
1252          return input == null ? week : this.add((input - week) * 7, 'd');
1253      }
1254  
1255      // FORMATTING
1256  
1257      addFormatToken('d', 0, 'do', 'day');
1258  
1259      addFormatToken('dd', 0, 0, function (format) {
1260          return this.localeData().weekdaysMin(this, format);
1261      });
1262  
1263      addFormatToken('ddd', 0, 0, function (format) {
1264          return this.localeData().weekdaysShort(this, format);
1265      });
1266  
1267      addFormatToken('dddd', 0, 0, function (format) {
1268          return this.localeData().weekdays(this, format);
1269      });
1270  
1271      addFormatToken('e', 0, 0, 'weekday');
1272      addFormatToken('E', 0, 0, 'isoWeekday');
1273  
1274      // ALIASES
1275  
1276      addUnitAlias('day', 'd');
1277      addUnitAlias('weekday', 'e');
1278      addUnitAlias('isoWeekday', 'E');
1279  
1280      // PRIORITY
1281      addUnitPriority('day', 11);
1282      addUnitPriority('weekday', 11);
1283      addUnitPriority('isoWeekday', 11);
1284  
1285      // PARSING
1286  
1287      addRegexToken('d',    match1to2);
1288      addRegexToken('e',    match1to2);
1289      addRegexToken('E',    match1to2);
1290      addRegexToken('dd',   function (isStrict, locale) {
1291          return locale.weekdaysMinRegex(isStrict);
1292      });
1293      addRegexToken('ddd',   function (isStrict, locale) {
1294          return locale.weekdaysShortRegex(isStrict);
1295      });
1296      addRegexToken('dddd',   function (isStrict, locale) {
1297          return locale.weekdaysRegex(isStrict);
1298      });
1299  
1300      addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1301          var weekday = config._locale.weekdaysParse(input, token, config._strict);
1302          // if we didn't get a weekday name, mark the date as invalid
1303          if (weekday != null) {
1304              week.d = weekday;
1305          } else {
1306              getParsingFlags(config).invalidWeekday = input;
1307          }
1308      });
1309  
1310      addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1311          week[token] = toInt(input);
1312      });
1313  
1314      // HELPERS
1315  
1316      function parseWeekday(input, locale) {
1317          if (typeof input !== 'string') {
1318              return input;
1319          }
1320  
1321          if (!isNaN(input)) {
1322              return parseInt(input, 10);
1323          }
1324  
1325          input = locale.weekdaysParse(input);
1326          if (typeof input === 'number') {
1327              return input;
1328          }
1329  
1330          return null;
1331      }
1332  
1333      function parseIsoWeekday(input, locale) {
1334          if (typeof input === 'string') {
1335              return locale.weekdaysParse(input) % 7 || 7;
1336          }
1337          return isNaN(input) ? null : input;
1338      }
1339  
1340      // LOCALES
1341  
1342      var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
1343      function localeWeekdays (m, format) {
1344          if (!m) {
1345              return this._weekdays;
1346          }
1347          return isArray(this._weekdays) ? this._weekdays[m.day()] :
1348              this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
1349      }
1350  
1351      var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
1352      function localeWeekdaysShort (m) {
1353          return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
1354      }
1355  
1356      var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
1357      function localeWeekdaysMin (m) {
1358          return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
1359      }
1360  
1361      function day_of_week__handleStrictParse(weekdayName, format, strict) {
1362          var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
1363          if (!this._weekdaysParse) {
1364              this._weekdaysParse = [];
1365              this._shortWeekdaysParse = [];
1366              this._minWeekdaysParse = [];
1367  
1368              for (i = 0; i < 7; ++i) {
1369                  mom = create_utc__createUTC([2000, 1]).day(i);
1370                  this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
1371                  this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
1372                  this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1373              }
1374          }
1375  
1376          if (strict) {
1377              if (format === 'dddd') {
1378                  ii = indexOf.call(this._weekdaysParse, llc);
1379                  return ii !== -1 ? ii : null;
1380              } else if (format === 'ddd') {
1381                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1382                  return ii !== -1 ? ii : null;
1383              } else {
1384                  ii = indexOf.call(this._minWeekdaysParse, llc);
1385                  return ii !== -1 ? ii : null;
1386              }
1387          } else {
1388              if (format === 'dddd') {
1389                  ii = indexOf.call(this._weekdaysParse, llc);
1390                  if (ii !== -1) {
1391                      return ii;
1392                  }
1393                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1394                  if (ii !== -1) {
1395                      return ii;
1396                  }
1397                  ii = indexOf.call(this._minWeekdaysParse, llc);
1398                  return ii !== -1 ? ii : null;
1399              } else if (format === 'ddd') {
1400                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1401                  if (ii !== -1) {
1402                      return ii;
1403                  }
1404                  ii = indexOf.call(this._weekdaysParse, llc);
1405                  if (ii !== -1) {
1406                      return ii;
1407                  }
1408                  ii = indexOf.call(this._minWeekdaysParse, llc);
1409                  return ii !== -1 ? ii : null;
1410              } else {
1411                  ii = indexOf.call(this._minWeekdaysParse, llc);
1412                  if (ii !== -1) {
1413                      return ii;
1414                  }
1415                  ii = indexOf.call(this._weekdaysParse, llc);
1416                  if (ii !== -1) {
1417                      return ii;
1418                  }
1419                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1420                  return ii !== -1 ? ii : null;
1421              }
1422          }
1423      }
1424  
1425      function localeWeekdaysParse (weekdayName, format, strict) {
1426          var i, mom, regex;
1427  
1428          if (this._weekdaysParseExact) {
1429              return day_of_week__handleStrictParse.call(this, weekdayName, format, strict);
1430          }
1431  
1432          if (!this._weekdaysParse) {
1433              this._weekdaysParse = [];
1434              this._minWeekdaysParse = [];
1435              this._shortWeekdaysParse = [];
1436              this._fullWeekdaysParse = [];
1437          }
1438  
1439          for (i = 0; i < 7; i++) {
1440              // make the regex if we don't have it already
1441  
1442              mom = create_utc__createUTC([2000, 1]).day(i);
1443              if (strict && !this._fullWeekdaysParse[i]) {
1444                  this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
1445                  this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
1446                  this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
1447              }
1448              if (!this._weekdaysParse[i]) {
1449                  regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
1450                  this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
1451              }
1452              // test the regex
1453              if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
1454                  return i;
1455              } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
1456                  return i;
1457              } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
1458                  return i;
1459              } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
1460                  return i;
1461              }
1462          }
1463      }
1464  
1465      // MOMENTS
1466  
1467      function getSetDayOfWeek (input) {
1468          if (!this.isValid()) {
1469              return input != null ? this : NaN;
1470          }
1471          var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1472          if (input != null) {
1473              input = parseWeekday(input, this.localeData());
1474              return this.add(input - day, 'd');
1475          } else {
1476              return day;
1477          }
1478      }
1479  
1480      function getSetLocaleDayOfWeek (input) {
1481          if (!this.isValid()) {
1482              return input != null ? this : NaN;
1483          }
1484          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1485          return input == null ? weekday : this.add(input - weekday, 'd');
1486      }
1487  
1488      function getSetISODayOfWeek (input) {
1489          if (!this.isValid()) {
1490              return input != null ? this : NaN;
1491          }
1492  
1493          // behaves the same as moment#day except
1494          // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1495          // as a setter, sunday should belong to the previous week.
1496  
1497          if (input != null) {
1498              var weekday = parseIsoWeekday(input, this.localeData());
1499              return this.day(this.day() % 7 ? weekday : weekday - 7);
1500          } else {
1501              return this.day() || 7;
1502          }
1503      }
1504  
1505      var defaultWeekdaysRegex = matchWord;
1506      function weekdaysRegex (isStrict) {
1507          if (this._weekdaysParseExact) {
1508              if (!hasOwnProp(this, '_weekdaysRegex')) {
1509                  computeWeekdaysParse.call(this);
1510              }
1511              if (isStrict) {
1512                  return this._weekdaysStrictRegex;
1513              } else {
1514                  return this._weekdaysRegex;
1515              }
1516          } else {
1517              if (!hasOwnProp(this, '_weekdaysRegex')) {
1518                  this._weekdaysRegex = defaultWeekdaysRegex;
1519              }
1520              return this._weekdaysStrictRegex && isStrict ?
1521                  this._weekdaysStrictRegex : this._weekdaysRegex;
1522          }
1523      }
1524  
1525      var defaultWeekdaysShortRegex = matchWord;
1526      function weekdaysShortRegex (isStrict) {
1527          if (this._weekdaysParseExact) {
1528              if (!hasOwnProp(this, '_weekdaysRegex')) {
1529                  computeWeekdaysParse.call(this);
1530              }
1531              if (isStrict) {
1532                  return this._weekdaysShortStrictRegex;
1533              } else {
1534                  return this._weekdaysShortRegex;
1535              }
1536          } else {
1537              if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1538                  this._weekdaysShortRegex = defaultWeekdaysShortRegex;
1539              }
1540              return this._weekdaysShortStrictRegex && isStrict ?
1541                  this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
1542          }
1543      }
1544  
1545      var defaultWeekdaysMinRegex = matchWord;
1546      function weekdaysMinRegex (isStrict) {
1547          if (this._weekdaysParseExact) {
1548              if (!hasOwnProp(this, '_weekdaysRegex')) {
1549                  computeWeekdaysParse.call(this);
1550              }
1551              if (isStrict) {
1552                  return this._weekdaysMinStrictRegex;
1553              } else {
1554                  return this._weekdaysMinRegex;
1555              }
1556          } else {
1557              if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1558                  this._weekdaysMinRegex = defaultWeekdaysMinRegex;
1559              }
1560              return this._weekdaysMinStrictRegex && isStrict ?
1561                  this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
1562          }
1563      }
1564  
1565  
1566      function computeWeekdaysParse () {
1567          function cmpLenRev(a, b) {
1568              return b.length - a.length;
1569          }
1570  
1571          var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
1572              i, mom, minp, shortp, longp;
1573          for (i = 0; i < 7; i++) {
1574              // make the regex if we don't have it already
1575              mom = create_utc__createUTC([2000, 1]).day(i);
1576              minp = this.weekdaysMin(mom, '');
1577              shortp = this.weekdaysShort(mom, '');
1578              longp = this.weekdays(mom, '');
1579              minPieces.push(minp);
1580              shortPieces.push(shortp);
1581              longPieces.push(longp);
1582              mixedPieces.push(minp);
1583              mixedPieces.push(shortp);
1584              mixedPieces.push(longp);
1585          }
1586          // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1587          // will match the longer piece.
1588          minPieces.sort(cmpLenRev);
1589          shortPieces.sort(cmpLenRev);
1590          longPieces.sort(cmpLenRev);
1591          mixedPieces.sort(cmpLenRev);
1592          for (i = 0; i < 7; i++) {
1593              shortPieces[i] = regexEscape(shortPieces[i]);
1594              longPieces[i] = regexEscape(longPieces[i]);
1595              mixedPieces[i] = regexEscape(mixedPieces[i]);
1596          }
1597  
1598          this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1599          this._weekdaysShortRegex = this._weekdaysRegex;
1600          this._weekdaysMinRegex = this._weekdaysRegex;
1601  
1602          this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1603          this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1604          this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
1605      }
1606  
1607      // FORMATTING
1608  
1609      function hFormat() {
1610          return this.hours() % 12 || 12;
1611      }
1612  
1613      function kFormat() {
1614          return this.hours() || 24;
1615      }
1616  
1617      addFormatToken('H', ['HH', 2], 0, 'hour');
1618      addFormatToken('h', ['hh', 2], 0, hFormat);
1619      addFormatToken('k', ['kk', 2], 0, kFormat);
1620  
1621      addFormatToken('hmm', 0, 0, function () {
1622          return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
1623      });
1624  
1625      addFormatToken('hmmss', 0, 0, function () {
1626          return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
1627              zeroFill(this.seconds(), 2);
1628      });
1629  
1630      addFormatToken('Hmm', 0, 0, function () {
1631          return '' + this.hours() + zeroFill(this.minutes(), 2);
1632      });
1633  
1634      addFormatToken('Hmmss', 0, 0, function () {
1635          return '' + this.hours() + zeroFill(this.minutes(), 2) +
1636              zeroFill(this.seconds(), 2);
1637      });
1638  
1639      function meridiem (token, lowercase) {
1640          addFormatToken(token, 0, 0, function () {
1641              return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
1642          });
1643      }
1644  
1645      meridiem('a', true);
1646      meridiem('A', false);
1647  
1648      // ALIASES
1649  
1650      addUnitAlias('hour', 'h');
1651  
1652      // PRIORITY
1653      addUnitPriority('hour', 13);
1654  
1655      // PARSING
1656  
1657      function matchMeridiem (isStrict, locale) {
1658          return locale._meridiemParse;
1659      }
1660  
1661      addRegexToken('a',  matchMeridiem);
1662      addRegexToken('A',  matchMeridiem);
1663      addRegexToken('H',  match1to2);
1664      addRegexToken('h',  match1to2);
1665      addRegexToken('HH', match1to2, match2);
1666      addRegexToken('hh', match1to2, match2);
1667  
1668      addRegexToken('hmm', match3to4);
1669      addRegexToken('hmmss', match5to6);
1670      addRegexToken('Hmm', match3to4);
1671      addRegexToken('Hmmss', match5to6);
1672  
1673      addParseToken(['H', 'HH'], HOUR);
1674      addParseToken(['a', 'A'], function (input, array, config) {
1675          config._isPm = config._locale.isPM(input);
1676          config._meridiem = input;
1677      });
1678      addParseToken(['h', 'hh'], function (input, array, config) {
1679          array[HOUR] = toInt(input);
1680          getParsingFlags(config).bigHour = true;
1681      });
1682      addParseToken('hmm', function (input, array, config) {
1683          var pos = input.length - 2;
1684          array[HOUR] = toInt(input.substr(0, pos));
1685          array[MINUTE] = toInt(input.substr(pos));
1686          getParsingFlags(config).bigHour = true;
1687      });
1688      addParseToken('hmmss', function (input, array, config) {
1689          var pos1 = input.length - 4;
1690          var pos2 = input.length - 2;
1691          array[HOUR] = toInt(input.substr(0, pos1));
1692          array[MINUTE] = toInt(input.substr(pos1, 2));
1693          array[SECOND] = toInt(input.substr(pos2));
1694          getParsingFlags(config).bigHour = true;
1695      });
1696      addParseToken('Hmm', function (input, array, config) {
1697          var pos = input.length - 2;
1698          array[HOUR] = toInt(input.substr(0, pos));
1699          array[MINUTE] = toInt(input.substr(pos));
1700      });
1701      addParseToken('Hmmss', function (input, array, config) {
1702          var pos1 = input.length - 4;
1703          var pos2 = input.length - 2;
1704          array[HOUR] = toInt(input.substr(0, pos1));
1705          array[MINUTE] = toInt(input.substr(pos1, 2));
1706          array[SECOND] = toInt(input.substr(pos2));
1707      });
1708  
1709      // LOCALES
1710  
1711      function localeIsPM (input) {
1712          // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1713          // Using charAt should be more compatible.
1714          return ((input + '').toLowerCase().charAt(0) === 'p');
1715      }
1716  
1717      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
1718      function localeMeridiem (hours, minutes, isLower) {
1719          if (hours > 11) {
1720              return isLower ? 'pm' : 'PM';
1721          } else {
1722              return isLower ? 'am' : 'AM';
1723          }
1724      }
1725  
1726  
1727      // MOMENTS
1728  
1729      // Setting the hour should keep the time, because the user explicitly
1730      // specified which hour he wants. So trying to maintain the same hour (in
1731      // a new timezone) makes sense. Adding/subtracting hours does not follow
1732      // this rule.
1733      var getSetHour = makeGetSet('Hours', true);
1734  
1735      var baseConfig = {
1736          calendar: defaultCalendar,
1737          longDateFormat: defaultLongDateFormat,
1738          invalidDate: defaultInvalidDate,
1739          ordinal: defaultOrdinal,
1740          ordinalParse: defaultOrdinalParse,
1741          relativeTime: defaultRelativeTime,
1742  
1743          months: defaultLocaleMonths,
1744          monthsShort: defaultLocaleMonthsShort,
1745  
1746          week: defaultLocaleWeek,
1747  
1748          weekdays: defaultLocaleWeekdays,
1749          weekdaysMin: defaultLocaleWeekdaysMin,
1750          weekdaysShort: defaultLocaleWeekdaysShort,
1751  
1752          meridiemParse: defaultLocaleMeridiemParse
1753      };
1754  
1755      // internal storage for locale config files
1756      var locales = {};
1757      var globalLocale;
1758  
1759      function normalizeLocale(key) {
1760          return key ? key.toLowerCase().replace('_', '-') : key;
1761      }
1762  
1763      // pick the locale from the array
1764      // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
1765      // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
1766      function chooseLocale(names) {
1767          var i = 0, j, next, locale, split;
1768  
1769          while (i < names.length) {
1770              split = normalizeLocale(names[i]).split('-');
1771              j = split.length;
1772              next = normalizeLocale(names[i + 1]);
1773              next = next ? next.split('-') : null;
1774              while (j > 0) {
1775                  locale = loadLocale(split.slice(0, j).join('-'));
1776                  if (locale) {
1777                      return locale;
1778                  }
1779                  if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
1780                      //the next array item is better than a shallower substring of this one
1781                      break;
1782                  }
1783                  j--;
1784              }
1785              i++;
1786          }
1787          return null;
1788      }
1789  
1790      function loadLocale(name) {
1791          var oldLocale = null;
1792          // TODO: Find a better way to register and load all the locales in Node
1793          if (!locales[name] && (typeof module !== 'undefined') &&
1794                  module && module.exports) {
1795              try {
1796                  oldLocale = globalLocale._abbr;
1797                  require('./locale/' + name);
1798                  // because defineLocale currently also sets the global locale, we
1799                  // want to undo that for lazy loaded locales
1800                  locale_locales__getSetGlobalLocale(oldLocale);
1801              } catch (e) { }
1802          }
1803          return locales[name];
1804      }
1805  
1806      // This function will load locale and then set the global locale.  If
1807      // no arguments are passed in, it will simply return the current global
1808      // locale key.
1809      function locale_locales__getSetGlobalLocale (key, values) {
1810          var data;
1811          if (key) {
1812              if (isUndefined(values)) {
1813                  data = locale_locales__getLocale(key);
1814              }
1815              else {
1816                  data = defineLocale(key, values);
1817              }
1818  
1819              if (data) {
1820                  // moment.duration._locale = moment._locale = data;
1821                  globalLocale = data;
1822              }
1823          }
1824  
1825          return globalLocale._abbr;
1826      }
1827  
1828      function defineLocale (name, config) {
1829          if (config !== null) {
1830              var parentConfig = baseConfig;
1831              config.abbr = name;
1832              if (locales[name] != null) {
1833                  deprecateSimple('defineLocaleOverride',
1834                          'use moment.updateLocale(localeName, config) to change ' +
1835                          'an existing locale. moment.defineLocale(localeName, ' +
1836                          'config) should only be used for creating a new locale ' +
1837                          'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
1838                  parentConfig = locales[name]._config;
1839              } else if (config.parentLocale != null) {
1840                  if (locales[config.parentLocale] != null) {
1841                      parentConfig = locales[config.parentLocale]._config;
1842                  } else {
1843                      // treat as if there is no base config
1844                      deprecateSimple('parentLocaleUndefined',
1845                              'specified parentLocale is not defined yet. See http://momentjs.com/guides/#/warnings/parent-locale/');
1846                  }
1847              }
1848              locales[name] = new Locale(mergeConfigs(parentConfig, config));
1849  
1850              // backwards compat for now: also set the locale
1851              locale_locales__getSetGlobalLocale(name);
1852  
1853              return locales[name];
1854          } else {
1855              // useful for testing
1856              delete locales[name];
1857              return null;
1858          }
1859      }
1860  
1861      function updateLocale(name, config) {
1862          if (config != null) {
1863              var locale, parentConfig = baseConfig;
1864              // MERGE
1865              if (locales[name] != null) {
1866                  parentConfig = locales[name]._config;
1867              }
1868              config = mergeConfigs(parentConfig, config);
1869              locale = new Locale(config);
1870              locale.parentLocale = locales[name];
1871              locales[name] = locale;
1872  
1873              // backwards compat for now: also set the locale
1874              locale_locales__getSetGlobalLocale(name);
1875          } else {
1876              // pass null for config to unupdate, useful for tests
1877              if (locales[name] != null) {
1878                  if (locales[name].parentLocale != null) {
1879                      locales[name] = locales[name].parentLocale;
1880                  } else if (locales[name] != null) {
1881                      delete locales[name];
1882                  }
1883              }
1884          }
1885          return locales[name];
1886      }
1887  
1888      // returns locale data
1889      function locale_locales__getLocale (key) {
1890          var locale;
1891  
1892          if (key && key._locale && key._locale._abbr) {
1893              key = key._locale._abbr;
1894          }
1895  
1896          if (!key) {
1897              return globalLocale;
1898          }
1899  
1900          if (!isArray(key)) {
1901              //short-circuit everything else
1902              locale = loadLocale(key);
1903              if (locale) {
1904                  return locale;
1905              }
1906              key = [key];
1907          }
1908  
1909          return chooseLocale(key);
1910      }
1911  
1912      function locale_locales__listLocales() {
1913          return keys(locales);
1914      }
1915  
1916      function checkOverflow (m) {
1917          var overflow;
1918          var a = m._a;
1919  
1920          if (a && getParsingFlags(m).overflow === -2) {
1921              overflow =
1922                  a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
1923                  a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
1924                  a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
1925                  a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
1926                  a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
1927                  a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
1928                  -1;
1929  
1930              if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
1931                  overflow = DATE;
1932              }
1933              if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
1934                  overflow = WEEK;
1935              }
1936              if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
1937                  overflow = WEEKDAY;
1938              }
1939  
1940              getParsingFlags(m).overflow = overflow;
1941          }
1942  
1943          return m;
1944      }
1945  
1946      // iso 8601 regex
1947      // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
1948      var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
1949      var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
1950  
1951      var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
1952  
1953      var isoDates = [
1954          ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
1955          ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
1956          ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
1957          ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
1958          ['YYYY-DDD', /\d{4}-\d{3}/],
1959          ['YYYY-MM', /\d{4}-\d\d/, false],
1960          ['YYYYYYMMDD', /[+-]\d{10}/],
1961          ['YYYYMMDD', /\d{8}/],
1962          // YYYYMM is NOT allowed by the standard
1963          ['GGGG[W]WWE', /\d{4}W\d{3}/],
1964          ['GGGG[W]WW', /\d{4}W\d{2}/, false],
1965          ['YYYYDDD', /\d{7}/]
1966      ];
1967  
1968      // iso time formats and regexes
1969      var isoTimes = [
1970          ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
1971          ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
1972          ['HH:mm:ss', /\d\d:\d\d:\d\d/],
1973          ['HH:mm', /\d\d:\d\d/],
1974          ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
1975          ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
1976          ['HHmmss', /\d\d\d\d\d\d/],
1977          ['HHmm', /\d\d\d\d/],
1978          ['HH', /\d\d/]
1979      ];
1980  
1981      var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
1982  
1983      // date from iso format
1984      function configFromISO(config) {
1985          var i, l,
1986              string = config._i,
1987              match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
1988              allowTime, dateFormat, timeFormat, tzFormat;
1989  
1990          if (match) {
1991              getParsingFlags(config).iso = true;
1992  
1993              for (i = 0, l = isoDates.length; i < l; i++) {
1994                  if (isoDates[i][1].exec(match[1])) {
1995                      dateFormat = isoDates[i][0];
1996                      allowTime = isoDates[i][2] !== false;
1997                      break;
1998                  }
1999              }
2000              if (dateFormat == null) {
2001                  config._isValid = false;
2002                  return;
2003              }
2004              if (match[3]) {
2005                  for (i = 0, l = isoTimes.length; i < l; i++) {
2006                      if (isoTimes[i][1].exec(match[3])) {
2007                          // match[2] should be 'T' or space
2008                          timeFormat = (match[2] || ' ') + isoTimes[i][0];
2009                          break;
2010                      }
2011                  }
2012                  if (timeFormat == null) {
2013                      config._isValid = false;
2014                      return;
2015                  }
2016              }
2017              if (!allowTime && timeFormat != null) {
2018                  config._isValid = false;
2019                  return;
2020              }
2021              if (match[4]) {
2022                  if (tzRegex.exec(match[4])) {
2023                      tzFormat = 'Z';
2024                  } else {
2025                      config._isValid = false;
2026                      return;
2027                  }
2028              }
2029              config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2030              configFromStringAndFormat(config);
2031          } else {
2032              config._isValid = false;
2033          }
2034      }
2035  
2036      // date from iso format or fallback
2037      function configFromString(config) {
2038          var matched = aspNetJsonRegex.exec(config._i);
2039  
2040          if (matched !== null) {
2041              config._d = new Date(+matched[1]);
2042              return;
2043          }
2044  
2045          configFromISO(config);
2046          if (config._isValid === false) {
2047              delete config._isValid;
2048              utils_hooks__hooks.createFromInputFallback(config);
2049          }
2050      }
2051  
2052      utils_hooks__hooks.createFromInputFallback = deprecate(
2053          'value provided is not in a recognized ISO format. moment construction falls back to js Date(), ' +
2054          'which is not reliable across all browsers and versions. Non ISO date formats are ' +
2055          'discouraged and will be removed in an upcoming major release. Please refer to ' +
2056          'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2057          function (config) {
2058              config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2059          }
2060      );
2061  
2062      // Pick the first defined of two or three arguments.
2063      function defaults(a, b, c) {
2064          if (a != null) {
2065              return a;
2066          }
2067          if (b != null) {
2068              return b;
2069          }
2070          return c;
2071      }
2072  
2073      function currentDateArray(config) {
2074          // hooks is actually the exported moment object
2075          var nowValue = new Date(utils_hooks__hooks.now());
2076          if (config._useUTC) {
2077              return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
2078          }
2079          return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2080      }
2081  
2082      // convert an array to a date.
2083      // the array should mirror the parameters below
2084      // note: all values past the year are optional and will default to the lowest possible value.
2085      // [year, month, day , hour, minute, second, millisecond]
2086      function configFromArray (config) {
2087          var i, date, input = [], currentDate, yearToUse;
2088  
2089          if (config._d) {
2090              return;
2091          }
2092  
2093          currentDate = currentDateArray(config);
2094  
2095          //compute day of the year from weeks and weekdays
2096          if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2097              dayOfYearFromWeekInfo(config);
2098          }
2099  
2100          //if the day of the year is set, figure out what it is
2101          if (config._dayOfYear) {
2102              yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2103  
2104              if (config._dayOfYear > daysInYear(yearToUse)) {
2105                  getParsingFlags(config)._overflowDayOfYear = true;
2106              }
2107  
2108              date = createUTCDate(yearToUse, 0, config._dayOfYear);
2109              config._a[MONTH] = date.getUTCMonth();
2110              config._a[DATE] = date.getUTCDate();
2111          }
2112  
2113          // Default to current date.
2114          // * if no year, month, day of month are given, default to today
2115          // * if day of month is given, default month and year
2116          // * if month is given, default only year
2117          // * if year is given, don't default anything
2118          for (i = 0; i < 3 && config._a[i] == null; ++i) {
2119              config._a[i] = input[i] = currentDate[i];
2120          }
2121  
2122          // Zero out whatever was not defaulted, including time
2123          for (; i < 7; i++) {
2124              config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
2125          }
2126  
2127          // Check for 24:00:00.000
2128          if (config._a[HOUR] === 24 &&
2129                  config._a[MINUTE] === 0 &&
2130                  config._a[SECOND] === 0 &&
2131                  config._a[MILLISECOND] === 0) {
2132              config._nextDay = true;
2133              config._a[HOUR] = 0;
2134          }
2135  
2136          config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
2137          // Apply timezone offset from input. The actual utcOffset can be changed
2138          // with parseZone.
2139          if (config._tzm != null) {
2140              config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2141          }
2142  
2143          if (config._nextDay) {
2144              config._a[HOUR] = 24;
2145          }
2146      }
2147  
2148      function dayOfYearFromWeekInfo(config) {
2149          var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
2150  
2151          w = config._w;
2152          if (w.GG != null || w.W != null || w.E != null) {
2153              dow = 1;
2154              doy = 4;
2155  
2156              // TODO: We need to take the current isoWeekYear, but that depends on
2157              // how we interpret now (local, utc, fixed offset). So create
2158              // a now version of current config (take local/utc/offset flags, and
2159              // create now).
2160              weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
2161              week = defaults(w.W, 1);
2162              weekday = defaults(w.E, 1);
2163              if (weekday < 1 || weekday > 7) {
2164                  weekdayOverflow = true;
2165              }
2166          } else {
2167              dow = config._locale._week.dow;
2168              doy = config._locale._week.doy;
2169  
2170              weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
2171              week = defaults(w.w, 1);
2172  
2173              if (w.d != null) {
2174                  // weekday -- low day numbers are considered next week
2175                  weekday = w.d;
2176                  if (weekday < 0 || weekday > 6) {
2177                      weekdayOverflow = true;
2178                  }
2179              } else if (w.e != null) {
2180                  // local weekday -- counting starts from begining of week
2181                  weekday = w.e + dow;
2182                  if (w.e < 0 || w.e > 6) {
2183                      weekdayOverflow = true;
2184                  }
2185              } else {
2186                  // default to begining of week
2187                  weekday = dow;
2188              }
2189          }
2190          if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2191              getParsingFlags(config)._overflowWeeks = true;
2192          } else if (weekdayOverflow != null) {
2193              getParsingFlags(config)._overflowWeekday = true;
2194          } else {
2195              temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2196              config._a[YEAR] = temp.year;
2197              config._dayOfYear = temp.dayOfYear;
2198          }
2199      }
2200  
2201      // constant that refers to the ISO standard
2202      utils_hooks__hooks.ISO_8601 = function () {};
2203  
2204      // date from string and format string
2205      function configFromStringAndFormat(config) {
2206          // TODO: Move this to another part of the creation flow to prevent circular deps
2207          if (config._f === utils_hooks__hooks.ISO_8601) {
2208              configFromISO(config);
2209              return;
2210          }
2211  
2212          config._a = [];
2213          getParsingFlags(config).empty = true;
2214  
2215          // This array is used to make a Date, either with `new Date` or `Date.UTC`
2216          var string = '' + config._i,
2217              i, parsedInput, tokens, token, skipped,
2218              stringLength = string.length,
2219              totalParsedInputLength = 0;
2220  
2221          tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
2222  
2223          for (i = 0; i < tokens.length; i++) {
2224              token = tokens[i];
2225              parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
2226              // console.log('token', token, 'parsedInput', parsedInput,
2227              //         'regex', getParseRegexForToken(token, config));
2228              if (parsedInput) {
2229                  skipped = string.substr(0, string.indexOf(parsedInput));
2230                  if (skipped.length > 0) {
2231                      getParsingFlags(config).unusedInput.push(skipped);
2232                  }
2233                  string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
2234                  totalParsedInputLength += parsedInput.length;
2235              }
2236              // don't parse if it's not a known token
2237              if (formatTokenFunctions[token]) {
2238                  if (parsedInput) {
2239                      getParsingFlags(config).empty = false;
2240                  }
2241                  else {
2242                      getParsingFlags(config).unusedTokens.push(token);
2243                  }
2244                  addTimeToArrayFromToken(token, parsedInput, config);
2245              }
2246              else if (config._strict && !parsedInput) {
2247                  getParsingFlags(config).unusedTokens.push(token);
2248              }
2249          }
2250  
2251          // add remaining unparsed input length to the string
2252          getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
2253          if (string.length > 0) {
2254              getParsingFlags(config).unusedInput.push(string);
2255          }
2256  
2257          // clear _12h flag if hour is <= 12
2258          if (config._a[HOUR] <= 12 &&
2259              getParsingFlags(config).bigHour === true &&
2260              config._a[HOUR] > 0) {
2261              getParsingFlags(config).bigHour = undefined;
2262          }
2263  
2264          getParsingFlags(config).parsedDateParts = config._a.slice(0);
2265          getParsingFlags(config).meridiem = config._meridiem;
2266          // handle meridiem
2267          config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
2268  
2269          configFromArray(config);
2270          checkOverflow(config);
2271      }
2272  
2273  
2274      function meridiemFixWrap (locale, hour, meridiem) {
2275          var isPm;
2276  
2277          if (meridiem == null) {
2278              // nothing to do
2279              return hour;
2280          }
2281          if (locale.meridiemHour != null) {
2282              return locale.meridiemHour(hour, meridiem);
2283          } else if (locale.isPM != null) {
2284              // Fallback
2285              isPm = locale.isPM(meridiem);
2286              if (isPm && hour < 12) {
2287                  hour += 12;
2288              }
2289              if (!isPm && hour === 12) {
2290                  hour = 0;
2291              }
2292              return hour;
2293          } else {
2294              // this is not supposed to happen
2295              return hour;
2296          }
2297      }
2298  
2299      // date from string and array of format strings
2300      function configFromStringAndArray(config) {
2301          var tempConfig,
2302              bestMoment,
2303  
2304              scoreToBeat,
2305              i,
2306              currentScore;
2307  
2308          if (config._f.length === 0) {
2309              getParsingFlags(config).invalidFormat = true;
2310              config._d = new Date(NaN);
2311              return;
2312          }
2313  
2314          for (i = 0; i < config._f.length; i++) {
2315              currentScore = 0;
2316              tempConfig = copyConfig({}, config);
2317              if (config._useUTC != null) {
2318                  tempConfig._useUTC = config._useUTC;
2319              }
2320              tempConfig._f = config._f[i];
2321              configFromStringAndFormat(tempConfig);
2322  
2323              if (!valid__isValid(tempConfig)) {
2324                  continue;
2325              }
2326  
2327              // if there is any input that was not parsed add a penalty for that format
2328              currentScore += getParsingFlags(tempConfig).charsLeftOver;
2329  
2330              //or tokens
2331              currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2332  
2333              getParsingFlags(tempConfig).score = currentScore;
2334  
2335              if (scoreToBeat == null || currentScore < scoreToBeat) {
2336                  scoreToBeat = currentScore;
2337                  bestMoment = tempConfig;
2338              }
2339          }
2340  
2341          extend(config, bestMoment || tempConfig);
2342      }
2343  
2344      function configFromObject(config) {
2345          if (config._d) {
2346              return;
2347          }
2348  
2349          var i = normalizeObjectUnits(config._i);
2350          config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
2351              return obj && parseInt(obj, 10);
2352          });
2353  
2354          configFromArray(config);
2355      }
2356  
2357      function createFromConfig (config) {
2358          var res = new Moment(checkOverflow(prepareConfig(config)));
2359          if (res._nextDay) {
2360              // Adding is smart enough around DST
2361              res.add(1, 'd');
2362              res._nextDay = undefined;
2363          }
2364  
2365          return res;
2366      }
2367  
2368      function prepareConfig (config) {
2369          var input = config._i,
2370              format = config._f;
2371  
2372          config._locale = config._locale || locale_locales__getLocale(config._l);
2373  
2374          if (input === null || (format === undefined && input === '')) {
2375              return valid__createInvalid({nullInput: true});
2376          }
2377  
2378          if (typeof input === 'string') {
2379              config._i = input = config._locale.preparse(input);
2380          }
2381  
2382          if (isMoment(input)) {
2383              return new Moment(checkOverflow(input));
2384          } else if (isArray(format)) {
2385              configFromStringAndArray(config);
2386          } else if (isDate(input)) {
2387              config._d = input;
2388          } else if (format) {
2389              configFromStringAndFormat(config);
2390          }  else {
2391              configFromInput(config);
2392          }
2393  
2394          if (!valid__isValid(config)) {
2395              config._d = null;
2396          }
2397  
2398          return config;
2399      }
2400  
2401      function configFromInput(config) {
2402          var input = config._i;
2403          if (input === undefined) {
2404              config._d = new Date(utils_hooks__hooks.now());
2405          } else if (isDate(input)) {
2406              config._d = new Date(input.valueOf());
2407          } else if (typeof input === 'string') {
2408              configFromString(config);
2409          } else if (isArray(input)) {
2410              config._a = map(input.slice(0), function (obj) {
2411                  return parseInt(obj, 10);
2412              });
2413              configFromArray(config);
2414          } else if (typeof(input) === 'object') {
2415              configFromObject(config);
2416          } else if (typeof(input) === 'number') {
2417              // from milliseconds
2418              config._d = new Date(input);
2419          } else {
2420              utils_hooks__hooks.createFromInputFallback(config);
2421          }
2422      }
2423  
2424      function createLocalOrUTC (input, format, locale, strict, isUTC) {
2425          var c = {};
2426  
2427          if (typeof(locale) === 'boolean') {
2428              strict = locale;
2429              locale = undefined;
2430          }
2431  
2432          if ((isObject(input) && isObjectEmpty(input)) ||
2433                  (isArray(input) && input.length === 0)) {
2434              input = undefined;
2435          }
2436          // object construction must be done this way.
2437          // https://github.com/moment/moment/issues/1423
2438          c._isAMomentObject = true;
2439          c._useUTC = c._isUTC = isUTC;
2440          c._l = locale;
2441          c._i = input;
2442          c._f = format;
2443          c._strict = strict;
2444  
2445          return createFromConfig(c);
2446      }
2447  
2448      function local__createLocal (input, format, locale, strict) {
2449          return createLocalOrUTC(input, format, locale, strict, false);
2450      }
2451  
2452      var prototypeMin = deprecate(
2453          'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
2454          function () {
2455              var other = local__createLocal.apply(null, arguments);
2456              if (this.isValid() && other.isValid()) {
2457                  return other < this ? this : other;
2458              } else {
2459                  return valid__createInvalid();
2460              }
2461          }
2462      );
2463  
2464      var prototypeMax = deprecate(
2465          'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
2466          function () {
2467              var other = local__createLocal.apply(null, arguments);
2468              if (this.isValid() && other.isValid()) {
2469                  return other > this ? this : other;
2470              } else {
2471                  return valid__createInvalid();
2472              }
2473          }
2474      );
2475  
2476      // Pick a moment m from moments so that m[fn](other) is true for all
2477      // other. This relies on the function fn to be transitive.
2478      //
2479      // moments should either be an array of moment objects or an array, whose
2480      // first element is an array of moment objects.
2481      function pickBy(fn, moments) {
2482          var res, i;
2483          if (moments.length === 1 && isArray(moments[0])) {
2484              moments = moments[0];
2485          }
2486          if (!moments.length) {
2487              return local__createLocal();
2488          }
2489          res = moments[0];
2490          for (i = 1; i < moments.length; ++i) {
2491              if (!moments[i].isValid() || moments[i][fn](res)) {
2492                  res = moments[i];
2493              }
2494          }
2495          return res;
2496      }
2497  
2498      // TODO: Use [].sort instead?
2499      function min () {
2500          var args = [].slice.call(arguments, 0);
2501  
2502          return pickBy('isBefore', args);
2503      }
2504  
2505      function max () {
2506          var args = [].slice.call(arguments, 0);
2507  
2508          return pickBy('isAfter', args);
2509      }
2510  
2511      var now = function () {
2512          return Date.now ? Date.now() : +(new Date());
2513      };
2514  
2515      function Duration (duration) {
2516          var normalizedInput = normalizeObjectUnits(duration),
2517              years = normalizedInput.year || 0,
2518              quarters = normalizedInput.quarter || 0,
2519              months = normalizedInput.month || 0,
2520              weeks = normalizedInput.week || 0,
2521              days = normalizedInput.day || 0,
2522              hours = normalizedInput.hour || 0,
2523              minutes = normalizedInput.minute || 0,
2524              seconds = normalizedInput.second || 0,
2525              milliseconds = normalizedInput.millisecond || 0;
2526  
2527          // representation for dateAddRemove
2528          this._milliseconds = +milliseconds +
2529              seconds * 1e3 + // 1000
2530              minutes * 6e4 + // 1000 * 60
2531              hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
2532          // Because of dateAddRemove treats 24 hours as different from a
2533          // day when working around DST, we need to store them separately
2534          this._days = +days +
2535              weeks * 7;
2536          // It is impossible translate months into days without knowing
2537          // which months you are are talking about, so we have to store
2538          // it separately.
2539          this._months = +months +
2540              quarters * 3 +
2541              years * 12;
2542  
2543          this._data = {};
2544  
2545          this._locale = locale_locales__getLocale();
2546  
2547          this._bubble();
2548      }
2549  
2550      function isDuration (obj) {
2551          return obj instanceof Duration;
2552      }
2553  
2554      function absRound (number) {
2555          if (number < 0) {
2556              return Math.round(-1 * number) * -1;
2557          } else {
2558              return Math.round(number);
2559          }
2560      }
2561  
2562      // FORMATTING
2563  
2564      function offset (token, separator) {
2565          addFormatToken(token, 0, 0, function () {
2566              var offset = this.utcOffset();
2567              var sign = '+';
2568              if (offset < 0) {
2569                  offset = -offset;
2570                  sign = '-';
2571              }
2572              return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
2573          });
2574      }
2575  
2576      offset('Z', ':');
2577      offset('ZZ', '');
2578  
2579      // PARSING
2580  
2581      addRegexToken('Z',  matchShortOffset);
2582      addRegexToken('ZZ', matchShortOffset);
2583      addParseToken(['Z', 'ZZ'], function (input, array, config) {
2584          config._useUTC = true;
2585          config._tzm = offsetFromString(matchShortOffset, input);
2586      });
2587  
2588      // HELPERS
2589  
2590      // timezone chunker
2591      // '+10:00' > ['10',  '00']
2592      // '-1530'  > ['-15', '30']
2593      var chunkOffset = /([\+\-]|\d\d)/gi;
2594  
2595      function offsetFromString(matcher, string) {
2596          var matches = ((string || '').match(matcher) || []);
2597          var chunk   = matches[matches.length - 1] || [];
2598          var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
2599          var minutes = +(parts[1] * 60) + toInt(parts[2]);
2600  
2601          return parts[0] === '+' ? minutes : -minutes;
2602      }
2603  
2604      // Return a moment from input, that is local/utc/zone equivalent to model.
2605      function cloneWithOffset(input, model) {
2606          var res, diff;
2607          if (model._isUTC) {
2608              res = model.clone();
2609              diff = (isMoment(input) || isDate(input) ? input.valueOf() : local__createLocal(input).valueOf()) - res.valueOf();
2610              // Use low-level api, because this fn is low-level api.
2611              res._d.setTime(res._d.valueOf() + diff);
2612              utils_hooks__hooks.updateOffset(res, false);
2613              return res;
2614          } else {
2615              return local__createLocal(input).local();
2616          }
2617      }
2618  
2619      function getDateOffset (m) {
2620          // On Firefox.24 Date#getTimezoneOffset returns a floating point.
2621          // https://github.com/moment/moment/pull/1871
2622          return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
2623      }
2624  
2625      // HOOKS
2626  
2627      // This function will be called whenever a moment is mutated.
2628      // It is intended to keep the offset in sync with the timezone.
2629      utils_hooks__hooks.updateOffset = function () {};
2630  
2631      // MOMENTS
2632  
2633      // keepLocalTime = true means only change the timezone, without
2634      // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
2635      // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
2636      // +0200, so we adjust the time as needed, to be valid.
2637      //
2638      // Keeping the time actually adds/subtracts (one hour)
2639      // from the actual represented time. That is why we call updateOffset
2640      // a second time. In case it wants us to change the offset again
2641      // _changeInProgress == true case, then we have to adjust, because
2642      // there is no such time in the given timezone.
2643      function getSetOffset (input, keepLocalTime) {
2644          var offset = this._offset || 0,
2645              localAdjust;
2646          if (!this.isValid()) {
2647              return input != null ? this : NaN;
2648          }
2649          if (input != null) {
2650              if (typeof input === 'string') {
2651                  input = offsetFromString(matchShortOffset, input);
2652              } else if (Math.abs(input) < 16) {
2653                  input = input * 60;
2654              }
2655              if (!this._isUTC && keepLocalTime) {
2656                  localAdjust = getDateOffset(this);
2657              }
2658              this._offset = input;
2659              this._isUTC = true;
2660              if (localAdjust != null) {
2661                  this.add(localAdjust, 'm');
2662              }
2663              if (offset !== input) {
2664                  if (!keepLocalTime || this._changeInProgress) {
2665                      add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
2666                  } else if (!this._changeInProgress) {
2667                      this._changeInProgress = true;
2668                      utils_hooks__hooks.updateOffset(this, true);
2669                      this._changeInProgress = null;
2670                  }
2671              }
2672              return this;
2673          } else {
2674              return this._isUTC ? offset : getDateOffset(this);
2675          }
2676      }
2677  
2678      function getSetZone (input, keepLocalTime) {
2679          if (input != null) {
2680              if (typeof input !== 'string') {
2681                  input = -input;
2682              }
2683  
2684              this.utcOffset(input, keepLocalTime);
2685  
2686              return this;
2687          } else {
2688              return -this.utcOffset();
2689          }
2690      }
2691  
2692      function setOffsetToUTC (keepLocalTime) {
2693          return this.utcOffset(0, keepLocalTime);
2694      }
2695  
2696      function setOffsetToLocal (keepLocalTime) {
2697          if (this._isUTC) {
2698              this.utcOffset(0, keepLocalTime);
2699              this._isUTC = false;
2700  
2701              if (keepLocalTime) {
2702                  this.subtract(getDateOffset(this), 'm');
2703              }
2704          }
2705          return this;
2706      }
2707  
2708      function setOffsetToParsedOffset () {
2709          if (this._tzm) {
2710              this.utcOffset(this._tzm);
2711          } else if (typeof this._i === 'string') {
2712              var tZone = offsetFromString(matchOffset, this._i);
2713  
2714              if (tZone === 0) {
2715                  this.utcOffset(0, true);
2716              } else {
2717                  this.utcOffset(offsetFromString(matchOffset, this._i));
2718              }
2719          }
2720          return this;
2721      }
2722  
2723      function hasAlignedHourOffset (input) {
2724          if (!this.isValid()) {
2725              return false;
2726          }
2727          input = input ? local__createLocal(input).utcOffset() : 0;
2728  
2729          return (this.utcOffset() - input) % 60 === 0;
2730      }
2731  
2732      function isDaylightSavingTime () {
2733          return (
2734              this.utcOffset() > this.clone().month(0).utcOffset() ||
2735              this.utcOffset() > this.clone().month(5).utcOffset()
2736          );
2737      }
2738  
2739      function isDaylightSavingTimeShifted () {
2740          if (!isUndefined(this._isDSTShifted)) {
2741              return this._isDSTShifted;
2742          }
2743  
2744          var c = {};
2745  
2746          copyConfig(c, this);
2747          c = prepareConfig(c);
2748  
2749          if (c._a) {
2750              var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
2751              this._isDSTShifted = this.isValid() &&
2752                  compareArrays(c._a, other.toArray()) > 0;
2753          } else {
2754              this._isDSTShifted = false;
2755          }
2756  
2757          return this._isDSTShifted;
2758      }
2759  
2760      function isLocal () {
2761          return this.isValid() ? !this._isUTC : false;
2762      }
2763  
2764      function isUtcOffset () {
2765          return this.isValid() ? this._isUTC : false;
2766      }
2767  
2768      function isUtc () {
2769          return this.isValid() ? this._isUTC && this._offset === 0 : false;
2770      }
2771  
2772      // ASP.NET json date format regex
2773      var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
2774  
2775      // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
2776      // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
2777      // and further modified to allow for strings containing both week and day
2778      var isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
2779  
2780      function create__createDuration (input, key) {
2781          var duration = input,
2782              // matching against regexp is expensive, do it on demand
2783              match = null,
2784              sign,
2785              ret,
2786              diffRes;
2787  
2788          if (isDuration(input)) {
2789              duration = {
2790                  ms : input._milliseconds,
2791                  d  : input._days,
2792                  M  : input._months
2793              };
2794          } else if (typeof input === 'number') {
2795              duration = {};
2796              if (key) {
2797                  duration[key] = input;
2798              } else {
2799                  duration.milliseconds = input;
2800              }
2801          } else if (!!(match = aspNetRegex.exec(input))) {
2802              sign = (match[1] === '-') ? -1 : 1;
2803              duration = {
2804                  y  : 0,
2805                  d  : toInt(match[DATE])                         * sign,
2806                  h  : toInt(match[HOUR])                         * sign,
2807                  m  : toInt(match[MINUTE])                       * sign,
2808                  s  : toInt(match[SECOND])                       * sign,
2809                  ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
2810              };
2811          } else if (!!(match = isoRegex.exec(input))) {
2812              sign = (match[1] === '-') ? -1 : 1;
2813              duration = {
2814                  y : parseIso(match[2], sign),
2815                  M : parseIso(match[3], sign),
2816                  w : parseIso(match[4], sign),
2817                  d : parseIso(match[5], sign),
2818                  h : parseIso(match[6], sign),
2819                  m : parseIso(match[7], sign),
2820                  s : parseIso(match[8], sign)
2821              };
2822          } else if (duration == null) {// checks for null or undefined
2823              duration = {};
2824          } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
2825              diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
2826  
2827              duration = {};
2828              duration.ms = diffRes.milliseconds;
2829              duration.M = diffRes.months;
2830          }
2831  
2832          ret = new Duration(duration);
2833  
2834          if (isDuration(input) && hasOwnProp(input, '_locale')) {
2835              ret._locale = input._locale;
2836          }
2837  
2838          return ret;
2839      }
2840  
2841      create__createDuration.fn = Duration.prototype;
2842  
2843      function parseIso (inp, sign) {
2844          // We'd normally use ~~inp for this, but unfortunately it also
2845          // converts floats to ints.
2846          // inp may be undefined, so careful calling replace on it.
2847          var res = inp && parseFloat(inp.replace(',', '.'));
2848          // apply sign while we're at it
2849          return (isNaN(res) ? 0 : res) * sign;
2850      }
2851  
2852      function positiveMomentsDifference(base, other) {
2853          var res = {milliseconds: 0, months: 0};
2854  
2855          res.months = other.month() - base.month() +
2856              (other.year() - base.year()) * 12;
2857          if (base.clone().add(res.months, 'M').isAfter(other)) {
2858              --res.months;
2859          }
2860  
2861          res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
2862  
2863          return res;
2864      }
2865  
2866      function momentsDifference(base, other) {
2867          var res;
2868          if (!(base.isValid() && other.isValid())) {
2869              return {milliseconds: 0, months: 0};
2870          }
2871  
2872          other = cloneWithOffset(other, base);
2873          if (base.isBefore(other)) {
2874              res = positiveMomentsDifference(base, other);
2875          } else {
2876              res = positiveMomentsDifference(other, base);
2877              res.milliseconds = -res.milliseconds;
2878              res.months = -res.months;
2879          }
2880  
2881          return res;
2882      }
2883  
2884      // TODO: remove 'name' arg after deprecation is removed
2885      function createAdder(direction, name) {
2886          return function (val, period) {
2887              var dur, tmp;
2888              //invert the arguments, but complain about it
2889              if (period !== null && !isNaN(+period)) {
2890                  deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
2891                  'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
2892                  tmp = val; val = period; period = tmp;
2893              }
2894  
2895              val = typeof val === 'string' ? +val : val;
2896              dur = create__createDuration(val, period);
2897              add_subtract__addSubtract(this, dur, direction);
2898              return this;
2899          };
2900      }
2901  
2902      function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
2903          var milliseconds = duration._milliseconds,
2904              days = absRound(duration._days),
2905              months = absRound(duration._months);
2906  
2907          if (!mom.isValid()) {
2908              // No op
2909              return;
2910          }
2911  
2912          updateOffset = updateOffset == null ? true : updateOffset;
2913  
2914          if (milliseconds) {
2915              mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
2916          }
2917          if (days) {
2918              get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
2919          }
2920          if (months) {
2921              setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
2922          }
2923          if (updateOffset) {
2924              utils_hooks__hooks.updateOffset(mom, days || months);
2925          }
2926      }
2927  
2928      var add_subtract__add      = createAdder(1, 'add');
2929      var add_subtract__subtract = createAdder(-1, 'subtract');
2930  
2931      function getCalendarFormat(myMoment, now) {
2932          var diff = myMoment.diff(now, 'days', true);
2933          return diff < -6 ? 'sameElse' :
2934                  diff < -1 ? 'lastWeek' :
2935                  diff < 0 ? 'lastDay' :
2936                  diff < 1 ? 'sameDay' :
2937                  diff < 2 ? 'nextDay' :
2938                  diff < 7 ? 'nextWeek' : 'sameElse';
2939      }
2940  
2941      function moment_calendar__calendar (time, formats) {
2942          // We want to compare the start of today, vs this.
2943          // Getting start-of-today depends on whether we're local/utc/offset or not.
2944          var now = time || local__createLocal(),
2945              sod = cloneWithOffset(now, this).startOf('day'),
2946              format = utils_hooks__hooks.calendarFormat(this, sod) || 'sameElse';
2947  
2948          var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
2949  
2950          return this.format(output || this.localeData().calendar(format, this, local__createLocal(now)));
2951      }
2952  
2953      function clone () {
2954          return new Moment(this);
2955      }
2956  
2957      function isAfter (input, units) {
2958          var localInput = isMoment(input) ? input : local__createLocal(input);
2959          if (!(this.isValid() && localInput.isValid())) {
2960              return false;
2961          }
2962          units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
2963          if (units === 'millisecond') {
2964              return this.valueOf() > localInput.valueOf();
2965          } else {
2966              return localInput.valueOf() < this.clone().startOf(units).valueOf();
2967          }
2968      }
2969  
2970      function isBefore (input, units) {
2971          var localInput = isMoment(input) ? input : local__createLocal(input);
2972          if (!(this.isValid() && localInput.isValid())) {
2973              return false;
2974          }
2975          units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
2976          if (units === 'millisecond') {
2977              return this.valueOf() < localInput.valueOf();
2978          } else {
2979              return this.clone().endOf(units).valueOf() < localInput.valueOf();
2980          }
2981      }
2982  
2983      function isBetween (from, to, units, inclusivity) {
2984          inclusivity = inclusivity || '()';
2985          return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
2986              (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
2987      }
2988  
2989      function isSame (input, units) {
2990          var localInput = isMoment(input) ? input : local__createLocal(input),
2991              inputMs;
2992          if (!(this.isValid() && localInput.isValid())) {
2993              return false;
2994          }
2995          units = normalizeUnits(units || 'millisecond');
2996          if (units === 'millisecond') {
2997              return this.valueOf() === localInput.valueOf();
2998          } else {
2999              inputMs = localInput.valueOf();
3000              return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
3001          }
3002      }
3003  
3004      function isSameOrAfter (input, units) {
3005          return this.isSame(input, units) || this.isAfter(input,units);
3006      }
3007  
3008      function isSameOrBefore (input, units) {
3009          return this.isSame(input, units) || this.isBefore(input,units);
3010      }
3011  
3012      function diff (input, units, asFloat) {
3013          var that,
3014              zoneDelta,
3015              delta, output;
3016  
3017          if (!this.isValid()) {
3018              return NaN;
3019          }
3020  
3021          that = cloneWithOffset(input, this);
3022  
3023          if (!that.isValid()) {
3024              return NaN;
3025          }
3026  
3027          zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
3028  
3029          units = normalizeUnits(units);
3030  
3031          if (units === 'year' || units === 'month' || units === 'quarter') {
3032              output = monthDiff(this, that);
3033              if (units === 'quarter') {
3034                  output = output / 3;
3035              } else if (units === 'year') {
3036                  output = output / 12;
3037              }
3038          } else {
3039              delta = this - that;
3040              output = units === 'second' ? delta / 1e3 : // 1000
3041                  units === 'minute' ? delta / 6e4 : // 1000 * 60
3042                  units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
3043                  units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
3044                  units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
3045                  delta;
3046          }
3047          return asFloat ? output : absFloor(output);
3048      }
3049  
3050      function monthDiff (a, b) {
3051          // difference in months
3052          var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
3053              // b is in (anchor - 1 month, anchor + 1 month)
3054              anchor = a.clone().add(wholeMonthDiff, 'months'),
3055              anchor2, adjust;
3056  
3057          if (b - anchor < 0) {
3058              anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
3059              // linear across the month
3060              adjust = (b - anchor) / (anchor - anchor2);
3061          } else {
3062              anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
3063              // linear across the month
3064              adjust = (b - anchor) / (anchor2 - anchor);
3065          }
3066  
3067          //check for negative zero, return zero if negative zero
3068          return -(wholeMonthDiff + adjust) || 0;
3069      }
3070  
3071      utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
3072      utils_hooks__hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
3073  
3074      function toString () {
3075          return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
3076      }
3077  
3078      function moment_format__toISOString () {
3079          var m = this.clone().utc();
3080          if (0 < m.year() && m.year() <= 9999) {
3081              if (isFunction(Date.prototype.toISOString)) {
3082                  // native implementation is ~50x faster, use it when we can
3083                  return this.toDate().toISOString();
3084              } else {
3085                  return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
3086              }
3087          } else {
3088              return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
3089          }
3090      }
3091  
3092      function format (inputString) {
3093          if (!inputString) {
3094              inputString = this.isUtc() ? utils_hooks__hooks.defaultFormatUtc : utils_hooks__hooks.defaultFormat;
3095          }
3096          var output = formatMoment(this, inputString);
3097          return this.localeData().postformat(output);
3098      }
3099  
3100      function from (time, withoutSuffix) {
3101          if (this.isValid() &&
3102                  ((isMoment(time) && time.isValid()) ||
3103                   local__createLocal(time).isValid())) {
3104              return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
3105          } else {
3106              return this.localeData().invalidDate();
3107          }
3108      }
3109  
3110      function fromNow (withoutSuffix) {
3111          return this.from(local__createLocal(), withoutSuffix);
3112      }
3113  
3114      function to (time, withoutSuffix) {
3115          if (this.isValid() &&
3116                  ((isMoment(time) && time.isValid()) ||
3117                   local__createLocal(time).isValid())) {
3118              return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
3119          } else {
3120              return this.localeData().invalidDate();
3121          }
3122      }
3123  
3124      function toNow (withoutSuffix) {
3125          return this.to(local__createLocal(), withoutSuffix);
3126      }
3127  
3128      // If passed a locale key, it will set the locale for this
3129      // instance.  Otherwise, it will return the locale configuration
3130      // variables for this instance.
3131      function locale (key) {
3132          var newLocaleData;
3133  
3134          if (key === undefined) {
3135              return this._locale._abbr;
3136          } else {
3137              newLocaleData = locale_locales__getLocale(key);
3138              if (newLocaleData != null) {
3139                  this._locale = newLocaleData;
3140              }
3141              return this;
3142          }
3143      }
3144  
3145      var lang = deprecate(
3146          'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
3147          function (key) {
3148              if (key === undefined) {
3149                  return this.localeData();
3150              } else {
3151                  return this.locale(key);
3152              }
3153          }
3154      );
3155  
3156      function localeData () {
3157          return this._locale;
3158      }
3159  
3160      function startOf (units) {
3161          units = normalizeUnits(units);
3162          // the following switch intentionally omits break keywords
3163          // to utilize falling through the cases.
3164          switch (units) {
3165              case 'year':
3166                  this.month(0);
3167                  /* falls through */
3168              case 'quarter':
3169              case 'month':
3170                  this.date(1);
3171                  /* falls through */
3172              case 'week':
3173              case 'isoWeek':
3174              case 'day':
3175              case 'date':
3176                  this.hours(0);
3177                  /* falls through */
3178              case 'hour':
3179                  this.minutes(0);
3180                  /* falls through */
3181              case 'minute':
3182                  this.seconds(0);
3183                  /* falls through */
3184              case 'second':
3185                  this.milliseconds(0);
3186          }
3187  
3188          // weeks are a special case
3189          if (units === 'week') {
3190              this.weekday(0);
3191          }
3192          if (units === 'isoWeek') {
3193              this.isoWeekday(1);
3194          }
3195  
3196          // quarters are also special
3197          if (units === 'quarter') {
3198              this.month(Math.floor(this.month() / 3) * 3);
3199          }
3200  
3201          return this;
3202      }
3203  
3204      function endOf (units) {
3205          units = normalizeUnits(units);
3206          if (units === undefined || units === 'millisecond') {
3207              return this;
3208          }
3209  
3210          // 'date' is an alias for 'day', so it should be considered as such.
3211          if (units === 'date') {
3212              units = 'day';
3213          }
3214  
3215          return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
3216      }
3217  
3218      function to_type__valueOf () {
3219          return this._d.valueOf() - ((this._offset || 0) * 60000);
3220      }
3221  
3222      function unix () {
3223          return Math.floor(this.valueOf() / 1000);
3224      }
3225  
3226      function toDate () {
3227          return new Date(this.valueOf());
3228      }
3229  
3230      function toArray () {
3231          var m = this;
3232          return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
3233      }
3234  
3235      function toObject () {
3236          var m = this;
3237          return {
3238              years: m.year(),
3239              months: m.month(),
3240              date: m.date(),
3241              hours: m.hours(),
3242              minutes: m.minutes(),
3243              seconds: m.seconds(),
3244              milliseconds: m.milliseconds()
3245          };
3246      }
3247  
3248      function toJSON () {
3249          // new Date(NaN).toJSON() === null
3250          return this.isValid() ? this.toISOString() : null;
3251      }
3252  
3253      function moment_valid__isValid () {
3254          return valid__isValid(this);
3255      }
3256  
3257      function parsingFlags () {
3258          return extend({}, getParsingFlags(this));
3259      }
3260  
3261      function invalidAt () {
3262          return getParsingFlags(this).overflow;
3263      }
3264  
3265      function creationData() {
3266          return {
3267              input: this._i,
3268              format: this._f,
3269              locale: this._locale,
3270              isUTC: this._isUTC,
3271              strict: this._strict
3272          };
3273      }
3274  
3275      // FORMATTING
3276  
3277      addFormatToken(0, ['gg', 2], 0, function () {
3278          return this.weekYear() % 100;
3279      });
3280  
3281      addFormatToken(0, ['GG', 2], 0, function () {
3282          return this.isoWeekYear() % 100;
3283      });
3284  
3285      function addWeekYearFormatToken (token, getter) {
3286          addFormatToken(0, [token, token.length], 0, getter);
3287      }
3288  
3289      addWeekYearFormatToken('gggg',     'weekYear');
3290      addWeekYearFormatToken('ggggg',    'weekYear');
3291      addWeekYearFormatToken('GGGG',  'isoWeekYear');
3292      addWeekYearFormatToken('GGGGG', 'isoWeekYear');
3293  
3294      // ALIASES
3295  
3296      addUnitAlias('weekYear', 'gg');
3297      addUnitAlias('isoWeekYear', 'GG');
3298  
3299      // PRIORITY
3300  
3301      addUnitPriority('weekYear', 1);
3302      addUnitPriority('isoWeekYear', 1);
3303  
3304  
3305      // PARSING
3306  
3307      addRegexToken('G',      matchSigned);
3308      addRegexToken('g',      matchSigned);
3309      addRegexToken('GG',     match1to2, match2);
3310      addRegexToken('gg',     match1to2, match2);
3311      addRegexToken('GGGG',   match1to4, match4);
3312      addRegexToken('gggg',   match1to4, match4);
3313      addRegexToken('GGGGG',  match1to6, match6);
3314      addRegexToken('ggggg',  match1to6, match6);
3315  
3316      addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
3317          week[token.substr(0, 2)] = toInt(input);
3318      });
3319  
3320      addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
3321          week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
3322      });
3323  
3324      // MOMENTS
3325  
3326      function getSetWeekYear (input) {
3327          return getSetWeekYearHelper.call(this,
3328                  input,
3329                  this.week(),
3330                  this.weekday(),
3331                  this.localeData()._week.dow,
3332                  this.localeData()._week.doy);
3333      }
3334  
3335      function getSetISOWeekYear (input) {
3336          return getSetWeekYearHelper.call(this,
3337                  input, this.isoWeek(), this.isoWeekday(), 1, 4);
3338      }
3339  
3340      function getISOWeeksInYear () {
3341          return weeksInYear(this.year(), 1, 4);
3342      }
3343  
3344      function getWeeksInYear () {
3345          var weekInfo = this.localeData()._week;
3346          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
3347      }
3348  
3349      function getSetWeekYearHelper(input, week, weekday, dow, doy) {
3350          var weeksTarget;
3351          if (input == null) {
3352              return weekOfYear(this, dow, doy).year;
3353          } else {
3354              weeksTarget = weeksInYear(input, dow, doy);
3355              if (week > weeksTarget) {
3356                  week = weeksTarget;
3357              }
3358              return setWeekAll.call(this, input, week, weekday, dow, doy);
3359          }
3360      }
3361  
3362      function setWeekAll(weekYear, week, weekday, dow, doy) {
3363          var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
3364              date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
3365  
3366          this.year(date.getUTCFullYear());
3367          this.month(date.getUTCMonth());
3368          this.date(date.getUTCDate());
3369          return this;
3370      }
3371  
3372      // FORMATTING
3373  
3374      addFormatToken('Q', 0, 'Qo', 'quarter');
3375  
3376      // ALIASES
3377  
3378      addUnitAlias('quarter', 'Q');
3379  
3380      // PRIORITY
3381  
3382      addUnitPriority('quarter', 7);
3383  
3384      // PARSING
3385  
3386      addRegexToken('Q', match1);
3387      addParseToken('Q', function (input, array) {
3388          array[MONTH] = (toInt(input) - 1) * 3;
3389      });
3390  
3391      // MOMENTS
3392  
3393      function getSetQuarter (input) {
3394          return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
3395      }
3396  
3397      // FORMATTING
3398  
3399      addFormatToken('D', ['DD', 2], 'Do', 'date');
3400  
3401      // ALIASES
3402  
3403      addUnitAlias('date', 'D');
3404  
3405      // PRIOROITY
3406      addUnitPriority('date', 9);
3407  
3408      // PARSING
3409  
3410      addRegexToken('D',  match1to2);
3411      addRegexToken('DD', match1to2, match2);
3412      addRegexToken('Do', function (isStrict, locale) {
3413          return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
3414      });
3415  
3416      addParseToken(['D', 'DD'], DATE);
3417      addParseToken('Do', function (input, array) {
3418          array[DATE] = toInt(input.match(match1to2)[0], 10);
3419      });
3420  
3421      // MOMENTS
3422  
3423      var getSetDayOfMonth = makeGetSet('Date', true);
3424  
3425      // FORMATTING
3426  
3427      addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
3428  
3429      // ALIASES
3430  
3431      addUnitAlias('dayOfYear', 'DDD');
3432  
3433      // PRIORITY
3434      addUnitPriority('dayOfYear', 4);
3435  
3436      // PARSING
3437  
3438      addRegexToken('DDD',  match1to3);
3439      addRegexToken('DDDD', match3);
3440      addParseToken(['DDD', 'DDDD'], function (input, array, config) {
3441          config._dayOfYear = toInt(input);
3442      });
3443  
3444      // HELPERS
3445  
3446      // MOMENTS
3447  
3448      function getSetDayOfYear (input) {
3449          var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
3450          return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
3451      }
3452  
3453      // FORMATTING
3454  
3455      addFormatToken('m', ['mm', 2], 0, 'minute');
3456  
3457      // ALIASES
3458  
3459      addUnitAlias('minute', 'm');
3460  
3461      // PRIORITY
3462  
3463      addUnitPriority('minute', 14);
3464  
3465      // PARSING
3466  
3467      addRegexToken('m',  match1to2);
3468      addRegexToken('mm', match1to2, match2);
3469      addParseToken(['m', 'mm'], MINUTE);
3470  
3471      // MOMENTS
3472  
3473      var getSetMinute = makeGetSet('Minutes', false);
3474  
3475      // FORMATTING
3476  
3477      addFormatToken('s', ['ss', 2], 0, 'second');
3478  
3479      // ALIASES
3480  
3481      addUnitAlias('second', 's');
3482  
3483      // PRIORITY
3484  
3485      addUnitPriority('second', 15);
3486  
3487      // PARSING
3488  
3489      addRegexToken('s',  match1to2);
3490      addRegexToken('ss', match1to2, match2);
3491      addParseToken(['s', 'ss'], SECOND);
3492  
3493      // MOMENTS
3494  
3495      var getSetSecond = makeGetSet('Seconds', false);
3496  
3497      // FORMATTING
3498  
3499      addFormatToken('S', 0, 0, function () {
3500          return ~~(this.millisecond() / 100);
3501      });
3502  
3503      addFormatToken(0, ['SS', 2], 0, function () {
3504          return ~~(this.millisecond() / 10);
3505      });
3506  
3507      addFormatToken(0, ['SSS', 3], 0, 'millisecond');
3508      addFormatToken(0, ['SSSS', 4], 0, function () {
3509          return this.millisecond() * 10;
3510      });
3511      addFormatToken(0, ['SSSSS', 5], 0, function () {
3512          return this.millisecond() * 100;
3513      });
3514      addFormatToken(0, ['SSSSSS', 6], 0, function () {
3515          return this.millisecond() * 1000;
3516      });
3517      addFormatToken(0, ['SSSSSSS', 7], 0, function () {
3518          return this.millisecond() * 10000;
3519      });
3520      addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
3521          return this.millisecond() * 100000;
3522      });
3523      addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
3524          return this.millisecond() * 1000000;
3525      });
3526  
3527  
3528      // ALIASES
3529  
3530      addUnitAlias('millisecond', 'ms');
3531  
3532      // PRIORITY
3533  
3534      addUnitPriority('millisecond', 16);
3535  
3536      // PARSING
3537  
3538      addRegexToken('S',    match1to3, match1);
3539      addRegexToken('SS',   match1to3, match2);
3540      addRegexToken('SSS',  match1to3, match3);
3541  
3542      var token;
3543      for (token = 'SSSS'; token.length <= 9; token += 'S') {
3544          addRegexToken(token, matchUnsigned);
3545      }
3546  
3547      function parseMs(input, array) {
3548          array[MILLISECOND] = toInt(('0.' + input) * 1000);
3549      }
3550  
3551      for (token = 'S'; token.length <= 9; token += 'S') {
3552          addParseToken(token, parseMs);
3553      }
3554      // MOMENTS
3555  
3556      var getSetMillisecond = makeGetSet('Milliseconds', false);
3557  
3558      // FORMATTING
3559  
3560      addFormatToken('z',  0, 0, 'zoneAbbr');
3561      addFormatToken('zz', 0, 0, 'zoneName');
3562  
3563      // MOMENTS
3564  
3565      function getZoneAbbr () {
3566          return this._isUTC ? 'UTC' : '';
3567      }
3568  
3569      function getZoneName () {
3570          return this._isUTC ? 'Coordinated Universal Time' : '';
3571      }
3572  
3573      var momentPrototype__proto = Moment.prototype;
3574  
3575      momentPrototype__proto.add               = add_subtract__add;
3576      momentPrototype__proto.calendar          = moment_calendar__calendar;
3577      momentPrototype__proto.clone             = clone;
3578      momentPrototype__proto.diff              = diff;
3579      momentPrototype__proto.endOf             = endOf;
3580      momentPrototype__proto.format            = format;
3581      momentPrototype__proto.from              = from;
3582      momentPrototype__proto.fromNow           = fromNow;
3583      momentPrototype__proto.to                = to;
3584      momentPrototype__proto.toNow             = toNow;
3585      momentPrototype__proto.get               = stringGet;
3586      momentPrototype__proto.invalidAt         = invalidAt;
3587      momentPrototype__proto.isAfter           = isAfter;
3588      momentPrototype__proto.isBefore          = isBefore;
3589      momentPrototype__proto.isBetween         = isBetween;
3590      momentPrototype__proto.isSame            = isSame;
3591      momentPrototype__proto.isSameOrAfter     = isSameOrAfter;
3592      momentPrototype__proto.isSameOrBefore    = isSameOrBefore;
3593      momentPrototype__proto.isValid           = moment_valid__isValid;
3594      momentPrototype__proto.lang              = lang;
3595      momentPrototype__proto.locale            = locale;
3596      momentPrototype__proto.localeData        = localeData;
3597      momentPrototype__proto.max               = prototypeMax;
3598      momentPrototype__proto.min               = prototypeMin;
3599      momentPrototype__proto.parsingFlags      = parsingFlags;
3600      momentPrototype__proto.set               = stringSet;
3601      momentPrototype__proto.startOf           = startOf;
3602      momentPrototype__proto.subtract          = add_subtract__subtract;
3603      momentPrototype__proto.toArray           = toArray;
3604      momentPrototype__proto.toObject          = toObject;
3605      momentPrototype__proto.toDate            = toDate;
3606      momentPrototype__proto.toISOString       = moment_format__toISOString;
3607      momentPrototype__proto.toJSON            = toJSON;
3608      momentPrototype__proto.toString          = toString;
3609      momentPrototype__proto.unix              = unix;
3610      momentPrototype__proto.valueOf           = to_type__valueOf;
3611      momentPrototype__proto.creationData      = creationData;
3612  
3613      // Year
3614      momentPrototype__proto.year       = getSetYear;
3615      momentPrototype__proto.isLeapYear = getIsLeapYear;
3616  
3617      // Week Year
3618      momentPrototype__proto.weekYear    = getSetWeekYear;
3619      momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
3620  
3621      // Quarter
3622      momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
3623  
3624      // Month
3625      momentPrototype__proto.month       = getSetMonth;
3626      momentPrototype__proto.daysInMonth = getDaysInMonth;
3627  
3628      // Week
3629      momentPrototype__proto.week           = momentPrototype__proto.weeks        = getSetWeek;
3630      momentPrototype__proto.isoWeek        = momentPrototype__proto.isoWeeks     = getSetISOWeek;
3631      momentPrototype__proto.weeksInYear    = getWeeksInYear;
3632      momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
3633  
3634      // Day
3635      momentPrototype__proto.date       = getSetDayOfMonth;
3636      momentPrototype__proto.day        = momentPrototype__proto.days             = getSetDayOfWeek;
3637      momentPrototype__proto.weekday    = getSetLocaleDayOfWeek;
3638      momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
3639      momentPrototype__proto.dayOfYear  = getSetDayOfYear;
3640  
3641      // Hour
3642      momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
3643  
3644      // Minute
3645      momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
3646  
3647      // Second
3648      momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
3649  
3650      // Millisecond
3651      momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
3652  
3653      // Offset
3654      momentPrototype__proto.utcOffset            = getSetOffset;
3655      momentPrototype__proto.utc                  = setOffsetToUTC;
3656      momentPrototype__proto.local                = setOffsetToLocal;
3657      momentPrototype__proto.parseZone            = setOffsetToParsedOffset;
3658      momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
3659      momentPrototype__proto.isDST                = isDaylightSavingTime;
3660      momentPrototype__proto.isLocal              = isLocal;
3661      momentPrototype__proto.isUtcOffset          = isUtcOffset;
3662      momentPrototype__proto.isUtc                = isUtc;
3663      momentPrototype__proto.isUTC                = isUtc;
3664  
3665      // Timezone
3666      momentPrototype__proto.zoneAbbr = getZoneAbbr;
3667      momentPrototype__proto.zoneName = getZoneName;
3668  
3669      // Deprecations
3670      momentPrototype__proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
3671      momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
3672      momentPrototype__proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
3673      momentPrototype__proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
3674      momentPrototype__proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
3675  
3676      var momentPrototype = momentPrototype__proto;
3677  
3678      function moment__createUnix (input) {
3679          return local__createLocal(input * 1000);
3680      }
3681  
3682      function moment__createInZone () {
3683          return local__createLocal.apply(null, arguments).parseZone();
3684      }
3685  
3686      function preParsePostFormat (string) {
3687          return string;
3688      }
3689  
3690      var prototype__proto = Locale.prototype;
3691  
3692      prototype__proto.calendar        = locale_calendar__calendar;
3693      prototype__proto.longDateFormat  = longDateFormat;
3694      prototype__proto.invalidDate     = invalidDate;
3695      prototype__proto.ordinal         = ordinal;
3696      prototype__proto.preparse        = preParsePostFormat;
3697      prototype__proto.postformat      = preParsePostFormat;
3698      prototype__proto.relativeTime    = relative__relativeTime;
3699      prototype__proto.pastFuture      = pastFuture;
3700      prototype__proto.set             = locale_set__set;
3701  
3702      // Month
3703      prototype__proto.months            =        localeMonths;
3704      prototype__proto.monthsShort       =        localeMonthsShort;
3705      prototype__proto.monthsParse       =        localeMonthsParse;
3706      prototype__proto.monthsRegex       = monthsRegex;
3707      prototype__proto.monthsShortRegex  = monthsShortRegex;
3708  
3709      // Week
3710      prototype__proto.week = localeWeek;
3711      prototype__proto.firstDayOfYear = localeFirstDayOfYear;
3712      prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
3713  
3714      // Day of Week
3715      prototype__proto.weekdays       =        localeWeekdays;
3716      prototype__proto.weekdaysMin    =        localeWeekdaysMin;
3717      prototype__proto.weekdaysShort  =        localeWeekdaysShort;
3718      prototype__proto.weekdaysParse  =        localeWeekdaysParse;
3719  
3720      prototype__proto.weekdaysRegex       =        weekdaysRegex;
3721      prototype__proto.weekdaysShortRegex  =        weekdaysShortRegex;
3722      prototype__proto.weekdaysMinRegex    =        weekdaysMinRegex;
3723  
3724      // Hours
3725      prototype__proto.isPM = localeIsPM;
3726      prototype__proto.meridiem = localeMeridiem;
3727  
3728      function lists__get (format, index, field, setter) {
3729          var locale = locale_locales__getLocale();
3730          var utc = create_utc__createUTC().set(setter, index);
3731          return locale[field](utc, format);
3732      }
3733  
3734      function listMonthsImpl (format, index, field) {
3735          if (typeof format === 'number') {
3736              index = format;
3737              format = undefined;
3738          }
3739  
3740          format = format || '';
3741  
3742          if (index != null) {
3743              return lists__get(format, index, field, 'month');
3744          }
3745  
3746          var i;
3747          var out = [];
3748          for (i = 0; i < 12; i++) {
3749              out[i] = lists__get(format, i, field, 'month');
3750          }
3751          return out;
3752      }
3753  
3754      // ()
3755      // (5)
3756      // (fmt, 5)
3757      // (fmt)
3758      // (true)
3759      // (true, 5)
3760      // (true, fmt, 5)
3761      // (true, fmt)
3762      function listWeekdaysImpl (localeSorted, format, index, field) {
3763          if (typeof localeSorted === 'boolean') {
3764              if (typeof format === 'number') {
3765                  index = format;
3766                  format = undefined;
3767              }
3768  
3769              format = format || '';
3770          } else {
3771              format = localeSorted;
3772              index = format;
3773              localeSorted = false;
3774  
3775              if (typeof format === 'number') {
3776                  index = format;
3777                  format = undefined;
3778              }
3779  
3780              format = format || '';
3781          }
3782  
3783          var locale = locale_locales__getLocale(),
3784              shift = localeSorted ? locale._week.dow : 0;
3785  
3786          if (index != null) {
3787              return lists__get(format, (index + shift) % 7, field, 'day');
3788          }
3789  
3790          var i;
3791          var out = [];
3792          for (i = 0; i < 7; i++) {
3793              out[i] = lists__get(format, (i + shift) % 7, field, 'day');
3794          }
3795          return out;
3796      }
3797  
3798      function lists__listMonths (format, index) {
3799          return listMonthsImpl(format, index, 'months');
3800      }
3801  
3802      function lists__listMonthsShort (format, index) {
3803          return listMonthsImpl(format, index, 'monthsShort');
3804      }
3805  
3806      function lists__listWeekdays (localeSorted, format, index) {
3807          return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
3808      }
3809  
3810      function lists__listWeekdaysShort (localeSorted, format, index) {
3811          return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
3812      }
3813  
3814      function lists__listWeekdaysMin (localeSorted, format, index) {
3815          return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
3816      }
3817  
3818      locale_locales__getSetGlobalLocale('en', {
3819          ordinalParse: /\d{1,2}(th|st|nd|rd)/,
3820          ordinal : function (number) {
3821              var b = number % 10,
3822                  output = (toInt(number % 100 / 10) === 1) ? 'th' :
3823                  (b === 1) ? 'st' :
3824                  (b === 2) ? 'nd' :
3825                  (b === 3) ? 'rd' : 'th';
3826              return number + output;
3827          }
3828      });
3829  
3830      // Side effect imports
3831      utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
3832      utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
3833  
3834      var mathAbs = Math.abs;
3835  
3836      function duration_abs__abs () {
3837          var data           = this._data;
3838  
3839          this._milliseconds = mathAbs(this._milliseconds);
3840          this._days         = mathAbs(this._days);
3841          this._months       = mathAbs(this._months);
3842  
3843          data.milliseconds  = mathAbs(data.milliseconds);
3844          data.seconds       = mathAbs(data.seconds);
3845          data.minutes       = mathAbs(data.minutes);
3846          data.hours         = mathAbs(data.hours);
3847          data.months        = mathAbs(data.months);
3848          data.years         = mathAbs(data.years);
3849  
3850          return this;
3851      }
3852  
3853      function duration_add_subtract__addSubtract (duration, input, value, direction) {
3854          var other = create__createDuration(input, value);
3855  
3856          duration._milliseconds += direction * other._milliseconds;
3857          duration._days         += direction * other._days;
3858          duration._months       += direction * other._months;
3859  
3860          return duration._bubble();
3861      }
3862  
3863      // supports only 2.0-style add(1, 's') or add(duration)
3864      function duration_add_subtract__add (input, value) {
3865          return duration_add_subtract__addSubtract(this, input, value, 1);
3866      }
3867  
3868      // supports only 2.0-style subtract(1, 's') or subtract(duration)
3869      function duration_add_subtract__subtract (input, value) {
3870          return duration_add_subtract__addSubtract(this, input, value, -1);
3871      }
3872  
3873      function absCeil (number) {
3874          if (number < 0) {
3875              return Math.floor(number);
3876          } else {
3877              return Math.ceil(number);
3878          }
3879      }
3880  
3881      function bubble () {
3882          var milliseconds = this._milliseconds;
3883          var days         = this._days;
3884          var months       = this._months;
3885          var data         = this._data;
3886          var seconds, minutes, hours, years, monthsFromDays;
3887  
3888          // if we have a mix of positive and negative values, bubble down first
3889          // check: https://github.com/moment/moment/issues/2166
3890          if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
3891                  (milliseconds <= 0 && days <= 0 && months <= 0))) {
3892              milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
3893              days = 0;
3894              months = 0;
3895          }
3896  
3897          // The following code bubbles up values, see the tests for
3898          // examples of what that means.
3899          data.milliseconds = milliseconds % 1000;
3900  
3901          seconds           = absFloor(milliseconds / 1000);
3902          data.seconds      = seconds % 60;
3903  
3904          minutes           = absFloor(seconds / 60);
3905          data.minutes      = minutes % 60;
3906  
3907          hours             = absFloor(minutes / 60);
3908          data.hours        = hours % 24;
3909  
3910          days += absFloor(hours / 24);
3911  
3912          // convert days to months
3913          monthsFromDays = absFloor(daysToMonths(days));
3914          months += monthsFromDays;
3915          days -= absCeil(monthsToDays(monthsFromDays));
3916  
3917          // 12 months -> 1 year
3918          years = absFloor(months / 12);
3919          months %= 12;
3920  
3921          data.days   = days;
3922          data.months = months;
3923          data.years  = years;
3924  
3925          return this;
3926      }
3927  
3928      function daysToMonths (days) {
3929          // 400 years have 146097 days (taking into account leap year rules)
3930          // 400 years have 12 months === 4800
3931          return days * 4800 / 146097;
3932      }
3933  
3934      function monthsToDays (months) {
3935          // the reverse of daysToMonths
3936          return months * 146097 / 4800;
3937      }
3938  
3939      function as (units) {
3940          var days;
3941          var months;
3942          var milliseconds = this._milliseconds;
3943  
3944          units = normalizeUnits(units);
3945  
3946          if (units === 'month' || units === 'year') {
3947              days   = this._days   + milliseconds / 864e5;
3948              months = this._months + daysToMonths(days);
3949              return units === 'month' ? months : months / 12;
3950          } else {
3951              // handle milliseconds separately because of floating point math errors (issue #1867)
3952              days = this._days + Math.round(monthsToDays(this._months));
3953              switch (units) {
3954                  case 'week'   : return days / 7     + milliseconds / 6048e5;
3955                  case 'day'    : return days         + milliseconds / 864e5;
3956                  case 'hour'   : return days * 24    + milliseconds / 36e5;
3957                  case 'minute' : return days * 1440  + milliseconds / 6e4;
3958                  case 'second' : return days * 86400 + milliseconds / 1000;
3959                  // Math.floor prevents floating point math errors here
3960                  case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
3961                  default: throw new Error('Unknown unit ' + units);
3962              }
3963          }
3964      }
3965  
3966      // TODO: Use this.as('ms')?
3967      function duration_as__valueOf () {
3968          return (
3969              this._milliseconds +
3970              this._days * 864e5 +
3971              (this._months % 12) * 2592e6 +
3972              toInt(this._months / 12) * 31536e6
3973          );
3974      }
3975  
3976      function makeAs (alias) {
3977          return function () {
3978              return this.as(alias);
3979          };
3980      }
3981  
3982      var asMilliseconds = makeAs('ms');
3983      var asSeconds      = makeAs('s');
3984      var asMinutes      = makeAs('m');
3985      var asHours        = makeAs('h');
3986      var asDays         = makeAs('d');
3987      var asWeeks        = makeAs('w');
3988      var asMonths       = makeAs('M');
3989      var asYears        = makeAs('y');
3990  
3991      function duration_get__get (units) {
3992          units = normalizeUnits(units);
3993          return this[units + 's']();
3994      }
3995  
3996      function makeGetter(name) {
3997          return function () {
3998              return this._data[name];
3999          };
4000      }
4001  
4002      var milliseconds = makeGetter('milliseconds');
4003      var seconds      = makeGetter('seconds');
4004      var minutes      = makeGetter('minutes');
4005      var hours        = makeGetter('hours');
4006      var days         = makeGetter('days');
4007      var months       = makeGetter('months');
4008      var years        = makeGetter('years');
4009  
4010      function weeks () {
4011          return absFloor(this.days() / 7);
4012      }
4013  
4014      var round = Math.round;
4015      var thresholds = {
4016          s: 45,  // seconds to minute
4017          m: 45,  // minutes to hour
4018          h: 22,  // hours to day
4019          d: 26,  // days to month
4020          M: 11   // months to year
4021      };
4022  
4023      // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
4024      function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
4025          return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
4026      }
4027  
4028      function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
4029          var duration = create__createDuration(posNegDuration).abs();
4030          var seconds  = round(duration.as('s'));
4031          var minutes  = round(duration.as('m'));
4032          var hours    = round(duration.as('h'));
4033          var days     = round(duration.as('d'));
4034          var months   = round(duration.as('M'));
4035          var years    = round(duration.as('y'));
4036  
4037          var a = seconds < thresholds.s && ['s', seconds]  ||
4038                  minutes <= 1           && ['m']           ||
4039                  minutes < thresholds.m && ['mm', minutes] ||
4040                  hours   <= 1           && ['h']           ||
4041                  hours   < thresholds.h && ['hh', hours]   ||
4042                  days    <= 1           && ['d']           ||
4043                  days    < thresholds.d && ['dd', days]    ||
4044                  months  <= 1           && ['M']           ||
4045                  months  < thresholds.M && ['MM', months]  ||
4046                  years   <= 1           && ['y']           || ['yy', years];
4047  
4048          a[2] = withoutSuffix;
4049          a[3] = +posNegDuration > 0;
4050          a[4] = locale;
4051          return substituteTimeAgo.apply(null, a);
4052      }
4053  
4054      // This function allows you to set the rounding function for relative time strings
4055      function duration_humanize__getSetRelativeTimeRounding (roundingFunction) {
4056          if (roundingFunction === undefined) {
4057              return round;
4058          }
4059          if (typeof(roundingFunction) === 'function') {
4060              round = roundingFunction;
4061              return true;
4062          }
4063          return false;
4064      }
4065  
4066      // This function allows you to set a threshold for relative time strings
4067      function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
4068          if (thresholds[threshold] === undefined) {
4069              return false;
4070          }
4071          if (limit === undefined) {
4072              return thresholds[threshold];
4073          }
4074          thresholds[threshold] = limit;
4075          return true;
4076      }
4077  
4078      function humanize (withSuffix) {
4079          var locale = this.localeData();
4080          var output = duration_humanize__relativeTime(this, !withSuffix, locale);
4081  
4082          if (withSuffix) {
4083              output = locale.pastFuture(+this, output);
4084          }
4085  
4086          return locale.postformat(output);
4087      }
4088  
4089      var iso_string__abs = Math.abs;
4090  
4091      function iso_string__toISOString() {
4092          // for ISO strings we do not use the normal bubbling rules:
4093          //  * milliseconds bubble up until they become hours
4094          //  * days do not bubble at all
4095          //  * months bubble up until they become years
4096          // This is because there is no context-free conversion between hours and days
4097          // (think of clock changes)
4098          // and also not between days and months (28-31 days per month)
4099          var seconds = iso_string__abs(this._milliseconds) / 1000;
4100          var days         = iso_string__abs(this._days);
4101          var months       = iso_string__abs(this._months);
4102          var minutes, hours, years;
4103  
4104          // 3600 seconds -> 60 minutes -> 1 hour
4105          minutes           = absFloor(seconds / 60);
4106          hours             = absFloor(minutes / 60);
4107          seconds %= 60;
4108          minutes %= 60;
4109  
4110          // 12 months -> 1 year
4111          years  = absFloor(months / 12);
4112          months %= 12;
4113  
4114  
4115          // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
4116          var Y = years;
4117          var M = months;
4118          var D = days;
4119          var h = hours;
4120          var m = minutes;
4121          var s = seconds;
4122          var total = this.asSeconds();
4123  
4124          if (!total) {
4125              // this is the same as C#'s (Noda) and python (isodate)...
4126              // but not other JS (goog.date)
4127              return 'P0D';
4128          }
4129  
4130          return (total < 0 ? '-' : '') +
4131              'P' +
4132              (Y ? Y + 'Y' : '') +
4133              (M ? M + 'M' : '') +
4134              (D ? D + 'D' : '') +
4135              ((h || m || s) ? 'T' : '') +
4136              (h ? h + 'H' : '') +
4137              (m ? m + 'M' : '') +
4138              (s ? s + 'S' : '');
4139      }
4140  
4141      var duration_prototype__proto = Duration.prototype;
4142  
4143      duration_prototype__proto.abs            = duration_abs__abs;
4144      duration_prototype__proto.add            = duration_add_subtract__add;
4145      duration_prototype__proto.subtract       = duration_add_subtract__subtract;
4146      duration_prototype__proto.as             = as;
4147      duration_prototype__proto.asMilliseconds = asMilliseconds;
4148      duration_prototype__proto.asSeconds      = asSeconds;
4149      duration_prototype__proto.asMinutes      = asMinutes;
4150      duration_prototype__proto.asHours        = asHours;
4151      duration_prototype__proto.asDays         = asDays;
4152      duration_prototype__proto.asWeeks        = asWeeks;
4153      duration_prototype__proto.asMonths       = asMonths;
4154      duration_prototype__proto.asYears        = asYears;
4155      duration_prototype__proto.valueOf        = duration_as__valueOf;
4156      duration_prototype__proto._bubble        = bubble;
4157      duration_prototype__proto.get            = duration_get__get;
4158      duration_prototype__proto.milliseconds   = milliseconds;
4159      duration_prototype__proto.seconds        = seconds;
4160      duration_prototype__proto.minutes        = minutes;
4161      duration_prototype__proto.hours          = hours;
4162      duration_prototype__proto.days           = days;
4163      duration_prototype__proto.weeks          = weeks;
4164      duration_prototype__proto.months         = months;
4165      duration_prototype__proto.years          = years;
4166      duration_prototype__proto.humanize       = humanize;
4167      duration_prototype__proto.toISOString    = iso_string__toISOString;
4168      duration_prototype__proto.toString       = iso_string__toISOString;
4169      duration_prototype__proto.toJSON         = iso_string__toISOString;
4170      duration_prototype__proto.locale         = locale;
4171      duration_prototype__proto.localeData     = localeData;
4172  
4173      // Deprecations
4174      duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
4175      duration_prototype__proto.lang = lang;
4176  
4177      // Side effect imports
4178  
4179      // FORMATTING
4180  
4181      addFormatToken('X', 0, 0, 'unix');
4182      addFormatToken('x', 0, 0, 'valueOf');
4183  
4184      // PARSING
4185  
4186      addRegexToken('x', matchSigned);
4187      addRegexToken('X', matchTimestamp);
4188      addParseToken('X', function (input, array, config) {
4189          config._d = new Date(parseFloat(input, 10) * 1000);
4190      });
4191      addParseToken('x', function (input, array, config) {
4192          config._d = new Date(toInt(input));
4193      });
4194  
4195      // Side effect imports
4196  
4197  
4198      utils_hooks__hooks.version = '2.15.1';
4199  
4200      setHookCallback(local__createLocal);
4201  
4202      utils_hooks__hooks.fn                    = momentPrototype;
4203      utils_hooks__hooks.min                   = min;
4204      utils_hooks__hooks.max                   = max;
4205      utils_hooks__hooks.now                   = now;
4206      utils_hooks__hooks.utc                   = create_utc__createUTC;
4207      utils_hooks__hooks.unix                  = moment__createUnix;
4208      utils_hooks__hooks.months                = lists__listMonths;
4209      utils_hooks__hooks.isDate                = isDate;
4210      utils_hooks__hooks.locale                = locale_locales__getSetGlobalLocale;
4211      utils_hooks__hooks.invalid               = valid__createInvalid;
4212      utils_hooks__hooks.duration              = create__createDuration;
4213      utils_hooks__hooks.isMoment              = isMoment;
4214      utils_hooks__hooks.weekdays              = lists__listWeekdays;
4215      utils_hooks__hooks.parseZone             = moment__createInZone;
4216      utils_hooks__hooks.localeData            = locale_locales__getLocale;
4217      utils_hooks__hooks.isDuration            = isDuration;
4218      utils_hooks__hooks.monthsShort           = lists__listMonthsShort;
4219      utils_hooks__hooks.weekdaysMin           = lists__listWeekdaysMin;
4220      utils_hooks__hooks.defineLocale          = defineLocale;
4221      utils_hooks__hooks.updateLocale          = updateLocale;
4222      utils_hooks__hooks.locales               = locale_locales__listLocales;
4223      utils_hooks__hooks.weekdaysShort         = lists__listWeekdaysShort;
4224      utils_hooks__hooks.normalizeUnits        = normalizeUnits;
4225      utils_hooks__hooks.relativeTimeRounding = duration_humanize__getSetRelativeTimeRounding;
4226      utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
4227      utils_hooks__hooks.calendarFormat        = getCalendarFormat;
4228      utils_hooks__hooks.prototype             = momentPrototype;
4229  
4230      var _moment = utils_hooks__hooks;
4231  
4232      return _moment;
4233  
4234  }));


Generated: Tue Sep 17 01:01:39 2019 Cross-referenced by PHPXref 0.7.1