[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/vendor/ -> moment.js (source)

   1  //! moment.js
   2  //! version : 2.29.2
   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 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 (
  27              input instanceof Array ||
  28              Object.prototype.toString.call(input) === '[object Array]'
  29          );
  30      }
  31  
  32      function isObject(input) {
  33          // IE8 will treat undefined and null as object if it wasn't for
  34          // input != null
  35          return (
  36              input != null &&
  37              Object.prototype.toString.call(input) === '[object Object]'
  38          );
  39      }
  40  
  41      function hasOwnProp(a, b) {
  42          return Object.prototype.hasOwnProperty.call(a, b);
  43      }
  44  
  45      function isObjectEmpty(obj) {
  46          if (Object.getOwnPropertyNames) {
  47              return Object.getOwnPropertyNames(obj).length === 0;
  48          } else {
  49              var k;
  50              for (k in obj) {
  51                  if (hasOwnProp(obj, k)) {
  52                      return false;
  53                  }
  54              }
  55              return true;
  56          }
  57      }
  58  
  59      function isUndefined(input) {
  60          return input === void 0;
  61      }
  62  
  63      function isNumber(input) {
  64          return (
  65              typeof input === 'number' ||
  66              Object.prototype.toString.call(input) === '[object Number]'
  67          );
  68      }
  69  
  70      function isDate(input) {
  71          return (
  72              input instanceof Date ||
  73              Object.prototype.toString.call(input) === '[object Date]'
  74          );
  75      }
  76  
  77      function map(arr, fn) {
  78          var res = [],
  79              i,
  80              arrLen = arr.length;
  81          for (i = 0; i < arrLen; ++i) {
  82              res.push(fn(arr[i], i));
  83          }
  84          return res;
  85      }
  86  
  87      function extend(a, b) {
  88          for (var i in b) {
  89              if (hasOwnProp(b, i)) {
  90                  a[i] = b[i];
  91              }
  92          }
  93  
  94          if (hasOwnProp(b, 'toString')) {
  95              a.toString = b.toString;
  96          }
  97  
  98          if (hasOwnProp(b, 'valueOf')) {
  99              a.valueOf = b.valueOf;
 100          }
 101  
 102          return a;
 103      }
 104  
 105      function createUTC(input, format, locale, strict) {
 106          return createLocalOrUTC(input, format, locale, strict, true).utc();
 107      }
 108  
 109      function defaultParsingFlags() {
 110          // We need to deep clone this object.
 111          return {
 112              empty: false,
 113              unusedTokens: [],
 114              unusedInput: [],
 115              overflow: -2,
 116              charsLeftOver: 0,
 117              nullInput: false,
 118              invalidEra: null,
 119              invalidMonth: null,
 120              invalidFormat: false,
 121              userInvalidated: false,
 122              iso: false,
 123              parsedDateParts: [],
 124              era: null,
 125              meridiem: null,
 126              rfc2822: false,
 127              weekdayMismatch: false,
 128          };
 129      }
 130  
 131      function getParsingFlags(m) {
 132          if (m._pf == null) {
 133              m._pf = defaultParsingFlags();
 134          }
 135          return m._pf;
 136      }
 137  
 138      var some;
 139      if (Array.prototype.some) {
 140          some = Array.prototype.some;
 141      } else {
 142          some = function (fun) {
 143              var t = Object(this),
 144                  len = t.length >>> 0,
 145                  i;
 146  
 147              for (i = 0; i < len; i++) {
 148                  if (i in t && fun.call(this, t[i], i, t)) {
 149                      return true;
 150                  }
 151              }
 152  
 153              return false;
 154          };
 155      }
 156  
 157      function isValid(m) {
 158          if (m._isValid == null) {
 159              var flags = getParsingFlags(m),
 160                  parsedParts = some.call(flags.parsedDateParts, function (i) {
 161                      return i != null;
 162                  }),
 163                  isNowValid =
 164                      !isNaN(m._d.getTime()) &&
 165                      flags.overflow < 0 &&
 166                      !flags.empty &&
 167                      !flags.invalidEra &&
 168                      !flags.invalidMonth &&
 169                      !flags.invalidWeekday &&
 170                      !flags.weekdayMismatch &&
 171                      !flags.nullInput &&
 172                      !flags.invalidFormat &&
 173                      !flags.userInvalidated &&
 174                      (!flags.meridiem || (flags.meridiem && parsedParts));
 175  
 176              if (m._strict) {
 177                  isNowValid =
 178                      isNowValid &&
 179                      flags.charsLeftOver === 0 &&
 180                      flags.unusedTokens.length === 0 &&
 181                      flags.bigHour === undefined;
 182              }
 183  
 184              if (Object.isFrozen == null || !Object.isFrozen(m)) {
 185                  m._isValid = isNowValid;
 186              } else {
 187                  return isNowValid;
 188              }
 189          }
 190          return m._isValid;
 191      }
 192  
 193      function createInvalid(flags) {
 194          var m = createUTC(NaN);
 195          if (flags != null) {
 196              extend(getParsingFlags(m), flags);
 197          } else {
 198              getParsingFlags(m).userInvalidated = true;
 199          }
 200  
 201          return m;
 202      }
 203  
 204      // Plugins that add properties should also add the key here (null value),
 205      // so we can properly clone ourselves.
 206      var momentProperties = (hooks.momentProperties = []),
 207          updateInProgress = false;
 208  
 209      function copyConfig(to, from) {
 210          var i,
 211              prop,
 212              val,
 213              momentPropertiesLen = momentProperties.length;
 214  
 215          if (!isUndefined(from._isAMomentObject)) {
 216              to._isAMomentObject = from._isAMomentObject;
 217          }
 218          if (!isUndefined(from._i)) {
 219              to._i = from._i;
 220          }
 221          if (!isUndefined(from._f)) {
 222              to._f = from._f;
 223          }
 224          if (!isUndefined(from._l)) {
 225              to._l = from._l;
 226          }
 227          if (!isUndefined(from._strict)) {
 228              to._strict = from._strict;
 229          }
 230          if (!isUndefined(from._tzm)) {
 231              to._tzm = from._tzm;
 232          }
 233          if (!isUndefined(from._isUTC)) {
 234              to._isUTC = from._isUTC;
 235          }
 236          if (!isUndefined(from._offset)) {
 237              to._offset = from._offset;
 238          }
 239          if (!isUndefined(from._pf)) {
 240              to._pf = getParsingFlags(from);
 241          }
 242          if (!isUndefined(from._locale)) {
 243              to._locale = from._locale;
 244          }
 245  
 246          if (momentPropertiesLen > 0) {
 247              for (i = 0; i < momentPropertiesLen; i++) {
 248                  prop = momentProperties[i];
 249                  val = from[prop];
 250                  if (!isUndefined(val)) {
 251                      to[prop] = val;
 252                  }
 253              }
 254          }
 255  
 256          return to;
 257      }
 258  
 259      // Moment prototype object
 260      function Moment(config) {
 261          copyConfig(this, config);
 262          this._d = new Date(config._d != null ? config._d.getTime() : NaN);
 263          if (!this.isValid()) {
 264              this._d = new Date(NaN);
 265          }
 266          // Prevent infinite loop in case updateOffset creates new moment
 267          // objects.
 268          if (updateInProgress === false) {
 269              updateInProgress = true;
 270              hooks.updateOffset(this);
 271              updateInProgress = false;
 272          }
 273      }
 274  
 275      function isMoment(obj) {
 276          return (
 277              obj instanceof Moment || (obj != null && obj._isAMomentObject != null)
 278          );
 279      }
 280  
 281      function warn(msg) {
 282          if (
 283              hooks.suppressDeprecationWarnings === false &&
 284              typeof console !== 'undefined' &&
 285              console.warn
 286          ) {
 287              console.warn('Deprecation warning: ' + msg);
 288          }
 289      }
 290  
 291      function deprecate(msg, fn) {
 292          var firstTime = true;
 293  
 294          return extend(function () {
 295              if (hooks.deprecationHandler != null) {
 296                  hooks.deprecationHandler(null, msg);
 297              }
 298              if (firstTime) {
 299                  var args = [],
 300                      arg,
 301                      i,
 302                      key,
 303                      argLen = arguments.length;
 304                  for (i = 0; i < argLen; i++) {
 305                      arg = '';
 306                      if (typeof arguments[i] === 'object') {
 307                          arg += '\n[' + i + '] ';
 308                          for (key in arguments[0]) {
 309                              if (hasOwnProp(arguments[0], key)) {
 310                                  arg += key + ': ' + arguments[0][key] + ', ';
 311                              }
 312                          }
 313                          arg = arg.slice(0, -2); // Remove trailing comma and space
 314                      } else {
 315                          arg = arguments[i];
 316                      }
 317                      args.push(arg);
 318                  }
 319                  warn(
 320                      msg +
 321                          '\nArguments: ' +
 322                          Array.prototype.slice.call(args).join('') +
 323                          '\n' +
 324                          new Error().stack
 325                  );
 326                  firstTime = false;
 327              }
 328              return fn.apply(this, arguments);
 329          }, fn);
 330      }
 331  
 332      var deprecations = {};
 333  
 334      function deprecateSimple(name, msg) {
 335          if (hooks.deprecationHandler != null) {
 336              hooks.deprecationHandler(name, msg);
 337          }
 338          if (!deprecations[name]) {
 339              warn(msg);
 340              deprecations[name] = true;
 341          }
 342      }
 343  
 344      hooks.suppressDeprecationWarnings = false;
 345      hooks.deprecationHandler = null;
 346  
 347      function isFunction(input) {
 348          return (
 349              (typeof Function !== 'undefined' && input instanceof Function) ||
 350              Object.prototype.toString.call(input) === '[object Function]'
 351          );
 352      }
 353  
 354      function set(config) {
 355          var prop, i;
 356          for (i in config) {
 357              if (hasOwnProp(config, i)) {
 358                  prop = config[i];
 359                  if (isFunction(prop)) {
 360                      this[i] = prop;
 361                  } else {
 362                      this['_' + i] = prop;
 363                  }
 364              }
 365          }
 366          this._config = config;
 367          // Lenient ordinal parsing accepts just a number in addition to
 368          // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
 369          // TODO: Remove "ordinalParse" fallback in next major release.
 370          this._dayOfMonthOrdinalParseLenient = new RegExp(
 371              (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
 372                  '|' +
 373                  /\d{1,2}/.source
 374          );
 375      }
 376  
 377      function mergeConfigs(parentConfig, childConfig) {
 378          var res = extend({}, parentConfig),
 379              prop;
 380          for (prop in childConfig) {
 381              if (hasOwnProp(childConfig, prop)) {
 382                  if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
 383                      res[prop] = {};
 384                      extend(res[prop], parentConfig[prop]);
 385                      extend(res[prop], childConfig[prop]);
 386                  } else if (childConfig[prop] != null) {
 387                      res[prop] = childConfig[prop];
 388                  } else {
 389                      delete res[prop];
 390                  }
 391              }
 392          }
 393          for (prop in parentConfig) {
 394              if (
 395                  hasOwnProp(parentConfig, prop) &&
 396                  !hasOwnProp(childConfig, prop) &&
 397                  isObject(parentConfig[prop])
 398              ) {
 399                  // make sure changes to properties don't modify parent config
 400                  res[prop] = extend({}, res[prop]);
 401              }
 402          }
 403          return res;
 404      }
 405  
 406      function Locale(config) {
 407          if (config != null) {
 408              this.set(config);
 409          }
 410      }
 411  
 412      var keys;
 413  
 414      if (Object.keys) {
 415          keys = Object.keys;
 416      } else {
 417          keys = function (obj) {
 418              var i,
 419                  res = [];
 420              for (i in obj) {
 421                  if (hasOwnProp(obj, i)) {
 422                      res.push(i);
 423                  }
 424              }
 425              return res;
 426          };
 427      }
 428  
 429      var defaultCalendar = {
 430          sameDay: '[Today at] LT',
 431          nextDay: '[Tomorrow at] LT',
 432          nextWeek: 'dddd [at] LT',
 433          lastDay: '[Yesterday at] LT',
 434          lastWeek: '[Last] dddd [at] LT',
 435          sameElse: 'L',
 436      };
 437  
 438      function calendar(key, mom, now) {
 439          var output = this._calendar[key] || this._calendar['sameElse'];
 440          return isFunction(output) ? output.call(mom, now) : output;
 441      }
 442  
 443      function zeroFill(number, targetLength, forceSign) {
 444          var absNumber = '' + Math.abs(number),
 445              zerosToFill = targetLength - absNumber.length,
 446              sign = number >= 0;
 447          return (
 448              (sign ? (forceSign ? '+' : '') : '-') +
 449              Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +
 450              absNumber
 451          );
 452      }
 453  
 454      var formattingTokens =
 455              /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
 456          localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
 457          formatFunctions = {},
 458          formatTokenFunctions = {};
 459  
 460      // token:    'M'
 461      // padded:   ['MM', 2]
 462      // ordinal:  'Mo'
 463      // callback: function () { this.month() + 1 }
 464      function addFormatToken(token, padded, ordinal, callback) {
 465          var func = callback;
 466          if (typeof callback === 'string') {
 467              func = function () {
 468                  return this[callback]();
 469              };
 470          }
 471          if (token) {
 472              formatTokenFunctions[token] = func;
 473          }
 474          if (padded) {
 475              formatTokenFunctions[padded[0]] = function () {
 476                  return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
 477              };
 478          }
 479          if (ordinal) {
 480              formatTokenFunctions[ordinal] = function () {
 481                  return this.localeData().ordinal(
 482                      func.apply(this, arguments),
 483                      token
 484                  );
 485              };
 486          }
 487      }
 488  
 489      function removeFormattingTokens(input) {
 490          if (input.match(/\[[\s\S]/)) {
 491              return input.replace(/^\[|\]$/g, '');
 492          }
 493          return input.replace(/\\/g, '');
 494      }
 495  
 496      function makeFormatFunction(format) {
 497          var array = format.match(formattingTokens),
 498              i,
 499              length;
 500  
 501          for (i = 0, length = array.length; i < length; i++) {
 502              if (formatTokenFunctions[array[i]]) {
 503                  array[i] = formatTokenFunctions[array[i]];
 504              } else {
 505                  array[i] = removeFormattingTokens(array[i]);
 506              }
 507          }
 508  
 509          return function (mom) {
 510              var output = '',
 511                  i;
 512              for (i = 0; i < length; i++) {
 513                  output += isFunction(array[i])
 514                      ? array[i].call(mom, format)
 515                      : array[i];
 516              }
 517              return output;
 518          };
 519      }
 520  
 521      // format date using native date object
 522      function formatMoment(m, format) {
 523          if (!m.isValid()) {
 524              return m.localeData().invalidDate();
 525          }
 526  
 527          format = expandFormat(format, m.localeData());
 528          formatFunctions[format] =
 529              formatFunctions[format] || makeFormatFunction(format);
 530  
 531          return formatFunctions[format](m);
 532      }
 533  
 534      function expandFormat(format, locale) {
 535          var i = 5;
 536  
 537          function replaceLongDateFormatTokens(input) {
 538              return locale.longDateFormat(input) || input;
 539          }
 540  
 541          localFormattingTokens.lastIndex = 0;
 542          while (i >= 0 && localFormattingTokens.test(format)) {
 543              format = format.replace(
 544                  localFormattingTokens,
 545                  replaceLongDateFormatTokens
 546              );
 547              localFormattingTokens.lastIndex = 0;
 548              i -= 1;
 549          }
 550  
 551          return format;
 552      }
 553  
 554      var defaultLongDateFormat = {
 555          LTS: 'h:mm:ss A',
 556          LT: 'h:mm A',
 557          L: 'MM/DD/YYYY',
 558          LL: 'MMMM D, YYYY',
 559          LLL: 'MMMM D, YYYY h:mm A',
 560          LLLL: 'dddd, MMMM D, YYYY h:mm A',
 561      };
 562  
 563      function longDateFormat(key) {
 564          var format = this._longDateFormat[key],
 565              formatUpper = this._longDateFormat[key.toUpperCase()];
 566  
 567          if (format || !formatUpper) {
 568              return format;
 569          }
 570  
 571          this._longDateFormat[key] = formatUpper
 572              .match(formattingTokens)
 573              .map(function (tok) {
 574                  if (
 575                      tok === 'MMMM' ||
 576                      tok === 'MM' ||
 577                      tok === 'DD' ||
 578                      tok === 'dddd'
 579                  ) {
 580                      return tok.slice(1);
 581                  }
 582                  return tok;
 583              })
 584              .join('');
 585  
 586          return this._longDateFormat[key];
 587      }
 588  
 589      var defaultInvalidDate = 'Invalid date';
 590  
 591      function invalidDate() {
 592          return this._invalidDate;
 593      }
 594  
 595      var defaultOrdinal = '%d',
 596          defaultDayOfMonthOrdinalParse = /\d{1,2}/;
 597  
 598      function ordinal(number) {
 599          return this._ordinal.replace('%d', number);
 600      }
 601  
 602      var defaultRelativeTime = {
 603          future: 'in %s',
 604          past: '%s ago',
 605          s: 'a few seconds',
 606          ss: '%d seconds',
 607          m: 'a minute',
 608          mm: '%d minutes',
 609          h: 'an hour',
 610          hh: '%d hours',
 611          d: 'a day',
 612          dd: '%d days',
 613          w: 'a week',
 614          ww: '%d weeks',
 615          M: 'a month',
 616          MM: '%d months',
 617          y: 'a year',
 618          yy: '%d years',
 619      };
 620  
 621      function relativeTime(number, withoutSuffix, string, isFuture) {
 622          var output = this._relativeTime[string];
 623          return isFunction(output)
 624              ? output(number, withoutSuffix, string, isFuture)
 625              : output.replace(/%d/i, number);
 626      }
 627  
 628      function pastFuture(diff, output) {
 629          var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
 630          return isFunction(format) ? format(output) : format.replace(/%s/i, output);
 631      }
 632  
 633      var aliases = {};
 634  
 635      function addUnitAlias(unit, shorthand) {
 636          var lowerCase = unit.toLowerCase();
 637          aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
 638      }
 639  
 640      function normalizeUnits(units) {
 641          return typeof units === 'string'
 642              ? aliases[units] || aliases[units.toLowerCase()]
 643              : undefined;
 644      }
 645  
 646      function normalizeObjectUnits(inputObject) {
 647          var normalizedInput = {},
 648              normalizedProp,
 649              prop;
 650  
 651          for (prop in inputObject) {
 652              if (hasOwnProp(inputObject, prop)) {
 653                  normalizedProp = normalizeUnits(prop);
 654                  if (normalizedProp) {
 655                      normalizedInput[normalizedProp] = inputObject[prop];
 656                  }
 657              }
 658          }
 659  
 660          return normalizedInput;
 661      }
 662  
 663      var priorities = {};
 664  
 665      function addUnitPriority(unit, priority) {
 666          priorities[unit] = priority;
 667      }
 668  
 669      function getPrioritizedUnits(unitsObj) {
 670          var units = [],
 671              u;
 672          for (u in unitsObj) {
 673              if (hasOwnProp(unitsObj, u)) {
 674                  units.push({ unit: u, priority: priorities[u] });
 675              }
 676          }
 677          units.sort(function (a, b) {
 678              return a.priority - b.priority;
 679          });
 680          return units;
 681      }
 682  
 683      function isLeapYear(year) {
 684          return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
 685      }
 686  
 687      function absFloor(number) {
 688          if (number < 0) {
 689              // -0 -> 0
 690              return Math.ceil(number) || 0;
 691          } else {
 692              return Math.floor(number);
 693          }
 694      }
 695  
 696      function toInt(argumentForCoercion) {
 697          var coercedNumber = +argumentForCoercion,
 698              value = 0;
 699  
 700          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
 701              value = absFloor(coercedNumber);
 702          }
 703  
 704          return value;
 705      }
 706  
 707      function makeGetSet(unit, keepTime) {
 708          return function (value) {
 709              if (value != null) {
 710                  set$1(this, unit, value);
 711                  hooks.updateOffset(this, keepTime);
 712                  return this;
 713              } else {
 714                  return get(this, unit);
 715              }
 716          };
 717      }
 718  
 719      function get(mom, unit) {
 720          return mom.isValid()
 721              ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()
 722              : NaN;
 723      }
 724  
 725      function set$1(mom, unit, value) {
 726          if (mom.isValid() && !isNaN(value)) {
 727              if (
 728                  unit === 'FullYear' &&
 729                  isLeapYear(mom.year()) &&
 730                  mom.month() === 1 &&
 731                  mom.date() === 29
 732              ) {
 733                  value = toInt(value);
 734                  mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](
 735                      value,
 736                      mom.month(),
 737                      daysInMonth(value, mom.month())
 738                  );
 739              } else {
 740                  mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
 741              }
 742          }
 743      }
 744  
 745      // MOMENTS
 746  
 747      function stringGet(units) {
 748          units = normalizeUnits(units);
 749          if (isFunction(this[units])) {
 750              return this[units]();
 751          }
 752          return this;
 753      }
 754  
 755      function stringSet(units, value) {
 756          if (typeof units === 'object') {
 757              units = normalizeObjectUnits(units);
 758              var prioritized = getPrioritizedUnits(units),
 759                  i,
 760                  prioritizedLen = prioritized.length;
 761              for (i = 0; i < prioritizedLen; i++) {
 762                  this[prioritized[i].unit](units[prioritized[i].unit]);
 763              }
 764          } else {
 765              units = normalizeUnits(units);
 766              if (isFunction(this[units])) {
 767                  return this[units](value);
 768              }
 769          }
 770          return this;
 771      }
 772  
 773      var match1 = /\d/, //       0 - 9
 774          match2 = /\d\d/, //      00 - 99
 775          match3 = /\d{3}/, //     000 - 999
 776          match4 = /\d{4}/, //    0000 - 9999
 777          match6 = /[+-]?\d{6}/, // -999999 - 999999
 778          match1to2 = /\d\d?/, //       0 - 99
 779          match3to4 = /\d\d\d\d?/, //     999 - 9999
 780          match5to6 = /\d\d\d\d\d\d?/, //   99999 - 999999
 781          match1to3 = /\d{1,3}/, //       0 - 999
 782          match1to4 = /\d{1,4}/, //       0 - 9999
 783          match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
 784          matchUnsigned = /\d+/, //       0 - inf
 785          matchSigned = /[+-]?\d+/, //    -inf - inf
 786          matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
 787          matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
 788          matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
 789          // any word (or two) characters or numbers including two/three word month in arabic.
 790          // includes scottish gaelic two word and hyphenated months
 791          matchWord =
 792              /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
 793          regexes;
 794  
 795      regexes = {};
 796  
 797      function addRegexToken(token, regex, strictRegex) {
 798          regexes[token] = isFunction(regex)
 799              ? regex
 800              : function (isStrict, localeData) {
 801                    return isStrict && strictRegex ? strictRegex : regex;
 802                };
 803      }
 804  
 805      function getParseRegexForToken(token, config) {
 806          if (!hasOwnProp(regexes, token)) {
 807              return new RegExp(unescapeFormat(token));
 808          }
 809  
 810          return regexes[token](config._strict, config._locale);
 811      }
 812  
 813      // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
 814      function unescapeFormat(s) {
 815          return regexEscape(
 816              s
 817                  .replace('\\', '')
 818                  .replace(
 819                      /\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
 820                      function (matched, p1, p2, p3, p4) {
 821                          return p1 || p2 || p3 || p4;
 822                      }
 823                  )
 824          );
 825      }
 826  
 827      function regexEscape(s) {
 828          return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
 829      }
 830  
 831      var tokens = {};
 832  
 833      function addParseToken(token, callback) {
 834          var i,
 835              func = callback,
 836              tokenLen;
 837          if (typeof token === 'string') {
 838              token = [token];
 839          }
 840          if (isNumber(callback)) {
 841              func = function (input, array) {
 842                  array[callback] = toInt(input);
 843              };
 844          }
 845          tokenLen = token.length;
 846          for (i = 0; i < tokenLen; i++) {
 847              tokens[token[i]] = func;
 848          }
 849      }
 850  
 851      function addWeekParseToken(token, callback) {
 852          addParseToken(token, function (input, array, config, token) {
 853              config._w = config._w || {};
 854              callback(input, config._w, config, token);
 855          });
 856      }
 857  
 858      function addTimeToArrayFromToken(token, input, config) {
 859          if (input != null && hasOwnProp(tokens, token)) {
 860              tokens[token](input, config._a, config, token);
 861          }
 862      }
 863  
 864      var YEAR = 0,
 865          MONTH = 1,
 866          DATE = 2,
 867          HOUR = 3,
 868          MINUTE = 4,
 869          SECOND = 5,
 870          MILLISECOND = 6,
 871          WEEK = 7,
 872          WEEKDAY = 8;
 873  
 874      function mod(n, x) {
 875          return ((n % x) + x) % x;
 876      }
 877  
 878      var indexOf;
 879  
 880      if (Array.prototype.indexOf) {
 881          indexOf = Array.prototype.indexOf;
 882      } else {
 883          indexOf = function (o) {
 884              // I know
 885              var i;
 886              for (i = 0; i < this.length; ++i) {
 887                  if (this[i] === o) {
 888                      return i;
 889                  }
 890              }
 891              return -1;
 892          };
 893      }
 894  
 895      function daysInMonth(year, month) {
 896          if (isNaN(year) || isNaN(month)) {
 897              return NaN;
 898          }
 899          var modMonth = mod(month, 12);
 900          year += (month - modMonth) / 12;
 901          return modMonth === 1
 902              ? isLeapYear(year)
 903                  ? 29
 904                  : 28
 905              : 31 - ((modMonth % 7) % 2);
 906      }
 907  
 908      // FORMATTING
 909  
 910      addFormatToken('M', ['MM', 2], 'Mo', function () {
 911          return this.month() + 1;
 912      });
 913  
 914      addFormatToken('MMM', 0, 0, function (format) {
 915          return this.localeData().monthsShort(this, format);
 916      });
 917  
 918      addFormatToken('MMMM', 0, 0, function (format) {
 919          return this.localeData().months(this, format);
 920      });
 921  
 922      // ALIASES
 923  
 924      addUnitAlias('month', 'M');
 925  
 926      // PRIORITY
 927  
 928      addUnitPriority('month', 8);
 929  
 930      // PARSING
 931  
 932      addRegexToken('M', match1to2);
 933      addRegexToken('MM', match1to2, match2);
 934      addRegexToken('MMM', function (isStrict, locale) {
 935          return locale.monthsShortRegex(isStrict);
 936      });
 937      addRegexToken('MMMM', function (isStrict, locale) {
 938          return locale.monthsRegex(isStrict);
 939      });
 940  
 941      addParseToken(['M', 'MM'], function (input, array) {
 942          array[MONTH] = toInt(input) - 1;
 943      });
 944  
 945      addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
 946          var month = config._locale.monthsParse(input, token, config._strict);
 947          // if we didn't find a month name, mark the date as invalid.
 948          if (month != null) {
 949              array[MONTH] = month;
 950          } else {
 951              getParsingFlags(config).invalidMonth = input;
 952          }
 953      });
 954  
 955      // LOCALES
 956  
 957      var defaultLocaleMonths =
 958              'January_February_March_April_May_June_July_August_September_October_November_December'.split(
 959                  '_'
 960              ),
 961          defaultLocaleMonthsShort =
 962              'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
 963          MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
 964          defaultMonthsShortRegex = matchWord,
 965          defaultMonthsRegex = matchWord;
 966  
 967      function localeMonths(m, format) {
 968          if (!m) {
 969              return isArray(this._months)
 970                  ? this._months
 971                  : this._months['standalone'];
 972          }
 973          return isArray(this._months)
 974              ? this._months[m.month()]
 975              : this._months[
 976                    (this._months.isFormat || MONTHS_IN_FORMAT).test(format)
 977                        ? 'format'
 978                        : 'standalone'
 979                ][m.month()];
 980      }
 981  
 982      function localeMonthsShort(m, format) {
 983          if (!m) {
 984              return isArray(this._monthsShort)
 985                  ? this._monthsShort
 986                  : this._monthsShort['standalone'];
 987          }
 988          return isArray(this._monthsShort)
 989              ? this._monthsShort[m.month()]
 990              : this._monthsShort[
 991                    MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'
 992                ][m.month()];
 993      }
 994  
 995      function handleStrictParse(monthName, format, strict) {
 996          var i,
 997              ii,
 998              mom,
 999              llc = monthName.toLocaleLowerCase();
1000          if (!this._monthsParse) {
1001              // this is not used
1002              this._monthsParse = [];
1003              this._longMonthsParse = [];
1004              this._shortMonthsParse = [];
1005              for (i = 0; i < 12; ++i) {
1006                  mom = createUTC([2000, i]);
1007                  this._shortMonthsParse[i] = this.monthsShort(
1008                      mom,
1009                      ''
1010                  ).toLocaleLowerCase();
1011                  this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
1012              }
1013          }
1014  
1015          if (strict) {
1016              if (format === 'MMM') {
1017                  ii = indexOf.call(this._shortMonthsParse, llc);
1018                  return ii !== -1 ? ii : null;
1019              } else {
1020                  ii = indexOf.call(this._longMonthsParse, llc);
1021                  return ii !== -1 ? ii : null;
1022              }
1023          } else {
1024              if (format === 'MMM') {
1025                  ii = indexOf.call(this._shortMonthsParse, llc);
1026                  if (ii !== -1) {
1027                      return ii;
1028                  }
1029                  ii = indexOf.call(this._longMonthsParse, llc);
1030                  return ii !== -1 ? ii : null;
1031              } else {
1032                  ii = indexOf.call(this._longMonthsParse, llc);
1033                  if (ii !== -1) {
1034                      return ii;
1035                  }
1036                  ii = indexOf.call(this._shortMonthsParse, llc);
1037                  return ii !== -1 ? ii : null;
1038              }
1039          }
1040      }
1041  
1042      function localeMonthsParse(monthName, format, strict) {
1043          var i, mom, regex;
1044  
1045          if (this._monthsParseExact) {
1046              return handleStrictParse.call(this, monthName, format, strict);
1047          }
1048  
1049          if (!this._monthsParse) {
1050              this._monthsParse = [];
1051              this._longMonthsParse = [];
1052              this._shortMonthsParse = [];
1053          }
1054  
1055          // TODO: add sorting
1056          // Sorting makes sure if one month (or abbr) is a prefix of another
1057          // see sorting in computeMonthsParse
1058          for (i = 0; i < 12; i++) {
1059              // make the regex if we don't have it already
1060              mom = createUTC([2000, i]);
1061              if (strict && !this._longMonthsParse[i]) {
1062                  this._longMonthsParse[i] = new RegExp(
1063                      '^' + this.months(mom, '').replace('.', '') + '$',
1064                      'i'
1065                  );
1066                  this._shortMonthsParse[i] = new RegExp(
1067                      '^' + this.monthsShort(mom, '').replace('.', '') + '$',
1068                      'i'
1069                  );
1070              }
1071              if (!strict && !this._monthsParse[i]) {
1072                  regex =
1073                      '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
1074                  this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
1075              }
1076              // test the regex
1077              if (
1078                  strict &&
1079                  format === 'MMMM' &&
1080                  this._longMonthsParse[i].test(monthName)
1081              ) {
1082                  return i;
1083              } else if (
1084                  strict &&
1085                  format === 'MMM' &&
1086                  this._shortMonthsParse[i].test(monthName)
1087              ) {
1088                  return i;
1089              } else if (!strict && this._monthsParse[i].test(monthName)) {
1090                  return i;
1091              }
1092          }
1093      }
1094  
1095      // MOMENTS
1096  
1097      function setMonth(mom, value) {
1098          var dayOfMonth;
1099  
1100          if (!mom.isValid()) {
1101              // No op
1102              return mom;
1103          }
1104  
1105          if (typeof value === 'string') {
1106              if (/^\d+$/.test(value)) {
1107                  value = toInt(value);
1108              } else {
1109                  value = mom.localeData().monthsParse(value);
1110                  // TODO: Another silent failure?
1111                  if (!isNumber(value)) {
1112                      return mom;
1113                  }
1114              }
1115          }
1116  
1117          dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
1118          mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
1119          return mom;
1120      }
1121  
1122      function getSetMonth(value) {
1123          if (value != null) {
1124              setMonth(this, value);
1125              hooks.updateOffset(this, true);
1126              return this;
1127          } else {
1128              return get(this, 'Month');
1129          }
1130      }
1131  
1132      function getDaysInMonth() {
1133          return daysInMonth(this.year(), this.month());
1134      }
1135  
1136      function monthsShortRegex(isStrict) {
1137          if (this._monthsParseExact) {
1138              if (!hasOwnProp(this, '_monthsRegex')) {
1139                  computeMonthsParse.call(this);
1140              }
1141              if (isStrict) {
1142                  return this._monthsShortStrictRegex;
1143              } else {
1144                  return this._monthsShortRegex;
1145              }
1146          } else {
1147              if (!hasOwnProp(this, '_monthsShortRegex')) {
1148                  this._monthsShortRegex = defaultMonthsShortRegex;
1149              }
1150              return this._monthsShortStrictRegex && isStrict
1151                  ? this._monthsShortStrictRegex
1152                  : this._monthsShortRegex;
1153          }
1154      }
1155  
1156      function monthsRegex(isStrict) {
1157          if (this._monthsParseExact) {
1158              if (!hasOwnProp(this, '_monthsRegex')) {
1159                  computeMonthsParse.call(this);
1160              }
1161              if (isStrict) {
1162                  return this._monthsStrictRegex;
1163              } else {
1164                  return this._monthsRegex;
1165              }
1166          } else {
1167              if (!hasOwnProp(this, '_monthsRegex')) {
1168                  this._monthsRegex = defaultMonthsRegex;
1169              }
1170              return this._monthsStrictRegex && isStrict
1171                  ? this._monthsStrictRegex
1172                  : this._monthsRegex;
1173          }
1174      }
1175  
1176      function computeMonthsParse() {
1177          function cmpLenRev(a, b) {
1178              return b.length - a.length;
1179          }
1180  
1181          var shortPieces = [],
1182              longPieces = [],
1183              mixedPieces = [],
1184              i,
1185              mom;
1186          for (i = 0; i < 12; i++) {
1187              // make the regex if we don't have it already
1188              mom = createUTC([2000, i]);
1189              shortPieces.push(this.monthsShort(mom, ''));
1190              longPieces.push(this.months(mom, ''));
1191              mixedPieces.push(this.months(mom, ''));
1192              mixedPieces.push(this.monthsShort(mom, ''));
1193          }
1194          // Sorting makes sure if one month (or abbr) is a prefix of another it
1195          // will match the longer piece.
1196          shortPieces.sort(cmpLenRev);
1197          longPieces.sort(cmpLenRev);
1198          mixedPieces.sort(cmpLenRev);
1199          for (i = 0; i < 12; i++) {
1200              shortPieces[i] = regexEscape(shortPieces[i]);
1201              longPieces[i] = regexEscape(longPieces[i]);
1202          }
1203          for (i = 0; i < 24; i++) {
1204              mixedPieces[i] = regexEscape(mixedPieces[i]);
1205          }
1206  
1207          this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1208          this._monthsShortRegex = this._monthsRegex;
1209          this._monthsStrictRegex = new RegExp(
1210              '^(' + longPieces.join('|') + ')',
1211              'i'
1212          );
1213          this._monthsShortStrictRegex = new RegExp(
1214              '^(' + shortPieces.join('|') + ')',
1215              'i'
1216          );
1217      }
1218  
1219      // FORMATTING
1220  
1221      addFormatToken('Y', 0, 0, function () {
1222          var y = this.year();
1223          return y <= 9999 ? zeroFill(y, 4) : '+' + y;
1224      });
1225  
1226      addFormatToken(0, ['YY', 2], 0, function () {
1227          return this.year() % 100;
1228      });
1229  
1230      addFormatToken(0, ['YYYY', 4], 0, 'year');
1231      addFormatToken(0, ['YYYYY', 5], 0, 'year');
1232      addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
1233  
1234      // ALIASES
1235  
1236      addUnitAlias('year', 'y');
1237  
1238      // PRIORITIES
1239  
1240      addUnitPriority('year', 1);
1241  
1242      // PARSING
1243  
1244      addRegexToken('Y', matchSigned);
1245      addRegexToken('YY', match1to2, match2);
1246      addRegexToken('YYYY', match1to4, match4);
1247      addRegexToken('YYYYY', match1to6, match6);
1248      addRegexToken('YYYYYY', match1to6, match6);
1249  
1250      addParseToken(['YYYYY', 'YYYYYY'], YEAR);
1251      addParseToken('YYYY', function (input, array) {
1252          array[YEAR] =
1253              input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
1254      });
1255      addParseToken('YY', function (input, array) {
1256          array[YEAR] = hooks.parseTwoDigitYear(input);
1257      });
1258      addParseToken('Y', function (input, array) {
1259          array[YEAR] = parseInt(input, 10);
1260      });
1261  
1262      // HELPERS
1263  
1264      function daysInYear(year) {
1265          return isLeapYear(year) ? 366 : 365;
1266      }
1267  
1268      // HOOKS
1269  
1270      hooks.parseTwoDigitYear = function (input) {
1271          return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
1272      };
1273  
1274      // MOMENTS
1275  
1276      var getSetYear = makeGetSet('FullYear', true);
1277  
1278      function getIsLeapYear() {
1279          return isLeapYear(this.year());
1280      }
1281  
1282      function createDate(y, m, d, h, M, s, ms) {
1283          // can't just apply() to create a date:
1284          // https://stackoverflow.com/q/181348
1285          var date;
1286          // the date constructor remaps years 0-99 to 1900-1999
1287          if (y < 100 && y >= 0) {
1288              // preserve leap years using a full 400 year cycle, then reset
1289              date = new Date(y + 400, m, d, h, M, s, ms);
1290              if (isFinite(date.getFullYear())) {
1291                  date.setFullYear(y);
1292              }
1293          } else {
1294              date = new Date(y, m, d, h, M, s, ms);
1295          }
1296  
1297          return date;
1298      }
1299  
1300      function createUTCDate(y) {
1301          var date, args;
1302          // the Date.UTC function remaps years 0-99 to 1900-1999
1303          if (y < 100 && y >= 0) {
1304              args = Array.prototype.slice.call(arguments);
1305              // preserve leap years using a full 400 year cycle, then reset
1306              args[0] = y + 400;
1307              date = new Date(Date.UTC.apply(null, args));
1308              if (isFinite(date.getUTCFullYear())) {
1309                  date.setUTCFullYear(y);
1310              }
1311          } else {
1312              date = new Date(Date.UTC.apply(null, arguments));
1313          }
1314  
1315          return date;
1316      }
1317  
1318      // start-of-first-week - start-of-year
1319      function firstWeekOffset(year, dow, doy) {
1320          var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1321              fwd = 7 + dow - doy,
1322              // first-week day local weekday -- which local weekday is fwd
1323              fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1324  
1325          return -fwdlw + fwd - 1;
1326      }
1327  
1328      // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1329      function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1330          var localWeekday = (7 + weekday - dow) % 7,
1331              weekOffset = firstWeekOffset(year, dow, doy),
1332              dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1333              resYear,
1334              resDayOfYear;
1335  
1336          if (dayOfYear <= 0) {
1337              resYear = year - 1;
1338              resDayOfYear = daysInYear(resYear) + dayOfYear;
1339          } else if (dayOfYear > daysInYear(year)) {
1340              resYear = year + 1;
1341              resDayOfYear = dayOfYear - daysInYear(year);
1342          } else {
1343              resYear = year;
1344              resDayOfYear = dayOfYear;
1345          }
1346  
1347          return {
1348              year: resYear,
1349              dayOfYear: resDayOfYear,
1350          };
1351      }
1352  
1353      function weekOfYear(mom, dow, doy) {
1354          var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1355              week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1356              resWeek,
1357              resYear;
1358  
1359          if (week < 1) {
1360              resYear = mom.year() - 1;
1361              resWeek = week + weeksInYear(resYear, dow, doy);
1362          } else if (week > weeksInYear(mom.year(), dow, doy)) {
1363              resWeek = week - weeksInYear(mom.year(), dow, doy);
1364              resYear = mom.year() + 1;
1365          } else {
1366              resYear = mom.year();
1367              resWeek = week;
1368          }
1369  
1370          return {
1371              week: resWeek,
1372              year: resYear,
1373          };
1374      }
1375  
1376      function weeksInYear(year, dow, doy) {
1377          var weekOffset = firstWeekOffset(year, dow, doy),
1378              weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1379          return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1380      }
1381  
1382      // FORMATTING
1383  
1384      addFormatToken('w', ['ww', 2], 'wo', 'week');
1385      addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1386  
1387      // ALIASES
1388  
1389      addUnitAlias('week', 'w');
1390      addUnitAlias('isoWeek', 'W');
1391  
1392      // PRIORITIES
1393  
1394      addUnitPriority('week', 5);
1395      addUnitPriority('isoWeek', 5);
1396  
1397      // PARSING
1398  
1399      addRegexToken('w', match1to2);
1400      addRegexToken('ww', match1to2, match2);
1401      addRegexToken('W', match1to2);
1402      addRegexToken('WW', match1to2, match2);
1403  
1404      addWeekParseToken(
1405          ['w', 'ww', 'W', 'WW'],
1406          function (input, week, config, token) {
1407              week[token.substr(0, 1)] = toInt(input);
1408          }
1409      );
1410  
1411      // HELPERS
1412  
1413      // LOCALES
1414  
1415      function localeWeek(mom) {
1416          return weekOfYear(mom, this._week.dow, this._week.doy).week;
1417      }
1418  
1419      var defaultLocaleWeek = {
1420          dow: 0, // Sunday is the first day of the week.
1421          doy: 6, // The week that contains Jan 6th is the first week of the year.
1422      };
1423  
1424      function localeFirstDayOfWeek() {
1425          return this._week.dow;
1426      }
1427  
1428      function localeFirstDayOfYear() {
1429          return this._week.doy;
1430      }
1431  
1432      // MOMENTS
1433  
1434      function getSetWeek(input) {
1435          var week = this.localeData().week(this);
1436          return input == null ? week : this.add((input - week) * 7, 'd');
1437      }
1438  
1439      function getSetISOWeek(input) {
1440          var week = weekOfYear(this, 1, 4).week;
1441          return input == null ? week : this.add((input - week) * 7, 'd');
1442      }
1443  
1444      // FORMATTING
1445  
1446      addFormatToken('d', 0, 'do', 'day');
1447  
1448      addFormatToken('dd', 0, 0, function (format) {
1449          return this.localeData().weekdaysMin(this, format);
1450      });
1451  
1452      addFormatToken('ddd', 0, 0, function (format) {
1453          return this.localeData().weekdaysShort(this, format);
1454      });
1455  
1456      addFormatToken('dddd', 0, 0, function (format) {
1457          return this.localeData().weekdays(this, format);
1458      });
1459  
1460      addFormatToken('e', 0, 0, 'weekday');
1461      addFormatToken('E', 0, 0, 'isoWeekday');
1462  
1463      // ALIASES
1464  
1465      addUnitAlias('day', 'd');
1466      addUnitAlias('weekday', 'e');
1467      addUnitAlias('isoWeekday', 'E');
1468  
1469      // PRIORITY
1470      addUnitPriority('day', 11);
1471      addUnitPriority('weekday', 11);
1472      addUnitPriority('isoWeekday', 11);
1473  
1474      // PARSING
1475  
1476      addRegexToken('d', match1to2);
1477      addRegexToken('e', match1to2);
1478      addRegexToken('E', match1to2);
1479      addRegexToken('dd', function (isStrict, locale) {
1480          return locale.weekdaysMinRegex(isStrict);
1481      });
1482      addRegexToken('ddd', function (isStrict, locale) {
1483          return locale.weekdaysShortRegex(isStrict);
1484      });
1485      addRegexToken('dddd', function (isStrict, locale) {
1486          return locale.weekdaysRegex(isStrict);
1487      });
1488  
1489      addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1490          var weekday = config._locale.weekdaysParse(input, token, config._strict);
1491          // if we didn't get a weekday name, mark the date as invalid
1492          if (weekday != null) {
1493              week.d = weekday;
1494          } else {
1495              getParsingFlags(config).invalidWeekday = input;
1496          }
1497      });
1498  
1499      addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1500          week[token] = toInt(input);
1501      });
1502  
1503      // HELPERS
1504  
1505      function parseWeekday(input, locale) {
1506          if (typeof input !== 'string') {
1507              return input;
1508          }
1509  
1510          if (!isNaN(input)) {
1511              return parseInt(input, 10);
1512          }
1513  
1514          input = locale.weekdaysParse(input);
1515          if (typeof input === 'number') {
1516              return input;
1517          }
1518  
1519          return null;
1520      }
1521  
1522      function parseIsoWeekday(input, locale) {
1523          if (typeof input === 'string') {
1524              return locale.weekdaysParse(input) % 7 || 7;
1525          }
1526          return isNaN(input) ? null : input;
1527      }
1528  
1529      // LOCALES
1530      function shiftWeekdays(ws, n) {
1531          return ws.slice(n, 7).concat(ws.slice(0, n));
1532      }
1533  
1534      var defaultLocaleWeekdays =
1535              'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
1536          defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
1537          defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
1538          defaultWeekdaysRegex = matchWord,
1539          defaultWeekdaysShortRegex = matchWord,
1540          defaultWeekdaysMinRegex = matchWord;
1541  
1542      function localeWeekdays(m, format) {
1543          var weekdays = isArray(this._weekdays)
1544              ? this._weekdays
1545              : this._weekdays[
1546                    m && m !== true && this._weekdays.isFormat.test(format)
1547                        ? 'format'
1548                        : 'standalone'
1549                ];
1550          return m === true
1551              ? shiftWeekdays(weekdays, this._week.dow)
1552              : m
1553              ? weekdays[m.day()]
1554              : weekdays;
1555      }
1556  
1557      function localeWeekdaysShort(m) {
1558          return m === true
1559              ? shiftWeekdays(this._weekdaysShort, this._week.dow)
1560              : m
1561              ? this._weekdaysShort[m.day()]
1562              : this._weekdaysShort;
1563      }
1564  
1565      function localeWeekdaysMin(m) {
1566          return m === true
1567              ? shiftWeekdays(this._weekdaysMin, this._week.dow)
1568              : m
1569              ? this._weekdaysMin[m.day()]
1570              : this._weekdaysMin;
1571      }
1572  
1573      function handleStrictParse$1(weekdayName, format, strict) {
1574          var i,
1575              ii,
1576              mom,
1577              llc = weekdayName.toLocaleLowerCase();
1578          if (!this._weekdaysParse) {
1579              this._weekdaysParse = [];
1580              this._shortWeekdaysParse = [];
1581              this._minWeekdaysParse = [];
1582  
1583              for (i = 0; i < 7; ++i) {
1584                  mom = createUTC([2000, 1]).day(i);
1585                  this._minWeekdaysParse[i] = this.weekdaysMin(
1586                      mom,
1587                      ''
1588                  ).toLocaleLowerCase();
1589                  this._shortWeekdaysParse[i] = this.weekdaysShort(
1590                      mom,
1591                      ''
1592                  ).toLocaleLowerCase();
1593                  this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1594              }
1595          }
1596  
1597          if (strict) {
1598              if (format === 'dddd') {
1599                  ii = indexOf.call(this._weekdaysParse, llc);
1600                  return ii !== -1 ? ii : null;
1601              } else if (format === 'ddd') {
1602                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1603                  return ii !== -1 ? ii : null;
1604              } else {
1605                  ii = indexOf.call(this._minWeekdaysParse, llc);
1606                  return ii !== -1 ? ii : null;
1607              }
1608          } else {
1609              if (format === 'dddd') {
1610                  ii = indexOf.call(this._weekdaysParse, llc);
1611                  if (ii !== -1) {
1612                      return ii;
1613                  }
1614                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1615                  if (ii !== -1) {
1616                      return ii;
1617                  }
1618                  ii = indexOf.call(this._minWeekdaysParse, llc);
1619                  return ii !== -1 ? ii : null;
1620              } else if (format === 'ddd') {
1621                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1622                  if (ii !== -1) {
1623                      return ii;
1624                  }
1625                  ii = indexOf.call(this._weekdaysParse, llc);
1626                  if (ii !== -1) {
1627                      return ii;
1628                  }
1629                  ii = indexOf.call(this._minWeekdaysParse, llc);
1630                  return ii !== -1 ? ii : null;
1631              } else {
1632                  ii = indexOf.call(this._minWeekdaysParse, llc);
1633                  if (ii !== -1) {
1634                      return ii;
1635                  }
1636                  ii = indexOf.call(this._weekdaysParse, llc);
1637                  if (ii !== -1) {
1638                      return ii;
1639                  }
1640                  ii = indexOf.call(this._shortWeekdaysParse, llc);
1641                  return ii !== -1 ? ii : null;
1642              }
1643          }
1644      }
1645  
1646      function localeWeekdaysParse(weekdayName, format, strict) {
1647          var i, mom, regex;
1648  
1649          if (this._weekdaysParseExact) {
1650              return handleStrictParse$1.call(this, weekdayName, format, strict);
1651          }
1652  
1653          if (!this._weekdaysParse) {
1654              this._weekdaysParse = [];
1655              this._minWeekdaysParse = [];
1656              this._shortWeekdaysParse = [];
1657              this._fullWeekdaysParse = [];
1658          }
1659  
1660          for (i = 0; i < 7; i++) {
1661              // make the regex if we don't have it already
1662  
1663              mom = createUTC([2000, 1]).day(i);
1664              if (strict && !this._fullWeekdaysParse[i]) {
1665                  this._fullWeekdaysParse[i] = new RegExp(
1666                      '^' + this.weekdays(mom, '').replace('.', '\\.?') + '$',
1667                      'i'
1668                  );
1669                  this._shortWeekdaysParse[i] = new RegExp(
1670                      '^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$',
1671                      'i'
1672                  );
1673                  this._minWeekdaysParse[i] = new RegExp(
1674                      '^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$',
1675                      'i'
1676                  );
1677              }
1678              if (!this._weekdaysParse[i]) {
1679                  regex =
1680                      '^' +
1681                      this.weekdays(mom, '') +
1682                      '|^' +
1683                      this.weekdaysShort(mom, '') +
1684                      '|^' +
1685                      this.weekdaysMin(mom, '');
1686                  this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
1687              }
1688              // test the regex
1689              if (
1690                  strict &&
1691                  format === 'dddd' &&
1692                  this._fullWeekdaysParse[i].test(weekdayName)
1693              ) {
1694                  return i;
1695              } else if (
1696                  strict &&
1697                  format === 'ddd' &&
1698                  this._shortWeekdaysParse[i].test(weekdayName)
1699              ) {
1700                  return i;
1701              } else if (
1702                  strict &&
1703                  format === 'dd' &&
1704                  this._minWeekdaysParse[i].test(weekdayName)
1705              ) {
1706                  return i;
1707              } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
1708                  return i;
1709              }
1710          }
1711      }
1712  
1713      // MOMENTS
1714  
1715      function getSetDayOfWeek(input) {
1716          if (!this.isValid()) {
1717              return input != null ? this : NaN;
1718          }
1719          var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1720          if (input != null) {
1721              input = parseWeekday(input, this.localeData());
1722              return this.add(input - day, 'd');
1723          } else {
1724              return day;
1725          }
1726      }
1727  
1728      function getSetLocaleDayOfWeek(input) {
1729          if (!this.isValid()) {
1730              return input != null ? this : NaN;
1731          }
1732          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1733          return input == null ? weekday : this.add(input - weekday, 'd');
1734      }
1735  
1736      function getSetISODayOfWeek(input) {
1737          if (!this.isValid()) {
1738              return input != null ? this : NaN;
1739          }
1740  
1741          // behaves the same as moment#day except
1742          // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1743          // as a setter, sunday should belong to the previous week.
1744  
1745          if (input != null) {
1746              var weekday = parseIsoWeekday(input, this.localeData());
1747              return this.day(this.day() % 7 ? weekday : weekday - 7);
1748          } else {
1749              return this.day() || 7;
1750          }
1751      }
1752  
1753      function weekdaysRegex(isStrict) {
1754          if (this._weekdaysParseExact) {
1755              if (!hasOwnProp(this, '_weekdaysRegex')) {
1756                  computeWeekdaysParse.call(this);
1757              }
1758              if (isStrict) {
1759                  return this._weekdaysStrictRegex;
1760              } else {
1761                  return this._weekdaysRegex;
1762              }
1763          } else {
1764              if (!hasOwnProp(this, '_weekdaysRegex')) {
1765                  this._weekdaysRegex = defaultWeekdaysRegex;
1766              }
1767              return this._weekdaysStrictRegex && isStrict
1768                  ? this._weekdaysStrictRegex
1769                  : this._weekdaysRegex;
1770          }
1771      }
1772  
1773      function weekdaysShortRegex(isStrict) {
1774          if (this._weekdaysParseExact) {
1775              if (!hasOwnProp(this, '_weekdaysRegex')) {
1776                  computeWeekdaysParse.call(this);
1777              }
1778              if (isStrict) {
1779                  return this._weekdaysShortStrictRegex;
1780              } else {
1781                  return this._weekdaysShortRegex;
1782              }
1783          } else {
1784              if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1785                  this._weekdaysShortRegex = defaultWeekdaysShortRegex;
1786              }
1787              return this._weekdaysShortStrictRegex && isStrict
1788                  ? this._weekdaysShortStrictRegex
1789                  : this._weekdaysShortRegex;
1790          }
1791      }
1792  
1793      function weekdaysMinRegex(isStrict) {
1794          if (this._weekdaysParseExact) {
1795              if (!hasOwnProp(this, '_weekdaysRegex')) {
1796                  computeWeekdaysParse.call(this);
1797              }
1798              if (isStrict) {
1799                  return this._weekdaysMinStrictRegex;
1800              } else {
1801                  return this._weekdaysMinRegex;
1802              }
1803          } else {
1804              if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1805                  this._weekdaysMinRegex = defaultWeekdaysMinRegex;
1806              }
1807              return this._weekdaysMinStrictRegex && isStrict
1808                  ? this._weekdaysMinStrictRegex
1809                  : this._weekdaysMinRegex;
1810          }
1811      }
1812  
1813      function computeWeekdaysParse() {
1814          function cmpLenRev(a, b) {
1815              return b.length - a.length;
1816          }
1817  
1818          var minPieces = [],
1819              shortPieces = [],
1820              longPieces = [],
1821              mixedPieces = [],
1822              i,
1823              mom,
1824              minp,
1825              shortp,
1826              longp;
1827          for (i = 0; i < 7; i++) {
1828              // make the regex if we don't have it already
1829              mom = createUTC([2000, 1]).day(i);
1830              minp = regexEscape(this.weekdaysMin(mom, ''));
1831              shortp = regexEscape(this.weekdaysShort(mom, ''));
1832              longp = regexEscape(this.weekdays(mom, ''));
1833              minPieces.push(minp);
1834              shortPieces.push(shortp);
1835              longPieces.push(longp);
1836              mixedPieces.push(minp);
1837              mixedPieces.push(shortp);
1838              mixedPieces.push(longp);
1839          }
1840          // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1841          // will match the longer piece.
1842          minPieces.sort(cmpLenRev);
1843          shortPieces.sort(cmpLenRev);
1844          longPieces.sort(cmpLenRev);
1845          mixedPieces.sort(cmpLenRev);
1846  
1847          this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1848          this._weekdaysShortRegex = this._weekdaysRegex;
1849          this._weekdaysMinRegex = this._weekdaysRegex;
1850  
1851          this._weekdaysStrictRegex = new RegExp(
1852              '^(' + longPieces.join('|') + ')',
1853              'i'
1854          );
1855          this._weekdaysShortStrictRegex = new RegExp(
1856              '^(' + shortPieces.join('|') + ')',
1857              'i'
1858          );
1859          this._weekdaysMinStrictRegex = new RegExp(
1860              '^(' + minPieces.join('|') + ')',
1861              'i'
1862          );
1863      }
1864  
1865      // FORMATTING
1866  
1867      function hFormat() {
1868          return this.hours() % 12 || 12;
1869      }
1870  
1871      function kFormat() {
1872          return this.hours() || 24;
1873      }
1874  
1875      addFormatToken('H', ['HH', 2], 0, 'hour');
1876      addFormatToken('h', ['hh', 2], 0, hFormat);
1877      addFormatToken('k', ['kk', 2], 0, kFormat);
1878  
1879      addFormatToken('hmm', 0, 0, function () {
1880          return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
1881      });
1882  
1883      addFormatToken('hmmss', 0, 0, function () {
1884          return (
1885              '' +
1886              hFormat.apply(this) +
1887              zeroFill(this.minutes(), 2) +
1888              zeroFill(this.seconds(), 2)
1889          );
1890      });
1891  
1892      addFormatToken('Hmm', 0, 0, function () {
1893          return '' + this.hours() + zeroFill(this.minutes(), 2);
1894      });
1895  
1896      addFormatToken('Hmmss', 0, 0, function () {
1897          return (
1898              '' +
1899              this.hours() +
1900              zeroFill(this.minutes(), 2) +
1901              zeroFill(this.seconds(), 2)
1902          );
1903      });
1904  
1905      function meridiem(token, lowercase) {
1906          addFormatToken(token, 0, 0, function () {
1907              return this.localeData().meridiem(
1908                  this.hours(),
1909                  this.minutes(),
1910                  lowercase
1911              );
1912          });
1913      }
1914  
1915      meridiem('a', true);
1916      meridiem('A', false);
1917  
1918      // ALIASES
1919  
1920      addUnitAlias('hour', 'h');
1921  
1922      // PRIORITY
1923      addUnitPriority('hour', 13);
1924  
1925      // PARSING
1926  
1927      function matchMeridiem(isStrict, locale) {
1928          return locale._meridiemParse;
1929      }
1930  
1931      addRegexToken('a', matchMeridiem);
1932      addRegexToken('A', matchMeridiem);
1933      addRegexToken('H', match1to2);
1934      addRegexToken('h', match1to2);
1935      addRegexToken('k', match1to2);
1936      addRegexToken('HH', match1to2, match2);
1937      addRegexToken('hh', match1to2, match2);
1938      addRegexToken('kk', match1to2, match2);
1939  
1940      addRegexToken('hmm', match3to4);
1941      addRegexToken('hmmss', match5to6);
1942      addRegexToken('Hmm', match3to4);
1943      addRegexToken('Hmmss', match5to6);
1944  
1945      addParseToken(['H', 'HH'], HOUR);
1946      addParseToken(['k', 'kk'], function (input, array, config) {
1947          var kInput = toInt(input);
1948          array[HOUR] = kInput === 24 ? 0 : kInput;
1949      });
1950      addParseToken(['a', 'A'], function (input, array, config) {
1951          config._isPm = config._locale.isPM(input);
1952          config._meridiem = input;
1953      });
1954      addParseToken(['h', 'hh'], function (input, array, config) {
1955          array[HOUR] = toInt(input);
1956          getParsingFlags(config).bigHour = true;
1957      });
1958      addParseToken('hmm', function (input, array, config) {
1959          var pos = input.length - 2;
1960          array[HOUR] = toInt(input.substr(0, pos));
1961          array[MINUTE] = toInt(input.substr(pos));
1962          getParsingFlags(config).bigHour = true;
1963      });
1964      addParseToken('hmmss', function (input, array, config) {
1965          var pos1 = input.length - 4,
1966              pos2 = input.length - 2;
1967          array[HOUR] = toInt(input.substr(0, pos1));
1968          array[MINUTE] = toInt(input.substr(pos1, 2));
1969          array[SECOND] = toInt(input.substr(pos2));
1970          getParsingFlags(config).bigHour = true;
1971      });
1972      addParseToken('Hmm', function (input, array, config) {
1973          var pos = input.length - 2;
1974          array[HOUR] = toInt(input.substr(0, pos));
1975          array[MINUTE] = toInt(input.substr(pos));
1976      });
1977      addParseToken('Hmmss', function (input, array, config) {
1978          var pos1 = input.length - 4,
1979              pos2 = input.length - 2;
1980          array[HOUR] = toInt(input.substr(0, pos1));
1981          array[MINUTE] = toInt(input.substr(pos1, 2));
1982          array[SECOND] = toInt(input.substr(pos2));
1983      });
1984  
1985      // LOCALES
1986  
1987      function localeIsPM(input) {
1988          // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1989          // Using charAt should be more compatible.
1990          return (input + '').toLowerCase().charAt(0) === 'p';
1991      }
1992  
1993      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i,
1994          // Setting the hour should keep the time, because the user explicitly
1995          // specified which hour they want. So trying to maintain the same hour (in
1996          // a new timezone) makes sense. Adding/subtracting hours does not follow
1997          // this rule.
1998          getSetHour = makeGetSet('Hours', true);
1999  
2000      function localeMeridiem(hours, minutes, isLower) {
2001          if (hours > 11) {
2002              return isLower ? 'pm' : 'PM';
2003          } else {
2004              return isLower ? 'am' : 'AM';
2005          }
2006      }
2007  
2008      var baseConfig = {
2009          calendar: defaultCalendar,
2010          longDateFormat: defaultLongDateFormat,
2011          invalidDate: defaultInvalidDate,
2012          ordinal: defaultOrdinal,
2013          dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
2014          relativeTime: defaultRelativeTime,
2015  
2016          months: defaultLocaleMonths,
2017          monthsShort: defaultLocaleMonthsShort,
2018  
2019          week: defaultLocaleWeek,
2020  
2021          weekdays: defaultLocaleWeekdays,
2022          weekdaysMin: defaultLocaleWeekdaysMin,
2023          weekdaysShort: defaultLocaleWeekdaysShort,
2024  
2025          meridiemParse: defaultLocaleMeridiemParse,
2026      };
2027  
2028      // internal storage for locale config files
2029      var locales = {},
2030          localeFamilies = {},
2031          globalLocale;
2032  
2033      function commonPrefix(arr1, arr2) {
2034          var i,
2035              minl = Math.min(arr1.length, arr2.length);
2036          for (i = 0; i < minl; i += 1) {
2037              if (arr1[i] !== arr2[i]) {
2038                  return i;
2039              }
2040          }
2041          return minl;
2042      }
2043  
2044      function normalizeLocale(key) {
2045          return key ? key.toLowerCase().replace('_', '-') : key;
2046      }
2047  
2048      // pick the locale from the array
2049      // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
2050      // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
2051      function chooseLocale(names) {
2052          var i = 0,
2053              j,
2054              next,
2055              locale,
2056              split;
2057  
2058          while (i < names.length) {
2059              split = normalizeLocale(names[i]).split('-');
2060              j = split.length;
2061              next = normalizeLocale(names[i + 1]);
2062              next = next ? next.split('-') : null;
2063              while (j > 0) {
2064                  locale = loadLocale(split.slice(0, j).join('-'));
2065                  if (locale) {
2066                      return locale;
2067                  }
2068                  if (
2069                      next &&
2070                      next.length >= j &&
2071                      commonPrefix(split, next) >= j - 1
2072                  ) {
2073                      //the next array item is better than a shallower substring of this one
2074                      break;
2075                  }
2076                  j--;
2077              }
2078              i++;
2079          }
2080          return globalLocale;
2081      }
2082  
2083      function isLocaleNameSane(name) {
2084          // Prevent names that look like filesystem paths, i.e contain '/' or '\'
2085          return name.match('^[^/\\\\]*$') != null;
2086      }
2087  
2088      function loadLocale(name) {
2089          var oldLocale = null,
2090              aliasedRequire;
2091          // TODO: Find a better way to register and load all the locales in Node
2092          if (
2093              locales[name] === undefined &&
2094              typeof module !== 'undefined' &&
2095              module &&
2096              module.exports &&
2097              isLocaleNameSane(name)
2098          ) {
2099              try {
2100                  oldLocale = globalLocale._abbr;
2101                  aliasedRequire = require;
2102                  aliasedRequire('./locale/' + name);
2103                  getSetGlobalLocale(oldLocale);
2104              } catch (e) {
2105                  // mark as not found to avoid repeating expensive file require call causing high CPU
2106                  // when trying to find en-US, en_US, en-us for every format call
2107                  locales[name] = null; // null means not found
2108              }
2109          }
2110          return locales[name];
2111      }
2112  
2113      // This function will load locale and then set the global locale.  If
2114      // no arguments are passed in, it will simply return the current global
2115      // locale key.
2116      function getSetGlobalLocale(key, values) {
2117          var data;
2118          if (key) {
2119              if (isUndefined(values)) {
2120                  data = getLocale(key);
2121              } else {
2122                  data = defineLocale(key, values);
2123              }
2124  
2125              if (data) {
2126                  // moment.duration._locale = moment._locale = data;
2127                  globalLocale = data;
2128              } else {
2129                  if (typeof console !== 'undefined' && console.warn) {
2130                      //warn user if arguments are passed but the locale could not be set
2131                      console.warn(
2132                          'Locale ' + key + ' not found. Did you forget to load it?'
2133                      );
2134                  }
2135              }
2136          }
2137  
2138          return globalLocale._abbr;
2139      }
2140  
2141      function defineLocale(name, config) {
2142          if (config !== null) {
2143              var locale,
2144                  parentConfig = baseConfig;
2145              config.abbr = name;
2146              if (locales[name] != null) {
2147                  deprecateSimple(
2148                      'defineLocaleOverride',
2149                      'use moment.updateLocale(localeName, config) to change ' +
2150                          'an existing locale. moment.defineLocale(localeName, ' +
2151                          'config) should only be used for creating a new locale ' +
2152                          'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
2153                  );
2154                  parentConfig = locales[name]._config;
2155              } else if (config.parentLocale != null) {
2156                  if (locales[config.parentLocale] != null) {
2157                      parentConfig = locales[config.parentLocale]._config;
2158                  } else {
2159                      locale = loadLocale(config.parentLocale);
2160                      if (locale != null) {
2161                          parentConfig = locale._config;
2162                      } else {
2163                          if (!localeFamilies[config.parentLocale]) {
2164                              localeFamilies[config.parentLocale] = [];
2165                          }
2166                          localeFamilies[config.parentLocale].push({
2167                              name: name,
2168                              config: config,
2169                          });
2170                          return null;
2171                      }
2172                  }
2173              }
2174              locales[name] = new Locale(mergeConfigs(parentConfig, config));
2175  
2176              if (localeFamilies[name]) {
2177                  localeFamilies[name].forEach(function (x) {
2178                      defineLocale(x.name, x.config);
2179                  });
2180              }
2181  
2182              // backwards compat for now: also set the locale
2183              // make sure we set the locale AFTER all child locales have been
2184              // created, so we won't end up with the child locale set.
2185              getSetGlobalLocale(name);
2186  
2187              return locales[name];
2188          } else {
2189              // useful for testing
2190              delete locales[name];
2191              return null;
2192          }
2193      }
2194  
2195      function updateLocale(name, config) {
2196          if (config != null) {
2197              var locale,
2198                  tmpLocale,
2199                  parentConfig = baseConfig;
2200  
2201              if (locales[name] != null && locales[name].parentLocale != null) {
2202                  // Update existing child locale in-place to avoid memory-leaks
2203                  locales[name].set(mergeConfigs(locales[name]._config, config));
2204              } else {
2205                  // MERGE
2206                  tmpLocale = loadLocale(name);
2207                  if (tmpLocale != null) {
2208                      parentConfig = tmpLocale._config;
2209                  }
2210                  config = mergeConfigs(parentConfig, config);
2211                  if (tmpLocale == null) {
2212                      // updateLocale is called for creating a new locale
2213                      // Set abbr so it will have a name (getters return
2214                      // undefined otherwise).
2215                      config.abbr = name;
2216                  }
2217                  locale = new Locale(config);
2218                  locale.parentLocale = locales[name];
2219                  locales[name] = locale;
2220              }
2221  
2222              // backwards compat for now: also set the locale
2223              getSetGlobalLocale(name);
2224          } else {
2225              // pass null for config to unupdate, useful for tests
2226              if (locales[name] != null) {
2227                  if (locales[name].parentLocale != null) {
2228                      locales[name] = locales[name].parentLocale;
2229                      if (name === getSetGlobalLocale()) {
2230                          getSetGlobalLocale(name);
2231                      }
2232                  } else if (locales[name] != null) {
2233                      delete locales[name];
2234                  }
2235              }
2236          }
2237          return locales[name];
2238      }
2239  
2240      // returns locale data
2241      function getLocale(key) {
2242          var locale;
2243  
2244          if (key && key._locale && key._locale._abbr) {
2245              key = key._locale._abbr;
2246          }
2247  
2248          if (!key) {
2249              return globalLocale;
2250          }
2251  
2252          if (!isArray(key)) {
2253              //short-circuit everything else
2254              locale = loadLocale(key);
2255              if (locale) {
2256                  return locale;
2257              }
2258              key = [key];
2259          }
2260  
2261          return chooseLocale(key);
2262      }
2263  
2264      function listLocales() {
2265          return keys(locales);
2266      }
2267  
2268      function checkOverflow(m) {
2269          var overflow,
2270              a = m._a;
2271  
2272          if (a && getParsingFlags(m).overflow === -2) {
2273              overflow =
2274                  a[MONTH] < 0 || a[MONTH] > 11
2275                      ? MONTH
2276                      : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
2277                      ? DATE
2278                      : a[HOUR] < 0 ||
2279                        a[HOUR] > 24 ||
2280                        (a[HOUR] === 24 &&
2281                            (a[MINUTE] !== 0 ||
2282                                a[SECOND] !== 0 ||
2283                                a[MILLISECOND] !== 0))
2284                      ? HOUR
2285                      : a[MINUTE] < 0 || a[MINUTE] > 59
2286                      ? MINUTE
2287                      : a[SECOND] < 0 || a[SECOND] > 59
2288                      ? SECOND
2289                      : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
2290                      ? MILLISECOND
2291                      : -1;
2292  
2293              if (
2294                  getParsingFlags(m)._overflowDayOfYear &&
2295                  (overflow < YEAR || overflow > DATE)
2296              ) {
2297                  overflow = DATE;
2298              }
2299              if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
2300                  overflow = WEEK;
2301              }
2302              if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
2303                  overflow = WEEKDAY;
2304              }
2305  
2306              getParsingFlags(m).overflow = overflow;
2307          }
2308  
2309          return m;
2310      }
2311  
2312      // iso 8601 regex
2313      // 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)
2314      var extendedIsoRegex =
2315              /^\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)?)?$/,
2316          basicIsoRegex =
2317              /^\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)?)?$/,
2318          tzRegex = /Z|[+-]\d\d(?::?\d\d)?/,
2319          isoDates = [
2320              ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2321              ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2322              ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2323              ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2324              ['YYYY-DDD', /\d{4}-\d{3}/],
2325              ['YYYY-MM', /\d{4}-\d\d/, false],
2326              ['YYYYYYMMDD', /[+-]\d{10}/],
2327              ['YYYYMMDD', /\d{8}/],
2328              ['GGGG[W]WWE', /\d{4}W\d{3}/],
2329              ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2330              ['YYYYDDD', /\d{7}/],
2331              ['YYYYMM', /\d{6}/, false],
2332              ['YYYY', /\d{4}/, false],
2333          ],
2334          // iso time formats and regexes
2335          isoTimes = [
2336              ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2337              ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2338              ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2339              ['HH:mm', /\d\d:\d\d/],
2340              ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2341              ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2342              ['HHmmss', /\d\d\d\d\d\d/],
2343              ['HHmm', /\d\d\d\d/],
2344              ['HH', /\d\d/],
2345          ],
2346          aspNetJsonRegex = /^\/?Date\((-?\d+)/i,
2347          // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2348          rfc2822 =
2349              /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,
2350          obsOffsets = {
2351              UT: 0,
2352              GMT: 0,
2353              EDT: -4 * 60,
2354              EST: -5 * 60,
2355              CDT: -5 * 60,
2356              CST: -6 * 60,
2357              MDT: -6 * 60,
2358              MST: -7 * 60,
2359              PDT: -7 * 60,
2360              PST: -8 * 60,
2361          };
2362  
2363      // date from iso format
2364      function configFromISO(config) {
2365          var i,
2366              l,
2367              string = config._i,
2368              match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2369              allowTime,
2370              dateFormat,
2371              timeFormat,
2372              tzFormat,
2373              isoDatesLen = isoDates.length,
2374              isoTimesLen = isoTimes.length;
2375  
2376          if (match) {
2377              getParsingFlags(config).iso = true;
2378              for (i = 0, l = isoDatesLen; i < l; i++) {
2379                  if (isoDates[i][1].exec(match[1])) {
2380                      dateFormat = isoDates[i][0];
2381                      allowTime = isoDates[i][2] !== false;
2382                      break;
2383                  }
2384              }
2385              if (dateFormat == null) {
2386                  config._isValid = false;
2387                  return;
2388              }
2389              if (match[3]) {
2390                  for (i = 0, l = isoTimesLen; i < l; i++) {
2391                      if (isoTimes[i][1].exec(match[3])) {
2392                          // match[2] should be 'T' or space
2393                          timeFormat = (match[2] || ' ') + isoTimes[i][0];
2394                          break;
2395                      }
2396                  }
2397                  if (timeFormat == null) {
2398                      config._isValid = false;
2399                      return;
2400                  }
2401              }
2402              if (!allowTime && timeFormat != null) {
2403                  config._isValid = false;
2404                  return;
2405              }
2406              if (match[4]) {
2407                  if (tzRegex.exec(match[4])) {
2408                      tzFormat = 'Z';
2409                  } else {
2410                      config._isValid = false;
2411                      return;
2412                  }
2413              }
2414              config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2415              configFromStringAndFormat(config);
2416          } else {
2417              config._isValid = false;
2418          }
2419      }
2420  
2421      function extractFromRFC2822Strings(
2422          yearStr,
2423          monthStr,
2424          dayStr,
2425          hourStr,
2426          minuteStr,
2427          secondStr
2428      ) {
2429          var result = [
2430              untruncateYear(yearStr),
2431              defaultLocaleMonthsShort.indexOf(monthStr),
2432              parseInt(dayStr, 10),
2433              parseInt(hourStr, 10),
2434              parseInt(minuteStr, 10),
2435          ];
2436  
2437          if (secondStr) {
2438              result.push(parseInt(secondStr, 10));
2439          }
2440  
2441          return result;
2442      }
2443  
2444      function untruncateYear(yearStr) {
2445          var year = parseInt(yearStr, 10);
2446          if (year <= 49) {
2447              return 2000 + year;
2448          } else if (year <= 999) {
2449              return 1900 + year;
2450          }
2451          return year;
2452      }
2453  
2454      function preprocessRFC2822(s) {
2455          // Remove comments and folding whitespace and replace multiple-spaces with a single space
2456          return s
2457              .replace(/\([^)]*\)|[\n\t]/g, ' ')
2458              .replace(/(\s\s+)/g, ' ')
2459              .replace(/^\s\s*/, '')
2460              .replace(/\s\s*$/, '');
2461      }
2462  
2463      function checkWeekday(weekdayStr, parsedInput, config) {
2464          if (weekdayStr) {
2465              // TODO: Replace the vanilla JS Date object with an independent day-of-week check.
2466              var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
2467                  weekdayActual = new Date(
2468                      parsedInput[0],
2469                      parsedInput[1],
2470                      parsedInput[2]
2471                  ).getDay();
2472              if (weekdayProvided !== weekdayActual) {
2473                  getParsingFlags(config).weekdayMismatch = true;
2474                  config._isValid = false;
2475                  return false;
2476              }
2477          }
2478          return true;
2479      }
2480  
2481      function calculateOffset(obsOffset, militaryOffset, numOffset) {
2482          if (obsOffset) {
2483              return obsOffsets[obsOffset];
2484          } else if (militaryOffset) {
2485              // the only allowed military tz is Z
2486              return 0;
2487          } else {
2488              var hm = parseInt(numOffset, 10),
2489                  m = hm % 100,
2490                  h = (hm - m) / 100;
2491              return h * 60 + m;
2492          }
2493      }
2494  
2495      // date and time from ref 2822 format
2496      function configFromRFC2822(config) {
2497          var match = rfc2822.exec(preprocessRFC2822(config._i)),
2498              parsedArray;
2499          if (match) {
2500              parsedArray = extractFromRFC2822Strings(
2501                  match[4],
2502                  match[3],
2503                  match[2],
2504                  match[5],
2505                  match[6],
2506                  match[7]
2507              );
2508              if (!checkWeekday(match[1], parsedArray, config)) {
2509                  return;
2510              }
2511  
2512              config._a = parsedArray;
2513              config._tzm = calculateOffset(match[8], match[9], match[10]);
2514  
2515              config._d = createUTCDate.apply(null, config._a);
2516              config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2517  
2518              getParsingFlags(config).rfc2822 = true;
2519          } else {
2520              config._isValid = false;
2521          }
2522      }
2523  
2524      // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
2525      function configFromString(config) {
2526          var matched = aspNetJsonRegex.exec(config._i);
2527          if (matched !== null) {
2528              config._d = new Date(+matched[1]);
2529              return;
2530          }
2531  
2532          configFromISO(config);
2533          if (config._isValid === false) {
2534              delete config._isValid;
2535          } else {
2536              return;
2537          }
2538  
2539          configFromRFC2822(config);
2540          if (config._isValid === false) {
2541              delete config._isValid;
2542          } else {
2543              return;
2544          }
2545  
2546          if (config._strict) {
2547              config._isValid = false;
2548          } else {
2549              // Final attempt, use Input Fallback
2550              hooks.createFromInputFallback(config);
2551          }
2552      }
2553  
2554      hooks.createFromInputFallback = deprecate(
2555          'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
2556              'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
2557              'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2558          function (config) {
2559              config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2560          }
2561      );
2562  
2563      // Pick the first defined of two or three arguments.
2564      function defaults(a, b, c) {
2565          if (a != null) {
2566              return a;
2567          }
2568          if (b != null) {
2569              return b;
2570          }
2571          return c;
2572      }
2573  
2574      function currentDateArray(config) {
2575          // hooks is actually the exported moment object
2576          var nowValue = new Date(hooks.now());
2577          if (config._useUTC) {
2578              return [
2579                  nowValue.getUTCFullYear(),
2580                  nowValue.getUTCMonth(),
2581                  nowValue.getUTCDate(),
2582              ];
2583          }
2584          return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2585      }
2586  
2587      // convert an array to a date.
2588      // the array should mirror the parameters below
2589      // note: all values past the year are optional and will default to the lowest possible value.
2590      // [year, month, day , hour, minute, second, millisecond]
2591      function configFromArray(config) {
2592          var i,
2593              date,
2594              input = [],
2595              currentDate,
2596              expectedWeekday,
2597              yearToUse;
2598  
2599          if (config._d) {
2600              return;
2601          }
2602  
2603          currentDate = currentDateArray(config);
2604  
2605          //compute day of the year from weeks and weekdays
2606          if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2607              dayOfYearFromWeekInfo(config);
2608          }
2609  
2610          //if the day of the year is set, figure out what it is
2611          if (config._dayOfYear != null) {
2612              yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2613  
2614              if (
2615                  config._dayOfYear > daysInYear(yearToUse) ||
2616                  config._dayOfYear === 0
2617              ) {
2618                  getParsingFlags(config)._overflowDayOfYear = true;
2619              }
2620  
2621              date = createUTCDate(yearToUse, 0, config._dayOfYear);
2622              config._a[MONTH] = date.getUTCMonth();
2623              config._a[DATE] = date.getUTCDate();
2624          }
2625  
2626          // Default to current date.
2627          // * if no year, month, day of month are given, default to today
2628          // * if day of month is given, default month and year
2629          // * if month is given, default only year
2630          // * if year is given, don't default anything
2631          for (i = 0; i < 3 && config._a[i] == null; ++i) {
2632              config._a[i] = input[i] = currentDate[i];
2633          }
2634  
2635          // Zero out whatever was not defaulted, including time
2636          for (; i < 7; i++) {
2637              config._a[i] = input[i] =
2638                  config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i];
2639          }
2640  
2641          // Check for 24:00:00.000
2642          if (
2643              config._a[HOUR] === 24 &&
2644              config._a[MINUTE] === 0 &&
2645              config._a[SECOND] === 0 &&
2646              config._a[MILLISECOND] === 0
2647          ) {
2648              config._nextDay = true;
2649              config._a[HOUR] = 0;
2650          }
2651  
2652          config._d = (config._useUTC ? createUTCDate : createDate).apply(
2653              null,
2654              input
2655          );
2656          expectedWeekday = config._useUTC
2657              ? config._d.getUTCDay()
2658              : config._d.getDay();
2659  
2660          // Apply timezone offset from input. The actual utcOffset can be changed
2661          // with parseZone.
2662          if (config._tzm != null) {
2663              config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2664          }
2665  
2666          if (config._nextDay) {
2667              config._a[HOUR] = 24;
2668          }
2669  
2670          // check for mismatching day of week
2671          if (
2672              config._w &&
2673              typeof config._w.d !== 'undefined' &&
2674              config._w.d !== expectedWeekday
2675          ) {
2676              getParsingFlags(config).weekdayMismatch = true;
2677          }
2678      }
2679  
2680      function dayOfYearFromWeekInfo(config) {
2681          var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
2682  
2683          w = config._w;
2684          if (w.GG != null || w.W != null || w.E != null) {
2685              dow = 1;
2686              doy = 4;
2687  
2688              // TODO: We need to take the current isoWeekYear, but that depends on
2689              // how we interpret now (local, utc, fixed offset). So create
2690              // a now version of current config (take local/utc/offset flags, and
2691              // create now).
2692              weekYear = defaults(
2693                  w.GG,
2694                  config._a[YEAR],
2695                  weekOfYear(createLocal(), 1, 4).year
2696              );
2697              week = defaults(w.W, 1);
2698              weekday = defaults(w.E, 1);
2699              if (weekday < 1 || weekday > 7) {
2700                  weekdayOverflow = true;
2701              }
2702          } else {
2703              dow = config._locale._week.dow;
2704              doy = config._locale._week.doy;
2705  
2706              curWeek = weekOfYear(createLocal(), dow, doy);
2707  
2708              weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
2709  
2710              // Default to current week.
2711              week = defaults(w.w, curWeek.week);
2712  
2713              if (w.d != null) {
2714                  // weekday -- low day numbers are considered next week
2715                  weekday = w.d;
2716                  if (weekday < 0 || weekday > 6) {
2717                      weekdayOverflow = true;
2718                  }
2719              } else if (w.e != null) {
2720                  // local weekday -- counting starts from beginning of week
2721                  weekday = w.e + dow;
2722                  if (w.e < 0 || w.e > 6) {
2723                      weekdayOverflow = true;
2724                  }
2725              } else {
2726                  // default to beginning of week
2727                  weekday = dow;
2728              }
2729          }
2730          if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2731              getParsingFlags(config)._overflowWeeks = true;
2732          } else if (weekdayOverflow != null) {
2733              getParsingFlags(config)._overflowWeekday = true;
2734          } else {
2735              temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2736              config._a[YEAR] = temp.year;
2737              config._dayOfYear = temp.dayOfYear;
2738          }
2739      }
2740  
2741      // constant that refers to the ISO standard
2742      hooks.ISO_8601 = function () {};
2743  
2744      // constant that refers to the RFC 2822 form
2745      hooks.RFC_2822 = function () {};
2746  
2747      // date from string and format string
2748      function configFromStringAndFormat(config) {
2749          // TODO: Move this to another part of the creation flow to prevent circular deps
2750          if (config._f === hooks.ISO_8601) {
2751              configFromISO(config);
2752              return;
2753          }
2754          if (config._f === hooks.RFC_2822) {
2755              configFromRFC2822(config);
2756              return;
2757          }
2758          config._a = [];
2759          getParsingFlags(config).empty = true;
2760  
2761          // This array is used to make a Date, either with `new Date` or `Date.UTC`
2762          var string = '' + config._i,
2763              i,
2764              parsedInput,
2765              tokens,
2766              token,
2767              skipped,
2768              stringLength = string.length,
2769              totalParsedInputLength = 0,
2770              era,
2771              tokenLen;
2772  
2773          tokens =
2774              expandFormat(config._f, config._locale).match(formattingTokens) || [];
2775          tokenLen = tokens.length;
2776          for (i = 0; i < tokenLen; i++) {
2777              token = tokens[i];
2778              parsedInput = (string.match(getParseRegexForToken(token, config)) ||
2779                  [])[0];
2780              if (parsedInput) {
2781                  skipped = string.substr(0, string.indexOf(parsedInput));
2782                  if (skipped.length > 0) {
2783                      getParsingFlags(config).unusedInput.push(skipped);
2784                  }
2785                  string = string.slice(
2786                      string.indexOf(parsedInput) + parsedInput.length
2787                  );
2788                  totalParsedInputLength += parsedInput.length;
2789              }
2790              // don't parse if it's not a known token
2791              if (formatTokenFunctions[token]) {
2792                  if (parsedInput) {
2793                      getParsingFlags(config).empty = false;
2794                  } else {
2795                      getParsingFlags(config).unusedTokens.push(token);
2796                  }
2797                  addTimeToArrayFromToken(token, parsedInput, config);
2798              } else if (config._strict && !parsedInput) {
2799                  getParsingFlags(config).unusedTokens.push(token);
2800              }
2801          }
2802  
2803          // add remaining unparsed input length to the string
2804          getParsingFlags(config).charsLeftOver =
2805              stringLength - totalParsedInputLength;
2806          if (string.length > 0) {
2807              getParsingFlags(config).unusedInput.push(string);
2808          }
2809  
2810          // clear _12h flag if hour is <= 12
2811          if (
2812              config._a[HOUR] <= 12 &&
2813              getParsingFlags(config).bigHour === true &&
2814              config._a[HOUR] > 0
2815          ) {
2816              getParsingFlags(config).bigHour = undefined;
2817          }
2818  
2819          getParsingFlags(config).parsedDateParts = config._a.slice(0);
2820          getParsingFlags(config).meridiem = config._meridiem;
2821          // handle meridiem
2822          config._a[HOUR] = meridiemFixWrap(
2823              config._locale,
2824              config._a[HOUR],
2825              config._meridiem
2826          );
2827  
2828          // handle era
2829          era = getParsingFlags(config).era;
2830          if (era !== null) {
2831              config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
2832          }
2833  
2834          configFromArray(config);
2835          checkOverflow(config);
2836      }
2837  
2838      function meridiemFixWrap(locale, hour, meridiem) {
2839          var isPm;
2840  
2841          if (meridiem == null) {
2842              // nothing to do
2843              return hour;
2844          }
2845          if (locale.meridiemHour != null) {
2846              return locale.meridiemHour(hour, meridiem);
2847          } else if (locale.isPM != null) {
2848              // Fallback
2849              isPm = locale.isPM(meridiem);
2850              if (isPm && hour < 12) {
2851                  hour += 12;
2852              }
2853              if (!isPm && hour === 12) {
2854                  hour = 0;
2855              }
2856              return hour;
2857          } else {
2858              // this is not supposed to happen
2859              return hour;
2860          }
2861      }
2862  
2863      // date from string and array of format strings
2864      function configFromStringAndArray(config) {
2865          var tempConfig,
2866              bestMoment,
2867              scoreToBeat,
2868              i,
2869              currentScore,
2870              validFormatFound,
2871              bestFormatIsValid = false,
2872              configfLen = config._f.length;
2873  
2874          if (configfLen === 0) {
2875              getParsingFlags(config).invalidFormat = true;
2876              config._d = new Date(NaN);
2877              return;
2878          }
2879  
2880          for (i = 0; i < configfLen; i++) {
2881              currentScore = 0;
2882              validFormatFound = false;
2883              tempConfig = copyConfig({}, config);
2884              if (config._useUTC != null) {
2885                  tempConfig._useUTC = config._useUTC;
2886              }
2887              tempConfig._f = config._f[i];
2888              configFromStringAndFormat(tempConfig);
2889  
2890              if (isValid(tempConfig)) {
2891                  validFormatFound = true;
2892              }
2893  
2894              // if there is any input that was not parsed add a penalty for that format
2895              currentScore += getParsingFlags(tempConfig).charsLeftOver;
2896  
2897              //or tokens
2898              currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2899  
2900              getParsingFlags(tempConfig).score = currentScore;
2901  
2902              if (!bestFormatIsValid) {
2903                  if (
2904                      scoreToBeat == null ||
2905                      currentScore < scoreToBeat ||
2906                      validFormatFound
2907                  ) {
2908                      scoreToBeat = currentScore;
2909                      bestMoment = tempConfig;
2910                      if (validFormatFound) {
2911                          bestFormatIsValid = true;
2912                      }
2913                  }
2914              } else {
2915                  if (currentScore < scoreToBeat) {
2916                      scoreToBeat = currentScore;
2917                      bestMoment = tempConfig;
2918                  }
2919              }
2920          }
2921  
2922          extend(config, bestMoment || tempConfig);
2923      }
2924  
2925      function configFromObject(config) {
2926          if (config._d) {
2927              return;
2928          }
2929  
2930          var i = normalizeObjectUnits(config._i),
2931              dayOrDate = i.day === undefined ? i.date : i.day;
2932          config._a = map(
2933              [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
2934              function (obj) {
2935                  return obj && parseInt(obj, 10);
2936              }
2937          );
2938  
2939          configFromArray(config);
2940      }
2941  
2942      function createFromConfig(config) {
2943          var res = new Moment(checkOverflow(prepareConfig(config)));
2944          if (res._nextDay) {
2945              // Adding is smart enough around DST
2946              res.add(1, 'd');
2947              res._nextDay = undefined;
2948          }
2949  
2950          return res;
2951      }
2952  
2953      function prepareConfig(config) {
2954          var input = config._i,
2955              format = config._f;
2956  
2957          config._locale = config._locale || getLocale(config._l);
2958  
2959          if (input === null || (format === undefined && input === '')) {
2960              return createInvalid({ nullInput: true });
2961          }
2962  
2963          if (typeof input === 'string') {
2964              config._i = input = config._locale.preparse(input);
2965          }
2966  
2967          if (isMoment(input)) {
2968              return new Moment(checkOverflow(input));
2969          } else if (isDate(input)) {
2970              config._d = input;
2971          } else if (isArray(format)) {
2972              configFromStringAndArray(config);
2973          } else if (format) {
2974              configFromStringAndFormat(config);
2975          } else {
2976              configFromInput(config);
2977          }
2978  
2979          if (!isValid(config)) {
2980              config._d = null;
2981          }
2982  
2983          return config;
2984      }
2985  
2986      function configFromInput(config) {
2987          var input = config._i;
2988          if (isUndefined(input)) {
2989              config._d = new Date(hooks.now());
2990          } else if (isDate(input)) {
2991              config._d = new Date(input.valueOf());
2992          } else if (typeof input === 'string') {
2993              configFromString(config);
2994          } else if (isArray(input)) {
2995              config._a = map(input.slice(0), function (obj) {
2996                  return parseInt(obj, 10);
2997              });
2998              configFromArray(config);
2999          } else if (isObject(input)) {
3000              configFromObject(config);
3001          } else if (isNumber(input)) {
3002              // from milliseconds
3003              config._d = new Date(input);
3004          } else {
3005              hooks.createFromInputFallback(config);
3006          }
3007      }
3008  
3009      function createLocalOrUTC(input, format, locale, strict, isUTC) {
3010          var c = {};
3011  
3012          if (format === true || format === false) {
3013              strict = format;
3014              format = undefined;
3015          }
3016  
3017          if (locale === true || locale === false) {
3018              strict = locale;
3019              locale = undefined;
3020          }
3021  
3022          if (
3023              (isObject(input) && isObjectEmpty(input)) ||
3024              (isArray(input) && input.length === 0)
3025          ) {
3026              input = undefined;
3027          }
3028          // object construction must be done this way.
3029          // https://github.com/moment/moment/issues/1423
3030          c._isAMomentObject = true;
3031          c._useUTC = c._isUTC = isUTC;
3032          c._l = locale;
3033          c._i = input;
3034          c._f = format;
3035          c._strict = strict;
3036  
3037          return createFromConfig(c);
3038      }
3039  
3040      function createLocal(input, format, locale, strict) {
3041          return createLocalOrUTC(input, format, locale, strict, false);
3042      }
3043  
3044      var prototypeMin = deprecate(
3045              'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
3046              function () {
3047                  var other = createLocal.apply(null, arguments);
3048                  if (this.isValid() && other.isValid()) {
3049                      return other < this ? this : other;
3050                  } else {
3051                      return createInvalid();
3052                  }
3053              }
3054          ),
3055          prototypeMax = deprecate(
3056              'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
3057              function () {
3058                  var other = createLocal.apply(null, arguments);
3059                  if (this.isValid() && other.isValid()) {
3060                      return other > this ? this : other;
3061                  } else {
3062                      return createInvalid();
3063                  }
3064              }
3065          );
3066  
3067      // Pick a moment m from moments so that m[fn](other) is true for all
3068      // other. This relies on the function fn to be transitive.
3069      //
3070      // moments should either be an array of moment objects or an array, whose
3071      // first element is an array of moment objects.
3072      function pickBy(fn, moments) {
3073          var res, i;
3074          if (moments.length === 1 && isArray(moments[0])) {
3075              moments = moments[0];
3076          }
3077          if (!moments.length) {
3078              return createLocal();
3079          }
3080          res = moments[0];
3081          for (i = 1; i < moments.length; ++i) {
3082              if (!moments[i].isValid() || moments[i][fn](res)) {
3083                  res = moments[i];
3084              }
3085          }
3086          return res;
3087      }
3088  
3089      // TODO: Use [].sort instead?
3090      function min() {
3091          var args = [].slice.call(arguments, 0);
3092  
3093          return pickBy('isBefore', args);
3094      }
3095  
3096      function max() {
3097          var args = [].slice.call(arguments, 0);
3098  
3099          return pickBy('isAfter', args);
3100      }
3101  
3102      var now = function () {
3103          return Date.now ? Date.now() : +new Date();
3104      };
3105  
3106      var ordering = [
3107          'year',
3108          'quarter',
3109          'month',
3110          'week',
3111          'day',
3112          'hour',
3113          'minute',
3114          'second',
3115          'millisecond',
3116      ];
3117  
3118      function isDurationValid(m) {
3119          var key,
3120              unitHasDecimal = false,
3121              i,
3122              orderLen = ordering.length;
3123          for (key in m) {
3124              if (
3125                  hasOwnProp(m, key) &&
3126                  !(
3127                      indexOf.call(ordering, key) !== -1 &&
3128                      (m[key] == null || !isNaN(m[key]))
3129                  )
3130              ) {
3131                  return false;
3132              }
3133          }
3134  
3135          for (i = 0; i < orderLen; ++i) {
3136              if (m[ordering[i]]) {
3137                  if (unitHasDecimal) {
3138                      return false; // only allow non-integers for smallest unit
3139                  }
3140                  if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
3141                      unitHasDecimal = true;
3142                  }
3143              }
3144          }
3145  
3146          return true;
3147      }
3148  
3149      function isValid$1() {
3150          return this._isValid;
3151      }
3152  
3153      function createInvalid$1() {
3154          return createDuration(NaN);
3155      }
3156  
3157      function Duration(duration) {
3158          var normalizedInput = normalizeObjectUnits(duration),
3159              years = normalizedInput.year || 0,
3160              quarters = normalizedInput.quarter || 0,
3161              months = normalizedInput.month || 0,
3162              weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
3163              days = normalizedInput.day || 0,
3164              hours = normalizedInput.hour || 0,
3165              minutes = normalizedInput.minute || 0,
3166              seconds = normalizedInput.second || 0,
3167              milliseconds = normalizedInput.millisecond || 0;
3168  
3169          this._isValid = isDurationValid(normalizedInput);
3170  
3171          // representation for dateAddRemove
3172          this._milliseconds =
3173              +milliseconds +
3174              seconds * 1e3 + // 1000
3175              minutes * 6e4 + // 1000 * 60
3176              hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
3177          // Because of dateAddRemove treats 24 hours as different from a
3178          // day when working around DST, we need to store them separately
3179          this._days = +days + weeks * 7;
3180          // It is impossible to translate months into days without knowing
3181          // which months you are are talking about, so we have to store
3182          // it separately.
3183          this._months = +months + quarters * 3 + years * 12;
3184  
3185          this._data = {};
3186  
3187          this._locale = getLocale();
3188  
3189          this._bubble();
3190      }
3191  
3192      function isDuration(obj) {
3193          return obj instanceof Duration;
3194      }
3195  
3196      function absRound(number) {
3197          if (number < 0) {
3198              return Math.round(-1 * number) * -1;
3199          } else {
3200              return Math.round(number);
3201          }
3202      }
3203  
3204      // compare two arrays, return the number of differences
3205      function compareArrays(array1, array2, dontConvert) {
3206          var len = Math.min(array1.length, array2.length),
3207              lengthDiff = Math.abs(array1.length - array2.length),
3208              diffs = 0,
3209              i;
3210          for (i = 0; i < len; i++) {
3211              if (
3212                  (dontConvert && array1[i] !== array2[i]) ||
3213                  (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
3214              ) {
3215                  diffs++;
3216              }
3217          }
3218          return diffs + lengthDiff;
3219      }
3220  
3221      // FORMATTING
3222  
3223      function offset(token, separator) {
3224          addFormatToken(token, 0, 0, function () {
3225              var offset = this.utcOffset(),
3226                  sign = '+';
3227              if (offset < 0) {
3228                  offset = -offset;
3229                  sign = '-';
3230              }
3231              return (
3232                  sign +
3233                  zeroFill(~~(offset / 60), 2) +
3234                  separator +
3235                  zeroFill(~~offset % 60, 2)
3236              );
3237          });
3238      }
3239  
3240      offset('Z', ':');
3241      offset('ZZ', '');
3242  
3243      // PARSING
3244  
3245      addRegexToken('Z', matchShortOffset);
3246      addRegexToken('ZZ', matchShortOffset);
3247      addParseToken(['Z', 'ZZ'], function (input, array, config) {
3248          config._useUTC = true;
3249          config._tzm = offsetFromString(matchShortOffset, input);
3250      });
3251  
3252      // HELPERS
3253  
3254      // timezone chunker
3255      // '+10:00' > ['10',  '00']
3256      // '-1530'  > ['-15', '30']
3257      var chunkOffset = /([\+\-]|\d\d)/gi;
3258  
3259      function offsetFromString(matcher, string) {
3260          var matches = (string || '').match(matcher),
3261              chunk,
3262              parts,
3263              minutes;
3264  
3265          if (matches === null) {
3266              return null;
3267          }
3268  
3269          chunk = matches[matches.length - 1] || [];
3270          parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
3271          minutes = +(parts[1] * 60) + toInt(parts[2]);
3272  
3273          return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
3274      }
3275  
3276      // Return a moment from input, that is local/utc/zone equivalent to model.
3277      function cloneWithOffset(input, model) {
3278          var res, diff;
3279          if (model._isUTC) {
3280              res = model.clone();
3281              diff =
3282                  (isMoment(input) || isDate(input)
3283                      ? input.valueOf()
3284                      : createLocal(input).valueOf()) - res.valueOf();
3285              // Use low-level api, because this fn is low-level api.
3286              res._d.setTime(res._d.valueOf() + diff);
3287              hooks.updateOffset(res, false);
3288              return res;
3289          } else {
3290              return createLocal(input).local();
3291          }
3292      }
3293  
3294      function getDateOffset(m) {
3295          // On Firefox.24 Date#getTimezoneOffset returns a floating point.
3296          // https://github.com/moment/moment/pull/1871
3297          return -Math.round(m._d.getTimezoneOffset());
3298      }
3299  
3300      // HOOKS
3301  
3302      // This function will be called whenever a moment is mutated.
3303      // It is intended to keep the offset in sync with the timezone.
3304      hooks.updateOffset = function () {};
3305  
3306      // MOMENTS
3307  
3308      // keepLocalTime = true means only change the timezone, without
3309      // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
3310      // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
3311      // +0200, so we adjust the time as needed, to be valid.
3312      //
3313      // Keeping the time actually adds/subtracts (one hour)
3314      // from the actual represented time. That is why we call updateOffset
3315      // a second time. In case it wants us to change the offset again
3316      // _changeInProgress == true case, then we have to adjust, because
3317      // there is no such time in the given timezone.
3318      function getSetOffset(input, keepLocalTime, keepMinutes) {
3319          var offset = this._offset || 0,
3320              localAdjust;
3321          if (!this.isValid()) {
3322              return input != null ? this : NaN;
3323          }
3324          if (input != null) {
3325              if (typeof input === 'string') {
3326                  input = offsetFromString(matchShortOffset, input);
3327                  if (input === null) {
3328                      return this;
3329                  }
3330              } else if (Math.abs(input) < 16 && !keepMinutes) {
3331                  input = input * 60;
3332              }
3333              if (!this._isUTC && keepLocalTime) {
3334                  localAdjust = getDateOffset(this);
3335              }
3336              this._offset = input;
3337              this._isUTC = true;
3338              if (localAdjust != null) {
3339                  this.add(localAdjust, 'm');
3340              }
3341              if (offset !== input) {
3342                  if (!keepLocalTime || this._changeInProgress) {
3343                      addSubtract(
3344                          this,
3345                          createDuration(input - offset, 'm'),
3346                          1,
3347                          false
3348                      );
3349                  } else if (!this._changeInProgress) {
3350                      this._changeInProgress = true;
3351                      hooks.updateOffset(this, true);
3352                      this._changeInProgress = null;
3353                  }
3354              }
3355              return this;
3356          } else {
3357              return this._isUTC ? offset : getDateOffset(this);
3358          }
3359      }
3360  
3361      function getSetZone(input, keepLocalTime) {
3362          if (input != null) {
3363              if (typeof input !== 'string') {
3364                  input = -input;
3365              }
3366  
3367              this.utcOffset(input, keepLocalTime);
3368  
3369              return this;
3370          } else {
3371              return -this.utcOffset();
3372          }
3373      }
3374  
3375      function setOffsetToUTC(keepLocalTime) {
3376          return this.utcOffset(0, keepLocalTime);
3377      }
3378  
3379      function setOffsetToLocal(keepLocalTime) {
3380          if (this._isUTC) {
3381              this.utcOffset(0, keepLocalTime);
3382              this._isUTC = false;
3383  
3384              if (keepLocalTime) {
3385                  this.subtract(getDateOffset(this), 'm');
3386              }
3387          }
3388          return this;
3389      }
3390  
3391      function setOffsetToParsedOffset() {
3392          if (this._tzm != null) {
3393              this.utcOffset(this._tzm, false, true);
3394          } else if (typeof this._i === 'string') {
3395              var tZone = offsetFromString(matchOffset, this._i);
3396              if (tZone != null) {
3397                  this.utcOffset(tZone);
3398              } else {
3399                  this.utcOffset(0, true);
3400              }
3401          }
3402          return this;
3403      }
3404  
3405      function hasAlignedHourOffset(input) {
3406          if (!this.isValid()) {
3407              return false;
3408          }
3409          input = input ? createLocal(input).utcOffset() : 0;
3410  
3411          return (this.utcOffset() - input) % 60 === 0;
3412      }
3413  
3414      function isDaylightSavingTime() {
3415          return (
3416              this.utcOffset() > this.clone().month(0).utcOffset() ||
3417              this.utcOffset() > this.clone().month(5).utcOffset()
3418          );
3419      }
3420  
3421      function isDaylightSavingTimeShifted() {
3422          if (!isUndefined(this._isDSTShifted)) {
3423              return this._isDSTShifted;
3424          }
3425  
3426          var c = {},
3427              other;
3428  
3429          copyConfig(c, this);
3430          c = prepareConfig(c);
3431  
3432          if (c._a) {
3433              other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
3434              this._isDSTShifted =
3435                  this.isValid() && compareArrays(c._a, other.toArray()) > 0;
3436          } else {
3437              this._isDSTShifted = false;
3438          }
3439  
3440          return this._isDSTShifted;
3441      }
3442  
3443      function isLocal() {
3444          return this.isValid() ? !this._isUTC : false;
3445      }
3446  
3447      function isUtcOffset() {
3448          return this.isValid() ? this._isUTC : false;
3449      }
3450  
3451      function isUtc() {
3452          return this.isValid() ? this._isUTC && this._offset === 0 : false;
3453      }
3454  
3455      // ASP.NET json date format regex
3456      var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,
3457          // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
3458          // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
3459          // and further modified to allow for strings containing both week and day
3460          isoRegex =
3461              /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
3462  
3463      function createDuration(input, key) {
3464          var duration = input,
3465              // matching against regexp is expensive, do it on demand
3466              match = null,
3467              sign,
3468              ret,
3469              diffRes;
3470  
3471          if (isDuration(input)) {
3472              duration = {
3473                  ms: input._milliseconds,
3474                  d: input._days,
3475                  M: input._months,
3476              };
3477          } else if (isNumber(input) || !isNaN(+input)) {
3478              duration = {};
3479              if (key) {
3480                  duration[key] = +input;
3481              } else {
3482                  duration.milliseconds = +input;
3483              }
3484          } else if ((match = aspNetRegex.exec(input))) {
3485              sign = match[1] === '-' ? -1 : 1;
3486              duration = {
3487                  y: 0,
3488                  d: toInt(match[DATE]) * sign,
3489                  h: toInt(match[HOUR]) * sign,
3490                  m: toInt(match[MINUTE]) * sign,
3491                  s: toInt(match[SECOND]) * sign,
3492                  ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match
3493              };
3494          } else if ((match = isoRegex.exec(input))) {
3495              sign = match[1] === '-' ? -1 : 1;
3496              duration = {
3497                  y: parseIso(match[2], sign),
3498                  M: parseIso(match[3], sign),
3499                  w: parseIso(match[4], sign),
3500                  d: parseIso(match[5], sign),
3501                  h: parseIso(match[6], sign),
3502                  m: parseIso(match[7], sign),
3503                  s: parseIso(match[8], sign),
3504              };
3505          } else if (duration == null) {
3506              // checks for null or undefined
3507              duration = {};
3508          } else if (
3509              typeof duration === 'object' &&
3510              ('from' in duration || 'to' in duration)
3511          ) {
3512              diffRes = momentsDifference(
3513                  createLocal(duration.from),
3514                  createLocal(duration.to)
3515              );
3516  
3517              duration = {};
3518              duration.ms = diffRes.milliseconds;
3519              duration.M = diffRes.months;
3520          }
3521  
3522          ret = new Duration(duration);
3523  
3524          if (isDuration(input) && hasOwnProp(input, '_locale')) {
3525              ret._locale = input._locale;
3526          }
3527  
3528          if (isDuration(input) && hasOwnProp(input, '_isValid')) {
3529              ret._isValid = input._isValid;
3530          }
3531  
3532          return ret;
3533      }
3534  
3535      createDuration.fn = Duration.prototype;
3536      createDuration.invalid = createInvalid$1;
3537  
3538      function parseIso(inp, sign) {
3539          // We'd normally use ~~inp for this, but unfortunately it also
3540          // converts floats to ints.
3541          // inp may be undefined, so careful calling replace on it.
3542          var res = inp && parseFloat(inp.replace(',', '.'));
3543          // apply sign while we're at it
3544          return (isNaN(res) ? 0 : res) * sign;
3545      }
3546  
3547      function positiveMomentsDifference(base, other) {
3548          var res = {};
3549  
3550          res.months =
3551              other.month() - base.month() + (other.year() - base.year()) * 12;
3552          if (base.clone().add(res.months, 'M').isAfter(other)) {
3553              --res.months;
3554          }
3555  
3556          res.milliseconds = +other - +base.clone().add(res.months, 'M');
3557  
3558          return res;
3559      }
3560  
3561      function momentsDifference(base, other) {
3562          var res;
3563          if (!(base.isValid() && other.isValid())) {
3564              return { milliseconds: 0, months: 0 };
3565          }
3566  
3567          other = cloneWithOffset(other, base);
3568          if (base.isBefore(other)) {
3569              res = positiveMomentsDifference(base, other);
3570          } else {
3571              res = positiveMomentsDifference(other, base);
3572              res.milliseconds = -res.milliseconds;
3573              res.months = -res.months;
3574          }
3575  
3576          return res;
3577      }
3578  
3579      // TODO: remove 'name' arg after deprecation is removed
3580      function createAdder(direction, name) {
3581          return function (val, period) {
3582              var dur, tmp;
3583              //invert the arguments, but complain about it
3584              if (period !== null && !isNaN(+period)) {
3585                  deprecateSimple(
3586                      name,
3587                      'moment().' +
3588                          name +
3589                          '(period, number) is deprecated. Please use moment().' +
3590                          name +
3591                          '(number, period). ' +
3592                          'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'
3593                  );
3594                  tmp = val;
3595                  val = period;
3596                  period = tmp;
3597              }
3598  
3599              dur = createDuration(val, period);
3600              addSubtract(this, dur, direction);
3601              return this;
3602          };
3603      }
3604  
3605      function addSubtract(mom, duration, isAdding, updateOffset) {
3606          var milliseconds = duration._milliseconds,
3607              days = absRound(duration._days),
3608              months = absRound(duration._months);
3609  
3610          if (!mom.isValid()) {
3611              // No op
3612              return;
3613          }
3614  
3615          updateOffset = updateOffset == null ? true : updateOffset;
3616  
3617          if (months) {
3618              setMonth(mom, get(mom, 'Month') + months * isAdding);
3619          }
3620          if (days) {
3621              set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
3622          }
3623          if (milliseconds) {
3624              mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
3625          }
3626          if (updateOffset) {
3627              hooks.updateOffset(mom, days || months);
3628          }
3629      }
3630  
3631      var add = createAdder(1, 'add'),
3632          subtract = createAdder(-1, 'subtract');
3633  
3634      function isString(input) {
3635          return typeof input === 'string' || input instanceof String;
3636      }
3637  
3638      // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined
3639      function isMomentInput(input) {
3640          return (
3641              isMoment(input) ||
3642              isDate(input) ||
3643              isString(input) ||
3644              isNumber(input) ||
3645              isNumberOrStringArray(input) ||
3646              isMomentInputObject(input) ||
3647              input === null ||
3648              input === undefined
3649          );
3650      }
3651  
3652      function isMomentInputObject(input) {
3653          var objectTest = isObject(input) && !isObjectEmpty(input),
3654              propertyTest = false,
3655              properties = [
3656                  'years',
3657                  'year',
3658                  'y',
3659                  'months',
3660                  'month',
3661                  'M',
3662                  'days',
3663                  'day',
3664                  'd',
3665                  'dates',
3666                  'date',
3667                  'D',
3668                  'hours',
3669                  'hour',
3670                  'h',
3671                  'minutes',
3672                  'minute',
3673                  'm',
3674                  'seconds',
3675                  'second',
3676                  's',
3677                  'milliseconds',
3678                  'millisecond',
3679                  'ms',
3680              ],
3681              i,
3682              property,
3683              propertyLen = properties.length;
3684  
3685          for (i = 0; i < propertyLen; i += 1) {
3686              property = properties[i];
3687              propertyTest = propertyTest || hasOwnProp(input, property);
3688          }
3689  
3690          return objectTest && propertyTest;
3691      }
3692  
3693      function isNumberOrStringArray(input) {
3694          var arrayTest = isArray(input),
3695              dataTypeTest = false;
3696          if (arrayTest) {
3697              dataTypeTest =
3698                  input.filter(function (item) {
3699                      return !isNumber(item) && isString(input);
3700                  }).length === 0;
3701          }
3702          return arrayTest && dataTypeTest;
3703      }
3704  
3705      function isCalendarSpec(input) {
3706          var objectTest = isObject(input) && !isObjectEmpty(input),
3707              propertyTest = false,
3708              properties = [
3709                  'sameDay',
3710                  'nextDay',
3711                  'lastDay',
3712                  'nextWeek',
3713                  'lastWeek',
3714                  'sameElse',
3715              ],
3716              i,
3717              property;
3718  
3719          for (i = 0; i < properties.length; i += 1) {
3720              property = properties[i];
3721              propertyTest = propertyTest || hasOwnProp(input, property);
3722          }
3723  
3724          return objectTest && propertyTest;
3725      }
3726  
3727      function getCalendarFormat(myMoment, now) {
3728          var diff = myMoment.diff(now, 'days', true);
3729          return diff < -6
3730              ? 'sameElse'
3731              : diff < -1
3732              ? 'lastWeek'
3733              : diff < 0
3734              ? 'lastDay'
3735              : diff < 1
3736              ? 'sameDay'
3737              : diff < 2
3738              ? 'nextDay'
3739              : diff < 7
3740              ? 'nextWeek'
3741              : 'sameElse';
3742      }
3743  
3744      function calendar$1(time, formats) {
3745          // Support for single parameter, formats only overload to the calendar function
3746          if (arguments.length === 1) {
3747              if (!arguments[0]) {
3748                  time = undefined;
3749                  formats = undefined;
3750              } else if (isMomentInput(arguments[0])) {
3751                  time = arguments[0];
3752                  formats = undefined;
3753              } else if (isCalendarSpec(arguments[0])) {
3754                  formats = arguments[0];
3755                  time = undefined;
3756              }
3757          }
3758          // We want to compare the start of today, vs this.
3759          // Getting start-of-today depends on whether we're local/utc/offset or not.
3760          var now = time || createLocal(),
3761              sod = cloneWithOffset(now, this).startOf('day'),
3762              format = hooks.calendarFormat(this, sod) || 'sameElse',
3763              output =
3764                  formats &&
3765                  (isFunction(formats[format])
3766                      ? formats[format].call(this, now)
3767                      : formats[format]);
3768  
3769          return this.format(
3770              output || this.localeData().calendar(format, this, createLocal(now))
3771          );
3772      }
3773  
3774      function clone() {
3775          return new Moment(this);
3776      }
3777  
3778      function isAfter(input, units) {
3779          var localInput = isMoment(input) ? input : createLocal(input);
3780          if (!(this.isValid() && localInput.isValid())) {
3781              return false;
3782          }
3783          units = normalizeUnits(units) || 'millisecond';
3784          if (units === 'millisecond') {
3785              return this.valueOf() > localInput.valueOf();
3786          } else {
3787              return localInput.valueOf() < this.clone().startOf(units).valueOf();
3788          }
3789      }
3790  
3791      function isBefore(input, units) {
3792          var localInput = isMoment(input) ? input : createLocal(input);
3793          if (!(this.isValid() && localInput.isValid())) {
3794              return false;
3795          }
3796          units = normalizeUnits(units) || 'millisecond';
3797          if (units === 'millisecond') {
3798              return this.valueOf() < localInput.valueOf();
3799          } else {
3800              return this.clone().endOf(units).valueOf() < localInput.valueOf();
3801          }
3802      }
3803  
3804      function isBetween(from, to, units, inclusivity) {
3805          var localFrom = isMoment(from) ? from : createLocal(from),
3806              localTo = isMoment(to) ? to : createLocal(to);
3807          if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
3808              return false;
3809          }
3810          inclusivity = inclusivity || '()';
3811          return (
3812              (inclusivity[0] === '('
3813                  ? this.isAfter(localFrom, units)
3814                  : !this.isBefore(localFrom, units)) &&
3815              (inclusivity[1] === ')'
3816                  ? this.isBefore(localTo, units)
3817                  : !this.isAfter(localTo, units))
3818          );
3819      }
3820  
3821      function isSame(input, units) {
3822          var localInput = isMoment(input) ? input : createLocal(input),
3823              inputMs;
3824          if (!(this.isValid() && localInput.isValid())) {
3825              return false;
3826          }
3827          units = normalizeUnits(units) || 'millisecond';
3828          if (units === 'millisecond') {
3829              return this.valueOf() === localInput.valueOf();
3830          } else {
3831              inputMs = localInput.valueOf();
3832              return (
3833                  this.clone().startOf(units).valueOf() <= inputMs &&
3834                  inputMs <= this.clone().endOf(units).valueOf()
3835              );
3836          }
3837      }
3838  
3839      function isSameOrAfter(input, units) {
3840          return this.isSame(input, units) || this.isAfter(input, units);
3841      }
3842  
3843      function isSameOrBefore(input, units) {
3844          return this.isSame(input, units) || this.isBefore(input, units);
3845      }
3846  
3847      function diff(input, units, asFloat) {
3848          var that, zoneDelta, output;
3849  
3850          if (!this.isValid()) {
3851              return NaN;
3852          }
3853  
3854          that = cloneWithOffset(input, this);
3855  
3856          if (!that.isValid()) {
3857              return NaN;
3858          }
3859  
3860          zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
3861  
3862          units = normalizeUnits(units);
3863  
3864          switch (units) {
3865              case 'year':
3866                  output = monthDiff(this, that) / 12;
3867                  break;
3868              case 'month':
3869                  output = monthDiff(this, that);
3870                  break;
3871              case 'quarter':
3872                  output = monthDiff(this, that) / 3;
3873                  break;
3874              case 'second':
3875                  output = (this - that) / 1e3;
3876                  break; // 1000
3877              case 'minute':
3878                  output = (this - that) / 6e4;
3879                  break; // 1000 * 60
3880              case 'hour':
3881                  output = (this - that) / 36e5;
3882                  break; // 1000 * 60 * 60
3883              case 'day':
3884                  output = (this - that - zoneDelta) / 864e5;
3885                  break; // 1000 * 60 * 60 * 24, negate dst
3886              case 'week':
3887                  output = (this - that - zoneDelta) / 6048e5;
3888                  break; // 1000 * 60 * 60 * 24 * 7, negate dst
3889              default:
3890                  output = this - that;
3891          }
3892  
3893          return asFloat ? output : absFloor(output);
3894      }
3895  
3896      function monthDiff(a, b) {
3897          if (a.date() < b.date()) {
3898              // end-of-month calculations work correct when the start month has more
3899              // days than the end month.
3900              return -monthDiff(b, a);
3901          }
3902          // difference in months
3903          var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),
3904              // b is in (anchor - 1 month, anchor + 1 month)
3905              anchor = a.clone().add(wholeMonthDiff, 'months'),
3906              anchor2,
3907              adjust;
3908  
3909          if (b - anchor < 0) {
3910              anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
3911              // linear across the month
3912              adjust = (b - anchor) / (anchor - anchor2);
3913          } else {
3914              anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
3915              // linear across the month
3916              adjust = (b - anchor) / (anchor2 - anchor);
3917          }
3918  
3919          //check for negative zero, return zero if negative zero
3920          return -(wholeMonthDiff + adjust) || 0;
3921      }
3922  
3923      hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
3924      hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
3925  
3926      function toString() {
3927          return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
3928      }
3929  
3930      function toISOString(keepOffset) {
3931          if (!this.isValid()) {
3932              return null;
3933          }
3934          var utc = keepOffset !== true,
3935              m = utc ? this.clone().utc() : this;
3936          if (m.year() < 0 || m.year() > 9999) {
3937              return formatMoment(
3938                  m,
3939                  utc
3940                      ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'
3941                      : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'
3942              );
3943          }
3944          if (isFunction(Date.prototype.toISOString)) {
3945              // native implementation is ~50x faster, use it when we can
3946              if (utc) {
3947                  return this.toDate().toISOString();
3948              } else {
3949                  return new Date(this.valueOf() + this.utcOffset() * 60 * 1000)
3950                      .toISOString()
3951                      .replace('Z', formatMoment(m, 'Z'));
3952              }
3953          }
3954          return formatMoment(
3955              m,
3956              utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'
3957          );
3958      }
3959  
3960      /**
3961       * Return a human readable representation of a moment that can
3962       * also be evaluated to get a new moment which is the same
3963       *
3964       * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
3965       */
3966      function inspect() {
3967          if (!this.isValid()) {
3968              return 'moment.invalid(/* ' + this._i + ' */)';
3969          }
3970          var func = 'moment',
3971              zone = '',
3972              prefix,
3973              year,
3974              datetime,
3975              suffix;
3976          if (!this.isLocal()) {
3977              func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
3978              zone = 'Z';
3979          }
3980          prefix = '[' + func + '("]';
3981          year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';
3982          datetime = '-MM-DD[T]HH:mm:ss.SSS';
3983          suffix = zone + '[")]';
3984  
3985          return this.format(prefix + year + datetime + suffix);
3986      }
3987  
3988      function format(inputString) {
3989          if (!inputString) {
3990              inputString = this.isUtc()
3991                  ? hooks.defaultFormatUtc
3992                  : hooks.defaultFormat;
3993          }
3994          var output = formatMoment(this, inputString);
3995          return this.localeData().postformat(output);
3996      }
3997  
3998      function from(time, withoutSuffix) {
3999          if (
4000              this.isValid() &&
4001              ((isMoment(time) && time.isValid()) || createLocal(time).isValid())
4002          ) {
4003              return createDuration({ to: this, from: time })
4004                  .locale(this.locale())
4005                  .humanize(!withoutSuffix);
4006          } else {
4007              return this.localeData().invalidDate();
4008          }
4009      }
4010  
4011      function fromNow(withoutSuffix) {
4012          return this.from(createLocal(), withoutSuffix);
4013      }
4014  
4015      function to(time, withoutSuffix) {
4016          if (
4017              this.isValid() &&
4018              ((isMoment(time) && time.isValid()) || createLocal(time).isValid())
4019          ) {
4020              return createDuration({ from: this, to: time })
4021                  .locale(this.locale())
4022                  .humanize(!withoutSuffix);
4023          } else {
4024              return this.localeData().invalidDate();
4025          }
4026      }
4027  
4028      function toNow(withoutSuffix) {
4029          return this.to(createLocal(), withoutSuffix);
4030      }
4031  
4032      // If passed a locale key, it will set the locale for this
4033      // instance.  Otherwise, it will return the locale configuration
4034      // variables for this instance.
4035      function locale(key) {
4036          var newLocaleData;
4037  
4038          if (key === undefined) {
4039              return this._locale._abbr;
4040          } else {
4041              newLocaleData = getLocale(key);
4042              if (newLocaleData != null) {
4043                  this._locale = newLocaleData;
4044              }
4045              return this;
4046          }
4047      }
4048  
4049      var lang = deprecate(
4050          'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
4051          function (key) {
4052              if (key === undefined) {
4053                  return this.localeData();
4054              } else {
4055                  return this.locale(key);
4056              }
4057          }
4058      );
4059  
4060      function localeData() {
4061          return this._locale;
4062      }
4063  
4064      var MS_PER_SECOND = 1000,
4065          MS_PER_MINUTE = 60 * MS_PER_SECOND,
4066          MS_PER_HOUR = 60 * MS_PER_MINUTE,
4067          MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
4068  
4069      // actual modulo - handles negative numbers (for dates before 1970):
4070      function mod$1(dividend, divisor) {
4071          return ((dividend % divisor) + divisor) % divisor;
4072      }
4073  
4074      function localStartOfDate(y, m, d) {
4075          // the date constructor remaps years 0-99 to 1900-1999
4076          if (y < 100 && y >= 0) {
4077              // preserve leap years using a full 400 year cycle, then reset
4078              return new Date(y + 400, m, d) - MS_PER_400_YEARS;
4079          } else {
4080              return new Date(y, m, d).valueOf();
4081          }
4082      }
4083  
4084      function utcStartOfDate(y, m, d) {
4085          // Date.UTC remaps years 0-99 to 1900-1999
4086          if (y < 100 && y >= 0) {
4087              // preserve leap years using a full 400 year cycle, then reset
4088              return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
4089          } else {
4090              return Date.UTC(y, m, d);
4091          }
4092      }
4093  
4094      function startOf(units) {
4095          var time, startOfDate;
4096          units = normalizeUnits(units);
4097          if (units === undefined || units === 'millisecond' || !this.isValid()) {
4098              return this;
4099          }
4100  
4101          startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
4102  
4103          switch (units) {
4104              case 'year':
4105                  time = startOfDate(this.year(), 0, 1);
4106                  break;
4107              case 'quarter':
4108                  time = startOfDate(
4109                      this.year(),
4110                      this.month() - (this.month() % 3),
4111                      1
4112                  );
4113                  break;
4114              case 'month':
4115                  time = startOfDate(this.year(), this.month(), 1);
4116                  break;
4117              case 'week':
4118                  time = startOfDate(
4119                      this.year(),
4120                      this.month(),
4121                      this.date() - this.weekday()
4122                  );
4123                  break;
4124              case 'isoWeek':
4125                  time = startOfDate(
4126                      this.year(),
4127                      this.month(),
4128                      this.date() - (this.isoWeekday() - 1)
4129                  );
4130                  break;
4131              case 'day':
4132              case 'date':
4133                  time = startOfDate(this.year(), this.month(), this.date());
4134                  break;
4135              case 'hour':
4136                  time = this._d.valueOf();
4137                  time -= mod$1(
4138                      time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
4139                      MS_PER_HOUR
4140                  );
4141                  break;
4142              case 'minute':
4143                  time = this._d.valueOf();
4144                  time -= mod$1(time, MS_PER_MINUTE);
4145                  break;
4146              case 'second':
4147                  time = this._d.valueOf();
4148                  time -= mod$1(time, MS_PER_SECOND);
4149                  break;
4150          }
4151  
4152          this._d.setTime(time);
4153          hooks.updateOffset(this, true);
4154          return this;
4155      }
4156  
4157      function endOf(units) {
4158          var time, startOfDate;
4159          units = normalizeUnits(units);
4160          if (units === undefined || units === 'millisecond' || !this.isValid()) {
4161              return this;
4162          }
4163  
4164          startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
4165  
4166          switch (units) {
4167              case 'year':
4168                  time = startOfDate(this.year() + 1, 0, 1) - 1;
4169                  break;
4170              case 'quarter':
4171                  time =
4172                      startOfDate(
4173                          this.year(),
4174                          this.month() - (this.month() % 3) + 3,
4175                          1
4176                      ) - 1;
4177                  break;
4178              case 'month':
4179                  time = startOfDate(this.year(), this.month() + 1, 1) - 1;
4180                  break;
4181              case 'week':
4182                  time =
4183                      startOfDate(
4184                          this.year(),
4185                          this.month(),
4186                          this.date() - this.weekday() + 7
4187                      ) - 1;
4188                  break;
4189              case 'isoWeek':
4190                  time =
4191                      startOfDate(
4192                          this.year(),
4193                          this.month(),
4194                          this.date() - (this.isoWeekday() - 1) + 7
4195                      ) - 1;
4196                  break;
4197              case 'day':
4198              case 'date':
4199                  time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
4200                  break;
4201              case 'hour':
4202                  time = this._d.valueOf();
4203                  time +=
4204                      MS_PER_HOUR -
4205                      mod$1(
4206                          time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
4207                          MS_PER_HOUR
4208                      ) -
4209                      1;
4210                  break;
4211              case 'minute':
4212                  time = this._d.valueOf();
4213                  time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
4214                  break;
4215              case 'second':
4216                  time = this._d.valueOf();
4217                  time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
4218                  break;
4219          }
4220  
4221          this._d.setTime(time);
4222          hooks.updateOffset(this, true);
4223          return this;
4224      }
4225  
4226      function valueOf() {
4227          return this._d.valueOf() - (this._offset || 0) * 60000;
4228      }
4229  
4230      function unix() {
4231          return Math.floor(this.valueOf() / 1000);
4232      }
4233  
4234      function toDate() {
4235          return new Date(this.valueOf());
4236      }
4237  
4238      function toArray() {
4239          var m = this;
4240          return [
4241              m.year(),
4242              m.month(),
4243              m.date(),
4244              m.hour(),
4245              m.minute(),
4246              m.second(),
4247              m.millisecond(),
4248          ];
4249      }
4250  
4251      function toObject() {
4252          var m = this;
4253          return {
4254              years: m.year(),
4255              months: m.month(),
4256              date: m.date(),
4257              hours: m.hours(),
4258              minutes: m.minutes(),
4259              seconds: m.seconds(),
4260              milliseconds: m.milliseconds(),
4261          };
4262      }
4263  
4264      function toJSON() {
4265          // new Date(NaN).toJSON() === null
4266          return this.isValid() ? this.toISOString() : null;
4267      }
4268  
4269      function isValid$2() {
4270          return isValid(this);
4271      }
4272  
4273      function parsingFlags() {
4274          return extend({}, getParsingFlags(this));
4275      }
4276  
4277      function invalidAt() {
4278          return getParsingFlags(this).overflow;
4279      }
4280  
4281      function creationData() {
4282          return {
4283              input: this._i,
4284              format: this._f,
4285              locale: this._locale,
4286              isUTC: this._isUTC,
4287              strict: this._strict,
4288          };
4289      }
4290  
4291      addFormatToken('N', 0, 0, 'eraAbbr');
4292      addFormatToken('NN', 0, 0, 'eraAbbr');
4293      addFormatToken('NNN', 0, 0, 'eraAbbr');
4294      addFormatToken('NNNN', 0, 0, 'eraName');
4295      addFormatToken('NNNNN', 0, 0, 'eraNarrow');
4296  
4297      addFormatToken('y', ['y', 1], 'yo', 'eraYear');
4298      addFormatToken('y', ['yy', 2], 0, 'eraYear');
4299      addFormatToken('y', ['yyy', 3], 0, 'eraYear');
4300      addFormatToken('y', ['yyyy', 4], 0, 'eraYear');
4301  
4302      addRegexToken('N', matchEraAbbr);
4303      addRegexToken('NN', matchEraAbbr);
4304      addRegexToken('NNN', matchEraAbbr);
4305      addRegexToken('NNNN', matchEraName);
4306      addRegexToken('NNNNN', matchEraNarrow);
4307  
4308      addParseToken(
4309          ['N', 'NN', 'NNN', 'NNNN', 'NNNNN'],
4310          function (input, array, config, token) {
4311              var era = config._locale.erasParse(input, token, config._strict);
4312              if (era) {
4313                  getParsingFlags(config).era = era;
4314              } else {
4315                  getParsingFlags(config).invalidEra = input;
4316              }
4317          }
4318      );
4319  
4320      addRegexToken('y', matchUnsigned);
4321      addRegexToken('yy', matchUnsigned);
4322      addRegexToken('yyy', matchUnsigned);
4323      addRegexToken('yyyy', matchUnsigned);
4324      addRegexToken('yo', matchEraYearOrdinal);
4325  
4326      addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR);
4327      addParseToken(['yo'], function (input, array, config, token) {
4328          var match;
4329          if (config._locale._eraYearOrdinalRegex) {
4330              match = input.match(config._locale._eraYearOrdinalRegex);
4331          }
4332  
4333          if (config._locale.eraYearOrdinalParse) {
4334              array[YEAR] = config._locale.eraYearOrdinalParse(input, match);
4335          } else {
4336              array[YEAR] = parseInt(input, 10);
4337          }
4338      });
4339  
4340      function localeEras(m, format) {
4341          var i,
4342              l,
4343              date,
4344              eras = this._eras || getLocale('en')._eras;
4345          for (i = 0, l = eras.length; i < l; ++i) {
4346              switch (typeof eras[i].since) {
4347                  case 'string':
4348                      // truncate time
4349                      date = hooks(eras[i].since).startOf('day');
4350                      eras[i].since = date.valueOf();
4351                      break;
4352              }
4353  
4354              switch (typeof eras[i].until) {
4355                  case 'undefined':
4356                      eras[i].until = +Infinity;
4357                      break;
4358                  case 'string':
4359                      // truncate time
4360                      date = hooks(eras[i].until).startOf('day').valueOf();
4361                      eras[i].until = date.valueOf();
4362                      break;
4363              }
4364          }
4365          return eras;
4366      }
4367  
4368      function localeErasParse(eraName, format, strict) {
4369          var i,
4370              l,
4371              eras = this.eras(),
4372              name,
4373              abbr,
4374              narrow;
4375          eraName = eraName.toUpperCase();
4376  
4377          for (i = 0, l = eras.length; i < l; ++i) {
4378              name = eras[i].name.toUpperCase();
4379              abbr = eras[i].abbr.toUpperCase();
4380              narrow = eras[i].narrow.toUpperCase();
4381  
4382              if (strict) {
4383                  switch (format) {
4384                      case 'N':
4385                      case 'NN':
4386                      case 'NNN':
4387                          if (abbr === eraName) {
4388                              return eras[i];
4389                          }
4390                          break;
4391  
4392                      case 'NNNN':
4393                          if (name === eraName) {
4394                              return eras[i];
4395                          }
4396                          break;
4397  
4398                      case 'NNNNN':
4399                          if (narrow === eraName) {
4400                              return eras[i];
4401                          }
4402                          break;
4403                  }
4404              } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
4405                  return eras[i];
4406              }
4407          }
4408      }
4409  
4410      function localeErasConvertYear(era, year) {
4411          var dir = era.since <= era.until ? +1 : -1;
4412          if (year === undefined) {
4413              return hooks(era.since).year();
4414          } else {
4415              return hooks(era.since).year() + (year - era.offset) * dir;
4416          }
4417      }
4418  
4419      function getEraName() {
4420          var i,
4421              l,
4422              val,
4423              eras = this.localeData().eras();
4424          for (i = 0, l = eras.length; i < l; ++i) {
4425              // truncate time
4426              val = this.clone().startOf('day').valueOf();
4427  
4428              if (eras[i].since <= val && val <= eras[i].until) {
4429                  return eras[i].name;
4430              }
4431              if (eras[i].until <= val && val <= eras[i].since) {
4432                  return eras[i].name;
4433              }
4434          }
4435  
4436          return '';
4437      }
4438  
4439      function getEraNarrow() {
4440          var i,
4441              l,
4442              val,
4443              eras = this.localeData().eras();
4444          for (i = 0, l = eras.length; i < l; ++i) {
4445              // truncate time
4446              val = this.clone().startOf('day').valueOf();
4447  
4448              if (eras[i].since <= val && val <= eras[i].until) {
4449                  return eras[i].narrow;
4450              }
4451              if (eras[i].until <= val && val <= eras[i].since) {
4452                  return eras[i].narrow;
4453              }
4454          }
4455  
4456          return '';
4457      }
4458  
4459      function getEraAbbr() {
4460          var i,
4461              l,
4462              val,
4463              eras = this.localeData().eras();
4464          for (i = 0, l = eras.length; i < l; ++i) {
4465              // truncate time
4466              val = this.clone().startOf('day').valueOf();
4467  
4468              if (eras[i].since <= val && val <= eras[i].until) {
4469                  return eras[i].abbr;
4470              }
4471              if (eras[i].until <= val && val <= eras[i].since) {
4472                  return eras[i].abbr;
4473              }
4474          }
4475  
4476          return '';
4477      }
4478  
4479      function getEraYear() {
4480          var i,
4481              l,
4482              dir,
4483              val,
4484              eras = this.localeData().eras();
4485          for (i = 0, l = eras.length; i < l; ++i) {
4486              dir = eras[i].since <= eras[i].until ? +1 : -1;
4487  
4488              // truncate time
4489              val = this.clone().startOf('day').valueOf();
4490  
4491              if (
4492                  (eras[i].since <= val && val <= eras[i].until) ||
4493                  (eras[i].until <= val && val <= eras[i].since)
4494              ) {
4495                  return (
4496                      (this.year() - hooks(eras[i].since).year()) * dir +
4497                      eras[i].offset
4498                  );
4499              }
4500          }
4501  
4502          return this.year();
4503      }
4504  
4505      function erasNameRegex(isStrict) {
4506          if (!hasOwnProp(this, '_erasNameRegex')) {
4507              computeErasParse.call(this);
4508          }
4509          return isStrict ? this._erasNameRegex : this._erasRegex;
4510      }
4511  
4512      function erasAbbrRegex(isStrict) {
4513          if (!hasOwnProp(this, '_erasAbbrRegex')) {
4514              computeErasParse.call(this);
4515          }
4516          return isStrict ? this._erasAbbrRegex : this._erasRegex;
4517      }
4518  
4519      function erasNarrowRegex(isStrict) {
4520          if (!hasOwnProp(this, '_erasNarrowRegex')) {
4521              computeErasParse.call(this);
4522          }
4523          return isStrict ? this._erasNarrowRegex : this._erasRegex;
4524      }
4525  
4526      function matchEraAbbr(isStrict, locale) {
4527          return locale.erasAbbrRegex(isStrict);
4528      }
4529  
4530      function matchEraName(isStrict, locale) {
4531          return locale.erasNameRegex(isStrict);
4532      }
4533  
4534      function matchEraNarrow(isStrict, locale) {
4535          return locale.erasNarrowRegex(isStrict);
4536      }
4537  
4538      function matchEraYearOrdinal(isStrict, locale) {
4539          return locale._eraYearOrdinalRegex || matchUnsigned;
4540      }
4541  
4542      function computeErasParse() {
4543          var abbrPieces = [],
4544              namePieces = [],
4545              narrowPieces = [],
4546              mixedPieces = [],
4547              i,
4548              l,
4549              eras = this.eras();
4550  
4551          for (i = 0, l = eras.length; i < l; ++i) {
4552              namePieces.push(regexEscape(eras[i].name));
4553              abbrPieces.push(regexEscape(eras[i].abbr));
4554              narrowPieces.push(regexEscape(eras[i].narrow));
4555  
4556              mixedPieces.push(regexEscape(eras[i].name));
4557              mixedPieces.push(regexEscape(eras[i].abbr));
4558              mixedPieces.push(regexEscape(eras[i].narrow));
4559          }
4560  
4561          this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
4562          this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i');
4563          this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i');
4564          this._erasNarrowRegex = new RegExp(
4565              '^(' + narrowPieces.join('|') + ')',
4566              'i'
4567          );
4568      }
4569  
4570      // FORMATTING
4571  
4572      addFormatToken(0, ['gg', 2], 0, function () {
4573          return this.weekYear() % 100;
4574      });
4575  
4576      addFormatToken(0, ['GG', 2], 0, function () {
4577          return this.isoWeekYear() % 100;
4578      });
4579  
4580      function addWeekYearFormatToken(token, getter) {
4581          addFormatToken(0, [token, token.length], 0, getter);
4582      }
4583  
4584      addWeekYearFormatToken('gggg', 'weekYear');
4585      addWeekYearFormatToken('ggggg', 'weekYear');
4586      addWeekYearFormatToken('GGGG', 'isoWeekYear');
4587      addWeekYearFormatToken('GGGGG', 'isoWeekYear');
4588  
4589      // ALIASES
4590  
4591      addUnitAlias('weekYear', 'gg');
4592      addUnitAlias('isoWeekYear', 'GG');
4593  
4594      // PRIORITY
4595  
4596      addUnitPriority('weekYear', 1);
4597      addUnitPriority('isoWeekYear', 1);
4598  
4599      // PARSING
4600  
4601      addRegexToken('G', matchSigned);
4602      addRegexToken('g', matchSigned);
4603      addRegexToken('GG', match1to2, match2);
4604      addRegexToken('gg', match1to2, match2);
4605      addRegexToken('GGGG', match1to4, match4);
4606      addRegexToken('gggg', match1to4, match4);
4607      addRegexToken('GGGGG', match1to6, match6);
4608      addRegexToken('ggggg', match1to6, match6);
4609  
4610      addWeekParseToken(
4611          ['gggg', 'ggggg', 'GGGG', 'GGGGG'],
4612          function (input, week, config, token) {
4613              week[token.substr(0, 2)] = toInt(input);
4614          }
4615      );
4616  
4617      addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
4618          week[token] = hooks.parseTwoDigitYear(input);
4619      });
4620  
4621      // MOMENTS
4622  
4623      function getSetWeekYear(input) {
4624          return getSetWeekYearHelper.call(
4625              this,
4626              input,
4627              this.week(),
4628              this.weekday(),
4629              this.localeData()._week.dow,
4630              this.localeData()._week.doy
4631          );
4632      }
4633  
4634      function getSetISOWeekYear(input) {
4635          return getSetWeekYearHelper.call(
4636              this,
4637              input,
4638              this.isoWeek(),
4639              this.isoWeekday(),
4640              1,
4641              4
4642          );
4643      }
4644  
4645      function getISOWeeksInYear() {
4646          return weeksInYear(this.year(), 1, 4);
4647      }
4648  
4649      function getISOWeeksInISOWeekYear() {
4650          return weeksInYear(this.isoWeekYear(), 1, 4);
4651      }
4652  
4653      function getWeeksInYear() {
4654          var weekInfo = this.localeData()._week;
4655          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
4656      }
4657  
4658      function getWeeksInWeekYear() {
4659          var weekInfo = this.localeData()._week;
4660          return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
4661      }
4662  
4663      function getSetWeekYearHelper(input, week, weekday, dow, doy) {
4664          var weeksTarget;
4665          if (input == null) {
4666              return weekOfYear(this, dow, doy).year;
4667          } else {
4668              weeksTarget = weeksInYear(input, dow, doy);
4669              if (week > weeksTarget) {
4670                  week = weeksTarget;
4671              }
4672              return setWeekAll.call(this, input, week, weekday, dow, doy);
4673          }
4674      }
4675  
4676      function setWeekAll(weekYear, week, weekday, dow, doy) {
4677          var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
4678              date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
4679  
4680          this.year(date.getUTCFullYear());
4681          this.month(date.getUTCMonth());
4682          this.date(date.getUTCDate());
4683          return this;
4684      }
4685  
4686      // FORMATTING
4687  
4688      addFormatToken('Q', 0, 'Qo', 'quarter');
4689  
4690      // ALIASES
4691  
4692      addUnitAlias('quarter', 'Q');
4693  
4694      // PRIORITY
4695  
4696      addUnitPriority('quarter', 7);
4697  
4698      // PARSING
4699  
4700      addRegexToken('Q', match1);
4701      addParseToken('Q', function (input, array) {
4702          array[MONTH] = (toInt(input) - 1) * 3;
4703      });
4704  
4705      // MOMENTS
4706  
4707      function getSetQuarter(input) {
4708          return input == null
4709              ? Math.ceil((this.month() + 1) / 3)
4710              : this.month((input - 1) * 3 + (this.month() % 3));
4711      }
4712  
4713      // FORMATTING
4714  
4715      addFormatToken('D', ['DD', 2], 'Do', 'date');
4716  
4717      // ALIASES
4718  
4719      addUnitAlias('date', 'D');
4720  
4721      // PRIORITY
4722      addUnitPriority('date', 9);
4723  
4724      // PARSING
4725  
4726      addRegexToken('D', match1to2);
4727      addRegexToken('DD', match1to2, match2);
4728      addRegexToken('Do', function (isStrict, locale) {
4729          // TODO: Remove "ordinalParse" fallback in next major release.
4730          return isStrict
4731              ? locale._dayOfMonthOrdinalParse || locale._ordinalParse
4732              : locale._dayOfMonthOrdinalParseLenient;
4733      });
4734  
4735      addParseToken(['D', 'DD'], DATE);
4736      addParseToken('Do', function (input, array) {
4737          array[DATE] = toInt(input.match(match1to2)[0]);
4738      });
4739  
4740      // MOMENTS
4741  
4742      var getSetDayOfMonth = makeGetSet('Date', true);
4743  
4744      // FORMATTING
4745  
4746      addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
4747  
4748      // ALIASES
4749  
4750      addUnitAlias('dayOfYear', 'DDD');
4751  
4752      // PRIORITY
4753      addUnitPriority('dayOfYear', 4);
4754  
4755      // PARSING
4756  
4757      addRegexToken('DDD', match1to3);
4758      addRegexToken('DDDD', match3);
4759      addParseToken(['DDD', 'DDDD'], function (input, array, config) {
4760          config._dayOfYear = toInt(input);
4761      });
4762  
4763      // HELPERS
4764  
4765      // MOMENTS
4766  
4767      function getSetDayOfYear(input) {
4768          var dayOfYear =
4769              Math.round(
4770                  (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5
4771              ) + 1;
4772          return input == null ? dayOfYear : this.add(input - dayOfYear, 'd');
4773      }
4774  
4775      // FORMATTING
4776  
4777      addFormatToken('m', ['mm', 2], 0, 'minute');
4778  
4779      // ALIASES
4780  
4781      addUnitAlias('minute', 'm');
4782  
4783      // PRIORITY
4784  
4785      addUnitPriority('minute', 14);
4786  
4787      // PARSING
4788  
4789      addRegexToken('m', match1to2);
4790      addRegexToken('mm', match1to2, match2);
4791      addParseToken(['m', 'mm'], MINUTE);
4792  
4793      // MOMENTS
4794  
4795      var getSetMinute = makeGetSet('Minutes', false);
4796  
4797      // FORMATTING
4798  
4799      addFormatToken('s', ['ss', 2], 0, 'second');
4800  
4801      // ALIASES
4802  
4803      addUnitAlias('second', 's');
4804  
4805      // PRIORITY
4806  
4807      addUnitPriority('second', 15);
4808  
4809      // PARSING
4810  
4811      addRegexToken('s', match1to2);
4812      addRegexToken('ss', match1to2, match2);
4813      addParseToken(['s', 'ss'], SECOND);
4814  
4815      // MOMENTS
4816  
4817      var getSetSecond = makeGetSet('Seconds', false);
4818  
4819      // FORMATTING
4820  
4821      addFormatToken('S', 0, 0, function () {
4822          return ~~(this.millisecond() / 100);
4823      });
4824  
4825      addFormatToken(0, ['SS', 2], 0, function () {
4826          return ~~(this.millisecond() / 10);
4827      });
4828  
4829      addFormatToken(0, ['SSS', 3], 0, 'millisecond');
4830      addFormatToken(0, ['SSSS', 4], 0, function () {
4831          return this.millisecond() * 10;
4832      });
4833      addFormatToken(0, ['SSSSS', 5], 0, function () {
4834          return this.millisecond() * 100;
4835      });
4836      addFormatToken(0, ['SSSSSS', 6], 0, function () {
4837          return this.millisecond() * 1000;
4838      });
4839      addFormatToken(0, ['SSSSSSS', 7], 0, function () {
4840          return this.millisecond() * 10000;
4841      });
4842      addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
4843          return this.millisecond() * 100000;
4844      });
4845      addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
4846          return this.millisecond() * 1000000;
4847      });
4848  
4849      // ALIASES
4850  
4851      addUnitAlias('millisecond', 'ms');
4852  
4853      // PRIORITY
4854  
4855      addUnitPriority('millisecond', 16);
4856  
4857      // PARSING
4858  
4859      addRegexToken('S', match1to3, match1);
4860      addRegexToken('SS', match1to3, match2);
4861      addRegexToken('SSS', match1to3, match3);
4862  
4863      var token, getSetMillisecond;
4864      for (token = 'SSSS'; token.length <= 9; token += 'S') {
4865          addRegexToken(token, matchUnsigned);
4866      }
4867  
4868      function parseMs(input, array) {
4869          array[MILLISECOND] = toInt(('0.' + input) * 1000);
4870      }
4871  
4872      for (token = 'S'; token.length <= 9; token += 'S') {
4873          addParseToken(token, parseMs);
4874      }
4875  
4876      getSetMillisecond = makeGetSet('Milliseconds', false);
4877  
4878      // FORMATTING
4879  
4880      addFormatToken('z', 0, 0, 'zoneAbbr');
4881      addFormatToken('zz', 0, 0, 'zoneName');
4882  
4883      // MOMENTS
4884  
4885      function getZoneAbbr() {
4886          return this._isUTC ? 'UTC' : '';
4887      }
4888  
4889      function getZoneName() {
4890          return this._isUTC ? 'Coordinated Universal Time' : '';
4891      }
4892  
4893      var proto = Moment.prototype;
4894  
4895      proto.add = add;
4896      proto.calendar = calendar$1;
4897      proto.clone = clone;
4898      proto.diff = diff;
4899      proto.endOf = endOf;
4900      proto.format = format;
4901      proto.from = from;
4902      proto.fromNow = fromNow;
4903      proto.to = to;
4904      proto.toNow = toNow;
4905      proto.get = stringGet;
4906      proto.invalidAt = invalidAt;
4907      proto.isAfter = isAfter;
4908      proto.isBefore = isBefore;
4909      proto.isBetween = isBetween;
4910      proto.isSame = isSame;
4911      proto.isSameOrAfter = isSameOrAfter;
4912      proto.isSameOrBefore = isSameOrBefore;
4913      proto.isValid = isValid$2;
4914      proto.lang = lang;
4915      proto.locale = locale;
4916      proto.localeData = localeData;
4917      proto.max = prototypeMax;
4918      proto.min = prototypeMin;
4919      proto.parsingFlags = parsingFlags;
4920      proto.set = stringSet;
4921      proto.startOf = startOf;
4922      proto.subtract = subtract;
4923      proto.toArray = toArray;
4924      proto.toObject = toObject;
4925      proto.toDate = toDate;
4926      proto.toISOString = toISOString;
4927      proto.inspect = inspect;
4928      if (typeof Symbol !== 'undefined' && Symbol.for != null) {
4929          proto[Symbol.for('nodejs.util.inspect.custom')] = function () {
4930              return 'Moment<' + this.format() + '>';
4931          };
4932      }
4933      proto.toJSON = toJSON;
4934      proto.toString = toString;
4935      proto.unix = unix;
4936      proto.valueOf = valueOf;
4937      proto.creationData = creationData;
4938      proto.eraName = getEraName;
4939      proto.eraNarrow = getEraNarrow;
4940      proto.eraAbbr = getEraAbbr;
4941      proto.eraYear = getEraYear;
4942      proto.year = getSetYear;
4943      proto.isLeapYear = getIsLeapYear;
4944      proto.weekYear = getSetWeekYear;
4945      proto.isoWeekYear = getSetISOWeekYear;
4946      proto.quarter = proto.quarters = getSetQuarter;
4947      proto.month = getSetMonth;
4948      proto.daysInMonth = getDaysInMonth;
4949      proto.week = proto.weeks = getSetWeek;
4950      proto.isoWeek = proto.isoWeeks = getSetISOWeek;
4951      proto.weeksInYear = getWeeksInYear;
4952      proto.weeksInWeekYear = getWeeksInWeekYear;
4953      proto.isoWeeksInYear = getISOWeeksInYear;
4954      proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
4955      proto.date = getSetDayOfMonth;
4956      proto.day = proto.days = getSetDayOfWeek;
4957      proto.weekday = getSetLocaleDayOfWeek;
4958      proto.isoWeekday = getSetISODayOfWeek;
4959      proto.dayOfYear = getSetDayOfYear;
4960      proto.hour = proto.hours = getSetHour;
4961      proto.minute = proto.minutes = getSetMinute;
4962      proto.second = proto.seconds = getSetSecond;
4963      proto.millisecond = proto.milliseconds = getSetMillisecond;
4964      proto.utcOffset = getSetOffset;
4965      proto.utc = setOffsetToUTC;
4966      proto.local = setOffsetToLocal;
4967      proto.parseZone = setOffsetToParsedOffset;
4968      proto.hasAlignedHourOffset = hasAlignedHourOffset;
4969      proto.isDST = isDaylightSavingTime;
4970      proto.isLocal = isLocal;
4971      proto.isUtcOffset = isUtcOffset;
4972      proto.isUtc = isUtc;
4973      proto.isUTC = isUtc;
4974      proto.zoneAbbr = getZoneAbbr;
4975      proto.zoneName = getZoneName;
4976      proto.dates = deprecate(
4977          'dates accessor is deprecated. Use date instead.',
4978          getSetDayOfMonth
4979      );
4980      proto.months = deprecate(
4981          'months accessor is deprecated. Use month instead',
4982          getSetMonth
4983      );
4984      proto.years = deprecate(
4985          'years accessor is deprecated. Use year instead',
4986          getSetYear
4987      );
4988      proto.zone = deprecate(
4989          'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
4990          getSetZone
4991      );
4992      proto.isDSTShifted = deprecate(
4993          'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
4994          isDaylightSavingTimeShifted
4995      );
4996  
4997      function createUnix(input) {
4998          return createLocal(input * 1000);
4999      }
5000  
5001      function createInZone() {
5002          return createLocal.apply(null, arguments).parseZone();
5003      }
5004  
5005      function preParsePostFormat(string) {
5006          return string;
5007      }
5008  
5009      var proto$1 = Locale.prototype;
5010  
5011      proto$1.calendar = calendar;
5012      proto$1.longDateFormat = longDateFormat;
5013      proto$1.invalidDate = invalidDate;
5014      proto$1.ordinal = ordinal;
5015      proto$1.preparse = preParsePostFormat;
5016      proto$1.postformat = preParsePostFormat;
5017      proto$1.relativeTime = relativeTime;
5018      proto$1.pastFuture = pastFuture;
5019      proto$1.set = set;
5020      proto$1.eras = localeEras;
5021      proto$1.erasParse = localeErasParse;
5022      proto$1.erasConvertYear = localeErasConvertYear;
5023      proto$1.erasAbbrRegex = erasAbbrRegex;
5024      proto$1.erasNameRegex = erasNameRegex;
5025      proto$1.erasNarrowRegex = erasNarrowRegex;
5026  
5027      proto$1.months = localeMonths;
5028      proto$1.monthsShort = localeMonthsShort;
5029      proto$1.monthsParse = localeMonthsParse;
5030      proto$1.monthsRegex = monthsRegex;
5031      proto$1.monthsShortRegex = monthsShortRegex;
5032      proto$1.week = localeWeek;
5033      proto$1.firstDayOfYear = localeFirstDayOfYear;
5034      proto$1.firstDayOfWeek = localeFirstDayOfWeek;
5035  
5036      proto$1.weekdays = localeWeekdays;
5037      proto$1.weekdaysMin = localeWeekdaysMin;
5038      proto$1.weekdaysShort = localeWeekdaysShort;
5039      proto$1.weekdaysParse = localeWeekdaysParse;
5040  
5041      proto$1.weekdaysRegex = weekdaysRegex;
5042      proto$1.weekdaysShortRegex = weekdaysShortRegex;
5043      proto$1.weekdaysMinRegex = weekdaysMinRegex;
5044  
5045      proto$1.isPM = localeIsPM;
5046      proto$1.meridiem = localeMeridiem;
5047  
5048      function get$1(format, index, field, setter) {
5049          var locale = getLocale(),
5050              utc = createUTC().set(setter, index);
5051          return locale[field](utc, format);
5052      }
5053  
5054      function listMonthsImpl(format, index, field) {
5055          if (isNumber(format)) {
5056              index = format;
5057              format = undefined;
5058          }
5059  
5060          format = format || '';
5061  
5062          if (index != null) {
5063              return get$1(format, index, field, 'month');
5064          }
5065  
5066          var i,
5067              out = [];
5068          for (i = 0; i < 12; i++) {
5069              out[i] = get$1(format, i, field, 'month');
5070          }
5071          return out;
5072      }
5073  
5074      // ()
5075      // (5)
5076      // (fmt, 5)
5077      // (fmt)
5078      // (true)
5079      // (true, 5)
5080      // (true, fmt, 5)
5081      // (true, fmt)
5082      function listWeekdaysImpl(localeSorted, format, index, field) {
5083          if (typeof localeSorted === 'boolean') {
5084              if (isNumber(format)) {
5085                  index = format;
5086                  format = undefined;
5087              }
5088  
5089              format = format || '';
5090          } else {
5091              format = localeSorted;
5092              index = format;
5093              localeSorted = false;
5094  
5095              if (isNumber(format)) {
5096                  index = format;
5097                  format = undefined;
5098              }
5099  
5100              format = format || '';
5101          }
5102  
5103          var locale = getLocale(),
5104              shift = localeSorted ? locale._week.dow : 0,
5105              i,
5106              out = [];
5107  
5108          if (index != null) {
5109              return get$1(format, (index + shift) % 7, field, 'day');
5110          }
5111  
5112          for (i = 0; i < 7; i++) {
5113              out[i] = get$1(format, (i + shift) % 7, field, 'day');
5114          }
5115          return out;
5116      }
5117  
5118      function listMonths(format, index) {
5119          return listMonthsImpl(format, index, 'months');
5120      }
5121  
5122      function listMonthsShort(format, index) {
5123          return listMonthsImpl(format, index, 'monthsShort');
5124      }
5125  
5126      function listWeekdays(localeSorted, format, index) {
5127          return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
5128      }
5129  
5130      function listWeekdaysShort(localeSorted, format, index) {
5131          return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
5132      }
5133  
5134      function listWeekdaysMin(localeSorted, format, index) {
5135          return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
5136      }
5137  
5138      getSetGlobalLocale('en', {
5139          eras: [
5140              {
5141                  since: '0001-01-01',
5142                  until: +Infinity,
5143                  offset: 1,
5144                  name: 'Anno Domini',
5145                  narrow: 'AD',
5146                  abbr: 'AD',
5147              },
5148              {
5149                  since: '0000-12-31',
5150                  until: -Infinity,
5151                  offset: 1,
5152                  name: 'Before Christ',
5153                  narrow: 'BC',
5154                  abbr: 'BC',
5155              },
5156          ],
5157          dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
5158          ordinal: function (number) {
5159              var b = number % 10,
5160                  output =
5161                      toInt((number % 100) / 10) === 1
5162                          ? 'th'
5163                          : b === 1
5164                          ? 'st'
5165                          : b === 2
5166                          ? 'nd'
5167                          : b === 3
5168                          ? 'rd'
5169                          : 'th';
5170              return number + output;
5171          },
5172      });
5173  
5174      // Side effect imports
5175  
5176      hooks.lang = deprecate(
5177          'moment.lang is deprecated. Use moment.locale instead.',
5178          getSetGlobalLocale
5179      );
5180      hooks.langData = deprecate(
5181          'moment.langData is deprecated. Use moment.localeData instead.',
5182          getLocale
5183      );
5184  
5185      var mathAbs = Math.abs;
5186  
5187      function abs() {
5188          var data = this._data;
5189  
5190          this._milliseconds = mathAbs(this._milliseconds);
5191          this._days = mathAbs(this._days);
5192          this._months = mathAbs(this._months);
5193  
5194          data.milliseconds = mathAbs(data.milliseconds);
5195          data.seconds = mathAbs(data.seconds);
5196          data.minutes = mathAbs(data.minutes);
5197          data.hours = mathAbs(data.hours);
5198          data.months = mathAbs(data.months);
5199          data.years = mathAbs(data.years);
5200  
5201          return this;
5202      }
5203  
5204      function addSubtract$1(duration, input, value, direction) {
5205          var other = createDuration(input, value);
5206  
5207          duration._milliseconds += direction * other._milliseconds;
5208          duration._days += direction * other._days;
5209          duration._months += direction * other._months;
5210  
5211          return duration._bubble();
5212      }
5213  
5214      // supports only 2.0-style add(1, 's') or add(duration)
5215      function add$1(input, value) {
5216          return addSubtract$1(this, input, value, 1);
5217      }
5218  
5219      // supports only 2.0-style subtract(1, 's') or subtract(duration)
5220      function subtract$1(input, value) {
5221          return addSubtract$1(this, input, value, -1);
5222      }
5223  
5224      function absCeil(number) {
5225          if (number < 0) {
5226              return Math.floor(number);
5227          } else {
5228              return Math.ceil(number);
5229          }
5230      }
5231  
5232      function bubble() {
5233          var milliseconds = this._milliseconds,
5234              days = this._days,
5235              months = this._months,
5236              data = this._data,
5237              seconds,
5238              minutes,
5239              hours,
5240              years,
5241              monthsFromDays;
5242  
5243          // if we have a mix of positive and negative values, bubble down first
5244          // check: https://github.com/moment/moment/issues/2166
5245          if (
5246              !(
5247                  (milliseconds >= 0 && days >= 0 && months >= 0) ||
5248                  (milliseconds <= 0 && days <= 0 && months <= 0)
5249              )
5250          ) {
5251              milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
5252              days = 0;
5253              months = 0;
5254          }
5255  
5256          // The following code bubbles up values, see the tests for
5257          // examples of what that means.
5258          data.milliseconds = milliseconds % 1000;
5259  
5260          seconds = absFloor(milliseconds / 1000);
5261          data.seconds = seconds % 60;
5262  
5263          minutes = absFloor(seconds / 60);
5264          data.minutes = minutes % 60;
5265  
5266          hours = absFloor(minutes / 60);
5267          data.hours = hours % 24;
5268  
5269          days += absFloor(hours / 24);
5270  
5271          // convert days to months
5272          monthsFromDays = absFloor(daysToMonths(days));
5273          months += monthsFromDays;
5274          days -= absCeil(monthsToDays(monthsFromDays));
5275  
5276          // 12 months -> 1 year
5277          years = absFloor(months / 12);
5278          months %= 12;
5279  
5280          data.days = days;
5281          data.months = months;
5282          data.years = years;
5283  
5284          return this;
5285      }
5286  
5287      function daysToMonths(days) {
5288          // 400 years have 146097 days (taking into account leap year rules)
5289          // 400 years have 12 months === 4800
5290          return (days * 4800) / 146097;
5291      }
5292  
5293      function monthsToDays(months) {
5294          // the reverse of daysToMonths
5295          return (months * 146097) / 4800;
5296      }
5297  
5298      function as(units) {
5299          if (!this.isValid()) {
5300              return NaN;
5301          }
5302          var days,
5303              months,
5304              milliseconds = this._milliseconds;
5305  
5306          units = normalizeUnits(units);
5307  
5308          if (units === 'month' || units === 'quarter' || units === 'year') {
5309              days = this._days + milliseconds / 864e5;
5310              months = this._months + daysToMonths(days);
5311              switch (units) {
5312                  case 'month':
5313                      return months;
5314                  case 'quarter':
5315                      return months / 3;
5316                  case 'year':
5317                      return months / 12;
5318              }
5319          } else {
5320              // handle milliseconds separately because of floating point math errors (issue #1867)
5321              days = this._days + Math.round(monthsToDays(this._months));
5322              switch (units) {
5323                  case 'week':
5324                      return days / 7 + milliseconds / 6048e5;
5325                  case 'day':
5326                      return days + milliseconds / 864e5;
5327                  case 'hour':
5328                      return days * 24 + milliseconds / 36e5;
5329                  case 'minute':
5330                      return days * 1440 + milliseconds / 6e4;
5331                  case 'second':
5332                      return days * 86400 + milliseconds / 1000;
5333                  // Math.floor prevents floating point math errors here
5334                  case 'millisecond':
5335                      return Math.floor(days * 864e5) + milliseconds;
5336                  default:
5337                      throw new Error('Unknown unit ' + units);
5338              }
5339          }
5340      }
5341  
5342      // TODO: Use this.as('ms')?
5343      function valueOf$1() {
5344          if (!this.isValid()) {
5345              return NaN;
5346          }
5347          return (
5348              this._milliseconds +
5349              this._days * 864e5 +
5350              (this._months % 12) * 2592e6 +
5351              toInt(this._months / 12) * 31536e6
5352          );
5353      }
5354  
5355      function makeAs(alias) {
5356          return function () {
5357              return this.as(alias);
5358          };
5359      }
5360  
5361      var asMilliseconds = makeAs('ms'),
5362          asSeconds = makeAs('s'),
5363          asMinutes = makeAs('m'),
5364          asHours = makeAs('h'),
5365          asDays = makeAs('d'),
5366          asWeeks = makeAs('w'),
5367          asMonths = makeAs('M'),
5368          asQuarters = makeAs('Q'),
5369          asYears = makeAs('y');
5370  
5371      function clone$1() {
5372          return createDuration(this);
5373      }
5374  
5375      function get$2(units) {
5376          units = normalizeUnits(units);
5377          return this.isValid() ? this[units + 's']() : NaN;
5378      }
5379  
5380      function makeGetter(name) {
5381          return function () {
5382              return this.isValid() ? this._data[name] : NaN;
5383          };
5384      }
5385  
5386      var milliseconds = makeGetter('milliseconds'),
5387          seconds = makeGetter('seconds'),
5388          minutes = makeGetter('minutes'),
5389          hours = makeGetter('hours'),
5390          days = makeGetter('days'),
5391          months = makeGetter('months'),
5392          years = makeGetter('years');
5393  
5394      function weeks() {
5395          return absFloor(this.days() / 7);
5396      }
5397  
5398      var round = Math.round,
5399          thresholds = {
5400              ss: 44, // a few seconds to seconds
5401              s: 45, // seconds to minute
5402              m: 45, // minutes to hour
5403              h: 22, // hours to day
5404              d: 26, // days to month/week
5405              w: null, // weeks to month
5406              M: 11, // months to year
5407          };
5408  
5409      // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
5410      function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
5411          return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
5412      }
5413  
5414      function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {
5415          var duration = createDuration(posNegDuration).abs(),
5416              seconds = round(duration.as('s')),
5417              minutes = round(duration.as('m')),
5418              hours = round(duration.as('h')),
5419              days = round(duration.as('d')),
5420              months = round(duration.as('M')),
5421              weeks = round(duration.as('w')),
5422              years = round(duration.as('y')),
5423              a =
5424                  (seconds <= thresholds.ss && ['s', seconds]) ||
5425                  (seconds < thresholds.s && ['ss', seconds]) ||
5426                  (minutes <= 1 && ['m']) ||
5427                  (minutes < thresholds.m && ['mm', minutes]) ||
5428                  (hours <= 1 && ['h']) ||
5429                  (hours < thresholds.h && ['hh', hours]) ||
5430                  (days <= 1 && ['d']) ||
5431                  (days < thresholds.d && ['dd', days]);
5432  
5433          if (thresholds.w != null) {
5434              a =
5435                  a ||
5436                  (weeks <= 1 && ['w']) ||
5437                  (weeks < thresholds.w && ['ww', weeks]);
5438          }
5439          a = a ||
5440              (months <= 1 && ['M']) ||
5441              (months < thresholds.M && ['MM', months]) ||
5442              (years <= 1 && ['y']) || ['yy', years];
5443  
5444          a[2] = withoutSuffix;
5445          a[3] = +posNegDuration > 0;
5446          a[4] = locale;
5447          return substituteTimeAgo.apply(null, a);
5448      }
5449  
5450      // This function allows you to set the rounding function for relative time strings
5451      function getSetRelativeTimeRounding(roundingFunction) {
5452          if (roundingFunction === undefined) {
5453              return round;
5454          }
5455          if (typeof roundingFunction === 'function') {
5456              round = roundingFunction;
5457              return true;
5458          }
5459          return false;
5460      }
5461  
5462      // This function allows you to set a threshold for relative time strings
5463      function getSetRelativeTimeThreshold(threshold, limit) {
5464          if (thresholds[threshold] === undefined) {
5465              return false;
5466          }
5467          if (limit === undefined) {
5468              return thresholds[threshold];
5469          }
5470          thresholds[threshold] = limit;
5471          if (threshold === 's') {
5472              thresholds.ss = limit - 1;
5473          }
5474          return true;
5475      }
5476  
5477      function humanize(argWithSuffix, argThresholds) {
5478          if (!this.isValid()) {
5479              return this.localeData().invalidDate();
5480          }
5481  
5482          var withSuffix = false,
5483              th = thresholds,
5484              locale,
5485              output;
5486  
5487          if (typeof argWithSuffix === 'object') {
5488              argThresholds = argWithSuffix;
5489              argWithSuffix = false;
5490          }
5491          if (typeof argWithSuffix === 'boolean') {
5492              withSuffix = argWithSuffix;
5493          }
5494          if (typeof argThresholds === 'object') {
5495              th = Object.assign({}, thresholds, argThresholds);
5496              if (argThresholds.s != null && argThresholds.ss == null) {
5497                  th.ss = argThresholds.s - 1;
5498              }
5499          }
5500  
5501          locale = this.localeData();
5502          output = relativeTime$1(this, !withSuffix, th, locale);
5503  
5504          if (withSuffix) {
5505              output = locale.pastFuture(+this, output);
5506          }
5507  
5508          return locale.postformat(output);
5509      }
5510  
5511      var abs$1 = Math.abs;
5512  
5513      function sign(x) {
5514          return (x > 0) - (x < 0) || +x;
5515      }
5516  
5517      function toISOString$1() {
5518          // for ISO strings we do not use the normal bubbling rules:
5519          //  * milliseconds bubble up until they become hours
5520          //  * days do not bubble at all
5521          //  * months bubble up until they become years
5522          // This is because there is no context-free conversion between hours and days
5523          // (think of clock changes)
5524          // and also not between days and months (28-31 days per month)
5525          if (!this.isValid()) {
5526              return this.localeData().invalidDate();
5527          }
5528  
5529          var seconds = abs$1(this._milliseconds) / 1000,
5530              days = abs$1(this._days),
5531              months = abs$1(this._months),
5532              minutes,
5533              hours,
5534              years,
5535              s,
5536              total = this.asSeconds(),
5537              totalSign,
5538              ymSign,
5539              daysSign,
5540              hmsSign;
5541  
5542          if (!total) {
5543              // this is the same as C#'s (Noda) and python (isodate)...
5544              // but not other JS (goog.date)
5545              return 'P0D';
5546          }
5547  
5548          // 3600 seconds -> 60 minutes -> 1 hour
5549          minutes = absFloor(seconds / 60);
5550          hours = absFloor(minutes / 60);
5551          seconds %= 60;
5552          minutes %= 60;
5553  
5554          // 12 months -> 1 year
5555          years = absFloor(months / 12);
5556          months %= 12;
5557  
5558          // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
5559          s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
5560  
5561          totalSign = total < 0 ? '-' : '';
5562          ymSign = sign(this._months) !== sign(total) ? '-' : '';
5563          daysSign = sign(this._days) !== sign(total) ? '-' : '';
5564          hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
5565  
5566          return (
5567              totalSign +
5568              'P' +
5569              (years ? ymSign + years + 'Y' : '') +
5570              (months ? ymSign + months + 'M' : '') +
5571              (days ? daysSign + days + 'D' : '') +
5572              (hours || minutes || seconds ? 'T' : '') +
5573              (hours ? hmsSign + hours + 'H' : '') +
5574              (minutes ? hmsSign + minutes + 'M' : '') +
5575              (seconds ? hmsSign + s + 'S' : '')
5576          );
5577      }
5578  
5579      var proto$2 = Duration.prototype;
5580  
5581      proto$2.isValid = isValid$1;
5582      proto$2.abs = abs;
5583      proto$2.add = add$1;
5584      proto$2.subtract = subtract$1;
5585      proto$2.as = as;
5586      proto$2.asMilliseconds = asMilliseconds;
5587      proto$2.asSeconds = asSeconds;
5588      proto$2.asMinutes = asMinutes;
5589      proto$2.asHours = asHours;
5590      proto$2.asDays = asDays;
5591      proto$2.asWeeks = asWeeks;
5592      proto$2.asMonths = asMonths;
5593      proto$2.asQuarters = asQuarters;
5594      proto$2.asYears = asYears;
5595      proto$2.valueOf = valueOf$1;
5596      proto$2._bubble = bubble;
5597      proto$2.clone = clone$1;
5598      proto$2.get = get$2;
5599      proto$2.milliseconds = milliseconds;
5600      proto$2.seconds = seconds;
5601      proto$2.minutes = minutes;
5602      proto$2.hours = hours;
5603      proto$2.days = days;
5604      proto$2.weeks = weeks;
5605      proto$2.months = months;
5606      proto$2.years = years;
5607      proto$2.humanize = humanize;
5608      proto$2.toISOString = toISOString$1;
5609      proto$2.toString = toISOString$1;
5610      proto$2.toJSON = toISOString$1;
5611      proto$2.locale = locale;
5612      proto$2.localeData = localeData;
5613  
5614      proto$2.toIsoString = deprecate(
5615          'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
5616          toISOString$1
5617      );
5618      proto$2.lang = lang;
5619  
5620      // FORMATTING
5621  
5622      addFormatToken('X', 0, 0, 'unix');
5623      addFormatToken('x', 0, 0, 'valueOf');
5624  
5625      // PARSING
5626  
5627      addRegexToken('x', matchSigned);
5628      addRegexToken('X', matchTimestamp);
5629      addParseToken('X', function (input, array, config) {
5630          config._d = new Date(parseFloat(input) * 1000);
5631      });
5632      addParseToken('x', function (input, array, config) {
5633          config._d = new Date(toInt(input));
5634      });
5635  
5636      //! moment.js
5637  
5638      hooks.version = '2.29.2';
5639  
5640      setHookCallback(createLocal);
5641  
5642      hooks.fn = proto;
5643      hooks.min = min;
5644      hooks.max = max;
5645      hooks.now = now;
5646      hooks.utc = createUTC;
5647      hooks.unix = createUnix;
5648      hooks.months = listMonths;
5649      hooks.isDate = isDate;
5650      hooks.locale = getSetGlobalLocale;
5651      hooks.invalid = createInvalid;
5652      hooks.duration = createDuration;
5653      hooks.isMoment = isMoment;
5654      hooks.weekdays = listWeekdays;
5655      hooks.parseZone = createInZone;
5656      hooks.localeData = getLocale;
5657      hooks.isDuration = isDuration;
5658      hooks.monthsShort = listMonthsShort;
5659      hooks.weekdaysMin = listWeekdaysMin;
5660      hooks.defineLocale = defineLocale;
5661      hooks.updateLocale = updateLocale;
5662      hooks.locales = listLocales;
5663      hooks.weekdaysShort = listWeekdaysShort;
5664      hooks.normalizeUnits = normalizeUnits;
5665      hooks.relativeTimeRounding = getSetRelativeTimeRounding;
5666      hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
5667      hooks.calendarFormat = getCalendarFormat;
5668      hooks.prototype = proto;
5669  
5670      // currently HTML5 input type only supports 24-hour formats
5671      hooks.HTML5_FMT = {
5672          DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" />
5673          DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" />
5674          DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" />
5675          DATE: 'YYYY-MM-DD', // <input type="date" />
5676          TIME: 'HH:mm', // <input type="time" />
5677          TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" />
5678          TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" />
5679          WEEK: 'GGGG-[W]WW', // <input type="week" />
5680          MONTH: 'YYYY-MM', // <input type="month" />
5681      };
5682  
5683      return hooks;
5684  
5685  })));


Generated: Sun May 22 01:00:03 2022 Cross-referenced by PHPXref 0.7.1