text: ;(function (global, factory) {
      typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
      typeof define === 'function' && define.amd ? define(factory) :
      global.moment = factory()
  }(this, function () { 'use strict';
  
      var hookCallback;
  
      function utils_hooks__hooks () {
          return hookCallback.apply(null, arguments);
      }
  
      // This is done to register the method called with moment()
      // without creating circular dependencies.
      function setHookCallback (callback) {
          hookCallback = callback;
      }
  
      function isArray(input) {
          return Object.prototype.toString.call(input) === '[object Array]';
      }
  
      function isDate(input) {
          return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
      }
  
      function map(arr, fn) {
          var res = [], i;
          for (i = 0; i < arr.length; ++i) {
              res.push(fn(arr[i], i));
          }
          return res;
      }
  
      function hasOwnProp(a, b) {
          return Object.prototype.hasOwnProperty.call(a, b);
      }
  
      function extend(a, b) {
          for (var i in b) {
              if (hasOwnProp(b, i)) {
                  a[i] = b[i];
              }
          }
  
          if (hasOwnProp(b, 'toString')) {
              a.toString = b.toString;
          }
  
          if (hasOwnProp(b, 'valueOf')) {
              a.valueOf = b.valueOf;
          }
  
          return a;
      }
  
      function create_utc__createUTC (input, format, locale, strict) {
          return createLocalOrUTC(input, format, locale, strict, true).utc();
      }
  
      function defaultParsingFlags() {
          // We need to deep clone this object.
          return {
              empty           : false,
              unusedTokens    : [],
              unusedInput     : [],
              overflow        : -2,
              charsLeftOver   : 0,
              nullInput       : false,
              invalidMonth    : null,
              invalidFormat   : false,
              userInvalidated : false,
              iso             : false
          };
      }
  
      function getParsingFlags(m) {
          if (m._pf == null) {
              m._pf = defaultParsingFlags();
          }
          return m._pf;
      }
  
      function valid__isValid(m) {
          if (m._isValid == null) {
              var flags = getParsingFlags(m);
              m._isValid = !isNaN(m._d.getTime()) &&
                  flags.overflow < 0 &&
                  !flags.empty &&
                  !flags.invalidMonth &&
                  !flags.invalidWeekday &&
                  !flags.nullInput &&
                  !flags.invalidFormat &&
                  !flags.userInvalidated;
  
              if (m._strict) {
                  m._isValid = m._isValid &&
                      flags.charsLeftOver === 0 &&
                      flags.unusedTokens.length === 0 &&
                      flags.bigHour === undefined;
              }
          }
          return m._isValid;
      }
  
      function valid__createInvalid (flags) {
          var m = create_utc__createUTC(NaN);
          if (flags != null) {
              extend(getParsingFlags(m), flags);
          }
          else {
              getParsingFlags(m).userInvalidated = true;
          }
  
          return m;
      }
  
      function isUndefined(input) {
          return input === void 0;
      }
  
      // Plugins that add properties should also add the key here (null value),
      // so we can properly clone ourselves.
      var momentProperties = utils_hooks__hooks.momentProperties = [];
  
      function copyConfig(to, from) {
          var i, prop, val;
  
          if (!isUndefined(from._isAMomentObject)) {
              to._isAMomentObject = from._isAMomentObject;
          }
          if (!isUndefined(from._i)) {
              to._i = from._i;
          }
          if (!isUndefined(from._f)) {
              to._f = from._f;
          }
          if (!isUndefined(from._l)) {
              to._l = from._l;
          }
          if (!isUndefined(from._strict)) {
              to._strict = from._strict;
          }
          if (!isUndefined(from._tzm)) {
              to._tzm = from._tzm;
          }
          if (!isUndefined(from._isUTC)) {
              to._isUTC = from._isUTC;
          }
          if (!isUndefined(from._offset)) {
              to._offset = from._offset;
          }
          if (!isUndefined(from._pf)) {
              to._pf = getParsingFlags(from);
          }
          if (!isUndefined(from._locale)) {
              to._locale = from._locale;
          }
  
          if (momentProperties.length > 0) {
              for (i in momentProperties) {
                  prop = momentProperties[i];
                  val = from[prop];
                  if (!isUndefined(val)) {
                      to[prop] = val;
                  }
              }
          }
  
          return to;
      }
  
      var updateInProgress = false;
  
      // Moment prototype object
      function Moment(config) {
          copyConfig(this, config);
          this._d = new Date(config._d != null ? config._d.getTime() : NaN);
          // Prevent infinite loop in case updateOffset creates new moment
          // objects.
          if (updateInProgress === false) {
              updateInProgress = true;
              utils_hooks__hooks.updateOffset(this);
              updateInProgress = false;
          }
      }
  
      function isMoment (obj) {
          return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
      }
  
      function absFloor (number) {
          if (number < 0) {
              return Math.ceil(number);
          } else {
              return Math.floor(number);
          }
      }
  
      function toInt(argumentForCoercion) {
          var coercedNumber = +argumentForCoercion,
              value = 0;
  
          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
              value = absFloor(coercedNumber);
          }
  
          return value;
      }
  
      // compare two arrays, return the number of differences
      function compareArrays(array1, array2, dontConvert) {
          var len = Math.min(array1.length, array2.length),
              lengthDiff = Math.abs(array1.length - array2.length),
              diffs = 0,
              i;
          for (i = 0; i < len; i++) {
              if ((dontConvert && array1[i] !== array2[i]) ||
                  (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
                  diffs++;
              }
          }
          return diffs + lengthDiff;
      }
  
      function Locale() {
      }
  
      // internal storage for locale config files
      var locales = {};
      var globalLocale;
  
      function normalizeLocale(key) {
          return key ? key.toLowerCase().replace('_', '-') : key;
      }
  
      // pick the locale from the array
      // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
      // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
      function chooseLocale(names) {
          var i = 0, j, next, locale, split;
  
          while (i < names.length) {
              split = normalizeLocale(names[i]).split('-');
              j = split.length;
              next = normalizeLocale(names[i + 1]);
              next = next ? next.split('-') : null;
              while (j > 0) {
                  locale = loadLocale(split.slice(0, j).join('-'));
                  if (locale) {
                      return locale;
                  }
                  if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
                      //the next array item is better than a shallower substring of this one
                      break;
                  }
                  j--;
              }
              i++;
          }
          return null;
      }
  
      function loadLocale(name) {
          var oldLocale = null;
          // TODO: Find a better way to register and load all the locales in Node
          if (!locales[name] && (typeof module !== 'undefined') &&
                  module && module.exports) {
              try {
                  oldLocale = globalLocale._abbr;
                  require('./locale/' + name);
                  // because defineLocale currently also sets the global locale, we
                  // want to undo that for lazy loaded locales
                  locale_locales__getSetGlobalLocale(oldLocale);
              } catch (e) { }
          }
          return locales[name];
      }
  
      // This function will load locale and then set the global locale.  If
      // no arguments are passed in, it will simply return the current global
      // locale key.
      function locale_locales__getSetGlobalLocale (key, values) {
          var data;
          if (key) {
              if (isUndefined(values)) {
                  data = locale_locales__getLocale(key);
              }
              else {
                  data = defineLocale(key, values);
              }
  
              if (data) {
                  // moment.duration._locale = moment._locale = data;
                  globalLocale = data;
              }
          }
  
          return globalLocale._abbr;
      }
  
      function defineLocale (name, values) {
          if (values !== null) {
              values.abbr = name;
              locales[name] = locales[name] || new Locale();
              locales[name].set(values);
  
              // backwards compat for now: also set the locale
              locale_locales__getSetGlobalLocale(name);
  
              return locales[name];
          } else {
              // useful for testing
              delete locales[name];
              return null;
          }
      }
  
      // returns locale data
      function locale_locales__getLocale (key) {
          var locale;
  
          if (key && key._locale && key._locale._abbr) {
              key = key._locale._abbr;
          }
  
          if (!key) {
              return globalLocale;
          }
  
          if (!isArray(key)) {
              //short-circuit everything else
              locale = loadLocale(key);
              if (locale) {
                  return locale;
              }
              key = [key];
          }
  
          return chooseLocale(key);
      }
  
      var aliases = {};
  
      function addUnitAlias (unit, shorthand) {
          var lowerCase = unit.toLowerCase();
          aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
      }
  
      function normalizeUnits(units) {
          return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
      }
  
      function normalizeObjectUnits(inputObject) {
          var normalizedInput = {},
              normalizedProp,
              prop;
  
          for (prop in inputObject) {
              if (hasOwnProp(inputObject, prop)) {
                  normalizedProp = normalizeUnits(prop);
                  if (normalizedProp) {
                      normalizedInput[normalizedProp] = inputObject[prop];
                  }
              }
          }
  
          return normalizedInput;
      }
  
      function isFunction(input) {
          return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
      }
  
      function makeGetSet (unit, keepTime) {
          return function (value) {
              if (value != null) {
                  get_set__set(this, unit, value);
                  utils_hooks__hooks.updateOffset(this, keepTime);
                  return this;
              } else {
                  return get_set__get(this, unit);
              }
          };
      }
  
      function get_set__get (mom, unit) {
          return mom.isValid() ?
              mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
      }
  
      function get_set__set (mom, unit, value) {
          if (mom.isValid()) {
              mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
          }
      }
  
      // MOMENTS
  
      function getSet (units, value) {
          var unit;
          if (typeof units === 'object') {
              for (unit in units) {
                  this.set(unit, units[unit]);
              }
          } else {
              units = normalizeUnits(units);
              if (isFunction(this[units])) {
                  return this[units](value);
              }
          }
          return this;
      }
  
      function zeroFill(number, targetLength, forceSign) {
          var absNumber = '' + Math.abs(number),
              zerosToFill = targetLength - absNumber.length,
              sign = number >= 0;
          return (sign ? (forceSign ? '+' : '') : '-') +
              Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
      }
  
      var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
  
      var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
  
      var formatFunctions = {};
  
      var formatTokenFunctions = {};
  
      // token:    'M'
      // padded:   ['MM', 2]
      // ordinal:  'Mo'
      // callback: function () { this.month() + 1 }
      function addFormatToken (token, padded, ordinal, callback) {
          var func = callback;
          if (typeof callback === 'string') {
              func = function () {
                  return this[callback]();
              };
          }
          if (token) {
              formatTokenFunctions[token] = func;
          }
          if (padded) {
              formatTokenFunctions[padded[0]] = function () {
                  return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
              };
          }
          if (ordinal) {
              formatTokenFunctions[ordinal] = function () {
                  return this.localeData().ordinal(func.apply(this, arguments), token);
              };
          }
      }
  
      function removeFormattingTokens(input) {
          if (input.match(/\[[\s\S]/)) {
              return input.replace(/^\[|\]$/g, '');
          }
          return input.replace(/\\/g, '');
      }
  
      function makeFormatFunction(format) {
          var array = format.match(formattingTokens), i, length;
  
          for (i = 0, length = array.length; i < length; i++) {
              if (formatTokenFunctions[array[i]]) {
                  array[i] = formatTokenFunctions[array[i]];
              } else {
                  array[i] = removeFormattingTokens(array[i]);
              }
          }
  
          return function (mom) {
              var output = '';
              for (i = 0; i < length; i++) {
                  output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
              }
              return output;
          };
      }
  
      // format date using native date object
      function formatMoment(m, format) {
          if (!m.isValid()) {
              return m.localeData().invalidDate();
          }
  
          format = expandFormat(format, m.localeData());
          formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
  
          return formatFunctions[format](m);
      }
  
      function expandFormat(format, locale) {
          var i = 5;
  
          function replaceLongDateFormatTokens(input) {
              return locale.longDateFormat(input) || input;
          }
  
          localFormattingTokens.lastIndex = 0;
          while (i >= 0 && localFormattingTokens.test(format)) {
              format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
              localFormattingTokens.lastIndex = 0;
              i -= 1;
          }
  
          return format;
      }
  
      var match1         = /\d/;            //       0 - 9
      var match2         = /\d\d/;          //      00 - 99
      var match3         = /\d{3}/;         //     000 - 999
      var match4         = /\d{4}/;         //    0000 - 9999
      var match6         = /[+-]?\d{6}/;    // -999999 - 999999
      var match1to2      = /\d\d?/;         //       0 - 99
      var match3to4      = /\d\d\d\d?/;     //     999 - 9999
      var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
      var match1to3      = /\d{1,3}/;       //       0 - 999
      var match1to4      = /\d{1,4}/;       //       0 - 9999
      var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
  
      var matchUnsigned  = /\d+/;           //       0 - inf
      var matchSigned    = /[+-]?\d+/;      //    -inf - inf
  
      var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
      var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
  
      var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
  
      // any word (or two) characters or numbers including two/three word month in arabic.
      // includes scottish gaelic two word and hyphenated months
      var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
  
  
      var regexes = {};
  
      function addRegexToken (token, regex, strictRegex) {
          regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
              return (isStrict && strictRegex) ? strictRegex : regex;
          };
      }
  
      function getParseRegexForToken (token, config) {
          if (!hasOwnProp(regexes, token)) {
              return new RegExp(unescapeFormat(token));
          }
  
          return regexes[token](config._strict, config._locale);
      }
  
      // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
      function unescapeFormat(s) {
          return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
              return p1 || p2 || p3 || p4;
          }));
      }
  
      function regexEscape(s) {
          return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
      }
  
      var tokens = {};
  
      function addParseToken (token, callback) {
          var i, func = callback;
          if (typeof token === 'string') {
              token = [token];
          }
          if (typeof callback === 'number') {
              func = function (input, array) {
                  array[callback] = toInt(input);
              };
          }
          for (i = 0; i < token.length; i++) {
              tokens[token[i]] = func;
          }
      }
  
      function addWeekParseToken (token, callback) {
          addParseToken(token, function (input, array, config, token) {
              config._w = config._w || {};
              callback(input, config._w, config, token);
          });
      }
  
      function addTimeToArrayFromToken(token, input, config) {
          if (input != null && hasOwnProp(tokens, token)) {
              tokens[token](input, config._a, config, token);
          }
      }
  
      var YEAR = 0;
      var MONTH = 1;
      var DATE = 2;
      var HOUR = 3;
      var MINUTE = 4;
      var SECOND = 5;
      var MILLISECOND = 6;
      var WEEK = 7;
      var WEEKDAY = 8;
  
      function daysInMonth(year, month) {
          return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
      }
  
      // FORMATTING
  
      addFormatToken('M', ['MM', 2], 'Mo', function () {
          return this.month() + 1;
      });
  
      addFormatToken('MMM', 0, 0, function (format) {
          return this.localeData().monthsShort(this, format);
      });
  
      addFormatToken('MMMM', 0, 0, function (format) {
          return this.localeData().months(this, format);
      });
  
      // ALIASES
  
      addUnitAlias('month', 'M');
  
      // PARSING
  
      addRegexToken('M',    match1to2);
      addRegexToken('MM',   match1to2, match2);
      addRegexToken('MMM',  function (isStrict, locale) {
          return locale.monthsShortRegex(isStrict);
      });
      addRegexToken('MMMM', function (isStrict, locale) {
          return locale.monthsRegex(isStrict);
      });
  
      addParseToken(['M', 'MM'], function (input, array) {
          array[MONTH] = toInt(input) - 1;
      });
  
      addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
          var month = config._locale.monthsParse(input, token, config._strict);
          // if we didn't find a month name, mark the date as invalid.
          if (month != null) {
              array[MONTH] = month;
          } else {
              getParsingFlags(config).invalidMonth = input;
          }
      });
  
      // LOCALES
  
      var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/;
      var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
      function localeMonths (m, format) {
          return isArray(this._months) ? this._months[m.month()] :
              this._months[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
      }
  
      var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
      function localeMonthsShort (m, format) {
          return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
              this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
      }
  
      function localeMonthsParse (monthName, format, strict) {
          var i, mom, regex;
  
          if (!this._monthsParse) {
              this._monthsParse = [];
              this._longMonthsParse = [];
              this._shortMonthsParse = [];
          }
  
          for (i = 0; i < 12; i++) {
              // make the regex if we don't have it already
              mom = create_utc__createUTC([2000, i]);
              if (strict && !this._longMonthsParse[i]) {
                  this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
                  this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
              }
              if (!strict && !this._monthsParse[i]) {
                  regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
                  this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
              }
              // test the regex
              if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
                  return i;
              } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
                  return i;
              } else if (!strict && this._monthsParse[i].test(monthName)) {
                  return i;
              }
          }
      }
  
      // MOMENTS
  
      function setMonth (mom, value) {
          var dayOfMonth;
  
          if (!mom.isValid()) {
              // No op
              return mom;
          }
  
          // TODO: Move this out of here!
          if (typeof value === 'string') {
              value = mom.localeData().monthsParse(value);
              // TODO: Another silent failure?
              if (typeof value !== 'number') {
                  return mom;
              }
          }
  
          dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
          mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
          return mom;
      }
  
      function getSetMonth (value) {
          if (value != null) {
              setMonth(this, value);
              utils_hooks__hooks.updateOffset(this, true);
              return this;
          } else {
              return get_set__get(this, 'Month');
          }
      }
  
      function getDaysInMonth () {
          return daysInMonth(this.year(), this.month());
      }
  
      var defaultMonthsShortRegex = matchWord;
      function monthsShortRegex (isStrict) {
          if (this._monthsParseExact) {
              if (!hasOwnProp(this, '_monthsRegex')) {
                  computeMonthsParse.call(this);
              }
              if (isStrict) {
                  return this._monthsShortStrictRegex;
              } else {
                  return this._monthsShortRegex;
              }
          } else {
              return this._monthsShortStrictRegex && isStrict ?
                  this._monthsShortStrictRegex : this._monthsShortRegex;
          }
      }
  
      var defaultMonthsRegex = matchWord;
      function monthsRegex (isStrict) {
          if (this._monthsParseExact) {
              if (!hasOwnProp(this, '_monthsRegex')) {
                  computeMonthsParse.call(this);
              }
              if (isStrict) {
                  return this._monthsStrictRegex;
              } else {
                  return this._monthsRegex;
              }
          } else {
              return this._monthsStrictRegex && isStrict ?
                  this._monthsStrictRegex : this._monthsRegex;
          }
      }
  
      function computeMonthsParse () {
          function cmpLenRev(a, b) {
              return b.length - a.length;
          }
  
          var shortPieces = [], longPieces = [], mixedPieces = [],
              i, mom;
          for (i = 0; i < 12; i++) {
              // make the regex if we don't have it already
              mom = create_utc__createUTC([2000, i]);
              shortPieces.push(this.monthsShort(mom, ''));
              longPieces.push(this.months(mom, ''));
              mixedPieces.push(this.months(mom, ''));
              mixedPieces.push(this.monthsShort(mom, ''));
          }
          // Sorting makes sure if one month (or abbr) is a prefix of another it
          // will match the longer piece.
          shortPieces.sort(cmpLenRev);
          longPieces.sort(cmpLenRev);
          mixedPieces.sort(cmpLenRev);
          for (i = 0; i < 12; i++) {
              shortPieces[i] = regexEscape(shortPieces[i]);
              longPieces[i] = regexEscape(longPieces[i]);
              mixedPieces[i] = regexEscape(mixedPieces[i]);
          }
  
          this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
          this._monthsShortRegex = this._monthsRegex;
          this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')$', 'i');
          this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')$', 'i');
      }
  
      function checkOverflow (m) {
          var overflow;
          var a = m._a;
  
          if (a && getParsingFlags(m).overflow === -2) {
              overflow =
                  a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
                  a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
                  a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
                  a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
                  a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
                  a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
                  -1;
  
              if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
                  overflow = DATE;
              }
              if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
                  overflow = WEEK;
              }
              if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
                  overflow = WEEKDAY;
              }
  
              getParsingFlags(m).overflow = overflow;
          }
  
          return m;
      }
  
      function warn(msg) {
          if (utils_hooks__hooks.suppressDeprecationWarnings === false &&
                  (typeof console !==  'undefined') && console.warn) {
              console.warn('Deprecation warning: ' + msg);
          }
      }
  
      function deprecate(msg, fn) {
          var firstTime = true;
  
          return extend(function () {
              if (firstTime) {
                  warn(msg + '\nArguments: ' + Array.prototype.slice.call(arguments).join(', ') + '\n' + (new Error()).stack);
                  firstTime = false;
              }
              return fn.apply(this, arguments);
          }, fn);
      }
  
      var deprecations = {};
  
      function deprecateSimple(name, msg) {
          if (!deprecations[name]) {
              warn(msg);
              deprecations[name] = true;
          }
      }
  
      utils_hooks__hooks.suppressDeprecationWarnings = false;
  
      // iso 8601 regex
      // 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)
      var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
      var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
  
      var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
  
      var isoDates = [
          ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
          ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
          ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
          ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
          ['YYYY-DDD', /\d{4}-\d{3}/],
          ['YYYY-MM', /\d{4}-\d\d/, false],
          ['YYYYYYMMDD', /[+-]\d{10}/],
          ['YYYYMMDD', /\d{8}/],
          // YYYYMM is NOT allowed by the standard
          ['GGGG[W]WWE', /\d{4}W\d{3}/],
          ['GGGG[W]WW', /\d{4}W\d{2}/, false],
          ['YYYYDDD', /\d{7}/]
      ];
  
      // iso time formats and regexes
      var isoTimes = [
          ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
          ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
          ['HH:mm:ss', /\d\d:\d\d:\d\d/],
          ['HH:mm', /\d\d:\d\d/],
          ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
          ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
          ['HHmmss', /\d\d\d\d\d\d/],
          ['HHmm', /\d\d\d\d/],
          ['HH', /\d\d/]
      ];
  
      var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
  
      // date from iso format
      function configFromISO(config) {
          var i, l,
              string = config._i,
              match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
              allowTime, dateFormat, timeFormat, tzFormat;
  
          if (match) {
              getParsingFlags(config).iso = true;
  
              for (i = 0, l = isoDates.length; i < l; i++) {
                  if (isoDates[i][1].exec(match[1])) {
                      dateFormat = isoDates[i][0];
                      allowTime = isoDates[i][2] !== false;
                      break;
                  }
              }
              if (dateFormat == null) {
                  config._isValid = false;
                  return;
              }
              if (match[3]) {
                  for (i = 0, l = isoTimes.length; i < l; i++) {
                      if (isoTimes[i][1].exec(match[3])) {
                          // match[2] should be 'T' or space
                          timeFormat = (match[2] || ' ') + isoTimes[i][0];
                          break;
                      }
                  }
                  if (timeFormat == null) {
                      config._isValid = false;
                      return;
                  }
              }
              if (!allowTime && timeFormat != null) {
                  config._isValid = false;
                  return;
              }
              if (match[4]) {
                  if (tzRegex.exec(match[4])) {
                      tzFormat = 'Z';
                  } else {
                      config._isValid = false;
                      return;
                  }
              }
              config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
              configFromStringAndFormat(config);
          } else {
              config._isValid = false;
          }
      }
  
      // date from iso format or fallback
      function configFromString(config) {
          var matched = aspNetJsonRegex.exec(config._i);
  
          if (matched !== null) {
              config._d = new Date(+matched[1]);
              return;
          }
  
          configFromISO(config);
          if (config._isValid === false) {
              delete config._isValid;
              utils_hooks__hooks.createFromInputFallback(config);
          }
      }
  
      utils_hooks__hooks.createFromInputFallback = deprecate(
          'moment construction falls back to js Date. This is ' +
          'discouraged and will be removed in upcoming major ' +
          'release. Please refer to ' +
          'https://github.com/moment/moment/issues/1407 for more info.',
          function (config) {
              config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
          }
      );
  
      function createDate (y, m, d, h, M, s, ms) {
          //can't just apply() to create a date:
          //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
          var date = new Date(y, m, d, h, M, s, ms);
  
          //the date constructor remaps years 0-99 to 1900-1999
          if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
              date.setFullYear(y);
          }
          return date;
      }
  
      function createUTCDate (y) {
          var date = new Date(Date.UTC.apply(null, arguments));
  
          //the Date.UTC function remaps years 0-99 to 1900-1999
          if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
              date.setUTCFullYear(y);
          }
          return date;
      }
  
      // FORMATTING
  
      addFormatToken('Y', 0, 0, function () {
          var y = this.year();
          return y <= 9999 ? '' + y : '+' + y;
      });
  
      addFormatToken(0, ['YY', 2], 0, function () {
          return this.year() % 100;
      });
  
      addFormatToken(0, ['YYYY',   4],       0, 'year');
      addFormatToken(0, ['YYYYY',  5],       0, 'year');
      addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
  
      // ALIASES
  
      addUnitAlias('year', 'y');
  
      // PARSING
  
      addRegexToken('Y',      matchSigned);
      addRegexToken('YY',     match1to2, match2);
      addRegexToken('YYYY',   match1to4, match4);
      addRegexToken('YYYYY',  match1to6, match6);
      addRegexToken('YYYYYY', match1to6, match6);
  
      addParseToken(['YYYYY', 'YYYYYY'], YEAR);
      addParseToken('YYYY', function (input, array) {
          array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input);
      });
      addParseToken('YY', function (input, array) {
          array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
      });
      addParseToken('Y', function (input, array) {
          array[YEAR] = parseInt(input, 10);
      });
  
      // HELPERS
  
      function daysInYear(year) {
          return isLeapYear(year) ? 366 : 365;
      }
  
      function isLeapYear(year) {
          return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
      }
  
      // HOOKS
  
      utils_hooks__hooks.parseTwoDigitYear = function (input) {
          return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
      };
  
      // MOMENTS
  
      var getSetYear = makeGetSet('FullYear', false);
  
      function getIsLeapYear () {
          return isLeapYear(this.year());
      }
  
      // start-of-first-week - start-of-year
      function firstWeekOffset(year, dow, doy) {
          var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
              fwd = 7 + dow - doy,
              // first-week day local weekday -- which local weekday is fwd
              fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
  
          return -fwdlw + fwd - 1;
      }
  
      //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
      function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
          var localWeekday = (7 + weekday - dow) % 7,
              weekOffset = firstWeekOffset(year, dow, doy),
              dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
              resYear, resDayOfYear;
  
          if (dayOfYear <= 0) {
              resYear = year - 1;
              resDayOfYear = daysInYear(resYear) + dayOfYear;
          } else if (dayOfYear > daysInYear(year)) {
              resYear = year + 1;
              resDayOfYear = dayOfYear - daysInYear(year);
          } else {
              resYear = year;
              resDayOfYear = dayOfYear;
          }
  
          return {
              year: resYear,
              dayOfYear: resDayOfYear
          };
      }
  
      function weekOfYear(mom, dow, doy) {
          var weekOffset = firstWeekOffset(mom.year(), dow, doy),
              week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
              resWeek, resYear;
  
          if (week < 1) {
              resYear = mom.year() - 1;
              resWeek = week + weeksInYear(resYear, dow, doy);
          } else if (week > weeksInYear(mom.year(), dow, doy)) {
              resWeek = week - weeksInYear(mom.year(), dow, doy);
              resYear = mom.year() + 1;
          } else {
              resYear = mom.year();
              resWeek = week;
          }
  
          return {
              week: resWeek,
              year: resYear
          };
      }
  
      function weeksInYear(year, dow, doy) {
          var weekOffset = firstWeekOffset(year, dow, doy),
              weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
          return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
      }
  
      // Pick the first defined of two or three arguments.
      function defaults(a, b, c) {
          if (a != null) {
              return a;
          }
          if (b != null) {
              return b;
          }
          return c;
      }
  
      function currentDateArray(config) {
          // hooks is actually the exported moment object
          var nowValue = new Date(utils_hooks__hooks.now());
          if (config._useUTC) {
              return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
          }
          return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
      }
  
      // convert an array to a date.
      // the array should mirror the parameters below
      // note: all values past the year are optional and will default to the lowest possible value.
      // [year, month, day , hour, minute, second, millisecond]
      function configFromArray (config) {
          var i, date, input = [], currentDate, yearToUse;
  
          if (config._d) {
              return;
          }
  
          currentDate = currentDateArray(config);
  
          //compute day of the year from weeks and weekdays
          if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
              dayOfYearFromWeekInfo(config);
          }
  
          //if the day of the year is set, figure out what it is
          if (config._dayOfYear) {
              yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
  
              if (config._dayOfYear > daysInYear(yearToUse)) {
                  getParsingFlags(config)._overflowDayOfYear = true;
              }
  
              date = createUTCDate(yearToUse, 0, config._dayOfYear);
              config._a[MONTH] = date.getUTCMonth();
              config._a[DATE] = date.getUTCDate();
          }
  
          // Default to current date.
          // * if no year, month, day of month are given, default to today
          // * if day of month is given, default month and year
          // * if month is given, default only year
          // * if year is given, don't default anything
          for (i = 0; i < 3 && config._a[i] == null; ++i) {
              config._a[i] = input[i] = currentDate[i];
          }
  
          // Zero out whatever was not defaulted, including time
          for (; i < 7; i++) {
              config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
          }
  
          // Check for 24:00:00.000
          if (config._a[HOUR] === 24 &&
                  config._a[MINUTE] === 0 &&
                  config._a[SECOND] === 0 &&
                  config._a[MILLISECOND] === 0) {
              config._nextDay = true;
              config._a[HOUR] = 0;
          }
  
          config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
          // Apply timezone offset from input. The actual utcOffset can be changed
          // with parseZone.
          if (config._tzm != null) {
              config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
          }
  
          if (config._nextDay) {
              config._a[HOUR] = 24;
          }
      }
  
      function dayOfYearFromWeekInfo(config) {
          var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
  
          w = config._w;
          if (w.GG != null || w.W != null || w.E != null) {
              dow = 1;
              doy = 4;
  
              // TODO: We need to take the current isoWeekYear, but that depends on
              // how we interpret now (local, utc, fixed offset). So create
              // a now version of current config (take local/utc/offset flags, and
              // create now).
              weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
              week = defaults(w.W, 1);
              weekday = defaults(w.E, 1);
              if (weekday < 1 || weekday > 7) {
                  weekdayOverflow = true;
              }
          } else {
              dow = config._locale._week.dow;
              doy = config._locale._week.doy;
  
              weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
              week = defaults(w.w, 1);
  
              if (w.d != null) {
                  // weekday -- low day numbers are considered next week
                  weekday = w.d;
                  if (weekday < 0 || weekday > 6) {
                      weekdayOverflow = true;
                  }
              } else if (w.e != null) {
                  // local weekday -- counting starts from begining of week
                  weekday = w.e + dow;
                  if (w.e < 0 || w.e > 6) {
                      weekdayOverflow = true;
                  }
              } else {
                  // default to begining of week
                  weekday = dow;
              }
          }
          if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
              getParsingFlags(config)._overflowWeeks = true;
          } else if (weekdayOverflow != null) {
              getParsingFlags(config)._overflowWeekday = true;
          } else {
              temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
              config._a[YEAR] = temp.year;
              config._dayOfYear = temp.dayOfYear;
          }
      }
  
      // constant that refers to the ISO standard
      utils_hooks__hooks.ISO_8601 = function () {};
  
      // date from string and format string
      function configFromStringAndFormat(config) {
          // TODO: Move this to another part of the creation flow to prevent circular deps
          if (config._f === utils_hooks__hooks.ISO_8601) {
              configFromISO(config);
              return;
          }
  
          config._a = [];
          getParsingFlags(config).empty = true;
  
          // This array is used to make a Date, either with `new Date` or `Date.UTC`
          var string = '' + config._i,
              i, parsedInput, tokens, token, skipped,
              stringLength = string.length,
              totalParsedInputLength = 0;
  
          tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
  
          for (i = 0; i < tokens.length; i++) {
              token = tokens[i];
              parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
              // console.log('token', token, 'parsedInput', parsedInput,
              //         'regex', getParseRegexForToken(token, config));
              if (parsedInput) {
                  skipped = string.substr(0, string.indexOf(parsedInput));
                  if (skipped.length > 0) {
                      getParsingFlags(config).unusedInput.push(skipped);
                  }
                  string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
                  totalParsedInputLength += parsedInput.length;
              }
              // don't parse if it's not a known token
              if (formatTokenFunctions[token]) {
                  if (parsedInput) {
                      getParsingFlags(config).empty = false;
                  }
                  else {
                      getParsingFlags(config).unusedTokens.push(token);
                  }
                  addTimeToArrayFromToken(token, parsedInput, config);
              }
              else if (config._strict && !parsedInput) {
                  getParsingFlags(config).unusedTokens.push(token);
              }
          }
  
          // add remaining unparsed input length to the string
          getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
          if (string.length > 0) {
              getParsingFlags(config).unusedInput.push(string);
          }
  
          // clear _12h flag if hour is <= 12
          if (getParsingFlags(config).bigHour === true &&
                  config._a[HOUR] <= 12 &&
                  config._a[HOUR] > 0) {
              getParsingFlags(config).bigHour = undefined;
          }
          // handle meridiem
          config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
  
          configFromArray(config);
          checkOverflow(config);
      }
  
  
      function meridiemFixWrap (locale, hour, meridiem) {
          var isPm;
  
          if (meridiem == null) {
              // nothing to do
              return hour;
          }
          if (locale.meridiemHour != null) {
              return locale.meridiemHour(hour, meridiem);
          } else if (locale.isPM != null) {
              // Fallback
              isPm = locale.isPM(meridiem);
              if (isPm && hour < 12) {
                  hour += 12;
              }
              if (!isPm && hour === 12) {
                  hour = 0;
              }
              return hour;
          } else {
              // this is not supposed to happen
              return hour;
          }
      }
  
      // date from string and array of format strings
      function configFromStringAndArray(config) {
          var tempConfig,
              bestMoment,
  
              scoreToBeat,
              i,
              currentScore;
  
          if (config._f.length === 0) {
              getParsingFlags(config).invalidFormat = true;
              config._d = new Date(NaN);
              return;
          }
  
          for (i = 0; i < config._f.length; i++) {
              currentScore = 0;
              tempConfig = copyConfig({}, config);
              if (config._useUTC != null) {
                  tempConfig._useUTC = config._useUTC;
              }
              tempConfig._f = config._f[i];
              configFromStringAndFormat(tempConfig);
  
              if (!valid__isValid(tempConfig)) {
                  continue;
              }
  
              // if there is any input that was not parsed add a penalty for that format
              currentScore += getParsingFlags(tempConfig).charsLeftOver;
  
              //or tokens
              currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
  
              getParsingFlags(tempConfig).score = currentScore;
  
              if (scoreToBeat == null || currentScore < scoreToBeat) {
                  scoreToBeat = currentScore;
                  bestMoment = tempConfig;
              }
          }
  
          extend(config, bestMoment || tempConfig);
      }
  
      function configFromObject(config) {
          if (config._d) {
              return;
          }
  
          var i = normalizeObjectUnits(config._i);
          config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
              return obj && parseInt(obj, 10);
          });
  
          configFromArray(config);
      }
  
      function createFromConfig (config) {
          var res = new Moment(checkOverflow(prepareConfig(config)));
          if (res._nextDay) {
              // Adding is smart enough around DST
              res.add(1, 'd');
              res._nextDay = undefined;
          }
  
          return res;
      }
  
      function prepareConfig (config) {
          var input = config._i,
              format = config._f;
  
          config._locale = config._locale || locale_locales__getLocale(config._l);
  
          if (input === null || (format === undefined && input === '')) {
              return valid__createInvalid({nullInput: true});
          }
  
          if (typeof input === 'string') {
              config._i = input = config._locale.preparse(input);
          }
  
          if (isMoment(input)) {
              return new Moment(checkOverflow(input));
          } else if (isArray(format)) {
              configFromStringAndArray(config);
          } else if (format) {
              configFromStringAndFormat(config);
          } else if (isDate(input)) {
              config._d = input;
          } else {
              configFromInput(config);
          }
  
          if (!valid__isValid(config)) {
              config._d = null;
          }
  
          return config;
      }
  
      function configFromInput(config) {
          var input = config._i;
          if (input === undefined) {
              config._d = new Date(utils_hooks__hooks.now());
          } else if (isDate(input)) {
              config._d = new Date(+input);
          } else if (typeof input === 'string') {
              configFromString(config);
          } else if (isArray(input)) {
              config._a = map(input.slice(0), function (obj) {
                  return parseInt(obj, 10);
              });
              configFromArray(config);
          } else if (typeof(input) === 'object') {
              configFromObject(config);
          } else if (typeof(input) === 'number') {
              // from milliseconds
              config._d = new Date(input);
          } else {
              utils_hooks__hooks.createFromInputFallback(config);
          }
      }
  
      function createLocalOrUTC (input, format, locale, strict, isUTC) {
          var c = {};
  
          if (typeof(locale) === 'boolean') {
              strict = locale;
              locale = undefined;
          }
          // object construction must be done this way.
          // https://github.com/moment/moment/issues/1423
          c._isAMomentObject = true;
          c._useUTC = c._isUTC = isUTC;
          c._l = locale;
          c._i = input;
          c._f = format;
          c._strict = strict;
  
          return createFromConfig(c);
      }
  
      function local__createLocal (input, format, locale, strict) {
          return createLocalOrUTC(input, format, locale, strict, false);
      }
  
      var prototypeMin = deprecate(
           'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
           function () {
               var other = local__createLocal.apply(null, arguments);
               if (this.isValid() && other.isValid()) {
                   return other < this ? this : other;
               } else {
                   return valid__createInvalid();
               }
           }
       );
  
      var prototypeMax = deprecate(
          'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
          function () {
              var other = local__createLocal.apply(null, arguments);
              if (this.isValid() && other.isValid()) {
                  return other > this ? this : other;
              } else {
                  return valid__createInvalid();
              }
          }
      );
  
      // Pick a moment m from moments so that m[fn](other) is true for all
      // other. This relies on the function fn to be transitive.
      //
      // moments should either be an array of moment objects or an array, whose
      // first element is an array of moment objects.
      function pickBy(fn, moments) {
          var res, i;
          if (moments.length === 1 && isArray(moments[0])) {
              moments = moments[0];
          }
          if (!moments.length) {
              return local__createLocal();
          }
          res = moments[0];
          for (i = 1; i < moments.length; ++i) {
              if (!moments[i].isValid() || moments[i][fn](res)) {
                  res = moments[i];
              }
          }
          return res;
      }
  
      // TODO: Use [].sort instead?
      function min () {
          var args = [].slice.call(arguments, 0);
  
          return pickBy('isBefore', args);
      }
  
      function max () {
          var args = [].slice.call(arguments, 0);
  
          return pickBy('isAfter', args);
      }
  
      var now = function () {
          return Date.now ? Date.now() : +(new Date());
      };
  
      function Duration (duration) {
          var normalizedInput = normalizeObjectUnits(duration),
              years = normalizedInput.year || 0,
              quarters = normalizedInput.quarter || 0,
              months = normalizedInput.month || 0,
              weeks = normalizedInput.week || 0,
              days = normalizedInput.day || 0,
              hours = normalizedInput.hour || 0,
              minutes = normalizedInput.minute || 0,
              seconds = normalizedInput.second || 0,
              milliseconds = normalizedInput.millisecond || 0;
  
          // representation for dateAddRemove
          this._milliseconds = +milliseconds +
              seconds * 1e3 + // 1000
              minutes * 6e4 + // 1000 * 60
              hours * 36e5; // 1000 * 60 * 60
          // Because of dateAddRemove treats 24 hours as different from a
          // day when working around DST, we need to store them separately
          this._days = +days +
              weeks * 7;
          // It is impossible translate months into days without knowing
          // which months you are are talking about, so we have to store
          // it separately.
          this._months = +months +
              quarters * 3 +
              years * 12;
  
          this._data = {};
  
          this._locale = locale_locales__getLocale();
  
          this._bubble();
      }
  
      function isDuration (obj) {
          return obj instanceof Duration;
      }
  
      // FORMATTING
  
      function offset (token, separator) {
          addFormatToken(token, 0, 0, function () {
              var offset = this.utcOffset();
              var sign = '+';
              if (offset < 0) {
                  offset = -offset;
                  sign = '-';
              }
              return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
          });
      }
  
      offset('Z', ':');
      offset('ZZ', '');
  
      // PARSING
  
      addRegexToken('Z',  matchShortOffset);
      addRegexToken('ZZ', matchShortOffset);
      addParseToken(['Z', 'ZZ'], function (input, array, config) {
          config._useUTC = true;
          config._tzm = offsetFromString(matchShortOffset, input);
      });
  
      // HELPERS
  
      // timezone chunker
      // '+10:00' > ['10',  '00']
      // '-1530'  > ['-15', '30']
      var chunkOffset = /([\+\-]|\d\d)/gi;
  
      function offsetFromString(matcher, string) {
          var matches = ((string || '').match(matcher) || []);
          var chunk   = matches[matches.length - 1] || [];
          var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
          var minutes = +(parts[1] * 60) + toInt(parts[2]);
  
          return parts[0] === '+' ? minutes : -minutes;
      }
  
      // Return a moment from input, that is local/utc/zone equivalent to model.
      function cloneWithOffset(input, model) {
          var res, diff;
          if (model._isUTC) {
              res = model.clone();
              diff = (isMoment(input) || isDate(input) ? +input : +local__createLocal(input)) - (+res);
              // Use low-level api, because this fn is low-level api.
              res._d.setTime(+res._d + diff);
              utils_hooks__hooks.updateOffset(res, false);
              return res;
          } else {
              return local__createLocal(input).local();
          }
      }
  
      function getDateOffset (m) {
          // On Firefox.24 Date#getTimezoneOffset returns a floating point.
          // https://github.com/moment/moment/pull/1871
          return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
      }
  
      // HOOKS
  
      // This function will be called whenever a moment is mutated.
      // It is intended to keep the offset in sync with the timezone.
      utils_hooks__hooks.updateOffset = function () {};
  
      // MOMENTS
  
      // keepLocalTime = true means only change the timezone, without
      // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
      // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
      // +0200, so we adjust the time as needed, to be valid.
      //
      // Keeping the time actually adds/subtracts (one hour)
      // from the actual represented time. That is why we call updateOffset
      // a second time. In case it wants us to change the offset again
      // _changeInProgress == true case, then we have to adjust, because
      // there is no such time in the given timezone.
      function getSetOffset (input, keepLocalTime) {
          var offset = this._offset || 0,
              localAdjust;
          if (!this.isValid()) {
              return input != null ? this : NaN;
          }
          if (input != null) {
              if (typeof input === 'string') {
                  input = offsetFromString(matchShortOffset, input);
              } else if (Math.abs(input) < 16) {
                  input = input * 60;
              }
              if (!this._isUTC && keepLocalTime) {
                  localAdjust = getDateOffset(this);
              }
              this._offset = input;
              this._isUTC = true;
              if (localAdjust != null) {
                  this.add(localAdjust, 'm');
              }
              if (offset !== input) {
                  if (!keepLocalTime || this._changeInProgress) {
                      add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
                  } else if (!this._changeInProgress) {
                      this._changeInProgress = true;
                      utils_hooks__hooks.updateOffset(this, true);
                      this._changeInProgress = null;
                  }
              }
              return this;
          } else {
              return this._isUTC ? offset : getDateOffset(this);
          }
      }
  
      function getSetZone (input, keepLocalTime) {
          if (input != null) {
              if (typeof input !== 'string') {
                  input = -input;
              }
  
              this.utcOffset(input, keepLocalTime);
  
              return this;
          } else {
              return -this.utcOffset();
          }
      }
  
      function setOffsetToUTC (keepLocalTime) {
          return this.utcOffset(0, keepLocalTime);
      }
  
      function setOffsetToLocal (keepLocalTime) {
          if (this._isUTC) {
              this.utcOffset(0, keepLocalTime);
              this._isUTC = false;
  
              if (keepLocalTime) {
                  this.subtract(getDateOffset(this), 'm');
              }
          }
          return this;
      }
  
      function setOffsetToParsedOffset () {
          if (this._tzm) {
              this.utcOffset(this._tzm);
          } else if (typeof this._i === 'string') {
              this.utcOffset(offsetFromString(matchOffset, this._i));
          }
          return this;
      }
  
      function hasAlignedHourOffset (input) {
          if (!this.isValid()) {
              return false;
          }
          input = input ? local__createLocal(input).utcOffset() : 0;
  
          return (this.utcOffset() - input) % 60 === 0;
      }
  
      function isDaylightSavingTime () {
          return (
              this.utcOffset() > this.clone().month(0).utcOffset() ||
              this.utcOffset() > this.clone().month(5).utcOffset()
          );
      }
  
      function isDaylightSavingTimeShifted () {
          if (!isUndefined(this._isDSTShifted)) {
              return this._isDSTShifted;
          }
  
          var c = {};
  
          copyConfig(c, this);
          c = prepareConfig(c);
  
          if (c._a) {
              var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
              this._isDSTShifted = this.isValid() &&
                  compareArrays(c._a, other.toArray()) > 0;
          } else {
              this._isDSTShifted = false;
          }
  
          return this._isDSTShifted;
      }
  
      function isLocal () {
          return this.isValid() ? !this._isUTC : false;
      }
  
      function isUtcOffset () {
          return this.isValid() ? this._isUTC : false;
      }
  
      function isUtc () {
          return this.isValid() ? this._isUTC && this._offset === 0 : false;
      }
  
      // ASP.NET json date format regex
      var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/;
  
      // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
      // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
      var isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
  
      function create__createDuration (input, key) {
          var duration = input,
              // matching against regexp is expensive, do it on demand
              match = null,
              sign,
              ret,
              diffRes;
  
          if (isDuration(input)) {
              duration = {
                  ms : input._milliseconds,
                  d  : input._days,
                  M  : input._months
              };
          } else if (typeof input === 'number') {
              duration = {};
              if (key) {
                  duration[key] = input;
              } else {
                  duration.milliseconds = input;
              }
          } else if (!!(match = aspNetRegex.exec(input))) {
              sign = (match[1] === '-') ? -1 : 1;
              duration = {
                  y  : 0,
                  d  : toInt(match[DATE])        * sign,
                  h  : toInt(match[HOUR])        * sign,
                  m  : toInt(match[MINUTE])      * sign,
                  s  : toInt(match[SECOND])      * sign,
                  ms : toInt(match[MILLISECOND]) * sign
              };
          } else if (!!(match = isoRegex.exec(input))) {
              sign = (match[1] === '-') ? -1 : 1;
              duration = {
                  y : parseIso(match[2], sign),
                  M : parseIso(match[3], sign),
                  d : parseIso(match[4], sign),
                  h : parseIso(match[5], sign),
                  m : parseIso(match[6], sign),
                  s : parseIso(match[7], sign),
                  w : parseIso(match[8], sign)
              };
          } else if (duration == null) {// checks for null or undefined
              duration = {};
          } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
              diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
  
              duration = {};
              duration.ms = diffRes.milliseconds;
              duration.M = diffRes.months;
          }
  
          ret = new Duration(duration);
  
          if (isDuration(input) && hasOwnProp(input, '_locale')) {
              ret._locale = input._locale;
          }
  
          return ret;
      }
  
      create__createDuration.fn = Duration.prototype;
  
      function parseIso (inp, sign) {
          // We'd normally use ~~inp for this, but unfortunately it also
          // converts floats to ints.
          // inp may be undefined, so careful calling replace on it.
          var res = inp && parseFloat(inp.replace(',', '.'));
          // apply sign while we're at it
          return (isNaN(res) ? 0 : res) * sign;
      }
  
      function positiveMomentsDifference(base, other) {
          var res = {milliseconds: 0, months: 0};
  
          res.months = other.month() - base.month() +
              (other.year() - base.year()) * 12;
          if (base.clone().add(res.months, 'M').isAfter(other)) {
              --res.months;
          }
  
          res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
  
          return res;
      }
  
      function momentsDifference(base, other) {
          var res;
          if (!(base.isValid() && other.isValid())) {
              return {milliseconds: 0, months: 0};
          }
  
          other = cloneWithOffset(other, base);
          if (base.isBefore(other)) {
              res = positiveMomentsDifference(base, other);
          } else {
              res = positiveMomentsDifference(other, base);
              res.milliseconds = -res.milliseconds;
              res.months = -res.months;
          }
  
          return res;
      }
  
      // TODO: remove 'name' arg after deprecation is removed
      function createAdder(direction, name) {
          return function (val, period) {
              var dur, tmp;
              //invert the arguments, but complain about it
              if (period !== null && !isNaN(+period)) {
                  deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
                  tmp = val; val = period; period = tmp;
              }
  
              val = typeof val === 'string' ? +val : val;
              dur = create__createDuration(val, period);
              add_subtract__addSubtract(this, dur, direction);
              return this;
          };
      }
  
      function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
          var milliseconds = duration._milliseconds,
              days = duration._days,
              months = duration._months;
  
          if (!mom.isValid()) {
              // No op
              return;
          }
  
          updateOffset = updateOffset == null ? true : updateOffset;
  
          if (milliseconds) {
              mom._d.setTime(+mom._d + milliseconds * isAdding);
          }
          if (days) {
              get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
          }
          if (months) {
              setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
          }
          if (updateOffset) {
              utils_hooks__hooks.updateOffset(mom, days || months);
          }
      }
  
      var add_subtract__add      = createAdder(1, 'add');
      var add_subtract__subtract = createAdder(-1, 'subtract');
  
      function moment_calendar__calendar (time, formats) {
          // We want to compare the start of today, vs this.
          // Getting start-of-today depends on whether we're local/utc/offset or not.
          var now = time || local__createLocal(),
              sod = cloneWithOffset(now, this).startOf('day'),
              diff = this.diff(sod, 'days', true),
              format = diff < -6 ? 'sameElse' :
                  diff < -1 ? 'lastWeek' :
                  diff < 0 ? 'lastDay' :
                  diff < 1 ? 'sameDay' :
                  diff < 2 ? 'nextDay' :
                  diff < 7 ? 'nextWeek' : 'sameElse';
  
          var output = formats && (isFunction(formats[format]) ? formats[format]() : formats[format]);
  
          return this.format(output || this.localeData().calendar(format, this, local__createLocal(now)));
      }
  
      function clone () {
          return new Moment(this);
      }
  
      function isAfter (input, units) {
          var localInput = isMoment(input) ? input : local__createLocal(input);
          if (!(this.isValid() && localInput.isValid())) {
              return false;
          }
          units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
          if (units === 'millisecond') {
              return +this > +localInput;
          } else {
              return +localInput < +this.clone().startOf(units);
          }
      }
  
      function isBefore (input, units) {
          var localInput = isMoment(input) ? input : local__createLocal(input);
          if (!(this.isValid() && localInput.isValid())) {
              return false;
          }
          units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
          if (units === 'millisecond') {
              return +this < +localInput;
          } else {
              return +this.clone().endOf(units) < +localInput;
          }
      }
  
      function isBetween (from, to, units) {
          return this.isAfter(from, units) && this.isBefore(to, units);
      }
  
      function isSame (input, units) {
          var localInput = isMoment(input) ? input : local__createLocal(input),
              inputMs;
          if (!(this.isValid() && localInput.isValid())) {
              return false;
          }
          units = normalizeUnits(units || 'millisecond');
          if (units === 'millisecond') {
              return +this === +localInput;
          } else {
              inputMs = +localInput;
              return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units));
          }
      }
  
      function isSameOrAfter (input, units) {
          return this.isSame(input, units) || this.isAfter(input,units);
      }
  
      function isSameOrBefore (input, units) {
          return this.isSame(input, units) || this.isBefore(input,units);
      }
  
      function diff (input, units, asFloat) {
          var that,
              zoneDelta,
              delta, output;
  
          if (!this.isValid()) {
              return NaN;
          }
  
          that = cloneWithOffset(input, this);
  
          if (!that.isValid()) {
              return NaN;
          }
  
          zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
  
          units = normalizeUnits(units);
  
          if (units === 'year' || units === 'month' || units === 'quarter') {
              output = monthDiff(this, that);
              if (units === 'quarter') {
                  output = output / 3;
              } else if (units === 'year') {
                  output = output / 12;
              }
          } else {
              delta = this - that;
              output = units === 'second' ? delta / 1e3 : // 1000
                  units === 'minute' ? delta / 6e4 : // 1000 * 60
                  units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
                  units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
                  units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
                  delta;
          }
          return asFloat ? output : absFloor(output);
      }
  
      function monthDiff (a, b) {
          // difference in months
          var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
              // b is in (anchor - 1 month, anchor + 1 month)
              anchor = a.clone().add(wholeMonthDiff, 'months'),
              anchor2, adjust;
  
          if (b - anchor < 0) {
              anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
              // linear across the month
              adjust = (b - anchor) / (anchor - anchor2);
          } else {
              anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
              // linear across the month
              adjust = (b - anchor) / (anchor2 - anchor);
          }
  
          return -(wholeMonthDiff + adjust);
      }
  
      utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
  
      function toString () {
          return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
      }
  
      function moment_format__toISOString () {
          var m = this.clone().utc();
          if (0 < m.year() && m.year() <= 9999) {
              if (isFunction(Date.prototype.toISOString)) {
                  // native implementation is ~50x faster, use it when we can
                  return this.toDate().toISOString();
              } else {
                  return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
              }
          } else {
              return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
          }
      }
  
      function moment_format__format (inputString) {
          var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);
          return this.localeData().postformat(output);
      }
  
      function from (time, withoutSuffix) {
          if (this.isValid() &&
                  ((isMoment(time) && time.isValid()) ||
                   local__createLocal(time).isValid())) {
              return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
          } else {
              return this.localeData().invalidDate();
          }
      }
  
      function fromNow (withoutSuffix) {
          return this.from(local__createLocal(), withoutSuffix);
      }
  
      function to (time, withoutSuffix) {
          if (this.isValid() &&
                  ((isMoment(time) && time.isValid()) ||
                   local__createLocal(time).isValid())) {
              return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
          } else {
              return this.localeData().invalidDate();
          }
      }
  
      function toNow (withoutSuffix) {
          return this.to(local__createLocal(), withoutSuffix);
      }
  
      // If passed a locale key, it will set the locale for this
      // instance.  Otherwise, it will return the locale configuration
      // variables for this instance.
      function locale (key) {
          var newLocaleData;
  
          if (key === undefined) {
              return this._locale._abbr;
          } else {
              newLocaleData = locale_locales__getLocale(key);
              if (newLocaleData != null) {
                  this._locale = newLocaleData;
              }
              return this;
          }
      }
  
      var lang = deprecate(
          'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
          function (key) {
              if (key === undefined) {
                  return this.localeData();
              } else {
                  return this.locale(key);
              }
          }
      );
  
      function localeData () {
          return this._locale;
      }
  
      function startOf (units) {
          units = normalizeUnits(units);
          // the following switch intentionally omits break keywords
          // to utilize falling through the cases.
          switch (units) {
          case 'year':
              this.month(0);
              /* falls through */
          case 'quarter':
          case 'month':
              this.date(1);
              /* falls through */
          case 'week':
          case 'isoWeek':
          case 'day':
              this.hours(0);
              /* falls through */
          case 'hour':
              this.minutes(0);
              /* falls through */
          case 'minute':
              this.seconds(0);
              /* falls through */
          case 'second':
              this.milliseconds(0);
          }
  
          // weeks are a special case
          if (units === 'week') {
              this.weekday(0);
          }
          if (units === 'isoWeek') {
              this.isoWeekday(1);
          }
  
          // quarters are also special
          if (units === 'quarter') {
              this.month(Math.floor(this.month() / 3) * 3);
          }
  
          return this;
      }
  
      function endOf (units) {
          units = normalizeUnits(units);
          if (units === undefined || units === 'millisecond') {
              return this;
          }
          return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
      }
  
      function to_type__valueOf () {
          return +this._d - ((this._offset || 0) * 60000);
      }
  
      function unix () {
          return Math.floor(+this / 1000);
      }
  
      function toDate () {
          return this._offset ? new Date(+this) : this._d;
      }
  
      function toArray () {
          var m = this;
          return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
      }
  
      function toObject () {
          var m = this;
          return {
              years: m.year(),
              months: m.month(),
              date: m.date(),
              hours: m.hours(),
              minutes: m.minutes(),
              seconds: m.seconds(),
              milliseconds: m.milliseconds()
          };
      }
  
      function toJSON () {
          // JSON.stringify(new Date(NaN)) === 'null'
          return this.isValid() ? this.toISOString() : 'null';
      }
  
      function moment_valid__isValid () {
          return valid__isValid(this);
      }
  
      function parsingFlags () {
          return extend({}, getParsingFlags(this));
      }
  
      function invalidAt () {
          return getParsingFlags(this).overflow;
      }
  
      function creationData() {
          return {
              input: this._i,
              format: this._f,
              locale: this._locale,
              isUTC: this._isUTC,
              strict: this._strict
          };
      }
  
      // FORMATTING
  
      addFormatToken(0, ['gg', 2], 0, function () {
          return this.weekYear() % 100;
      });
  
      addFormatToken(0, ['GG', 2], 0, function () {
          return this.isoWeekYear() % 100;
      });
  
      function addWeekYearFormatToken (token, getter) {
          addFormatToken(0, [token, token.length], 0, getter);
      }
  
      addWeekYearFormatToken('gggg',     'weekYear');
      addWeekYearFormatToken('ggggg',    'weekYear');
      addWeekYearFormatToken('GGGG',  'isoWeekYear');
      addWeekYearFormatToken('GGGGG', 'isoWeekYear');
  
      // ALIASES
  
      addUnitAlias('weekYear', 'gg');
      addUnitAlias('isoWeekYear', 'GG');
  
      // PARSING
  
      addRegexToken('G',      matchSigned);
      addRegexToken('g',      matchSigned);
      addRegexToken('GG',     match1to2, match2);
      addRegexToken('gg',     match1to2, match2);
      addRegexToken('GGGG',   match1to4, match4);
      addRegexToken('gggg',   match1to4, match4);
      addRegexToken('GGGGG',  match1to6, match6);
      addRegexToken('ggggg',  match1to6, match6);
  
      addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
          week[token.substr(0, 2)] = toInt(input);
      });
  
      addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
          week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
      });
  
      // MOMENTS
  
      function getSetWeekYear (input) {
          return getSetWeekYearHelper.call(this,
                  input,
                  this.week(),
                  this.weekday(),
                  this.localeData()._week.dow,
                  this.localeData()._week.doy);
      }
  
      function getSetISOWeekYear (input) {
          return getSetWeekYearHelper.call(this,
                  input, this.isoWeek(), this.isoWeekday(), 1, 4);
      }
  
      function getISOWeeksInYear () {
          return weeksInYear(this.year(), 1, 4);
      }
  
      function getWeeksInYear () {
          var weekInfo = this.localeData()._week;
          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
      }
  
      function getSetWeekYearHelper(input, week, weekday, dow, doy) {
          var weeksTarget;
          if (input == null) {
              return weekOfYear(this, dow, doy).year;
          } else {
              weeksTarget = weeksInYear(input, dow, doy);
              if (week > weeksTarget) {
                  week = weeksTarget;
              }
              return setWeekAll.call(this, input, week, weekday, dow, doy);
          }
      }
  
      function setWeekAll(weekYear, week, weekday, dow, doy) {
          var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
              date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
  
          // console.log("got", weekYear, week, weekday, "set", date.toISOString());
          this.year(date.getUTCFullYear());
          this.month(date.getUTCMonth());
          this.date(date.getUTCDate());
          return this;
      }
  
      // FORMATTING
  
      addFormatToken('Q', 0, 'Qo', 'quarter');
  
      // ALIASES
  
      addUnitAlias('quarter', 'Q');
  
      // PARSING
  
      addRegexToken('Q', match1);
      addParseToken('Q', function (input, array) {
          array[MONTH] = (toInt(input) - 1) * 3;
      });
  
      // MOMENTS
  
      function getSetQuarter (input) {
          return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
      }
  
      // FORMATTING
  
      addFormatToken('w', ['ww', 2], 'wo', 'week');
      addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
  
      // ALIASES
  
      addUnitAlias('week', 'w');
      addUnitAlias('isoWeek', 'W');
  
      // PARSING
  
      addRegexToken('w',  match1to2);
      addRegexToken('ww', match1to2, match2);
      addRegexToken('W',  match1to2);
      addRegexToken('WW', match1to2, match2);
  
      addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
          week[token.substr(0, 1)] = toInt(input);
      });
  
      // HELPERS
  
      // LOCALES
  
      function localeWeek (mom) {
          return weekOfYear(mom, this._week.dow, this._week.doy).week;
      }
  
      var defaultLocaleWeek = {
          dow : 0, // Sunday is the first day of the week.
          doy : 6  // The week that contains Jan 1st is the first week of the year.
      };
  
      function localeFirstDayOfWeek () {
          return this._week.dow;
      }
  
      function localeFirstDayOfYear () {
          return this._week.doy;
      }
  
      // MOMENTS
  
      function getSetWeek (input) {
          var week = this.localeData().week(this);
          return input == null ? week : this.add((input - week) * 7, 'd');
      }
  
      function getSetISOWeek (input) {
          var week = weekOfYear(this, 1, 4).week;
          return input == null ? week : this.add((input - week) * 7, 'd');
      }
  
      // FORMATTING
  
      addFormatToken('D', ['DD', 2], 'Do', 'date');
  
      // ALIASES
  
      addUnitAlias('date', 'D');
  
      // PARSING
  
      addRegexToken('D',  match1to2);
      addRegexToken('DD', match1to2, match2);
      addRegexToken('Do', function (isStrict, locale) {
          return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
      });
  
      addParseToken(['D', 'DD'], DATE);
      addParseToken('Do', function (input, array) {
          array[DATE] = toInt(input.match(match1to2)[0], 10);
      });
  
      // MOMENTS
  
      var getSetDayOfMonth = makeGetSet('Date', true);
  
      // FORMATTING
  
      addFormatToken('d', 0, 'do', 'day');
  
      addFormatToken('dd', 0, 0, function (format) {
          return this.localeData().weekdaysMin(this, format);
      });
  
      addFormatToken('ddd', 0, 0, function (format) {
          return this.localeData().weekdaysShort(this, format);
      });
  
      addFormatToken('dddd', 0, 0, function (format) {
          return this.localeData().weekdays(this, format);
      });
  
      addFormatToken('e', 0, 0, 'weekday');
      addFormatToken('E', 0, 0, 'isoWeekday');
  
      // ALIASES
  
      addUnitAlias('day', 'd');
      addUnitAlias('weekday', 'e');
      addUnitAlias('isoWeekday', 'E');
  
      // PARSING
  
      addRegexToken('d',    match1to2);
      addRegexToken('e',    match1to2);
      addRegexToken('E',    match1to2);
      addRegexToken('dd',   matchWord);
      addRegexToken('ddd',  matchWord);
      addRegexToken('dddd', matchWord);
  
      addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
          var weekday = config._locale.weekdaysParse(input, token, config._strict);
          // if we didn't get a weekday name, mark the date as invalid
          if (weekday != null) {
              week.d = weekday;
          } else {
              getParsingFlags(config).invalidWeekday = input;
          }
      });
  
      addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
          week[token] = toInt(input);
      });
  
      // HELPERS
  
      function parseWeekday(input, locale) {
          if (typeof input !== 'string') {
              return input;
          }
  
          if (!isNaN(input)) {
              return parseInt(input, 10);
          }
  
          input = locale.weekdaysParse(input);
          if (typeof input === 'number') {
              return input;
          }
  
          return null;
      }
  
      // LOCALES
  
      var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
      function localeWeekdays (m, format) {
          return isArray(this._weekdays) ? this._weekdays[m.day()] :
              this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
      }
  
      var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
      function localeWeekdaysShort (m) {
          return this._weekdaysShort[m.day()];
      }
  
      var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
      function localeWeekdaysMin (m) {
          return this._weekdaysMin[m.day()];
      }
  
      function localeWeekdaysParse (weekdayName, format, strict) {
          var i, mom, regex;
  
          if (!this._weekdaysParse) {
              this._weekdaysParse = [];
              this._minWeekdaysParse = [];
              this._shortWeekdaysParse = [];
              this._fullWeekdaysParse = [];
          }
  
          for (i = 0; i < 7; i++) {
              // make the regex if we don't have it already
  
              mom = local__createLocal([2000, 1]).day(i);
              if (strict && !this._fullWeekdaysParse[i]) {
                  this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
                  this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
                  this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
              }
              if (!this._weekdaysParse[i]) {
                  regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
                  this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
              }
              // test the regex
              if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
                  return i;
              } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
                  return i;
              } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
                  return i;
              } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
                  return i;
              }
          }
      }
  
      // MOMENTS
  
      function getSetDayOfWeek (input) {
          if (!this.isValid()) {
              return input != null ? this : NaN;
          }
          var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
          if (input != null) {
              input = parseWeekday(input, this.localeData());
              return this.add(input - day, 'd');
          } else {
              return day;
          }
      }
  
      function getSetLocaleDayOfWeek (input) {
          if (!this.isValid()) {
              return input != null ? this : NaN;
          }
          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
          return input == null ? weekday : this.add(input - weekday, 'd');
      }
  
      function getSetISODayOfWeek (input) {
          if (!this.isValid()) {
              return input != null ? this : NaN;
          }
          // behaves the same as moment#day except
          // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
          // as a setter, sunday should belong to the previous week.
          return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
      }
  
      // FORMATTING
  
      addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
  
      // ALIASES
  
      addUnitAlias('dayOfYear', 'DDD');
  
      // PARSING
  
      addRegexToken('DDD',  match1to3);
      addRegexToken('DDDD', match3);
      addParseToken(['DDD', 'DDDD'], function (input, array, config) {
          config._dayOfYear = toInt(input);
      });
  
      // HELPERS
  
      // MOMENTS
  
      function getSetDayOfYear (input) {
          var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
          return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
      }
  
      // FORMATTING
  
      function hFormat() {
          return this.hours() % 12 || 12;
      }
  
      addFormatToken('H', ['HH', 2], 0, 'hour');
      addFormatToken('h', ['hh', 2], 0, hFormat);
  
      addFormatToken('hmm', 0, 0, function () {
          return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
      });
  
      addFormatToken('hmmss', 0, 0, function () {
          return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
              zeroFill(this.seconds(), 2);
      });
  
      addFormatToken('Hmm', 0, 0, function () {
          return '' + this.hours() + zeroFill(this.minutes(), 2);
      });
  
      addFormatToken('Hmmss', 0, 0, function () {
          return '' + this.hours() + zeroFill(this.minutes(), 2) +
              zeroFill(this.seconds(), 2);
      });
  
      function meridiem (token, lowercase) {
          addFormatToken(token, 0, 0, function () {
              return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
          });
      }
  
      meridiem('a', true);
      meridiem('A', false);
  
      // ALIASES
  
      addUnitAlias('hour', 'h');
  
      // PARSING
  
      function matchMeridiem (isStrict, locale) {
          return locale._meridiemParse;
      }
  
      addRegexToken('a',  matchMeridiem);
      addRegexToken('A',  matchMeridiem);
      addRegexToken('H',  match1to2);
      addRegexToken('h',  match1to2);
      addRegexToken('HH', match1to2, match2);
      addRegexToken('hh', match1to2, match2);
  
      addRegexToken('hmm', match3to4);
      addRegexToken('hmmss', match5to6);
      addRegexToken('Hmm', match3to4);
      addRegexToken('Hmmss', match5to6);
  
      addParseToken(['H', 'HH'], HOUR);
      addParseToken(['a', 'A'], function (input, array, config) {
          config._isPm = config._locale.isPM(input);
          config._meridiem = input;
      });
      addParseToken(['h', 'hh'], function (input, array, config) {
          array[HOUR] = toInt(input);
          getParsingFlags(config).bigHour = true;
      });
      addParseToken('hmm', function (input, array, config) {
          var pos = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos));
          array[MINUTE] = toInt(input.substr(pos));
          getParsingFlags(config).bigHour = true;
      });
      addParseToken('hmmss', function (input, array, config) {
          var pos1 = input.length - 4;
          var pos2 = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos1));
          array[MINUTE] = toInt(input.substr(pos1, 2));
          array[SECOND] = toInt(input.substr(pos2));
          getParsingFlags(config).bigHour = true;
      });
      addParseToken('Hmm', function (input, array, config) {
          var pos = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos));
          array[MINUTE] = toInt(input.substr(pos));
      });
      addParseToken('Hmmss', function (input, array, config) {
          var pos1 = input.length - 4;
          var pos2 = input.length - 2;
          array[HOUR] = toInt(input.substr(0, pos1));
          array[MINUTE] = toInt(input.substr(pos1, 2));
          array[SECOND] = toInt(input.substr(pos2));
      });
  
      // LOCALES
  
      function localeIsPM (input) {
          // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
          // Using charAt should be more compatible.
          return ((input + '').toLowerCase().charAt(0) === 'p');
      }
  
      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
      function localeMeridiem (hours, minutes, isLower) {
          if (hours > 11) {
              return isLower ? 'pm' : 'PM';
          } else {
              return isLower ? 'am' : 'AM';
          }
      }
  
  
      // MOMENTS
  
      // Setting the hour should keep the time, because the user explicitly
      // specified which hour he wants. So trying to maintain the same hour (in
      // a new timezone) makes sense. Adding/subtracting hours does not follow
      // this rule.
      var getSetHour = makeGetSet('Hours', true);
  
      // FORMATTING
  
      addFormatToken('m', ['mm', 2], 0, 'minute');
  
      // ALIASES
  
      addUnitAlias('minute', 'm');
  
      // PARSING
  
      addRegexToken('m',  match1to2);
      addRegexToken('mm', match1to2, match2);
      addParseToken(['m', 'mm'], MINUTE);
  
      // MOMENTS
  
      var getSetMinute = makeGetSet('Minutes', false);
  
      // FORMATTING
  
      addFormatToken('s', ['ss', 2], 0, 'second');
  
      // ALIASES
  
      addUnitAlias('second', 's');
  
      // PARSING
  
      addRegexToken('s',  match1to2);
      addRegexToken('ss', match1to2, match2);
      addParseToken(['s', 'ss'], SECOND);
  
      // MOMENTS
  
      var getSetSecond = makeGetSet('Seconds', false);
  
      // FORMATTING
  
      addFormatToken('S', 0, 0, function () {
          return ~~(this.millisecond() / 100);
      });
  
      addFormatToken(0, ['SS', 2], 0, function () {
          return ~~(this.millisecond() / 10);
      });
  
      addFormatToken(0, ['SSS', 3], 0, 'millisecond');
      addFormatToken(0, ['SSSS', 4], 0, function () {
          return this.millisecond() * 10;
      });
      addFormatToken(0, ['SSSSS', 5], 0, function () {
          return this.millisecond() * 100;
      });
      addFormatToken(0, ['SSSSSS', 6], 0, function () {
          return this.millisecond() * 1000;
      });
      addFormatToken(0, ['SSSSSSS', 7], 0, function () {
          return this.millisecond() * 10000;
      });
      addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
          return this.millisecond() * 100000;
      });
      addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
          return this.millisecond() * 1000000;
      });
  
  
      // ALIASES
  
      addUnitAlias('millisecond', 'ms');
  
      // PARSING
  
      addRegexToken('S',    match1to3, match1);
      addRegexToken('SS',   match1to3, match2);
      addRegexToken('SSS',  match1to3, match3);
  
      var token;
      for (token = 'SSSS'; token.length <= 9; token += 'S') {
          addRegexToken(token, matchUnsigned);
      }
  
      function parseMs(input, array) {
          array[MILLISECOND] = toInt(('0.' + input) * 1000);
      }
  
      for (token = 'S'; token.length <= 9; token += 'S') {
          addParseToken(token, parseMs);
      }
      // MOMENTS
  
      var getSetMillisecond = makeGetSet('Milliseconds', false);
  
      // FORMATTING
  
      addFormatToken('z',  0, 0, 'zoneAbbr');
      addFormatToken('zz', 0, 0, 'zoneName');
  
      // MOMENTS
  
      function getZoneAbbr () {
          return this._isUTC ? 'UTC' : '';
      }
  
      function getZoneName () {
          return this._isUTC ? 'Coordinated Universal Time' : '';
      }
  
      var momentPrototype__proto = Moment.prototype;
  
      momentPrototype__proto.add               = add_subtract__add;
      momentPrototype__proto.calendar          = moment_calendar__calendar;
      momentPrototype__proto.clone             = clone;
      momentPrototype__proto.diff              = diff;
      momentPrototype__proto.endOf             = endOf;
      momentPrototype__proto.format            = moment_format__format;
      momentPrototype__proto.from              = from;
      momentPrototype__proto.fromNow           = fromNow;
      momentPrototype__proto.to                = to;
      momentPrototype__proto.toNow             = toNow;
      momentPrototype__proto.get               = getSet;
      momentPrototype__proto.invalidAt         = invalidAt;
      momentPrototype__proto.isAfter           = isAfter;
      momentPrototype__proto.isBefore          = isBefore;
      momentPrototype__proto.isBetween         = isBetween;
      momentPrototype__proto.isSame            = isSame;
      momentPrototype__proto.isSameOrAfter     = isSameOrAfter;
      momentPrototype__proto.isSameOrBefore    = isSameOrBefore;
      momentPrototype__proto.isValid           = moment_valid__isValid;
      momentPrototype__proto.lang              = lang;
      momentPrototype__proto.locale            = locale;
      momentPrototype__proto.localeData        = localeData;
      momentPrototype__proto.max               = prototypeMax;
      momentPrototype__proto.min               = prototypeMin;
      momentPrototype__proto.parsingFlags      = parsingFlags;
      momentPrototype__proto.set               = getSet;
      momentPrototype__proto.startOf           = startOf;
      momentPrototype__proto.subtract          = add_subtract__subtract;
      momentPrototype__proto.toArray           = toArray;
      momentPrototype__proto.toObject          = toObject;
      momentPrototype__proto.toDate            = toDate;
      momentPrototype__proto.toISOString       = moment_format__toISOString;
      momentPrototype__proto.toJSON            = toJSON;
      momentPrototype__proto.toString          = toString;
      momentPrototype__proto.unix              = unix;
      momentPrototype__proto.valueOf           = to_type__valueOf;
      momentPrototype__proto.creationData      = creationData;
  
      // Year
      momentPrototype__proto.year       = getSetYear;
      momentPrototype__proto.isLeapYear = getIsLeapYear;
  
      // Week Year
      momentPrototype__proto.weekYear    = getSetWeekYear;
      momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
  
      // Quarter
      momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
  
      // Month
      momentPrototype__proto.month       = getSetMonth;
      momentPrototype__proto.daysInMonth = getDaysInMonth;
  
      // Week
      momentPrototype__proto.week           = momentPrototype__proto.weeks        = getSetWeek;
      momentPrototype__proto.isoWeek        = momentPrototype__proto.isoWeeks     = getSetISOWeek;
      momentPrototype__proto.weeksInYear    = getWeeksInYear;
      momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
  
      // Day
      momentPrototype__proto.date       = getSetDayOfMonth;
      momentPrototype__proto.day        = momentPrototype__proto.days             = getSetDayOfWeek;
      momentPrototype__proto.weekday    = getSetLocaleDayOfWeek;
      momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
      momentPrototype__proto.dayOfYear  = getSetDayOfYear;
  
      // Hour
      momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
  
      // Minute
      momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
  
      // Second
      momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
  
      // Millisecond
      momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
  
      // Offset
      momentPrototype__proto.utcOffset            = getSetOffset;
      momentPrototype__proto.utc                  = setOffsetToUTC;
      momentPrototype__proto.local                = setOffsetToLocal;
      momentPrototype__proto.parseZone            = setOffsetToParsedOffset;
      momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
      momentPrototype__proto.isDST                = isDaylightSavingTime;
      momentPrototype__proto.isDSTShifted         = isDaylightSavingTimeShifted;
      momentPrototype__proto.isLocal              = isLocal;
      momentPrototype__proto.isUtcOffset          = isUtcOffset;
      momentPrototype__proto.isUtc                = isUtc;
      momentPrototype__proto.isUTC                = isUtc;
  
      // Timezone
      momentPrototype__proto.zoneAbbr = getZoneAbbr;
      momentPrototype__proto.zoneName = getZoneName;
  
      // Deprecations
      momentPrototype__proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
      momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
      momentPrototype__proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
      momentPrototype__proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
  
      var momentPrototype = momentPrototype__proto;
  
      function moment_moment__createUnix (input) {
          return local__createLocal(input * 1000);
      }
  
      function moment_moment__createInZone () {
          return local__createLocal.apply(null, arguments).parseZone();
      }
  
      var defaultCalendar = {
          sameDay : '[Today at] LT',
          nextDay : '[Tomorrow at] LT',
          nextWeek : 'dddd [at] LT',
          lastDay : '[Yesterday at] LT',
          lastWeek : '[Last] dddd [at] LT',
          sameElse : 'L'
      };
  
      function locale_calendar__calendar (key, mom, now) {
          var output = this._calendar[key];
          return isFunction(output) ? output.call(mom, now) : output;
      }
  
      var defaultLongDateFormat = {
          LTS  : 'h:mm:ss A',
          LT   : 'h:mm A',
          L    : 'MM/DD/YYYY',
          LL   : 'MMMM D, YYYY',
          LLL  : 'MMMM D, YYYY h:mm A',
          LLLL : 'dddd, MMMM D, YYYY h:mm A'
      };
  
      function longDateFormat (key) {
          var format = this._longDateFormat[key],
              formatUpper = this._longDateFormat[key.toUpperCase()];
  
          if (format || !formatUpper) {
              return format;
          }
  
          this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
              return val.slice(1);
          });
  
          return this._longDateFormat[key];
      }
  
      var defaultInvalidDate = 'Invalid date';
  
      function invalidDate () {
          return this._invalidDate;
      }
  
      var defaultOrdinal = '%d';
      var defaultOrdinalParse = /\d{1,2}/;
  
      function ordinal (number) {
          return this._ordinal.replace('%d', number);
      }
  
      function preParsePostFormat (string) {
          return string;
      }
  
      var defaultRelativeTime = {
          future : 'in %s',
          past   : '%s ago',
          s  : 'a few seconds',
          m  : 'a minute',
          mm : '%d minutes',
          h  : 'an hour',
          hh : '%d hours',
          d  : 'a day',
          dd : '%d days',
          M  : 'a month',
          MM : '%d months',
          y  : 'a year',
          yy : '%d years'
      };
  
      function relative__relativeTime (number, withoutSuffix, string, isFuture) {
          var output = this._relativeTime[string];
          return (isFunction(output)) ?
              output(number, withoutSuffix, string, isFuture) :
              output.replace(/%d/i, number);
      }
  
      function pastFuture (diff, output) {
          var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
          return isFunction(format) ? format(output) : format.replace(/%s/i, output);
      }
  
      function locale_set__set (config) {
          var prop, i;
          for (i in config) {
              prop = config[i];
              if (isFunction(prop)) {
                  this[i] = prop;
              } else {
                  this['_' + i] = prop;
              }
          }
          // Lenient ordinal parsing accepts just a number in addition to
          // number + (possibly) stuff coming from _ordinalParseLenient.
          this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
      }
  
      var prototype__proto = Locale.prototype;
  
      prototype__proto._calendar       = defaultCalendar;
      prototype__proto.calendar        = locale_calendar__calendar;
      prototype__proto._longDateFormat = defaultLongDateFormat;
      prototype__proto.longDateFormat  = longDateFormat;
      prototype__proto._invalidDate    = defaultInvalidDate;
      prototype__proto.invalidDate     = invalidDate;
      prototype__proto._ordinal        = defaultOrdinal;
      prototype__proto.ordinal         = ordinal;
      prototype__proto._ordinalParse   = defaultOrdinalParse;
      prototype__proto.preparse        = preParsePostFormat;
      prototype__proto.postformat      = preParsePostFormat;
      prototype__proto._relativeTime   = defaultRelativeTime;
      prototype__proto.relativeTime    = relative__relativeTime;
      prototype__proto.pastFuture      = pastFuture;
      prototype__proto.set             = locale_set__set;
  
      // Month
      prototype__proto.months            =        localeMonths;
      prototype__proto._months           = defaultLocaleMonths;
      prototype__proto.monthsShort       =        localeMonthsShort;
      prototype__proto._monthsShort      = defaultLocaleMonthsShort;
      prototype__proto.monthsParse       =        localeMonthsParse;
      prototype__proto._monthsRegex      = defaultMonthsRegex;
      prototype__proto.monthsRegex       = monthsRegex;
      prototype__proto._monthsShortRegex = defaultMonthsShortRegex;
      prototype__proto.monthsShortRegex  = monthsShortRegex;
  
      // Week
      prototype__proto.week = localeWeek;
      prototype__proto._week = defaultLocaleWeek;
      prototype__proto.firstDayOfYear = localeFirstDayOfYear;
      prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
  
      // Day of Week
      prototype__proto.weekdays       =        localeWeekdays;
      prototype__proto._weekdays      = defaultLocaleWeekdays;
      prototype__proto.weekdaysMin    =        localeWeekdaysMin;
      prototype__proto._weekdaysMin   = defaultLocaleWeekdaysMin;
      prototype__proto.weekdaysShort  =        localeWeekdaysShort;
      prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
      prototype__proto.weekdaysParse  =        localeWeekdaysParse;
  
      // Hours
      prototype__proto.isPM = localeIsPM;
      prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
      prototype__proto.meridiem = localeMeridiem;
  
      function lists__get (format, index, field, setter) {
          var locale = locale_locales__getLocale();
          var utc = create_utc__createUTC().set(setter, index);
          return locale[field](utc, format);
      }
  
      function list (format, index, field, count, setter) {
          if (typeof format === 'number') {
              index = format;
              format = undefined;
          }
  
          format = format || '';
  
          if (index != null) {
              return lists__get(format, index, field, setter);
          }
  
          var i;
          var out = [];
          for (i = 0; i < count; i++) {
              out[i] = lists__get(format, i, field, setter);
          }
          return out;
      }
  
      function lists__listMonths (format, index) {
          return list(format, index, 'months', 12, 'month');
      }
  
      function lists__listMonthsShort (format, index) {
          return list(format, index, 'monthsShort', 12, 'month');
      }
  
      function lists__listWeekdays (format, index) {
          return list(format, index, 'weekdays', 7, 'day');
      }
  
      function lists__listWeekdaysShort (format, index) {
          return list(format, index, 'weekdaysShort', 7, 'day');
      }
  
      function lists__listWeekdaysMin (format, index) {
          return list(format, index, 'weekdaysMin', 7, 'day');
      }
  
      locale_locales__getSetGlobalLocale('en', {
          ordinalParse: /\d{1,2}(th|st|nd|rd)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (toInt(number % 100 / 10) === 1) ? 'th' :
                  (b === 1) ? 'st' :
                  (b === 2) ? 'nd' :
                  (b === 3) ? 'rd' : 'th';
              return number + output;
          }
      });
  
      // Side effect imports
      utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
      utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
  
      var mathAbs = Math.abs;
  
      function duration_abs__abs () {
          var data           = this._data;
  
          this._milliseconds = mathAbs(this._milliseconds);
          this._days         = mathAbs(this._days);
          this._months       = mathAbs(this._months);
  
          data.milliseconds  = mathAbs(data.milliseconds);
          data.seconds       = mathAbs(data.seconds);
          data.minutes       = mathAbs(data.minutes);
          data.hours         = mathAbs(data.hours);
          data.months        = mathAbs(data.months);
          data.years         = mathAbs(data.years);
  
          return this;
      }
  
      function duration_add_subtract__addSubtract (duration, input, value, direction) {
          var other = create__createDuration(input, value);
  
          duration._milliseconds += direction * other._milliseconds;
          duration._days         += direction * other._days;
          duration._months       += direction * other._months;
  
          return duration._bubble();
      }
  
      // supports only 2.0-style add(1, 's') or add(duration)
      function duration_add_subtract__add (input, value) {
          return duration_add_subtract__addSubtract(this, input, value, 1);
      }
  
      // supports only 2.0-style subtract(1, 's') or subtract(duration)
      function duration_add_subtract__subtract (input, value) {
          return duration_add_subtract__addSubtract(this, input, value, -1);
      }
  
      function absCeil (number) {
          if (number < 0) {
              return Math.floor(number);
          } else {
              return Math.ceil(number);
          }
      }
  
      function bubble () {
          var milliseconds = this._milliseconds;
          var days         = this._days;
          var months       = this._months;
          var data         = this._data;
          var seconds, minutes, hours, years, monthsFromDays;
  
          // if we have a mix of positive and negative values, bubble down first
          // check: https://github.com/moment/moment/issues/2166
          if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
                  (milliseconds <= 0 && days <= 0 && months <= 0))) {
              milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
              days = 0;
              months = 0;
          }
  
          // The following code bubbles up values, see the tests for
          // examples of what that means.
          data.milliseconds = milliseconds % 1000;
  
          seconds           = absFloor(milliseconds / 1000);
          data.seconds      = seconds % 60;
  
          minutes           = absFloor(seconds / 60);
          data.minutes      = minutes % 60;
  
          hours             = absFloor(minutes / 60);
          data.hours        = hours % 24;
  
          days += absFloor(hours / 24);
  
          // convert days to months
          monthsFromDays = absFloor(daysToMonths(days));
          months += monthsFromDays;
          days -= absCeil(monthsToDays(monthsFromDays));
  
          // 12 months -> 1 year
          years = absFloor(months / 12);
          months %= 12;
  
          data.days   = days;
          data.months = months;
          data.years  = years;
  
          return this;
      }
  
      function daysToMonths (days) {
          // 400 years have 146097 days (taking into account leap year rules)
          // 400 years have 12 months === 4800
          return days * 4800 / 146097;
      }
  
      function monthsToDays (months) {
          // the reverse of daysToMonths
          return months * 146097 / 4800;
      }
  
      function as (units) {
          var days;
          var months;
          var milliseconds = this._milliseconds;
  
          units = normalizeUnits(units);
  
          if (units === 'month' || units === 'year') {
              days   = this._days   + milliseconds / 864e5;
              months = this._months + daysToMonths(days);
              return units === 'month' ? months : months / 12;
          } else {
              // handle milliseconds separately because of floating point math errors (issue #1867)
              days = this._days + Math.round(monthsToDays(this._months));
              switch (units) {
                  case 'week'   : return days / 7     + milliseconds / 6048e5;
                  case 'day'    : return days         + milliseconds / 864e5;
                  case 'hour'   : return days * 24    + milliseconds / 36e5;
                  case 'minute' : return days * 1440  + milliseconds / 6e4;
                  case 'second' : return days * 86400 + milliseconds / 1000;
                  // Math.floor prevents floating point math errors here
                  case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
                  default: throw new Error('Unknown unit ' + units);
              }
          }
      }
  
      // TODO: Use this.as('ms')?
      function duration_as__valueOf () {
          return (
              this._milliseconds +
              this._days * 864e5 +
              (this._months % 12) * 2592e6 +
              toInt(this._months / 12) * 31536e6
          );
      }
  
      function makeAs (alias) {
          return function () {
              return this.as(alias);
          };
      }
  
      var asMilliseconds = makeAs('ms');
      var asSeconds      = makeAs('s');
      var asMinutes      = makeAs('m');
      var asHours        = makeAs('h');
      var asDays         = makeAs('d');
      var asWeeks        = makeAs('w');
      var asMonths       = makeAs('M');
      var asYears        = makeAs('y');
  
      function duration_get__get (units) {
          units = normalizeUnits(units);
          return this[units + 's']();
      }
  
      function makeGetter(name) {
          return function () {
              return this._data[name];
          };
      }
  
      var milliseconds = makeGetter('milliseconds');
      var seconds      = makeGetter('seconds');
      var minutes      = makeGetter('minutes');
      var hours        = makeGetter('hours');
      var days         = makeGetter('days');
      var duration_get__months       = makeGetter('months');
      var years        = makeGetter('years');
  
      function weeks () {
          return absFloor(this.days() / 7);
      }
  
      var round = Math.round;
      var thresholds = {
          s: 45,  // seconds to minute
          m: 45,  // minutes to hour
          h: 22,  // hours to day
          d: 26,  // days to month
          M: 11   // months to year
      };
  
      // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
      function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
          return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
      }
  
      function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
          var duration = create__createDuration(posNegDuration).abs();
          var seconds  = round(duration.as('s'));
          var minutes  = round(duration.as('m'));
          var hours    = round(duration.as('h'));
          var days     = round(duration.as('d'));
          var months   = round(duration.as('M'));
          var years    = round(duration.as('y'));
  
          var a = seconds < thresholds.s && ['s', seconds]  ||
                  minutes <= 1           && ['m']           ||
                  minutes < thresholds.m && ['mm', minutes] ||
                  hours   <= 1           && ['h']           ||
                  hours   < thresholds.h && ['hh', hours]   ||
                  days    <= 1           && ['d']           ||
                  days    < thresholds.d && ['dd', days]    ||
                  months  <= 1           && ['M']           ||
                  months  < thresholds.M && ['MM', months]  ||
                  years   <= 1           && ['y']           || ['yy', years];
  
          a[2] = withoutSuffix;
          a[3] = +posNegDuration > 0;
          a[4] = locale;
          return substituteTimeAgo.apply(null, a);
      }
  
      // This function allows you to set a threshold for relative time strings
      function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
          if (thresholds[threshold] === undefined) {
              return false;
          }
          if (limit === undefined) {
              return thresholds[threshold];
          }
          thresholds[threshold] = limit;
          return true;
      }
  
      function humanize (withSuffix) {
          var locale = this.localeData();
          var output = duration_humanize__relativeTime(this, !withSuffix, locale);
  
          if (withSuffix) {
              output = locale.pastFuture(+this, output);
          }
  
          return locale.postformat(output);
      }
  
      var iso_string__abs = Math.abs;
  
      function iso_string__toISOString() {
          // for ISO strings we do not use the normal bubbling rules:
          //  * milliseconds bubble up until they become hours
          //  * days do not bubble at all
          //  * months bubble up until they become years
          // This is because there is no context-free conversion between hours and days
          // (think of clock changes)
          // and also not between days and months (28-31 days per month)
          var seconds = iso_string__abs(this._milliseconds) / 1000;
          var days         = iso_string__abs(this._days);
          var months       = iso_string__abs(this._months);
          var minutes, hours, years;
  
          // 3600 seconds -> 60 minutes -> 1 hour
          minutes           = absFloor(seconds / 60);
          hours             = absFloor(minutes / 60);
          seconds %= 60;
          minutes %= 60;
  
          // 12 months -> 1 year
          years  = absFloor(months / 12);
          months %= 12;
  
  
          // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
          var Y = years;
          var M = months;
          var D = days;
          var h = hours;
          var m = minutes;
          var s = seconds;
          var total = this.asSeconds();
  
          if (!total) {
              // this is the same as C#'s (Noda) and python (isodate)...
              // but not other JS (goog.date)
              return 'P0D';
          }
  
          return (total < 0 ? '-' : '') +
              'P' +
              (Y ? Y + 'Y' : '') +
              (M ? M + 'M' : '') +
              (D ? D + 'D' : '') +
              ((h || m || s) ? 'T' : '') +
              (h ? h + 'H' : '') +
              (m ? m + 'M' : '') +
              (s ? s + 'S' : '');
      }
  
      var duration_prototype__proto = Duration.prototype;
  
      duration_prototype__proto.abs            = duration_abs__abs;
      duration_prototype__proto.add            = duration_add_subtract__add;
      duration_prototype__proto.subtract       = duration_add_subtract__subtract;
      duration_prototype__proto.as             = as;
      duration_prototype__proto.asMilliseconds = asMilliseconds;
      duration_prototype__proto.asSeconds      = asSeconds;
      duration_prototype__proto.asMinutes      = asMinutes;
      duration_prototype__proto.asHours        = asHours;
      duration_prototype__proto.asDays         = asDays;
      duration_prototype__proto.asWeeks        = asWeeks;
      duration_prototype__proto.asMonths       = asMonths;
      duration_prototype__proto.asYears        = asYears;
      duration_prototype__proto.valueOf        = duration_as__valueOf;
      duration_prototype__proto._bubble        = bubble;
      duration_prototype__proto.get            = duration_get__get;
      duration_prototype__proto.milliseconds   = milliseconds;
      duration_prototype__proto.seconds        = seconds;
      duration_prototype__proto.minutes        = minutes;
      duration_prototype__proto.hours          = hours;
      duration_prototype__proto.days           = days;
      duration_prototype__proto.weeks          = weeks;
      duration_prototype__proto.months         = duration_get__months;
      duration_prototype__proto.years          = years;
      duration_prototype__proto.humanize       = humanize;
      duration_prototype__proto.toISOString    = iso_string__toISOString;
      duration_prototype__proto.toString       = iso_string__toISOString;
      duration_prototype__proto.toJSON         = iso_string__toISOString;
      duration_prototype__proto.locale         = locale;
      duration_prototype__proto.localeData     = localeData;
  
      // Deprecations
      duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
      duration_prototype__proto.lang = lang;
  
      // Side effect imports
  
      // FORMATTING
  
      addFormatToken('X', 0, 0, 'unix');
      addFormatToken('x', 0, 0, 'valueOf');
  
      // PARSING
  
      addRegexToken('x', matchSigned);
      addRegexToken('X', matchTimestamp);
      addParseToken('X', function (input, array, config) {
          config._d = new Date(parseFloat(input, 10) * 1000);
      });
      addParseToken('x', function (input, array, config) {
          config._d = new Date(toInt(input));
      });
  
      // Side effect imports
  
      ;
  
      //! moment.js
      //! version : 2.11.2
      //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
      //! license : MIT
      //! momentjs.com
  
      utils_hooks__hooks.version = '2.11.2';
  
      setHookCallback(local__createLocal);
  
      utils_hooks__hooks.fn                    = momentPrototype;
      utils_hooks__hooks.min                   = min;
      utils_hooks__hooks.max                   = max;
      utils_hooks__hooks.now                   = now;
      utils_hooks__hooks.utc                   = create_utc__createUTC;
      utils_hooks__hooks.unix                  = moment_moment__createUnix;
      utils_hooks__hooks.months                = lists__listMonths;
      utils_hooks__hooks.isDate                = isDate;
      utils_hooks__hooks.locale                = locale_locales__getSetGlobalLocale;
      utils_hooks__hooks.invalid               = valid__createInvalid;
      utils_hooks__hooks.duration              = create__createDuration;
      utils_hooks__hooks.isMoment              = isMoment;
      utils_hooks__hooks.weekdays              = lists__listWeekdays;
      utils_hooks__hooks.parseZone             = moment_moment__createInZone;
      utils_hooks__hooks.localeData            = locale_locales__getLocale;
      utils_hooks__hooks.isDuration            = isDuration;
      utils_hooks__hooks.monthsShort           = lists__listMonthsShort;
      utils_hooks__hooks.weekdaysMin           = lists__listWeekdaysMin;
      utils_hooks__hooks.defineLocale          = defineLocale;
      utils_hooks__hooks.weekdaysShort         = lists__listWeekdaysShort;
      utils_hooks__hooks.normalizeUnits        = normalizeUnits;
      utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
      utils_hooks__hooks.prototype             = momentPrototype;
  
      var moment__default = utils_hooks__hooks;
  
      //! moment.js locale configuration
      //! locale : afrikaans (af)
      //! author : Werner Mollentze : https://github.com/wernerm
  
      var af = moment__default.defineLocale('af', {
          months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
          weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
          weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
          weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
          meridiemParse: /vm|nm/i,
          isPM : function (input) {
              return /^nm$/i.test(input);
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours < 12) {
                  return isLower ? 'vm' : 'VM';
              } else {
                  return isLower ? 'nm' : 'NM';
              }
          },
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[Vandag om] LT',
              nextDay : '[Môre om] LT',
              nextWeek : 'dddd [om] LT',
              lastDay : '[Gister om] LT',
              lastWeek : '[Laas] dddd [om] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'oor %s',
              past : '%s gelede',
              s : '\'n paar sekondes',
              m : '\'n minuut',
              mm : '%d minute',
              h : '\'n uur',
              hh : '%d ure',
              d : '\'n dag',
              dd : '%d dae',
              M : '\'n maand',
              MM : '%d maande',
              y : '\'n jaar',
              yy : '%d jaar'
          },
          ordinalParse: /\d{1,2}(ste|de)/,
          ordinal : function (number) {
              return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
          },
          week : {
              dow : 1, // Maandag is die eerste dag van die week.
              doy : 4  // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Moroccan Arabic (ar-ma)
      //! author : ElFadili Yassine : https://github.com/ElFadiliY
      //! author : Abdel Said : https://github.com/abdelsaid
  
      var ar_ma = moment__default.defineLocale('ar-ma', {
          months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
          monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
          weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
          weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
          weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[اليوم على الساعة] LT',
              nextDay: '[غدا على الساعة] LT',
              nextWeek: 'dddd [على الساعة] LT',
              lastDay: '[أمس على الساعة] LT',
              lastWeek: 'dddd [على الساعة] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'في %s',
              past : 'منذ %s',
              s : 'ثوان',
              m : 'دقيقة',
              mm : '%d دقائق',
              h : 'ساعة',
              hh : '%d ساعات',
              d : 'يوم',
              dd : '%d أيام',
              M : 'شهر',
              MM : '%d أشهر',
              y : 'سنة',
              yy : '%d سنوات'
          },
          week : {
              dow : 0, // Saturday is the first day of the week.
              doy : 12  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Arabic Saudi Arabia (ar-sa)
      //! author : Suhail Alkowaileet : https://github.com/xsoh
  
      var ar_sa__symbolMap = {
          '1': '1',
          '2': '2',
          '3': '3',
          '4': '4',
          '5': '5',
          '6': '6',
          '7': '7',
          '8': '8',
          '9': '9',
          '0': '0'
      }, ar_sa__numberMap = {
          '1': '1',
          '2': '2',
          '3': '3',
          '4': '4',
          '5': '5',
          '6': '6',
          '7': '7',
          '8': '8',
          '9': '9',
          '0': '0'
      };
  
      var ar_sa = moment__default.defineLocale('ar-sa', {
          months : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
          monthsShort : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
          weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
          weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
          weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          meridiemParse: /ص|م/,
          isPM : function (input) {
              return 'م' === input;
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 12) {
                  return 'ص';
              } else {
                  return 'م';
              }
          },
          calendar : {
              sameDay: '[اليوم على الساعة] LT',
              nextDay: '[غدا على الساعة] LT',
              nextWeek: 'dddd [على الساعة] LT',
              lastDay: '[أمس على الساعة] LT',
              lastWeek: 'dddd [على الساعة] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'في %s',
              past : 'منذ %s',
              s : 'ثوان',
              m : 'دقيقة',
              mm : '%d دقائق',
              h : 'ساعة',
              hh : '%d ساعات',
              d : 'يوم',
              dd : '%d أيام',
              M : 'شهر',
              MM : '%d أشهر',
              y : 'سنة',
              yy : '%d سنوات'
          },
          preparse: function (string) {
              return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
                  return ar_sa__numberMap[match];
              }).replace(/،/g, ',');
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return ar_sa__symbolMap[match];
              }).replace(/,/g, '،');
          },
          week : {
              dow : 0, // Saturday is the first day of the week.
              doy : 12  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale  : Tunisian Arabic (ar-tn)
  
      var ar_tn = moment__default.defineLocale('ar-tn', {
          months: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
          monthsShort: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
          weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
          weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
          weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
          longDateFormat: {
              LT: 'HH:mm',
              LTS: 'HH:mm:ss',
              L: 'DD/MM/YYYY',
              LL: 'D MMMM YYYY',
              LLL: 'D MMMM YYYY HH:mm',
              LLLL: 'dddd D MMMM YYYY HH:mm'
          },
          calendar: {
              sameDay: '[اليوم على الساعة] LT',
              nextDay: '[غدا على الساعة] LT',
              nextWeek: 'dddd [على الساعة] LT',
              lastDay: '[أمس على الساعة] LT',
              lastWeek: 'dddd [على الساعة] LT',
              sameElse: 'L'
          },
          relativeTime: {
              future: 'في %s',
              past: 'منذ %s',
              s: 'ثوان',
              m: 'دقيقة',
              mm: '%d دقائق',
              h: 'ساعة',
              hh: '%d ساعات',
              d: 'يوم',
              dd: '%d أيام',
              M: 'شهر',
              MM: '%d أشهر',
              y: 'سنة',
              yy: '%d سنوات'
          },
          week: {
              dow: 1, // Monday is the first day of the week.
              doy: 4 // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! Locale: Arabic (ar)
      //! Author: Abdel Said: https://github.com/abdelsaid
      //! Changes in months, weekdays: Ahmed Elkhatib
      //! Native plural forms: forabi https://github.com/forabi
  
      var ar__symbolMap = {
          '1': '١',
          '2': '٢',
          '3': '٣',
          '4': '٤',
          '5': '٥',
          '6': '٦',
          '7': '٧',
          '8': '٨',
          '9': '٩',
          '0': '٠'
      }, ar__numberMap = {
          '١': '1',
          '٢': '2',
          '٣': '3',
          '٤': '4',
          '٥': '5',
          '٦': '6',
          '٧': '7',
          '٨': '8',
          '٩': '9',
          '٠': '0'
      }, pluralForm = function (n) {
          return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
      }, plurals = {
          s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
          m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
          h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
          d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
          M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
          y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
      }, pluralize = function (u) {
          return function (number, withoutSuffix, string, isFuture) {
              var f = pluralForm(number),
                  str = plurals[u][pluralForm(number)];
              if (f === 2) {
                  str = str[withoutSuffix ? 0 : 1];
              }
              return str.replace(/%d/i, number);
          };
      }, ar__months = [
          'كانون الثاني يناير',
          'شباط فبراير',
          'آذار مارس',
          'نيسان أبريل',
          'أيار مايو',
          'حزيران يونيو',
          'تموز يوليو',
          'آب أغسطس',
          'أيلول سبتمبر',
          'تشرين الأول أكتوبر',
          'تشرين الثاني نوفمبر',
          'كانون الأول ديسمبر'
      ];
  
      var ar = moment__default.defineLocale('ar', {
          months : ar__months,
          monthsShort : ar__months,
          weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
          weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
          weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'D/\u200FM/\u200FYYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          meridiemParse: /ص|م/,
          isPM : function (input) {
              return 'م' === input;
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 12) {
                  return 'ص';
              } else {
                  return 'م';
              }
          },
          calendar : {
              sameDay: '[اليوم عند الساعة] LT',
              nextDay: '[غدًا عند الساعة] LT',
              nextWeek: 'dddd [عند الساعة] LT',
              lastDay: '[أمس عند الساعة] LT',
              lastWeek: 'dddd [عند الساعة] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'بعد %s',
              past : 'منذ %s',
              s : pluralize('s'),
              m : pluralize('m'),
              mm : pluralize('m'),
              h : pluralize('h'),
              hh : pluralize('h'),
              d : pluralize('d'),
              dd : pluralize('d'),
              M : pluralize('M'),
              MM : pluralize('M'),
              y : pluralize('y'),
              yy : pluralize('y')
          },
          preparse: function (string) {
              return string.replace(/\u200f/g, '').replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
                  return ar__numberMap[match];
              }).replace(/،/g, ',');
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return ar__symbolMap[match];
              }).replace(/,/g, '،');
          },
          week : {
              dow : 0, // Saturday is the first day of the week.
              doy : 12  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : azerbaijani (az)
      //! author : topchiyev : https://github.com/topchiyev
  
      var az__suffixes = {
          1: '-inci',
          5: '-inci',
          8: '-inci',
          70: '-inci',
          80: '-inci',
          2: '-nci',
          7: '-nci',
          20: '-nci',
          50: '-nci',
          3: '-üncü',
          4: '-üncü',
          100: '-üncü',
          6: '-ncı',
          9: '-uncu',
          10: '-uncu',
          30: '-uncu',
          60: '-ıncı',
          90: '-ıncı'
      };
  
      var az = moment__default.defineLocale('az', {
          months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
          monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
          weekdays : 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
          weekdaysShort : 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
          weekdaysMin : 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[bugün saat] LT',
              nextDay : '[sabah saat] LT',
              nextWeek : '[gələn həftə] dddd [saat] LT',
              lastDay : '[dünən] LT',
              lastWeek : '[keçən həftə] dddd [saat] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s sonra',
              past : '%s əvvəl',
              s : 'birneçə saniyyə',
              m : 'bir dəqiqə',
              mm : '%d dəqiqə',
              h : 'bir saat',
              hh : '%d saat',
              d : 'bir gün',
              dd : '%d gün',
              M : 'bir ay',
              MM : '%d ay',
              y : 'bir il',
              yy : '%d il'
          },
          meridiemParse: /gecə|səhər|gündüz|axşam/,
          isPM : function (input) {
              return /^(gündüz|axşam)$/.test(input);
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'gecə';
              } else if (hour < 12) {
                  return 'səhər';
              } else if (hour < 17) {
                  return 'gündüz';
              } else {
                  return 'axşam';
              }
          },
          ordinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
          ordinal : function (number) {
              if (number === 0) {  // special case for zero
                  return number + '-ıncı';
              }
              var a = number % 10,
                  b = number % 100 - a,
                  c = number >= 100 ? 100 : null;
              return number + (az__suffixes[a] || az__suffixes[b] || az__suffixes[c]);
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : belarusian (be)
      //! author : Dmitry Demidov : https://github.com/demidov91
      //! author: Praleska: http://praleska.pro/
      //! Author : Menelion Elensúle : https://github.com/Oire
  
      function be__plural(word, num) {
          var forms = word.split('_');
          return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
      }
      function be__relativeTimeWithPlural(number, withoutSuffix, key) {
          var format = {
              'mm': withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
              'hh': withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
              'dd': 'дзень_дні_дзён',
              'MM': 'месяц_месяцы_месяцаў',
              'yy': 'год_гады_гадоў'
          };
          if (key === 'm') {
              return withoutSuffix ? 'хвіліна' : 'хвіліну';
          }
          else if (key === 'h') {
              return withoutSuffix ? 'гадзіна' : 'гадзіну';
          }
          else {
              return number + ' ' + be__plural(format[key], +number);
          }
      }
  
      var be = moment__default.defineLocale('be', {
          months : {
              format: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_'),
              standalone: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_')
          },
          monthsShort : 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split('_'),
          weekdays : {
              format: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_'),
              standalone: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
              isFormat: /\[ ?[Вв] ?(?:мінулую|наступную)? ?\] ?dddd/
          },
          weekdaysShort : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
          weekdaysMin : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY г.',
              LLL : 'D MMMM YYYY г., HH:mm',
              LLLL : 'dddd, D MMMM YYYY г., HH:mm'
          },
          calendar : {
              sameDay: '[Сёння ў] LT',
              nextDay: '[Заўтра ў] LT',
              lastDay: '[Учора ў] LT',
              nextWeek: function () {
                  return '[У] dddd [ў] LT';
              },
              lastWeek: function () {
                  switch (this.day()) {
                  case 0:
                  case 3:
                  case 5:
                  case 6:
                      return '[У мінулую] dddd [ў] LT';
                  case 1:
                  case 2:
                  case 4:
                      return '[У мінулы] dddd [ў] LT';
                  }
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'праз %s',
              past : '%s таму',
              s : 'некалькі секунд',
              m : be__relativeTimeWithPlural,
              mm : be__relativeTimeWithPlural,
              h : be__relativeTimeWithPlural,
              hh : be__relativeTimeWithPlural,
              d : 'дзень',
              dd : be__relativeTimeWithPlural,
              M : 'месяц',
              MM : be__relativeTimeWithPlural,
              y : 'год',
              yy : be__relativeTimeWithPlural
          },
          meridiemParse: /ночы|раніцы|дня|вечара/,
          isPM : function (input) {
              return /^(дня|вечара)$/.test(input);
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'ночы';
              } else if (hour < 12) {
                  return 'раніцы';
              } else if (hour < 17) {
                  return 'дня';
              } else {
                  return 'вечара';
              }
          },
          ordinalParse: /\d{1,2}-(і|ы|га)/,
          ordinal: function (number, period) {
              switch (period) {
              case 'M':
              case 'd':
              case 'DDD':
              case 'w':
              case 'W':
                  return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-і' : number + '-ы';
              case 'D':
                  return number + '-га';
              default:
                  return number;
              }
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : bulgarian (bg)
      //! author : Krasen Borisov : https://github.com/kraz
  
      var bg = moment__default.defineLocale('bg', {
          months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
          monthsShort : 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
          weekdays : 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
          weekdaysShort : 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
          weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'D.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY H:mm',
              LLLL : 'dddd, D MMMM YYYY H:mm'
          },
          calendar : {
              sameDay : '[Днес в] LT',
              nextDay : '[Утре в] LT',
              nextWeek : 'dddd [в] LT',
              lastDay : '[Вчера в] LT',
              lastWeek : function () {
                  switch (this.day()) {
                  case 0:
                  case 3:
                  case 6:
                      return '[В изминалата] dddd [в] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[В изминалия] dddd [в] LT';
                  }
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'след %s',
              past : 'преди %s',
              s : 'няколко секунди',
              m : 'минута',
              mm : '%d минути',
              h : 'час',
              hh : '%d часа',
              d : 'ден',
              dd : '%d дни',
              M : 'месец',
              MM : '%d месеца',
              y : 'година',
              yy : '%d години'
          },
          ordinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
          ordinal : function (number) {
              var lastDigit = number % 10,
                  last2Digits = number % 100;
              if (number === 0) {
                  return number + '-ев';
              } else if (last2Digits === 0) {
                  return number + '-ен';
              } else if (last2Digits > 10 && last2Digits < 20) {
                  return number + '-ти';
              } else if (lastDigit === 1) {
                  return number + '-ви';
              } else if (lastDigit === 2) {
                  return number + '-ри';
              } else if (lastDigit === 7 || lastDigit === 8) {
                  return number + '-ми';
              } else {
                  return number + '-ти';
              }
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Bengali (bn)
      //! author : Kaushik Gandhi : https://github.com/kaushikgandhi
  
      var bn__symbolMap = {
          '1': '১',
          '2': '২',
          '3': '৩',
          '4': '৪',
          '5': '৫',
          '6': '৬',
          '7': '৭',
          '8': '৮',
          '9': '৯',
          '0': '০'
      },
      bn__numberMap = {
          '১': '1',
          '২': '2',
          '৩': '3',
          '৪': '4',
          '৫': '5',
          '৬': '6',
          '৭': '7',
          '৮': '8',
          '৯': '9',
          '০': '0'
      };
  
      var bn = moment__default.defineLocale('bn', {
          months : 'জানুয়ারী_ফেবুয়ারী_মার্চ_এপ্রিল_মে_জুন_জুলাই_অগাস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split('_'),
          monthsShort : 'জানু_ফেব_মার্চ_এপর_মে_জুন_জুল_অগ_সেপ্ট_অক্টো_নভ_ডিসেম্'.split('_'),
          weekdays : 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পত্তিবার_শুক্রবার_শনিবার'.split('_'),
          weekdaysShort : 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পত্তি_শুক্র_শনি'.split('_'),
          weekdaysMin : 'রব_সম_মঙ্গ_বু_ব্রিহ_শু_শনি'.split('_'),
          longDateFormat : {
              LT : 'A h:mm সময়',
              LTS : 'A h:mm:ss সময়',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, A h:mm সময়',
              LLLL : 'dddd, D MMMM YYYY, A h:mm সময়'
          },
          calendar : {
              sameDay : '[আজ] LT',
              nextDay : '[আগামীকাল] LT',
              nextWeek : 'dddd, LT',
              lastDay : '[গতকাল] LT',
              lastWeek : '[গত] dddd, LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s পরে',
              past : '%s আগে',
              s : 'কয়েক সেকেন্ড',
              m : 'এক মিনিট',
              mm : '%d মিনিট',
              h : 'এক ঘন্টা',
              hh : '%d ঘন্টা',
              d : 'এক দিন',
              dd : '%d দিন',
              M : 'এক মাস',
              MM : '%d মাস',
              y : 'এক বছর',
              yy : '%d বছর'
          },
          preparse: function (string) {
              return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
                  return bn__numberMap[match];
              });
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return bn__symbolMap[match];
              });
          },
          meridiemParse: /রাত|সকাল|দুপুর|বিকাল|রাত/,
          isPM: function (input) {
              return /^(দুপুর|বিকাল|রাত)$/.test(input);
          },
          //Bengali is a vast language its spoken
          //in different forms in various parts of the world.
          //I have just generalized with most common one used
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'রাত';
              } else if (hour < 10) {
                  return 'সকাল';
              } else if (hour < 17) {
                  return 'দুপুর';
              } else if (hour < 20) {
                  return 'বিকাল';
              } else {
                  return 'রাত';
              }
          },
          week : {
              dow : 0, // Sunday is the first day of the week.
              doy : 6  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : tibetan (bo)
      //! author : Thupten N. Chakrishar : https://github.com/vajradog
  
      var bo__symbolMap = {
          '1': '༡',
          '2': '༢',
          '3': '༣',
          '4': '༤',
          '5': '༥',
          '6': '༦',
          '7': '༧',
          '8': '༨',
          '9': '༩',
          '0': '༠'
      },
      bo__numberMap = {
          '༡': '1',
          '༢': '2',
          '༣': '3',
          '༤': '4',
          '༥': '5',
          '༦': '6',
          '༧': '7',
          '༨': '8',
          '༩': '9',
          '༠': '0'
      };
  
      var bo = moment__default.defineLocale('bo', {
          months : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
          monthsShort : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
          weekdays : 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
          weekdaysShort : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
          weekdaysMin : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
          longDateFormat : {
              LT : 'A h:mm',
              LTS : 'A h:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, A h:mm',
              LLLL : 'dddd, D MMMM YYYY, A h:mm'
          },
          calendar : {
              sameDay : '[དི་རིང] LT',
              nextDay : '[སང་ཉིན] LT',
              nextWeek : '[བདུན་ཕྲག་རྗེས་མ], LT',
              lastDay : '[ཁ་སང] LT',
              lastWeek : '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s ལ་',
              past : '%s སྔན་ལ',
              s : 'ལམ་སང',
              m : 'སྐར་མ་གཅིག',
              mm : '%d སྐར་མ',
              h : 'ཆུ་ཚོད་གཅིག',
              hh : '%d ཆུ་ཚོད',
              d : 'ཉིན་གཅིག',
              dd : '%d ཉིན་',
              M : 'ཟླ་བ་གཅིག',
              MM : '%d ཟླ་བ',
              y : 'ལོ་གཅིག',
              yy : '%d ལོ'
          },
          preparse: function (string) {
              return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
                  return bo__numberMap[match];
              });
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return bo__symbolMap[match];
              });
          },
          meridiemParse: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
          isPM: function (input) {
              return /^(ཉིན་གུང|དགོང་དག|མཚན་མོ)$/.test(input);
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'མཚན་མོ';
              } else if (hour < 10) {
                  return 'ཞོགས་ཀས';
              } else if (hour < 17) {
                  return 'ཉིན་གུང';
              } else if (hour < 20) {
                  return 'དགོང་དག';
              } else {
                  return 'མཚན་མོ';
              }
          },
          week : {
              dow : 0, // Sunday is the first day of the week.
              doy : 6  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : breton (br)
      //! author : Jean-Baptiste Le Duigou : https://github.com/jbleduigou
  
      function relativeTimeWithMutation(number, withoutSuffix, key) {
          var format = {
              'mm': 'munutenn',
              'MM': 'miz',
              'dd': 'devezh'
          };
          return number + ' ' + mutation(format[key], number);
      }
      function specialMutationForYears(number) {
          switch (lastNumber(number)) {
          case 1:
          case 3:
          case 4:
          case 5:
          case 9:
              return number + ' bloaz';
          default:
              return number + ' vloaz';
          }
      }
      function lastNumber(number) {
          if (number > 9) {
              return lastNumber(number % 10);
          }
          return number;
      }
      function mutation(text, number) {
          if (number === 2) {
              return softMutation(text);
          }
          return text;
      }
      function softMutation(text) {
          var mutationTable = {
              'm': 'v',
              'b': 'v',
              'd': 'z'
          };
          if (mutationTable[text.charAt(0)] === undefined) {
              return text;
          }
          return mutationTable[text.charAt(0)] + text.substring(1);
      }
  
      var br = moment__default.defineLocale('br', {
          months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
          monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
          weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
          weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
          weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
          longDateFormat : {
              LT : 'h[e]mm A',
              LTS : 'h[e]mm:ss A',
              L : 'DD/MM/YYYY',
              LL : 'D [a viz] MMMM YYYY',
              LLL : 'D [a viz] MMMM YYYY h[e]mm A',
              LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A'
          },
          calendar : {
              sameDay : '[Hiziv da] LT',
              nextDay : '[Warc\'hoazh da] LT',
              nextWeek : 'dddd [da] LT',
              lastDay : '[Dec\'h da] LT',
              lastWeek : 'dddd [paset da] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'a-benn %s',
              past : '%s \'zo',
              s : 'un nebeud segondennoù',
              m : 'ur vunutenn',
              mm : relativeTimeWithMutation,
              h : 'un eur',
              hh : '%d eur',
              d : 'un devezh',
              dd : relativeTimeWithMutation,
              M : 'ur miz',
              MM : relativeTimeWithMutation,
              y : 'ur bloaz',
              yy : specialMutationForYears
          },
          ordinalParse: /\d{1,2}(añ|vet)/,
          ordinal : function (number) {
              var output = (number === 1) ? 'añ' : 'vet';
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : bosnian (bs)
      //! author : Nedim Cholich : https://github.com/frontyard
      //! based on (hr) translation by Bojan Marković
  
      function bs__translate(number, withoutSuffix, key) {
          var result = number + ' ';
          switch (key) {
          case 'm':
              return withoutSuffix ? 'jedna minuta' : 'jedne minute';
          case 'mm':
              if (number === 1) {
                  result += 'minuta';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'minute';
              } else {
                  result += 'minuta';
              }
              return result;
          case 'h':
              return withoutSuffix ? 'jedan sat' : 'jednog sata';
          case 'hh':
              if (number === 1) {
                  result += 'sat';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'sata';
              } else {
                  result += 'sati';
              }
              return result;
          case 'dd':
              if (number === 1) {
                  result += 'dan';
              } else {
                  result += 'dana';
              }
              return result;
          case 'MM':
              if (number === 1) {
                  result += 'mjesec';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'mjeseca';
              } else {
                  result += 'mjeseci';
              }
              return result;
          case 'yy':
              if (number === 1) {
                  result += 'godina';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'godine';
              } else {
                  result += 'godina';
              }
              return result;
          }
      }
  
      var bs = moment__default.defineLocale('bs', {
          months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
          monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
          weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
          weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
          weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD. MM. YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY H:mm',
              LLLL : 'dddd, D. MMMM YYYY H:mm'
          },
          calendar : {
              sameDay  : '[danas u] LT',
              nextDay  : '[sutra u] LT',
              nextWeek : function () {
                  switch (this.day()) {
                  case 0:
                      return '[u] [nedjelju] [u] LT';
                  case 3:
                      return '[u] [srijedu] [u] LT';
                  case 6:
                      return '[u] [subotu] [u] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[u] dddd [u] LT';
                  }
              },
              lastDay  : '[jučer u] LT',
              lastWeek : function () {
                  switch (this.day()) {
                  case 0:
                  case 3:
                      return '[prošlu] dddd [u] LT';
                  case 6:
                      return '[prošle] [subote] [u] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[prošli] dddd [u] LT';
                  }
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'za %s',
              past   : 'prije %s',
              s      : 'par sekundi',
              m      : bs__translate,
              mm     : bs__translate,
              h      : bs__translate,
              hh     : bs__translate,
              d      : 'dan',
              dd     : bs__translate,
              M      : 'mjesec',
              MM     : bs__translate,
              y      : 'godinu',
              yy     : bs__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : catalan (ca)
      //! author : Juan G. Hurtado : https://github.com/juanghurtado
  
      var ca = moment__default.defineLocale('ca', {
          months : 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
          monthsShort : 'gen._febr._mar._abr._mai._jun._jul._ag._set._oct._nov._des.'.split('_'),
          weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
          weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
          weekdaysMin : 'Dg_Dl_Dt_Dc_Dj_Dv_Ds'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY H:mm',
              LLLL : 'dddd D MMMM YYYY H:mm'
          },
          calendar : {
              sameDay : function () {
                  return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
              },
              nextDay : function () {
                  return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
              },
              nextWeek : function () {
                  return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
              },
              lastDay : function () {
                  return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
              },
              lastWeek : function () {
                  return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'en %s',
              past : 'fa %s',
              s : 'uns segons',
              m : 'un minut',
              mm : '%d minuts',
              h : 'una hora',
              hh : '%d hores',
              d : 'un dia',
              dd : '%d dies',
              M : 'un mes',
              MM : '%d mesos',
              y : 'un any',
              yy : '%d anys'
          },
          ordinalParse: /\d{1,2}(r|n|t|è|a)/,
          ordinal : function (number, period) {
              var output = (number === 1) ? 'r' :
                  (number === 2) ? 'n' :
                  (number === 3) ? 'r' :
                  (number === 4) ? 't' : 'è';
              if (period === 'w' || period === 'W') {
                  output = 'a';
              }
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : czech (cs)
      //! author : petrbela : https://github.com/petrbela
  
      var cs__months = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_'),
          cs__monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_');
      function cs__plural(n) {
          return (n > 1) && (n < 5) && (~~(n / 10) !== 1);
      }
      function cs__translate(number, withoutSuffix, key, isFuture) {
          var result = number + ' ';
          switch (key) {
          case 's':  // a few seconds / in a few seconds / a few seconds ago
              return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
          case 'm':  // a minute / in a minute / a minute ago
              return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
          case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
              if (withoutSuffix || isFuture) {
                  return result + (cs__plural(number) ? 'minuty' : 'minut');
              } else {
                  return result + 'minutami';
              }
              break;
          case 'h':  // an hour / in an hour / an hour ago
              return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
          case 'hh': // 9 hours / in 9 hours / 9 hours ago
              if (withoutSuffix || isFuture) {
                  return result + (cs__plural(number) ? 'hodiny' : 'hodin');
              } else {
                  return result + 'hodinami';
              }
              break;
          case 'd':  // a day / in a day / a day ago
              return (withoutSuffix || isFuture) ? 'den' : 'dnem';
          case 'dd': // 9 days / in 9 days / 9 days ago
              if (withoutSuffix || isFuture) {
                  return result + (cs__plural(number) ? 'dny' : 'dní');
              } else {
                  return result + 'dny';
              }
              break;
          case 'M':  // a month / in a month / a month ago
              return (withoutSuffix || isFuture) ? 'měsíc' : 'měsícem';
          case 'MM': // 9 months / in 9 months / 9 months ago
              if (withoutSuffix || isFuture) {
                  return result + (cs__plural(number) ? 'měsíce' : 'měsíců');
              } else {
                  return result + 'měsíci';
              }
              break;
          case 'y':  // a year / in a year / a year ago
              return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
          case 'yy': // 9 years / in 9 years / 9 years ago
              if (withoutSuffix || isFuture) {
                  return result + (cs__plural(number) ? 'roky' : 'let');
              } else {
                  return result + 'lety';
              }
              break;
          }
      }
  
      var cs = moment__default.defineLocale('cs', {
          months : cs__months,
          monthsShort : cs__monthsShort,
          monthsParse : (function (months, monthsShort) {
              var i, _monthsParse = [];
              for (i = 0; i < 12; i++) {
                  // use custom parser to solve problem with July (červenec)
                  _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
              }
              return _monthsParse;
          }(cs__months, cs__monthsShort)),
          shortMonthsParse : (function (monthsShort) {
              var i, _shortMonthsParse = [];
              for (i = 0; i < 12; i++) {
                  _shortMonthsParse[i] = new RegExp('^' + monthsShort[i] + '$', 'i');
              }
              return _shortMonthsParse;
          }(cs__monthsShort)),
          longMonthsParse : (function (months) {
              var i, _longMonthsParse = [];
              for (i = 0; i < 12; i++) {
                  _longMonthsParse[i] = new RegExp('^' + months[i] + '$', 'i');
              }
              return _longMonthsParse;
          }(cs__months)),
          weekdays : 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
          weekdaysShort : 'ne_po_út_st_čt_pá_so'.split('_'),
          weekdaysMin : 'ne_po_út_st_čt_pá_so'.split('_'),
          longDateFormat : {
              LT: 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY H:mm',
              LLLL : 'dddd D. MMMM YYYY H:mm'
          },
          calendar : {
              sameDay: '[dnes v] LT',
              nextDay: '[zítra v] LT',
              nextWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[v neděli v] LT';
                  case 1:
                  case 2:
                      return '[v] dddd [v] LT';
                  case 3:
                      return '[ve středu v] LT';
                  case 4:
                      return '[ve čtvrtek v] LT';
                  case 5:
                      return '[v pátek v] LT';
                  case 6:
                      return '[v sobotu v] LT';
                  }
              },
              lastDay: '[včera v] LT',
              lastWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[minulou neděli v] LT';
                  case 1:
                  case 2:
                      return '[minulé] dddd [v] LT';
                  case 3:
                      return '[minulou středu v] LT';
                  case 4:
                  case 5:
                      return '[minulý] dddd [v] LT';
                  case 6:
                      return '[minulou sobotu v] LT';
                  }
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'za %s',
              past : 'před %s',
              s : cs__translate,
              m : cs__translate,
              mm : cs__translate,
              h : cs__translate,
              hh : cs__translate,
              d : cs__translate,
              dd : cs__translate,
              M : cs__translate,
              MM : cs__translate,
              y : cs__translate,
              yy : cs__translate
          },
          ordinalParse : /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : chuvash (cv)
      //! author : Anatoly Mironov : https://github.com/mirontoli
  
      var cv = moment__default.defineLocale('cv', {
          months : 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split('_'),
          monthsShort : 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
          weekdays : 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split('_'),
          weekdaysShort : 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
          weekdaysMin : 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD-MM-YYYY',
              LL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
              LLL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
              LLLL : 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm'
          },
          calendar : {
              sameDay: '[Паян] LT [сехетре]',
              nextDay: '[Ыран] LT [сехетре]',
              lastDay: '[Ӗнер] LT [сехетре]',
              nextWeek: '[Ҫитес] dddd LT [сехетре]',
              lastWeek: '[Иртнӗ] dddd LT [сехетре]',
              sameElse: 'L'
          },
          relativeTime : {
              future : function (output) {
                  var affix = /сехет$/i.exec(output) ? 'рен' : /ҫул$/i.exec(output) ? 'тан' : 'ран';
                  return output + affix;
              },
              past : '%s каялла',
              s : 'пӗр-ик ҫеккунт',
              m : 'пӗр минут',
              mm : '%d минут',
              h : 'пӗр сехет',
              hh : '%d сехет',
              d : 'пӗр кун',
              dd : '%d кун',
              M : 'пӗр уйӑх',
              MM : '%d уйӑх',
              y : 'пӗр ҫул',
              yy : '%d ҫул'
          },
          ordinalParse: /\d{1,2}-мӗш/,
          ordinal : '%d-мӗш',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Welsh (cy)
      //! author : Robert Allen
  
      var cy = moment__default.defineLocale('cy', {
          months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
          monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
          weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
          weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
          weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
          // time formats are the same as en-gb
          longDateFormat: {
              LT: 'HH:mm',
              LTS : 'HH:mm:ss',
              L: 'DD/MM/YYYY',
              LL: 'D MMMM YYYY',
              LLL: 'D MMMM YYYY HH:mm',
              LLLL: 'dddd, D MMMM YYYY HH:mm'
          },
          calendar: {
              sameDay: '[Heddiw am] LT',
              nextDay: '[Yfory am] LT',
              nextWeek: 'dddd [am] LT',
              lastDay: '[Ddoe am] LT',
              lastWeek: 'dddd [diwethaf am] LT',
              sameElse: 'L'
          },
          relativeTime: {
              future: 'mewn %s',
              past: '%s yn ôl',
              s: 'ychydig eiliadau',
              m: 'munud',
              mm: '%d munud',
              h: 'awr',
              hh: '%d awr',
              d: 'diwrnod',
              dd: '%d diwrnod',
              M: 'mis',
              MM: '%d mis',
              y: 'blwyddyn',
              yy: '%d flynedd'
          },
          ordinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
          // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
          ordinal: function (number) {
              var b = number,
                  output = '',
                  lookup = [
                      '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
                      'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
                  ];
              if (b > 20) {
                  if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
                      output = 'fed'; // not 30ain, 70ain or 90ain
                  } else {
                      output = 'ain';
                  }
              } else if (b > 0) {
                  output = lookup[b];
              }
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : danish (da)
      //! author : Ulrik Nielsen : https://github.com/mrbase
  
      var da = moment__default.defineLocale('da', {
          months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
          monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
          weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
          weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'),
          weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY HH:mm',
              LLLL : 'dddd [d.] D. MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[I dag kl.] LT',
              nextDay : '[I morgen kl.] LT',
              nextWeek : 'dddd [kl.] LT',
              lastDay : '[I går kl.] LT',
              lastWeek : '[sidste] dddd [kl] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'om %s',
              past : '%s siden',
              s : 'få sekunder',
              m : 'et minut',
              mm : '%d minutter',
              h : 'en time',
              hh : '%d timer',
              d : 'en dag',
              dd : '%d dage',
              M : 'en måned',
              MM : '%d måneder',
              y : 'et år',
              yy : '%d år'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : austrian german (de-at)
      //! author : lluchs : https://github.com/lluchs
      //! author: Menelion Elensúle: https://github.com/Oire
      //! author : Martin Groller : https://github.com/MadMG
      //! author : Mikolaj Dadela : https://github.com/mik01aj
  
      function de_at__processRelativeTime(number, withoutSuffix, key, isFuture) {
          var format = {
              'm': ['eine Minute', 'einer Minute'],
              'h': ['eine Stunde', 'einer Stunde'],
              'd': ['ein Tag', 'einem Tag'],
              'dd': [number + ' Tage', number + ' Tagen'],
              'M': ['ein Monat', 'einem Monat'],
              'MM': [number + ' Monate', number + ' Monaten'],
              'y': ['ein Jahr', 'einem Jahr'],
              'yy': [number + ' Jahre', number + ' Jahren']
          };
          return withoutSuffix ? format[key][0] : format[key][1];
      }
  
      var de_at = moment__default.defineLocale('de-at', {
          months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
          monthsShort : 'Jän._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
          weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
          weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
          weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
          longDateFormat : {
              LT: 'HH:mm',
              LTS: 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY HH:mm',
              LLLL : 'dddd, D. MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[heute um] LT [Uhr]',
              sameElse: 'L',
              nextDay: '[morgen um] LT [Uhr]',
              nextWeek: 'dddd [um] LT [Uhr]',
              lastDay: '[gestern um] LT [Uhr]',
              lastWeek: '[letzten] dddd [um] LT [Uhr]'
          },
          relativeTime : {
              future : 'in %s',
              past : 'vor %s',
              s : 'ein paar Sekunden',
              m : de_at__processRelativeTime,
              mm : '%d Minuten',
              h : de_at__processRelativeTime,
              hh : '%d Stunden',
              d : de_at__processRelativeTime,
              dd : de_at__processRelativeTime,
              M : de_at__processRelativeTime,
              MM : de_at__processRelativeTime,
              y : de_at__processRelativeTime,
              yy : de_at__processRelativeTime
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : german (de)
      //! author : lluchs : https://github.com/lluchs
      //! author: Menelion Elensúle: https://github.com/Oire
      //! author : Mikolaj Dadela : https://github.com/mik01aj
  
      function de__processRelativeTime(number, withoutSuffix, key, isFuture) {
          var format = {
              'm': ['eine Minute', 'einer Minute'],
              'h': ['eine Stunde', 'einer Stunde'],
              'd': ['ein Tag', 'einem Tag'],
              'dd': [number + ' Tage', number + ' Tagen'],
              'M': ['ein Monat', 'einem Monat'],
              'MM': [number + ' Monate', number + ' Monaten'],
              'y': ['ein Jahr', 'einem Jahr'],
              'yy': [number + ' Jahre', number + ' Jahren']
          };
          return withoutSuffix ? format[key][0] : format[key][1];
      }
  
      var de = moment__default.defineLocale('de', {
          months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
          monthsShort : 'Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
          weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
          weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
          weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
          longDateFormat : {
              LT: 'HH:mm',
              LTS: 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY HH:mm',
              LLLL : 'dddd, D. MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[heute um] LT [Uhr]',
              sameElse: 'L',
              nextDay: '[morgen um] LT [Uhr]',
              nextWeek: 'dddd [um] LT [Uhr]',
              lastDay: '[gestern um] LT [Uhr]',
              lastWeek: '[letzten] dddd [um] LT [Uhr]'
          },
          relativeTime : {
              future : 'in %s',
              past : 'vor %s',
              s : 'ein paar Sekunden',
              m : de__processRelativeTime,
              mm : '%d Minuten',
              h : de__processRelativeTime,
              hh : '%d Stunden',
              d : de__processRelativeTime,
              dd : de__processRelativeTime,
              M : de__processRelativeTime,
              MM : de__processRelativeTime,
              y : de__processRelativeTime,
              yy : de__processRelativeTime
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : dhivehi (dv)
      //! author : Jawish Hameed : https://github.com/jawish
  
      var dv__months = [
          'ޖެނުއަރީ',
          'ފެބްރުއަރީ',
          'މާރިޗު',
          'އޭޕްރީލު',
          'މޭ',
          'ޖޫން',
          'ޖުލައި',
          'އޯގަސްޓު',
          'ސެޕްޓެމްބަރު',
          'އޮކްޓޯބަރު',
          'ނޮވެމްބަރު',
          'ޑިސެމްބަރު'
      ], dv__weekdays = [
          'އާދިއްތަ',
          'ހޯމަ',
          'އަންގާރަ',
          'ބުދަ',
          'ބުރާސްފަތި',
          'ހުކުރު',
          'ހޮނިހިރު'
      ];
  
      var dv = moment__default.defineLocale('dv', {
          months : dv__months,
          monthsShort : dv__months,
          weekdays : dv__weekdays,
          weekdaysShort : dv__weekdays,
          weekdaysMin : 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
          longDateFormat : {
  
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'D/M/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          meridiemParse: /މކ|މފ/,
          isPM : function (input) {
              return '' === input;
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 12) {
                  return 'މކ';
              } else {
                  return 'މފ';
              }
          },
          calendar : {
              sameDay : '[މިއަދު] LT',
              nextDay : '[މާދަމާ] LT',
              nextWeek : 'dddd LT',
              lastDay : '[އިއްޔެ] LT',
              lastWeek : '[ފާއިތުވި] dddd LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'ތެރޭގައި %s',
              past : 'ކުރިން %s',
              s : 'ސިކުންތުކޮޅެއް',
              m : 'މިނިޓެއް',
              mm : 'މިނިޓު %d',
              h : 'ގަޑިއިރެއް',
              hh : 'ގަޑިއިރު %d',
              d : 'ދުވަހެއް',
              dd : 'ދުވަސް %d',
              M : 'މަހެއް',
              MM : 'މަސް %d',
              y : 'އަހަރެއް',
              yy : 'އަހަރު %d'
          },
          preparse: function (string) {
              return string.replace(/،/g, ',');
          },
          postformat: function (string) {
              return string.replace(/,/g, '،');
          },
          week : {
              dow : 7,  // Sunday is the first day of the week.
              doy : 12  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : modern greek (el)
      //! author : Aggelos Karalias : https://github.com/mehiel
  
      var el = moment__default.defineLocale('el', {
          monthsNominativeEl : 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
          monthsGenitiveEl : 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split('_'),
          months : function (momentToFormat, format) {
              if (/D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
                  return this._monthsGenitiveEl[momentToFormat.month()];
              } else {
                  return this._monthsNominativeEl[momentToFormat.month()];
              }
          },
          monthsShort : 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
          weekdays : 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split('_'),
          weekdaysShort : 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
          weekdaysMin : 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
          meridiem : function (hours, minutes, isLower) {
              if (hours > 11) {
                  return isLower ? 'μμ' : 'ΜΜ';
              } else {
                  return isLower ? 'πμ' : 'ΠΜ';
              }
          },
          isPM : function (input) {
              return ((input + '').toLowerCase()[0] === 'μ');
          },
          meridiemParse : /[ΠΜ]\.?Μ?\.?/i,
          longDateFormat : {
              LT : 'h:mm A',
              LTS : 'h:mm:ss A',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY h:mm A',
              LLLL : 'dddd, D MMMM YYYY h:mm A'
          },
          calendarEl : {
              sameDay : '[Σήμερα {}] LT',
              nextDay : '[Αύριο {}] LT',
              nextWeek : 'dddd [{}] LT',
              lastDay : '[Χθες {}] LT',
              lastWeek : function () {
                  switch (this.day()) {
                      case 6:
                          return '[το προηγούμενο] dddd [{}] LT';
                      default:
                          return '[την προηγούμενη] dddd [{}] LT';
                  }
              },
              sameElse : 'L'
          },
          calendar : function (key, mom) {
              var output = this._calendarEl[key],
                  hours = mom && mom.hours();
              if (isFunction(output)) {
                  output = output.apply(mom);
              }
              return output.replace('{}', (hours % 12 === 1 ? 'στη' : 'στις'));
          },
          relativeTime : {
              future : 'σε %s',
              past : '%s πριν',
              s : 'λίγα δευτερόλεπτα',
              m : 'ένα λεπτό',
              mm : '%d λεπτά',
              h : 'μία ώρα',
              hh : '%d ώρες',
              d : 'μία μέρα',
              dd : '%d μέρες',
              M : 'ένας μήνας',
              MM : '%d μήνες',
              y : 'ένας χρόνος',
              yy : '%d χρόνια'
          },
          ordinalParse: /\d{1,2}η/,
          ordinal: '%dη',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : australian english (en-au)
  
      var en_au = moment__default.defineLocale('en-au', {
          months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
          weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
          weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
          weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
          longDateFormat : {
              LT : 'h:mm A',
              LTS : 'h:mm:ss A',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY h:mm A',
              LLLL : 'dddd, D MMMM YYYY h:mm A'
          },
          calendar : {
              sameDay : '[Today at] LT',
              nextDay : '[Tomorrow at] LT',
              nextWeek : 'dddd [at] LT',
              lastDay : '[Yesterday at] LT',
              lastWeek : '[Last] dddd [at] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'in %s',
              past : '%s ago',
              s : 'a few seconds',
              m : 'a minute',
              mm : '%d minutes',
              h : 'an hour',
              hh : '%d hours',
              d : 'a day',
              dd : '%d days',
              M : 'a month',
              MM : '%d months',
              y : 'a year',
              yy : '%d years'
          },
          ordinalParse: /\d{1,2}(st|nd|rd|th)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (~~(number % 100 / 10) === 1) ? 'th' :
                  (b === 1) ? 'st' :
                  (b === 2) ? 'nd' :
                  (b === 3) ? 'rd' : 'th';
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : canadian english (en-ca)
      //! author : Jonathan Abourbih : https://github.com/jonbca
  
      var en_ca = moment__default.defineLocale('en-ca', {
          months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
          weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
          weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
          weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
          longDateFormat : {
              LT : 'h:mm A',
              LTS : 'h:mm:ss A',
              L : 'YYYY-MM-DD',
              LL : 'D MMMM, YYYY',
              LLL : 'D MMMM, YYYY h:mm A',
              LLLL : 'dddd, D MMMM, YYYY h:mm A'
          },
          calendar : {
              sameDay : '[Today at] LT',
              nextDay : '[Tomorrow at] LT',
              nextWeek : 'dddd [at] LT',
              lastDay : '[Yesterday at] LT',
              lastWeek : '[Last] dddd [at] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'in %s',
              past : '%s ago',
              s : 'a few seconds',
              m : 'a minute',
              mm : '%d minutes',
              h : 'an hour',
              hh : '%d hours',
              d : 'a day',
              dd : '%d days',
              M : 'a month',
              MM : '%d months',
              y : 'a year',
              yy : '%d years'
          },
          ordinalParse: /\d{1,2}(st|nd|rd|th)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (~~(number % 100 / 10) === 1) ? 'th' :
                  (b === 1) ? 'st' :
                  (b === 2) ? 'nd' :
                  (b === 3) ? 'rd' : 'th';
              return number + output;
          }
      });
  
      //! moment.js locale configuration
      //! locale : great britain english (en-gb)
      //! author : Chris Gedrim : https://github.com/chrisgedrim
  
      var en_gb = moment__default.defineLocale('en-gb', {
          months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
          weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
          weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
          weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[Today at] LT',
              nextDay : '[Tomorrow at] LT',
              nextWeek : 'dddd [at] LT',
              lastDay : '[Yesterday at] LT',
              lastWeek : '[Last] dddd [at] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'in %s',
              past : '%s ago',
              s : 'a few seconds',
              m : 'a minute',
              mm : '%d minutes',
              h : 'an hour',
              hh : '%d hours',
              d : 'a day',
              dd : '%d days',
              M : 'a month',
              MM : '%d months',
              y : 'a year',
              yy : '%d years'
          },
          ordinalParse: /\d{1,2}(st|nd|rd|th)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (~~(number % 100 / 10) === 1) ? 'th' :
                  (b === 1) ? 'st' :
                  (b === 2) ? 'nd' :
                  (b === 3) ? 'rd' : 'th';
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Irish english (en-ie)
      //! author : Chris Cartlidge : https://github.com/chriscartlidge
  
      var en_ie = moment__default.defineLocale('en-ie', {
          months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
          weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
          weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
          weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD-MM-YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[Today at] LT',
              nextDay : '[Tomorrow at] LT',
              nextWeek : 'dddd [at] LT',
              lastDay : '[Yesterday at] LT',
              lastWeek : '[Last] dddd [at] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'in %s',
              past : '%s ago',
              s : 'a few seconds',
              m : 'a minute',
              mm : '%d minutes',
              h : 'an hour',
              hh : '%d hours',
              d : 'a day',
              dd : '%d days',
              M : 'a month',
              MM : '%d months',
              y : 'a year',
              yy : '%d years'
          },
          ordinalParse: /\d{1,2}(st|nd|rd|th)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (~~(number % 100 / 10) === 1) ? 'th' :
                  (b === 1) ? 'st' :
                  (b === 2) ? 'nd' :
                  (b === 3) ? 'rd' : 'th';
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : New Zealand english (en-nz)
  
      var en_nz = moment__default.defineLocale('en-nz', {
          months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
          weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
          weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
          weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
          longDateFormat : {
              LT : 'h:mm A',
              LTS : 'h:mm:ss A',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY h:mm A',
              LLLL : 'dddd, D MMMM YYYY h:mm A'
          },
          calendar : {
              sameDay : '[Today at] LT',
              nextDay : '[Tomorrow at] LT',
              nextWeek : 'dddd [at] LT',
              lastDay : '[Yesterday at] LT',
              lastWeek : '[Last] dddd [at] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'in %s',
              past : '%s ago',
              s : 'a few seconds',
              m : 'a minute',
              mm : '%d minutes',
              h : 'an hour',
              hh : '%d hours',
              d : 'a day',
              dd : '%d days',
              M : 'a month',
              MM : '%d months',
              y : 'a year',
              yy : '%d years'
          },
          ordinalParse: /\d{1,2}(st|nd|rd|th)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (~~(number % 100 / 10) === 1) ? 'th' :
                  (b === 1) ? 'st' :
                  (b === 2) ? 'nd' :
                  (b === 3) ? 'rd' : 'th';
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : esperanto (eo)
      //! author : Colin Dean : https://github.com/colindean
      //! komento: Mi estas malcerta se mi korekte traktis akuzativojn en tiu traduko.
      //!          Se ne, bonvolu korekti kaj avizi min por ke mi povas lerni!
  
      var eo = moment__default.defineLocale('eo', {
          months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
          monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec'.split('_'),
          weekdays : 'Dimanĉo_Lundo_Mardo_Merkredo_Ĵaŭdo_Vendredo_Sabato'.split('_'),
          weekdaysShort : 'Dim_Lun_Mard_Merk_Ĵaŭ_Ven_Sab'.split('_'),
          weekdaysMin : 'Di_Lu_Ma_Me_Ĵa_Ve_Sa'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'YYYY-MM-DD',
              LL : 'D[-an de] MMMM, YYYY',
              LLL : 'D[-an de] MMMM, YYYY HH:mm',
              LLLL : 'dddd, [la] D[-an de] MMMM, YYYY HH:mm'
          },
          meridiemParse: /[ap]\.t\.m/i,
          isPM: function (input) {
              return input.charAt(0).toLowerCase() === 'p';
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours > 11) {
                  return isLower ? 'p.t.m.' : 'P.T.M.';
              } else {
                  return isLower ? 'a.t.m.' : 'A.T.M.';
              }
          },
          calendar : {
              sameDay : '[Hodiaŭ je] LT',
              nextDay : '[Morgaŭ je] LT',
              nextWeek : 'dddd [je] LT',
              lastDay : '[Hieraŭ je] LT',
              lastWeek : '[pasinta] dddd [je] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'je %s',
              past : 'antaŭ %s',
              s : 'sekundoj',
              m : 'minuto',
              mm : '%d minutoj',
              h : 'horo',
              hh : '%d horoj',
              d : 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
              dd : '%d tagoj',
              M : 'monato',
              MM : '%d monatoj',
              y : 'jaro',
              yy : '%d jaroj'
          },
          ordinalParse: /\d{1,2}a/,
          ordinal : '%da',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : spanish (es)
      //! author : Julio Napurí : https://github.com/julionc
  
      var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
          es__monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
  
      var es = moment__default.defineLocale('es', {
          months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
          monthsShort : function (m, format) {
              if (/-MMM-/.test(format)) {
                  return es__monthsShort[m.month()];
              } else {
                  return monthsShortDot[m.month()];
              }
          },
          weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
          weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
          weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D [de] MMMM [de] YYYY',
              LLL : 'D [de] MMMM [de] YYYY H:mm',
              LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
          },
          calendar : {
              sameDay : function () {
                  return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
              },
              nextDay : function () {
                  return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
              },
              nextWeek : function () {
                  return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
              },
              lastDay : function () {
                  return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
              },
              lastWeek : function () {
                  return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'en %s',
              past : 'hace %s',
              s : 'unos segundos',
              m : 'un minuto',
              mm : '%d minutos',
              h : 'una hora',
              hh : '%d horas',
              d : 'un día',
              dd : '%d días',
              M : 'un mes',
              MM : '%d meses',
              y : 'un año',
              yy : '%d años'
          },
          ordinalParse : /\d{1,2}º/,
          ordinal : '%dº',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : estonian (et)
      //! author : Henry Kehlmann : https://github.com/madhenry
      //! improvements : Illimar Tambek : https://github.com/ragulka
  
      function et__processRelativeTime(number, withoutSuffix, key, isFuture) {
          var format = {
              's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
              'm' : ['ühe minuti', 'üks minut'],
              'mm': [number + ' minuti', number + ' minutit'],
              'h' : ['ühe tunni', 'tund aega', 'üks tund'],
              'hh': [number + ' tunni', number + ' tundi'],
              'd' : ['ühe päeva', 'üks päev'],
              'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
              'MM': [number + ' kuu', number + ' kuud'],
              'y' : ['ühe aasta', 'aasta', 'üks aasta'],
              'yy': [number + ' aasta', number + ' aastat']
          };
          if (withoutSuffix) {
              return format[key][2] ? format[key][2] : format[key][1];
          }
          return isFuture ? format[key][0] : format[key][1];
      }
  
      var et = moment__default.defineLocale('et', {
          months        : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
          monthsShort   : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
          weekdays      : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
          weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
          weekdaysMin   : 'P_E_T_K_N_R_L'.split('_'),
          longDateFormat : {
              LT   : 'H:mm',
              LTS : 'H:mm:ss',
              L    : 'DD.MM.YYYY',
              LL   : 'D. MMMM YYYY',
              LLL  : 'D. MMMM YYYY H:mm',
              LLLL : 'dddd, D. MMMM YYYY H:mm'
          },
          calendar : {
              sameDay  : '[Täna,] LT',
              nextDay  : '[Homme,] LT',
              nextWeek : '[Järgmine] dddd LT',
              lastDay  : '[Eile,] LT',
              lastWeek : '[Eelmine] dddd LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s pärast',
              past   : '%s tagasi',
              s      : et__processRelativeTime,
              m      : et__processRelativeTime,
              mm     : et__processRelativeTime,
              h      : et__processRelativeTime,
              hh     : et__processRelativeTime,
              d      : et__processRelativeTime,
              dd     : '%d päeva',
              M      : et__processRelativeTime,
              MM     : et__processRelativeTime,
              y      : et__processRelativeTime,
              yy     : et__processRelativeTime
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : euskara (eu)
      //! author : Eneko Illarramendi : https://github.com/eillarra
  
      var eu = moment__default.defineLocale('eu', {
          months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
          monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
          weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
          weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
          weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'YYYY-MM-DD',
              LL : 'YYYY[ko] MMMM[ren] D[a]',
              LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm',
              LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
              l : 'YYYY-M-D',
              ll : 'YYYY[ko] MMM D[a]',
              lll : 'YYYY[ko] MMM D[a] HH:mm',
              llll : 'ddd, YYYY[ko] MMM D[a] HH:mm'
          },
          calendar : {
              sameDay : '[gaur] LT[etan]',
              nextDay : '[bihar] LT[etan]',
              nextWeek : 'dddd LT[etan]',
              lastDay : '[atzo] LT[etan]',
              lastWeek : '[aurreko] dddd LT[etan]',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s barru',
              past : 'duela %s',
              s : 'segundo batzuk',
              m : 'minutu bat',
              mm : '%d minutu',
              h : 'ordu bat',
              hh : '%d ordu',
              d : 'egun bat',
              dd : '%d egun',
              M : 'hilabete bat',
              MM : '%d hilabete',
              y : 'urte bat',
              yy : '%d urte'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Persian (fa)
      //! author : Ebrahim Byagowi : https://github.com/ebraminio
  
      var fa__symbolMap = {
          '1': '۱',
          '2': '۲',
          '3': '۳',
          '4': '۴',
          '5': '۵',
          '6': '۶',
          '7': '۷',
          '8': '۸',
          '9': '۹',
          '0': '۰'
      }, fa__numberMap = {
          '۱': '1',
          '۲': '2',
          '۳': '3',
          '۴': '4',
          '۵': '5',
          '۶': '6',
          '۷': '7',
          '۸': '8',
          '۹': '9',
          '۰': '0'
      };
  
      var fa = moment__default.defineLocale('fa', {
          months : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
          monthsShort : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
          weekdays : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
          weekdaysShort : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
          weekdaysMin : 'ی_د_س_چ_پ_ج_ش'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          meridiemParse: /قبل از ظهر|بعد از ظهر/,
          isPM: function (input) {
              return /بعد از ظهر/.test(input);
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 12) {
                  return 'قبل از ظهر';
              } else {
                  return 'بعد از ظهر';
              }
          },
          calendar : {
              sameDay : '[امروز ساعت] LT',
              nextDay : '[فردا ساعت] LT',
              nextWeek : 'dddd [ساعت] LT',
              lastDay : '[دیروز ساعت] LT',
              lastWeek : 'dddd [پیش] [ساعت] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'در %s',
              past : '%s پیش',
              s : 'چندین ثانیه',
              m : 'یک دقیقه',
              mm : '%d دقیقه',
              h : 'یک ساعت',
              hh : '%d ساعت',
              d : 'یک روز',
              dd : '%d روز',
              M : 'یک ماه',
              MM : '%d ماه',
              y : 'یک سال',
              yy : '%d سال'
          },
          preparse: function (string) {
              return string.replace(/[۰-۹]/g, function (match) {
                  return fa__numberMap[match];
              }).replace(/،/g, ',');
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return fa__symbolMap[match];
              }).replace(/,/g, '،');
          },
          ordinalParse: /\d{1,2}م/,
          ordinal : '%dم',
          week : {
              dow : 6, // Saturday is the first day of the week.
              doy : 12 // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : finnish (fi)
      //! author : Tarmo Aidantausta : https://github.com/bleadof
  
      var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '),
          numbersFuture = [
              'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
              numbersPast[7], numbersPast[8], numbersPast[9]
          ];
      function fi__translate(number, withoutSuffix, key, isFuture) {
          var result = '';
          switch (key) {
          case 's':
              return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
          case 'm':
              return isFuture ? 'minuutin' : 'minuutti';
          case 'mm':
              result = isFuture ? 'minuutin' : 'minuuttia';
              break;
          case 'h':
              return isFuture ? 'tunnin' : 'tunti';
          case 'hh':
              result = isFuture ? 'tunnin' : 'tuntia';
              break;
          case 'd':
              return isFuture ? 'päivän' : 'päivä';
          case 'dd':
              result = isFuture ? 'päivän' : 'päivää';
              break;
          case 'M':
              return isFuture ? 'kuukauden' : 'kuukausi';
          case 'MM':
              result = isFuture ? 'kuukauden' : 'kuukautta';
              break;
          case 'y':
              return isFuture ? 'vuoden' : 'vuosi';
          case 'yy':
              result = isFuture ? 'vuoden' : 'vuotta';
              break;
          }
          result = verbalNumber(number, isFuture) + ' ' + result;
          return result;
      }
      function verbalNumber(number, isFuture) {
          return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;
      }
  
      var fi = moment__default.defineLocale('fi', {
          months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
          monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
          weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
          weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
          weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
          longDateFormat : {
              LT : 'HH.mm',
              LTS : 'HH.mm.ss',
              L : 'DD.MM.YYYY',
              LL : 'Do MMMM[ta] YYYY',
              LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm',
              LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
              l : 'D.M.YYYY',
              ll : 'Do MMM YYYY',
              lll : 'Do MMM YYYY, [klo] HH.mm',
              llll : 'ddd, Do MMM YYYY, [klo] HH.mm'
          },
          calendar : {
              sameDay : '[tänään] [klo] LT',
              nextDay : '[huomenna] [klo] LT',
              nextWeek : 'dddd [klo] LT',
              lastDay : '[eilen] [klo] LT',
              lastWeek : '[viime] dddd[na] [klo] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s päästä',
              past : '%s sitten',
              s : fi__translate,
              m : fi__translate,
              mm : fi__translate,
              h : fi__translate,
              hh : fi__translate,
              d : fi__translate,
              dd : fi__translate,
              M : fi__translate,
              MM : fi__translate,
              y : fi__translate,
              yy : fi__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : faroese (fo)
      //! author : Ragnar Johannesen : https://github.com/ragnar123
  
      var fo = moment__default.defineLocale('fo', {
          months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
          monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
          weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
          weekdaysShort : 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
          weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D. MMMM, YYYY HH:mm'
          },
          calendar : {
              sameDay : '[Í dag kl.] LT',
              nextDay : '[Í morgin kl.] LT',
              nextWeek : 'dddd [kl.] LT',
              lastDay : '[Í gjár kl.] LT',
              lastWeek : '[síðstu] dddd [kl] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'um %s',
              past : '%s síðani',
              s : 'fá sekund',
              m : 'ein minutt',
              mm : '%d minuttir',
              h : 'ein tími',
              hh : '%d tímar',
              d : 'ein dagur',
              dd : '%d dagar',
              M : 'ein mánaði',
              MM : '%d mánaðir',
              y : 'eitt ár',
              yy : '%d ár'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : canadian french (fr-ca)
      //! author : Jonathan Abourbih : https://github.com/jonbca
  
      var fr_ca = moment__default.defineLocale('fr-ca', {
          months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
          monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
          weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
          weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
          weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'YYYY-MM-DD',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Aujourd\'hui à] LT',
              nextDay: '[Demain à] LT',
              nextWeek: 'dddd [à] LT',
              lastDay: '[Hier à] LT',
              lastWeek: 'dddd [dernier à] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'dans %s',
              past : 'il y a %s',
              s : 'quelques secondes',
              m : 'une minute',
              mm : '%d minutes',
              h : 'une heure',
              hh : '%d heures',
              d : 'un jour',
              dd : '%d jours',
              M : 'un mois',
              MM : '%d mois',
              y : 'un an',
              yy : '%d ans'
          },
          ordinalParse: /\d{1,2}(er|e)/,
          ordinal : function (number) {
              return number + (number === 1 ? 'er' : 'e');
          }
      });
  
      //! moment.js locale configuration
      //! locale : swiss french (fr)
      //! author : Gaspard Bucher : https://github.com/gaspard
  
      var fr_ch = moment__default.defineLocale('fr-ch', {
          months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
          monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
          weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
          weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
          weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Aujourd\'hui à] LT',
              nextDay: '[Demain à] LT',
              nextWeek: 'dddd [à] LT',
              lastDay: '[Hier à] LT',
              lastWeek: 'dddd [dernier à] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'dans %s',
              past : 'il y a %s',
              s : 'quelques secondes',
              m : 'une minute',
              mm : '%d minutes',
              h : 'une heure',
              hh : '%d heures',
              d : 'un jour',
              dd : '%d jours',
              M : 'un mois',
              MM : '%d mois',
              y : 'un an',
              yy : '%d ans'
          },
          ordinalParse: /\d{1,2}(er|e)/,
          ordinal : function (number) {
              return number + (number === 1 ? 'er' : 'e');
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : french (fr)
      //! author : John Fischer : https://github.com/jfroffice
  
      var fr = moment__default.defineLocale('fr', {
          months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
          monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
          weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
          weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
          weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Aujourd\'hui à] LT',
              nextDay: '[Demain à] LT',
              nextWeek: 'dddd [à] LT',
              lastDay: '[Hier à] LT',
              lastWeek: 'dddd [dernier à] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'dans %s',
              past : 'il y a %s',
              s : 'quelques secondes',
              m : 'une minute',
              mm : '%d minutes',
              h : 'une heure',
              hh : '%d heures',
              d : 'un jour',
              dd : '%d jours',
              M : 'un mois',
              MM : '%d mois',
              y : 'un an',
              yy : '%d ans'
          },
          ordinalParse: /\d{1,2}(er|)/,
          ordinal : function (number) {
              return number + (number === 1 ? 'er' : '');
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : frisian (fy)
      //! author : Robin van der Vliet : https://github.com/robin0van0der0v
  
      var fy__monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'),
          fy__monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
  
      var fy = moment__default.defineLocale('fy', {
          months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
          monthsShort : function (m, format) {
              if (/-MMM-/.test(format)) {
                  return fy__monthsShortWithoutDots[m.month()];
              } else {
                  return fy__monthsShortWithDots[m.month()];
              }
          },
          weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
          weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'),
          weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD-MM-YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[hjoed om] LT',
              nextDay: '[moarn om] LT',
              nextWeek: 'dddd [om] LT',
              lastDay: '[juster om] LT',
              lastWeek: '[ôfrûne] dddd [om] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'oer %s',
              past : '%s lyn',
              s : 'in pear sekonden',
              m : 'ien minút',
              mm : '%d minuten',
              h : 'ien oere',
              hh : '%d oeren',
              d : 'ien dei',
              dd : '%d dagen',
              M : 'ien moanne',
              MM : '%d moannen',
              y : 'ien jier',
              yy : '%d jierren'
          },
          ordinalParse: /\d{1,2}(ste|de)/,
          ordinal : function (number) {
              return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : great britain scottish gealic (gd)
      //! author : Jon Ashdown : https://github.com/jonashdown
  
      var gd__months = [
          'Am Faoilleach', 'An Gearran', 'Am Màrt', 'An Giblean', 'An Cèitean', 'An t-Ògmhios', 'An t-Iuchar', 'An Lùnastal', 'An t-Sultain', 'An Dàmhair', 'An t-Samhain', 'An Dùbhlachd'
      ];
  
      var gd__monthsShort = ['Faoi', 'Gear', 'Màrt', 'Gibl', 'Cèit', 'Ògmh', 'Iuch', 'Lùn', 'Sult', 'Dàmh', 'Samh', 'Dùbh'];
  
      var gd__weekdays = ['Didòmhnaich', 'Diluain', 'Dimàirt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];
  
      var weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];
  
      var weekdaysMin = ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];
  
      var gd = moment__default.defineLocale('gd', {
          months : gd__months,
          monthsShort : gd__monthsShort,
          monthsParseExact : true,
          weekdays : gd__weekdays,
          weekdaysShort : weekdaysShort,
          weekdaysMin : weekdaysMin,
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[An-diugh aig] LT',
              nextDay : '[A-màireach aig] LT',
              nextWeek : 'dddd [aig] LT',
              lastDay : '[An-dè aig] LT',
              lastWeek : 'dddd [seo chaidh] [aig] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'ann an %s',
              past : 'bho chionn %s',
              s : 'beagan diogan',
              m : 'mionaid',
              mm : '%d mionaidean',
              h : 'uair',
              hh : '%d uairean',
              d : 'latha',
              dd : '%d latha',
              M : 'mìos',
              MM : '%d mìosan',
              y : 'bliadhna',
              yy : '%d bliadhna'
          },
          ordinalParse : /\d{1,2}(d|na|mh)/,
          ordinal : function (number) {
              var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : galician (gl)
      //! author : Juan G. Hurtado : https://github.com/juanghurtado
  
      var gl = moment__default.defineLocale('gl', {
          months : 'Xaneiro_Febreiro_Marzo_Abril_Maio_Xuño_Xullo_Agosto_Setembro_Outubro_Novembro_Decembro'.split('_'),
          monthsShort : 'Xan._Feb._Mar._Abr._Mai._Xuñ._Xul._Ago._Set._Out._Nov._Dec.'.split('_'),
          weekdays : 'Domingo_Luns_Martes_Mércores_Xoves_Venres_Sábado'.split('_'),
          weekdaysShort : 'Dom._Lun._Mar._Mér._Xov._Ven._Sáb.'.split('_'),
          weekdaysMin : 'Do_Lu_Ma_Mé_Xo_Ve_Sá'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY H:mm',
              LLLL : 'dddd D MMMM YYYY H:mm'
          },
          calendar : {
              sameDay : function () {
                  return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
              },
              nextDay : function () {
                  return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
              },
              nextWeek : function () {
                  return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
              },
              lastDay : function () {
                  return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
              },
              lastWeek : function () {
                  return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : function (str) {
                  if (str === 'uns segundos') {
                      return 'nuns segundos';
                  }
                  return 'en ' + str;
              },
              past : 'hai %s',
              s : 'uns segundos',
              m : 'un minuto',
              mm : '%d minutos',
              h : 'unha hora',
              hh : '%d horas',
              d : 'un día',
              dd : '%d días',
              M : 'un mes',
              MM : '%d meses',
              y : 'un ano',
              yy : '%d anos'
          },
          ordinalParse : /\d{1,2}º/,
          ordinal : '%dº',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Hebrew (he)
      //! author : Tomer Cohen : https://github.com/tomer
      //! author : Moshe Simantov : https://github.com/DevelopmentIL
      //! author : Tal Ater : https://github.com/TalAter
  
      var he = moment__default.defineLocale('he', {
          months : 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
          monthsShort : 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split('_'),
          weekdays : 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
          weekdaysShort : 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
          weekdaysMin : 'א_ב_ג_ד_ה_ו_ש'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D [ב]MMMM YYYY',
              LLL : 'D [ב]MMMM YYYY HH:mm',
              LLLL : 'dddd, D [ב]MMMM YYYY HH:mm',
              l : 'D/M/YYYY',
              ll : 'D MMM YYYY',
              lll : 'D MMM YYYY HH:mm',
              llll : 'ddd, D MMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[היום ב־]LT',
              nextDay : '[מחר ב־]LT',
              nextWeek : 'dddd [בשעה] LT',
              lastDay : '[אתמול ב־]LT',
              lastWeek : '[ביום] dddd [האחרון בשעה] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'בעוד %s',
              past : 'לפני %s',
              s : 'מספר שניות',
              m : 'דקה',
              mm : '%d דקות',
              h : 'שעה',
              hh : function (number) {
                  if (number === 2) {
                      return 'שעתיים';
                  }
                  return number + ' שעות';
              },
              d : 'יום',
              dd : function (number) {
                  if (number === 2) {
                      return 'יומיים';
                  }
                  return number + ' ימים';
              },
              M : 'חודש',
              MM : function (number) {
                  if (number === 2) {
                      return 'חודשיים';
                  }
                  return number + ' חודשים';
              },
              y : 'שנה',
              yy : function (number) {
                  if (number === 2) {
                      return 'שנתיים';
                  } else if (number % 10 === 0 && number !== 10) {
                      return number + ' שנה';
                  }
                  return number + ' שנים';
              }
          }
      });
  
      //! moment.js locale configuration
      //! locale : hindi (hi)
      //! author : Mayank Singhal : https://github.com/mayanksinghal
  
      var hi__symbolMap = {
          '1': '१',
          '2': '२',
          '3': '३',
          '4': '४',
          '5': '५',
          '6': '६',
          '7': '७',
          '8': '८',
          '9': '९',
          '0': '०'
      },
      hi__numberMap = {
          '१': '1',
          '२': '2',
          '३': '3',
          '४': '4',
          '५': '5',
          '६': '6',
          '७': '7',
          '८': '8',
          '९': '9',
          '०': '0'
      };
  
      var hi = moment__default.defineLocale('hi', {
          months : 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split('_'),
          monthsShort : 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split('_'),
          weekdays : 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
          weekdaysShort : 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
          weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
          longDateFormat : {
              LT : 'A h:mm बजे',
              LTS : 'A h:mm:ss बजे',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, A h:mm बजे',
              LLLL : 'dddd, D MMMM YYYY, A h:mm बजे'
          },
          calendar : {
              sameDay : '[आज] LT',
              nextDay : '[कल] LT',
              nextWeek : 'dddd, LT',
              lastDay : '[कल] LT',
              lastWeek : '[पिछले] dddd, LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s में',
              past : '%s पहले',
              s : 'कुछ ही क्षण',
              m : 'एक मिनट',
              mm : '%d मिनट',
              h : 'एक घंटा',
              hh : '%d घंटे',
              d : 'एक दिन',
              dd : '%d दिन',
              M : 'एक महीने',
              MM : '%d महीने',
              y : 'एक वर्ष',
              yy : '%d वर्ष'
          },
          preparse: function (string) {
              return string.replace(/[१२३४५६७८९०]/g, function (match) {
                  return hi__numberMap[match];
              });
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return hi__symbolMap[match];
              });
          },
          // Hindi notation for meridiems are quite fuzzy in practice. While there exists
          // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
          meridiemParse: /रात|सुबह|दोपहर|शाम/,
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'रात') {
                  return hour < 4 ? hour : hour + 12;
              } else if (meridiem === 'सुबह') {
                  return hour;
              } else if (meridiem === 'दोपहर') {
                  return hour >= 10 ? hour : hour + 12;
              } else if (meridiem === 'शाम') {
                  return hour + 12;
              }
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'रात';
              } else if (hour < 10) {
                  return 'सुबह';
              } else if (hour < 17) {
                  return 'दोपहर';
              } else if (hour < 20) {
                  return 'शाम';
              } else {
                  return 'रात';
              }
          },
          week : {
              dow : 0, // Sunday is the first day of the week.
              doy : 6  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : hrvatski (hr)
      //! author : Bojan Marković : https://github.com/bmarkovic
  
      function hr__translate(number, withoutSuffix, key) {
          var result = number + ' ';
          switch (key) {
          case 'm':
              return withoutSuffix ? 'jedna minuta' : 'jedne minute';
          case 'mm':
              if (number === 1) {
                  result += 'minuta';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'minute';
              } else {
                  result += 'minuta';
              }
              return result;
          case 'h':
              return withoutSuffix ? 'jedan sat' : 'jednog sata';
          case 'hh':
              if (number === 1) {
                  result += 'sat';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'sata';
              } else {
                  result += 'sati';
              }
              return result;
          case 'dd':
              if (number === 1) {
                  result += 'dan';
              } else {
                  result += 'dana';
              }
              return result;
          case 'MM':
              if (number === 1) {
                  result += 'mjesec';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'mjeseca';
              } else {
                  result += 'mjeseci';
              }
              return result;
          case 'yy':
              if (number === 1) {
                  result += 'godina';
              } else if (number === 2 || number === 3 || number === 4) {
                  result += 'godine';
              } else {
                  result += 'godina';
              }
              return result;
          }
      }
  
      var hr = moment__default.defineLocale('hr', {
          months : {
              format: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
              standalone: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
          },
          monthsShort : 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
          weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
          weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
          weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD. MM. YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY H:mm',
              LLLL : 'dddd, D. MMMM YYYY H:mm'
          },
          calendar : {
              sameDay  : '[danas u] LT',
              nextDay  : '[sutra u] LT',
              nextWeek : function () {
                  switch (this.day()) {
                  case 0:
                      return '[u] [nedjelju] [u] LT';
                  case 3:
                      return '[u] [srijedu] [u] LT';
                  case 6:
                      return '[u] [subotu] [u] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[u] dddd [u] LT';
                  }
              },
              lastDay  : '[jučer u] LT',
              lastWeek : function () {
                  switch (this.day()) {
                  case 0:
                  case 3:
                      return '[prošlu] dddd [u] LT';
                  case 6:
                      return '[prošle] [subote] [u] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[prošli] dddd [u] LT';
                  }
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'za %s',
              past   : 'prije %s',
              s      : 'par sekundi',
              m      : hr__translate,
              mm     : hr__translate,
              h      : hr__translate,
              hh     : hr__translate,
              d      : 'dan',
              dd     : hr__translate,
              M      : 'mjesec',
              MM     : hr__translate,
              y      : 'godinu',
              yy     : hr__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : hungarian (hu)
      //! author : Adam Brunner : https://github.com/adambrunner
  
      var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');
      function hu__translate(number, withoutSuffix, key, isFuture) {
          var num = number,
              suffix;
          switch (key) {
          case 's':
              return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce';
          case 'm':
              return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
          case 'mm':
              return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
          case 'h':
              return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
          case 'hh':
              return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
          case 'd':
              return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
          case 'dd':
              return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
          case 'M':
              return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
          case 'MM':
              return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
          case 'y':
              return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
          case 'yy':
              return num + (isFuture || withoutSuffix ? ' év' : ' éve');
          }
          return '';
      }
      function week(isFuture) {
          return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';
      }
  
      var hu = moment__default.defineLocale('hu', {
          months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
          monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
          weekdays : 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
          weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
          weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'YYYY.MM.DD.',
              LL : 'YYYY. MMMM D.',
              LLL : 'YYYY. MMMM D. H:mm',
              LLLL : 'YYYY. MMMM D., dddd H:mm'
          },
          meridiemParse: /de|du/i,
          isPM: function (input) {
              return input.charAt(1).toLowerCase() === 'u';
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours < 12) {
                  return isLower === true ? 'de' : 'DE';
              } else {
                  return isLower === true ? 'du' : 'DU';
              }
          },
          calendar : {
              sameDay : '[ma] LT[-kor]',
              nextDay : '[holnap] LT[-kor]',
              nextWeek : function () {
                  return week.call(this, true);
              },
              lastDay : '[tegnap] LT[-kor]',
              lastWeek : function () {
                  return week.call(this, false);
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s múlva',
              past : '%s',
              s : hu__translate,
              m : hu__translate,
              mm : hu__translate,
              h : hu__translate,
              hh : hu__translate,
              d : hu__translate,
              dd : hu__translate,
              M : hu__translate,
              MM : hu__translate,
              y : hu__translate,
              yy : hu__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Armenian (hy-am)
      //! author : Armendarabyan : https://github.com/armendarabyan
  
      var hy_am = moment__default.defineLocale('hy-am', {
          months : {
              format: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_'),
              standalone: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_')
          },
          monthsShort : 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
          weekdays : 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split('_'),
          weekdaysShort : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
          weekdaysMin : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY թ.',
              LLL : 'D MMMM YYYY թ., HH:mm',
              LLLL : 'dddd, D MMMM YYYY թ., HH:mm'
          },
          calendar : {
              sameDay: '[այսօր] LT',
              nextDay: '[վաղը] LT',
              lastDay: '[երեկ] LT',
              nextWeek: function () {
                  return 'dddd [օրը ժամը] LT';
              },
              lastWeek: function () {
                  return '[անցած] dddd [օրը ժամը] LT';
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : '%s հետո',
              past : '%s առաջ',
              s : 'մի քանի վայրկյան',
              m : 'րոպե',
              mm : '%d րոպե',
              h : 'ժամ',
              hh : '%d ժամ',
              d : 'օր',
              dd : '%d օր',
              M : 'ամիս',
              MM : '%d ամիս',
              y : 'տարի',
              yy : '%d տարի'
          },
          meridiemParse: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
          isPM: function (input) {
              return /^(ցերեկվա|երեկոյան)$/.test(input);
          },
          meridiem : function (hour) {
              if (hour < 4) {
                  return 'գիշերվա';
              } else if (hour < 12) {
                  return 'առավոտվա';
              } else if (hour < 17) {
                  return 'ցերեկվա';
              } else {
                  return 'երեկոյան';
              }
          },
          ordinalParse: /\d{1,2}|\d{1,2}-(ին|րդ)/,
          ordinal: function (number, period) {
              switch (period) {
              case 'DDD':
              case 'w':
              case 'W':
              case 'DDDo':
                  if (number === 1) {
                      return number + '-ին';
                  }
                  return number + '-րդ';
              default:
                  return number;
              }
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Bahasa Indonesia (id)
      //! author : Mohammad Satrio Utomo : https://github.com/tyok
      //! reference: http://id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan
  
      var id = moment__default.defineLocale('id', {
          months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des'.split('_'),
          weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
          weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
          weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
          longDateFormat : {
              LT : 'HH.mm',
              LTS : 'HH.mm.ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY [pukul] HH.mm',
              LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
          },
          meridiemParse: /pagi|siang|sore|malam/,
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'pagi') {
                  return hour;
              } else if (meridiem === 'siang') {
                  return hour >= 11 ? hour : hour + 12;
              } else if (meridiem === 'sore' || meridiem === 'malam') {
                  return hour + 12;
              }
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours < 11) {
                  return 'pagi';
              } else if (hours < 15) {
                  return 'siang';
              } else if (hours < 19) {
                  return 'sore';
              } else {
                  return 'malam';
              }
          },
          calendar : {
              sameDay : '[Hari ini pukul] LT',
              nextDay : '[Besok pukul] LT',
              nextWeek : 'dddd [pukul] LT',
              lastDay : '[Kemarin pukul] LT',
              lastWeek : 'dddd [lalu pukul] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'dalam %s',
              past : '%s yang lalu',
              s : 'beberapa detik',
              m : 'semenit',
              mm : '%d menit',
              h : 'sejam',
              hh : '%d jam',
              d : 'sehari',
              dd : '%d hari',
              M : 'sebulan',
              MM : '%d bulan',
              y : 'setahun',
              yy : '%d tahun'
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : icelandic (is)
      //! author : Hinrik Örn Sigurðsson : https://github.com/hinrik
  
      function is__plural(n) {
          if (n % 100 === 11) {
              return true;
          } else if (n % 10 === 1) {
              return false;
          }
          return true;
      }
      function is__translate(number, withoutSuffix, key, isFuture) {
          var result = number + ' ';
          switch (key) {
          case 's':
              return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
          case 'm':
              return withoutSuffix ? 'mínúta' : 'mínútu';
          case 'mm':
              if (is__plural(number)) {
                  return result + (withoutSuffix || isFuture ? 'mínútur' : 'mínútum');
              } else if (withoutSuffix) {
                  return result + 'mínúta';
              }
              return result + 'mínútu';
          case 'hh':
              if (is__plural(number)) {
                  return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
              }
              return result + 'klukkustund';
          case 'd':
              if (withoutSuffix) {
                  return 'dagur';
              }
              return isFuture ? 'dag' : 'degi';
          case 'dd':
              if (is__plural(number)) {
                  if (withoutSuffix) {
                      return result + 'dagar';
                  }
                  return result + (isFuture ? 'daga' : 'dögum');
              } else if (withoutSuffix) {
                  return result + 'dagur';
              }
              return result + (isFuture ? 'dag' : 'degi');
          case 'M':
              if (withoutSuffix) {
                  return 'mánuður';
              }
              return isFuture ? 'mánuð' : 'mánuði';
          case 'MM':
              if (is__plural(number)) {
                  if (withoutSuffix) {
                      return result + 'mánuðir';
                  }
                  return result + (isFuture ? 'mánuði' : 'mánuðum');
              } else if (withoutSuffix) {
                  return result + 'mánuður';
              }
              return result + (isFuture ? 'mánuð' : 'mánuði');
          case 'y':
              return withoutSuffix || isFuture ? 'ár' : 'ári';
          case 'yy':
              if (is__plural(number)) {
                  return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
              }
              return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
          }
      }
  
      var is = moment__default.defineLocale('is', {
          months : 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split('_'),
          monthsShort : 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
          weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
          weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
          weekdaysMin : 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY [kl.] H:mm',
              LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm'
          },
          calendar : {
              sameDay : '[í dag kl.] LT',
              nextDay : '[á morgun kl.] LT',
              nextWeek : 'dddd [kl.] LT',
              lastDay : '[í gær kl.] LT',
              lastWeek : '[síðasta] dddd [kl.] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'eftir %s',
              past : 'fyrir %s síðan',
              s : is__translate,
              m : is__translate,
              mm : is__translate,
              h : 'klukkustund',
              hh : is__translate,
              d : is__translate,
              dd : is__translate,
              M : is__translate,
              MM : is__translate,
              y : is__translate,
              yy : is__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : italian (it)
      //! author : Lorenzo : https://github.com/aliem
      //! author: Mattia Larentis: https://github.com/nostalgiaz
  
      var it = moment__default.defineLocale('it', {
          months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
          monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
          weekdays : 'Domenica_Lunedì_Martedì_Mercoledì_Giovedì_Venerdì_Sabato'.split('_'),
          weekdaysShort : 'Dom_Lun_Mar_Mer_Gio_Ven_Sab'.split('_'),
          weekdaysMin : 'Do_Lu_Ma_Me_Gi_Ve_Sa'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Oggi alle] LT',
              nextDay: '[Domani alle] LT',
              nextWeek: 'dddd [alle] LT',
              lastDay: '[Ieri alle] LT',
              lastWeek: function () {
                  switch (this.day()) {
                      case 0:
                          return '[la scorsa] dddd [alle] LT';
                      default:
                          return '[lo scorso] dddd [alle] LT';
                  }
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : function (s) {
                  return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
              },
              past : '%s fa',
              s : 'alcuni secondi',
              m : 'un minuto',
              mm : '%d minuti',
              h : 'un\'ora',
              hh : '%d ore',
              d : 'un giorno',
              dd : '%d giorni',
              M : 'un mese',
              MM : '%d mesi',
              y : 'un anno',
              yy : '%d anni'
          },
          ordinalParse : /\d{1,2}º/,
          ordinal: '%dº',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : japanese (ja)
      //! author : LI Long : https://github.com/baryon
  
      var ja = moment__default.defineLocale('ja', {
          months : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
          monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
          weekdays : '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
          weekdaysShort : '日_月_火_水_木_金_土'.split('_'),
          weekdaysMin : '日_月_火_水_木_金_土'.split('_'),
          longDateFormat : {
              LT : 'Ah時m分',
              LTS : 'Ah時m分s秒',
              L : 'YYYY/MM/DD',
              LL : 'YYYY年M月D日',
              LLL : 'YYYY年M月D日Ah時m分',
              LLLL : 'YYYY年M月D日Ah時m分 dddd'
          },
          meridiemParse: /午前|午後/i,
          isPM : function (input) {
              return input === '午後';
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 12) {
                  return '午前';
              } else {
                  return '午後';
              }
          },
          calendar : {
              sameDay : '[今日] LT',
              nextDay : '[明日] LT',
              nextWeek : '[来週]dddd LT',
              lastDay : '[昨日] LT',
              lastWeek : '[前週]dddd LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s後',
              past : '%s前',
              s : '数秒',
              m : '1分',
              mm : '%d分',
              h : '1時間',
              hh : '%d時間',
              d : '1日',
              dd : '%d日',
              M : '1ヶ月',
              MM : '%dヶ月',
              y : '1年',
              yy : '%d年'
          }
      });
  
      //! moment.js locale configuration
      //! locale : Boso Jowo (jv)
      //! author : Rony Lantip : https://github.com/lantip
      //! reference: http://jv.wikipedia.org/wiki/Basa_Jawa
  
      var jv = moment__default.defineLocale('jv', {
          months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
          monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
          weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
          weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
          weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
          longDateFormat : {
              LT : 'HH.mm',
              LTS : 'HH.mm.ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY [pukul] HH.mm',
              LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
          },
          meridiemParse: /enjing|siyang|sonten|ndalu/,
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'enjing') {
                  return hour;
              } else if (meridiem === 'siyang') {
                  return hour >= 11 ? hour : hour + 12;
              } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
                  return hour + 12;
              }
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours < 11) {
                  return 'enjing';
              } else if (hours < 15) {
                  return 'siyang';
              } else if (hours < 19) {
                  return 'sonten';
              } else {
                  return 'ndalu';
              }
          },
          calendar : {
              sameDay : '[Dinten puniko pukul] LT',
              nextDay : '[Mbenjang pukul] LT',
              nextWeek : 'dddd [pukul] LT',
              lastDay : '[Kala wingi pukul] LT',
              lastWeek : 'dddd [kepengker pukul] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'wonten ing %s',
              past : '%s ingkang kepengker',
              s : 'sawetawis detik',
              m : 'setunggal menit',
              mm : '%d menit',
              h : 'setunggal jam',
              hh : '%d jam',
              d : 'sedinten',
              dd : '%d dinten',
              M : 'sewulan',
              MM : '%d wulan',
              y : 'setaun',
              yy : '%d taun'
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Georgian (ka)
      //! author : Irakli Janiashvili : https://github.com/irakli-janiashvili
  
      var ka = moment__default.defineLocale('ka', {
          months : {
              standalone: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
              format: 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
          },
          monthsShort : 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
          weekdays : {
              standalone: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
              format: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_'),
              isFormat: /(წინა|შემდეგ)/
          },
          weekdaysShort : 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
          weekdaysMin : 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
          longDateFormat : {
              LT : 'h:mm A',
              LTS : 'h:mm:ss A',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY h:mm A',
              LLLL : 'dddd, D MMMM YYYY h:mm A'
          },
          calendar : {
              sameDay : '[დღეს] LT[-ზე]',
              nextDay : '[ხვალ] LT[-ზე]',
              lastDay : '[გუშინ] LT[-ზე]',
              nextWeek : '[შემდეგ] dddd LT[-ზე]',
              lastWeek : '[წინა] dddd LT-ზე',
              sameElse : 'L'
          },
          relativeTime : {
              future : function (s) {
                  return (/(წამი|წუთი|საათი|წელი)/).test(s) ?
                      s.replace(/ი$/, 'ში') :
                      s + 'ში';
              },
              past : function (s) {
                  if ((/(წამი|წუთი|საათი|დღე|თვე)/).test(s)) {
                      return s.replace(/(ი|ე)$/, 'ის წინ');
                  }
                  if ((/წელი/).test(s)) {
                      return s.replace(/წელი$/, 'წლის წინ');
                  }
              },
              s : 'რამდენიმე წამი',
              m : 'წუთი',
              mm : '%d წუთი',
              h : 'საათი',
              hh : '%d საათი',
              d : 'დღე',
              dd : '%d დღე',
              M : 'თვე',
              MM : '%d თვე',
              y : 'წელი',
              yy : '%d წელი'
          },
          ordinalParse: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
          ordinal : function (number) {
              if (number === 0) {
                  return number;
              }
              if (number === 1) {
                  return number + '-ლი';
              }
              if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
                  return 'მე-' + number;
              }
              return number + '-ე';
          },
          week : {
              dow : 1,
              doy : 7
          }
      });
  
      //! moment.js locale configuration
      //! locale : kazakh (kk)
      //! authors : Nurlan Rakhimzhanov : https://github.com/nurlan
  
      var kk__suffixes = {
          0: '-ші',
          1: '-ші',
          2: '-ші',
          3: '-ші',
          4: '-ші',
          5: '-ші',
          6: '-шы',
          7: '-ші',
          8: '-ші',
          9: '-шы',
          10: '-шы',
          20: '-шы',
          30: '-шы',
          40: '-шы',
          50: '-ші',
          60: '-шы',
          70: '-ші',
          80: '-ші',
          90: '-шы',
          100: '-ші'
      };
  
      var kk = moment__default.defineLocale('kk', {
          months : 'Қаңтар_Ақпан_Наурыз_Сәуір_Мамыр_Маусым_Шілде_Тамыз_Қыркүйек_Қазан_Қараша_Желтоқсан'.split('_'),
          monthsShort : 'Қаң_Ақп_Нау_Сәу_Мам_Мау_Шіл_Там_Қыр_Қаз_Қар_Жел'.split('_'),
          weekdays : 'Жексенбі_Дүйсенбі_Сейсенбі_Сәрсенбі_Бейсенбі_Жұма_Сенбі'.split('_'),
          weekdaysShort : 'Жек_Дүй_Сей_Сәр_Бей_Жұм_Сен'.split('_'),
          weekdaysMin : 'Жк_Дй_Сй_Ср_Бй_Жм_Сн'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[Бүгін сағат] LT',
              nextDay : '[Ертең сағат] LT',
              nextWeek : 'dddd [сағат] LT',
              lastDay : '[Кеше сағат] LT',
              lastWeek : '[Өткен аптаның] dddd [сағат] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s ішінде',
              past : '%s бұрын',
              s : 'бірнеше секунд',
              m : 'бір минут',
              mm : '%d минут',
              h : 'бір сағат',
              hh : '%d сағат',
              d : 'бір күн',
              dd : '%d күн',
              M : 'бір ай',
              MM : '%d ай',
              y : 'бір жыл',
              yy : '%d жыл'
          },
          ordinalParse: /\d{1,2}-(ші|шы)/,
          ordinal : function (number) {
              var a = number % 10,
                  b = number >= 100 ? 100 : null;
              return number + (kk__suffixes[number] || kk__suffixes[a] || kk__suffixes[b]);
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : khmer (km)
      //! author : Kruy Vanna : https://github.com/kruyvanna
  
      var km = moment__default.defineLocale('km', {
          months: 'មករា_កុម្ភៈ_មិនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
          monthsShort: 'មករា_កុម្ភៈ_មិនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
          weekdays: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
          weekdaysShort: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
          weekdaysMin: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
          longDateFormat: {
              LT: 'HH:mm',
              LTS : 'HH:mm:ss',
              L: 'DD/MM/YYYY',
              LL: 'D MMMM YYYY',
              LLL: 'D MMMM YYYY HH:mm',
              LLLL: 'dddd, D MMMM YYYY HH:mm'
          },
          calendar: {
              sameDay: '[ថ្ងៃនេះ ម៉ោង] LT',
              nextDay: '[ស្អែក ម៉ោង] LT',
              nextWeek: 'dddd [ម៉ោង] LT',
              lastDay: '[ម្សិលមិញ ម៉ោង] LT',
              lastWeek: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
              sameElse: 'L'
          },
          relativeTime: {
              future: '%sទៀត',
              past: '%sមុន',
              s: 'ប៉ុន្មានវិនាទី',
              m: 'មួយនាទី',
              mm: '%d នាទី',
              h: 'មួយម៉ោង',
              hh: '%d ម៉ោង',
              d: 'មួយថ្ងៃ',
              dd: '%d ថ្ងៃ',
              M: 'មួយខែ',
              MM: '%d ខែ',
              y: 'មួយឆ្នាំ',
              yy: '%d ឆ្នាំ'
          },
          week: {
              dow: 1, // Monday is the first day of the week.
              doy: 4 // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : korean (ko)
      //!
      //! authors
      //!
      //! - Kyungwook, Park : https://github.com/kyungw00k
      //! - Jeeeyul Lee <jeeeyul@gmail.com>
  
      var ko = moment__default.defineLocale('ko', {
          months : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
          monthsShort : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
          weekdays : '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
          weekdaysShort : '일_월_화_수_목_금_토'.split('_'),
          weekdaysMin : '일_월_화_수_목_금_토'.split('_'),
          longDateFormat : {
              LT : 'A h시 m분',
              LTS : 'A h시 m분 s초',
              L : 'YYYY.MM.DD',
              LL : 'YYYY년 MMMM D일',
              LLL : 'YYYY년 MMMM D일 A h시 m분',
              LLLL : 'YYYY년 MMMM D일 dddd A h시 m분'
          },
          calendar : {
              sameDay : '오늘 LT',
              nextDay : '내일 LT',
              nextWeek : 'dddd LT',
              lastDay : '어제 LT',
              lastWeek : '지난주 dddd LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s 후',
              past : '%s 전',
              s : '몇초',
              ss : '%d초',
              m : '일분',
              mm : '%d분',
              h : '한시간',
              hh : '%d시간',
              d : '하루',
              dd : '%d일',
              M : '한달',
              MM : '%d달',
              y : '일년',
              yy : '%d년'
          },
          ordinalParse : /\d{1,2}일/,
          ordinal : '%d일',
          meridiemParse : /오전|오후/,
          isPM : function (token) {
              return token === '오후';
          },
          meridiem : function (hour, minute, isUpper) {
              return hour < 12 ? '오전' : '오후';
          }
      });
  
      //! moment.js locale configuration
      //! locale : Luxembourgish (lb)
      //! author : mweimerskirch : https://github.com/mweimerskirch, David Raison : https://github.com/kwisatz
  
      function lb__processRelativeTime(number, withoutSuffix, key, isFuture) {
          var format = {
              'm': ['eng Minutt', 'enger Minutt'],
              'h': ['eng Stonn', 'enger Stonn'],
              'd': ['een Dag', 'engem Dag'],
              'M': ['ee Mount', 'engem Mount'],
              'y': ['ee Joer', 'engem Joer']
          };
          return withoutSuffix ? format[key][0] : format[key][1];
      }
      function processFutureTime(string) {
          var number = string.substr(0, string.indexOf(' '));
          if (eifelerRegelAppliesToNumber(number)) {
              return 'a ' + string;
          }
          return 'an ' + string;
      }
      function processPastTime(string) {
          var number = string.substr(0, string.indexOf(' '));
          if (eifelerRegelAppliesToNumber(number)) {
              return 'viru ' + string;
          }
          return 'virun ' + string;
      }
      /**
       * Returns true if the word before the given number loses the '-n' ending.
       * e.g. 'an 10 Deeg' but 'a 5 Deeg'
       *
       * @param number {integer}
       * @returns {boolean}
       */
      function eifelerRegelAppliesToNumber(number) {
          number = parseInt(number, 10);
          if (isNaN(number)) {
              return false;
          }
          if (number < 0) {
              // Negative Number --> always true
              return true;
          } else if (number < 10) {
              // Only 1 digit
              if (4 <= number && number <= 7) {
                  return true;
              }
              return false;
          } else if (number < 100) {
              // 2 digits
              var lastDigit = number % 10, firstDigit = number / 10;
              if (lastDigit === 0) {
                  return eifelerRegelAppliesToNumber(firstDigit);
              }
              return eifelerRegelAppliesToNumber(lastDigit);
          } else if (number < 10000) {
              // 3 or 4 digits --> recursively check first digit
              while (number >= 10) {
                  number = number / 10;
              }
              return eifelerRegelAppliesToNumber(number);
          } else {
              // Anything larger than 4 digits: recursively check first n-3 digits
              number = number / 1000;
              return eifelerRegelAppliesToNumber(number);
          }
      }
  
      var lb = moment__default.defineLocale('lb', {
          months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
          monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
          weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
          weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
          weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
          longDateFormat: {
              LT: 'H:mm [Auer]',
              LTS: 'H:mm:ss [Auer]',
              L: 'DD.MM.YYYY',
              LL: 'D. MMMM YYYY',
              LLL: 'D. MMMM YYYY H:mm [Auer]',
              LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]'
          },
          calendar: {
              sameDay: '[Haut um] LT',
              sameElse: 'L',
              nextDay: '[Muer um] LT',
              nextWeek: 'dddd [um] LT',
              lastDay: '[Gëschter um] LT',
              lastWeek: function () {
                  // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
                  switch (this.day()) {
                      case 2:
                      case 4:
                          return '[Leschten] dddd [um] LT';
                      default:
                          return '[Leschte] dddd [um] LT';
                  }
              }
          },
          relativeTime : {
              future : processFutureTime,
              past : processPastTime,
              s : 'e puer Sekonnen',
              m : lb__processRelativeTime,
              mm : '%d Minutten',
              h : lb__processRelativeTime,
              hh : '%d Stonnen',
              d : lb__processRelativeTime,
              dd : '%d Deeg',
              M : lb__processRelativeTime,
              MM : '%d Méint',
              y : lb__processRelativeTime,
              yy : '%d Joer'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal: '%d.',
          week: {
              dow: 1, // Monday is the first day of the week.
              doy: 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : lao (lo)
      //! author : Ryan Hart : https://github.com/ryanhart2
  
      var lo = moment__default.defineLocale('lo', {
          months : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
          monthsShort : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
          weekdays : 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
          weekdaysShort : 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
          weekdaysMin : 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'ວັນdddd D MMMM YYYY HH:mm'
          },
          meridiemParse: /ຕອນເຊົ້າ|ຕອນແລງ/,
          isPM: function (input) {
              return input === 'ຕອນແລງ';
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 12) {
                  return 'ຕອນເຊົ້າ';
              } else {
                  return 'ຕອນແລງ';
              }
          },
          calendar : {
              sameDay : '[ມື້ນີ້ເວລາ] LT',
              nextDay : '[ມື້ອື່ນເວລາ] LT',
              nextWeek : '[ວັນ]dddd[ໜ້າເວລາ] LT',
              lastDay : '[ມື້ວານນີ້ເວລາ] LT',
              lastWeek : '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'ອີກ %s',
              past : '%sຜ່ານມາ',
              s : 'ບໍ່ເທົ່າໃດວິນາທີ',
              m : '1 ນາທີ',
              mm : '%d ນາທີ',
              h : '1 ຊົ່ວໂມງ',
              hh : '%d ຊົ່ວໂມງ',
              d : '1 ມື້',
              dd : '%d ມື້',
              M : '1 ເດືອນ',
              MM : '%d ເດືອນ',
              y : '1 ປີ',
              yy : '%d ປີ'
          },
          ordinalParse: /(ທີ່)\d{1,2}/,
          ordinal : function (number) {
              return 'ທີ່' + number;
          }
      });
  
      //! moment.js locale configuration
      //! locale : Lithuanian (lt)
      //! author : Mindaugas Mozūras : https://github.com/mmozuras
  
      var lt__units = {
          'm' : 'minutė_minutės_minutę',
          'mm': 'minutės_minučių_minutes',
          'h' : 'valanda_valandos_valandą',
          'hh': 'valandos_valandų_valandas',
          'd' : 'diena_dienos_dieną',
          'dd': 'dienos_dienų_dienas',
          'M' : 'mėnuo_mėnesio_mėnesį',
          'MM': 'mėnesiai_mėnesių_mėnesius',
          'y' : 'metai_metų_metus',
          'yy': 'metai_metų_metus'
      };
      function translateSeconds(number, withoutSuffix, key, isFuture) {
          if (withoutSuffix) {
              return 'kelios sekundės';
          } else {
              return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
          }
      }
      function translateSingular(number, withoutSuffix, key, isFuture) {
          return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);
      }
      function special(number) {
          return number % 10 === 0 || (number > 10 && number < 20);
      }
      function forms(key) {
          return lt__units[key].split('_');
      }
      function lt__translate(number, withoutSuffix, key, isFuture) {
          var result = number + ' ';
          if (number === 1) {
              return result + translateSingular(number, withoutSuffix, key[0], isFuture);
          } else if (withoutSuffix) {
              return result + (special(number) ? forms(key)[1] : forms(key)[0]);
          } else {
              if (isFuture) {
                  return result + forms(key)[1];
              } else {
                  return result + (special(number) ? forms(key)[1] : forms(key)[2]);
              }
          }
      }
      var lt = moment__default.defineLocale('lt', {
          months : {
              format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
              standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_')
          },
          monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
          weekdays : {
              format: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split('_'),
              standalone: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split('_'),
              isFormat: /dddd HH:mm/
          },
          weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
          weekdaysMin : 'S_P_A_T_K_Pn_Š'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'YYYY-MM-DD',
              LL : 'YYYY [m.] MMMM D [d.]',
              LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
              LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
              l : 'YYYY-MM-DD',
              ll : 'YYYY [m.] MMMM D [d.]',
              lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
              llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
          },
          calendar : {
              sameDay : '[Šiandien] LT',
              nextDay : '[Rytoj] LT',
              nextWeek : 'dddd LT',
              lastDay : '[Vakar] LT',
              lastWeek : '[Praėjusį] dddd LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'po %s',
              past : 'prieš %s',
              s : translateSeconds,
              m : translateSingular,
              mm : lt__translate,
              h : translateSingular,
              hh : lt__translate,
              d : translateSingular,
              dd : lt__translate,
              M : translateSingular,
              MM : lt__translate,
              y : translateSingular,
              yy : lt__translate
          },
          ordinalParse: /\d{1,2}-oji/,
          ordinal : function (number) {
              return number + '-oji';
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : latvian (lv)
      //! author : Kristaps Karlsons : https://github.com/skakri
      //! author : Jānis Elmeris : https://github.com/JanisE
  
      var lv__units = {
          'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
          'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
          'h': 'stundas_stundām_stunda_stundas'.split('_'),
          'hh': 'stundas_stundām_stunda_stundas'.split('_'),
          'd': 'dienas_dienām_diena_dienas'.split('_'),
          'dd': 'dienas_dienām_diena_dienas'.split('_'),
          'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
          'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
          'y': 'gada_gadiem_gads_gadi'.split('_'),
          'yy': 'gada_gadiem_gads_gadi'.split('_')
      };
      /**
       * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
       */
      function lv__format(forms, number, withoutSuffix) {
          if (withoutSuffix) {
              // E.g. "21 minūte", "3 minūtes".
              return number % 10 === 1 && number !== 11 ? forms[2] : forms[3];
          } else {
              // E.g. "21 minūtes" as in "pēc 21 minūtes".
              // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
              return number % 10 === 1 && number !== 11 ? forms[0] : forms[1];
          }
      }
      function lv__relativeTimeWithPlural(number, withoutSuffix, key) {
          return number + ' ' + lv__format(lv__units[key], number, withoutSuffix);
      }
      function relativeTimeWithSingular(number, withoutSuffix, key) {
          return lv__format(lv__units[key], number, withoutSuffix);
      }
      function relativeSeconds(number, withoutSuffix) {
          return withoutSuffix ? 'dažas sekundes' : 'dažām sekundēm';
      }
  
      var lv = moment__default.defineLocale('lv', {
          months : 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
          monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
          weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
          weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
          weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY.',
              LL : 'YYYY. [gada] D. MMMM',
              LLL : 'YYYY. [gada] D. MMMM, HH:mm',
              LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
          },
          calendar : {
              sameDay : '[Šodien pulksten] LT',
              nextDay : '[Rīt pulksten] LT',
              nextWeek : 'dddd [pulksten] LT',
              lastDay : '[Vakar pulksten] LT',
              lastWeek : '[Pagājušā] dddd [pulksten] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'pēc %s',
              past : 'pirms %s',
              s : relativeSeconds,
              m : relativeTimeWithSingular,
              mm : lv__relativeTimeWithPlural,
              h : relativeTimeWithSingular,
              hh : lv__relativeTimeWithPlural,
              d : relativeTimeWithSingular,
              dd : lv__relativeTimeWithPlural,
              M : relativeTimeWithSingular,
              MM : lv__relativeTimeWithPlural,
              y : relativeTimeWithSingular,
              yy : lv__relativeTimeWithPlural
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Montenegrin (me)
      //! author : Miodrag Nikač <miodrag@restartit.me> : https://github.com/miodragnikac
  
      var me__translator = {
          words: { //Different grammatical cases
              m: ['jedan minut', 'jednog minuta'],
              mm: ['minut', 'minuta', 'minuta'],
              h: ['jedan sat', 'jednog sata'],
              hh: ['sat', 'sata', 'sati'],
              dd: ['dan', 'dana', 'dana'],
              MM: ['mjesec', 'mjeseca', 'mjeseci'],
              yy: ['godina', 'godine', 'godina']
          },
          correctGrammaticalCase: function (number, wordKey) {
              return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
          },
          translate: function (number, withoutSuffix, key) {
              var wordKey = me__translator.words[key];
              if (key.length === 1) {
                  return withoutSuffix ? wordKey[0] : wordKey[1];
              } else {
                  return number + ' ' + me__translator.correctGrammaticalCase(number, wordKey);
              }
          }
      };
  
      var me = moment__default.defineLocale('me', {
          months: ['januar', 'februar', 'mart', 'april', 'maj', 'jun', 'jul', 'avgust', 'septembar', 'oktobar', 'novembar', 'decembar'],
          monthsShort: ['jan.', 'feb.', 'mar.', 'apr.', 'maj', 'jun', 'jul', 'avg.', 'sep.', 'okt.', 'nov.', 'dec.'],
          weekdays: ['nedjelja', 'ponedjeljak', 'utorak', 'srijeda', 'četvrtak', 'petak', 'subota'],
          weekdaysShort: ['ned.', 'pon.', 'uto.', 'sri.', 'čet.', 'pet.', 'sub.'],
          weekdaysMin: ['ne', 'po', 'ut', 'sr', 'če', 'pe', 'su'],
          longDateFormat: {
              LT: 'H:mm',
              LTS : 'H:mm:ss',
              L: 'DD. MM. YYYY',
              LL: 'D. MMMM YYYY',
              LLL: 'D. MMMM YYYY H:mm',
              LLLL: 'dddd, D. MMMM YYYY H:mm'
          },
          calendar: {
              sameDay: '[danas u] LT',
              nextDay: '[sjutra u] LT',
  
              nextWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[u] [nedjelju] [u] LT';
                  case 3:
                      return '[u] [srijedu] [u] LT';
                  case 6:
                      return '[u] [subotu] [u] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[u] dddd [u] LT';
                  }
              },
              lastDay  : '[juče u] LT',
              lastWeek : function () {
                  var lastWeekDays = [
                      '[prošle] [nedjelje] [u] LT',
                      '[prošlog] [ponedjeljka] [u] LT',
                      '[prošlog] [utorka] [u] LT',
                      '[prošle] [srijede] [u] LT',
                      '[prošlog] [četvrtka] [u] LT',
                      '[prošlog] [petka] [u] LT',
                      '[prošle] [subote] [u] LT'
                  ];
                  return lastWeekDays[this.day()];
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'za %s',
              past   : 'prije %s',
              s      : 'nekoliko sekundi',
              m      : me__translator.translate,
              mm     : me__translator.translate,
              h      : me__translator.translate,
              hh     : me__translator.translate,
              d      : 'dan',
              dd     : me__translator.translate,
              M      : 'mjesec',
              MM     : me__translator.translate,
              y      : 'godinu',
              yy     : me__translator.translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : macedonian (mk)
      //! author : Borislav Mickov : https://github.com/B0k0
  
      var mk = moment__default.defineLocale('mk', {
          months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
          monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
          weekdays : 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
          weekdaysShort : 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
          weekdaysMin : 'нe_пo_вт_ср_че_пе_сa'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'D.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY H:mm',
              LLLL : 'dddd, D MMMM YYYY H:mm'
          },
          calendar : {
              sameDay : '[Денес во] LT',
              nextDay : '[Утре во] LT',
              nextWeek : '[Во] dddd [во] LT',
              lastDay : '[Вчера во] LT',
              lastWeek : function () {
                  switch (this.day()) {
                  case 0:
                  case 3:
                  case 6:
                      return '[Изминатата] dddd [во] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[Изминатиот] dddd [во] LT';
                  }
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'после %s',
              past : 'пред %s',
              s : 'неколку секунди',
              m : 'минута',
              mm : '%d минути',
              h : 'час',
              hh : '%d часа',
              d : 'ден',
              dd : '%d дена',
              M : 'месец',
              MM : '%d месеци',
              y : 'година',
              yy : '%d години'
          },
          ordinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
          ordinal : function (number) {
              var lastDigit = number % 10,
                  last2Digits = number % 100;
              if (number === 0) {
                  return number + '-ев';
              } else if (last2Digits === 0) {
                  return number + '-ен';
              } else if (last2Digits > 10 && last2Digits < 20) {
                  return number + '-ти';
              } else if (lastDigit === 1) {
                  return number + '-ви';
              } else if (lastDigit === 2) {
                  return number + '-ри';
              } else if (lastDigit === 7 || lastDigit === 8) {
                  return number + '-ми';
              } else {
                  return number + '-ти';
              }
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : malayalam (ml)
      //! author : Floyd Pink : https://github.com/floydpink
  
      var ml = moment__default.defineLocale('ml', {
          months : 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
          monthsShort : 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split('_'),
          weekdays : 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split('_'),
          weekdaysShort : 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
          weekdaysMin : 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
          longDateFormat : {
              LT : 'A h:mm -നു',
              LTS : 'A h:mm:ss -നു',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, A h:mm -നു',
              LLLL : 'dddd, D MMMM YYYY, A h:mm -നു'
          },
          calendar : {
              sameDay : '[ഇന്ന്] LT',
              nextDay : '[നാളെ] LT',
              nextWeek : 'dddd, LT',
              lastDay : '[ഇന്നലെ] LT',
              lastWeek : '[കഴിഞ്ഞ] dddd, LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s കഴിഞ്ഞ്',
              past : '%s മുൻപ്',
              s : 'അൽപ നിമിഷങ്ങൾ',
              m : 'ഒരു മിനിറ്റ്',
              mm : '%d മിനിറ്റ്',
              h : 'ഒരു മണിക്കൂർ',
              hh : '%d മണിക്കൂർ',
              d : 'ഒരു ദിവസം',
              dd : '%d ദിവസം',
              M : 'ഒരു മാസം',
              MM : '%d മാസം',
              y : 'ഒരു വർഷം',
              yy : '%d വർഷം'
          },
          meridiemParse: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
          isPM : function (input) {
              return /^(ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി)$/.test(input);
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'രാത്രി';
              } else if (hour < 12) {
                  return 'രാവിലെ';
              } else if (hour < 17) {
                  return 'ഉച്ച കഴിഞ്ഞ്';
              } else if (hour < 20) {
                  return 'വൈകുന്നേരം';
              } else {
                  return 'രാത്രി';
              }
          }
      });
  
      //! moment.js locale configuration
      //! locale : Marathi (mr)
      //! author : Harshad Kale : https://github.com/kalehv
      //! author : Vivek Athalye : https://github.com/vnathalye
  
      var mr__symbolMap = {
          '1': '१',
          '2': '२',
          '3': '३',
          '4': '४',
          '5': '५',
          '6': '६',
          '7': '७',
          '8': '८',
          '9': '९',
          '0': '०'
      },
      mr__numberMap = {
          '१': '1',
          '२': '2',
          '३': '3',
          '४': '4',
          '५': '5',
          '६': '6',
          '७': '7',
          '८': '8',
          '९': '9',
          '०': '0'
      };
  
      function relativeTimeMr(number, withoutSuffix, string, isFuture)
      {
          var output = '';
          if (withoutSuffix) {
              switch (string) {
                  case 's': output = 'काही सेकंद'; break;
                  case 'm': output = 'एक मिनिट'; break;
                  case 'mm': output = '%d मिनिटे'; break;
                  case 'h': output = 'एक तास'; break;
                  case 'hh': output = '%d तास'; break;
                  case 'd': output = 'एक दिवस'; break;
                  case 'dd': output = '%d दिवस'; break;
                  case 'M': output = 'एक महिना'; break;
                  case 'MM': output = '%d महिने'; break;
                  case 'y': output = 'एक वर्ष'; break;
                  case 'yy': output = '%d वर्षे'; break;
              }
          }
          else {
              switch (string) {
                  case 's': output = 'काही सेकंदां'; break;
                  case 'm': output = 'एका मिनिटा'; break;
                  case 'mm': output = '%d मिनिटां'; break;
                  case 'h': output = 'एका तासा'; break;
                  case 'hh': output = '%d तासां'; break;
                  case 'd': output = 'एका दिवसा'; break;
                  case 'dd': output = '%d दिवसां'; break;
                  case 'M': output = 'एका महिन्या'; break;
                  case 'MM': output = '%d महिन्यां'; break;
                  case 'y': output = 'एका वर्षा'; break;
                  case 'yy': output = '%d वर्षां'; break;
              }
          }
          return output.replace(/%d/i, number);
      }
  
      var mr = moment__default.defineLocale('mr', {
          months : 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split('_'),
          monthsShort: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split('_'),
          weekdays : 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
          weekdaysShort : 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
          weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
          longDateFormat : {
              LT : 'A h:mm वाजता',
              LTS : 'A h:mm:ss वाजता',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, A h:mm वाजता',
              LLLL : 'dddd, D MMMM YYYY, A h:mm वाजता'
          },
          calendar : {
              sameDay : '[आज] LT',
              nextDay : '[उद्या] LT',
              nextWeek : 'dddd, LT',
              lastDay : '[काल] LT',
              lastWeek: '[मागील] dddd, LT',
              sameElse : 'L'
          },
          relativeTime : {
              future: '%sमध्ये',
              past: '%sपूर्वी',
              s: relativeTimeMr,
              m: relativeTimeMr,
              mm: relativeTimeMr,
              h: relativeTimeMr,
              hh: relativeTimeMr,
              d: relativeTimeMr,
              dd: relativeTimeMr,
              M: relativeTimeMr,
              MM: relativeTimeMr,
              y: relativeTimeMr,
              yy: relativeTimeMr
          },
          preparse: function (string) {
              return string.replace(/[१२३४५६७८९०]/g, function (match) {
                  return mr__numberMap[match];
              });
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return mr__symbolMap[match];
              });
          },
          meridiemParse: /रात्री|सकाळी|दुपारी|सायंकाळी/,
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'रात्री') {
                  return hour < 4 ? hour : hour + 12;
              } else if (meridiem === 'सकाळी') {
                  return hour;
              } else if (meridiem === 'दुपारी') {
                  return hour >= 10 ? hour : hour + 12;
              } else if (meridiem === 'सायंकाळी') {
                  return hour + 12;
              }
          },
          meridiem: function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'रात्री';
              } else if (hour < 10) {
                  return 'सकाळी';
              } else if (hour < 17) {
                  return 'दुपारी';
              } else if (hour < 20) {
                  return 'सायंकाळी';
              } else {
                  return 'रात्री';
              }
          },
          week : {
              dow : 0, // Sunday is the first day of the week.
              doy : 6  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Bahasa Malaysia (ms-MY)
      //! author : Weldan Jamili : https://github.com/weldan
  
      var ms_my = moment__default.defineLocale('ms-my', {
          months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
          monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
          weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
          weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
          weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
          longDateFormat : {
              LT : 'HH.mm',
              LTS : 'HH.mm.ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY [pukul] HH.mm',
              LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
          },
          meridiemParse: /pagi|tengahari|petang|malam/,
          meridiemHour: function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'pagi') {
                  return hour;
              } else if (meridiem === 'tengahari') {
                  return hour >= 11 ? hour : hour + 12;
              } else if (meridiem === 'petang' || meridiem === 'malam') {
                  return hour + 12;
              }
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours < 11) {
                  return 'pagi';
              } else if (hours < 15) {
                  return 'tengahari';
              } else if (hours < 19) {
                  return 'petang';
              } else {
                  return 'malam';
              }
          },
          calendar : {
              sameDay : '[Hari ini pukul] LT',
              nextDay : '[Esok pukul] LT',
              nextWeek : 'dddd [pukul] LT',
              lastDay : '[Kelmarin pukul] LT',
              lastWeek : 'dddd [lepas pukul] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'dalam %s',
              past : '%s yang lepas',
              s : 'beberapa saat',
              m : 'seminit',
              mm : '%d minit',
              h : 'sejam',
              hh : '%d jam',
              d : 'sehari',
              dd : '%d hari',
              M : 'sebulan',
              MM : '%d bulan',
              y : 'setahun',
              yy : '%d tahun'
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Bahasa Malaysia (ms-MY)
      //! author : Weldan Jamili : https://github.com/weldan
  
      var locale_ms = moment__default.defineLocale('ms', {
          months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
          monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
          weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
          weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
          weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
          longDateFormat : {
              LT : 'HH.mm',
              LTS : 'HH.mm.ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY [pukul] HH.mm',
              LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
          },
          meridiemParse: /pagi|tengahari|petang|malam/,
          meridiemHour: function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'pagi') {
                  return hour;
              } else if (meridiem === 'tengahari') {
                  return hour >= 11 ? hour : hour + 12;
              } else if (meridiem === 'petang' || meridiem === 'malam') {
                  return hour + 12;
              }
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours < 11) {
                  return 'pagi';
              } else if (hours < 15) {
                  return 'tengahari';
              } else if (hours < 19) {
                  return 'petang';
              } else {
                  return 'malam';
              }
          },
          calendar : {
              sameDay : '[Hari ini pukul] LT',
              nextDay : '[Esok pukul] LT',
              nextWeek : 'dddd [pukul] LT',
              lastDay : '[Kelmarin pukul] LT',
              lastWeek : 'dddd [lepas pukul] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'dalam %s',
              past : '%s yang lepas',
              s : 'beberapa saat',
              m : 'seminit',
              mm : '%d minit',
              h : 'sejam',
              hh : '%d jam',
              d : 'sehari',
              dd : '%d hari',
              M : 'sebulan',
              MM : '%d bulan',
              y : 'setahun',
              yy : '%d tahun'
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Burmese (my)
      //! author : Squar team, mysquar.com
  
      var my__symbolMap = {
          '1': '၁',
          '2': '၂',
          '3': '၃',
          '4': '၄',
          '5': '၅',
          '6': '၆',
          '7': '၇',
          '8': '၈',
          '9': '၉',
          '0': '၀'
      }, my__numberMap = {
          '၁': '1',
          '၂': '2',
          '၃': '3',
          '၄': '4',
          '၅': '5',
          '၆': '6',
          '၇': '7',
          '၈': '8',
          '၉': '9',
          '၀': '0'
      };
  
      var my = moment__default.defineLocale('my', {
          months: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split('_'),
          monthsShort: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
          weekdays: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split('_'),
          weekdaysShort: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
          weekdaysMin: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
  
          longDateFormat: {
              LT: 'HH:mm',
              LTS: 'HH:mm:ss',
              L: 'DD/MM/YYYY',
              LL: 'D MMMM YYYY',
              LLL: 'D MMMM YYYY HH:mm',
              LLLL: 'dddd D MMMM YYYY HH:mm'
          },
          calendar: {
              sameDay: '[ယနေ.] LT [မှာ]',
              nextDay: '[မနက်ဖြန်] LT [မှာ]',
              nextWeek: 'dddd LT [မှာ]',
              lastDay: '[မနေ.က] LT [မှာ]',
              lastWeek: '[ပြီးခဲ့သော] dddd LT [မှာ]',
              sameElse: 'L'
          },
          relativeTime: {
              future: 'လာမည့် %s မှာ',
              past: 'လွန်ခဲ့သော %s က',
              s: 'စက္ကန်.အနည်းငယ်',
              m: 'တစ်မိနစ်',
              mm: '%d မိနစ်',
              h: 'တစ်နာရီ',
              hh: '%d နာရီ',
              d: 'တစ်ရက်',
              dd: '%d ရက်',
              M: 'တစ်လ',
              MM: '%d လ',
              y: 'တစ်နှစ်',
              yy: '%d နှစ်'
          },
          preparse: function (string) {
              return string.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match) {
                  return my__numberMap[match];
              });
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return my__symbolMap[match];
              });
          },
          week: {
              dow: 1, // Monday is the first day of the week.
              doy: 4 // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : norwegian bokmål (nb)
      //! authors : Espen Hovlandsdal : https://github.com/rexxars
      //!           Sigurd Gartmann : https://github.com/sigurdga
  
      var nb = moment__default.defineLocale('nb', {
          months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
          monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
          weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
          weekdaysShort : 'sø._ma._ti._on._to._fr._lø.'.split('_'),
          weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY [kl.] HH:mm',
              LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
          },
          calendar : {
              sameDay: '[i dag kl.] LT',
              nextDay: '[i morgen kl.] LT',
              nextWeek: 'dddd [kl.] LT',
              lastDay: '[i går kl.] LT',
              lastWeek: '[forrige] dddd [kl.] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'om %s',
              past : 'for %s siden',
              s : 'noen sekunder',
              m : 'ett minutt',
              mm : '%d minutter',
              h : 'en time',
              hh : '%d timer',
              d : 'en dag',
              dd : '%d dager',
              M : 'en måned',
              MM : '%d måneder',
              y : 'ett år',
              yy : '%d år'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : nepali/nepalese
      //! author : suvash : https://github.com/suvash
  
      var ne__symbolMap = {
          '1': '१',
          '2': '२',
          '3': '३',
          '4': '४',
          '5': '५',
          '6': '६',
          '7': '७',
          '8': '८',
          '9': '९',
          '0': '०'
      },
      ne__numberMap = {
          '१': '1',
          '२': '2',
          '३': '3',
          '४': '4',
          '५': '5',
          '६': '6',
          '७': '7',
          '८': '8',
          '९': '9',
          '०': '0'
      };
  
      var ne = moment__default.defineLocale('ne', {
          months : 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split('_'),
          monthsShort : 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split('_'),
          weekdays : 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split('_'),
          weekdaysShort : 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
          weekdaysMin : 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
          longDateFormat : {
              LT : 'Aको h:mm बजे',
              LTS : 'Aको h:mm:ss बजे',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, Aको h:mm बजे',
              LLLL : 'dddd, D MMMM YYYY, Aको h:mm बजे'
          },
          preparse: function (string) {
              return string.replace(/[१२३४५६७८९०]/g, function (match) {
                  return ne__numberMap[match];
              });
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return ne__symbolMap[match];
              });
          },
          meridiemParse: /राति|बिहान|दिउँसो|साँझ/,
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'राति') {
                  return hour < 4 ? hour : hour + 12;
              } else if (meridiem === 'बिहान') {
                  return hour;
              } else if (meridiem === 'दिउँसो') {
                  return hour >= 10 ? hour : hour + 12;
              } else if (meridiem === 'साँझ') {
                  return hour + 12;
              }
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 3) {
                  return 'राति';
              } else if (hour < 12) {
                  return 'बिहान';
              } else if (hour < 16) {
                  return 'दिउँसो';
              } else if (hour < 20) {
                  return 'साँझ';
              } else {
                  return 'राति';
              }
          },
          calendar : {
              sameDay : '[आज] LT',
              nextDay : '[भोलि] LT',
              nextWeek : '[आउँदो] dddd[,] LT',
              lastDay : '[हिजो] LT',
              lastWeek : '[गएको] dddd[,] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%sमा',
              past : '%s अगाडि',
              s : 'केही क्षण',
              m : 'एक मिनेट',
              mm : '%d मिनेट',
              h : 'एक घण्टा',
              hh : '%d घण्टा',
              d : 'एक दिन',
              dd : '%d दिन',
              M : 'एक महिना',
              MM : '%d महिना',
              y : 'एक बर्ष',
              yy : '%d बर्ष'
          },
          week : {
              dow : 0, // Sunday is the first day of the week.
              doy : 6  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : dutch (nl)
      //! author : Joris Röling : https://github.com/jjupiter
  
      var nl__monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
          nl__monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
  
      var nl = moment__default.defineLocale('nl', {
          months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
          monthsShort : function (m, format) {
              if (/-MMM-/.test(format)) {
                  return nl__monthsShortWithoutDots[m.month()];
              } else {
                  return nl__monthsShortWithDots[m.month()];
              }
          },
          weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
          weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
          weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD-MM-YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[vandaag om] LT',
              nextDay: '[morgen om] LT',
              nextWeek: 'dddd [om] LT',
              lastDay: '[gisteren om] LT',
              lastWeek: '[afgelopen] dddd [om] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'over %s',
              past : '%s geleden',
              s : 'een paar seconden',
              m : 'één minuut',
              mm : '%d minuten',
              h : 'één uur',
              hh : '%d uur',
              d : 'één dag',
              dd : '%d dagen',
              M : 'één maand',
              MM : '%d maanden',
              y : 'één jaar',
              yy : '%d jaar'
          },
          ordinalParse: /\d{1,2}(ste|de)/,
          ordinal : function (number) {
              return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : norwegian nynorsk (nn)
      //! author : https://github.com/mechuwind
  
      var nn = moment__default.defineLocale('nn', {
          months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
          monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
          weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
          weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
          weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY [kl.] H:mm',
              LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
          },
          calendar : {
              sameDay: '[I dag klokka] LT',
              nextDay: '[I morgon klokka] LT',
              nextWeek: 'dddd [klokka] LT',
              lastDay: '[I går klokka] LT',
              lastWeek: '[Føregåande] dddd [klokka] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'om %s',
              past : 'for %s sidan',
              s : 'nokre sekund',
              m : 'eit minutt',
              mm : '%d minutt',
              h : 'ein time',
              hh : '%d timar',
              d : 'ein dag',
              dd : '%d dagar',
              M : 'ein månad',
              MM : '%d månader',
              y : 'eit år',
              yy : '%d år'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : polish (pl)
      //! author : Rafal Hirsz : https://github.com/evoL
  
      var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'),
          monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');
      function pl__plural(n) {
          return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);
      }
      function pl__translate(number, withoutSuffix, key) {
          var result = number + ' ';
          switch (key) {
          case 'm':
              return withoutSuffix ? 'minuta' : 'minutę';
          case 'mm':
              return result + (pl__plural(number) ? 'minuty' : 'minut');
          case 'h':
              return withoutSuffix  ? 'godzina'  : 'godzinę';
          case 'hh':
              return result + (pl__plural(number) ? 'godziny' : 'godzin');
          case 'MM':
              return result + (pl__plural(number) ? 'miesiące' : 'miesięcy');
          case 'yy':
              return result + (pl__plural(number) ? 'lata' : 'lat');
          }
      }
  
      var pl = moment__default.defineLocale('pl', {
          months : function (momentToFormat, format) {
              if (format === '') {
                  // Hack: if format empty we know this is used to generate
                  // RegExp by moment. Give then back both valid forms of months
                  // in RegExp ready format.
                  return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')';
              } else if (/D MMMM/.test(format)) {
                  return monthsSubjective[momentToFormat.month()];
              } else {
                  return monthsNominative[momentToFormat.month()];
              }
          },
          monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
          weekdays : 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
          weekdaysShort : 'nie_pon_wt_śr_czw_pt_sb'.split('_'),
          weekdaysMin : 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Dziś o] LT',
              nextDay: '[Jutro o] LT',
              nextWeek: '[W] dddd [o] LT',
              lastDay: '[Wczoraj o] LT',
              lastWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[W zeszłą niedzielę o] LT';
                  case 3:
                      return '[W zeszłą środę o] LT';
                  case 6:
                      return '[W zeszłą sobotę o] LT';
                  default:
                      return '[W zeszły] dddd [o] LT';
                  }
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'za %s',
              past : '%s temu',
              s : 'kilka sekund',
              m : pl__translate,
              mm : pl__translate,
              h : pl__translate,
              hh : pl__translate,
              d : '1 dzień',
              dd : '%d dni',
              M : 'miesiąc',
              MM : pl__translate,
              y : 'rok',
              yy : pl__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : brazilian portuguese (pt-br)
      //! author : Caio Ribeiro Pereira : https://github.com/caio-ribeiro-pereira
  
      var pt_br = moment__default.defineLocale('pt-br', {
          months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
          monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
          weekdays : 'Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado'.split('_'),
          weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
          weekdaysMin : 'Dom_2ª_3ª_4ª_5ª_6ª_Sáb'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D [de] MMMM [de] YYYY',
              LLL : 'D [de] MMMM [de] YYYY [às] HH:mm',
              LLLL : 'dddd, D [de] MMMM [de] YYYY [às] HH:mm'
          },
          calendar : {
              sameDay: '[Hoje às] LT',
              nextDay: '[Amanhã às] LT',
              nextWeek: 'dddd [às] LT',
              lastDay: '[Ontem às] LT',
              lastWeek: function () {
                  return (this.day() === 0 || this.day() === 6) ?
                      '[Último] dddd [às] LT' : // Saturday + Sunday
                      '[Última] dddd [às] LT'; // Monday - Friday
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'em %s',
              past : '%s atrás',
              s : 'poucos segundos',
              m : 'um minuto',
              mm : '%d minutos',
              h : 'uma hora',
              hh : '%d horas',
              d : 'um dia',
              dd : '%d dias',
              M : 'um mês',
              MM : '%d meses',
              y : 'um ano',
              yy : '%d anos'
          },
          ordinalParse: /\d{1,2}º/,
          ordinal : '%dº'
      });
  
      //! moment.js locale configuration
      //! locale : portuguese (pt)
      //! author : Jefferson : https://github.com/jalex79
  
      var pt = moment__default.defineLocale('pt', {
          months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
          monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
          weekdays : 'Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado'.split('_'),
          weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
          weekdaysMin : 'Dom_2ª_3ª_4ª_5ª_6ª_Sáb'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D [de] MMMM [de] YYYY',
              LLL : 'D [de] MMMM [de] YYYY HH:mm',
              LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Hoje às] LT',
              nextDay: '[Amanhã às] LT',
              nextWeek: 'dddd [às] LT',
              lastDay: '[Ontem às] LT',
              lastWeek: function () {
                  return (this.day() === 0 || this.day() === 6) ?
                      '[Último] dddd [às] LT' : // Saturday + Sunday
                      '[Última] dddd [às] LT'; // Monday - Friday
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'em %s',
              past : 'há %s',
              s : 'segundos',
              m : 'um minuto',
              mm : '%d minutos',
              h : 'uma hora',
              hh : '%d horas',
              d : 'um dia',
              dd : '%d dias',
              M : 'um mês',
              MM : '%d meses',
              y : 'um ano',
              yy : '%d anos'
          },
          ordinalParse: /\d{1,2}º/,
          ordinal : '%dº',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : romanian (ro)
      //! author : Vlad Gurdiga : https://github.com/gurdiga
      //! author : Valentin Agachi : https://github.com/avaly
  
      function ro__relativeTimeWithPlural(number, withoutSuffix, key) {
          var format = {
                  'mm': 'minute',
                  'hh': 'ore',
                  'dd': 'zile',
                  'MM': 'luni',
                  'yy': 'ani'
              },
              separator = ' ';
          if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
              separator = ' de ';
          }
          return number + separator + format[key];
      }
  
      var ro = moment__default.defineLocale('ro', {
          months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
          monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
          weekdays : 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
          weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
          weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY H:mm',
              LLLL : 'dddd, D MMMM YYYY H:mm'
          },
          calendar : {
              sameDay: '[azi la] LT',
              nextDay: '[mâine la] LT',
              nextWeek: 'dddd [la] LT',
              lastDay: '[ieri la] LT',
              lastWeek: '[fosta] dddd [la] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'peste %s',
              past : '%s în urmă',
              s : 'câteva secunde',
              m : 'un minut',
              mm : ro__relativeTimeWithPlural,
              h : 'o oră',
              hh : ro__relativeTimeWithPlural,
              d : 'o zi',
              dd : ro__relativeTimeWithPlural,
              M : 'o lună',
              MM : ro__relativeTimeWithPlural,
              y : 'un an',
              yy : ro__relativeTimeWithPlural
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : russian (ru)
      //! author : Viktorminator : https://github.com/Viktorminator
      //! Author : Menelion Elensúle : https://github.com/Oire
  
      function ru__plural(word, num) {
          var forms = word.split('_');
          return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
      }
      function ru__relativeTimeWithPlural(number, withoutSuffix, key) {
          var format = {
              'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
              'hh': 'час_часа_часов',
              'dd': 'день_дня_дней',
              'MM': 'месяц_месяца_месяцев',
              'yy': 'год_года_лет'
          };
          if (key === 'm') {
              return withoutSuffix ? 'минута' : 'минуту';
          }
          else {
              return number + ' ' + ru__plural(format[key], +number);
          }
      }
      var monthsParse = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[й|я]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];
  
      var ru = moment__default.defineLocale('ru', {
          months : {
              format: 'Января_Февраля_Марта_Апреля_Мая_Июня_Июля_Августа_Сентября_Октября_Ноября_Декабря'.split('_'),
              standalone: 'Январь_Февраль_Март_Апрель_Май_Июнь_Июль_Август_Сентябрь_Октябрь_Ноябрь_Декабрь'.split('_')
          },
          monthsShort : {
              format: 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split('_'),
              standalone: 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_')
          },
          weekdays : {
              standalone: 'Воскресенье_Понедельник_Вторник_Среда_Четверг_Пятница_Суббота'.split('_'),
              format: 'Воскресенье_Понедельник_Вторник_Среду_Четверг_Пятницу_Субботу'.split('_'),
              isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
          },
          weekdaysShort : 'Вс_Пн_Вт_Ср_Чт_Пт_Сб'.split('_'),
          weekdaysMin : 'Вс_Пн_Вт_Ср_Чт_Пт_Сб'.split('_'),
          monthsParse : monthsParse,
          longMonthsParse : monthsParse,
          shortMonthsParse : monthsParse,
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY г.',
              LLL : 'D MMMM YYYY г., HH:mm',
              LLLL : 'dddd, D MMMM YYYY г., HH:mm'
          },
          calendar : {
              sameDay: '[Сегодня в] LT',
              nextDay: '[Завтра в] LT',
              lastDay: '[Вчера в] LT',
              nextWeek: function (now) {
                  if (now.week() !== this.week()) {
                      switch (this.day()) {
                      case 0:
                          return '[В следующее] dddd [в] LT';
                      case 1:
                      case 2:
                      case 4:
                          return '[В следующий] dddd [в] LT';
                      case 3:
                      case 5:
                      case 6:
                          return '[В следующую] dddd [в] LT';
                      }
                  } else {
                      if (this.day() === 2) {
                          return '[Во] dddd [в] LT';
                      } else {
                          return '[В] dddd [в] LT';
                      }
                  }
              },
              lastWeek: function (now) {
                  if (now.week() !== this.week()) {
                      switch (this.day()) {
                      case 0:
                          return '[В прошлое] dddd [в] LT';
                      case 1:
                      case 2:
                      case 4:
                          return '[В прошлый] dddd [в] LT';
                      case 3:
                      case 5:
                      case 6:
                          return '[В прошлую] dddd [в] LT';
                      }
                  } else {
                      if (this.day() === 2) {
                          return '[Во] dddd [в] LT';
                      } else {
                          return '[В] dddd [в] LT';
                      }
                  }
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'через %s',
              past : '%s назад',
              s : 'несколько секунд',
              m : ru__relativeTimeWithPlural,
              mm : ru__relativeTimeWithPlural,
              h : 'час',
              hh : ru__relativeTimeWithPlural,
              d : 'день',
              dd : ru__relativeTimeWithPlural,
              M : 'месяц',
              MM : ru__relativeTimeWithPlural,
              y : 'год',
              yy : ru__relativeTimeWithPlural
          },
          meridiemParse: /ночи|утра|дня|вечера/i,
          isPM : function (input) {
              return /^(дня|вечера)$/.test(input);
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'ночи';
              } else if (hour < 12) {
                  return 'утра';
              } else if (hour < 17) {
                  return 'дня';
              } else {
                  return 'вечера';
              }
          },
          ordinalParse: /\d{1,2}-(й|го|я)/,
          ordinal: function (number, period) {
              switch (period) {
              case 'M':
              case 'd':
              case 'DDD':
                  return number + '-й';
              case 'D':
                  return number + '-го';
              case 'w':
              case 'W':
                  return number + '-я';
              default:
                  return number;
              }
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Northern Sami (se)
      //! authors : Bård Rolstad Henriksen : https://github.com/karamell
  
  
      var se = moment__default.defineLocale('se', {
          months : 'ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu'.split('_'),
          monthsShort : 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split('_'),
          weekdays : 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),
          weekdaysShort : 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
          weekdaysMin : 's_v_m_g_d_b_L'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'MMMM D. [b.] YYYY',
              LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',
              LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
          },
          calendar : {
              sameDay: '[otne ti] LT',
              nextDay: '[ihttin ti] LT',
              nextWeek: 'dddd [ti] LT',
              lastDay: '[ikte ti] LT',
              lastWeek: '[ovddit] dddd [ti] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : '%s geažes',
              past : 'maŋit %s',
              s : 'moadde sekunddat',
              m : 'okta minuhta',
              mm : '%d minuhtat',
              h : 'okta diimmu',
              hh : '%d diimmut',
              d : 'okta beaivi',
              dd : '%d beaivvit',
              M : 'okta mánnu',
              MM : '%d mánut',
              y : 'okta jahki',
              yy : '%d jagit'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Sinhalese (si)
      //! author : Sampath Sitinamaluwa : https://github.com/sampathsris
  
      /*jshint -W100*/
      var si = moment__default.defineLocale('si', {
          months : 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split('_'),
          monthsShort : 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split('_'),
          weekdays : 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split('_'),
          weekdaysShort : 'ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන'.split('_'),
          weekdaysMin : 'ඉ_ස_අ_බ_බ්‍ර_සි_සෙ'.split('_'),
          longDateFormat : {
              LT : 'a h:mm',
              LTS : 'a h:mm:ss',
              L : 'YYYY/MM/DD',
              LL : 'YYYY MMMM D',
              LLL : 'YYYY MMMM D, a h:mm',
              LLLL : 'YYYY MMMM D [වැනි] dddd, a h:mm:ss'
          },
          calendar : {
              sameDay : '[අද] LT[ට]',
              nextDay : '[හෙට] LT[ට]',
              nextWeek : 'dddd LT[ට]',
              lastDay : '[ඊයේ] LT[ට]',
              lastWeek : '[පසුගිය] dddd LT[ට]',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%sකින්',
              past : '%sකට පෙර',
              s : 'තත්පර කිහිපය',
              m : 'මිනිත්තුව',
              mm : 'මිනිත්තු %d',
              h : 'පැය',
              hh : 'පැය %d',
              d : 'දිනය',
              dd : 'දින %d',
              M : 'මාසය',
              MM : 'මාස %d',
              y : 'වසර',
              yy : 'වසර %d'
          },
          ordinalParse: /\d{1,2} වැනි/,
          ordinal : function (number) {
              return number + ' වැනි';
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours > 11) {
                  return isLower ? 'ප.ව.' : 'පස් වරු';
              } else {
                  return isLower ? 'පෙ.ව.' : 'පෙර වරු';
              }
          }
      });
  
      //! moment.js locale configuration
      //! locale : slovak (sk)
      //! author : Martin Minka : https://github.com/k2s
      //! based on work of petrbela : https://github.com/petrbela
  
      var sk__months = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_'),
          sk__monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
      function sk__plural(n) {
          return (n > 1) && (n < 5);
      }
      function sk__translate(number, withoutSuffix, key, isFuture) {
          var result = number + ' ';
          switch (key) {
          case 's':  // a few seconds / in a few seconds / a few seconds ago
              return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
          case 'm':  // a minute / in a minute / a minute ago
              return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou');
          case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
              if (withoutSuffix || isFuture) {
                  return result + (sk__plural(number) ? 'minúty' : 'minút');
              } else {
                  return result + 'minútami';
              }
              break;
          case 'h':  // an hour / in an hour / an hour ago
              return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
          case 'hh': // 9 hours / in 9 hours / 9 hours ago
              if (withoutSuffix || isFuture) {
                  return result + (sk__plural(number) ? 'hodiny' : 'hodín');
              } else {
                  return result + 'hodinami';
              }
              break;
          case 'd':  // a day / in a day / a day ago
              return (withoutSuffix || isFuture) ? 'deň' : 'dňom';
          case 'dd': // 9 days / in 9 days / 9 days ago
              if (withoutSuffix || isFuture) {
                  return result + (sk__plural(number) ? 'dni' : 'dní');
              } else {
                  return result + 'dňami';
              }
              break;
          case 'M':  // a month / in a month / a month ago
              return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
          case 'MM': // 9 months / in 9 months / 9 months ago
              if (withoutSuffix || isFuture) {
                  return result + (sk__plural(number) ? 'mesiace' : 'mesiacov');
              } else {
                  return result + 'mesiacmi';
              }
              break;
          case 'y':  // a year / in a year / a year ago
              return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
          case 'yy': // 9 years / in 9 years / 9 years ago
              if (withoutSuffix || isFuture) {
                  return result + (sk__plural(number) ? 'roky' : 'rokov');
              } else {
                  return result + 'rokmi';
              }
              break;
          }
      }
  
      var sk = moment__default.defineLocale('sk', {
          months : sk__months,
          monthsShort : sk__monthsShort,
          weekdays : 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
          weekdaysShort : 'ne_po_ut_st_št_pi_so'.split('_'),
          weekdaysMin : 'ne_po_ut_st_št_pi_so'.split('_'),
          longDateFormat : {
              LT: 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY H:mm',
              LLLL : 'dddd D. MMMM YYYY H:mm'
          },
          calendar : {
              sameDay: '[dnes o] LT',
              nextDay: '[zajtra o] LT',
              nextWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[v nedeľu o] LT';
                  case 1:
                  case 2:
                      return '[v] dddd [o] LT';
                  case 3:
                      return '[v stredu o] LT';
                  case 4:
                      return '[vo štvrtok o] LT';
                  case 5:
                      return '[v piatok o] LT';
                  case 6:
                      return '[v sobotu o] LT';
                  }
              },
              lastDay: '[včera o] LT',
              lastWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[minulú nedeľu o] LT';
                  case 1:
                  case 2:
                      return '[minulý] dddd [o] LT';
                  case 3:
                      return '[minulú stredu o] LT';
                  case 4:
                  case 5:
                      return '[minulý] dddd [o] LT';
                  case 6:
                      return '[minulú sobotu o] LT';
                  }
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'za %s',
              past : 'pred %s',
              s : sk__translate,
              m : sk__translate,
              mm : sk__translate,
              h : sk__translate,
              hh : sk__translate,
              d : sk__translate,
              dd : sk__translate,
              M : sk__translate,
              MM : sk__translate,
              y : sk__translate,
              yy : sk__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : slovenian (sl)
      //! author : Robert Sedovšek : https://github.com/sedovsek
  
      function sl__processRelativeTime(number, withoutSuffix, key, isFuture) {
          var result = number + ' ';
          switch (key) {
          case 's':
              return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami';
          case 'm':
              return withoutSuffix ? 'ena minuta' : 'eno minuto';
          case 'mm':
              if (number === 1) {
                  result += withoutSuffix ? 'minuta' : 'minuto';
              } else if (number === 2) {
                  result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
              } else if (number < 5) {
                  result += withoutSuffix || isFuture ? 'minute' : 'minutami';
              } else {
                  result += withoutSuffix || isFuture ? 'minut' : 'minutami';
              }
              return result;
          case 'h':
              return withoutSuffix ? 'ena ura' : 'eno uro';
          case 'hh':
              if (number === 1) {
                  result += withoutSuffix ? 'ura' : 'uro';
              } else if (number === 2) {
                  result += withoutSuffix || isFuture ? 'uri' : 'urama';
              } else if (number < 5) {
                  result += withoutSuffix || isFuture ? 'ure' : 'urami';
              } else {
                  result += withoutSuffix || isFuture ? 'ur' : 'urami';
              }
              return result;
          case 'd':
              return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
          case 'dd':
              if (number === 1) {
                  result += withoutSuffix || isFuture ? 'dan' : 'dnem';
              } else if (number === 2) {
                  result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
              } else {
                  result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
              }
              return result;
          case 'M':
              return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
          case 'MM':
              if (number === 1) {
                  result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
              } else if (number === 2) {
                  result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
              } else if (number < 5) {
                  result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
              } else {
                  result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
              }
              return result;
          case 'y':
              return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
          case 'yy':
              if (number === 1) {
                  result += withoutSuffix || isFuture ? 'leto' : 'letom';
              } else if (number === 2) {
                  result += withoutSuffix || isFuture ? 'leti' : 'letoma';
              } else if (number < 5) {
                  result += withoutSuffix || isFuture ? 'leta' : 'leti';
              } else {
                  result += withoutSuffix || isFuture ? 'let' : 'leti';
              }
              return result;
          }
      }
  
      var sl = moment__default.defineLocale('sl', {
          months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
          monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
          weekdays : 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
          weekdaysShort : 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
          weekdaysMin : 'ne_po_to_sr_če_pe_so'.split('_'),
          longDateFormat : {
              LT : 'H:mm',
              LTS : 'H:mm:ss',
              L : 'DD. MM. YYYY',
              LL : 'D. MMMM YYYY',
              LLL : 'D. MMMM YYYY H:mm',
              LLLL : 'dddd, D. MMMM YYYY H:mm'
          },
          calendar : {
              sameDay  : '[danes ob] LT',
              nextDay  : '[jutri ob] LT',
  
              nextWeek : function () {
                  switch (this.day()) {
                  case 0:
                      return '[v] [nedeljo] [ob] LT';
                  case 3:
                      return '[v] [sredo] [ob] LT';
                  case 6:
                      return '[v] [soboto] [ob] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[v] dddd [ob] LT';
                  }
              },
              lastDay  : '[včeraj ob] LT',
              lastWeek : function () {
                  switch (this.day()) {
                  case 0:
                      return '[prejšnjo] [nedeljo] [ob] LT';
                  case 3:
                      return '[prejšnjo] [sredo] [ob] LT';
                  case 6:
                      return '[prejšnjo] [soboto] [ob] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[prejšnji] dddd [ob] LT';
                  }
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'čez %s',
              past   : 'pred %s',
              s      : sl__processRelativeTime,
              m      : sl__processRelativeTime,
              mm     : sl__processRelativeTime,
              h      : sl__processRelativeTime,
              hh     : sl__processRelativeTime,
              d      : sl__processRelativeTime,
              dd     : sl__processRelativeTime,
              M      : sl__processRelativeTime,
              MM     : sl__processRelativeTime,
              y      : sl__processRelativeTime,
              yy     : sl__processRelativeTime
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Albanian (sq)
      //! author : Flakërim Ismani : https://github.com/flakerimi
      //! author: Menelion Elensúle: https://github.com/Oire (tests)
      //! author : Oerd Cukalla : https://github.com/oerd (fixes)
  
      var sq = moment__default.defineLocale('sq', {
          months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
          monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
          weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
          weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
          weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'),
          meridiemParse: /PD|MD/,
          isPM: function (input) {
              return input.charAt(0) === 'M';
          },
          meridiem : function (hours, minutes, isLower) {
              return hours < 12 ? 'PD' : 'MD';
          },
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[Sot në] LT',
              nextDay : '[Nesër në] LT',
              nextWeek : 'dddd [në] LT',
              lastDay : '[Dje në] LT',
              lastWeek : 'dddd [e kaluar në] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'në %s',
              past : '%s më parë',
              s : 'disa sekonda',
              m : 'një minutë',
              mm : '%d minuta',
              h : 'një orë',
              hh : '%d orë',
              d : 'një ditë',
              dd : '%d ditë',
              M : 'një muaj',
              MM : '%d muaj',
              y : 'një vit',
              yy : '%d vite'
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Serbian-cyrillic (sr-cyrl)
      //! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
  
      var sr_cyrl__translator = {
          words: { //Different grammatical cases
              m: ['један минут', 'једне минуте'],
              mm: ['минут', 'минуте', 'минута'],
              h: ['један сат', 'једног сата'],
              hh: ['сат', 'сата', 'сати'],
              dd: ['дан', 'дана', 'дана'],
              MM: ['месец', 'месеца', 'месеци'],
              yy: ['година', 'године', 'година']
          },
          correctGrammaticalCase: function (number, wordKey) {
              return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
          },
          translate: function (number, withoutSuffix, key) {
              var wordKey = sr_cyrl__translator.words[key];
              if (key.length === 1) {
                  return withoutSuffix ? wordKey[0] : wordKey[1];
              } else {
                  return number + ' ' + sr_cyrl__translator.correctGrammaticalCase(number, wordKey);
              }
          }
      };
  
      var sr_cyrl = moment__default.defineLocale('sr-cyrl', {
          months: ['јануар', 'фебруар', 'март', 'април', 'мај', 'јун', 'јул', 'август', 'септембар', 'октобар', 'новембар', 'децембар'],
          monthsShort: ['јан.', 'феб.', 'мар.', 'апр.', 'мај', 'јун', 'јул', 'авг.', 'сеп.', 'окт.', 'нов.', 'дец.'],
          weekdays: ['недеља', 'понедељак', 'уторак', 'среда', 'четвртак', 'петак', 'субота'],
          weekdaysShort: ['нед.', 'пон.', 'уто.', 'сре.', 'чет.', 'пет.', 'суб.'],
          weekdaysMin: ['не', 'по', 'ут', 'ср', 'че', 'пе', 'су'],
          longDateFormat: {
              LT: 'H:mm',
              LTS : 'H:mm:ss',
              L: 'DD. MM. YYYY',
              LL: 'D. MMMM YYYY',
              LLL: 'D. MMMM YYYY H:mm',
              LLLL: 'dddd, D. MMMM YYYY H:mm'
          },
          calendar: {
              sameDay: '[данас у] LT',
              nextDay: '[сутра у] LT',
              nextWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[у] [недељу] [у] LT';
                  case 3:
                      return '[у] [среду] [у] LT';
                  case 6:
                      return '[у] [суботу] [у] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[у] dddd [у] LT';
                  }
              },
              lastDay  : '[јуче у] LT',
              lastWeek : function () {
                  var lastWeekDays = [
                      '[прошле] [недеље] [у] LT',
                      '[прошлог] [понедељка] [у] LT',
                      '[прошлог] [уторка] [у] LT',
                      '[прошле] [среде] [у] LT',
                      '[прошлог] [четвртка] [у] LT',
                      '[прошлог] [петка] [у] LT',
                      '[прошле] [суботе] [у] LT'
                  ];
                  return lastWeekDays[this.day()];
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'за %s',
              past   : 'пре %s',
              s      : 'неколико секунди',
              m      : sr_cyrl__translator.translate,
              mm     : sr_cyrl__translator.translate,
              h      : sr_cyrl__translator.translate,
              hh     : sr_cyrl__translator.translate,
              d      : 'дан',
              dd     : sr_cyrl__translator.translate,
              M      : 'месец',
              MM     : sr_cyrl__translator.translate,
              y      : 'годину',
              yy     : sr_cyrl__translator.translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Serbian-latin (sr)
      //! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
  
      var sr__translator = {
          words: { //Different grammatical cases
              m: ['jedan minut', 'jedne minute'],
              mm: ['minut', 'minute', 'minuta'],
              h: ['jedan sat', 'jednog sata'],
              hh: ['sat', 'sata', 'sati'],
              dd: ['dan', 'dana', 'dana'],
              MM: ['mesec', 'meseca', 'meseci'],
              yy: ['godina', 'godine', 'godina']
          },
          correctGrammaticalCase: function (number, wordKey) {
              return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
          },
          translate: function (number, withoutSuffix, key) {
              var wordKey = sr__translator.words[key];
              if (key.length === 1) {
                  return withoutSuffix ? wordKey[0] : wordKey[1];
              } else {
                  return number + ' ' + sr__translator.correctGrammaticalCase(number, wordKey);
              }
          }
      };
  
      var sr = moment__default.defineLocale('sr', {
          months: ['januar', 'februar', 'mart', 'april', 'maj', 'jun', 'jul', 'avgust', 'septembar', 'oktobar', 'novembar', 'decembar'],
          monthsShort: ['jan.', 'feb.', 'mar.', 'apr.', 'maj', 'jun', 'jul', 'avg.', 'sep.', 'okt.', 'nov.', 'dec.'],
          weekdays: ['nedelja', 'ponedeljak', 'utorak', 'sreda', 'četvrtak', 'petak', 'subota'],
          weekdaysShort: ['ned.', 'pon.', 'uto.', 'sre.', 'čet.', 'pet.', 'sub.'],
          weekdaysMin: ['ne', 'po', 'ut', 'sr', 'če', 'pe', 'su'],
          longDateFormat: {
              LT: 'H:mm',
              LTS : 'H:mm:ss',
              L: 'DD. MM. YYYY',
              LL: 'D. MMMM YYYY',
              LLL: 'D. MMMM YYYY H:mm',
              LLLL: 'dddd, D. MMMM YYYY H:mm'
          },
          calendar: {
              sameDay: '[danas u] LT',
              nextDay: '[sutra u] LT',
              nextWeek: function () {
                  switch (this.day()) {
                  case 0:
                      return '[u] [nedelju] [u] LT';
                  case 3:
                      return '[u] [sredu] [u] LT';
                  case 6:
                      return '[u] [subotu] [u] LT';
                  case 1:
                  case 2:
                  case 4:
                  case 5:
                      return '[u] dddd [u] LT';
                  }
              },
              lastDay  : '[juče u] LT',
              lastWeek : function () {
                  var lastWeekDays = [
                      '[prošle] [nedelje] [u] LT',
                      '[prošlog] [ponedeljka] [u] LT',
                      '[prošlog] [utorka] [u] LT',
                      '[prošle] [srede] [u] LT',
                      '[prošlog] [četvrtka] [u] LT',
                      '[prošlog] [petka] [u] LT',
                      '[prošle] [subote] [u] LT'
                  ];
                  return lastWeekDays[this.day()];
              },
              sameElse : 'L'
          },
          relativeTime : {
              future : 'za %s',
              past   : 'pre %s',
              s      : 'nekoliko sekundi',
              m      : sr__translator.translate,
              mm     : sr__translator.translate,
              h      : sr__translator.translate,
              hh     : sr__translator.translate,
              d      : 'dan',
              dd     : sr__translator.translate,
              M      : 'mesec',
              MM     : sr__translator.translate,
              y      : 'godinu',
              yy     : sr__translator.translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : swedish (sv)
      //! author : Jens Alm : https://github.com/ulmus
  
      var sv = moment__default.defineLocale('sv', {
          months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
          monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
          weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
          weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
          weekdaysMin : 'sö_må_ti_on_to_fr_lö'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'YYYY-MM-DD',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Idag] LT',
              nextDay: '[Imorgon] LT',
              lastDay: '[Igår] LT',
              nextWeek: '[På] dddd LT',
              lastWeek: '[I] dddd[s] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'om %s',
              past : 'för %s sedan',
              s : 'några sekunder',
              m : 'en minut',
              mm : '%d minuter',
              h : 'en timme',
              hh : '%d timmar',
              d : 'en dag',
              dd : '%d dagar',
              M : 'en månad',
              MM : '%d månader',
              y : 'ett år',
              yy : '%d år'
          },
          ordinalParse: /\d{1,2}(e|a)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (~~(number % 100 / 10) === 1) ? 'e' :
                  (b === 1) ? 'a' :
                  (b === 2) ? 'a' :
                  (b === 3) ? 'e' : 'e';
              return number + output;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : swahili (sw)
      //! author : Fahad Kassim : https://github.com/fadsel
  
      var sw = moment__default.defineLocale('sw', {
          months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
          monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
          weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
          weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
          weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[leo saa] LT',
              nextDay : '[kesho saa] LT',
              nextWeek : '[wiki ijayo] dddd [saat] LT',
              lastDay : '[jana] LT',
              lastWeek : '[wiki iliyopita] dddd [saat] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s baadaye',
              past : 'tokea %s',
              s : 'hivi punde',
              m : 'dakika moja',
              mm : 'dakika %d',
              h : 'saa limoja',
              hh : 'masaa %d',
              d : 'siku moja',
              dd : 'masiku %d',
              M : 'mwezi mmoja',
              MM : 'miezi %d',
              y : 'mwaka mmoja',
              yy : 'miaka %d'
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : tamil (ta)
      //! author : Arjunkumar Krishnamoorthy : https://github.com/tk120404
  
      var ta__symbolMap = {
          '1': '௧',
          '2': '௨',
          '3': '௩',
          '4': '௪',
          '5': '௫',
          '6': '௬',
          '7': '௭',
          '8': '௮',
          '9': '௯',
          '0': '௦'
      }, ta__numberMap = {
          '௧': '1',
          '௨': '2',
          '௩': '3',
          '௪': '4',
          '௫': '5',
          '௬': '6',
          '௭': '7',
          '௮': '8',
          '௯': '9',
          '௦': '0'
      };
  
      var ta = moment__default.defineLocale('ta', {
          months : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
          monthsShort : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
          weekdays : 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split('_'),
          weekdaysShort : 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split('_'),
          weekdaysMin : 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, HH:mm',
              LLLL : 'dddd, D MMMM YYYY, HH:mm'
          },
          calendar : {
              sameDay : '[இன்று] LT',
              nextDay : '[நாளை] LT',
              nextWeek : 'dddd, LT',
              lastDay : '[நேற்று] LT',
              lastWeek : '[கடந்த வாரம்] dddd, LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s இல்',
              past : '%s முன்',
              s : 'ஒரு சில விநாடிகள்',
              m : 'ஒரு நிமிடம்',
              mm : '%d நிமிடங்கள்',
              h : 'ஒரு மணி நேரம்',
              hh : '%d மணி நேரம்',
              d : 'ஒரு நாள்',
              dd : '%d நாட்கள்',
              M : 'ஒரு மாதம்',
              MM : '%d மாதங்கள்',
              y : 'ஒரு வருடம்',
              yy : '%d ஆண்டுகள்'
          },
          ordinalParse: /\d{1,2}வது/,
          ordinal : function (number) {
              return number + 'வது';
          },
          preparse: function (string) {
              return string.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match) {
                  return ta__numberMap[match];
              });
          },
          postformat: function (string) {
              return string.replace(/\d/g, function (match) {
                  return ta__symbolMap[match];
              });
          },
          // refer http://ta.wikipedia.org/s/1er1
          meridiemParse: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
          meridiem : function (hour, minute, isLower) {
              if (hour < 2) {
                  return ' யாமம்';
              } else if (hour < 6) {
                  return ' வைகறை';  // வைகறை
              } else if (hour < 10) {
                  return ' காலை'; // காலை
              } else if (hour < 14) {
                  return ' நண்பகல்'; // நண்பகல்
              } else if (hour < 18) {
                  return ' எற்பாடு'; // எற்பாடு
              } else if (hour < 22) {
                  return ' மாலை'; // மாலை
              } else {
                  return ' யாமம்';
              }
          },
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'யாமம்') {
                  return hour < 2 ? hour : hour + 12;
              } else if (meridiem === 'வைகறை' || meridiem === 'காலை') {
                  return hour;
              } else if (meridiem === 'நண்பகல்') {
                  return hour >= 10 ? hour : hour + 12;
              } else {
                  return hour + 12;
              }
          },
          week : {
              dow : 0, // Sunday is the first day of the week.
              doy : 6  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : telugu (te)
      //! author : Krishna Chaitanya Thota : https://github.com/kcthota
  
      var te = moment__default.defineLocale('te', {
          months : 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జూలై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split('_'),
          monthsShort : 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జూలై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split('_'),
          weekdays : 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split('_'),
          weekdaysShort : 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
          weekdaysMin : 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
          longDateFormat : {
              LT : 'A h:mm',
              LTS : 'A h:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY, A h:mm',
              LLLL : 'dddd, D MMMM YYYY, A h:mm'
          },
          calendar : {
              sameDay : '[నేడు] LT',
              nextDay : '[రేపు] LT',
              nextWeek : 'dddd, LT',
              lastDay : '[నిన్న] LT',
              lastWeek : '[గత] dddd, LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s లో',
              past : '%s క్రితం',
              s : 'కొన్ని క్షణాలు',
              m : 'ఒక నిమిషం',
              mm : '%d నిమిషాలు',
              h : 'ఒక గంట',
              hh : '%d గంటలు',
              d : 'ఒక రోజు',
              dd : '%d రోజులు',
              M : 'ఒక నెల',
              MM : '%d నెలలు',
              y : 'ఒక సంవత్సరం',
              yy : '%d సంవత్సరాలు'
          },
          ordinalParse : /\d{1,2}వ/,
          ordinal : '%dవ',
          meridiemParse: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === 'రాత్రి') {
                  return hour < 4 ? hour : hour + 12;
              } else if (meridiem === 'ఉదయం') {
                  return hour;
              } else if (meridiem === 'మధ్యాహ్నం') {
                  return hour >= 10 ? hour : hour + 12;
              } else if (meridiem === 'సాయంత్రం') {
                  return hour + 12;
              }
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'రాత్రి';
              } else if (hour < 10) {
                  return 'ఉదయం';
              } else if (hour < 17) {
                  return 'మధ్యాహ్నం';
              } else if (hour < 20) {
                  return 'సాయంత్రం';
              } else {
                  return 'రాత్రి';
              }
          },
          week : {
              dow : 0, // Sunday is the first day of the week.
              doy : 6  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : thai (th)
      //! author : Kridsada Thanabulpong : https://github.com/sirn
  
      var th = moment__default.defineLocale('th', {
          months : 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
          monthsShort : 'มกรา_กุมภา_มีนา_เมษา_พฤษภา_มิถุนา_กรกฎา_สิงหา_กันยา_ตุลา_พฤศจิกา_ธันวา'.split('_'),
          weekdays : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
          weekdaysShort : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
          weekdaysMin : 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
          longDateFormat : {
              LT : 'H นาฬิกา m นาที',
              LTS : 'H นาฬิกา m นาที s วินาที',
              L : 'YYYY/MM/DD',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY เวลา H นาฬิกา m นาที',
              LLLL : 'วันddddที่ D MMMM YYYY เวลา H นาฬิกา m นาที'
          },
          meridiemParse: /ก่อนเที่ยง|หลังเที่ยง/,
          isPM: function (input) {
              return input === 'หลังเที่ยง';
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 12) {
                  return 'ก่อนเที่ยง';
              } else {
                  return 'หลังเที่ยง';
              }
          },
          calendar : {
              sameDay : '[วันนี้ เวลา] LT',
              nextDay : '[พรุ่งนี้ เวลา] LT',
              nextWeek : 'dddd[หน้า เวลา] LT',
              lastDay : '[เมื่อวานนี้ เวลา] LT',
              lastWeek : '[วัน]dddd[ที่แล้ว เวลา] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'อีก %s',
              past : '%sที่แล้ว',
              s : 'ไม่กี่วินาที',
              m : '1 นาที',
              mm : '%d นาที',
              h : '1 ชั่วโมง',
              hh : '%d ชั่วโมง',
              d : '1 วัน',
              dd : '%d วัน',
              M : '1 เดือน',
              MM : '%d เดือน',
              y : '1 ปี',
              yy : '%d ปี'
          }
      });
  
      //! moment.js locale configuration
      //! locale : Tagalog/Filipino (tl-ph)
      //! author : Dan Hagman
  
      var tl_ph = moment__default.defineLocale('tl-ph', {
          months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
          monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
          weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
          weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
          weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'MM/D/YYYY',
              LL : 'MMMM D, YYYY',
              LLL : 'MMMM D, YYYY HH:mm',
              LLLL : 'dddd, MMMM DD, YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Ngayon sa] LT',
              nextDay: '[Bukas sa] LT',
              nextWeek: 'dddd [sa] LT',
              lastDay: '[Kahapon sa] LT',
              lastWeek: 'dddd [huling linggo] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'sa loob ng %s',
              past : '%s ang nakalipas',
              s : 'ilang segundo',
              m : 'isang minuto',
              mm : '%d minuto',
              h : 'isang oras',
              hh : '%d oras',
              d : 'isang araw',
              dd : '%d araw',
              M : 'isang buwan',
              MM : '%d buwan',
              y : 'isang taon',
              yy : '%d taon'
          },
          ordinalParse: /\d{1,2}/,
          ordinal : function (number) {
              return number;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Klingon (tlh)
      //! author : Dominika Kruk : https://github.com/amaranthrose
  
      var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
  
      function translateFuture(output) {
          var time = output;
          time = (output.indexOf('jaj') !== -1) ?
      	time.slice(0, -3) + 'leS' :
      	(output.indexOf('jar') !== -1) ?
      	time.slice(0, -3) + 'waQ' :
      	(output.indexOf('DIS') !== -1) ?
      	time.slice(0, -3) + 'nem' :
      	time + ' pIq';
          return time;
      }
  
      function translatePast(output) {
          var time = output;
          time = (output.indexOf('jaj') !== -1) ?
      	time.slice(0, -3) + 'Hu’' :
      	(output.indexOf('jar') !== -1) ?
      	time.slice(0, -3) + 'wen' :
      	(output.indexOf('DIS') !== -1) ?
      	time.slice(0, -3) + 'ben' :
      	time + ' ret';
          return time;
      }
  
      function tlh__translate(number, withoutSuffix, string, isFuture) {
          var numberNoun = numberAsNoun(number);
          switch (string) {
              case 'mm':
                  return numberNoun + ' tup';
              case 'hh':
                  return numberNoun + ' rep';
              case 'dd':
                  return numberNoun + ' jaj';
              case 'MM':
                  return numberNoun + ' jar';
              case 'yy':
                  return numberNoun + ' DIS';
          }
      }
  
      function numberAsNoun(number) {
          var hundred = Math.floor((number % 1000) / 100),
      	ten = Math.floor((number % 100) / 10),
      	one = number % 10,
      	word = '';
          if (hundred > 0) {
              word += numbersNouns[hundred] + 'vatlh';
          }
          if (ten > 0) {
              word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH';
          }
          if (one > 0) {
              word += ((word !== '') ? ' ' : '') + numbersNouns[one];
          }
          return (word === '') ? 'pagh' : word;
      }
  
      var tlh = moment__default.defineLocale('tlh', {
          months : 'tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’'.split('_'),
          monthsShort : 'jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’'.split('_'),
          weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
          weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
          weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[DaHjaj] LT',
              nextDay: '[wa’leS] LT',
              nextWeek: 'LLL',
              lastDay: '[wa’Hu’] LT',
              lastWeek: 'LLL',
              sameElse: 'L'
          },
          relativeTime : {
              future : translateFuture,
              past : translatePast,
              s : 'puS lup',
              m : 'wa’ tup',
              mm : tlh__translate,
              h : 'wa’ rep',
              hh : tlh__translate,
              d : 'wa’ jaj',
              dd : tlh__translate,
              M : 'wa’ jar',
              MM : tlh__translate,
              y : 'wa’ DIS',
              yy : tlh__translate
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : turkish (tr)
      //! authors : Erhan Gundogan : https://github.com/erhangundogan,
      //!           Burak Yiğit Kaya: https://github.com/BYK
  
      var tr__suffixes = {
          1: '\'inci',
          5: '\'inci',
          8: '\'inci',
          70: '\'inci',
          80: '\'inci',
          2: '\'nci',
          7: '\'nci',
          20: '\'nci',
          50: '\'nci',
          3: '\'üncü',
          4: '\'üncü',
          100: '\'üncü',
          6: '\'ncı',
          9: '\'uncu',
          10: '\'uncu',
          30: '\'uncu',
          60: '\'ıncı',
          90: '\'ıncı'
      };
  
      var tr = moment__default.defineLocale('tr', {
          months : 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
          monthsShort : 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
          weekdays : 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
          weekdaysShort : 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
          weekdaysMin : 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd, D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay : '[bugün saat] LT',
              nextDay : '[yarın saat] LT',
              nextWeek : '[haftaya] dddd [saat] LT',
              lastDay : '[dün] LT',
              lastWeek : '[geçen hafta] dddd [saat] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : '%s sonra',
              past : '%s önce',
              s : 'birkaç saniye',
              m : 'bir dakika',
              mm : '%d dakika',
              h : 'bir saat',
              hh : '%d saat',
              d : 'bir gün',
              dd : '%d gün',
              M : 'bir ay',
              MM : '%d ay',
              y : 'bir yıl',
              yy : '%d yıl'
          },
          ordinalParse: /\d{1,2}'(inci|nci|üncü|ncı|uncu|ıncı)/,
          ordinal : function (number) {
              if (number === 0) {  // special case for zero
                  return number + '\'ıncı';
              }
              var a = number % 10,
                  b = number % 100 - a,
                  c = number >= 100 ? 100 : null;
              return number + (tr__suffixes[a] || tr__suffixes[b] || tr__suffixes[c]);
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : talossan (tzl)
      //! author : Robin van der Vliet : https://github.com/robin0van0der0v with the help of Iustì Canun
  
  
      // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
      // This is currently too difficult (maybe even impossible) to add.
      var tzl = moment__default.defineLocale('tzl', {
          months : 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'),
          monthsShort : 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
          weekdays : 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
          weekdaysShort : 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
          weekdaysMin : 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
          longDateFormat : {
              LT : 'HH.mm',
              LTS : 'HH.mm.ss',
              L : 'DD.MM.YYYY',
              LL : 'D. MMMM [dallas] YYYY',
              LLL : 'D. MMMM [dallas] YYYY HH.mm',
              LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
          },
          meridiem : function (hours, minutes, isLower) {
              if (hours > 11) {
                  return isLower ? 'd\'o' : 'D\'O';
              } else {
                  return isLower ? 'd\'a' : 'D\'A';
              }
          },
          calendar : {
              sameDay : '[oxhi à] LT',
              nextDay : '[demà à] LT',
              nextWeek : 'dddd [à] LT',
              lastDay : '[ieiri à] LT',
              lastWeek : '[sür el] dddd [lasteu à] LT',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'osprei %s',
              past : 'ja%s',
              s : tzl__processRelativeTime,
              m : tzl__processRelativeTime,
              mm : tzl__processRelativeTime,
              h : tzl__processRelativeTime,
              hh : tzl__processRelativeTime,
              d : tzl__processRelativeTime,
              dd : tzl__processRelativeTime,
              M : tzl__processRelativeTime,
              MM : tzl__processRelativeTime,
              y : tzl__processRelativeTime,
              yy : tzl__processRelativeTime
          },
          ordinalParse: /\d{1,2}\./,
          ordinal : '%d.',
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      function tzl__processRelativeTime(number, withoutSuffix, key, isFuture) {
          var format = {
              's': ['viensas secunds', '\'iensas secunds'],
              'm': ['\'n míut', '\'iens míut'],
              'mm': [number + ' míuts', '' + number + ' míuts'],
              'h': ['\'n þora', '\'iensa þora'],
              'hh': [number + ' þoras', '' + number + ' þoras'],
              'd': ['\'n ziua', '\'iensa ziua'],
              'dd': [number + ' ziuas', '' + number + ' ziuas'],
              'M': ['\'n mes', '\'iens mes'],
              'MM': [number + ' mesen', '' + number + ' mesen'],
              'y': ['\'n ar', '\'iens ar'],
              'yy': [number + ' ars', '' + number + ' ars']
          };
          return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]);
      }
  
      //! moment.js locale configuration
      //! locale : Morocco Central Atlas Tamaziɣt in Latin (tzm-latn)
      //! author : Abdel Said : https://github.com/abdelsaid
  
      var tzm_latn = moment__default.defineLocale('tzm-latn', {
          months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
          monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
          weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
          weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
          weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[asdkh g] LT',
              nextDay: '[aska g] LT',
              nextWeek: 'dddd [g] LT',
              lastDay: '[assant g] LT',
              lastWeek: 'dddd [g] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'dadkh s yan %s',
              past : 'yan %s',
              s : 'imik',
              m : 'minuḍ',
              mm : '%d minuḍ',
              h : 'saɛa',
              hh : '%d tassaɛin',
              d : 'ass',
              dd : '%d ossan',
              M : 'ayowr',
              MM : '%d iyyirn',
              y : 'asgas',
              yy : '%d isgasn'
          },
          week : {
              dow : 6, // Saturday is the first day of the week.
              doy : 12  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : Morocco Central Atlas Tamaziɣt (tzm)
      //! author : Abdel Said : https://github.com/abdelsaid
  
      var tzm = moment__default.defineLocale('tzm', {
          months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
          monthsShort : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
          weekdays : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
          weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
          weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS: 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'dddd D MMMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
              nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
              nextWeek: 'dddd [ⴴ] LT',
              lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
              lastWeek: 'dddd [ⴴ] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
              past : 'ⵢⴰⵏ %s',
              s : 'ⵉⵎⵉⴽ',
              m : 'ⵎⵉⵏⵓⴺ',
              mm : '%d ⵎⵉⵏⵓⴺ',
              h : 'ⵙⴰⵄⴰ',
              hh : '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
              d : 'ⴰⵙⵙ',
              dd : '%d oⵙⵙⴰⵏ',
              M : 'ⴰⵢoⵓⵔ',
              MM : '%d ⵉⵢⵢⵉⵔⵏ',
              y : 'ⴰⵙⴳⴰⵙ',
              yy : '%d ⵉⵙⴳⴰⵙⵏ'
          },
          week : {
              dow : 6, // Saturday is the first day of the week.
              doy : 12  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : ukrainian (uk)
      //! author : zemlanin : https://github.com/zemlanin
      //! Author : Menelion Elensúle : https://github.com/Oire
  
      function uk__plural(word, num) {
          var forms = word.split('_');
          return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
      }
      function uk__relativeTimeWithPlural(number, withoutSuffix, key) {
          var format = {
              'mm': withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
              'hh': withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
              'dd': 'день_дні_днів',
              'MM': 'місяць_місяці_місяців',
              'yy': 'рік_роки_років'
          };
          if (key === 'm') {
              return withoutSuffix ? 'хвилина' : 'хвилину';
          }
          else if (key === 'h') {
              return withoutSuffix ? 'година' : 'годину';
          }
          else {
              return number + ' ' + uk__plural(format[key], +number);
          }
      }
      function weekdaysCaseReplace(m, format) {
          var weekdays = {
              'nominative': 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
              'accusative': 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split('_'),
              'genitive': 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split('_')
          },
          nounCase = (/(\[[ВвУу]\]) ?dddd/).test(format) ?
              'accusative' :
              ((/\[?(?:минулої|наступної)? ?\] ?dddd/).test(format) ?
                  'genitive' :
                  'nominative');
          return weekdays[nounCase][m.day()];
      }
      function processHoursFunction(str) {
          return function () {
              return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
          };
      }
  
      var uk = moment__default.defineLocale('uk', {
          months : {
              'format': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_'),
              'standalone': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_')
          },
          monthsShort : 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
          weekdays : weekdaysCaseReplace,
          weekdaysShort : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
          weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD.MM.YYYY',
              LL : 'D MMMM YYYY р.',
              LLL : 'D MMMM YYYY р., HH:mm',
              LLLL : 'dddd, D MMMM YYYY р., HH:mm'
          },
          calendar : {
              sameDay: processHoursFunction('[Сьогодні '),
              nextDay: processHoursFunction('[Завтра '),
              lastDay: processHoursFunction('[Вчора '),
              nextWeek: processHoursFunction('[У] dddd ['),
              lastWeek: function () {
                  switch (this.day()) {
                  case 0:
                  case 3:
                  case 5:
                  case 6:
                      return processHoursFunction('[Минулої] dddd [').call(this);
                  case 1:
                  case 2:
                  case 4:
                      return processHoursFunction('[Минулого] dddd [').call(this);
                  }
              },
              sameElse: 'L'
          },
          relativeTime : {
              future : 'за %s',
              past : '%s тому',
              s : 'декілька секунд',
              m : uk__relativeTimeWithPlural,
              mm : uk__relativeTimeWithPlural,
              h : 'годину',
              hh : uk__relativeTimeWithPlural,
              d : 'день',
              dd : uk__relativeTimeWithPlural,
              M : 'місяць',
              MM : uk__relativeTimeWithPlural,
              y : 'рік',
              yy : uk__relativeTimeWithPlural
          },
          // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
          meridiemParse: /ночі|ранку|дня|вечора/,
          isPM: function (input) {
              return /^(дня|вечора)$/.test(input);
          },
          meridiem : function (hour, minute, isLower) {
              if (hour < 4) {
                  return 'ночі';
              } else if (hour < 12) {
                  return 'ранку';
              } else if (hour < 17) {
                  return 'дня';
              } else {
                  return 'вечора';
              }
          },
          ordinalParse: /\d{1,2}-(й|го)/,
          ordinal: function (number, period) {
              switch (period) {
              case 'M':
              case 'd':
              case 'DDD':
              case 'w':
              case 'W':
                  return number + '-й';
              case 'D':
                  return number + '-го';
              default:
                  return number;
              }
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 1st is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : uzbek (uz)
      //! author : Sardor Muminov : https://github.com/muminoff
  
      var uz = moment__default.defineLocale('uz', {
          months : 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
          monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
          weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
          weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
          weekdaysMin : 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM YYYY',
              LLL : 'D MMMM YYYY HH:mm',
              LLLL : 'D MMMM YYYY, dddd HH:mm'
          },
          calendar : {
              sameDay : '[Бугун соат] LT [да]',
              nextDay : '[Эртага] LT [да]',
              nextWeek : 'dddd [куни соат] LT [да]',
              lastDay : '[Кеча соат] LT [да]',
              lastWeek : '[Утган] dddd [куни соат] LT [да]',
              sameElse : 'L'
          },
          relativeTime : {
              future : 'Якин %s ичида',
              past : 'Бир неча %s олдин',
              s : 'фурсат',
              m : 'бир дакика',
              mm : '%d дакика',
              h : 'бир соат',
              hh : '%d соат',
              d : 'бир кун',
              dd : '%d кун',
              M : 'бир ой',
              MM : '%d ой',
              y : 'бир йил',
              yy : '%d йил'
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 7  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : vietnamese (vi)
      //! author : Bang Nguyen : https://github.com/bangnk
  
      var vi = moment__default.defineLocale('vi', {
          months : 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split('_'),
          monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
          weekdays : 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
          weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
          weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
          longDateFormat : {
              LT : 'HH:mm',
              LTS : 'HH:mm:ss',
              L : 'DD/MM/YYYY',
              LL : 'D MMMM [năm] YYYY',
              LLL : 'D MMMM [năm] YYYY HH:mm',
              LLLL : 'dddd, D MMMM [năm] YYYY HH:mm',
              l : 'DD/M/YYYY',
              ll : 'D MMM YYYY',
              lll : 'D MMM YYYY HH:mm',
              llll : 'ddd, D MMM YYYY HH:mm'
          },
          calendar : {
              sameDay: '[Hôm nay lúc] LT',
              nextDay: '[Ngày mai lúc] LT',
              nextWeek: 'dddd [tuần tới lúc] LT',
              lastDay: '[Hôm qua lúc] LT',
              lastWeek: 'dddd [tuần rồi lúc] LT',
              sameElse: 'L'
          },
          relativeTime : {
              future : '%s tới',
              past : '%s trước',
              s : 'vài giây',
              m : 'một phút',
              mm : '%d phút',
              h : 'một giờ',
              hh : '%d giờ',
              d : 'một ngày',
              dd : '%d ngày',
              M : 'một tháng',
              MM : '%d tháng',
              y : 'một năm',
              yy : '%d năm'
          },
          ordinalParse: /\d{1,2}/,
          ordinal : function (number) {
              return number;
          },
          week : {
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : chinese (zh-cn)
      //! author : suupic : https://github.com/suupic
      //! author : Zeno Zeng : https://github.com/zenozeng
  
      var zh_cn = moment__default.defineLocale('zh-cn', {
          months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
          monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
          weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
          weekdaysShort : '周日_周一_周二_周三_周四_周五_周六'.split('_'),
          weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
          longDateFormat : {
              LT : 'Ah点mm分',
              LTS : 'Ah点m分s秒',
              L : 'YYYY-MM-DD',
              LL : 'YYYY年MMMD日',
              LLL : 'YYYY年MMMD日Ah点mm分',
              LLLL : 'YYYY年MMMD日ddddAh点mm分',
              l : 'YYYY-MM-DD',
              ll : 'YYYY年MMMD日',
              lll : 'YYYY年MMMD日Ah点mm分',
              llll : 'YYYY年MMMD日ddddAh点mm分'
          },
          meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
          meridiemHour: function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === '凌晨' || meridiem === '早上' ||
                      meridiem === '上午') {
                  return hour;
              } else if (meridiem === '下午' || meridiem === '晚上') {
                  return hour + 12;
              } else {
                  // '中午'
                  return hour >= 11 ? hour : hour + 12;
              }
          },
          meridiem : function (hour, minute, isLower) {
              var hm = hour * 100 + minute;
              if (hm < 600) {
                  return '凌晨';
              } else if (hm < 900) {
                  return '早上';
              } else if (hm < 1130) {
                  return '上午';
              } else if (hm < 1230) {
                  return '中午';
              } else if (hm < 1800) {
                  return '下午';
              } else {
                  return '晚上';
              }
          },
          calendar : {
              sameDay : function () {
                  return this.minutes() === 0 ? '[今天]Ah[点整]' : '[今天]LT';
              },
              nextDay : function () {
                  return this.minutes() === 0 ? '[明天]Ah[点整]' : '[明天]LT';
              },
              lastDay : function () {
                  return this.minutes() === 0 ? '[昨天]Ah[点整]' : '[昨天]LT';
              },
              nextWeek : function () {
                  var startOfWeek, prefix;
                  startOfWeek = moment__default().startOf('week');
                  prefix = this.unix() - startOfWeek.unix() >= 7 * 24 * 3600 ? '[下]' : '[本]';
                  return this.minutes() === 0 ? prefix + 'dddAh点整' : prefix + 'dddAh点mm';
              },
              lastWeek : function () {
                  var startOfWeek, prefix;
                  startOfWeek = moment__default().startOf('week');
                  prefix = this.unix() < startOfWeek.unix()  ? '[上]' : '[本]';
                  return this.minutes() === 0 ? prefix + 'dddAh点整' : prefix + 'dddAh点mm';
              },
              sameElse : 'LL'
          },
          ordinalParse: /\d{1,2}(日|月|周)/,
          ordinal : function (number, period) {
              switch (period) {
              case 'd':
              case 'D':
              case 'DDD':
                  return number + '日';
              case 'M':
                  return number + '月';
              case 'w':
              case 'W':
                  return number + '周';
              default:
                  return number;
              }
          },
          relativeTime : {
              future : '%s内',
              past : '%s前',
              s : '几秒',
              m : '1 分钟',
              mm : '%d 分钟',
              h : '1 小时',
              hh : '%d 小时',
              d : '1 天',
              dd : '%d 天',
              M : '1 个月',
              MM : '%d 个月',
              y : '1 年',
              yy : '%d 年'
          },
          week : {
              // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
              dow : 1, // Monday is the first day of the week.
              doy : 4  // The week that contains Jan 4th is the first week of the year.
          }
      });
  
      //! moment.js locale configuration
      //! locale : traditional chinese (zh-tw)
      //! author : Ben : https://github.com/ben-lin
  
      var zh_tw = moment__default.defineLocale('zh-tw', {
          months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
          monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
          weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
          weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
          weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
          longDateFormat : {
              LT : 'Ah點mm分',
              LTS : 'Ah點m分s秒',
              L : 'YYYY年MMMD日',
              LL : 'YYYY年MMMD日',
              LLL : 'YYYY年MMMD日Ah點mm分',
              LLLL : 'YYYY年MMMD日ddddAh點mm分',
              l : 'YYYY年MMMD日',
              ll : 'YYYY年MMMD日',
              lll : 'YYYY年MMMD日Ah點mm分',
              llll : 'YYYY年MMMD日ddddAh點mm分'
          },
          meridiemParse: /早上|上午|中午|下午|晚上/,
          meridiemHour : function (hour, meridiem) {
              if (hour === 12) {
                  hour = 0;
              }
              if (meridiem === '早上' || meridiem === '上午') {
                  return hour;
              } else if (meridiem === '中午') {
                  return hour >= 11 ? hour : hour + 12;
              } else if (meridiem === '下午' || meridiem === '晚上') {
                  return hour + 12;
              }
          },
          meridiem : function (hour, minute, isLower) {
              var hm = hour * 100 + minute;
              if (hm < 900) {
                  return '早上';
              } else if (hm < 1130) {
                  return '上午';
              } else if (hm < 1230) {
                  return '中午';
              } else if (hm < 1800) {
                  return '下午';
              } else {
                  return '晚上';
              }
          },
          calendar : {
              sameDay : '[今天]LT',
              nextDay : '[明天]LT',
              nextWeek : '[下]ddddLT',
              lastDay : '[昨天]LT',
              lastWeek : '[上]ddddLT',
              sameElse : 'L'
          },
          ordinalParse: /\d{1,2}(日|月|週)/,
          ordinal : function (number, period) {
              switch (period) {
              case 'd' :
              case 'D' :
              case 'DDD' :
                  return number + '日';
              case 'M' :
                  return number + '月';
              case 'w' :
              case 'W' :
                  return number + '週';
              default :
                  return number;
              }
          },
          relativeTime : {
              future : '%s內',
              past : '%s前',
              s : '幾秒',
              m : '一分鐘',
              mm : '%d分鐘',
              h : '一小時',
              hh : '%d小時',
              d : '一天',
              dd : '%d天',
              M : '一個月',
              MM : '%d個月',
              y : '一年',
              yy : '%d年'
          }
      });
  
      var moment_with_locales = moment__default;
      moment_with_locales.locale('en');
  
      return moment_with_locales;
  
  }));
  // moment-hijri.js
  // author: Suhail Alkowaileet
  // modifed by : @balbarak
  // This is a modified version of moment-jalaali by Behrang Noruzi Niya
  // license: MIT
  
  'use strict';
  
  /************************************
      Expose Moment Hijri
  ************************************/
  (function (root, factory) {
  	/* global define */
  	if (typeof define === 'function' && define.amd) {
  		define(['moment'], function (moment) {
  			root.moment = factory(moment)
  			return root.moment
  		})
  	} else if (typeof exports === 'object') {
  		module.exports = factory(require('moment'))
  	} else {
  		root.moment = factory(root.moment)
  	}
  })(this, function (moment) { // jshint ignore:line
  
  	if (moment == null) {
  		throw new Error('Cannot find moment')
  	}
  
  	/************************************
        Constants
    ************************************/
  
  	var ummalqura = {
  		ummalquraData: [28607, 28636, 28665, 28695, 28724, 28754, 28783, 28813, 28843, 28872, 28901, 28931, 28960, 28990, 29019, 29049, 29078, 29108, 29137, 29167,
                        29196, 29226, 29255, 29285, 29315, 29345, 29375, 29404, 29434, 29463, 29492, 29522, 29551, 29580, 29610, 29640, 29669, 29699, 29729, 29759,
                        29788, 29818, 29847, 29876, 29906, 29935, 29964, 29994, 30023, 30053, 30082, 30112, 30141, 30171, 30200, 30230, 30259, 30289, 30318, 30348,
                        30378, 30408, 30437, 30467, 30496, 30526, 30555, 30585, 30614, 30644, 30673, 30703, 30732, 30762, 30791, 30821, 30850, 30880, 30909, 30939,
                        30968, 30998, 31027, 31057, 31086, 31116, 31145, 31175, 31204, 31234, 31263, 31293, 31322, 31352, 31381, 31411, 31441, 31471, 31500, 31530,
                        31559, 31589, 31618, 31648, 31676, 31706, 31736, 31766, 31795, 31825, 31854, 31884, 31913, 31943, 31972, 32002, 32031, 32061, 32090, 32120,
                        32150, 32180, 32209, 32239, 32268, 32298, 32327, 32357, 32386, 32416, 32445, 32475, 32504, 32534, 32563, 32593, 32622, 32652, 32681, 32711,
                        32740, 32770, 32799, 32829, 32858, 32888, 32917, 32947, 32976, 33006, 33035, 33065, 33094, 33124, 33153, 33183, 33213, 33243, 33272, 33302,
                        33331, 33361, 33390, 33420, 33450, 33479, 33509, 33539, 33568, 33598, 33627, 33657, 33686, 33716, 33745, 33775, 33804, 33834, 33863, 33893,
                        33922, 33952, 33981, 34011, 34040, 34069, 34099, 34128, 34158, 34187, 34217, 34247, 34277, 34306, 34336, 34365, 34395, 34424, 34454, 34483,
                        34512, 34542, 34571, 34601, 34631, 34660, 34690, 34719, 34749, 34778, 34808, 34837, 34867, 34896, 34926, 34955, 34985, 35015, 35044, 35074,
                        35103, 35133, 35162, 35192, 35222, 35251, 35280, 35310, 35340, 35370, 35399, 35429, 35458, 35488, 35517, 35547, 35576, 35605, 35635, 35665,
                        35694, 35723, 35753, 35782, 35811, 35841, 35871, 35901, 35930, 35960, 35989, 36019, 36048, 36078, 36107, 36136, 36166, 36195, 36225, 36254,
                        36284, 36314, 36343, 36373, 36403, 36433, 36462, 36492, 36521, 36551, 36580, 36610, 36639, 36669, 36698, 36728, 36757, 36786, 36816, 36845,
                        36875, 36904, 36934, 36963, 36993, 37022, 37052, 37081, 37111, 37141, 37170, 37200, 37229, 37259, 37288, 37318, 37347, 37377, 37406, 37436,
                        37465, 37495, 37524, 37554, 37584, 37613, 37643, 37672, 37701, 37731, 37760, 37790, 37819, 37849, 37878, 37908, 37938, 37967, 37997, 38027,
                        38056, 38085, 38115, 38144, 38174, 38203, 38233, 38262, 38292, 38322, 38351, 38381, 38410, 38440, 38469, 38499, 38528, 38558, 38587, 38617,
                        38646, 38676, 38705, 38735, 38764, 38794, 38823, 38853, 38882, 38912, 38941, 38971, 39001, 39030, 39059, 39089, 39118, 39148, 39178, 39208,
                        39237, 39267, 39297, 39326, 39355, 39385, 39414, 39444, 39473, 39503, 39532, 39562, 39592, 39621, 39650, 39680, 39709, 39739, 39768, 39798,
                        39827, 39857, 39886, 39916, 39946, 39975, 40005, 40035, 40064, 40094, 40123, 40153, 40182, 40212, 40241, 40271, 40300, 40330, 40359, 40389,
                        40418, 40448, 40477, 40507, 40536, 40566, 40595, 40625, 40655, 40685, 40714, 40744, 40773, 40803, 40832, 40862, 40892, 40921, 40951, 40980,
                        41009, 41039, 41068, 41098, 41127, 41157, 41186, 41216, 41245, 41275, 41304, 41334, 41364, 41393, 41422, 41452, 41481, 41511, 41540, 41570,
                        41599, 41629, 41658, 41688, 41718, 41748, 41777, 41807, 41836, 41865, 41894, 41924, 41953, 41983, 42012, 42042, 42072, 42102, 42131, 42161,
                        42190, 42220, 42249, 42279, 42308, 42337, 42367, 42397, 42426, 42456, 42485, 42515, 42545, 42574, 42604, 42633, 42662, 42692, 42721, 42751,
                        42780, 42810, 42839, 42869, 42899, 42929, 42958, 42988, 43017, 43046, 43076, 43105, 43135, 43164, 43194, 43223, 43253, 43283, 43312, 43342,
                        43371, 43401, 43430, 43460, 43489, 43519, 43548, 43578, 43607, 43637, 43666, 43696, 43726, 43755, 43785, 43814, 43844, 43873, 43903, 43932,
                        43962, 43991, 44021, 44050, 44080, 44109, 44139, 44169, 44198, 44228, 44258, 44287, 44317, 44346, 44375, 44405, 44434, 44464, 44493, 44523,
                        44553, 44582, 44612, 44641, 44671, 44700, 44730, 44759, 44788, 44818, 44847, 44877, 44906, 44936, 44966, 44996, 45025, 45055, 45084, 45114,
                        45143, 45172, 45202, 45231, 45261, 45290, 45320, 45350, 45380, 45409, 45439, 45468, 45498, 45527, 45556, 45586, 45615, 45644, 45674, 45704,
                        45733, 45763, 45793, 45823, 45852, 45882, 45911, 45940, 45970, 45999, 46028, 46058, 46088, 46117, 46147, 46177, 46206, 46236, 46265, 46295,
                        46324, 46354, 46383, 46413, 46442, 46472, 46501, 46531, 46560, 46590, 46620, 46649, 46679, 46708, 46738, 46767, 46797, 46826, 46856, 46885,
                        46915, 46944, 46974, 47003, 47033, 47063, 47092, 47122, 47151, 47181, 47210, 47240, 47269, 47298, 47328, 47357, 47387, 47417, 47446, 47476,
                        47506, 47535, 47565, 47594, 47624, 47653, 47682, 47712, 47741, 47771, 47800, 47830, 47860, 47890, 47919, 47949, 47978, 48008, 48037, 48066,
                        48096, 48125, 48155, 48184, 48214, 48244, 48273, 48303, 48333, 48362, 48392, 48421, 48450, 48480, 48509, 48538, 48568, 48598, 48627, 48657,
                        48687, 48717, 48746, 48776, 48805, 48834, 48864, 48893, 48922, 48952, 48982, 49011, 49041, 49071, 49100, 49130, 49160, 49189, 49218, 49248,
                        49277, 49306, 49336, 49365, 49395, 49425, 49455, 49484, 49514, 49543, 49573, 49602, 49632, 49661, 49690, 49720, 49749, 49779, 49809, 49838,
                        49868, 49898, 49927, 49957, 49986, 50016, 50045, 50075, 50104, 50133, 50163, 50192, 50222, 50252, 50281, 50311, 50340, 50370, 50400, 50429,
                        50459, 50488, 50518, 50547, 50576, 50606, 50635, 50665, 50694, 50724, 50754, 50784, 50813, 50843, 50872, 50902, 50931, 50960, 50990, 51019,
                        51049, 51078, 51108, 51138, 51167, 51197, 51227, 51256, 51286, 51315, 51345, 51374, 51403, 51433, 51462, 51492, 51522, 51552, 51582, 51611,
                        51641, 51670, 51699, 51729, 51758, 51787, 51816, 51846, 51876, 51906, 51936, 51965, 51995, 52025, 52054, 52083, 52113, 52142, 52171, 52200,
                        52230, 52260, 52290, 52319, 52349, 52379, 52408, 52438, 52467, 52497, 52526, 52555, 52585, 52614, 52644, 52673, 52703, 52733, 52762, 52792,
                        52822, 52851, 52881, 52910, 52939, 52969, 52998, 53028, 53057, 53087, 53116, 53146, 53176, 53205, 53235, 53264, 53294, 53324, 53353, 53383,
                        53412, 53441, 53471, 53500, 53530, 53559, 53589, 53619, 53648, 53678, 53708, 53737, 53767, 53796, 53825, 53855, 53884, 53913, 53943, 53973,
                        54003, 54032, 54062, 54092, 54121, 54151, 54180, 54209, 54239, 54268, 54297, 54327, 54357, 54387, 54416, 54446, 54476, 54505, 54535, 54564,
                        54593, 54623, 54652, 54681, 54711, 54741, 54770, 54800, 54830, 54859, 54889, 54919, 54948, 54977, 55007, 55036, 55066, 55095, 55125, 55154,
                        55184, 55213, 55243, 55273, 55302, 55332, 55361, 55391, 55420, 55450, 55479, 55508, 55538, 55567, 55597, 55627, 55657, 55686, 55716, 55745,
                        55775, 55804, 55834, 55863, 55892, 55922, 55951, 55981, 56011, 56040, 56070, 56100, 56129, 56159, 56188, 56218, 56247, 56276, 56306, 56335,
                        56365, 56394, 56424, 56454, 56483, 56513, 56543, 56572, 56601, 56631, 56660, 56690, 56719, 56749, 56778, 56808, 56837, 56867, 56897, 56926,
                        56956, 56985, 57015, 57044, 57074, 57103, 57133, 57162, 57192, 57221, 57251, 57280, 57310, 57340, 57369, 57399, 57429, 57458, 57487, 57517,
                        57546, 57576, 57605, 57634, 57664, 57694, 57723, 57753, 57783, 57813, 57842, 57871, 57901, 57930, 57959, 57989, 58018, 58048, 58077, 58107,
                        58137, 58167, 58196, 58226, 58255, 58285, 58314, 58343, 58373, 58402, 58432, 58461, 58491, 58521, 58551, 58580, 58610, 58639, 58669, 58698,
                        58727, 58757, 58786, 58816, 58845, 58875, 58905, 58934, 58964, 58994, 59023, 59053, 59082, 59111, 59141, 59170, 59200, 59229, 59259, 59288,
                        59318, 59348, 59377, 59407, 59436, 59466, 59495, 59525, 59554, 59584, 59613, 59643, 59672, 59702, 59731, 59761, 59791, 59820, 59850, 59879,
                        59909, 59939, 59968, 59997, 60027, 60056, 60086, 60115, 60145, 60174, 60204, 60234, 60264, 60293, 60323, 60352, 60381, 60411, 60440, 60469,
                        60499, 60528, 60558, 60588, 60618, 60648, 60677, 60707, 60736, 60765, 60795, 60824, 60853, 60883, 60912, 60942, 60972, 61002, 61031, 61061,
                        61090, 61120, 61149, 61179, 61208, 61237, 61267, 61296, 61326, 61356, 61385, 61415, 61445, 61474, 61504, 61533, 61563, 61592, 61621, 61651,
                        61680, 61710, 61739, 61769, 61799, 61828, 61858, 61888, 61917, 61947, 61976, 62006, 62035, 62064, 62094, 62123, 62153, 62182, 62212, 62242,
                        62271, 62301, 62331, 62360, 62390, 62419, 62448, 62478, 62507, 62537, 62566, 62596, 62625, 62655, 62685, 62715, 62744, 62774, 62803, 62832,
                        62862, 62891, 62921, 62950, 62980, 63009, 63039, 63069, 63099, 63128, 63157, 63187, 63216, 63246, 63275, 63305, 63334, 63363, 63393, 63423,
                        63453, 63482, 63512, 63541, 63571, 63600, 63630, 63659, 63689, 63718, 63747, 63777, 63807, 63836, 63866, 63895, 63925, 63955, 63984, 64014,
                        64043, 64073, 64102, 64131, 64161, 64190, 64220, 64249, 64279, 64309, 64339, 64368, 64398, 64427, 64457, 64486, 64515, 64545, 64574, 64603,
                        64633, 64663, 64692, 64722, 64752, 64782, 64811, 64841, 64870, 64899, 64929, 64958, 64987, 65017, 65047, 65076, 65106, 65136, 65166, 65195,
                        65225, 65254, 65283, 65313, 65342, 65371, 65401, 65431, 65460, 65490, 65520, 65549, 65579, 65608, 65638, 65667, 65697, 65726, 65755, 65785,
                        65815, 65844, 65874, 65903, 65933, 65963, 65992, 66022, 66051, 66081, 66110, 66140, 66169, 66199, 66228, 66258, 66287, 66317, 66346, 66376,
                        66405, 66435, 66465, 66494, 66524, 66553, 66583, 66612, 66641, 66671, 66700, 66730, 66760, 66789, 66819, 66849, 66878, 66908, 66937, 66967,
                        66996, 67025, 67055, 67084, 67114, 67143, 67173, 67203, 67233, 67262, 67292, 67321, 67351, 67380, 67409, 67439, 67468, 67497, 67527, 67557,
                        67587, 67617, 67646, 67676, 67705, 67735, 67764, 67793, 67823, 67852, 67882, 67911, 67941, 67971, 68000, 68030, 68060, 68089, 68119, 68148,
                        68177, 68207, 68236, 68266, 68295, 68325, 68354, 68384, 68414, 68443, 68473, 68502, 68532, 68561, 68591, 68620, 68650, 68679, 68708, 68738,
                        68768, 68797, 68827, 68857, 68886, 68916, 68946, 68975, 69004, 69034, 69063, 69092, 69122, 69152, 69181, 69211, 69240, 69270, 69300, 69330,
                        69359, 69388, 69418, 69447, 69476, 69506, 69535, 69565, 69595, 69624, 69654, 69684, 69713, 69743, 69772, 69802, 69831, 69861, 69890, 69919,
                        69949, 69978, 70008, 70038, 70067, 70097, 70126, 70156, 70186, 70215, 70245, 70274, 70303, 70333, 70362, 70392, 70421, 70451, 70481, 70510,
                        70540, 70570, 70599, 70629, 70658, 70687, 70717, 70746, 70776, 70805, 70835, 70864, 70894, 70924, 70954, 70983, 71013, 71042, 71071, 71101,
                        71130, 71159, 71189, 71218, 71248, 71278, 71308, 71337, 71367, 71397, 71426, 71455, 71485, 71514, 71543, 71573, 71602, 71632, 71662, 71691,
                        71721, 71751, 71781, 71810, 71839, 71869, 71898, 71927, 71957, 71986, 72016, 72046, 72075, 72105, 72135, 72164, 72194, 72223, 72253, 72282,
                        72311, 72341, 72370, 72400, 72429, 72459, 72489, 72518, 72548, 72577, 72607, 72637, 72666, 72695, 72725, 72754, 72784, 72813, 72843, 72872,
                        72902, 72931, 72961, 72991, 73020, 73050, 73080, 73109, 73139, 73168, 73197, 73227, 73256, 73286, 73315, 73345, 73375, 73404, 73434, 73464,
                        73493, 73523, 73552, 73581, 73611, 73640, 73669, 73699, 73729, 73758, 73788, 73818, 73848, 73877, 73907, 73936, 73965, 73995, 74024, 74053,
                        74083, 74113, 74142, 74172, 74202, 74231, 74261, 74291, 74320, 74349, 74379, 74408, 74437, 74467, 74497, 74526, 74556, 74586, 74615, 74645,
                        74675, 74704, 74733, 74763, 74792, 74822, 74851, 74881, 74910, 74940, 74969, 74999, 75029, 75058, 75088, 75117, 75147, 75176, 75206, 75235,
                        75264, 75294, 75323, 75353, 75383, 75412, 75442, 75472, 75501, 75531, 75560, 75590, 75619, 75648, 75678, 75707, 75737, 75766, 75796, 75826,
                        75856, 75885, 75915, 75944, 75974, 76003, 76032, 76062, 76091, 76121, 76150, 76180, 76210, 76239, 76269, 76299, 76328, 76358, 76387, 76416,
                        76446, 76475, 76505, 76534, 76564, 76593, 76623, 76653, 76682, 76712, 76741, 76771, 76801, 76830, 76859, 76889, 76918, 76948, 76977, 77007,
                        77036, 77066, 77096, 77125, 77155, 77185, 77214, 77243, 77273, 77302, 77332, 77361, 77390, 77420, 77450, 77479, 77509, 77539, 77569, 77598,
                        77627, 77657, 77686, 77715, 77745, 77774, 77804, 77833, 77863, 77893, 77923, 77952, 77982, 78011, 78041, 78070, 78099, 78129, 78158, 78188,
                        78217, 78247, 78277, 78307, 78336, 78366, 78395, 78425, 78454, 78483, 78513, 78542, 78572, 78601, 78631, 78661, 78690, 78720, 78750, 78779,
                        78808, 78838, 78867, 78897, 78926, 78956, 78985, 79015, 79044, 79074, 79104, 79133, 79163, 79192, 79222, 79251, 79281, 79310, 79340, 79369,
                        79399, 79428, 79458, 79487, 79517, 79546, 79576, 79606, 79635, 79665, 79695, 79724, 79753, 79783, 79812, 79841, 79871, 79900, 79930, 79960,
                        79990]
  	}
  
  	var formattingTokens = /(\[[^\[]*\])|(\\)?i(Mo|MM?M?M?|Do|DDDo|DD?D?D?|w[o|w]?|YYYYY|YYYY|YY|gg(ggg?)?)|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|SS?S?|X|zz?|ZZ?|.)/g,
  		localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g
  
  	, parseTokenOneOrTwoDigits = /\d\d?/, parseTokenOneToThreeDigits = /\d{1,3}/, parseTokenThreeDigits = /\d{3}/, parseTokenFourDigits = /\d{1,4}/, parseTokenSixDigits = /[+\-]?\d{1,6}/, parseTokenWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+(\.?)|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i, parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/i, parseTokenT = /T/i, parseTokenTimestampMs = /[\+\-]?\d+(\.\d{1,3})?/
  
  	, unitAliases = {
  		hd: 'idate',
  		hm: 'imonth',
  		hy: 'iyear'
  	}
  
  	, formatFunctions = {}
  
  	, ordinalizeTokens = 'DDD w M D'.split(' '), paddedTokens = 'M D w'.split(' ')
  
  	, formatTokenFunctions = {
  		iM: function () {
  			return this.iMonth() + 1
  		},
  		iMMM: function (format) {
  			return this.localeData().iMonthsShort(this, format)
  		},
  		iMMMM: function (format) {
  			return this.localeData().iMonths(this, format)
  		},
  		iD: function () {
  			return this.iDate()
  		},
  		iDDD: function () {
  			return this.iDayOfYear()
  		},
  		iw: function () {
  			return this.iWeek()
  		},
  		iYY: function () {
  			return leftZeroFill(this.iYear() % 100, 2)
  		},
  		iYYYY: function () {
  			return leftZeroFill(this.iYear(), 4)
  		},
  		iYYYYY: function () {
  			return leftZeroFill(this.iYear(), 5)
  		},
  		igg: function () {
  			return leftZeroFill(this.iWeekYear() % 100, 2)
  		},
  		igggg: function () {
  			return this.iWeekYear()
  		},
  		iggggg: function () {
  			return leftZeroFill(this.iWeekYear(), 5)
  		}
  	}, i
  
  	function padToken(func, count) {
  		return function (a) {
  			return leftZeroFill(func.call(this, a), count)
  		}
  	}
  
  	function ordinalizeToken(func, period) {
  		return function (a) {
  			return this.localeData().ordinal(func.call(this, a), period)
  		}
  	}
  
  	while (ordinalizeTokens.length) {
  		i = ordinalizeTokens.pop()
  		formatTokenFunctions['i' + i + 'o'] = ordinalizeToken(formatTokenFunctions['i' + i], i)
  	}
  	while (paddedTokens.length) {
  		i = paddedTokens.pop()
  		formatTokenFunctions['i' + i + i] = padToken(formatTokenFunctions['i' + i], 2)
  	}
  	formatTokenFunctions.iDDDD = padToken(formatTokenFunctions.iDDD, 3)
  
  	/************************************
        Helpers
    ************************************/
  
  	function extend(a, b) {
  		var key
  		for (key in b)
  			if (b.hasOwnProperty(key))
  				a[key] = b[key]
  		return a
  	}
  
  	function leftZeroFill(number, targetLength) {
  		var output = number + ''
  		while (output.length < targetLength)
  			output = '0' + output
  		return output
  	}
  
  	function isArray(input) {
  		return Object.prototype.toString.call(input) === '[object Array]'
  	}
  
  	function normalizeUnits(units) {
  		return units ? unitAliases[units] || units.toLowerCase().replace(/(.)s$/, '$1') : units
  	}
  
  	function setDate(moment, year, month, date) {
  		var utc = moment._isUTC ? 'UTC' : ''
  		moment._d['set' + utc + 'FullYear'](year)
  		moment._d['set' + utc + 'Month'](month)
  		moment._d['set' + utc + 'Date'](date)
  	}
  
  	function objectCreate(parent) {
  		function F() {}
  		F.prototype = parent
  		return new F()
  	}
  
  	function getPrototypeOf(object) {
  		if (Object.getPrototypeOf)
  			return Object.getPrototypeOf(object)
  		else if (''.__proto__) // jshint ignore:line
  			return object.__proto__ // jshint ignore:line
  		else
  			return object.constructor.prototype
  	}
  
  	/************************************
        Languages
    ************************************/
  	extend(getPrototypeOf(moment.localeData()), {
  		_iMonths: ['Muharram'
                  , 'Safar'
                  , 'Rabi\' al-Awwal'
                  , 'Rabi\' al-Thani'
                  , 'Jumada al-Ula'
                  , 'Jumada al-Alkhirah'
                  , 'Rajab'
                  , 'Sha’ban'
                  , 'Ramadhan'
                  , 'Shawwal'
                  , 'Thul-Qi’dah'
                  , 'Thul-Hijjah'
                  ],
  		iMonths: function (m) {
  			return this._iMonths[m.iMonth()]
  		}
  
  		,
  		_iMonthsShort: ['Muh'
                        , 'Saf'
                        , 'Rab-I'
                        , 'Rab-II'
                        , 'Jum-I'
                        , 'Jum-II'
                        , 'Raj'
                        , 'Sha'
                        , 'Ram'
                        , 'Shw'
                        , 'Dhu-Q'
                        , 'Dhu-H'
                        ],
  		iMonthsShort: function (m) {
  			return this._iMonthsShort[m.iMonth()]
  		}
  
  		,
  		iMonthsParse: function (monthName) {
  			var i, mom, regex
  			if (!this._iMonthsParse)
  				this._iMonthsParse = []
  			for (i = 0; i < 12; i += 1) {
  				// Make the regex if we don't have it already.
  				if (!this._iMonthsParse[i]) {
  					mom = hMoment([2000, (2 + i) % 12, 25])
  					regex = '^' + this.iMonths(mom, '') + '$|^' + this.iMonthsShort(mom, '') + '$'
  					this._iMonthsParse[i] = new RegExp(regex.replace('.', ''), 'i')
  				}
  				// Test the regex.
  				if (this._iMonthsParse[i].test(monthName))
  					return i
  			}
  		}
  	});
  	var iMonthNames = {
  		iMonths: 'محرم_صفر_ربيع الأول_ربيع الثاني_جمادى الأولى_جمادى الآخرة_رجب_شعبان_رمضان_شوال_ذو القعدة_ذو الحجة'.split('_'),
  		iMonthsShort: 'محرم_صفر_ربيع ١_ربيع ٢_جمادى ١_جمادى ٢_رجب_شعبان_رمضان_شوال_ذو القعدة_ذو الحجة'.split('_')
  	};
  
  	// Default to the momentjs 2.12+ API
  	if (typeof moment.updateLocale === 'function') {
  		moment.updateLocale('ar-sa', iMonthNames);
  	} else {
  		var oldLocale = moment.locale();
  		moment.defineLocale('ar-sa', iMonthNames);
  		moment.locale(oldLocale);
  	}
  
  	/************************************
        Formatting
    ************************************/
  
  	function makeFormatFunction(format) {
  		var array = format.match(formattingTokens),
  			length = array.length,
  			i
  
  		for (i = 0; i < length; i += 1)
  			if (formatTokenFunctions[array[i]])
  				array[i] = formatTokenFunctions[array[i]]
  
  		return function (mom) {
  			var output = ''
  			for (i = 0; i < length; i += 1)
  				output += array[i] instanceof Function ? '[' + array[i].call(mom, format) + ']' : array[i]
  			return output
  		}
  	}
  
  	/************************************
        Parsing
    ************************************/
  
  	function getParseRegexForToken(token, config) {
  		switch (token) {
  		case 'iDDDD':
  			return parseTokenThreeDigits
  		case 'iYYYY':
  			return parseTokenFourDigits
  		case 'iYYYYY':
  			return parseTokenSixDigits
  		case 'iDDD':
  			return parseTokenOneToThreeDigits
  		case 'iMMM':
  		case 'iMMMM':
  			return parseTokenWord
  		case 'iMM':
  		case 'iDD':
  		case 'iYY':
  		case 'iM':
  		case 'iD':
  			return parseTokenOneOrTwoDigits
  		case 'DDDD':
  			return parseTokenThreeDigits
  		case 'YYYY':
  			return parseTokenFourDigits
  		case 'YYYYY':
  			return parseTokenSixDigits
  		case 'S':
  		case 'SS':
  		case 'SSS':
  		case 'DDD':
  			return parseTokenOneToThreeDigits
  		case 'MMM':
  		case 'MMMM':
  		case 'dd':
  		case 'ddd':
  		case 'dddd':
  			return parseTokenWord
  		case 'a':
  		case 'A':
  			return moment.localeData(config._l)._meridiemParse
  		case 'X':
  			return parseTokenTimestampMs
  		case 'Z':
  		case 'ZZ':
  			return parseTokenTimezone
  		case 'T':
  			return parseTokenT
  		case 'MM':
  		case 'DD':
  		case 'YY':
  		case 'HH':
  		case 'hh':
  		case 'mm':
  		case 'ss':
  		case 'M':
  		case 'D':
  		case 'd':
  		case 'H':
  		case 'h':
  		case 'm':
  		case 's':
  			return parseTokenOneOrTwoDigits
  		default:
  			return new RegExp(token.replace('\\', ''))
  		}
  	}
  
  	function addTimeToArrayFromToken(token, input, config) {
  		var a, datePartArray = config._a
  
  		switch (token) {
  		case 'iM':
  		case 'iMM':
  			datePartArray[1] = input == null ? 0 : ~~input - 1
  			break
  		case 'iMMM':
  		case 'iMMMM':
  			a = moment.localeData(config._l).iMonthsParse(input)
  			if (a != null)
  				datePartArray[1] = a
  			else
  				config._isValid = false
  			break
  		case 'iD':
  		case 'iDD':
  		case 'iDDD':
  		case 'iDDDD':
  			if (input != null)
  				datePartArray[2] = ~~input
  			break
  		case 'iYY':
  			datePartArray[0] = ~~input + (~~input > 47 ? 1300 : 1400)
  			break
  		case 'iYYYY':
  		case 'iYYYYY':
  			datePartArray[0] = ~~input
  		}
  		if (input == null)
  			config._isValid = false
  	}
  
  	function dateFromArray(config) {
  		var g, h, hy = config._a[0],
  			hm = config._a[1],
  			hd = config._a[2]
  
  		if ((hy == null) && (hm == null) && (hd == null))
  			return [0, 0, 1]
  		hy = hy || 0
  		hm = hm || 0
  		hd = hd || 1
  		if (hd < 1 || hd > hMoment.iDaysInMonth(hy, hm))
  			config._isValid = false
  		g = toGregorian(hy, hm, hd)
  		h = toHijri(g.gy, g.gm, g.gd)
  		config._hDiff = 0
  		if (~~h.hy !== hy)
  			config._hDiff += 1
  		if (~~h.hm !== hm)
  			config._hDiff += 1
  		if (~~h.hd !== hd)
  			config._hDiff += 1
  		return [g.gy, g.gm, g.gd]
  	}
  
  	function makeDateFromStringAndFormat(config) {
  		var tokens = config._f.match(formattingTokens),
  			string = config._i,
  			len = tokens.length,
  			i, token, parsedInput
  
  		config._a = []
  
  		for (i = 0; i < len; i += 1) {
  			token = tokens[i]
  			parsedInput = (getParseRegexForToken(token, config).exec(string) || [])[0];
  			if (parsedInput)
  				string = string.slice(string.indexOf(parsedInput) + parsedInput.length)
  			if (formatTokenFunctions[token])
  				addTimeToArrayFromToken(token, parsedInput, config)
  		}
  		if (string)
  			config._il = string
  
  		return dateFromArray(config)
  	}
  
  	function makeDateFromStringAndArray(config, utc) {
  		var len = config._f.length
  		, i
  		, format
  		, tempMoment
  		, bestMoment
  		, currentScore
  		, scoreToBeat
  
  		if (len === 0) {
  			return makeMoment(new Date(NaN))
  		}
  
  		for (i = 0; i < len; i += 1) {
  			format = config._f[i]
  			currentScore = 0
  			tempMoment = makeMoment(config._i, format, config._l, utc)
  
  			if (!tempMoment.isValid()) continue
  
  			currentScore += tempMoment._hDiff
  			if (tempMoment._il)
  				currentScore += tempMoment._il.length
  			if (scoreToBeat == null || currentScore < scoreToBeat) {
  				scoreToBeat = currentScore
  				bestMoment = tempMoment
  			}
  		}
  
  		return bestMoment
  	}
  
  	function removeParsedTokens(config) {
  		var string = config._i,
  			input = '',
  			format = '',
  			array = config._f.match(formattingTokens),
  			len = array.length,
  			i, match, parsed
  
  		for (i = 0; i < len; i += 1) {
  			match = array[i]
  			parsed = (getParseRegexForToken(match, config).exec(string) || [])[0]
  			if (parsed)
  				string = string.slice(string.indexOf(parsed) + parsed.length)
  			if (!(formatTokenFunctions[match] instanceof Function)) {
  				format += match
  				if (parsed)
  					input += parsed
  			}
  		}
  		config._i = input
  		config._f = format
  	}
  
  	/************************************
        Week of Year
    ************************************/
  
  	function iWeekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
  		var end = firstDayOfWeekOfYear - firstDayOfWeek,
  			daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
  			adjustedMoment
  
  		if (daysToDayOfWeek > end) {
  			daysToDayOfWeek -= 7
  		}
  		if (daysToDayOfWeek < end - 7) {
  			daysToDayOfWeek += 7
  		}
  		adjustedMoment = hMoment(mom).add(daysToDayOfWeek, 'd')
  		return {
  			week: Math.ceil(adjustedMoment.iDayOfYear() / 7),
  			year: adjustedMoment.iYear()
  		}
  	}
  
  	/************************************
        Top Level Functions
    ************************************/
  
  	function makeMoment(input, format, lang, utc) {
  		var config =
  			{ _i: input
  			, _f: format
  			, _l: lang
  			}
  			, date
  			, m
  			, hm
  		if (format) {
  			if (isArray(format)) {
  				return makeDateFromStringAndArray(config, utc)
  			} else {
  				date = makeDateFromStringAndFormat(config)
  				removeParsedTokens(config)
  				format = 'YYYY-MM-DD-' + config._f
  				input = leftZeroFill(date[0], 4) + '-'
  					+ leftZeroFill(date[1] + 1, 2) + '-'
  					+ leftZeroFill(date[2], 2) + '-'
  					+ config._i
  			}
  		}
  		if (utc)
  			m = moment.utc(input, format, lang)
  		else
  			m = moment(input, format, lang)
  		if (config._isValid === false)
  			m._isValid = false
  		m._hDiff = config._hDiff || 0
  		hm = objectCreate(hMoment.fn)
  		extend(hm, m)
  		return hm
  	}
  
  	function hMoment(input, format, lang) {
  		return makeMoment(input, format, lang, false)
  	}
  
  	extend(hMoment, moment)
  	hMoment.fn = objectCreate(moment.fn)
  
  	hMoment.utc = function (input, format, lang) {
  		return makeMoment(input, format, lang, true)
  	}
  
  	/************************************
        hMoment Prototype
    ************************************/
  
  	hMoment.fn.format = function (format) {
  		var i, replace, me = this
  
  		if (format) {
  			i = 5
  			replace = function (input) {
  				return me.localeData().longDateFormat(input) || input
  			}
  			while (i > 0 && localFormattingTokens.test(format)) {
  				i -= 1
  				format = format.replace(localFormattingTokens, replace)
  			}
  			if (!formatFunctions[format]) {
  				formatFunctions[format] = makeFormatFunction(format)
  			}
  			format = formatFunctions[format](this)
  		}
  		return moment.fn.format.call(this, format)
  	}
  
  	hMoment.fn.iYear = function (input) {
  		var lastDay, h, g
  		if (typeof input === 'number') {
  			h = toHijri(this.year(), this.month(), this.date())
  			lastDay = Math.min(h.hd, hMoment.iDaysInMonth(input, h.hm))
  			g = toGregorian(input, h.hm, lastDay)
  			setDate(this, g.gy, g.gm, g.gd)
  			//Workaround: sometimes moment wont set the date correctly if current day is the last in the month
  			if (this.month() !== g.gm || this.date() !== g.gd || this.year() !== g.gy) {
  				setDate(this, g.gy, g.gm, g.gd)
  			}
  			moment.updateOffset(this)
  			return this
  		} else {
  			return toHijri(this.year(), this.month(), this.date()).hy
  		}
  	}
  
  	hMoment.fn.iMonth = function (input) {
  		var lastDay, h, g
  		if (input != null) {
  			if (typeof input === 'string') {
  				input = this.localeData().iMonthsParse(input)
  				if(input >= 0) {
  					input -= 1
  				} else {
  					return this
  				}
  			}
  			h = toHijri(this.year(), this.month(), this.date())
  			lastDay = Math.min(h.hd, hMoment.iDaysInMonth(h.hy, input))
  			this.iYear(h.hy + div(input, 12))
  			input = mod(input, 12)
  			if (input < 0) {
  				input += 12
  				this.iYear(this.iYear() - 1)
  			}
  			g = toGregorian(this.iYear(), input, lastDay)
  			setDate(this, g.gy, g.gm, g.gd)
  			//Workaround: sometimes moment wont set the date correctly if current day is the last in the month
  			if (this.month() !== g.gm || this.date() !== g.gd || this.year() !== g.gy) {
  				setDate(this, g.gy, g.gm, g.gd)
  			}
  			moment.updateOffset(this)
  			return this
  		} else {
  			return toHijri(this.year(), this.month(), this.date()).hm
  		}
  	}
  
  	hMoment.fn.iDate = function (input) {
  		var h, g
  		if (typeof input === 'number') {
  			h = toHijri(this.year(), this.month(), this.date())
  			g = toGregorian(h.hy, h.hm, input)
  			setDate(this, g.gy, g.gm, g.gd)
  			//Workaround: sometimes moment wont set the date correctly if current day is the last in the month
  			if (this.month() !== g.gm || this.date() !== g.gd || this.year() !== g.gy) {
  				setDate(this, g.gy, g.gm, g.gd)
  			}
  			moment.updateOffset(this)
  			return this
  		} else {
  			return toHijri(this.year(), this.month(), this.date()).hd
  		}
  	}
  
  	hMoment.fn.iDayOfYear = function (input) {
  		var dayOfYear = Math.round((hMoment(this).startOf('day') - hMoment(this).startOf('iYear')) / 864e5) + 1
  		return input == null ? dayOfYear : this.add(input - dayOfYear, 'd')
  	}
  
  	hMoment.fn.iDaysInMonth = function () {
  		return parseInt(hMoment(this).endOf('iMonth').format('iDD'));
  	}
  
  	hMoment.fn.iWeek = function (input) {
  		var week = iWeekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).week
  		return input == null ? week : this.add( (input - week) * 7, 'd')
  	}
  
  	hMoment.fn.iWeekYear = function (input) {
  		var year = iWeekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year
  		return input == null ? year : this.add(input - year, 'y')
  	}
  
  	hMoment.fn.add = function (val, units) {
  		var temp
  		if (units !== null && !isNaN(+units)) {
  			temp = val
  			val = units
  			units = temp
  		}
  		units = normalizeUnits(units)
  		if (units === 'iyear') {
  			this.iYear(this.iYear() + val)
  		} else if (units === 'imonth') {
  			this.iMonth(this.iMonth() + val)
  		} else if (units === 'idate') {
  			this.iDate(this.iDate() + val)
  		}
  		 else {
  			moment.fn.add.call(this, val, units)
  		}
  		return this
  	}
  
  	hMoment.fn.subtract = function (val, units) {
  		var temp
  		if (units !== null && !isNaN(+units)) {
  			temp = val
  			val = units
  			units = temp
  		}
  		units = normalizeUnits(units)
  		if (units === 'iyear') {
  			this.iYear(this.iYear() - val)
  		} else if (units === 'imonth') {
  			this.iMonth(this.iMonth() - val)
  		} else if (units === 'idate') {
  			this.iDate(this.iDate() - val)
  		} else {
  			moment.fn.subtract.call(this, val, units)
  		}
  		return this
  	}
  
  	hMoment.fn.startOf = function (units) {
  		units = normalizeUnits(units)
  		if (units === 'iyear' || units === 'imonth') {
  			if (units === 'iyear') {
  				this.iMonth(0)
  			}
  			this.iDate(1)
  			this.hours(0)
  			this.minutes(0)
  			this.seconds(0)
  			this.milliseconds(0)
  			return this
  		} else {
  			return moment.fn.startOf.call(this, units)
  		}
  	}
  
  	hMoment.fn.endOf = function (units) {
  		units = normalizeUnits(units)
  		if (units === undefined || units === 'milisecond') {
  			return this
  		}
  		return this.startOf(units).add(1, (units === 'isoweek' ? 'week' : units)).subtract(1, 'milliseconds')
  	}
  
  	hMoment.fn.clone = function () {
  		return hMoment(this)
  	}
  
  	hMoment.fn.iYears = hMoment.fn.iYear
  	hMoment.fn.iMonths = hMoment.fn.iMonth
  	hMoment.fn.iDates = hMoment.fn.iDate
  	hMoment.fn.iWeeks = hMoment.fn.iWeek
  
  	/************************************
        hMoment Statics
    ************************************/
  
  	hMoment.iDaysInMonth = function (year, month) {
  		var i = getNewMoonMJDNIndex(year, month + 1),
  			daysInMonth = ummalqura.ummalquraData[i] - ummalqura.ummalquraData[i - 1]
  		return daysInMonth
  	}
  
  	function toHijri(gy, gm, gd) {
  		var h = d2h(g2d(gy, gm + 1, gd))
  		h.hm -= 1
  		return h
  	}
  
  	function toGregorian(hy, hm, hd) {
  		var g = d2g(h2d(hy, hm + 1, hd))
  		g.gm -= 1
  		return g
  	}
  
  	hMoment.iConvert = {
  		toHijri: toHijri,
  		toGregorian: toGregorian
  	}
  
  	return hMoment
  
  	/************************************
        Hijri Conversion
    ************************************/
  
  	/*
      Utility helper functions.
    */
  
  	function div(a, b) {
  		return~~ (a / b)
  	}
  
  	function mod(a, b) {
  		return a - ~~(a / b) * b
  	}
  
  	/*
      Converts a date of the Hijri calendar to the Julian Day number.
  
      @param hy Hijri year (1356 to 1500)
      @param hm Hijri month (1 to 12)
      @param hd Hijri day (1 to 29/30)
      @return Julian Day number
    */
  
  	function h2d(hy, hm, hd) {
  		var i = getNewMoonMJDNIndex(hy, hm),
  			mjdn = hd + ummalqura.ummalquraData[i - 1] - 1,
  			jdn = mjdn + 2400000;
  		return jdn
  	}
  
  	/*
      Converts the Julian Day number to a date in the Hijri calendar.
  
      @param jdn Julian Day number
      @return
        hy: Hijri year (1356 to 1500)
        hm: Hijri month (1 to 12)
        hd: Hijri day (1 to 29/30)
    */
  
  	function d2h(jdn) {
  		var mjdn = jdn - 2400000,
  			i = getNewMoonMJDNIndexByJDN(mjdn),
  			totalMonths = i + 16260,
  			cYears = Math.floor((totalMonths - 1) / 12),
  			hy = cYears + 1,
  			hm = totalMonths - 12 * cYears,
  			hd = mjdn - ummalqura.ummalquraData[i - 1] + 1
  
  		return {
  			hy: hy,
  			hm: hm,
  			hd: hd
  		}
  	}
  
  	/*
      Calculates the Julian Day number from Gregorian or Julian
      calendar dates. This integer number corresponds to the noon of
      the date (i.e. 12 hours of Universal Time).
      The procedure was tested to be good since 1 March, -100100 (of both
      calendars) up to a few million years into the future.
  
      @param gy Calendar year (years BC numbered 0, -1, -2, ...)
      @param gm Calendar month (1 to 12)
      @param gd Calendar day of the month (1 to 28/29/30/31)
      @return Julian Day number
    */
  
  	function g2d(gy, gm, gd) {
  		var d = div((gy + div(gm - 8, 6) + 100100) * 1461, 4) + div(153 * mod(gm + 9, 12) + 2, 5) + gd - 34840408
  		d = d - div(div(gy + 100100 + div(gm - 8, 6), 100) * 3, 4) + 752
  		return d
  	}
  
  	/*
      Calculates Gregorian and Julian calendar dates from the Julian Day number
      (hdn) for the period since jdn=-34839655 (i.e. the year -100100 of both
      calendars) to some millions years ahead of the present.
  
      @param jdn Julian Day number
      @return
        gy: Calendar year (years BC numbered 0, -1, -2, ...)
        gm: Calendar month (1 to 12)
        gd: Calendar day of the month M (1 to 28/29/30/31)
    */
  
  	function d2g(jdn) {
  		var j, i, gd, gm, gy
  		j = 4 * jdn + 139361631
  		j = j + div(div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908
  		i = div(mod(j, 1461), 4) * 5 + 308
  		gd = div(mod(i, 153), 5) + 1
  		gm = mod(div(i, 153), 12) + 1
  		gy = div(j, 1461) - 100100 + div(8 - gm, 6)
  		return {
  			gy: gy,
  			gm: gm,
  			gd: gd
  		}
  	}
  
  	/*
      Returns the index of the modified Julian day number of the new moon
      by the given year and month
  
      @param hy: Hijri year (1356 to 1500)
      @param hm: Hijri month (1 to 12)
      @return
          i: the index of the new moon in modified Julian day number.
    */
  	function getNewMoonMJDNIndex(hy, hm) {
  		var cYears = hy - 1,
  			totalMonths = (cYears * 12) + 1 + (hm - 1),
  			i = totalMonths - 16260
  		return i
  	}
  
  	/*
      Returns the nearest new moon
  
      @param jdn Julian Day number
      @return
        i: the index of a modified Julian day number.
    */
  	function getNewMoonMJDNIndexByJDN(mjdn) {
  		for (var i = 0; i < ummalqura.ummalquraData.length; i=i+1) {
  			if (ummalqura.ummalquraData[i] > mjdn)
  				return i
  		}
  	}
  
  });
  /*! version : 4.17.37
   =========================================================
   bootstrap-datetimejs
   
   https://github.com/Eonasdan/bootstrap-datetimepicker
  
   Modified by: @balbarak
   
   Copyright (c) 2015 Jonathan Peterson
   =========================================================
   */
  /*
   The MIT License (MIT)
  
  
   */
  /*global define:false */
  /*global exports:false */
  /*global require:false */
  /*global jQuery:false */
  /*global moment:false */
  (function (factory) {
      'use strict';
      if (typeof define === 'function' && define.amd) {
          // AMD is used - Register as an anonymous module.
          define(['jquery', 'moment'], factory);
      } else if (typeof exports === 'object') {
          factory(require('jquery'), require('moment'));
      } else {
          // Neither AMD nor CommonJS used. Use global variables.
          if (typeof jQuery === 'undefined') {
              throw 'bootstrap-hijri-datepicker requires jQuery to be loaded first';
          }
          if (typeof moment === 'undefined') {
              throw 'bootstrap-hijri-datepicker requires Moment.js to be loaded first';
          }
          factory(jQuery, moment);
      }
  }(function ($, moment) {
      'use strict';
      if (!moment) {
          throw new Error('bootstrap-hijri-datepicker requires Moment.js to be loaded first');
      }
  
      var hijriDatePicker = function (element, options) {
  
          var picker = {},
              date,
              viewDate,
              unset = true,
              input,
              component = false,
              widget = false,
              use24Hours,
              minViewModeNumber = 0,
              actualFormat,
              parseFormats,
              currentViewMode,
              datePickerModes = [
                  {
                      clsName: 'days',
                      navFnc: (options.hijri ? 'iMonth' : 'Month'),
                      navStep: 1
                  },
                  {
                      clsName: 'months',
                      navFnc: (options.hijri ? 'iYear' : 'y'),
                      navStep: 1
                  },
                  {
                      clsName: 'years',
                      navFnc: (options.hijri ? 'iYear' : 'y'),
                      navStep: 10
                  },
                  {
                      clsName: 'decades',
                      navFnc: (options.hijri ? 'iYear' : 'y'),
                      navStep: 100
                  }
              ],
              viewModes = ['days', 'months', 'years', 'decades'],
              verticalModes = ['top', 'bottom', 'auto'],
              horizontalModes = ['left', 'right', 'auto'],
              toolbarPlacements = ['default', 'top', 'bottom'],
              keyMap = {
                  'up': 38,
                  38: 'up',
                  'down': 40,
                  40: 'down',
                  'left': 37,
                  37: 'left',
                  'right': 39,
                  39: 'right',
                  'tab': 9,
                  9: 'tab',
                  'escape': 27,
                  27: 'escape',
                  'enter': 13,
                  13: 'enter',
                  'pageUp': 33,
                  33: 'pageUp',
                  'pageDown': 34,
                  34: 'pageDown',
                  'shift': 16,
                  16: 'shift',
                  'control': 17,
                  17: 'control',
                  'space': 32,
                  32: 'space',
                  't': 84,
                  84: 't',
                  'delete': 46,
                  46: 'delete'
              },
              keyState = {},
  
              getMoment = function (d) {
                  var tzEnabled = false,
                      returnMoment,
                      currentZoneOffset,
                      incomingZoneOffset,
                      timeZoneIndicator,
                      dateWithTimeZoneInfo;
  
                  if (moment.tz !== undefined && options.timeZone !== undefined && options.timeZone !== null && options.timeZone !== '') {
                      tzEnabled = true;
                  }
                  if (d === undefined || d === null) {
                      if (tzEnabled) {
                          returnMoment = moment().tz(options.timeZone).startOf('day');
                      } else {
                          returnMoment = moment().startOf('day');
                      }
                  } else {
                      if (tzEnabled) {
                          currentZoneOffset = moment().tz(options.timeZone).utcOffset();
                          incomingZoneOffset = moment(d, parseFormats, options.useStrict).utcOffset();
                          if (incomingZoneOffset !== currentZoneOffset) {
                              timeZoneIndicator = moment().tz(options.timeZone).format('Z');
                              dateWithTimeZoneInfo = moment(d, parseFormats, options.useStrict).format('YYYY-MM-DD[T]HH:mm:ss') + timeZoneIndicator;
                              returnMoment = moment(dateWithTimeZoneInfo, parseFormats, options.useStrict).tz(options.timeZone);
                          } else {
                              returnMoment = moment(d, parseFormats, options.useStrict).tz(options.timeZone);
                          }
                      } else {
                          returnMoment = moment(d, parseFormats, options.useStrict);
                      }
                  }
                  return returnMoment;
              },
              isEnabled = function (granularity) {
                  if (typeof granularity !== 'string' || granularity.length > 1) {
                      throw new TypeError('isEnabled expects a single character string parameter');
                  }
                  switch (granularity) {
                      case 'y':
                          return actualFormat.indexOf('Y') !== -1;
                      case 'M':
                          return actualFormat.indexOf('M') !== -1;
                      case 'd':
                          return actualFormat.toLowerCase().indexOf('d') !== -1;
                      case 'h':
                      case 'H':
                          return actualFormat.toLowerCase().indexOf('hh:') !== -1;
                      case 'm':
                          return actualFormat.indexOf('m') !== -1;
                      case 's':
                          return actualFormat.indexOf('s') !== -1;
                      default:
                          return false;
                  }
              },
              hasTime = function () {
                  return (isEnabled('h') || isEnabled('m') || isEnabled('s'));
              },
  
              hasDate = function () {
                  return (isEnabled('y') || isEnabled('M') || isEnabled('d'));
              },
  
              getDatePickerTemplate = function () {
                  var headTemplate = $('<thead>')
                      .append($('<tr>')
                          .append($('<th>').addClass('prev').attr('data-action', 'previous')
                              .append($('<span>').html(options.icons.previous))
                          )
                          .append($('<th>').addClass('picker-switch').attr('data-action', 'pickerSwitch').attr('colspan', (options.calendarWeeks ? '6' : '5')))
                          .append($('<th>').addClass('next').attr('data-action', 'next')
                              .append($('<span>').html(options.icons.next))
                          )
                      ),
                      contTemplate = $('<tbody>')
                          .append($('<tr>')
                              .append($('<td>').attr('colspan', (options.calendarWeeks ? '8' : '7')))
                          );
  
                  return [
                      $('<div>').addClass('datepicker-days')
                          .append($('<table>').addClass('table-condensed')
                              .append(headTemplate)
                              .append($('<tbody>'))
                          ),
                      $('<div>').addClass('datepicker-months')
                          .append($('<table>').addClass('table-condensed')
                              .append(headTemplate.clone())
                              .append(contTemplate.clone())
                          ),
                      $('<div>').addClass('datepicker-years')
                          .append($('<table>').addClass('table-condensed')
                              .append(headTemplate.clone())
                              .append(contTemplate.clone())
                          ),
                      $('<div>').addClass('datepicker-decades')
                          .append($('<table>').addClass('table-condensed')
                              .append(headTemplate.clone())
                              .append(contTemplate.clone())
                          )
                  ];
              },
  
              getTimePickerMainTemplate = function () {
                  var topRow = $('<tr>'),
                      middleRow = $('<tr>'),
                      bottomRow = $('<tr>');
  
                  if (isEnabled('h')) {
                      topRow.append($('<td>')
                          .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.incrementHour }).addClass('btn').attr('data-action', 'incrementHours')
                              .append($('<span>').addClass(options.icons.up))));
                      middleRow.append($('<td>')
                          .append($('<span>').addClass('timepicker-hour').attr({ 'data-time-component': 'hours', 'title': options.tooltips.pickHour }).attr('data-action', 'showHours')));
                      bottomRow.append($('<td>')
                          .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.decrementHour }).addClass('btn').attr('data-action', 'decrementHours')
                              .append($('<span>').addClass(options.icons.down))));
                  }
                  if (isEnabled('m')) {
                      if (isEnabled('h')) {
                          topRow.append($('<td>').addClass('separator'));
                          middleRow.append($('<td>').addClass('separator').html(':'));
                          bottomRow.append($('<td>').addClass('separator'));
                      }
                      topRow.append($('<td>')
                          .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.incrementMinute }).addClass('btn').attr('data-action', 'incrementMinutes')
                              .append($('<span>').addClass(options.icons.up))));
                      middleRow.append($('<td>')
                          .append($('<span>').addClass('timepicker-minute').attr({ 'data-time-component': 'minutes', 'title': options.tooltips.pickMinute }).attr('data-action', 'showMinutes')));
                      bottomRow.append($('<td>')
                          .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.decrementMinute }).addClass('btn').attr('data-action', 'decrementMinutes')
                              .append($('<span>').addClass(options.icons.down))));
                  }
                  if (isEnabled('s')) {
                      if (isEnabled('m')) {
                          topRow.append($('<td>').addClass('separator'));
                          middleRow.append($('<td>').addClass('separator').html(':'));
                          bottomRow.append($('<td>').addClass('separator'));
                      }
                      topRow.append($('<td>')
                          .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.incrementSecond }).addClass('btn').attr('data-action', 'incrementSeconds')
                              .append($('<span>').addClass(options.icons.up))));
                      middleRow.append($('<td>')
                          .append($('<span>').addClass('timepicker-second').attr({ 'data-time-component': 'seconds', 'title': options.tooltips.pickSecond }).attr('data-action', 'showSeconds')));
                      bottomRow.append($('<td>')
                          .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.decrementSecond }).addClass('btn').attr('data-action', 'decrementSeconds')
                              .append($('<span>').addClass(options.icons.down))));
                  }
  
                  if (!use24Hours) {
                      topRow.append($('<td>').addClass('separator'));
                      middleRow.append($('<td>')
                          .append($('<button>').addClass('btn btn-primary').attr({ 'data-action': 'togglePeriod', tabindex: '-1', 'title': options.tooltips.togglePeriod })));
                      bottomRow.append($('<td>').addClass('separator'));
                  }
  
                  return $('<div>').addClass('timepicker-picker')
                      .append($('<table>').addClass('table-condensed')
                          .append([topRow, middleRow, bottomRow]));
              },
  
              getTimePickerTemplate = function () {
                  var hoursView = $('<div>').addClass('timepicker-hours')
                      .append($('<table>').addClass('table-condensed')),
                      minutesView = $('<div>').addClass('timepicker-minutes')
                          .append($('<table>').addClass('table-condensed')),
                      secondsView = $('<div>').addClass('timepicker-seconds')
                          .append($('<table>').addClass('table-condensed')),
                      ret = [getTimePickerMainTemplate()];
  
                  if (isEnabled('h')) {
                      ret.push(hoursView);
                  }
                  if (isEnabled('m')) {
                      ret.push(minutesView);
                  }
                  if (isEnabled('s')) {
                      ret.push(secondsView);
                  }
  
                  return ret;
              },
  
              getToolbar = function () {
                  var row = [];
                  if (options.showTodayButton) {
                      row.push($('<td>').append($('<a>').attr({ 'data-action': 'today', 'title': options.tooltips.today }).append($('<span>').html(options.icons.today))));
                  }
                  if (!options.sideBySide && hasDate() && hasTime()) {
                      row.push($('<td>').append($('<a>').attr({ 'data-action': 'togglePicker', 'title': options.tooltips.selectTime }).append($('<span>').addClass(options.icons.time))));
                  }
                  if (options.showClear) {
                      row.push($('<td>').append($('<a>').attr({ 'data-action': 'clear', 'title': options.tooltips.clear }).append($('<span>').html(options.icons.clear))));
                  }
                  if (options.showClose) {
                      row.push($('<td>').append($('<a>').attr({ 'data-action': 'close', 'title': options.tooltips.close }).append($('<span>').html(options.icons.close))));
                  }
  
                  if (options.showSwitcher) {
                      row.push($('<td>').append($('<a>').attr({ 'data-action': 'switchDate', 'title': options.tooltips.close }).append($('<span>').html('هجري/ميلادي'))));
                  }
                  return $('<table>').addClass('table-condensed').append($('<tbody>').append($('<tr>').append(row)));
              },
  
              getTemplate = function () {
                  var template = $('<div>').addClass('bootstrap-datetimepicker-widget dropdown-menu'),
                      dateView = $('<div>').addClass('datepicker').append(getDatePickerTemplate()),
                      timeView = $('<div>').addClass('timepicker').append(getTimePickerTemplate()),
                      content = $('<ul>').addClass('list-unstyled'),
                      toolbar = $('<li>').addClass('picker-switch' + (options.collapse ? ' accordion-toggle' : '')).append(getToolbar());
  
                  if (options.inline) {
                      template.removeClass('dropdown-menu');
                  }
  
                  if (use24Hours) {
                      template.addClass('usetwentyfour');
                  }
                  if (isEnabled('s') && !use24Hours) {
                      template.addClass('wider');
                  }
  
                  if (options.sideBySide && hasDate() && hasTime()) {
                      template.addClass('timepicker-sbs');
                      if (options.toolbarPlacement === 'top') {
                          template.append(toolbar);
                      }
                      template.append(
                          $('<div>').addClass('row')
                              .append(dateView.addClass('col-md-6'))
                              .append(timeView.addClass('col-md-6'))
                      );
                      if (options.toolbarPlacement === 'bottom') {
                          template.append(toolbar);
                      }
                      return template;
                  }
  
                  if (options.toolbarPlacement === 'top') {
                      content.append(toolbar);
                  }
                  if (hasDate()) {
                      content.append($('<li>').addClass((options.collapse && hasTime() ? 'collapse in' : '')).append(dateView));
                  }
                  if (options.toolbarPlacement === 'default') {
                      content.append(toolbar);
                  }
                  if (hasTime()) {
                      content.append($('<li>').addClass((options.collapse && hasDate() ? 'collapse' : '')).append(timeView));
                  }
                  if (options.toolbarPlacement === 'bottom') {
                      content.append(toolbar);
                  }
                  return template.append(content);
              },
  
              dataToOptions = function () {
                  var eData,
                      dataOptions = {};
  
                  if (element.is('input') || options.inline) {
                      eData = element.data();
                  } else {
                      eData = element.find('input').data();
                  }
  
                  if (eData.dateOptions && eData.dateOptions instanceof Object) {
                      dataOptions = $.extend(true, dataOptions, eData.dateOptions);
                  }
  
                  $.each(options, function (key) {
                      var attributeName = 'date' + key.charAt(0).toUpperCase() + key.slice(1);
                      if (eData[attributeName] !== undefined) {
                          dataOptions[key] = eData[attributeName];
                      }
                  });
                  return dataOptions;
              },
  
              place = function () {
                  var position = (component || element).position(),
                      offset = (component || element).offset(),
                      vertical = options.widgetPositioning.vertical,
                      horizontal = options.widgetPositioning.horizontal,
                      parent;
  
                  if (options.widgetParent) {
                      parent = options.widgetParent.append(widget);
                  } else if (element.is('input')) {
                      parent = element.after(widget).parent();
                  } else if (options.inline) {
                      parent = element.append(widget);
                      return;
                  } else {
                      parent = element;
                      element.children().first().after(widget);
                  }
  
                  // Top and bottom logic
                  if (vertical === 'auto') {
                      if (offset.top + widget.height() * 1.5 >= $(window).height() + $(window).scrollTop() &&
                          widget.height() + element.outerHeight() < offset.top) {
                          vertical = 'top';
                      } else {
                          vertical = 'bottom';
                      }
                  }
  
                  // Left and right logic
                  if (horizontal === 'auto') {
                      if (parent.width() < offset.left + widget.outerWidth() / 2 &&
                          offset.left + widget.outerWidth() > $(window).width()) {
                          horizontal = 'right';
                      } else {
                          horizontal = 'left';
                      }
                  }
  
                  if (vertical === 'top') {
                      widget.addClass('top').removeClass('bottom');
                  } else {
                      widget.addClass('bottom').removeClass('top');
                  }
  
                  if (horizontal === 'right') {
                      widget.addClass('pull-right');
                  } else {
                      widget.removeClass('pull-right');
                  }
  
                  // find the first parent element that has a relative css positioning
                  if (parent.css('position') !== 'relative') {
                      parent = parent.parents().filter(function () {
                          return $(this).css('position') === 'relative';
                      }).first();
                  }
  
                  if (parent.length === 0) {
                      throw new Error('datetimepicker component should be placed within a relative positioned container');
                  }
  
                  widget.css({
                      top: vertical === 'top' ? 'auto' : position.top + element.outerHeight(),
                      bottom: vertical === 'top' ? position.top + element.outerHeight() : 'auto',
                      left: horizontal === 'left' ? (parent === element ? 0 : position.left) : 'auto',
                      right: horizontal === 'left' ? 'auto' : parent.outerWidth() - element.outerWidth() - (parent === element ? 0 : position.left)
                  });
              },
  
              notifyEvent = function (e) {
                  
                  if (e.type === 'dp.change' && ((e.date && e.date.isSame(e.oldDate)) || (!e.date && !e.oldDate))) {
                      return;
                  }
                  element.trigger(e);
              },
  
              viewUpdate = function (e) {
  
                  if (e === 'y') {
                      e = 'YYYY';
                  }
                  
                  if (e === 'M') {
                      e = 'YYYY MMMM';
                  }
  
                  notifyEvent({
                      type: 'dp.update',
                      change: e,
                      viewDate: viewDate.clone()
                  });
              },
  
              showMode = function (dir) {
                  if (!widget) {
                      return;
                  }
                  if (dir) {
                      currentViewMode = Math.max(minViewModeNumber, Math.min(2, currentViewMode + dir));
                  }
                  widget.find('.datepicker > div').hide().filter('.datepicker-' + datePickerModes[currentViewMode].clsName).show();
              },
  
              fillDow = function () {
                  var row = $('<tr>'),
                      currentDate = viewDate.clone().startOf('w').startOf('day');
  
                  if (options.calendarWeeks === true) {
                      row.append($('<th>').addClass('cw').text('#'));
                  }
  
                  while (currentDate.isBefore(viewDate.clone().endOf('w'))) {
                      row.append($('<th>').addClass('dow').text(currentDate.format('dd')));
                      currentDate.add(1, 'days');
                  }
                  widget.find('.datepicker-days thead').append(row);
              },
  
              isInDisabledDates = function (testDate) {
                  return options.disabledDates[testDate.format('YYYY-MM-DD')] === true;
              },
  
              isInEnabledDates = function (testDate) {
                  return options.enabledDates[testDate.format('YYYY-MM-DD')] === true;
              },
  
              isInDisabledHours = function (testDate) {
                  return options.disabledHours[testDate.format('H')] === true;
              },
  
              isInEnabledHours = function (testDate) {
                  return options.enabledHours[testDate.format('H')] === true;
              },
  
              isValid = function (targetMoment, granularity) {
  
                  
                  if (!targetMoment.isValid()) {
                      return false;
                  }
                  if (options.disabledDates && granularity === 'd' && isInDisabledDates(targetMoment)) {
                      return false;
                  }
                  if (options.enabledDates && granularity === 'd' && !isInEnabledDates(targetMoment)) {
                      return false;
                  }
                  if (options.minDate && targetMoment.isBefore(options.minDate, granularity)) {
                      return false;
                  }
                  if (options.maxDate && targetMoment.isAfter(options.maxDate, granularity)) {
                      return false;
                  }
                  if (options.daysOfWeekDisabled && granularity === 'd' && options.daysOfWeekDisabled.indexOf(targetMoment.day()) !== -1) {
                      return false;
                  }
                  if (options.disabledHours && (granularity === 'h' || granularity === 'm' || granularity === 's') && isInDisabledHours(targetMoment)) {
                      return false;
                  }
                  if (options.enabledHours && (granularity === 'h' || granularity === 'm' || granularity === 's') && !isInEnabledHours(targetMoment)) {
                      return false;
                  }
                  if (options.disabledTimeIntervals && (granularity === 'h' || granularity === 'm' || granularity === 's')) {
                      var found = false;
                      $.each(options.disabledTimeIntervals, function () {
                          if (targetMoment.isBetween(this[0], this[1])) {
                              found = true;
                              return false;
                          }
                      });
                      if (found) {
                          return false;
                      }
                  }
                  return true;
              },
  
              fillMonths = function () {
  
                  var spans = [],
                      monthsShort = viewDate.clone().startOf('y').startOf('day');
  
                  while (monthsShort.isSame(viewDate, 'years')) {
  
                      spans.push($('<span>').attr('data-action', 'selectMonth').addClass('month').text(monthsShort.format('MMM')));
  
                      monthsShort.add(1, 'months');
  
                  }
  
                  widget.find('.datepicker-months td').empty().append(spans);
              },
  
              fillHijriMonths = function () {
                  var spans = [],
                      monthsShort = viewDate.clone().startOf('hy').hour(12); // hour is changed to avoid DST issues in some browsers
  
                  while (monthsShort.iYear() === viewDate.iYear()) {
                      spans.push($('<span>').attr('data-action', 'selectMonth').addClass('month').text(monthsShort.format('iMMM')));
                      monthsShort.add(1, 'iMonth');
                  }
  
                  widget.find('.datepicker-months td').empty().append(spans);
              },
  
              updateHijriMonths = function () {
                  var monthsView = widget.find('.datepicker-months'),
                      monthsViewHeader = monthsView.find('th'),
                      months = monthsView.find('tbody').find('span');
  
                  monthsViewHeader.eq(0).find('span').attr('title', options.tooltips.prevYear);
                  monthsViewHeader.eq(1).attr('title', options.tooltips.selectYear);
                  monthsViewHeader.eq(2).find('span').attr('title', options.tooltips.nextYear);
  
                  monthsView.find('.disabled').removeClass('disabled');
  
                  if (!isValid(viewDate.clone().subtract(1, 'years'), 'y')) {
                      monthsViewHeader.eq(0).addClass('disabled');
                  }
  
                  monthsViewHeader.eq(1).text(viewDate.iYear());
  
                  if (!isValid(viewDate.clone().add(1, 'y'), 'y')) {
                      monthsViewHeader.eq(2).addClass('disabled');
                  }
  
                  months.removeClass('active');
                  if (date.isSame(viewDate, 'y')) {
                      months.eq(date.month()).addClass('active');
                  }
  
                  months.each(function (index) {
                      if (!isValid(viewDate.clone().month(index), 'M')) {
                          $(this).addClass('disabled');
                      }
                  });
              },
  
              updateMonths = function () {
                  var monthsView = widget.find('.datepicker-months'),
                      monthsViewHeader = monthsView.find('th'),
                      months = monthsView.find('tbody').find('span');
  
                  monthsViewHeader.eq(0).find('span').attr('title', options.tooltips.prevYear);
                  monthsViewHeader.eq(1).attr('title', options.tooltips.selectYear);
                  monthsViewHeader.eq(2).find('span').attr('title', options.tooltips.nextYear);
  
                  monthsView.find('.disabled').removeClass('disabled');
  
                  if (!isValid(viewDate.clone().subtract(1, 'years'), 'y')) {
                      monthsViewHeader.eq(0).addClass('disabled');
                  }
  
                  monthsViewHeader.eq(1).text(viewDate.year());
  
                  if (!isValid(viewDate.clone().add(1, 'y'), 'y')) {
                      monthsViewHeader.eq(2).addClass('disabled');
                  }
  
                  months.removeClass('active');
                  if (date.isSame(viewDate, 'y') && !unset) {
                      months.eq(date.month()).addClass('active');
                  }
  
                  months.each(function (index) {
                      if (!isValid(viewDate.clone().month(index), 'M')) {
                          $(this).addClass('disabled');
                      }
                  });
              },
  
              updateHijriYears = function () {
                  var yearsView = widget.find('.datepicker-years'),
                      yearsViewHeader = yearsView.find('th'),
                      startYear = viewDate.clone().subtract(5, 'hy'),
                      endYear = viewDate.clone().add(6, 'hy'),
                      html = '';
  
                  yearsViewHeader.eq(0).find('span').attr('title', options.tooltips.prevDecade);
                  yearsViewHeader.eq(1).attr('title', options.tooltips.selectDecade);
                  yearsViewHeader.eq(2).find('span').attr('title', options.tooltips.nextDecade);
  
                  yearsView.find('.disabled').removeClass('disabled');
  
                  if (options.minDate && options.minDate.isAfter(startYear, 'hy')) {
                      
                      yearsViewHeader.eq(0).addClass('disabled');
                  }
  
                  yearsViewHeader.eq(1).text(startYear.iYear() + '-' + endYear.iYear());
  
                  if (options.maxDate && options.maxDate.isBefore(endYear, 'hy')) {
                      yearsViewHeader.eq(2).addClass('disabled');
                  }
  
  
                  while (!startYear.isAfter(endYear, 'hy')) {
  
                      //here we need to fix the infinte loop
  
                      var endYearStr = endYear.format("iYYYY");
                      var startYearStr = startYear.format("iYYYY");
  
                      if (endYearStr === "1500" || startYearStr === "1355") {
  
                          startYear = viewDate.clone().subtract(5, 'hy');
                          html += '<span data-action="selectYear" class="year' + (startYear.iYear() === date.iYear() ? ' active' : '') + (!isValid(startYear, 'hy') ? ' disabled' : '') + '">' + startYear.iYear() + '</span>';
                          break;
                      }
  
                      html += '<span data-action="selectYear" class="year' + (startYear.iYear() === date.iYear() ? ' active' : '') + (!isValid(startYear, 'hy') ? ' disabled' : '') + '">' + startYear.iYear() + '</span>';
  
                      startYear.add(1, 'iYear');
                  }
  
  
                  yearsView.find('td').html(html);
              },
  
              updateYears = function () {
  
                  var yearsView = widget.find('.datepicker-years'),
                      yearsViewHeader = yearsView.find('th'),
                      startYear = viewDate.clone().subtract(5, 'y'),
                      endYear = viewDate.clone().add(6, 'y'),
                      html = '';
  
                  yearsViewHeader.eq(0).find('span').attr('title', options.tooltips.prevDecade);
                  yearsViewHeader.eq(1).attr('title', options.tooltips.selectDecade);
                  yearsViewHeader.eq(2).find('span').attr('title', options.tooltips.nextDecade);
  
                  yearsView.find('.disabled').removeClass('disabled');
  
                  if (options.minDate && options.minDate.isAfter(startYear, 'y')) {
                      yearsViewHeader.eq(0).addClass('disabled');
                  }
  
                  yearsViewHeader.eq(1).text(startYear.year() + '-' + endYear.year());
  
                  if (options.maxDate && options.maxDate.isBefore(endYear, 'y')) {
                      yearsViewHeader.eq(2).addClass('disabled');
                  }
  
                  while (!startYear.isAfter(endYear, 'y')) {
                      html += '<span data-action="selectYear" class="year' + (startYear.isSame(date, 'y') && !unset ? ' active' : '') + (!isValid(startYear, 'y') ? ' disabled' : '') + '">' + startYear.year() + '</span>';
                      startYear.add(1, 'y');
                  }
  
                  yearsView.find('td').html(html);
              },
  
              updateDecades = function () {
                  var decadesView = widget.find('.datepicker-decades'),
                      decadesViewHeader = decadesView.find('th'),
                      startDecade = moment({ y: viewDate.year() - (viewDate.year() % 100) - 1 }),
                      endDecade = startDecade.clone().add(100, 'y'),
                      startedAt = startDecade.clone(),
                      html = '';
  
                  decadesViewHeader.eq(0).find('span').attr('title', options.tooltips.prevCentury);
                  decadesViewHeader.eq(2).find('span').attr('title', options.tooltips.nextCentury);
  
                  decadesView.find('.disabled').removeClass('disabled');
  
                  if (startDecade.isSame(moment({ y: 1900 })) || (options.minDate && options.minDate.isAfter(startDecade, 'y'))) {
                      decadesViewHeader.eq(0).addClass('disabled');
                  }
  
                  decadesViewHeader.eq(1).text(startDecade.year() + '-' + endDecade.year());
  
                  if (startDecade.isSame(moment({ y: 2000 })) || (options.maxDate && options.maxDate.isBefore(endDecade, 'y'))) {
                      decadesViewHeader.eq(2).addClass('disabled');
                  }
  
                  while (!startDecade.isAfter(endDecade, 'y')) {
                      html += '<span data-action="selectDecade" class="decade' + (startDecade.isSame(date, 'y') ? ' active' : '') +
                          (!isValid(startDecade, 'y') ? ' disabled' : '') + '" data-selection="' + (startDecade.year() + 6) + '">' + (startDecade.year() + 1) + ' - ' + (startDecade.year() + 12) + '</span>';
                      startDecade.add(12, 'y');
                  }
                  html += '<span></span><span></span><span></span>'; //push the dangling block over, at least this way it's even
  
                  decadesView.find('td').html(html);
                  decadesViewHeader.eq(1).text((startedAt.year() + 1) + '-' + (startDecade.year()));
              },
  
              fillDate = function () {
  
                  if (options.hijri) {
                      fillHijriDate();
                      return;
                  }
  
                  
                  var daysView = widget.find('.datepicker-days'),
                      daysViewHeader = daysView.find('th'),
                      currentDate,
                      html = [],
                      row,
                      clsName,
                      i;
  
                  if (!hasDate()) {
                      return;
                  }
  
                  daysViewHeader.eq(0).find('span').attr('title', options.tooltips.prevMonth);
                  daysViewHeader.eq(1).attr('title', options.tooltips.selectMonth);
                  daysViewHeader.eq(2).find('span').attr('title', options.tooltips.nextMonth);
  
                  daysView.find('.disabled').removeClass('disabled');
                  daysViewHeader.eq(1).text(viewDate.format(options.dayViewHeaderFormat));
  
                  if (!isValid(viewDate.clone().subtract(1, 'months'), 'months')) {
                      daysViewHeader.eq(0).addClass('disabled');
                  }
                  if (!isValid(viewDate.clone().add(1, 'months'), 'months')) {
                      daysViewHeader.eq(2).addClass('disabled');
                  }
  
                  currentDate = viewDate.clone().startOf('months').startOf('weeks').startOf('days');
  
                  for (i = 0; i < 42; i++) { //always display 42 days (should show 6 weeks)
                      if (currentDate.weekday() === 0) {
                          row = $('<tr>');
                          if (options.calendarWeeks) {
                              row.append('<td class="cw">' + currentDate.week() + '</td>');
                          }
                          html.push(row);
                      }
                      clsName = '';
                      if (currentDate.isBefore(viewDate, 'months')) {
                          clsName += ' old';
                      }
                      if (currentDate.isAfter(viewDate, 'months')) {
                          clsName += ' new';
                      }
                      if (currentDate.isSame(date, 'days') && !unset) {
                          clsName += ' active';
                      }
                      if (!isValid(currentDate, 'days')) {
                          clsName += ' disabled';
                      }
                      if (currentDate.isSame(getMoment(), 'days')) {
                          clsName += ' today';
                      }
                      if (currentDate.day() === 6 || currentDate.day() === 5) {
                          clsName += ' weekend';
                      }
                      row.append('<td data-action="selectDay" data-day="' + currentDate.format('L') + '" class="day' + clsName + '">' + currentDate.date() + '</td>');
                      currentDate.add(1, 'days');
                  }
  
                  daysView.find('tbody').empty().append(html);
  
                  updateMonths();
  
                  updateYears();
  
                  //updateDecades();
  
              },
  
              fillHijriDate = function () {
                  var daysView = widget.find('.datepicker-days'),
                      daysViewHeader = daysView.find('th'),
                      currentDate,
                      html = [],
                      row,
                      clsName,
                      i;
  
                  if (!hasDate()) {
                      return;
                  }
  
                  daysViewHeader.eq(0).find('span').attr('title', options.tooltips.prevMonth);
                  daysViewHeader.eq(1).attr('title', options.tooltips.selectMonth);
                  daysViewHeader.eq(2).find('span').attr('title', options.tooltips.nextMonth);
  
                  daysView.find('.disabled').removeClass('disabled');
                  daysViewHeader.eq(1).text(viewDate.format(options.hijriDayViewHeaderFormat));
  
                  if (!isValid(viewDate.clone().subtract(1, 'iMonth'), 'iMonth')) {
                      daysViewHeader.eq(0).addClass('disabled');
                  }
                  if (!isValid(viewDate.clone().add(1, 'iMonth'), 'iMonth')) {
                      daysViewHeader.eq(2).addClass('disabled');
                  }
  
                  currentDate = viewDate.clone().startOf('iMonth').startOf('week');
                  for (i = 0; i < 42; i++) { // always display 42 days (should be show 6 weeks)
  
                      if (currentDate.weekday() === 0) {
                          row = $('<tr>');
                          if (options.calendarWeeks) {
                              row.append('<td class="cw">' + currentDate.week() + '</td>');
                          }
                          html.push(row);
                      }
                      clsName = '';
                      if (currentDate.iMonth() < viewDate.iMonth()) {
                          clsName += ' old';
                      }
                      if (currentDate.iMonth() > viewDate.iMonth()) {
                          clsName += ' new';
                      }
                      if (currentDate.isSame(date, 'd') && !unset) {
                          clsName += ' active';
                      }
                      if (!isValid(currentDate, 'd')) {
                          clsName += ' disabled';
                      }
                      if (currentDate.isSame(moment(), 'd')) {
                          clsName += ' today';
                      }
                      if (currentDate.day() === 5 || currentDate.day() === 6) {
                          clsName += ' weekend';
                      }
                      row.append('<td data-action="selectDay" data-mday="' + currentDate.date() + '" data-day="' + currentDate.format('L') + '" class="day' + clsName + '">' + currentDate.iDate() + '</td>');
                      //row.append('<td data-action="selectDay" data-day="' + currentDate.date() + '" class="day' + clsName + '">' + currentDate.hDate() + '</td>');
                      currentDate.add(1, 'days');
                  }
  
                  daysView.find('tbody').empty().append(html);
  
                  updateHijriMonths();
  
                  updateHijriYears();
                  //updateHijriDecades();
  
              },
  
              fillHours = function () {
                  var table = widget.find('.timepicker-hours table'),
                      currentHour = viewDate.clone().startOf('day'),
                      html = [],
                      row = $('<tr>');
  
                  if (viewDate.hour() > 11 && !use24Hours) {
                      currentHour.hour(12);
                  }
                  while (currentHour.isSame(viewDate, 'd') && (use24Hours || (viewDate.hour() < 12 && currentHour.hour() < 12) || viewDate.hour() > 11)) {
                      if (currentHour.hour() % 4 === 0) {
                          row = $('<tr>');
                          html.push(row);
                      }
                      row.append('<td data-action="selectHour" class="hour' + (!isValid(currentHour, 'h') ? ' disabled' : '') + '">' + currentHour.format(use24Hours ? 'HH' : 'hh') + '</td>');
                      currentHour.add(1, 'h');
                  }
                  table.empty().append(html);
              },
  
              fillMinutes = function () {
                  var table = widget.find('.timepicker-minutes table'),
                      currentMinute = viewDate.clone().startOf('h'),
                      html = [],
                      row = $('<tr>'),
                      step = options.stepping === 1 ? 5 : options.stepping;
  
                  while (viewDate.isSame(currentMinute, 'h')) {
                      if (currentMinute.minute() % (step * 4) === 0) {
                          row = $('<tr>');
                          html.push(row);
                      }
                      row.append('<td data-action="selectMinute" class="minute' + (!isValid(currentMinute, 'm') ? ' disabled' : '') + '">' + currentMinute.format('mm') + '</td>');
                      currentMinute.add(step, 'm');
                  }
                  table.empty().append(html);
              },
  
              fillSeconds = function () {
                  var table = widget.find('.timepicker-seconds table'),
                      currentSecond = viewDate.clone().startOf('m'),
                      html = [],
                      row = $('<tr>');
  
                  while (viewDate.isSame(currentSecond, 'm')) {
                      if (currentSecond.second() % 20 === 0) {
                          row = $('<tr>');
                          html.push(row);
                      }
                      row.append('<td data-action="selectSecond" class="second' + (!isValid(currentSecond, 's') ? ' disabled' : '') + '">' + currentSecond.format('ss') + '</td>');
                      currentSecond.add(5, 's');
                  }
  
                  table.empty().append(html);
              },
  
              fillTime = function () {
                  var toggle, newDate, timeComponents = widget.find('.timepicker span[data-time-component]');
  
                  if (!use24Hours) {
                      toggle = widget.find('.timepicker [data-action=togglePeriod]');
                      newDate = date.clone().add((date.hours() >= 12) ? -12 : 12, 'h');
  
                      toggle.text(date.format('A'));
  
                      if (isValid(newDate, 'h')) {
                          toggle.removeClass('disabled');
                      } else {
                          toggle.addClass('disabled');
                      }
                  }
                  timeComponents.filter('[data-time-component=hours]').text(date.format(use24Hours ? 'HH' : 'hh'));
                  timeComponents.filter('[data-time-component=minutes]').text(date.format('mm'));
                  timeComponents.filter('[data-time-component=seconds]').text(date.format('ss'));
  
                  fillHours();
                  fillMinutes();
                  fillSeconds();
              },
  
              update = function () {
  
                  if (!widget) {
                      return;
                  }
  
                  fillDate();
                  fillTime();
              },
  
              setValue = function (targetMoment) {
                  var oldDate = unset ? null : date;
  
                  // case of calling setValue(null or false)
                  if (!targetMoment) {
                      unset = true;
                      input.val('');
                      element.data('date', '');
                      notifyEvent({
                          type: 'dp.change',
                          date: false,
                          oldDate: oldDate
                      });
                      update();
                      return;
                  }
  
                  targetMoment = targetMoment.clone().locale(options.locale);
  
                  if (options.stepping !== 1) {
                      targetMoment.minutes((Math.round(targetMoment.minutes() / options.stepping) * options.stepping) % 60).seconds(0);
                  }
  
                  if (isValid(targetMoment)) {
                      
                      date = targetMoment;
                      viewDate = date.clone();
                      input.val(date.format(actualFormat));
                      element.data('date', date.format(actualFormat));
                      unset = false;
                      update();
                      notifyEvent({
                          type: 'dp.change',
                          date: date.clone(),
                          oldDate: oldDate
                      });
                  } else {
                      if (!options.keepInvalid) {
                          input.val(unset ? '' : date.format(actualFormat));
                      }
                      notifyEvent({
                          type: 'dp.error',
                          date: targetMoment
                      });
                  }
              },
  
              hide = function () {
                  ///<summary>Hides the widget. Possibly will emit dp.hide</summary>
                  var transitioning = false;
                  if (!widget) {
                      return picker;
                  }
                  // Ignore event if in the middle of a picker transition
                  widget.find('.collapse').each(function () {
                      var collapseData = $(this).data('collapse');
                      if (collapseData && collapseData.transitioning) {
                          transitioning = true;
                          return false;
                      }
                      return true;
                  });
                  if (transitioning) {
                      return picker;
                  }
                  if (component && component.hasClass('btn')) {
                      component.toggleClass('active');
                  }
                  widget.hide();
  
                  $(window).off('resize', place);
                  widget.off('click', '[data-action]');
                  widget.off('mousedown', false);
  
                  widget.remove();
                  widget = false;
  
                  notifyEvent({
                      type: 'dp.hide',
                      date: date.clone()
                  });
  
                  input.blur();
  
                  return picker;
              },
  
              clear = function () {
                  setValue(null);
              },
  
              /********************************************************************************
               *
               * Widget UI interaction functions
               *
               ********************************************************************************/
              actions = {
                  next: function () {
  
                      var navFnc = datePickerModes[currentViewMode].navFnc;
  
                      viewDate.add(datePickerModes[currentViewMode].navStep, navFnc);
  
                      if (options.hijri) {
                          fillHijriDate();
                      } else {
                          fillDate();
                      }
                      viewUpdate(navFnc);
                  },
  
                  previous: function () {
                      var navFnc = datePickerModes[currentViewMode].navFnc;
                      viewDate.subtract(datePickerModes[currentViewMode].navStep, navFnc);
                      if (options.hijri) {
                          fillHijriDate();
                      } else {
                          fillDate();
                      }
                      viewUpdate(navFnc);
                  },
  
                  pickerSwitch: function () {
                      showMode(1);
                  },
  
                  selectMonth: function (e) {
                      var month = $(e.target).closest('tbody').find('span').index($(e.target));
                      if (options.hijri) {
                          viewDate.iMonth(month);
                      } else {
                          viewDate.month(month);
                      }
                      if (currentViewMode === minViewModeNumber) {
                          if (options.hijri) {
                              setValue(date.clone().year(viewDate.iYear()).month(viewDate.iMonth()));
                          } else {
                              setValue(date.clone().year(viewDate.year()).month(viewDate.month()));
                          }
                          if (!options.inline) {
                              hide();
                          }
                      } else {
                          showMode(-1);
                          fillDate();
                      }
                      if (options.hijri) {
                          viewUpdate('iM');
                      } else {
                          viewUpdate('M');
                      }
                  },
  
                  selectYear: function (e) {
                      var year = parseInt($(e.target).text(), 10) || 0;
                      if (options.hijri) {
                          viewDate.iYear(year);
                      } else {
                          viewDate.year(year);
                      }
                      if (currentViewMode === minViewModeNumber) {
                          if (options.hijri) {
                              setValue(date.clone().iYear(viewDate.iYear()));
                          } else {
                              setValue(date.clone().year(viewDate.year()));
                          }
                          if (!options.inline) {
                              hide();
                          }
                      } else {
                          showMode(-1);
                          fillDate();
                      }
                      if (options.hijri) {
                          viewUpdate('hYYYY');
                      } else {
                          viewUpdate('YYYY');
                      }
                  },
  
                  selectDecade: function (e) {
                      var year = parseInt($(e.target).data('selection'), 10) || 0;
                      if (options.hijri) {
                          viewDate.iYear(year);
                      } else {
                          viewDate.year(year);
                      }
                      if (currentViewMode === minViewModeNumber) {
                          if (options.hijri) {
                              setValue(date.clone().iYear(viewDate.iYear()));
                          } else {
                              setValue(date.clone().year(viewDate.year()));
                          }
                          if (!options.inline) {
                              hide();
                          }
                      } else {
                          showMode(-1);
                          fillDate();
                      }
                      if (options.hijri) {
                          viewUpdate('hYYYY');
                      } else {
                          viewUpdate('YYYY');
                      }
                  },
  
                  selectDay: function (e) {
                      var day = viewDate.clone();
  
                      if (options.hijri) {
                          if ($(e.target).is('.old')) {
                              day.subtract(1, 'iMonth');
                          }
                          if ($(e.target).is('.new')) {
                              day.add(1, 'iMonth');
                          }
                          setValue(day.iDate(parseInt($(e.target).text(), 10)));
                      } else {
                          if ($(e.target).is('.old')) {
                              day.subtract(1, 'months');
                          }
                          if ($(e.target).is('.new')) {
                              day.add(1, 'months');
                          }
                          setValue(day.date(parseInt($(e.target).text(), 10)));
                      }
                      if (!hasTime() && !options.keepOpen && !options.inline) {
                          hide();
                      }
                  },
  
                  incrementHours: function () {
                      var newDate = date.clone().add(1, 'h');
                      if (isValid(newDate, 'h')) {
                          setValue(newDate);
                      }
                  },
  
                  incrementMinutes: function () {
                      var newDate = date.clone().add(options.stepping, 'm');
                      if (isValid(newDate, 'm')) {
                          setValue(newDate);
                      }
                  },
  
                  incrementSeconds: function () {
                      var newDate = date.clone().add(1, 's');
                      if (isValid(newDate, 's')) {
                          setValue(newDate);
                      }
                  },
  
                  decrementHours: function () {
                      var newDate = date.clone().subtract(1, 'h');
                      if (isValid(newDate, 'h')) {
                          setValue(newDate);
                      }
                  },
  
                  decrementMinutes: function () {
                      var newDate = date.clone().subtract(options.stepping, 'm');
                      if (isValid(newDate, 'm')) {
                          setValue(newDate);
                      }
                  },
  
                  decrementSeconds: function () {
                      var newDate = date.clone().subtract(1, 's');
                      if (isValid(newDate, 's')) {
                          setValue(newDate);
                      }
                  },
  
                  togglePeriod: function () {
                      setValue(date.clone().add((date.hours() >= 12) ? -12 : 12, 'h'));
                  },
  
                  togglePicker: function (e) {
                      var $this = $(e.target),
                          $parent = $this.closest('ul'),
                          expanded = $parent.find('.in'),
                          closed = $parent.find('.collapse:not(.in)'),
                          collapseData;
  
                      if (expanded && expanded.length) {
                          collapseData = expanded.data('collapse');
                          if (collapseData && collapseData.transitioning) {
                              return;
                          }
                          if (expanded.collapse) { // if collapse plugin is available through bootstrap.js then use it
                              expanded.collapse('hide');
                              closed.collapse('show');
                          } else { // otherwise just toggle in class on the two views
                              expanded.removeClass('in');
                              closed.addClass('in');
                          }
                          if ($this.is('span')) {
                              $this.toggleClass(options.icons.time + ' ' + options.icons.date);
                          } else {
                              $this.find('span').toggleClass(options.icons.time + ' ' + options.icons.date);
                          }
  
                          // NOTE: uncomment if toggled state will be restored in show()
                          //if (component) {
                          //    component.find('span').toggleClass(options.icons.time + ' ' + options.icons.date);
                          //}
                      }
                  },
  
                  showPicker: function () {
                      widget.find('.timepicker > div:not(.timepicker-picker)').hide();
                      widget.find('.timepicker .timepicker-picker').show();
                  },
  
                  showHours: function () {
                      widget.find('.timepicker .timepicker-picker').hide();
                      widget.find('.timepicker .timepicker-hours').show();
                  },
  
                  showMinutes: function () {
                      widget.find('.timepicker .timepicker-picker').hide();
                      widget.find('.timepicker .timepicker-minutes').show();
                  },
  
                  showSeconds: function () {
                      widget.find('.timepicker .timepicker-picker').hide();
                      widget.find('.timepicker .timepicker-seconds').show();
                  },
  
                  selectHour: function (e) {
                      var hour = parseInt($(e.target).text(), 10);
  
                      if (!use24Hours) {
                          if (date.hours() >= 12) {
                              if (hour !== 12) {
                                  hour += 12;
                              }
                          } else {
                              if (hour === 12) {
                                  hour = 0;
                              }
                          }
                      }
                      setValue(date.clone().hours(hour));
                      actions.showPicker.call(picker);
                  },
  
                  selectMinute: function (e) {
                      setValue(date.clone().minutes(parseInt($(e.target).text(), 10)));
                      actions.showPicker.call(picker);
                  },
  
                  selectSecond: function (e) {
                      setValue(date.clone().seconds(parseInt($(e.target).text(), 10)));
                      actions.showPicker.call(picker);
                  },
  
                  clear: clear,
  
                  today: function () {
                      
                      var todaysDate = getMoment();
                      if (isValid(todaysDate, 'd')) {
                          setValue(todaysDate);
                      }
                  },
  
                  close: hide,
  
                  switchDate: function () {
  
                      if (options.hijri) {
  
                          options.hijri = false;
                          fillDate();
                          fillMonths();
                          
                          initFormatting();
                      }
                      else {
                          options.hijri = true;
                          fillHijriDate();
                          fillHijriMonths();
                          initFormatting();
                      }
                      
                  }
              },
  
              doAction = function (e) {
  
  
  
                  if ($(e.currentTarget).is('.disabled')) {
                      return false;
                  }
                  actions[$(e.currentTarget).data('action')].apply(picker, arguments);
                  return false;
              },
  
              show = function () {
                  ///<summary>Shows the widget. Possibly will emit dp.show and dp.change</summary>
                  var currentMoment,
                      useCurrentGranularity = {
                          'year': function (m) {
                              return m.month(0).date(1).hours(0).seconds(0).minutes(0);
                          },
                          'month': function (m) {
                              return m.date(1).hours(0).seconds(0).minutes(0);
                          },
                          'day': function (m) {
                              return m.hours(0).seconds(0).minutes(0);
                          },
                          'hour': function (m) {
                              return m.seconds(0).minutes(0);
                          },
                          'minute': function (m) {
                              return m.seconds(0);
                          }
                      };
  
                  if (input.prop('disabled') || (!options.ignoreReadonly && input.prop('readonly')) || widget) {
                      return picker;
                  }
                  if (input.val() !== undefined && input.val().trim().length !== 0) {
                      setValue(parseInputDate(input.val().trim()));
                  } else if (options.useCurrent && unset && ((input.is('input') && input.val().trim().length === 0) || options.inline)) {
                      currentMoment = getMoment();
                      if (typeof options.useCurrent === 'string') {
                          currentMoment = useCurrentGranularity[options.useCurrent](currentMoment);
                      }
                      setValue(currentMoment);
                  }
  
                  widget = getTemplate();
  
                  fillDow();
                  if (options.hijri) {
                      fillHijriMonths();
                  } else {
                      fillMonths();
                  }
  
                  widget.find('.timepicker-hours').hide();
                  widget.find('.timepicker-minutes').hide();
                  widget.find('.timepicker-seconds').hide();
  
                  update();
                  showMode();
  
                  $(window).on('resize', place);
                  widget.on('click', '[data-action]', doAction); // this handles clicks on the widget
                  widget.on('mousedown', false);
  
                  if (component && component.hasClass('btn')) {
                      component.toggleClass('active');
                  }
                  widget.show();
                  place();
  
                  if (options.focusOnShow && !input.is(':focus')) {
                      input.focus();
                  }
  
                  notifyEvent({
                      type: 'dp.show'
                  });
                  return picker;
              },
  
              toggle = function () {
                  /// <summary>Shows or hides the widget</summary>
                  return (widget ? hide() : show());
              },
  
              parseInputDate = function (inputDate) {
                  if (options.parseInputDate === undefined) {
                      if (moment.isMoment(inputDate) || inputDate instanceof Date) {
                          inputDate = moment(inputDate);
                      } else {
                          inputDate = getMoment(inputDate);
                      }
                  } else {
                      inputDate = options.parseInputDate(inputDate);
                  }
                  inputDate.locale(options.locale);
                  return inputDate;
              },
  
              keydown = function (e) {
                  var handler = null,
                      index,
                      index2,
                      pressedKeys = [],
                      pressedModifiers = {},
                      currentKey = e.which,
                      keyBindKeys,
                      allModifiersPressed,
                      pressed = 'p';
  
                  keyState[currentKey] = pressed;
  
                  for (index in keyState) {
                      if (keyState.hasOwnProperty(index) && keyState[index] === pressed) {
                          pressedKeys.push(index);
                          if (parseInt(index, 10) !== currentKey) {
                              pressedModifiers[index] = true;
                          }
                      }
                  }
  
                  for (index in options.keyBinds) {
                      if (options.keyBinds.hasOwnProperty(index) && typeof (options.keyBinds[index]) === 'function') {
                          keyBindKeys = index.split(' ');
                          if (keyBindKeys.length === pressedKeys.length && keyMap[currentKey] === keyBindKeys[keyBindKeys.length - 1]) {
                              allModifiersPressed = true;
                              for (index2 = keyBindKeys.length - 2; index2 >= 0; index2--) {
                                  if (!(keyMap[keyBindKeys[index2]] in pressedModifiers)) {
                                      allModifiersPressed = false;
                                      break;
                                  }
                              }
                              if (allModifiersPressed) {
                                  handler = options.keyBinds[index];
                                  break;
                              }
                          }
                      }
                  }
  
                  if (handler) {
                      handler.call(picker, widget);
                      e.stopPropagation();
                      e.preventDefault();
                  }
              },
  
              keyup = function (e) {
                  keyState[e.which] = 'r';
                  e.stopPropagation();
                  e.preventDefault();
              },
  
              change = function (e) {
                  var val = $(e.target).val().trim(),
                      parsedDate = val ? parseInputDate(val) : null;
                  setValue(parsedDate);
                  e.stopImmediatePropagation();
                  return false;
              },
  
              attachDatePickerElementEvents = function () {
                  input.on({
                      'change': change,
                      'blur': options.debug ? '' : hide,
                      'keydown': keydown,
                      'keyup': keyup,
                      'focus': options.allowInputToggle ? show : ''
                  });
  
                  if (element.is('input')) {
                      input.on({
                          'focus': show
                      });
                  } else if (component) {
                      component.on('click', toggle);
                      component.on('mousedown', false);
                  }
              },
  
              detachDatePickerElementEvents = function () {
                  input.off({
                      'change': change,
                      'blur': blur,
                      'keydown': keydown,
                      'keyup': keyup,
                      'focus': options.allowInputToggle ? hide : ''
                  });
  
                  if (element.is('input')) {
                      input.off({
                          'focus': show
                      });
                  } else if (component) {
                      component.off('click', toggle);
                      component.off('mousedown', false);
                  }
              },
  
              indexGivenDates = function (givenDatesArray) {
                  // Store given enabledDates and disabledDates as keys.
                  // This way we can check their existence in O(1) time instead of looping through whole array.
                  // (for example: options.enabledDates['2014-02-27'] === true)
                  var givenDatesIndexed = {};
                  $.each(givenDatesArray, function () {
                      var dDate = parseInputDate(this);
                      if (dDate.isValid()) {
                          givenDatesIndexed[dDate.format('YYYY-MM-DD')] = true;
                      }
                  });
                  return (Object.keys(givenDatesIndexed).length) ? givenDatesIndexed : false;
              },
  
              indexGivenHours = function (givenHoursArray) {
                  // Store given enabledHours and disabledHours as keys.
                  // This way we can check their existence in O(1) time instead of looping through whole array.
                  // (for example: options.enabledHours['2014-02-27'] === true)
                  var givenHoursIndexed = {};
                  $.each(givenHoursArray, function () {
                      givenHoursIndexed[this] = true;
                  });
                  return (Object.keys(givenHoursIndexed).length) ? givenHoursIndexed : false;
              },
  
              initFormatting = function () {
                  
                  var format = options.format || 'L LT';
  
                  if (options.hijri) {
                      format = options.hijriFormat;
                  }
  
                  actualFormat = format.replace(/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, function (formatInput) {
                      var newinput = date.localeData().longDateFormat(formatInput) || formatInput;
                      return newinput.replace(/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, function (formatInput2) { //temp fix for #740
                          return date.localeData().longDateFormat(formatInput2) || formatInput2;
                      });
                  });
  
  
                  parseFormats = options.extraFormats ? options.extraFormats.slice() : [];
                  if (parseFormats.indexOf(format) < 0 && parseFormats.indexOf(actualFormat) < 0) {
                      parseFormats.push(actualFormat);
                  }
  
                  use24Hours = (actualFormat.toLowerCase().indexOf('a') < 1 && actualFormat.replace(/\[.*?\]/g, '').indexOf('h') < 1);
  
                  if (isEnabled('y')) {
                      minViewModeNumber = 2;
                  }
                  if (isEnabled('M')) {
                      minViewModeNumber = 1;
                  }
                  if (isEnabled('d')) {
                      minViewModeNumber = 0;
                  }
  
                  currentViewMode = Math.max(minViewModeNumber, currentViewMode);
  
                  if (!unset) {
                      setValue(date);
                  }
              };
  
          /********************************************************************************
           *
           * Public API functions
           * =====================
           *
           * Important: Do not expose direct references to private objects or the options
           * object to the outer world. Always return a clone when returning values or make
           * a clone when setting a private variable.
           *
           ********************************************************************************/
          picker.destroy = function () {
              ///<summary>Destroys the widget and removes all attached event listeners</summary>
              hide();
              detachDatePickerElementEvents();
              element.removeData('DateTimePicker');
              element.removeData('date');
          };
  
          picker.toggle = toggle;
  
          picker.show = show;
  
          picker.hide = hide;
  
          picker.disable = function () {
              ///<summary>Disables the input element, the component is attached to, by adding a disabled="true" attribute to it.
              ///If the widget was visible before that call it is hidden. Possibly emits dp.hide</summary>
              hide();
              if (component && component.hasClass('btn')) {
                  component.addClass('disabled');
              }
              input.prop('disabled', true);
              return picker;
          };
  
          picker.enable = function () {
              ///<summary>Enables the input element, the component is attached to, by removing disabled attribute from it.</summary>
              if (component && component.hasClass('btn')) {
                  component.removeClass('disabled');
              }
              input.prop('disabled', false);
              return picker;
          };
  
          picker.ignoreReadonly = function (ignoreReadonly) {
              if (arguments.length === 0) {
                  return options.ignoreReadonly;
              }
              if (typeof ignoreReadonly !== 'boolean') {
                  throw new TypeError('ignoreReadonly () expects a boolean parameter');
              }
              options.ignoreReadonly = ignoreReadonly;
              return picker;
          };
  
          picker.options = function (newOptions) {
              if (arguments.length === 0) {
                  return $.extend(true, {}, options);
              }
  
              if (!(newOptions instanceof Object)) {
                  throw new TypeError('options() options parameter should be an object');
              }
              $.extend(true, options, newOptions);
              $.each(options, function (key, value) {
                  if (picker[key] !== undefined) {
                      picker[key](value);
                  } else {
                      throw new TypeError('option ' + key + ' is not recognized!');
                  }
              });
              return picker;
          };
  
          picker.date = function (newDate) {
              ///<signature helpKeyword="$.fn.datetimepicker.date">
              ///<summary>Returns the component's model current date, a moment object or null if not set.</summary>
              ///<returns type="Moment">date.clone()</returns>
              ///</signature>
              ///<signature>
              ///<summary>Sets the components model current moment to it. Passing a null value unsets the components model current moment. Parsing of the newDate parameter is made using moment library with the options.format and options.useStrict components configuration.</summary>
              ///<param name="newDate" locid="$.fn.datetimepicker.date_p:newDate">Takes string, Date, moment, null parameter.</param>
              ///</signature>
              if (arguments.length === 0) {
                  if (unset) {
                      return null;
                  }
                  return date.clone();
              }
  
              if (newDate !== null && typeof newDate !== 'string' && !moment.isMoment(newDate) && !(newDate instanceof Date)) {
                  throw new TypeError('date() parameter must be one of [null, string, moment or Date]');
              }
  
              setValue(newDate === null ? null : parseInputDate(newDate));
              return picker;
          };
  
          picker.format = function (newFormat) {
              ///<summary>test su</summary>
              ///<param name="newFormat">info about para</param>
              ///<returns type="string|boolean">returns foo</returns>
              if (arguments.length === 0) {
                  return options.format;
              }
  
              if ((typeof newFormat !== 'string') && ((typeof newFormat !== 'boolean') || (newFormat !== false))) {
                  throw new TypeError('format() expects a sting or boolean:false parameter ' + newFormat);
              }
  
              options.format = newFormat;
              if (actualFormat) {
                  initFormatting(); // reinit formatting
              }
              return picker;
          };
  
          picker.hijriFormat = function (newFormat) {
  
              /////<summary>test su</summary>
              /////<param name="newFormat">info about para</param>
              /////<returns type="string|boolean">returns foo</returns>
              //if (arguments.length === 0) {
              //    return options.format;
              //}
  
              //if ((typeof newFormat !== 'string') && ((typeof newFormat !== 'boolean') || (newFormat !== false))) {
              //    throw new TypeError('format() expects a sting or boolean:false parameter ' + newFormat);
              //}
  
              //options.format = newFormat;
              //if (actualFormat) {
              //    initFormatting(); // reinit formatting
              //}
              //return picker;
          };
  
          picker.timeZone = function (newZone) {
              if (arguments.length === 0) {
                  return options.timeZone;
              }
  
              options.timeZone = newZone;
  
              return picker;
          };
  
          picker.dayViewHeaderFormat = function (newFormat) {
              if (arguments.length === 0) {
                  return options.dayViewHeaderFormat;
              }
  
              if (typeof newFormat !== 'string') {
                  throw new TypeError('dayViewHeaderFormat() expects a string parameter');
              }
  
              options.dayViewHeaderFormat = newFormat;
              return picker;
          };
  
          picker.hijriDayViewHeaderFormat = function (newFormat) {
  
              //if (arguments.length === 0) {
              //    return options.dayViewHeaderFormat;
              //}
  
              //if (typeof newFormat !== 'string') {
              //    throw new TypeError('dayViewHeaderFormat() expects a string parameter');
              //}
  
              //options.dayViewHeaderFormat = newFormat;
              //return picker;
          };
  
          picker.extraFormats = function (formats) {
              if (arguments.length === 0) {
                  return options.extraFormats;
              }
  
              if (formats !== false && !(formats instanceof Array)) {
                  throw new TypeError('extraFormats() expects an array or false parameter');
              }
  
              options.extraFormats = formats;
              if (parseFormats) {
                  initFormatting(); // reinit formatting
              }
              return picker;
          };
  
          picker.disabledDates = function (dates) {
              ///<signature helpKeyword="$.fn.datetimepicker.disabledDates">
              ///<summary>Returns an array with the currently set disabled dates on the component.</summary>
              ///<returns type="array">options.disabledDates</returns>
              ///</signature>
              ///<signature>
              ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of
              ///options.enabledDates if such exist.</summary>
              ///<param name="dates" locid="$.fn.datetimepicker.disabledDates_p:dates">Takes an [ string or Date or moment ] of values and allows the user to select only from those days.</param>
              ///</signature>
              if (arguments.length === 0) {
                  return (options.disabledDates ? $.extend({}, options.disabledDates) : options.disabledDates);
              }
  
              if (!dates) {
                  options.disabledDates = false;
                  update();
                  return picker;
              }
              if (!(dates instanceof Array)) {
                  throw new TypeError('disabledDates() expects an array parameter');
              }
              options.disabledDates = indexGivenDates(dates);
              options.enabledDates = false;
              update();
              return picker;
          };
  
          picker.enabledDates = function (dates) {
              ///<signature helpKeyword="$.fn.datetimepicker.enabledDates">
              ///<summary>Returns an array with the currently set enabled dates on the component.</summary>
              ///<returns type="array">options.enabledDates</returns>
              ///</signature>
              ///<signature>
              ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of options.disabledDates if such exist.</summary>
              ///<param name="dates" locid="$.fn.datetimepicker.enabledDates_p:dates">Takes an [ string or Date or moment ] of values and allows the user to select only from those days.</param>
              ///</signature>
              if (arguments.length === 0) {
                  return (options.enabledDates ? $.extend({}, options.enabledDates) : options.enabledDates);
              }
  
              if (!dates) {
                  options.enabledDates = false;
                  update();
                  return picker;
              }
              if (!(dates instanceof Array)) {
                  throw new TypeError('enabledDates() expects an array parameter');
              }
              options.enabledDates = indexGivenDates(dates);
              options.disabledDates = false;
              update();
              return picker;
          };
  
          picker.daysOfWeekDisabled = function (daysOfWeekDisabled) {
              if (arguments.length === 0) {
                  return options.daysOfWeekDisabled.splice(0);
              }
  
              if ((typeof daysOfWeekDisabled === 'boolean') && !daysOfWeekDisabled) {
                  options.daysOfWeekDisabled = false;
                  update();
                  return picker;
              }
  
              if (!(daysOfWeekDisabled instanceof Array)) {
                  throw new TypeError('daysOfWeekDisabled() expects an array parameter');
              }
              options.daysOfWeekDisabled = daysOfWeekDisabled.reduce(function (previousValue, currentValue) {
                  currentValue = parseInt(currentValue, 10);
                  if (currentValue > 6 || currentValue < 0 || isNaN(currentValue)) {
                      return previousValue;
                  }
                  if (previousValue.indexOf(currentValue) === -1) {
                      previousValue.push(currentValue);
                  }
                  return previousValue;
              }, []).sort();
              if (options.useCurrent && !options.keepInvalid) {
                  var tries = 0;
                  while (!isValid(date, 'd')) {
                      date.add(1, 'days');
                      if (tries === 7) {
                          throw 'Tried 7 times to find a valid date';
                      }
                      tries++;
                  }
                  setValue(date);
              }
              update();
              return picker;
          };
  
          picker.maxDate = function (maxDate) {
              if (arguments.length === 0) {
                  return options.maxDate ? options.maxDate.clone() : options.maxDate;
              }
  
              if ((typeof maxDate === 'boolean') && maxDate === false) {
                  options.maxDate = false;
                  update();
                  return picker;
              }
  
              if (typeof maxDate === 'string') {
                  if (maxDate === 'now' || maxDate === 'moment') {
                      maxDate = getMoment();
                  }
              }
  
              var parsedDate = parseInputDate(maxDate);
  
              if (!parsedDate.isValid()) {
                  throw new TypeError('maxDate() Could not parse date parameter: ' + maxDate);
              }
              if (options.minDate && parsedDate.isBefore(options.minDate)) {
                  throw new TypeError('maxDate() date parameter is before options.minDate: ' + parsedDate.format(actualFormat));
              }
              options.maxDate = parsedDate;
              if (options.useCurrent && !options.keepInvalid && date.isAfter(maxDate)) {
                  setValue(options.maxDate);
              }
              if (viewDate.isAfter(parsedDate)) {
                  viewDate = parsedDate.clone().subtract(options.stepping, 'm');
              }
              update();
              return picker;
          };
  
          picker.minDate = function (minDate) {
              if (arguments.length === 0) {
                  return options.minDate ? options.minDate.clone() : options.minDate;
              }
  
              if ((typeof minDate === 'boolean') && minDate === false) {
                  options.minDate = false;
                  update();
                  return picker;
              }
  
              if (typeof minDate === 'string') {
                  if (minDate === 'now' || minDate === 'moment') {
                      minDate = getMoment();
                  }
              }
  
              var parsedDate = parseInputDate(minDate);
  
              if (!parsedDate.isValid()) {
                  throw new TypeError('minDate() Could not parse date parameter: ' + minDate);
              }
              if (options.maxDate && parsedDate.isAfter(options.maxDate)) {
                  throw new TypeError('minDate() date parameter is after options.maxDate: ' + parsedDate.format(actualFormat));
              }
              options.minDate = parsedDate;
              if (options.useCurrent && !options.keepInvalid && date.isBefore(minDate)) {
                  setValue(options.minDate);
              }
              if (viewDate.isBefore(parsedDate)) {
                  viewDate = parsedDate.clone().add(options.stepping, 'm');
              }
              update();
              return picker;
          };
  
          picker.defaultDate = function (defaultDate) {
              ///<signature helpKeyword="$.fn.datetimepicker.defaultDate">
              ///<summary>Returns a moment with the options.defaultDate option configuration or false if not set</summary>
              ///<returns type="Moment">date.clone()</returns>
              ///</signature>
              ///<signature>
              ///<summary>Will set the picker's inital date. If a boolean:false value is passed the options.defaultDate parameter is cleared.</summary>
              ///<param name="defaultDate" locid="$.fn.datetimepicker.defaultDate_p:defaultDate">Takes a string, Date, moment, boolean:false</param>
              ///</signature>
              if (arguments.length === 0) {
                  return options.defaultDate ? options.defaultDate.clone() : options.defaultDate;
              }
              if (!defaultDate) {
                  options.defaultDate = false;
                  return picker;
              }
  
              if (typeof defaultDate === 'string') {
                  if (defaultDate === 'now' || defaultDate === 'moment') {
                      defaultDate = getMoment();
                  }
              }
  
              var parsedDate = parseInputDate(defaultDate);
              if (!parsedDate.isValid()) {
                  throw new TypeError('defaultDate() Could not parse date parameter: ' + defaultDate);
              }
              if (!isValid(parsedDate)) {
                  throw new TypeError('defaultDate() date passed is invalid according to component setup validations');
              }
  
              options.defaultDate = parsedDate;
  
              if ((options.defaultDate && options.inline) || input.val().trim() === '') {
                  setValue(options.defaultDate);
              }
              return picker;
          };
  
          picker.hijri = function (hijri) {
              if (arguments.length === 0) {
                  if (options.hijri) {
                      options.viewModes = ['days', 'months', 'years'];
                  }
                  return options.hijri;
              }
              if (typeof (hijri) !== "boolean") {
                  throw new TypeError('hijri() expects a boolean parameter');
              }
  
              options.hijri = hijri;
  
              if (options.hijri) {
                  options.viewModes = ['days', 'months', 'years'];
              }
              return picker;
          };
  
          picker.isRTL = function () {
              if (options.isRTL) {
                  options.icons.next = ">>";
                  options.icons.previous = "<<";
              }
              return options.isRTL;
          };
  
          picker.locale = function (locale) {
              if (arguments.length === 0) {
                  return options.locale;
              }
  
              if (!moment.localeData(locale)) {
                  throw new TypeError('locale() locale ' + locale + ' is not loaded from moment locales!');
              }
  
              options.locale = locale;
              date.locale(options.locale);
              viewDate.locale(options.locale);
  
              if (actualFormat) {
                  initFormatting(); // reinit formatting
              }
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.stepping = function (stepping) {
              if (arguments.length === 0) {
                  return options.stepping;
              }
  
              stepping = parseInt(stepping, 10);
              if (isNaN(stepping) || stepping < 1) {
                  stepping = 1;
              }
              options.stepping = stepping;
              return picker;
          };
  
          picker.useCurrent = function (useCurrent) {
              var useCurrentOptions = ['year', 'month', 'day', 'hour', 'minute'];
              if (arguments.length === 0) {
                  return options.useCurrent;
              }
  
              if ((typeof useCurrent !== 'boolean') && (typeof useCurrent !== 'string')) {
                  throw new TypeError('useCurrent() expects a boolean or string parameter');
              }
              if (typeof useCurrent === 'string' && useCurrentOptions.indexOf(useCurrent.toLowerCase()) === -1) {
                  throw new TypeError('useCurrent() expects a string parameter of ' + useCurrentOptions.join(', '));
              }
              options.useCurrent = useCurrent;
              return picker;
          };
  
          picker.collapse = function (collapse) {
              if (arguments.length === 0) {
                  return options.collapse;
              }
  
              if (typeof collapse !== 'boolean') {
                  throw new TypeError('collapse() expects a boolean parameter');
              }
              if (options.collapse === collapse) {
                  return picker;
              }
              options.collapse = collapse;
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.icons = function (icons) {
              if (arguments.length === 0) {
                  return $.extend({}, options.icons);
              }
  
              if (!(icons instanceof Object)) {
                  throw new TypeError('icons() expects parameter to be an Object');
              }
              $.extend(options.icons, icons);
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.tooltips = function (tooltips) {
              if (arguments.length === 0) {
                  return $.extend({}, options.tooltips);
              }
  
              if (!(tooltips instanceof Object)) {
                  throw new TypeError('tooltips() expects parameter to be an Object');
              }
              $.extend(options.tooltips, tooltips);
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.useStrict = function (useStrict) {
              if (arguments.length === 0) {
                  return options.useStrict;
              }
  
              if (typeof useStrict !== 'boolean') {
                  throw new TypeError('useStrict() expects a boolean parameter');
              }
              options.useStrict = useStrict;
              return picker;
          };
  
          picker.sideBySide = function (sideBySide) {
              if (arguments.length === 0) {
                  return options.sideBySide;
              }
  
              if (typeof sideBySide !== 'boolean') {
                  throw new TypeError('sideBySide() expects a boolean parameter');
              }
              options.sideBySide = sideBySide;
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.viewMode = function (viewMode) {
              if (arguments.length === 0) {
                  return options.viewMode;
              }
  
              if (typeof viewMode !== 'string') {
                  throw new TypeError('viewMode() expects a string parameter');
              }
  
              if (viewModes.indexOf(viewMode) === -1) {
                  throw new TypeError('viewMode() parameter must be one of (' + viewModes.join(', ') + ') value');
              }
  
              options.viewMode = viewMode;
              currentViewMode = Math.max(viewModes.indexOf(viewMode), minViewModeNumber);
  
              showMode();
              return picker;
          };
  
          picker.toolbarPlacement = function (toolbarPlacement) {
              if (arguments.length === 0) {
                  return options.toolbarPlacement;
              }
  
              if (typeof toolbarPlacement !== 'string') {
                  throw new TypeError('toolbarPlacement() expects a string parameter');
              }
              if (toolbarPlacements.indexOf(toolbarPlacement) === -1) {
                  throw new TypeError('toolbarPlacement() parameter must be one of (' + toolbarPlacements.join(', ') + ') value');
              }
              options.toolbarPlacement = toolbarPlacement;
  
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.widgetPositioning = function (widgetPositioning) {
              if (arguments.length === 0) {
                  return $.extend({}, options.widgetPositioning);
              }
  
              if (({}).toString.call(widgetPositioning) !== '[object Object]') {
                  throw new TypeError('widgetPositioning() expects an object variable');
              }
              if (widgetPositioning.horizontal) {
                  if (typeof widgetPositioning.horizontal !== 'string') {
                      throw new TypeError('widgetPositioning() horizontal variable must be a string');
                  }
                  widgetPositioning.horizontal = widgetPositioning.horizontal.toLowerCase();
                  if (horizontalModes.indexOf(widgetPositioning.horizontal) === -1) {
                      throw new TypeError('widgetPositioning() expects horizontal parameter to be one of (' + horizontalModes.join(', ') + ')');
                  }
                  options.widgetPositioning.horizontal = widgetPositioning.horizontal;
              }
              if (widgetPositioning.vertical) {
                  if (typeof widgetPositioning.vertical !== 'string') {
                      throw new TypeError('widgetPositioning() vertical variable must be a string');
                  }
                  widgetPositioning.vertical = widgetPositioning.vertical.toLowerCase();
                  if (verticalModes.indexOf(widgetPositioning.vertical) === -1) {
                      throw new TypeError('widgetPositioning() expects vertical parameter to be one of (' + verticalModes.join(', ') + ')');
                  }
                  options.widgetPositioning.vertical = widgetPositioning.vertical;
              }
              update();
              return picker;
          };
  
          picker.calendarWeeks = function (calendarWeeks) {
              if (arguments.length === 0) {
                  return options.calendarWeeks;
              }
  
              if (typeof calendarWeeks !== 'boolean') {
                  throw new TypeError('calendarWeeks() expects parameter to be a boolean value');
              }
  
              options.calendarWeeks = calendarWeeks;
              update();
              return picker;
          };
  
          picker.showTodayButton = function (showTodayButton) {
  
  
              if (arguments.length === 0) {
                  return options.showTodayButton;
              }
  
              if (typeof showTodayButton !== 'boolean') {
                  throw new TypeError('showTodayButton() expects a boolean parameter');
              }
  
              options.showTodayButton = showTodayButton;
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.showClear = function (showClear) {
              if (arguments.length === 0) {
                  return options.showClear;
              }
  
              if (typeof showClear !== 'boolean') {
                  throw new TypeError('showClear() expects a boolean parameter');
              }
  
              options.showClear = showClear;
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.widgetParent = function (widgetParent) {
              if (arguments.length === 0) {
                  return options.widgetParent;
              }
  
              if (typeof widgetParent === 'string') {
                  widgetParent = $(widgetParent);
              }
  
              if (widgetParent !== null && (typeof widgetParent !== 'string' && !(widgetParent instanceof $))) {
                  throw new TypeError('widgetParent() expects a string or a jQuery object parameter');
              }
  
              options.widgetParent = widgetParent;
              if (widget) {
                  hide();
                  show();
              }
              return picker;
          };
  
          picker.keepOpen = function (keepOpen) {
              if (arguments.length === 0) {
                  return options.keepOpen;
              }
  
              if (typeof keepOpen !== 'boolean') {
                  throw new TypeError('keepOpen() expects a boolean parameter');
              }
  
              options.keepOpen = keepOpen;
              return picker;
          };
  
          picker.focusOnShow = function (focusOnShow) {
              if (arguments.length === 0) {
                  return options.focusOnShow;
              }
  
              if (typeof focusOnShow !== 'boolean') {
                  throw new TypeError('focusOnShow() expects a boolean parameter');
              }
  
              options.focusOnShow = focusOnShow;
              return picker;
          };
  
          picker.inline = function (inline) {
              if (arguments.length === 0) {
                  return options.inline;
              }
  
              if (typeof inline !== 'boolean') {
                  throw new TypeError('inline() expects a boolean parameter');
              }
  
              options.inline = inline;
              return picker;
          };
  
          picker.clear = function () {
              clear();
              return picker;
          };
  
          picker.keyBinds = function (keyBinds) {
              options.keyBinds = keyBinds;
              return picker;
          };
  
          picker.getMoment = function (d) {
              return getMoment(d);
          };
  
          picker.debug = function (debug) {
              if (typeof debug !== 'boolean') {
                  throw new TypeError('debug() expects a boolean parameter');
              }
  
              options.debug = debug;
              return picker;
          };
  
          picker.allowInputToggle = function (allowInputToggle) {
              if (arguments.length === 0) {
                  return options.allowInputToggle;
              }
  
              if (typeof allowInputToggle !== 'boolean') {
                  throw new TypeError('allowInputToggle() expects a boolean parameter');
              }
  
              options.allowInputToggle = allowInputToggle;
              return picker;
          };
  
          picker.showClose = function (showClose) {
              if (arguments.length === 0) {
                  return options.showClose;
              }
  
              if (typeof showClose !== 'boolean') {
                  throw new TypeError('showClose() expects a boolean parameter');
              }
  
              options.showClose = showClose;
              return picker;
          };
  
          picker.showSwitcher = function (showSwitcher) {
  
              if (arguments.length === 0) {
                  return options.showSwitcher;
              }
  
              if (typeof showSwitcher !== 'boolean') {
                  throw new TypeError('showClose() expects a boolean parameter');
              }
  
              options.showSwitcher = showSwitcher;
  
              return picker;
          };
  
          picker.keepInvalid = function (keepInvalid) {
              if (arguments.length === 0) {
                  return options.keepInvalid;
              }
  
              if (typeof keepInvalid !== 'boolean') {
                  throw new TypeError('keepInvalid() expects a boolean parameter');
              }
              options.keepInvalid = keepInvalid;
              return picker;
          };
  
          picker.datepickerInput = function (datepickerInput) {
              if (arguments.length === 0) {
                  return options.datepickerInput;
              }
  
              if (typeof datepickerInput !== 'string') {
                  throw new TypeError('datepickerInput() expects a string parameter');
              }
  
              options.datepickerInput = datepickerInput;
              return picker;
          };
  
          picker.parseInputDate = function (parseInputDate) {
              if (arguments.length === 0) {
                  return options.parseInputDate;
              }
  
              if (typeof parseInputDate !== 'function') {
                  throw new TypeError('parseInputDate() sholud be as function');
              }
  
              options.parseInputDate = parseInputDate;
  
              return picker;
          };
  
          picker.disabledTimeIntervals = function (disabledTimeIntervals) {
              ///<signature helpKeyword="$.fn.datetimepicker.disabledTimeIntervals">
              ///<summary>Returns an array with the currently set disabled dates on the component.</summary>
              ///<returns type="array">options.disabledTimeIntervals</returns>
              ///</signature>
              ///<signature>
              ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of
              ///options.enabledDates if such exist.</summary>
              ///<param name="dates" locid="$.fn.datetimepicker.disabledTimeIntervals_p:dates">Takes an [ string or Date or moment ] of values and allows the user to select only from those days.</param>
              ///</signature>
              if (arguments.length === 0) {
                  return (options.disabledTimeIntervals ? $.extend({}, options.disabledTimeIntervals) : options.disabledTimeIntervals);
              }
  
              if (!disabledTimeIntervals) {
                  options.disabledTimeIntervals = false;
                  update();
                  return picker;
              }
              if (!(disabledTimeIntervals instanceof Array)) {
                  throw new TypeError('disabledTimeIntervals() expects an array parameter');
              }
              options.disabledTimeIntervals = disabledTimeIntervals;
              update();
              return picker;
          };
  
          picker.disabledHours = function (hours) {
              ///<signature helpKeyword="$.fn.datetimepicker.disabledHours">
              ///<summary>Returns an array with the currently set disabled hours on the component.</summary>
              ///<returns type="array">options.disabledHours</returns>
              ///</signature>
              ///<signature>
              ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of
              ///options.enabledHours if such exist.</summary>
              ///<param name="hours" locid="$.fn.datetimepicker.disabledHours_p:hours">Takes an [ int ] of values and disallows the user to select only from those hours.</param>
              ///</signature>
              if (arguments.length === 0) {
                  return (options.disabledHours ? $.extend({}, options.disabledHours) : options.disabledHours);
              }
  
              if (!hours) {
                  options.disabledHours = false;
                  update();
                  return picker;
              }
              if (!(hours instanceof Array)) {
                  throw new TypeError('disabledHours() expects an array parameter');
              }
              options.disabledHours = indexGivenHours(hours);
              options.enabledHours = false;
              if (options.useCurrent && !options.keepInvalid) {
                  var tries = 0;
                  while (!isValid(date, 'h')) {
                      date.add(1, 'h');
                      if (tries === 24) {
                          throw 'Tried 24 times to find a valid date';
                      }
                      tries++;
                  }
                  setValue(date);
              }
              update();
              return picker;
          };
  
          picker.enabledHours = function (hours) {
              ///<signature helpKeyword="$.fn.datetimepicker.enabledHours">
              ///<summary>Returns an array with the currently set enabled hours on the component.</summary>
              ///<returns type="array">options.enabledHours</returns>
              ///</signature>
              ///<signature>
              ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of options.disabledHours if such exist.</summary>
              ///<param name="hours" locid="$.fn.datetimepicker.enabledHours_p:hours">Takes an [ int ] of values and allows the user to select only from those hours.</param>
              ///</signature>
              if (arguments.length === 0) {
                  return (options.enabledHours ? $.extend({}, options.enabledHours) : options.enabledHours);
              }
  
              if (!hours) {
                  options.enabledHours = false;
                  update();
                  return picker;
              }
              if (!(hours instanceof Array)) {
                  throw new TypeError('enabledHours() expects an array parameter');
              }
              options.enabledHours = indexGivenHours(hours);
              options.disabledHours = false;
              if (options.useCurrent && !options.keepInvalid) {
                  var tries = 0;
                  while (!isValid(date, 'h')) {
                      date.add(1, 'h');
                      if (tries === 24) {
                          throw 'Tried 24 times to find a valid date';
                      }
                      tries++;
                  }
                  setValue(date);
              }
              update();
              return picker;
          };
  
          picker.viewDate = function (newDate) {
              ///<signature helpKeyword="$.fn.datetimepicker.viewDate">
              ///<summary>Returns the component's model current viewDate, a moment object or null if not set.</summary>
              ///<returns type="Moment">viewDate.clone()</returns>
              ///</signature>
              ///<signature>
              ///<summary>Sets the components model current moment to it. Passing a null value unsets the components model current moment. Parsing of the newDate parameter is made using moment library with the options.format and options.useStrict components configuration.</summary>
              ///<param name="newDate" locid="$.fn.datetimepicker.date_p:newDate">Takes string, viewDate, moment, null parameter.</param>
              ///</signature>
              if (arguments.length === 0) {
                  return viewDate.clone();
              }
  
              if (!newDate) {
                  viewDate = date.clone();
                  return picker;
              }
  
              if (typeof newDate !== 'string' && !moment.isMoment(newDate) && !(newDate instanceof Date)) {
                  throw new TypeError('viewDate() parameter must be one of [string, moment or Date]');
              }
  
              viewDate = parseInputDate(newDate);
              viewUpdate();
              return picker;
          };
  
          // initializing element and component attributes
          if (element.is('input')) {
              input = element;
          } else {
              input = element.find(options.datepickerInput);
              if (input.size() === 0) {
                  input = element.find('input');
              } else if (!input.is('input')) {
                  throw new Error('CSS class "' + options.datepickerInput + '" cannot be applied to non input element');
              }
          }
  
          if (element.hasClass('input-group')) {
              // in case there is more then one 'input-group-addon' Issue #48
              if (element.find('.datepickerbutton').size() === 0) {
                  component = element.find('.input-group-addon');
              } else {
                  component = element.find('.datepickerbutton');
              }
          }
  
          if (!options.inline && !input.is('input')) {
              throw new Error('Could not initialize DateTimePicker without an input element');
          }
  
          // Set defaults for date here now instead of in var declaration
          date = getMoment();
          viewDate = date.clone();
  
          $.extend(true, options, dataToOptions());
  
          picker.options(options);
  
          initFormatting();
  
          attachDatePickerElementEvents();
  
          if (input.prop('disabled')) {
              picker.disable();
          }
          if (input.is('input') && input.val().trim().length !== 0) {
              setValue(parseInputDate(input.val().trim()));
          }
          else if (options.defaultDate && input.attr('placeholder') === undefined) {
              setValue(options.defaultDate);
          }
          if (options.inline) {
              show();
          }
          return picker;
      };
  
      /********************************************************************************
       *
       * jQuery plugin constructor and defaults object
       *
       ********************************************************************************/
  
      $.fn.hijriDatePicker = function (options) {
          return this.each(function () {
              var $this = $(this);
              if (!$this.data('HijriDatePicker')) {
                  // create a private copy of the defaults object
                  options = $.extend(true, {}, $.fn.hijriDatePicker.defaults, options);
                  $this.data('HijriDatePicker', hijriDatePicker($this, options));
              }
          });
      };
  
      $.fn.hijriDatePicker.defaults = {
          timeZone: 'Etc/UTC',
          format: 'DD-MM-YYYY',
          hijriFormat: 'iYYYY-iMM-iDD',
          hijriDayViewHeaderFormat: 'iMMMM iYYYY',
          dayViewHeaderFormat: 'MMMM YYYY',
          minDate: '1950-01-01',
          maxDate: '2070-01-01',
          extraFormats: false,
          stepping: 1,
          useCurrent: true,
          collapse: true,
          locale: 'ar-SA',
          defaultDate: false,
          disabledDates: false,
          enabledDates: false,
          icons: {
              time: 'fa fa-clock text-primary',
              date: 'glyphicon glyphicon-calendar',
              up: 'fa fa-chevron-up text-primary',
              down: 'fa fa-chevron-down text-primary',
              previous: '<<',
              next: '>>',
              today: 'اليوم',
              clear: 'مسح',
              close: 'اغلاق'
          },
          tooltips: {
              today: 'Go to today',
              clear: 'Clear selection',
              close: 'Close the picker',
              selectMonth: 'Select Month',
              prevMonth: 'Previous Month',
              nextMonth: 'Next Month',
              selectYear: 'Select Year',
              prevYear: 'Previous Year',
              nextYear: 'Next Year',
              selectDecade: 'Select Decade',
              prevDecade: 'Previous Decade',
              nextDecade: 'Next Decade',
              prevCentury: 'Previous Century',
              nextCentury: 'Next Century',
              pickHour: 'Pick Hour',
              incrementHour: 'Increment Hour',
              decrementHour: 'Decrement Hour',
              pickMinute: 'Pick Minute',
              incrementMinute: 'Increment Minute',
              decrementMinute: 'Decrement Minute',
              pickSecond: 'Pick Second',
              incrementSecond: 'Increment Second',
              decrementSecond: 'Decrement Second',
              togglePeriod: 'Toggle Period',
              selectTime: 'Select Time'
          },
          useStrict: false,
          sideBySide: false,
          daysOfWeekDisabled: false,
          calendarWeeks: false,
          viewMode: 'days',
          toolbarPlacement: 'default',
          showTodayButton: false,
          showClear: false,
          showClose: false,
          widgetPositioning: {
              horizontal: 'auto',
              vertical: 'auto'
          },
          widgetParent: null,
          ignoreReadonly: false,
          keepOpen: false,
          focusOnShow: true,
          inline: false,
          keepInvalid: false,
          datepickerInput: '.datepickerinput',
          keyBinds: {
              up: function (widget) {
                  if (!widget) {
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().subtract(7, 'd'));
                  } else {
                      this.date(d.clone().add(this.stepping(), 'm'));
                  }
              },
              down: function (widget) {
                  if (!widget) {
                      this.show();
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().add(7, 'd'));
                  } else {
                      this.date(d.clone().subtract(this.stepping(), 'm'));
                  }
              },
              'control up': function (widget) {
                  if (!widget) {
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().subtract(1, 'years'));
                  } else {
                      this.date(d.clone().add(1, 'h'));
                  }
              },
              'control down': function (widget) {
                  if (!widget) {
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().add(1, 'y'));
                  } else {
                      this.date(d.clone().subtract(1, 'h'));
                  }
              },
              left: function (widget) {
                  if (!widget) {
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().subtract(1, 'days'));
                  }
              },
              right: function (widget) {
  
  
                  if (!widget) {
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().add(1, 'days'));
                  }
              },
              pageUp: function (widget) {
                  if (!widget) {
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().subtract(1, 'months'));
                  }
              },
              pageDown: function (widget) {
                  if (!widget) {
                      return;
                  }
                  var d = this.date() || this.getMoment();
                  if (widget.find('.datepicker').is(':visible')) {
                      this.date(d.clone().add(1, 'months'));
                  }
              },
              enter: function () {
                  this.hide();
              },
              escape: function () {
                  this.hide();
              },
              //tab: function (widget) { //this break the flow of the form. disabling for now
              //    var toggle = widget.find('.picker-switch a[data-action="togglePicker"]');
              //    if(toggle.length > 0) toggle.click();
              //},
              'control space': function (widget) {
                  if (widget.find('.timepicker').is(':visible')) {
                      widget.find('.btn[data-action="togglePeriod"]').click();
                  }
              },
              t: function () {
                  this.date(this.getMoment());
              },
              'delete': function () {
                  this.clear();
              }
          },
          showSwitcher: true,
          debug: false,
          allowInputToggle: false,
          disabledTimeIntervals: false,
          disabledHours: false,
          enabledHours: false,
          viewDate: false,
          hijri: false,
          isRTL: false
      };
  }));