[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

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

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


Generated : Sat Nov 2 08:20:01 2024 Cross-referenced by PHPXref