· 8 years ago · Jul 20, 2018, 11:04 AM
1/******/ (function(modules) { // webpackBootstrap
2/******/ // The module cache
3/******/ var installedModules = {};
4/******/
5/******/ // The require function
6/******/ function __webpack_require__(moduleId) {
7/******/
8/******/ // Check if module is in cache
9/******/ if(installedModules[moduleId])
10/******/ return installedModules[moduleId].exports;
11/******/
12/******/ // Create a new module (and put it into the cache)
13/******/ var module = installedModules[moduleId] = {
14/******/ i: moduleId,
15/******/ l: false,
16/******/ exports: {}
17/******/ };
18/******/
19/******/ // Execute the module function
20/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21/******/
22/******/ // Flag the module as loaded
23/******/ module.l = true;
24/******/
25/******/ // Return the exports of the module
26/******/ return module.exports;
27/******/ }
28/******/
29/******/
30/******/ // expose the modules object (__webpack_modules__)
31/******/ __webpack_require__.m = modules;
32/******/
33/******/ // expose the module cache
34/******/ __webpack_require__.c = installedModules;
35/******/
36/******/ // identity function for calling harmony imports with the correct context
37/******/ __webpack_require__.i = function(value) { return value; };
38/******/
39/******/ // define getter function for harmony exports
40/******/ __webpack_require__.d = function(exports, name, getter) {
41/******/ if(!__webpack_require__.o(exports, name)) {
42/******/ Object.defineProperty(exports, name, {
43/******/ configurable: false,
44/******/ enumerable: true,
45/******/ get: getter
46/******/ });
47/******/ }
48/******/ };
49/******/
50/******/ // getDefaultExport function for compatibility with non-harmony modules
51/******/ __webpack_require__.n = function(module) {
52/******/ var getter = module && module.__esModule ?
53/******/ function getDefault() { return module['default']; } :
54/******/ function getModuleExports() { return module; };
55/******/ __webpack_require__.d(getter, 'a', getter);
56/******/ return getter;
57/******/ };
58/******/
59/******/ // Object.prototype.hasOwnProperty.call
60/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
61/******/
62/******/ // __webpack_public_path__
63/******/ __webpack_require__.p = "";
64/******/
65/******/ // Load entry module and return exports
66/******/ return __webpack_require__(__webpack_require__.s = 250);
67/******/ })
68/************************************************************************/
69/******/ ([
70/* 0 */
71/***/ (function(module, exports, __webpack_require__) {
72
73/* WEBPACK VAR INJECTION */(function(module) {var require;//! moment.js
74
75;(function (global, factory) {
76 true ? module.exports = factory() :
77 typeof define === 'function' && define.amd ? define(factory) :
78 global.moment = factory()
79}(this, (function () { 'use strict';
80
81 var hookCallback;
82
83 function hooks () {
84 return hookCallback.apply(null, arguments);
85 }
86
87 // This is done to register the method called with moment()
88 // without creating circular dependencies.
89 function setHookCallback (callback) {
90 hookCallback = callback;
91 }
92
93 function isArray(input) {
94 return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
95 }
96
97 function isObject(input) {
98 // IE8 will treat undefined and null as object if it wasn't for
99 // input != null
100 return input != null && Object.prototype.toString.call(input) === '[object Object]';
101 }
102
103 function isObjectEmpty(obj) {
104 if (Object.getOwnPropertyNames) {
105 return (Object.getOwnPropertyNames(obj).length === 0);
106 } else {
107 var k;
108 for (k in obj) {
109 if (obj.hasOwnProperty(k)) {
110 return false;
111 }
112 }
113 return true;
114 }
115 }
116
117 function isUndefined(input) {
118 return input === void 0;
119 }
120
121 function isNumber(input) {
122 return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
123 }
124
125 function isDate(input) {
126 return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
127 }
128
129 function map(arr, fn) {
130 var res = [], i;
131 for (i = 0; i < arr.length; ++i) {
132 res.push(fn(arr[i], i));
133 }
134 return res;
135 }
136
137 function hasOwnProp(a, b) {
138 return Object.prototype.hasOwnProperty.call(a, b);
139 }
140
141 function extend(a, b) {
142 for (var i in b) {
143 if (hasOwnProp(b, i)) {
144 a[i] = b[i];
145 }
146 }
147
148 if (hasOwnProp(b, 'toString')) {
149 a.toString = b.toString;
150 }
151
152 if (hasOwnProp(b, 'valueOf')) {
153 a.valueOf = b.valueOf;
154 }
155
156 return a;
157 }
158
159 function createUTC (input, format, locale, strict) {
160 return createLocalOrUTC(input, format, locale, strict, true).utc();
161 }
162
163 function defaultParsingFlags() {
164 // We need to deep clone this object.
165 return {
166 empty : false,
167 unusedTokens : [],
168 unusedInput : [],
169 overflow : -2,
170 charsLeftOver : 0,
171 nullInput : false,
172 invalidMonth : null,
173 invalidFormat : false,
174 userInvalidated : false,
175 iso : false,
176 parsedDateParts : [],
177 meridiem : null,
178 rfc2822 : false,
179 weekdayMismatch : false
180 };
181 }
182
183 function getParsingFlags(m) {
184 if (m._pf == null) {
185 m._pf = defaultParsingFlags();
186 }
187 return m._pf;
188 }
189
190 var some;
191 if (Array.prototype.some) {
192 some = Array.prototype.some;
193 } else {
194 some = function (fun) {
195 var t = Object(this);
196 var len = t.length >>> 0;
197
198 for (var i = 0; i < len; i++) {
199 if (i in t && fun.call(this, t[i], i, t)) {
200 return true;
201 }
202 }
203
204 return false;
205 };
206 }
207
208 function isValid(m) {
209 if (m._isValid == null) {
210 var flags = getParsingFlags(m);
211 var parsedParts = some.call(flags.parsedDateParts, function (i) {
212 return i != null;
213 });
214 var isNowValid = !isNaN(m._d.getTime()) &&
215 flags.overflow < 0 &&
216 !flags.empty &&
217 !flags.invalidMonth &&
218 !flags.invalidWeekday &&
219 !flags.weekdayMismatch &&
220 !flags.nullInput &&
221 !flags.invalidFormat &&
222 !flags.userInvalidated &&
223 (!flags.meridiem || (flags.meridiem && parsedParts));
224
225 if (m._strict) {
226 isNowValid = isNowValid &&
227 flags.charsLeftOver === 0 &&
228 flags.unusedTokens.length === 0 &&
229 flags.bigHour === undefined;
230 }
231
232 if (Object.isFrozen == null || !Object.isFrozen(m)) {
233 m._isValid = isNowValid;
234 }
235 else {
236 return isNowValid;
237 }
238 }
239 return m._isValid;
240 }
241
242 function createInvalid (flags) {
243 var m = createUTC(NaN);
244 if (flags != null) {
245 extend(getParsingFlags(m), flags);
246 }
247 else {
248 getParsingFlags(m).userInvalidated = true;
249 }
250
251 return m;
252 }
253
254 // Plugins that add properties should also add the key here (null value),
255 // so we can properly clone ourselves.
256 var momentProperties = hooks.momentProperties = [];
257
258 function copyConfig(to, from) {
259 var i, prop, val;
260
261 if (!isUndefined(from._isAMomentObject)) {
262 to._isAMomentObject = from._isAMomentObject;
263 }
264 if (!isUndefined(from._i)) {
265 to._i = from._i;
266 }
267 if (!isUndefined(from._f)) {
268 to._f = from._f;
269 }
270 if (!isUndefined(from._l)) {
271 to._l = from._l;
272 }
273 if (!isUndefined(from._strict)) {
274 to._strict = from._strict;
275 }
276 if (!isUndefined(from._tzm)) {
277 to._tzm = from._tzm;
278 }
279 if (!isUndefined(from._isUTC)) {
280 to._isUTC = from._isUTC;
281 }
282 if (!isUndefined(from._offset)) {
283 to._offset = from._offset;
284 }
285 if (!isUndefined(from._pf)) {
286 to._pf = getParsingFlags(from);
287 }
288 if (!isUndefined(from._locale)) {
289 to._locale = from._locale;
290 }
291
292 if (momentProperties.length > 0) {
293 for (i = 0; i < momentProperties.length; i++) {
294 prop = momentProperties[i];
295 val = from[prop];
296 if (!isUndefined(val)) {
297 to[prop] = val;
298 }
299 }
300 }
301
302 return to;
303 }
304
305 var updateInProgress = false;
306
307 // Moment prototype object
308 function Moment(config) {
309 copyConfig(this, config);
310 this._d = new Date(config._d != null ? config._d.getTime() : NaN);
311 if (!this.isValid()) {
312 this._d = new Date(NaN);
313 }
314 // Prevent infinite loop in case updateOffset creates new moment
315 // objects.
316 if (updateInProgress === false) {
317 updateInProgress = true;
318 hooks.updateOffset(this);
319 updateInProgress = false;
320 }
321 }
322
323 function isMoment (obj) {
324 return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
325 }
326
327 function absFloor (number) {
328 if (number < 0) {
329 // -0 -> 0
330 return Math.ceil(number) || 0;
331 } else {
332 return Math.floor(number);
333 }
334 }
335
336 function toInt(argumentForCoercion) {
337 var coercedNumber = +argumentForCoercion,
338 value = 0;
339
340 if (coercedNumber !== 0 && isFinite(coercedNumber)) {
341 value = absFloor(coercedNumber);
342 }
343
344 return value;
345 }
346
347 // compare two arrays, return the number of differences
348 function compareArrays(array1, array2, dontConvert) {
349 var len = Math.min(array1.length, array2.length),
350 lengthDiff = Math.abs(array1.length - array2.length),
351 diffs = 0,
352 i;
353 for (i = 0; i < len; i++) {
354 if ((dontConvert && array1[i] !== array2[i]) ||
355 (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
356 diffs++;
357 }
358 }
359 return diffs + lengthDiff;
360 }
361
362 function warn(msg) {
363 if (hooks.suppressDeprecationWarnings === false &&
364 (typeof console !== 'undefined') && console.warn) {
365 console.warn('Deprecation warning: ' + msg);
366 }
367 }
368
369 function deprecate(msg, fn) {
370 var firstTime = true;
371
372 return extend(function () {
373 if (hooks.deprecationHandler != null) {
374 hooks.deprecationHandler(null, msg);
375 }
376 if (firstTime) {
377 var args = [];
378 var arg;
379 for (var i = 0; i < arguments.length; i++) {
380 arg = '';
381 if (typeof arguments[i] === 'object') {
382 arg += '\n[' + i + '] ';
383 for (var key in arguments[0]) {
384 arg += key + ': ' + arguments[0][key] + ', ';
385 }
386 arg = arg.slice(0, -2); // Remove trailing comma and space
387 } else {
388 arg = arguments[i];
389 }
390 args.push(arg);
391 }
392 warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
393 firstTime = false;
394 }
395 return fn.apply(this, arguments);
396 }, fn);
397 }
398
399 var deprecations = {};
400
401 function deprecateSimple(name, msg) {
402 if (hooks.deprecationHandler != null) {
403 hooks.deprecationHandler(name, msg);
404 }
405 if (!deprecations[name]) {
406 warn(msg);
407 deprecations[name] = true;
408 }
409 }
410
411 hooks.suppressDeprecationWarnings = false;
412 hooks.deprecationHandler = null;
413
414 function isFunction(input) {
415 return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
416 }
417
418 function set (config) {
419 var prop, i;
420 for (i in config) {
421 prop = config[i];
422 if (isFunction(prop)) {
423 this[i] = prop;
424 } else {
425 this['_' + i] = prop;
426 }
427 }
428 this._config = config;
429 // Lenient ordinal parsing accepts just a number in addition to
430 // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
431 // TODO: Remove "ordinalParse" fallback in next major release.
432 this._dayOfMonthOrdinalParseLenient = new RegExp(
433 (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
434 '|' + (/\d{1,2}/).source);
435 }
436
437 function mergeConfigs(parentConfig, childConfig) {
438 var res = extend({}, parentConfig), prop;
439 for (prop in childConfig) {
440 if (hasOwnProp(childConfig, prop)) {
441 if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
442 res[prop] = {};
443 extend(res[prop], parentConfig[prop]);
444 extend(res[prop], childConfig[prop]);
445 } else if (childConfig[prop] != null) {
446 res[prop] = childConfig[prop];
447 } else {
448 delete res[prop];
449 }
450 }
451 }
452 for (prop in parentConfig) {
453 if (hasOwnProp(parentConfig, prop) &&
454 !hasOwnProp(childConfig, prop) &&
455 isObject(parentConfig[prop])) {
456 // make sure changes to properties don't modify parent config
457 res[prop] = extend({}, res[prop]);
458 }
459 }
460 return res;
461 }
462
463 function Locale(config) {
464 if (config != null) {
465 this.set(config);
466 }
467 }
468
469 var keys;
470
471 if (Object.keys) {
472 keys = Object.keys;
473 } else {
474 keys = function (obj) {
475 var i, res = [];
476 for (i in obj) {
477 if (hasOwnProp(obj, i)) {
478 res.push(i);
479 }
480 }
481 return res;
482 };
483 }
484
485 var defaultCalendar = {
486 sameDay : '[Today at] LT',
487 nextDay : '[Tomorrow at] LT',
488 nextWeek : 'dddd [at] LT',
489 lastDay : '[Yesterday at] LT',
490 lastWeek : '[Last] dddd [at] LT',
491 sameElse : 'L'
492 };
493
494 function calendar (key, mom, now) {
495 var output = this._calendar[key] || this._calendar['sameElse'];
496 return isFunction(output) ? output.call(mom, now) : output;
497 }
498
499 var defaultLongDateFormat = {
500 LTS : 'h:mm:ss A',
501 LT : 'h:mm A',
502 L : 'MM/DD/YYYY',
503 LL : 'MMMM D, YYYY',
504 LLL : 'MMMM D, YYYY h:mm A',
505 LLLL : 'dddd, MMMM D, YYYY h:mm A'
506 };
507
508 function longDateFormat (key) {
509 var format = this._longDateFormat[key],
510 formatUpper = this._longDateFormat[key.toUpperCase()];
511
512 if (format || !formatUpper) {
513 return format;
514 }
515
516 this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
517 return val.slice(1);
518 });
519
520 return this._longDateFormat[key];
521 }
522
523 var defaultInvalidDate = 'Invalid date';
524
525 function invalidDate () {
526 return this._invalidDate;
527 }
528
529 var defaultOrdinal = '%d';
530 var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
531
532 function ordinal (number) {
533 return this._ordinal.replace('%d', number);
534 }
535
536 var defaultRelativeTime = {
537 future : 'in %s',
538 past : '%s ago',
539 s : 'a few seconds',
540 ss : '%d seconds',
541 m : 'a minute',
542 mm : '%d minutes',
543 h : 'an hour',
544 hh : '%d hours',
545 d : 'a day',
546 dd : '%d days',
547 M : 'a month',
548 MM : '%d months',
549 y : 'a year',
550 yy : '%d years'
551 };
552
553 function relativeTime (number, withoutSuffix, string, isFuture) {
554 var output = this._relativeTime[string];
555 return (isFunction(output)) ?
556 output(number, withoutSuffix, string, isFuture) :
557 output.replace(/%d/i, number);
558 }
559
560 function pastFuture (diff, output) {
561 var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
562 return isFunction(format) ? format(output) : format.replace(/%s/i, output);
563 }
564
565 var aliases = {};
566
567 function addUnitAlias (unit, shorthand) {
568 var lowerCase = unit.toLowerCase();
569 aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
570 }
571
572 function normalizeUnits(units) {
573 return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
574 }
575
576 function normalizeObjectUnits(inputObject) {
577 var normalizedInput = {},
578 normalizedProp,
579 prop;
580
581 for (prop in inputObject) {
582 if (hasOwnProp(inputObject, prop)) {
583 normalizedProp = normalizeUnits(prop);
584 if (normalizedProp) {
585 normalizedInput[normalizedProp] = inputObject[prop];
586 }
587 }
588 }
589
590 return normalizedInput;
591 }
592
593 var priorities = {};
594
595 function addUnitPriority(unit, priority) {
596 priorities[unit] = priority;
597 }
598
599 function getPrioritizedUnits(unitsObj) {
600 var units = [];
601 for (var u in unitsObj) {
602 units.push({unit: u, priority: priorities[u]});
603 }
604 units.sort(function (a, b) {
605 return a.priority - b.priority;
606 });
607 return units;
608 }
609
610 function zeroFill(number, targetLength, forceSign) {
611 var absNumber = '' + Math.abs(number),
612 zerosToFill = targetLength - absNumber.length,
613 sign = number >= 0;
614 return (sign ? (forceSign ? '+' : '') : '-') +
615 Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
616 }
617
618 var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
619
620 var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
621
622 var formatFunctions = {};
623
624 var formatTokenFunctions = {};
625
626 // token: 'M'
627 // padded: ['MM', 2]
628 // ordinal: 'Mo'
629 // callback: function () { this.month() + 1 }
630 function addFormatToken (token, padded, ordinal, callback) {
631 var func = callback;
632 if (typeof callback === 'string') {
633 func = function () {
634 return this[callback]();
635 };
636 }
637 if (token) {
638 formatTokenFunctions[token] = func;
639 }
640 if (padded) {
641 formatTokenFunctions[padded[0]] = function () {
642 return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
643 };
644 }
645 if (ordinal) {
646 formatTokenFunctions[ordinal] = function () {
647 return this.localeData().ordinal(func.apply(this, arguments), token);
648 };
649 }
650 }
651
652 function removeFormattingTokens(input) {
653 if (input.match(/\[[\s\S]/)) {
654 return input.replace(/^\[|\]$/g, '');
655 }
656 return input.replace(/\\/g, '');
657 }
658
659 function makeFormatFunction(format) {
660 var array = format.match(formattingTokens), i, length;
661
662 for (i = 0, length = array.length; i < length; i++) {
663 if (formatTokenFunctions[array[i]]) {
664 array[i] = formatTokenFunctions[array[i]];
665 } else {
666 array[i] = removeFormattingTokens(array[i]);
667 }
668 }
669
670 return function (mom) {
671 var output = '', i;
672 for (i = 0; i < length; i++) {
673 output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
674 }
675 return output;
676 };
677 }
678
679 // format date using native date object
680 function formatMoment(m, format) {
681 if (!m.isValid()) {
682 return m.localeData().invalidDate();
683 }
684
685 format = expandFormat(format, m.localeData());
686 formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
687
688 return formatFunctions[format](m);
689 }
690
691 function expandFormat(format, locale) {
692 var i = 5;
693
694 function replaceLongDateFormatTokens(input) {
695 return locale.longDateFormat(input) || input;
696 }
697
698 localFormattingTokens.lastIndex = 0;
699 while (i >= 0 && localFormattingTokens.test(format)) {
700 format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
701 localFormattingTokens.lastIndex = 0;
702 i -= 1;
703 }
704
705 return format;
706 }
707
708 var match1 = /\d/; // 0 - 9
709 var match2 = /\d\d/; // 00 - 99
710 var match3 = /\d{3}/; // 000 - 999
711 var match4 = /\d{4}/; // 0000 - 9999
712 var match6 = /[+-]?\d{6}/; // -999999 - 999999
713 var match1to2 = /\d\d?/; // 0 - 99
714 var match3to4 = /\d\d\d\d?/; // 999 - 9999
715 var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999
716 var match1to3 = /\d{1,3}/; // 0 - 999
717 var match1to4 = /\d{1,4}/; // 0 - 9999
718 var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
719
720 var matchUnsigned = /\d+/; // 0 - inf
721 var matchSigned = /[+-]?\d+/; // -inf - inf
722
723 var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
724 var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
725
726 var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
727
728 // any word (or two) characters or numbers including two/three word month in arabic.
729 // includes scottish gaelic two word and hyphenated months
730 var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;
731
732 var regexes = {};
733
734 function addRegexToken (token, regex, strictRegex) {
735 regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
736 return (isStrict && strictRegex) ? strictRegex : regex;
737 };
738 }
739
740 function getParseRegexForToken (token, config) {
741 if (!hasOwnProp(regexes, token)) {
742 return new RegExp(unescapeFormat(token));
743 }
744
745 return regexes[token](config._strict, config._locale);
746 }
747
748 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
749 function unescapeFormat(s) {
750 return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
751 return p1 || p2 || p3 || p4;
752 }));
753 }
754
755 function regexEscape(s) {
756 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
757 }
758
759 var tokens = {};
760
761 function addParseToken (token, callback) {
762 var i, func = callback;
763 if (typeof token === 'string') {
764 token = [token];
765 }
766 if (isNumber(callback)) {
767 func = function (input, array) {
768 array[callback] = toInt(input);
769 };
770 }
771 for (i = 0; i < token.length; i++) {
772 tokens[token[i]] = func;
773 }
774 }
775
776 function addWeekParseToken (token, callback) {
777 addParseToken(token, function (input, array, config, token) {
778 config._w = config._w || {};
779 callback(input, config._w, config, token);
780 });
781 }
782
783 function addTimeToArrayFromToken(token, input, config) {
784 if (input != null && hasOwnProp(tokens, token)) {
785 tokens[token](input, config._a, config, token);
786 }
787 }
788
789 var YEAR = 0;
790 var MONTH = 1;
791 var DATE = 2;
792 var HOUR = 3;
793 var MINUTE = 4;
794 var SECOND = 5;
795 var MILLISECOND = 6;
796 var WEEK = 7;
797 var WEEKDAY = 8;
798
799 // FORMATTING
800
801 addFormatToken('Y', 0, 0, function () {
802 var y = this.year();
803 return y <= 9999 ? '' + y : '+' + y;
804 });
805
806 addFormatToken(0, ['YY', 2], 0, function () {
807 return this.year() % 100;
808 });
809
810 addFormatToken(0, ['YYYY', 4], 0, 'year');
811 addFormatToken(0, ['YYYYY', 5], 0, 'year');
812 addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
813
814 // ALIASES
815
816 addUnitAlias('year', 'y');
817
818 // PRIORITIES
819
820 addUnitPriority('year', 1);
821
822 // PARSING
823
824 addRegexToken('Y', matchSigned);
825 addRegexToken('YY', match1to2, match2);
826 addRegexToken('YYYY', match1to4, match4);
827 addRegexToken('YYYYY', match1to6, match6);
828 addRegexToken('YYYYYY', match1to6, match6);
829
830 addParseToken(['YYYYY', 'YYYYYY'], YEAR);
831 addParseToken('YYYY', function (input, array) {
832 array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
833 });
834 addParseToken('YY', function (input, array) {
835 array[YEAR] = hooks.parseTwoDigitYear(input);
836 });
837 addParseToken('Y', function (input, array) {
838 array[YEAR] = parseInt(input, 10);
839 });
840
841 // HELPERS
842
843 function daysInYear(year) {
844 return isLeapYear(year) ? 366 : 365;
845 }
846
847 function isLeapYear(year) {
848 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
849 }
850
851 // HOOKS
852
853 hooks.parseTwoDigitYear = function (input) {
854 return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
855 };
856
857 // MOMENTS
858
859 var getSetYear = makeGetSet('FullYear', true);
860
861 function getIsLeapYear () {
862 return isLeapYear(this.year());
863 }
864
865 function makeGetSet (unit, keepTime) {
866 return function (value) {
867 if (value != null) {
868 set$1(this, unit, value);
869 hooks.updateOffset(this, keepTime);
870 return this;
871 } else {
872 return get(this, unit);
873 }
874 };
875 }
876
877 function get (mom, unit) {
878 return mom.isValid() ?
879 mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
880 }
881
882 function set$1 (mom, unit, value) {
883 if (mom.isValid() && !isNaN(value)) {
884 if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
885 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));
886 }
887 else {
888 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
889 }
890 }
891 }
892
893 // MOMENTS
894
895 function stringGet (units) {
896 units = normalizeUnits(units);
897 if (isFunction(this[units])) {
898 return this[units]();
899 }
900 return this;
901 }
902
903
904 function stringSet (units, value) {
905 if (typeof units === 'object') {
906 units = normalizeObjectUnits(units);
907 var prioritized = getPrioritizedUnits(units);
908 for (var i = 0; i < prioritized.length; i++) {
909 this[prioritized[i].unit](units[prioritized[i].unit]);
910 }
911 } else {
912 units = normalizeUnits(units);
913 if (isFunction(this[units])) {
914 return this[units](value);
915 }
916 }
917 return this;
918 }
919
920 function mod(n, x) {
921 return ((n % x) + x) % x;
922 }
923
924 var indexOf;
925
926 if (Array.prototype.indexOf) {
927 indexOf = Array.prototype.indexOf;
928 } else {
929 indexOf = function (o) {
930 // I know
931 var i;
932 for (i = 0; i < this.length; ++i) {
933 if (this[i] === o) {
934 return i;
935 }
936 }
937 return -1;
938 };
939 }
940
941 function daysInMonth(year, month) {
942 if (isNaN(year) || isNaN(month)) {
943 return NaN;
944 }
945 var modMonth = mod(month, 12);
946 year += (month - modMonth) / 12;
947 return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
948 }
949
950 // FORMATTING
951
952 addFormatToken('M', ['MM', 2], 'Mo', function () {
953 return this.month() + 1;
954 });
955
956 addFormatToken('MMM', 0, 0, function (format) {
957 return this.localeData().monthsShort(this, format);
958 });
959
960 addFormatToken('MMMM', 0, 0, function (format) {
961 return this.localeData().months(this, format);
962 });
963
964 // ALIASES
965
966 addUnitAlias('month', 'M');
967
968 // PRIORITY
969
970 addUnitPriority('month', 8);
971
972 // PARSING
973
974 addRegexToken('M', match1to2);
975 addRegexToken('MM', match1to2, match2);
976 addRegexToken('MMM', function (isStrict, locale) {
977 return locale.monthsShortRegex(isStrict);
978 });
979 addRegexToken('MMMM', function (isStrict, locale) {
980 return locale.monthsRegex(isStrict);
981 });
982
983 addParseToken(['M', 'MM'], function (input, array) {
984 array[MONTH] = toInt(input) - 1;
985 });
986
987 addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
988 var month = config._locale.monthsParse(input, token, config._strict);
989 // if we didn't find a month name, mark the date as invalid.
990 if (month != null) {
991 array[MONTH] = month;
992 } else {
993 getParsingFlags(config).invalidMonth = input;
994 }
995 });
996
997 // LOCALES
998
999 var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
1000 var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
1001 function localeMonths (m, format) {
1002 if (!m) {
1003 return isArray(this._months) ? this._months :
1004 this._months['standalone'];
1005 }
1006 return isArray(this._months) ? this._months[m.month()] :
1007 this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
1008 }
1009
1010 var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
1011 function localeMonthsShort (m, format) {
1012 if (!m) {
1013 return isArray(this._monthsShort) ? this._monthsShort :
1014 this._monthsShort['standalone'];
1015 }
1016 return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
1017 this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
1018 }
1019
1020 function handleStrictParse(monthName, format, strict) {
1021 var i, ii, mom, llc = monthName.toLocaleLowerCase();
1022 if (!this._monthsParse) {
1023 // this is not used
1024 this._monthsParse = [];
1025 this._longMonthsParse = [];
1026 this._shortMonthsParse = [];
1027 for (i = 0; i < 12; ++i) {
1028 mom = createUTC([2000, i]);
1029 this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
1030 this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
1031 }
1032 }
1033
1034 if (strict) {
1035 if (format === 'MMM') {
1036 ii = indexOf.call(this._shortMonthsParse, llc);
1037 return ii !== -1 ? ii : null;
1038 } else {
1039 ii = indexOf.call(this._longMonthsParse, llc);
1040 return ii !== -1 ? ii : null;
1041 }
1042 } else {
1043 if (format === 'MMM') {
1044 ii = indexOf.call(this._shortMonthsParse, llc);
1045 if (ii !== -1) {
1046 return ii;
1047 }
1048 ii = indexOf.call(this._longMonthsParse, llc);
1049 return ii !== -1 ? ii : null;
1050 } else {
1051 ii = indexOf.call(this._longMonthsParse, llc);
1052 if (ii !== -1) {
1053 return ii;
1054 }
1055 ii = indexOf.call(this._shortMonthsParse, llc);
1056 return ii !== -1 ? ii : null;
1057 }
1058 }
1059 }
1060
1061 function localeMonthsParse (monthName, format, strict) {
1062 var i, mom, regex;
1063
1064 if (this._monthsParseExact) {
1065 return handleStrictParse.call(this, monthName, format, strict);
1066 }
1067
1068 if (!this._monthsParse) {
1069 this._monthsParse = [];
1070 this._longMonthsParse = [];
1071 this._shortMonthsParse = [];
1072 }
1073
1074 // TODO: add sorting
1075 // Sorting makes sure if one month (or abbr) is a prefix of another
1076 // see sorting in computeMonthsParse
1077 for (i = 0; i < 12; i++) {
1078 // make the regex if we don't have it already
1079 mom = createUTC([2000, i]);
1080 if (strict && !this._longMonthsParse[i]) {
1081 this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
1082 this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
1083 }
1084 if (!strict && !this._monthsParse[i]) {
1085 regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
1086 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
1087 }
1088 // test the regex
1089 if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
1090 return i;
1091 } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
1092 return i;
1093 } else if (!strict && this._monthsParse[i].test(monthName)) {
1094 return i;
1095 }
1096 }
1097 }
1098
1099 // MOMENTS
1100
1101 function setMonth (mom, value) {
1102 var dayOfMonth;
1103
1104 if (!mom.isValid()) {
1105 // No op
1106 return mom;
1107 }
1108
1109 if (typeof value === 'string') {
1110 if (/^\d+$/.test(value)) {
1111 value = toInt(value);
1112 } else {
1113 value = mom.localeData().monthsParse(value);
1114 // TODO: Another silent failure?
1115 if (!isNumber(value)) {
1116 return mom;
1117 }
1118 }
1119 }
1120
1121 dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
1122 mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
1123 return mom;
1124 }
1125
1126 function getSetMonth (value) {
1127 if (value != null) {
1128 setMonth(this, value);
1129 hooks.updateOffset(this, true);
1130 return this;
1131 } else {
1132 return get(this, 'Month');
1133 }
1134 }
1135
1136 function getDaysInMonth () {
1137 return daysInMonth(this.year(), this.month());
1138 }
1139
1140 var defaultMonthsShortRegex = matchWord;
1141 function monthsShortRegex (isStrict) {
1142 if (this._monthsParseExact) {
1143 if (!hasOwnProp(this, '_monthsRegex')) {
1144 computeMonthsParse.call(this);
1145 }
1146 if (isStrict) {
1147 return this._monthsShortStrictRegex;
1148 } else {
1149 return this._monthsShortRegex;
1150 }
1151 } else {
1152 if (!hasOwnProp(this, '_monthsShortRegex')) {
1153 this._monthsShortRegex = defaultMonthsShortRegex;
1154 }
1155 return this._monthsShortStrictRegex && isStrict ?
1156 this._monthsShortStrictRegex : this._monthsShortRegex;
1157 }
1158 }
1159
1160 var defaultMonthsRegex = matchWord;
1161 function monthsRegex (isStrict) {
1162 if (this._monthsParseExact) {
1163 if (!hasOwnProp(this, '_monthsRegex')) {
1164 computeMonthsParse.call(this);
1165 }
1166 if (isStrict) {
1167 return this._monthsStrictRegex;
1168 } else {
1169 return this._monthsRegex;
1170 }
1171 } else {
1172 if (!hasOwnProp(this, '_monthsRegex')) {
1173 this._monthsRegex = defaultMonthsRegex;
1174 }
1175 return this._monthsStrictRegex && isStrict ?
1176 this._monthsStrictRegex : this._monthsRegex;
1177 }
1178 }
1179
1180 function computeMonthsParse () {
1181 function cmpLenRev(a, b) {
1182 return b.length - a.length;
1183 }
1184
1185 var shortPieces = [], longPieces = [], mixedPieces = [],
1186 i, mom;
1187 for (i = 0; i < 12; i++) {
1188 // make the regex if we don't have it already
1189 mom = createUTC([2000, i]);
1190 shortPieces.push(this.monthsShort(mom, ''));
1191 longPieces.push(this.months(mom, ''));
1192 mixedPieces.push(this.months(mom, ''));
1193 mixedPieces.push(this.monthsShort(mom, ''));
1194 }
1195 // Sorting makes sure if one month (or abbr) is a prefix of another it
1196 // will match the longer piece.
1197 shortPieces.sort(cmpLenRev);
1198 longPieces.sort(cmpLenRev);
1199 mixedPieces.sort(cmpLenRev);
1200 for (i = 0; i < 12; i++) {
1201 shortPieces[i] = regexEscape(shortPieces[i]);
1202 longPieces[i] = regexEscape(longPieces[i]);
1203 }
1204 for (i = 0; i < 24; i++) {
1205 mixedPieces[i] = regexEscape(mixedPieces[i]);
1206 }
1207
1208 this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1209 this._monthsShortRegex = this._monthsRegex;
1210 this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1211 this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1212 }
1213
1214 function createDate (y, m, d, h, M, s, ms) {
1215 // can't just apply() to create a date:
1216 // https://stackoverflow.com/q/181348
1217 var date = new Date(y, m, d, h, M, s, ms);
1218
1219 // the date constructor remaps years 0-99 to 1900-1999
1220 if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
1221 date.setFullYear(y);
1222 }
1223 return date;
1224 }
1225
1226 function createUTCDate (y) {
1227 var date = new Date(Date.UTC.apply(null, arguments));
1228
1229 // the Date.UTC function remaps years 0-99 to 1900-1999
1230 if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
1231 date.setUTCFullYear(y);
1232 }
1233 return date;
1234 }
1235
1236 // start-of-first-week - start-of-year
1237 function firstWeekOffset(year, dow, doy) {
1238 var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1239 fwd = 7 + dow - doy,
1240 // first-week day local weekday -- which local weekday is fwd
1241 fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1242
1243 return -fwdlw + fwd - 1;
1244 }
1245
1246 // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1247 function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1248 var localWeekday = (7 + weekday - dow) % 7,
1249 weekOffset = firstWeekOffset(year, dow, doy),
1250 dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1251 resYear, resDayOfYear;
1252
1253 if (dayOfYear <= 0) {
1254 resYear = year - 1;
1255 resDayOfYear = daysInYear(resYear) + dayOfYear;
1256 } else if (dayOfYear > daysInYear(year)) {
1257 resYear = year + 1;
1258 resDayOfYear = dayOfYear - daysInYear(year);
1259 } else {
1260 resYear = year;
1261 resDayOfYear = dayOfYear;
1262 }
1263
1264 return {
1265 year: resYear,
1266 dayOfYear: resDayOfYear
1267 };
1268 }
1269
1270 function weekOfYear(mom, dow, doy) {
1271 var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1272 week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1273 resWeek, resYear;
1274
1275 if (week < 1) {
1276 resYear = mom.year() - 1;
1277 resWeek = week + weeksInYear(resYear, dow, doy);
1278 } else if (week > weeksInYear(mom.year(), dow, doy)) {
1279 resWeek = week - weeksInYear(mom.year(), dow, doy);
1280 resYear = mom.year() + 1;
1281 } else {
1282 resYear = mom.year();
1283 resWeek = week;
1284 }
1285
1286 return {
1287 week: resWeek,
1288 year: resYear
1289 };
1290 }
1291
1292 function weeksInYear(year, dow, doy) {
1293 var weekOffset = firstWeekOffset(year, dow, doy),
1294 weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1295 return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1296 }
1297
1298 // FORMATTING
1299
1300 addFormatToken('w', ['ww', 2], 'wo', 'week');
1301 addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1302
1303 // ALIASES
1304
1305 addUnitAlias('week', 'w');
1306 addUnitAlias('isoWeek', 'W');
1307
1308 // PRIORITIES
1309
1310 addUnitPriority('week', 5);
1311 addUnitPriority('isoWeek', 5);
1312
1313 // PARSING
1314
1315 addRegexToken('w', match1to2);
1316 addRegexToken('ww', match1to2, match2);
1317 addRegexToken('W', match1to2);
1318 addRegexToken('WW', match1to2, match2);
1319
1320 addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
1321 week[token.substr(0, 1)] = toInt(input);
1322 });
1323
1324 // HELPERS
1325
1326 // LOCALES
1327
1328 function localeWeek (mom) {
1329 return weekOfYear(mom, this._week.dow, this._week.doy).week;
1330 }
1331
1332 var defaultLocaleWeek = {
1333 dow : 0, // Sunday is the first day of the week.
1334 doy : 6 // The week that contains Jan 1st is the first week of the year.
1335 };
1336
1337 function localeFirstDayOfWeek () {
1338 return this._week.dow;
1339 }
1340
1341 function localeFirstDayOfYear () {
1342 return this._week.doy;
1343 }
1344
1345 // MOMENTS
1346
1347 function getSetWeek (input) {
1348 var week = this.localeData().week(this);
1349 return input == null ? week : this.add((input - week) * 7, 'd');
1350 }
1351
1352 function getSetISOWeek (input) {
1353 var week = weekOfYear(this, 1, 4).week;
1354 return input == null ? week : this.add((input - week) * 7, 'd');
1355 }
1356
1357 // FORMATTING
1358
1359 addFormatToken('d', 0, 'do', 'day');
1360
1361 addFormatToken('dd', 0, 0, function (format) {
1362 return this.localeData().weekdaysMin(this, format);
1363 });
1364
1365 addFormatToken('ddd', 0, 0, function (format) {
1366 return this.localeData().weekdaysShort(this, format);
1367 });
1368
1369 addFormatToken('dddd', 0, 0, function (format) {
1370 return this.localeData().weekdays(this, format);
1371 });
1372
1373 addFormatToken('e', 0, 0, 'weekday');
1374 addFormatToken('E', 0, 0, 'isoWeekday');
1375
1376 // ALIASES
1377
1378 addUnitAlias('day', 'd');
1379 addUnitAlias('weekday', 'e');
1380 addUnitAlias('isoWeekday', 'E');
1381
1382 // PRIORITY
1383 addUnitPriority('day', 11);
1384 addUnitPriority('weekday', 11);
1385 addUnitPriority('isoWeekday', 11);
1386
1387 // PARSING
1388
1389 addRegexToken('d', match1to2);
1390 addRegexToken('e', match1to2);
1391 addRegexToken('E', match1to2);
1392 addRegexToken('dd', function (isStrict, locale) {
1393 return locale.weekdaysMinRegex(isStrict);
1394 });
1395 addRegexToken('ddd', function (isStrict, locale) {
1396 return locale.weekdaysShortRegex(isStrict);
1397 });
1398 addRegexToken('dddd', function (isStrict, locale) {
1399 return locale.weekdaysRegex(isStrict);
1400 });
1401
1402 addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1403 var weekday = config._locale.weekdaysParse(input, token, config._strict);
1404 // if we didn't get a weekday name, mark the date as invalid
1405 if (weekday != null) {
1406 week.d = weekday;
1407 } else {
1408 getParsingFlags(config).invalidWeekday = input;
1409 }
1410 });
1411
1412 addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1413 week[token] = toInt(input);
1414 });
1415
1416 // HELPERS
1417
1418 function parseWeekday(input, locale) {
1419 if (typeof input !== 'string') {
1420 return input;
1421 }
1422
1423 if (!isNaN(input)) {
1424 return parseInt(input, 10);
1425 }
1426
1427 input = locale.weekdaysParse(input);
1428 if (typeof input === 'number') {
1429 return input;
1430 }
1431
1432 return null;
1433 }
1434
1435 function parseIsoWeekday(input, locale) {
1436 if (typeof input === 'string') {
1437 return locale.weekdaysParse(input) % 7 || 7;
1438 }
1439 return isNaN(input) ? null : input;
1440 }
1441
1442 // LOCALES
1443
1444 var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
1445 function localeWeekdays (m, format) {
1446 if (!m) {
1447 return isArray(this._weekdays) ? this._weekdays :
1448 this._weekdays['standalone'];
1449 }
1450 return isArray(this._weekdays) ? this._weekdays[m.day()] :
1451 this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
1452 }
1453
1454 var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
1455 function localeWeekdaysShort (m) {
1456 return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
1457 }
1458
1459 var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
1460 function localeWeekdaysMin (m) {
1461 return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
1462 }
1463
1464 function handleStrictParse$1(weekdayName, format, strict) {
1465 var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
1466 if (!this._weekdaysParse) {
1467 this._weekdaysParse = [];
1468 this._shortWeekdaysParse = [];
1469 this._minWeekdaysParse = [];
1470
1471 for (i = 0; i < 7; ++i) {
1472 mom = createUTC([2000, 1]).day(i);
1473 this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
1474 this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
1475 this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1476 }
1477 }
1478
1479 if (strict) {
1480 if (format === 'dddd') {
1481 ii = indexOf.call(this._weekdaysParse, llc);
1482 return ii !== -1 ? ii : null;
1483 } else if (format === 'ddd') {
1484 ii = indexOf.call(this._shortWeekdaysParse, llc);
1485 return ii !== -1 ? ii : null;
1486 } else {
1487 ii = indexOf.call(this._minWeekdaysParse, llc);
1488 return ii !== -1 ? ii : null;
1489 }
1490 } else {
1491 if (format === 'dddd') {
1492 ii = indexOf.call(this._weekdaysParse, llc);
1493 if (ii !== -1) {
1494 return ii;
1495 }
1496 ii = indexOf.call(this._shortWeekdaysParse, llc);
1497 if (ii !== -1) {
1498 return ii;
1499 }
1500 ii = indexOf.call(this._minWeekdaysParse, llc);
1501 return ii !== -1 ? ii : null;
1502 } else if (format === 'ddd') {
1503 ii = indexOf.call(this._shortWeekdaysParse, llc);
1504 if (ii !== -1) {
1505 return ii;
1506 }
1507 ii = indexOf.call(this._weekdaysParse, llc);
1508 if (ii !== -1) {
1509 return ii;
1510 }
1511 ii = indexOf.call(this._minWeekdaysParse, llc);
1512 return ii !== -1 ? ii : null;
1513 } else {
1514 ii = indexOf.call(this._minWeekdaysParse, llc);
1515 if (ii !== -1) {
1516 return ii;
1517 }
1518 ii = indexOf.call(this._weekdaysParse, llc);
1519 if (ii !== -1) {
1520 return ii;
1521 }
1522 ii = indexOf.call(this._shortWeekdaysParse, llc);
1523 return ii !== -1 ? ii : null;
1524 }
1525 }
1526 }
1527
1528 function localeWeekdaysParse (weekdayName, format, strict) {
1529 var i, mom, regex;
1530
1531 if (this._weekdaysParseExact) {
1532 return handleStrictParse$1.call(this, weekdayName, format, strict);
1533 }
1534
1535 if (!this._weekdaysParse) {
1536 this._weekdaysParse = [];
1537 this._minWeekdaysParse = [];
1538 this._shortWeekdaysParse = [];
1539 this._fullWeekdaysParse = [];
1540 }
1541
1542 for (i = 0; i < 7; i++) {
1543 // make the regex if we don't have it already
1544
1545 mom = createUTC([2000, 1]).day(i);
1546 if (strict && !this._fullWeekdaysParse[i]) {
1547 this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');
1548 this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');
1549 this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');
1550 }
1551 if (!this._weekdaysParse[i]) {
1552 regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
1553 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
1554 }
1555 // test the regex
1556 if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
1557 return i;
1558 } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
1559 return i;
1560 } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
1561 return i;
1562 } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
1563 return i;
1564 }
1565 }
1566 }
1567
1568 // MOMENTS
1569
1570 function getSetDayOfWeek (input) {
1571 if (!this.isValid()) {
1572 return input != null ? this : NaN;
1573 }
1574 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1575 if (input != null) {
1576 input = parseWeekday(input, this.localeData());
1577 return this.add(input - day, 'd');
1578 } else {
1579 return day;
1580 }
1581 }
1582
1583 function getSetLocaleDayOfWeek (input) {
1584 if (!this.isValid()) {
1585 return input != null ? this : NaN;
1586 }
1587 var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1588 return input == null ? weekday : this.add(input - weekday, 'd');
1589 }
1590
1591 function getSetISODayOfWeek (input) {
1592 if (!this.isValid()) {
1593 return input != null ? this : NaN;
1594 }
1595
1596 // behaves the same as moment#day except
1597 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1598 // as a setter, sunday should belong to the previous week.
1599
1600 if (input != null) {
1601 var weekday = parseIsoWeekday(input, this.localeData());
1602 return this.day(this.day() % 7 ? weekday : weekday - 7);
1603 } else {
1604 return this.day() || 7;
1605 }
1606 }
1607
1608 var defaultWeekdaysRegex = matchWord;
1609 function weekdaysRegex (isStrict) {
1610 if (this._weekdaysParseExact) {
1611 if (!hasOwnProp(this, '_weekdaysRegex')) {
1612 computeWeekdaysParse.call(this);
1613 }
1614 if (isStrict) {
1615 return this._weekdaysStrictRegex;
1616 } else {
1617 return this._weekdaysRegex;
1618 }
1619 } else {
1620 if (!hasOwnProp(this, '_weekdaysRegex')) {
1621 this._weekdaysRegex = defaultWeekdaysRegex;
1622 }
1623 return this._weekdaysStrictRegex && isStrict ?
1624 this._weekdaysStrictRegex : this._weekdaysRegex;
1625 }
1626 }
1627
1628 var defaultWeekdaysShortRegex = matchWord;
1629 function weekdaysShortRegex (isStrict) {
1630 if (this._weekdaysParseExact) {
1631 if (!hasOwnProp(this, '_weekdaysRegex')) {
1632 computeWeekdaysParse.call(this);
1633 }
1634 if (isStrict) {
1635 return this._weekdaysShortStrictRegex;
1636 } else {
1637 return this._weekdaysShortRegex;
1638 }
1639 } else {
1640 if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1641 this._weekdaysShortRegex = defaultWeekdaysShortRegex;
1642 }
1643 return this._weekdaysShortStrictRegex && isStrict ?
1644 this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
1645 }
1646 }
1647
1648 var defaultWeekdaysMinRegex = matchWord;
1649 function weekdaysMinRegex (isStrict) {
1650 if (this._weekdaysParseExact) {
1651 if (!hasOwnProp(this, '_weekdaysRegex')) {
1652 computeWeekdaysParse.call(this);
1653 }
1654 if (isStrict) {
1655 return this._weekdaysMinStrictRegex;
1656 } else {
1657 return this._weekdaysMinRegex;
1658 }
1659 } else {
1660 if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1661 this._weekdaysMinRegex = defaultWeekdaysMinRegex;
1662 }
1663 return this._weekdaysMinStrictRegex && isStrict ?
1664 this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
1665 }
1666 }
1667
1668
1669 function computeWeekdaysParse () {
1670 function cmpLenRev(a, b) {
1671 return b.length - a.length;
1672 }
1673
1674 var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
1675 i, mom, minp, shortp, longp;
1676 for (i = 0; i < 7; i++) {
1677 // make the regex if we don't have it already
1678 mom = createUTC([2000, 1]).day(i);
1679 minp = this.weekdaysMin(mom, '');
1680 shortp = this.weekdaysShort(mom, '');
1681 longp = this.weekdays(mom, '');
1682 minPieces.push(minp);
1683 shortPieces.push(shortp);
1684 longPieces.push(longp);
1685 mixedPieces.push(minp);
1686 mixedPieces.push(shortp);
1687 mixedPieces.push(longp);
1688 }
1689 // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1690 // will match the longer piece.
1691 minPieces.sort(cmpLenRev);
1692 shortPieces.sort(cmpLenRev);
1693 longPieces.sort(cmpLenRev);
1694 mixedPieces.sort(cmpLenRev);
1695 for (i = 0; i < 7; i++) {
1696 shortPieces[i] = regexEscape(shortPieces[i]);
1697 longPieces[i] = regexEscape(longPieces[i]);
1698 mixedPieces[i] = regexEscape(mixedPieces[i]);
1699 }
1700
1701 this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1702 this._weekdaysShortRegex = this._weekdaysRegex;
1703 this._weekdaysMinRegex = this._weekdaysRegex;
1704
1705 this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1706 this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1707 this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
1708 }
1709
1710 // FORMATTING
1711
1712 function hFormat() {
1713 return this.hours() % 12 || 12;
1714 }
1715
1716 function kFormat() {
1717 return this.hours() || 24;
1718 }
1719
1720 addFormatToken('H', ['HH', 2], 0, 'hour');
1721 addFormatToken('h', ['hh', 2], 0, hFormat);
1722 addFormatToken('k', ['kk', 2], 0, kFormat);
1723
1724 addFormatToken('hmm', 0, 0, function () {
1725 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
1726 });
1727
1728 addFormatToken('hmmss', 0, 0, function () {
1729 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
1730 zeroFill(this.seconds(), 2);
1731 });
1732
1733 addFormatToken('Hmm', 0, 0, function () {
1734 return '' + this.hours() + zeroFill(this.minutes(), 2);
1735 });
1736
1737 addFormatToken('Hmmss', 0, 0, function () {
1738 return '' + this.hours() + zeroFill(this.minutes(), 2) +
1739 zeroFill(this.seconds(), 2);
1740 });
1741
1742 function meridiem (token, lowercase) {
1743 addFormatToken(token, 0, 0, function () {
1744 return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
1745 });
1746 }
1747
1748 meridiem('a', true);
1749 meridiem('A', false);
1750
1751 // ALIASES
1752
1753 addUnitAlias('hour', 'h');
1754
1755 // PRIORITY
1756 addUnitPriority('hour', 13);
1757
1758 // PARSING
1759
1760 function matchMeridiem (isStrict, locale) {
1761 return locale._meridiemParse;
1762 }
1763
1764 addRegexToken('a', matchMeridiem);
1765 addRegexToken('A', matchMeridiem);
1766 addRegexToken('H', match1to2);
1767 addRegexToken('h', match1to2);
1768 addRegexToken('k', match1to2);
1769 addRegexToken('HH', match1to2, match2);
1770 addRegexToken('hh', match1to2, match2);
1771 addRegexToken('kk', match1to2, match2);
1772
1773 addRegexToken('hmm', match3to4);
1774 addRegexToken('hmmss', match5to6);
1775 addRegexToken('Hmm', match3to4);
1776 addRegexToken('Hmmss', match5to6);
1777
1778 addParseToken(['H', 'HH'], HOUR);
1779 addParseToken(['k', 'kk'], function (input, array, config) {
1780 var kInput = toInt(input);
1781 array[HOUR] = kInput === 24 ? 0 : kInput;
1782 });
1783 addParseToken(['a', 'A'], function (input, array, config) {
1784 config._isPm = config._locale.isPM(input);
1785 config._meridiem = input;
1786 });
1787 addParseToken(['h', 'hh'], function (input, array, config) {
1788 array[HOUR] = toInt(input);
1789 getParsingFlags(config).bigHour = true;
1790 });
1791 addParseToken('hmm', function (input, array, config) {
1792 var pos = input.length - 2;
1793 array[HOUR] = toInt(input.substr(0, pos));
1794 array[MINUTE] = toInt(input.substr(pos));
1795 getParsingFlags(config).bigHour = true;
1796 });
1797 addParseToken('hmmss', function (input, array, config) {
1798 var pos1 = input.length - 4;
1799 var pos2 = input.length - 2;
1800 array[HOUR] = toInt(input.substr(0, pos1));
1801 array[MINUTE] = toInt(input.substr(pos1, 2));
1802 array[SECOND] = toInt(input.substr(pos2));
1803 getParsingFlags(config).bigHour = true;
1804 });
1805 addParseToken('Hmm', function (input, array, config) {
1806 var pos = input.length - 2;
1807 array[HOUR] = toInt(input.substr(0, pos));
1808 array[MINUTE] = toInt(input.substr(pos));
1809 });
1810 addParseToken('Hmmss', function (input, array, config) {
1811 var pos1 = input.length - 4;
1812 var pos2 = input.length - 2;
1813 array[HOUR] = toInt(input.substr(0, pos1));
1814 array[MINUTE] = toInt(input.substr(pos1, 2));
1815 array[SECOND] = toInt(input.substr(pos2));
1816 });
1817
1818 // LOCALES
1819
1820 function localeIsPM (input) {
1821 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1822 // Using charAt should be more compatible.
1823 return ((input + '').toLowerCase().charAt(0) === 'p');
1824 }
1825
1826 var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
1827 function localeMeridiem (hours, minutes, isLower) {
1828 if (hours > 11) {
1829 return isLower ? 'pm' : 'PM';
1830 } else {
1831 return isLower ? 'am' : 'AM';
1832 }
1833 }
1834
1835
1836 // MOMENTS
1837
1838 // Setting the hour should keep the time, because the user explicitly
1839 // specified which hour they want. So trying to maintain the same hour (in
1840 // a new timezone) makes sense. Adding/subtracting hours does not follow
1841 // this rule.
1842 var getSetHour = makeGetSet('Hours', true);
1843
1844 var baseConfig = {
1845 calendar: defaultCalendar,
1846 longDateFormat: defaultLongDateFormat,
1847 invalidDate: defaultInvalidDate,
1848 ordinal: defaultOrdinal,
1849 dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
1850 relativeTime: defaultRelativeTime,
1851
1852 months: defaultLocaleMonths,
1853 monthsShort: defaultLocaleMonthsShort,
1854
1855 week: defaultLocaleWeek,
1856
1857 weekdays: defaultLocaleWeekdays,
1858 weekdaysMin: defaultLocaleWeekdaysMin,
1859 weekdaysShort: defaultLocaleWeekdaysShort,
1860
1861 meridiemParse: defaultLocaleMeridiemParse
1862 };
1863
1864 // internal storage for locale config files
1865 var locales = {};
1866 var localeFamilies = {};
1867 var globalLocale;
1868
1869 function normalizeLocale(key) {
1870 return key ? key.toLowerCase().replace('_', '-') : key;
1871 }
1872
1873 // pick the locale from the array
1874 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
1875 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
1876 function chooseLocale(names) {
1877 var i = 0, j, next, locale, split;
1878
1879 while (i < names.length) {
1880 split = normalizeLocale(names[i]).split('-');
1881 j = split.length;
1882 next = normalizeLocale(names[i + 1]);
1883 next = next ? next.split('-') : null;
1884 while (j > 0) {
1885 locale = loadLocale(split.slice(0, j).join('-'));
1886 if (locale) {
1887 return locale;
1888 }
1889 if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
1890 //the next array item is better than a shallower substring of this one
1891 break;
1892 }
1893 j--;
1894 }
1895 i++;
1896 }
1897 return globalLocale;
1898 }
1899
1900 function loadLocale(name) {
1901 var oldLocale = null;
1902 // TODO: Find a better way to register and load all the locales in Node
1903 if (!locales[name] && (typeof module !== 'undefined') &&
1904 module && module.exports) {
1905 try {
1906 oldLocale = globalLocale._abbr;
1907 var aliasedRequire = require;
1908 __webpack_require__(141)("./" + name);
1909 getSetGlobalLocale(oldLocale);
1910 } catch (e) {}
1911 }
1912 return locales[name];
1913 }
1914
1915 // This function will load locale and then set the global locale. If
1916 // no arguments are passed in, it will simply return the current global
1917 // locale key.
1918 function getSetGlobalLocale (key, values) {
1919 var data;
1920 if (key) {
1921 if (isUndefined(values)) {
1922 data = getLocale(key);
1923 }
1924 else {
1925 data = defineLocale(key, values);
1926 }
1927
1928 if (data) {
1929 // moment.duration._locale = moment._locale = data;
1930 globalLocale = data;
1931 }
1932 else {
1933 if ((typeof console !== 'undefined') && console.warn) {
1934 //warn user if arguments are passed but the locale could not be set
1935 console.warn('Locale ' + key + ' not found. Did you forget to load it?');
1936 }
1937 }
1938 }
1939
1940 return globalLocale._abbr;
1941 }
1942
1943 function defineLocale (name, config) {
1944 if (config !== null) {
1945 var locale, parentConfig = baseConfig;
1946 config.abbr = name;
1947 if (locales[name] != null) {
1948 deprecateSimple('defineLocaleOverride',
1949 'use moment.updateLocale(localeName, config) to change ' +
1950 'an existing locale. moment.defineLocale(localeName, ' +
1951 'config) should only be used for creating a new locale ' +
1952 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
1953 parentConfig = locales[name]._config;
1954 } else if (config.parentLocale != null) {
1955 if (locales[config.parentLocale] != null) {
1956 parentConfig = locales[config.parentLocale]._config;
1957 } else {
1958 locale = loadLocale(config.parentLocale);
1959 if (locale != null) {
1960 parentConfig = locale._config;
1961 } else {
1962 if (!localeFamilies[config.parentLocale]) {
1963 localeFamilies[config.parentLocale] = [];
1964 }
1965 localeFamilies[config.parentLocale].push({
1966 name: name,
1967 config: config
1968 });
1969 return null;
1970 }
1971 }
1972 }
1973 locales[name] = new Locale(mergeConfigs(parentConfig, config));
1974
1975 if (localeFamilies[name]) {
1976 localeFamilies[name].forEach(function (x) {
1977 defineLocale(x.name, x.config);
1978 });
1979 }
1980
1981 // backwards compat for now: also set the locale
1982 // make sure we set the locale AFTER all child locales have been
1983 // created, so we won't end up with the child locale set.
1984 getSetGlobalLocale(name);
1985
1986
1987 return locales[name];
1988 } else {
1989 // useful for testing
1990 delete locales[name];
1991 return null;
1992 }
1993 }
1994
1995 function updateLocale(name, config) {
1996 if (config != null) {
1997 var locale, tmpLocale, parentConfig = baseConfig;
1998 // MERGE
1999 tmpLocale = loadLocale(name);
2000 if (tmpLocale != null) {
2001 parentConfig = tmpLocale._config;
2002 }
2003 config = mergeConfigs(parentConfig, config);
2004 locale = new Locale(config);
2005 locale.parentLocale = locales[name];
2006 locales[name] = locale;
2007
2008 // backwards compat for now: also set the locale
2009 getSetGlobalLocale(name);
2010 } else {
2011 // pass null for config to unupdate, useful for tests
2012 if (locales[name] != null) {
2013 if (locales[name].parentLocale != null) {
2014 locales[name] = locales[name].parentLocale;
2015 } else if (locales[name] != null) {
2016 delete locales[name];
2017 }
2018 }
2019 }
2020 return locales[name];
2021 }
2022
2023 // returns locale data
2024 function getLocale (key) {
2025 var locale;
2026
2027 if (key && key._locale && key._locale._abbr) {
2028 key = key._locale._abbr;
2029 }
2030
2031 if (!key) {
2032 return globalLocale;
2033 }
2034
2035 if (!isArray(key)) {
2036 //short-circuit everything else
2037 locale = loadLocale(key);
2038 if (locale) {
2039 return locale;
2040 }
2041 key = [key];
2042 }
2043
2044 return chooseLocale(key);
2045 }
2046
2047 function listLocales() {
2048 return keys(locales);
2049 }
2050
2051 function checkOverflow (m) {
2052 var overflow;
2053 var a = m._a;
2054
2055 if (a && getParsingFlags(m).overflow === -2) {
2056 overflow =
2057 a[MONTH] < 0 || a[MONTH] > 11 ? MONTH :
2058 a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
2059 a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
2060 a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE :
2061 a[SECOND] < 0 || a[SECOND] > 59 ? SECOND :
2062 a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
2063 -1;
2064
2065 if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
2066 overflow = DATE;
2067 }
2068 if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
2069 overflow = WEEK;
2070 }
2071 if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
2072 overflow = WEEKDAY;
2073 }
2074
2075 getParsingFlags(m).overflow = overflow;
2076 }
2077
2078 return m;
2079 }
2080
2081 // Pick the first defined of two or three arguments.
2082 function defaults(a, b, c) {
2083 if (a != null) {
2084 return a;
2085 }
2086 if (b != null) {
2087 return b;
2088 }
2089 return c;
2090 }
2091
2092 function currentDateArray(config) {
2093 // hooks is actually the exported moment object
2094 var nowValue = new Date(hooks.now());
2095 if (config._useUTC) {
2096 return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
2097 }
2098 return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2099 }
2100
2101 // convert an array to a date.
2102 // the array should mirror the parameters below
2103 // note: all values past the year are optional and will default to the lowest possible value.
2104 // [year, month, day , hour, minute, second, millisecond]
2105 function configFromArray (config) {
2106 var i, date, input = [], currentDate, expectedWeekday, yearToUse;
2107
2108 if (config._d) {
2109 return;
2110 }
2111
2112 currentDate = currentDateArray(config);
2113
2114 //compute day of the year from weeks and weekdays
2115 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2116 dayOfYearFromWeekInfo(config);
2117 }
2118
2119 //if the day of the year is set, figure out what it is
2120 if (config._dayOfYear != null) {
2121 yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2122
2123 if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
2124 getParsingFlags(config)._overflowDayOfYear = true;
2125 }
2126
2127 date = createUTCDate(yearToUse, 0, config._dayOfYear);
2128 config._a[MONTH] = date.getUTCMonth();
2129 config._a[DATE] = date.getUTCDate();
2130 }
2131
2132 // Default to current date.
2133 // * if no year, month, day of month are given, default to today
2134 // * if day of month is given, default month and year
2135 // * if month is given, default only year
2136 // * if year is given, don't default anything
2137 for (i = 0; i < 3 && config._a[i] == null; ++i) {
2138 config._a[i] = input[i] = currentDate[i];
2139 }
2140
2141 // Zero out whatever was not defaulted, including time
2142 for (; i < 7; i++) {
2143 config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
2144 }
2145
2146 // Check for 24:00:00.000
2147 if (config._a[HOUR] === 24 &&
2148 config._a[MINUTE] === 0 &&
2149 config._a[SECOND] === 0 &&
2150 config._a[MILLISECOND] === 0) {
2151 config._nextDay = true;
2152 config._a[HOUR] = 0;
2153 }
2154
2155 config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
2156 expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
2157
2158 // Apply timezone offset from input. The actual utcOffset can be changed
2159 // with parseZone.
2160 if (config._tzm != null) {
2161 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2162 }
2163
2164 if (config._nextDay) {
2165 config._a[HOUR] = 24;
2166 }
2167
2168 // check for mismatching day of week
2169 if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
2170 getParsingFlags(config).weekdayMismatch = true;
2171 }
2172 }
2173
2174 function dayOfYearFromWeekInfo(config) {
2175 var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
2176
2177 w = config._w;
2178 if (w.GG != null || w.W != null || w.E != null) {
2179 dow = 1;
2180 doy = 4;
2181
2182 // TODO: We need to take the current isoWeekYear, but that depends on
2183 // how we interpret now (local, utc, fixed offset). So create
2184 // a now version of current config (take local/utc/offset flags, and
2185 // create now).
2186 weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
2187 week = defaults(w.W, 1);
2188 weekday = defaults(w.E, 1);
2189 if (weekday < 1 || weekday > 7) {
2190 weekdayOverflow = true;
2191 }
2192 } else {
2193 dow = config._locale._week.dow;
2194 doy = config._locale._week.doy;
2195
2196 var curWeek = weekOfYear(createLocal(), dow, doy);
2197
2198 weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
2199
2200 // Default to current week.
2201 week = defaults(w.w, curWeek.week);
2202
2203 if (w.d != null) {
2204 // weekday -- low day numbers are considered next week
2205 weekday = w.d;
2206 if (weekday < 0 || weekday > 6) {
2207 weekdayOverflow = true;
2208 }
2209 } else if (w.e != null) {
2210 // local weekday -- counting starts from begining of week
2211 weekday = w.e + dow;
2212 if (w.e < 0 || w.e > 6) {
2213 weekdayOverflow = true;
2214 }
2215 } else {
2216 // default to begining of week
2217 weekday = dow;
2218 }
2219 }
2220 if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2221 getParsingFlags(config)._overflowWeeks = true;
2222 } else if (weekdayOverflow != null) {
2223 getParsingFlags(config)._overflowWeekday = true;
2224 } else {
2225 temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2226 config._a[YEAR] = temp.year;
2227 config._dayOfYear = temp.dayOfYear;
2228 }
2229 }
2230
2231 // iso 8601 regex
2232 // 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)
2233 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)?)?$/;
2234 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)?)?$/;
2235
2236 var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
2237
2238 var isoDates = [
2239 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2240 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2241 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2242 ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2243 ['YYYY-DDD', /\d{4}-\d{3}/],
2244 ['YYYY-MM', /\d{4}-\d\d/, false],
2245 ['YYYYYYMMDD', /[+-]\d{10}/],
2246 ['YYYYMMDD', /\d{8}/],
2247 // YYYYMM is NOT allowed by the standard
2248 ['GGGG[W]WWE', /\d{4}W\d{3}/],
2249 ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2250 ['YYYYDDD', /\d{7}/]
2251 ];
2252
2253 // iso time formats and regexes
2254 var isoTimes = [
2255 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2256 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2257 ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2258 ['HH:mm', /\d\d:\d\d/],
2259 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2260 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2261 ['HHmmss', /\d\d\d\d\d\d/],
2262 ['HHmm', /\d\d\d\d/],
2263 ['HH', /\d\d/]
2264 ];
2265
2266 var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
2267
2268 // date from iso format
2269 function configFromISO(config) {
2270 var i, l,
2271 string = config._i,
2272 match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2273 allowTime, dateFormat, timeFormat, tzFormat;
2274
2275 if (match) {
2276 getParsingFlags(config).iso = true;
2277
2278 for (i = 0, l = isoDates.length; i < l; i++) {
2279 if (isoDates[i][1].exec(match[1])) {
2280 dateFormat = isoDates[i][0];
2281 allowTime = isoDates[i][2] !== false;
2282 break;
2283 }
2284 }
2285 if (dateFormat == null) {
2286 config._isValid = false;
2287 return;
2288 }
2289 if (match[3]) {
2290 for (i = 0, l = isoTimes.length; i < l; i++) {
2291 if (isoTimes[i][1].exec(match[3])) {
2292 // match[2] should be 'T' or space
2293 timeFormat = (match[2] || ' ') + isoTimes[i][0];
2294 break;
2295 }
2296 }
2297 if (timeFormat == null) {
2298 config._isValid = false;
2299 return;
2300 }
2301 }
2302 if (!allowTime && timeFormat != null) {
2303 config._isValid = false;
2304 return;
2305 }
2306 if (match[4]) {
2307 if (tzRegex.exec(match[4])) {
2308 tzFormat = 'Z';
2309 } else {
2310 config._isValid = false;
2311 return;
2312 }
2313 }
2314 config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2315 configFromStringAndFormat(config);
2316 } else {
2317 config._isValid = false;
2318 }
2319 }
2320
2321 // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2322 var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;
2323
2324 function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
2325 var result = [
2326 untruncateYear(yearStr),
2327 defaultLocaleMonthsShort.indexOf(monthStr),
2328 parseInt(dayStr, 10),
2329 parseInt(hourStr, 10),
2330 parseInt(minuteStr, 10)
2331 ];
2332
2333 if (secondStr) {
2334 result.push(parseInt(secondStr, 10));
2335 }
2336
2337 return result;
2338 }
2339
2340 function untruncateYear(yearStr) {
2341 var year = parseInt(yearStr, 10);
2342 if (year <= 49) {
2343 return 2000 + year;
2344 } else if (year <= 999) {
2345 return 1900 + year;
2346 }
2347 return year;
2348 }
2349
2350 function preprocessRFC2822(s) {
2351 // Remove comments and folding whitespace and replace multiple-spaces with a single space
2352 return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, '');
2353 }
2354
2355 function checkWeekday(weekdayStr, parsedInput, config) {
2356 if (weekdayStr) {
2357 // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
2358 var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
2359 weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
2360 if (weekdayProvided !== weekdayActual) {
2361 getParsingFlags(config).weekdayMismatch = true;
2362 config._isValid = false;
2363 return false;
2364 }
2365 }
2366 return true;
2367 }
2368
2369 var obsOffsets = {
2370 UT: 0,
2371 GMT: 0,
2372 EDT: -4 * 60,
2373 EST: -5 * 60,
2374 CDT: -5 * 60,
2375 CST: -6 * 60,
2376 MDT: -6 * 60,
2377 MST: -7 * 60,
2378 PDT: -7 * 60,
2379 PST: -8 * 60
2380 };
2381
2382 function calculateOffset(obsOffset, militaryOffset, numOffset) {
2383 if (obsOffset) {
2384 return obsOffsets[obsOffset];
2385 } else if (militaryOffset) {
2386 // the only allowed military tz is Z
2387 return 0;
2388 } else {
2389 var hm = parseInt(numOffset, 10);
2390 var m = hm % 100, h = (hm - m) / 100;
2391 return h * 60 + m;
2392 }
2393 }
2394
2395 // date and time from ref 2822 format
2396 function configFromRFC2822(config) {
2397 var match = rfc2822.exec(preprocessRFC2822(config._i));
2398 if (match) {
2399 var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
2400 if (!checkWeekday(match[1], parsedArray, config)) {
2401 return;
2402 }
2403
2404 config._a = parsedArray;
2405 config._tzm = calculateOffset(match[8], match[9], match[10]);
2406
2407 config._d = createUTCDate.apply(null, config._a);
2408 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2409
2410 getParsingFlags(config).rfc2822 = true;
2411 } else {
2412 config._isValid = false;
2413 }
2414 }
2415
2416 // date from iso format or fallback
2417 function configFromString(config) {
2418 var matched = aspNetJsonRegex.exec(config._i);
2419
2420 if (matched !== null) {
2421 config._d = new Date(+matched[1]);
2422 return;
2423 }
2424
2425 configFromISO(config);
2426 if (config._isValid === false) {
2427 delete config._isValid;
2428 } else {
2429 return;
2430 }
2431
2432 configFromRFC2822(config);
2433 if (config._isValid === false) {
2434 delete config._isValid;
2435 } else {
2436 return;
2437 }
2438
2439 // Final attempt, use Input Fallback
2440 hooks.createFromInputFallback(config);
2441 }
2442
2443 hooks.createFromInputFallback = deprecate(
2444 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
2445 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
2446 'discouraged and will be removed in an upcoming major release. Please refer to ' +
2447 'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2448 function (config) {
2449 config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2450 }
2451 );
2452
2453 // constant that refers to the ISO standard
2454 hooks.ISO_8601 = function () {};
2455
2456 // constant that refers to the RFC 2822 form
2457 hooks.RFC_2822 = function () {};
2458
2459 // date from string and format string
2460 function configFromStringAndFormat(config) {
2461 // TODO: Move this to another part of the creation flow to prevent circular deps
2462 if (config._f === hooks.ISO_8601) {
2463 configFromISO(config);
2464 return;
2465 }
2466 if (config._f === hooks.RFC_2822) {
2467 configFromRFC2822(config);
2468 return;
2469 }
2470 config._a = [];
2471 getParsingFlags(config).empty = true;
2472
2473 // This array is used to make a Date, either with `new Date` or `Date.UTC`
2474 var string = '' + config._i,
2475 i, parsedInput, tokens, token, skipped,
2476 stringLength = string.length,
2477 totalParsedInputLength = 0;
2478
2479 tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
2480
2481 for (i = 0; i < tokens.length; i++) {
2482 token = tokens[i];
2483 parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
2484 // console.log('token', token, 'parsedInput', parsedInput,
2485 // 'regex', getParseRegexForToken(token, config));
2486 if (parsedInput) {
2487 skipped = string.substr(0, string.indexOf(parsedInput));
2488 if (skipped.length > 0) {
2489 getParsingFlags(config).unusedInput.push(skipped);
2490 }
2491 string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
2492 totalParsedInputLength += parsedInput.length;
2493 }
2494 // don't parse if it's not a known token
2495 if (formatTokenFunctions[token]) {
2496 if (parsedInput) {
2497 getParsingFlags(config).empty = false;
2498 }
2499 else {
2500 getParsingFlags(config).unusedTokens.push(token);
2501 }
2502 addTimeToArrayFromToken(token, parsedInput, config);
2503 }
2504 else if (config._strict && !parsedInput) {
2505 getParsingFlags(config).unusedTokens.push(token);
2506 }
2507 }
2508
2509 // add remaining unparsed input length to the string
2510 getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
2511 if (string.length > 0) {
2512 getParsingFlags(config).unusedInput.push(string);
2513 }
2514
2515 // clear _12h flag if hour is <= 12
2516 if (config._a[HOUR] <= 12 &&
2517 getParsingFlags(config).bigHour === true &&
2518 config._a[HOUR] > 0) {
2519 getParsingFlags(config).bigHour = undefined;
2520 }
2521
2522 getParsingFlags(config).parsedDateParts = config._a.slice(0);
2523 getParsingFlags(config).meridiem = config._meridiem;
2524 // handle meridiem
2525 config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
2526
2527 configFromArray(config);
2528 checkOverflow(config);
2529 }
2530
2531
2532 function meridiemFixWrap (locale, hour, meridiem) {
2533 var isPm;
2534
2535 if (meridiem == null) {
2536 // nothing to do
2537 return hour;
2538 }
2539 if (locale.meridiemHour != null) {
2540 return locale.meridiemHour(hour, meridiem);
2541 } else if (locale.isPM != null) {
2542 // Fallback
2543 isPm = locale.isPM(meridiem);
2544 if (isPm && hour < 12) {
2545 hour += 12;
2546 }
2547 if (!isPm && hour === 12) {
2548 hour = 0;
2549 }
2550 return hour;
2551 } else {
2552 // this is not supposed to happen
2553 return hour;
2554 }
2555 }
2556
2557 // date from string and array of format strings
2558 function configFromStringAndArray(config) {
2559 var tempConfig,
2560 bestMoment,
2561
2562 scoreToBeat,
2563 i,
2564 currentScore;
2565
2566 if (config._f.length === 0) {
2567 getParsingFlags(config).invalidFormat = true;
2568 config._d = new Date(NaN);
2569 return;
2570 }
2571
2572 for (i = 0; i < config._f.length; i++) {
2573 currentScore = 0;
2574 tempConfig = copyConfig({}, config);
2575 if (config._useUTC != null) {
2576 tempConfig._useUTC = config._useUTC;
2577 }
2578 tempConfig._f = config._f[i];
2579 configFromStringAndFormat(tempConfig);
2580
2581 if (!isValid(tempConfig)) {
2582 continue;
2583 }
2584
2585 // if there is any input that was not parsed add a penalty for that format
2586 currentScore += getParsingFlags(tempConfig).charsLeftOver;
2587
2588 //or tokens
2589 currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2590
2591 getParsingFlags(tempConfig).score = currentScore;
2592
2593 if (scoreToBeat == null || currentScore < scoreToBeat) {
2594 scoreToBeat = currentScore;
2595 bestMoment = tempConfig;
2596 }
2597 }
2598
2599 extend(config, bestMoment || tempConfig);
2600 }
2601
2602 function configFromObject(config) {
2603 if (config._d) {
2604 return;
2605 }
2606
2607 var i = normalizeObjectUnits(config._i);
2608 config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
2609 return obj && parseInt(obj, 10);
2610 });
2611
2612 configFromArray(config);
2613 }
2614
2615 function createFromConfig (config) {
2616 var res = new Moment(checkOverflow(prepareConfig(config)));
2617 if (res._nextDay) {
2618 // Adding is smart enough around DST
2619 res.add(1, 'd');
2620 res._nextDay = undefined;
2621 }
2622
2623 return res;
2624 }
2625
2626 function prepareConfig (config) {
2627 var input = config._i,
2628 format = config._f;
2629
2630 config._locale = config._locale || getLocale(config._l);
2631
2632 if (input === null || (format === undefined && input === '')) {
2633 return createInvalid({nullInput: true});
2634 }
2635
2636 if (typeof input === 'string') {
2637 config._i = input = config._locale.preparse(input);
2638 }
2639
2640 if (isMoment(input)) {
2641 return new Moment(checkOverflow(input));
2642 } else if (isDate(input)) {
2643 config._d = input;
2644 } else if (isArray(format)) {
2645 configFromStringAndArray(config);
2646 } else if (format) {
2647 configFromStringAndFormat(config);
2648 } else {
2649 configFromInput(config);
2650 }
2651
2652 if (!isValid(config)) {
2653 config._d = null;
2654 }
2655
2656 return config;
2657 }
2658
2659 function configFromInput(config) {
2660 var input = config._i;
2661 if (isUndefined(input)) {
2662 config._d = new Date(hooks.now());
2663 } else if (isDate(input)) {
2664 config._d = new Date(input.valueOf());
2665 } else if (typeof input === 'string') {
2666 configFromString(config);
2667 } else if (isArray(input)) {
2668 config._a = map(input.slice(0), function (obj) {
2669 return parseInt(obj, 10);
2670 });
2671 configFromArray(config);
2672 } else if (isObject(input)) {
2673 configFromObject(config);
2674 } else if (isNumber(input)) {
2675 // from milliseconds
2676 config._d = new Date(input);
2677 } else {
2678 hooks.createFromInputFallback(config);
2679 }
2680 }
2681
2682 function createLocalOrUTC (input, format, locale, strict, isUTC) {
2683 var c = {};
2684
2685 if (locale === true || locale === false) {
2686 strict = locale;
2687 locale = undefined;
2688 }
2689
2690 if ((isObject(input) && isObjectEmpty(input)) ||
2691 (isArray(input) && input.length === 0)) {
2692 input = undefined;
2693 }
2694 // object construction must be done this way.
2695 // https://github.com/moment/moment/issues/1423
2696 c._isAMomentObject = true;
2697 c._useUTC = c._isUTC = isUTC;
2698 c._l = locale;
2699 c._i = input;
2700 c._f = format;
2701 c._strict = strict;
2702
2703 return createFromConfig(c);
2704 }
2705
2706 function createLocal (input, format, locale, strict) {
2707 return createLocalOrUTC(input, format, locale, strict, false);
2708 }
2709
2710 var prototypeMin = deprecate(
2711 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
2712 function () {
2713 var other = createLocal.apply(null, arguments);
2714 if (this.isValid() && other.isValid()) {
2715 return other < this ? this : other;
2716 } else {
2717 return createInvalid();
2718 }
2719 }
2720 );
2721
2722 var prototypeMax = deprecate(
2723 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
2724 function () {
2725 var other = createLocal.apply(null, arguments);
2726 if (this.isValid() && other.isValid()) {
2727 return other > this ? this : other;
2728 } else {
2729 return createInvalid();
2730 }
2731 }
2732 );
2733
2734 // Pick a moment m from moments so that m[fn](other) is true for all
2735 // other. This relies on the function fn to be transitive.
2736 //
2737 // moments should either be an array of moment objects or an array, whose
2738 // first element is an array of moment objects.
2739 function pickBy(fn, moments) {
2740 var res, i;
2741 if (moments.length === 1 && isArray(moments[0])) {
2742 moments = moments[0];
2743 }
2744 if (!moments.length) {
2745 return createLocal();
2746 }
2747 res = moments[0];
2748 for (i = 1; i < moments.length; ++i) {
2749 if (!moments[i].isValid() || moments[i][fn](res)) {
2750 res = moments[i];
2751 }
2752 }
2753 return res;
2754 }
2755
2756 // TODO: Use [].sort instead?
2757 function min () {
2758 var args = [].slice.call(arguments, 0);
2759
2760 return pickBy('isBefore', args);
2761 }
2762
2763 function max () {
2764 var args = [].slice.call(arguments, 0);
2765
2766 return pickBy('isAfter', args);
2767 }
2768
2769 var now = function () {
2770 return Date.now ? Date.now() : +(new Date());
2771 };
2772
2773 var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
2774
2775 function isDurationValid(m) {
2776 for (var key in m) {
2777 if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
2778 return false;
2779 }
2780 }
2781
2782 var unitHasDecimal = false;
2783 for (var i = 0; i < ordering.length; ++i) {
2784 if (m[ordering[i]]) {
2785 if (unitHasDecimal) {
2786 return false; // only allow non-integers for smallest unit
2787 }
2788 if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
2789 unitHasDecimal = true;
2790 }
2791 }
2792 }
2793
2794 return true;
2795 }
2796
2797 function isValid$1() {
2798 return this._isValid;
2799 }
2800
2801 function createInvalid$1() {
2802 return createDuration(NaN);
2803 }
2804
2805 function Duration (duration) {
2806 var normalizedInput = normalizeObjectUnits(duration),
2807 years = normalizedInput.year || 0,
2808 quarters = normalizedInput.quarter || 0,
2809 months = normalizedInput.month || 0,
2810 weeks = normalizedInput.week || 0,
2811 days = normalizedInput.day || 0,
2812 hours = normalizedInput.hour || 0,
2813 minutes = normalizedInput.minute || 0,
2814 seconds = normalizedInput.second || 0,
2815 milliseconds = normalizedInput.millisecond || 0;
2816
2817 this._isValid = isDurationValid(normalizedInput);
2818
2819 // representation for dateAddRemove
2820 this._milliseconds = +milliseconds +
2821 seconds * 1e3 + // 1000
2822 minutes * 6e4 + // 1000 * 60
2823 hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
2824 // Because of dateAddRemove treats 24 hours as different from a
2825 // day when working around DST, we need to store them separately
2826 this._days = +days +
2827 weeks * 7;
2828 // It is impossible to translate months into days without knowing
2829 // which months you are are talking about, so we have to store
2830 // it separately.
2831 this._months = +months +
2832 quarters * 3 +
2833 years * 12;
2834
2835 this._data = {};
2836
2837 this._locale = getLocale();
2838
2839 this._bubble();
2840 }
2841
2842 function isDuration (obj) {
2843 return obj instanceof Duration;
2844 }
2845
2846 function absRound (number) {
2847 if (number < 0) {
2848 return Math.round(-1 * number) * -1;
2849 } else {
2850 return Math.round(number);
2851 }
2852 }
2853
2854 // FORMATTING
2855
2856 function offset (token, separator) {
2857 addFormatToken(token, 0, 0, function () {
2858 var offset = this.utcOffset();
2859 var sign = '+';
2860 if (offset < 0) {
2861 offset = -offset;
2862 sign = '-';
2863 }
2864 return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
2865 });
2866 }
2867
2868 offset('Z', ':');
2869 offset('ZZ', '');
2870
2871 // PARSING
2872
2873 addRegexToken('Z', matchShortOffset);
2874 addRegexToken('ZZ', matchShortOffset);
2875 addParseToken(['Z', 'ZZ'], function (input, array, config) {
2876 config._useUTC = true;
2877 config._tzm = offsetFromString(matchShortOffset, input);
2878 });
2879
2880 // HELPERS
2881
2882 // timezone chunker
2883 // '+10:00' > ['10', '00']
2884 // '-1530' > ['-15', '30']
2885 var chunkOffset = /([\+\-]|\d\d)/gi;
2886
2887 function offsetFromString(matcher, string) {
2888 var matches = (string || '').match(matcher);
2889
2890 if (matches === null) {
2891 return null;
2892 }
2893
2894 var chunk = matches[matches.length - 1] || [];
2895 var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
2896 var minutes = +(parts[1] * 60) + toInt(parts[2]);
2897
2898 return minutes === 0 ?
2899 0 :
2900 parts[0] === '+' ? minutes : -minutes;
2901 }
2902
2903 // Return a moment from input, that is local/utc/zone equivalent to model.
2904 function cloneWithOffset(input, model) {
2905 var res, diff;
2906 if (model._isUTC) {
2907 res = model.clone();
2908 diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
2909 // Use low-level api, because this fn is low-level api.
2910 res._d.setTime(res._d.valueOf() + diff);
2911 hooks.updateOffset(res, false);
2912 return res;
2913 } else {
2914 return createLocal(input).local();
2915 }
2916 }
2917
2918 function getDateOffset (m) {
2919 // On Firefox.24 Date#getTimezoneOffset returns a floating point.
2920 // https://github.com/moment/moment/pull/1871
2921 return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
2922 }
2923
2924 // HOOKS
2925
2926 // This function will be called whenever a moment is mutated.
2927 // It is intended to keep the offset in sync with the timezone.
2928 hooks.updateOffset = function () {};
2929
2930 // MOMENTS
2931
2932 // keepLocalTime = true means only change the timezone, without
2933 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
2934 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
2935 // +0200, so we adjust the time as needed, to be valid.
2936 //
2937 // Keeping the time actually adds/subtracts (one hour)
2938 // from the actual represented time. That is why we call updateOffset
2939 // a second time. In case it wants us to change the offset again
2940 // _changeInProgress == true case, then we have to adjust, because
2941 // there is no such time in the given timezone.
2942 function getSetOffset (input, keepLocalTime, keepMinutes) {
2943 var offset = this._offset || 0,
2944 localAdjust;
2945 if (!this.isValid()) {
2946 return input != null ? this : NaN;
2947 }
2948 if (input != null) {
2949 if (typeof input === 'string') {
2950 input = offsetFromString(matchShortOffset, input);
2951 if (input === null) {
2952 return this;
2953 }
2954 } else if (Math.abs(input) < 16 && !keepMinutes) {
2955 input = input * 60;
2956 }
2957 if (!this._isUTC && keepLocalTime) {
2958 localAdjust = getDateOffset(this);
2959 }
2960 this._offset = input;
2961 this._isUTC = true;
2962 if (localAdjust != null) {
2963 this.add(localAdjust, 'm');
2964 }
2965 if (offset !== input) {
2966 if (!keepLocalTime || this._changeInProgress) {
2967 addSubtract(this, createDuration(input - offset, 'm'), 1, false);
2968 } else if (!this._changeInProgress) {
2969 this._changeInProgress = true;
2970 hooks.updateOffset(this, true);
2971 this._changeInProgress = null;
2972 }
2973 }
2974 return this;
2975 } else {
2976 return this._isUTC ? offset : getDateOffset(this);
2977 }
2978 }
2979
2980 function getSetZone (input, keepLocalTime) {
2981 if (input != null) {
2982 if (typeof input !== 'string') {
2983 input = -input;
2984 }
2985
2986 this.utcOffset(input, keepLocalTime);
2987
2988 return this;
2989 } else {
2990 return -this.utcOffset();
2991 }
2992 }
2993
2994 function setOffsetToUTC (keepLocalTime) {
2995 return this.utcOffset(0, keepLocalTime);
2996 }
2997
2998 function setOffsetToLocal (keepLocalTime) {
2999 if (this._isUTC) {
3000 this.utcOffset(0, keepLocalTime);
3001 this._isUTC = false;
3002
3003 if (keepLocalTime) {
3004 this.subtract(getDateOffset(this), 'm');
3005 }
3006 }
3007 return this;
3008 }
3009
3010 function setOffsetToParsedOffset () {
3011 if (this._tzm != null) {
3012 this.utcOffset(this._tzm, false, true);
3013 } else if (typeof this._i === 'string') {
3014 var tZone = offsetFromString(matchOffset, this._i);
3015 if (tZone != null) {
3016 this.utcOffset(tZone);
3017 }
3018 else {
3019 this.utcOffset(0, true);
3020 }
3021 }
3022 return this;
3023 }
3024
3025 function hasAlignedHourOffset (input) {
3026 if (!this.isValid()) {
3027 return false;
3028 }
3029 input = input ? createLocal(input).utcOffset() : 0;
3030
3031 return (this.utcOffset() - input) % 60 === 0;
3032 }
3033
3034 function isDaylightSavingTime () {
3035 return (
3036 this.utcOffset() > this.clone().month(0).utcOffset() ||
3037 this.utcOffset() > this.clone().month(5).utcOffset()
3038 );
3039 }
3040
3041 function isDaylightSavingTimeShifted () {
3042 if (!isUndefined(this._isDSTShifted)) {
3043 return this._isDSTShifted;
3044 }
3045
3046 var c = {};
3047
3048 copyConfig(c, this);
3049 c = prepareConfig(c);
3050
3051 if (c._a) {
3052 var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
3053 this._isDSTShifted = this.isValid() &&
3054 compareArrays(c._a, other.toArray()) > 0;
3055 } else {
3056 this._isDSTShifted = false;
3057 }
3058
3059 return this._isDSTShifted;
3060 }
3061
3062 function isLocal () {
3063 return this.isValid() ? !this._isUTC : false;
3064 }
3065
3066 function isUtcOffset () {
3067 return this.isValid() ? this._isUTC : false;
3068 }
3069
3070 function isUtc () {
3071 return this.isValid() ? this._isUTC && this._offset === 0 : false;
3072 }
3073
3074 // ASP.NET json date format regex
3075 var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
3076
3077 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
3078 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
3079 // and further modified to allow for strings containing both week and day
3080 var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
3081
3082 function createDuration (input, key) {
3083 var duration = input,
3084 // matching against regexp is expensive, do it on demand
3085 match = null,
3086 sign,
3087 ret,
3088 diffRes;
3089
3090 if (isDuration(input)) {
3091 duration = {
3092 ms : input._milliseconds,
3093 d : input._days,
3094 M : input._months
3095 };
3096 } else if (isNumber(input)) {
3097 duration = {};
3098 if (key) {
3099 duration[key] = input;
3100 } else {
3101 duration.milliseconds = input;
3102 }
3103 } else if (!!(match = aspNetRegex.exec(input))) {
3104 sign = (match[1] === '-') ? -1 : 1;
3105 duration = {
3106 y : 0,
3107 d : toInt(match[DATE]) * sign,
3108 h : toInt(match[HOUR]) * sign,
3109 m : toInt(match[MINUTE]) * sign,
3110 s : toInt(match[SECOND]) * sign,
3111 ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
3112 };
3113 } else if (!!(match = isoRegex.exec(input))) {
3114 sign = (match[1] === '-') ? -1 : (match[1] === '+') ? 1 : 1;
3115 duration = {
3116 y : parseIso(match[2], sign),
3117 M : parseIso(match[3], sign),
3118 w : parseIso(match[4], sign),
3119 d : parseIso(match[5], sign),
3120 h : parseIso(match[6], sign),
3121 m : parseIso(match[7], sign),
3122 s : parseIso(match[8], sign)
3123 };
3124 } else if (duration == null) {// checks for null or undefined
3125 duration = {};
3126 } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
3127 diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
3128
3129 duration = {};
3130 duration.ms = diffRes.milliseconds;
3131 duration.M = diffRes.months;
3132 }
3133
3134 ret = new Duration(duration);
3135
3136 if (isDuration(input) && hasOwnProp(input, '_locale')) {
3137 ret._locale = input._locale;
3138 }
3139
3140 return ret;
3141 }
3142
3143 createDuration.fn = Duration.prototype;
3144 createDuration.invalid = createInvalid$1;
3145
3146 function parseIso (inp, sign) {
3147 // We'd normally use ~~inp for this, but unfortunately it also
3148 // converts floats to ints.
3149 // inp may be undefined, so careful calling replace on it.
3150 var res = inp && parseFloat(inp.replace(',', '.'));
3151 // apply sign while we're at it
3152 return (isNaN(res) ? 0 : res) * sign;
3153 }
3154
3155 function positiveMomentsDifference(base, other) {
3156 var res = {milliseconds: 0, months: 0};
3157
3158 res.months = other.month() - base.month() +
3159 (other.year() - base.year()) * 12;
3160 if (base.clone().add(res.months, 'M').isAfter(other)) {
3161 --res.months;
3162 }
3163
3164 res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
3165
3166 return res;
3167 }
3168
3169 function momentsDifference(base, other) {
3170 var res;
3171 if (!(base.isValid() && other.isValid())) {
3172 return {milliseconds: 0, months: 0};
3173 }
3174
3175 other = cloneWithOffset(other, base);
3176 if (base.isBefore(other)) {
3177 res = positiveMomentsDifference(base, other);
3178 } else {
3179 res = positiveMomentsDifference(other, base);
3180 res.milliseconds = -res.milliseconds;
3181 res.months = -res.months;
3182 }
3183
3184 return res;
3185 }
3186
3187 // TODO: remove 'name' arg after deprecation is removed
3188 function createAdder(direction, name) {
3189 return function (val, period) {
3190 var dur, tmp;
3191 //invert the arguments, but complain about it
3192 if (period !== null && !isNaN(+period)) {
3193 deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
3194 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
3195 tmp = val; val = period; period = tmp;
3196 }
3197
3198 val = typeof val === 'string' ? +val : val;
3199 dur = createDuration(val, period);
3200 addSubtract(this, dur, direction);
3201 return this;
3202 };
3203 }
3204
3205 function addSubtract (mom, duration, isAdding, updateOffset) {
3206 var milliseconds = duration._milliseconds,
3207 days = absRound(duration._days),
3208 months = absRound(duration._months);
3209
3210 if (!mom.isValid()) {
3211 // No op
3212 return;
3213 }
3214
3215 updateOffset = updateOffset == null ? true : updateOffset;
3216
3217 if (months) {
3218 setMonth(mom, get(mom, 'Month') + months * isAdding);
3219 }
3220 if (days) {
3221 set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
3222 }
3223 if (milliseconds) {
3224 mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
3225 }
3226 if (updateOffset) {
3227 hooks.updateOffset(mom, days || months);
3228 }
3229 }
3230
3231 var add = createAdder(1, 'add');
3232 var subtract = createAdder(-1, 'subtract');
3233
3234 function getCalendarFormat(myMoment, now) {
3235 var diff = myMoment.diff(now, 'days', true);
3236 return diff < -6 ? 'sameElse' :
3237 diff < -1 ? 'lastWeek' :
3238 diff < 0 ? 'lastDay' :
3239 diff < 1 ? 'sameDay' :
3240 diff < 2 ? 'nextDay' :
3241 diff < 7 ? 'nextWeek' : 'sameElse';
3242 }
3243
3244 function calendar$1 (time, formats) {
3245 // We want to compare the start of today, vs this.
3246 // Getting start-of-today depends on whether we're local/utc/offset or not.
3247 var now = time || createLocal(),
3248 sod = cloneWithOffset(now, this).startOf('day'),
3249 format = hooks.calendarFormat(this, sod) || 'sameElse';
3250
3251 var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
3252
3253 return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
3254 }
3255
3256 function clone () {
3257 return new Moment(this);
3258 }
3259
3260 function isAfter (input, units) {
3261 var localInput = isMoment(input) ? input : createLocal(input);
3262 if (!(this.isValid() && localInput.isValid())) {
3263 return false;
3264 }
3265 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
3266 if (units === 'millisecond') {
3267 return this.valueOf() > localInput.valueOf();
3268 } else {
3269 return localInput.valueOf() < this.clone().startOf(units).valueOf();
3270 }
3271 }
3272
3273 function isBefore (input, units) {
3274 var localInput = isMoment(input) ? input : createLocal(input);
3275 if (!(this.isValid() && localInput.isValid())) {
3276 return false;
3277 }
3278 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
3279 if (units === 'millisecond') {
3280 return this.valueOf() < localInput.valueOf();
3281 } else {
3282 return this.clone().endOf(units).valueOf() < localInput.valueOf();
3283 }
3284 }
3285
3286 function isBetween (from, to, units, inclusivity) {
3287 inclusivity = inclusivity || '()';
3288 return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
3289 (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
3290 }
3291
3292 function isSame (input, units) {
3293 var localInput = isMoment(input) ? input : createLocal(input),
3294 inputMs;
3295 if (!(this.isValid() && localInput.isValid())) {
3296 return false;
3297 }
3298 units = normalizeUnits(units || 'millisecond');
3299 if (units === 'millisecond') {
3300 return this.valueOf() === localInput.valueOf();
3301 } else {
3302 inputMs = localInput.valueOf();
3303 return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
3304 }
3305 }
3306
3307 function isSameOrAfter (input, units) {
3308 return this.isSame(input, units) || this.isAfter(input,units);
3309 }
3310
3311 function isSameOrBefore (input, units) {
3312 return this.isSame(input, units) || this.isBefore(input,units);
3313 }
3314
3315 function diff (input, units, asFloat) {
3316 var that,
3317 zoneDelta,
3318 output;
3319
3320 if (!this.isValid()) {
3321 return NaN;
3322 }
3323
3324 that = cloneWithOffset(input, this);
3325
3326 if (!that.isValid()) {
3327 return NaN;
3328 }
3329
3330 zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
3331
3332 units = normalizeUnits(units);
3333
3334 switch (units) {
3335 case 'year': output = monthDiff(this, that) / 12; break;
3336 case 'month': output = monthDiff(this, that); break;
3337 case 'quarter': output = monthDiff(this, that) / 3; break;
3338 case 'second': output = (this - that) / 1e3; break; // 1000
3339 case 'minute': output = (this - that) / 6e4; break; // 1000 * 60
3340 case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60
3341 case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst
3342 case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst
3343 default: output = this - that;
3344 }
3345
3346 return asFloat ? output : absFloor(output);
3347 }
3348
3349 function monthDiff (a, b) {
3350 // difference in months
3351 var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
3352 // b is in (anchor - 1 month, anchor + 1 month)
3353 anchor = a.clone().add(wholeMonthDiff, 'months'),
3354 anchor2, adjust;
3355
3356 if (b - anchor < 0) {
3357 anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
3358 // linear across the month
3359 adjust = (b - anchor) / (anchor - anchor2);
3360 } else {
3361 anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
3362 // linear across the month
3363 adjust = (b - anchor) / (anchor2 - anchor);
3364 }
3365
3366 //check for negative zero, return zero if negative zero
3367 return -(wholeMonthDiff + adjust) || 0;
3368 }
3369
3370 hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
3371 hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
3372
3373 function toString () {
3374 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
3375 }
3376
3377 function toISOString(keepOffset) {
3378 if (!this.isValid()) {
3379 return null;
3380 }
3381 var utc = keepOffset !== true;
3382 var m = utc ? this.clone().utc() : this;
3383 if (m.year() < 0 || m.year() > 9999) {
3384 return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
3385 }
3386 if (isFunction(Date.prototype.toISOString)) {
3387 // native implementation is ~50x faster, use it when we can
3388 if (utc) {
3389 return this.toDate().toISOString();
3390 } else {
3391 return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));
3392 }
3393 }
3394 return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
3395 }
3396
3397 /**
3398 * Return a human readable representation of a moment that can
3399 * also be evaluated to get a new moment which is the same
3400 *
3401 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
3402 */
3403 function inspect () {
3404 if (!this.isValid()) {
3405 return 'moment.invalid(/* ' + this._i + ' */)';
3406 }
3407 var func = 'moment';
3408 var zone = '';
3409 if (!this.isLocal()) {
3410 func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
3411 zone = 'Z';
3412 }
3413 var prefix = '[' + func + '("]';
3414 var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
3415 var datetime = '-MM-DD[T]HH:mm:ss.SSS';
3416 var suffix = zone + '[")]';
3417
3418 return this.format(prefix + year + datetime + suffix);
3419 }
3420
3421 function format (inputString) {
3422 if (!inputString) {
3423 inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
3424 }
3425 var output = formatMoment(this, inputString);
3426 return this.localeData().postformat(output);
3427 }
3428
3429 function from (time, withoutSuffix) {
3430 if (this.isValid() &&
3431 ((isMoment(time) && time.isValid()) ||
3432 createLocal(time).isValid())) {
3433 return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
3434 } else {
3435 return this.localeData().invalidDate();
3436 }
3437 }
3438
3439 function fromNow (withoutSuffix) {
3440 return this.from(createLocal(), withoutSuffix);
3441 }
3442
3443 function to (time, withoutSuffix) {
3444 if (this.isValid() &&
3445 ((isMoment(time) && time.isValid()) ||
3446 createLocal(time).isValid())) {
3447 return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
3448 } else {
3449 return this.localeData().invalidDate();
3450 }
3451 }
3452
3453 function toNow (withoutSuffix) {
3454 return this.to(createLocal(), withoutSuffix);
3455 }
3456
3457 // If passed a locale key, it will set the locale for this
3458 // instance. Otherwise, it will return the locale configuration
3459 // variables for this instance.
3460 function locale (key) {
3461 var newLocaleData;
3462
3463 if (key === undefined) {
3464 return this._locale._abbr;
3465 } else {
3466 newLocaleData = getLocale(key);
3467 if (newLocaleData != null) {
3468 this._locale = newLocaleData;
3469 }
3470 return this;
3471 }
3472 }
3473
3474 var lang = deprecate(
3475 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
3476 function (key) {
3477 if (key === undefined) {
3478 return this.localeData();
3479 } else {
3480 return this.locale(key);
3481 }
3482 }
3483 );
3484
3485 function localeData () {
3486 return this._locale;
3487 }
3488
3489 function startOf (units) {
3490 units = normalizeUnits(units);
3491 // the following switch intentionally omits break keywords
3492 // to utilize falling through the cases.
3493 switch (units) {
3494 case 'year':
3495 this.month(0);
3496 /* falls through */
3497 case 'quarter':
3498 case 'month':
3499 this.date(1);
3500 /* falls through */
3501 case 'week':
3502 case 'isoWeek':
3503 case 'day':
3504 case 'date':
3505 this.hours(0);
3506 /* falls through */
3507 case 'hour':
3508 this.minutes(0);
3509 /* falls through */
3510 case 'minute':
3511 this.seconds(0);
3512 /* falls through */
3513 case 'second':
3514 this.milliseconds(0);
3515 }
3516
3517 // weeks are a special case
3518 if (units === 'week') {
3519 this.weekday(0);
3520 }
3521 if (units === 'isoWeek') {
3522 this.isoWeekday(1);
3523 }
3524
3525 // quarters are also special
3526 if (units === 'quarter') {
3527 this.month(Math.floor(this.month() / 3) * 3);
3528 }
3529
3530 return this;
3531 }
3532
3533 function endOf (units) {
3534 units = normalizeUnits(units);
3535 if (units === undefined || units === 'millisecond') {
3536 return this;
3537 }
3538
3539 // 'date' is an alias for 'day', so it should be considered as such.
3540 if (units === 'date') {
3541 units = 'day';
3542 }
3543
3544 return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
3545 }
3546
3547 function valueOf () {
3548 return this._d.valueOf() - ((this._offset || 0) * 60000);
3549 }
3550
3551 function unix () {
3552 return Math.floor(this.valueOf() / 1000);
3553 }
3554
3555 function toDate () {
3556 return new Date(this.valueOf());
3557 }
3558
3559 function toArray () {
3560 var m = this;
3561 return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
3562 }
3563
3564 function toObject () {
3565 var m = this;
3566 return {
3567 years: m.year(),
3568 months: m.month(),
3569 date: m.date(),
3570 hours: m.hours(),
3571 minutes: m.minutes(),
3572 seconds: m.seconds(),
3573 milliseconds: m.milliseconds()
3574 };
3575 }
3576
3577 function toJSON () {
3578 // new Date(NaN).toJSON() === null
3579 return this.isValid() ? this.toISOString() : null;
3580 }
3581
3582 function isValid$2 () {
3583 return isValid(this);
3584 }
3585
3586 function parsingFlags () {
3587 return extend({}, getParsingFlags(this));
3588 }
3589
3590 function invalidAt () {
3591 return getParsingFlags(this).overflow;
3592 }
3593
3594 function creationData() {
3595 return {
3596 input: this._i,
3597 format: this._f,
3598 locale: this._locale,
3599 isUTC: this._isUTC,
3600 strict: this._strict
3601 };
3602 }
3603
3604 // FORMATTING
3605
3606 addFormatToken(0, ['gg', 2], 0, function () {
3607 return this.weekYear() % 100;
3608 });
3609
3610 addFormatToken(0, ['GG', 2], 0, function () {
3611 return this.isoWeekYear() % 100;
3612 });
3613
3614 function addWeekYearFormatToken (token, getter) {
3615 addFormatToken(0, [token, token.length], 0, getter);
3616 }
3617
3618 addWeekYearFormatToken('gggg', 'weekYear');
3619 addWeekYearFormatToken('ggggg', 'weekYear');
3620 addWeekYearFormatToken('GGGG', 'isoWeekYear');
3621 addWeekYearFormatToken('GGGGG', 'isoWeekYear');
3622
3623 // ALIASES
3624
3625 addUnitAlias('weekYear', 'gg');
3626 addUnitAlias('isoWeekYear', 'GG');
3627
3628 // PRIORITY
3629
3630 addUnitPriority('weekYear', 1);
3631 addUnitPriority('isoWeekYear', 1);
3632
3633
3634 // PARSING
3635
3636 addRegexToken('G', matchSigned);
3637 addRegexToken('g', matchSigned);
3638 addRegexToken('GG', match1to2, match2);
3639 addRegexToken('gg', match1to2, match2);
3640 addRegexToken('GGGG', match1to4, match4);
3641 addRegexToken('gggg', match1to4, match4);
3642 addRegexToken('GGGGG', match1to6, match6);
3643 addRegexToken('ggggg', match1to6, match6);
3644
3645 addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
3646 week[token.substr(0, 2)] = toInt(input);
3647 });
3648
3649 addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
3650 week[token] = hooks.parseTwoDigitYear(input);
3651 });
3652
3653 // MOMENTS
3654
3655 function getSetWeekYear (input) {
3656 return getSetWeekYearHelper.call(this,
3657 input,
3658 this.week(),
3659 this.weekday(),
3660 this.localeData()._week.dow,
3661 this.localeData()._week.doy);
3662 }
3663
3664 function getSetISOWeekYear (input) {
3665 return getSetWeekYearHelper.call(this,
3666 input, this.isoWeek(), this.isoWeekday(), 1, 4);
3667 }
3668
3669 function getISOWeeksInYear () {
3670 return weeksInYear(this.year(), 1, 4);
3671 }
3672
3673 function getWeeksInYear () {
3674 var weekInfo = this.localeData()._week;
3675 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
3676 }
3677
3678 function getSetWeekYearHelper(input, week, weekday, dow, doy) {
3679 var weeksTarget;
3680 if (input == null) {
3681 return weekOfYear(this, dow, doy).year;
3682 } else {
3683 weeksTarget = weeksInYear(input, dow, doy);
3684 if (week > weeksTarget) {
3685 week = weeksTarget;
3686 }
3687 return setWeekAll.call(this, input, week, weekday, dow, doy);
3688 }
3689 }
3690
3691 function setWeekAll(weekYear, week, weekday, dow, doy) {
3692 var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
3693 date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
3694
3695 this.year(date.getUTCFullYear());
3696 this.month(date.getUTCMonth());
3697 this.date(date.getUTCDate());
3698 return this;
3699 }
3700
3701 // FORMATTING
3702
3703 addFormatToken('Q', 0, 'Qo', 'quarter');
3704
3705 // ALIASES
3706
3707 addUnitAlias('quarter', 'Q');
3708
3709 // PRIORITY
3710
3711 addUnitPriority('quarter', 7);
3712
3713 // PARSING
3714
3715 addRegexToken('Q', match1);
3716 addParseToken('Q', function (input, array) {
3717 array[MONTH] = (toInt(input) - 1) * 3;
3718 });
3719
3720 // MOMENTS
3721
3722 function getSetQuarter (input) {
3723 return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
3724 }
3725
3726 // FORMATTING
3727
3728 addFormatToken('D', ['DD', 2], 'Do', 'date');
3729
3730 // ALIASES
3731
3732 addUnitAlias('date', 'D');
3733
3734 // PRIORITY
3735 addUnitPriority('date', 9);
3736
3737 // PARSING
3738
3739 addRegexToken('D', match1to2);
3740 addRegexToken('DD', match1to2, match2);
3741 addRegexToken('Do', function (isStrict, locale) {
3742 // TODO: Remove "ordinalParse" fallback in next major release.
3743 return isStrict ?
3744 (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
3745 locale._dayOfMonthOrdinalParseLenient;
3746 });
3747
3748 addParseToken(['D', 'DD'], DATE);
3749 addParseToken('Do', function (input, array) {
3750 array[DATE] = toInt(input.match(match1to2)[0]);
3751 });
3752
3753 // MOMENTS
3754
3755 var getSetDayOfMonth = makeGetSet('Date', true);
3756
3757 // FORMATTING
3758
3759 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
3760
3761 // ALIASES
3762
3763 addUnitAlias('dayOfYear', 'DDD');
3764
3765 // PRIORITY
3766 addUnitPriority('dayOfYear', 4);
3767
3768 // PARSING
3769
3770 addRegexToken('DDD', match1to3);
3771 addRegexToken('DDDD', match3);
3772 addParseToken(['DDD', 'DDDD'], function (input, array, config) {
3773 config._dayOfYear = toInt(input);
3774 });
3775
3776 // HELPERS
3777
3778 // MOMENTS
3779
3780 function getSetDayOfYear (input) {
3781 var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
3782 return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
3783 }
3784
3785 // FORMATTING
3786
3787 addFormatToken('m', ['mm', 2], 0, 'minute');
3788
3789 // ALIASES
3790
3791 addUnitAlias('minute', 'm');
3792
3793 // PRIORITY
3794
3795 addUnitPriority('minute', 14);
3796
3797 // PARSING
3798
3799 addRegexToken('m', match1to2);
3800 addRegexToken('mm', match1to2, match2);
3801 addParseToken(['m', 'mm'], MINUTE);
3802
3803 // MOMENTS
3804
3805 var getSetMinute = makeGetSet('Minutes', false);
3806
3807 // FORMATTING
3808
3809 addFormatToken('s', ['ss', 2], 0, 'second');
3810
3811 // ALIASES
3812
3813 addUnitAlias('second', 's');
3814
3815 // PRIORITY
3816
3817 addUnitPriority('second', 15);
3818
3819 // PARSING
3820
3821 addRegexToken('s', match1to2);
3822 addRegexToken('ss', match1to2, match2);
3823 addParseToken(['s', 'ss'], SECOND);
3824
3825 // MOMENTS
3826
3827 var getSetSecond = makeGetSet('Seconds', false);
3828
3829 // FORMATTING
3830
3831 addFormatToken('S', 0, 0, function () {
3832 return ~~(this.millisecond() / 100);
3833 });
3834
3835 addFormatToken(0, ['SS', 2], 0, function () {
3836 return ~~(this.millisecond() / 10);
3837 });
3838
3839 addFormatToken(0, ['SSS', 3], 0, 'millisecond');
3840 addFormatToken(0, ['SSSS', 4], 0, function () {
3841 return this.millisecond() * 10;
3842 });
3843 addFormatToken(0, ['SSSSS', 5], 0, function () {
3844 return this.millisecond() * 100;
3845 });
3846 addFormatToken(0, ['SSSSSS', 6], 0, function () {
3847 return this.millisecond() * 1000;
3848 });
3849 addFormatToken(0, ['SSSSSSS', 7], 0, function () {
3850 return this.millisecond() * 10000;
3851 });
3852 addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
3853 return this.millisecond() * 100000;
3854 });
3855 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
3856 return this.millisecond() * 1000000;
3857 });
3858
3859
3860 // ALIASES
3861
3862 addUnitAlias('millisecond', 'ms');
3863
3864 // PRIORITY
3865
3866 addUnitPriority('millisecond', 16);
3867
3868 // PARSING
3869
3870 addRegexToken('S', match1to3, match1);
3871 addRegexToken('SS', match1to3, match2);
3872 addRegexToken('SSS', match1to3, match3);
3873
3874 var token;
3875 for (token = 'SSSS'; token.length <= 9; token += 'S') {
3876 addRegexToken(token, matchUnsigned);
3877 }
3878
3879 function parseMs(input, array) {
3880 array[MILLISECOND] = toInt(('0.' + input) * 1000);
3881 }
3882
3883 for (token = 'S'; token.length <= 9; token += 'S') {
3884 addParseToken(token, parseMs);
3885 }
3886 // MOMENTS
3887
3888 var getSetMillisecond = makeGetSet('Milliseconds', false);
3889
3890 // FORMATTING
3891
3892 addFormatToken('z', 0, 0, 'zoneAbbr');
3893 addFormatToken('zz', 0, 0, 'zoneName');
3894
3895 // MOMENTS
3896
3897 function getZoneAbbr () {
3898 return this._isUTC ? 'UTC' : '';
3899 }
3900
3901 function getZoneName () {
3902 return this._isUTC ? 'Coordinated Universal Time' : '';
3903 }
3904
3905 var proto = Moment.prototype;
3906
3907 proto.add = add;
3908 proto.calendar = calendar$1;
3909 proto.clone = clone;
3910 proto.diff = diff;
3911 proto.endOf = endOf;
3912 proto.format = format;
3913 proto.from = from;
3914 proto.fromNow = fromNow;
3915 proto.to = to;
3916 proto.toNow = toNow;
3917 proto.get = stringGet;
3918 proto.invalidAt = invalidAt;
3919 proto.isAfter = isAfter;
3920 proto.isBefore = isBefore;
3921 proto.isBetween = isBetween;
3922 proto.isSame = isSame;
3923 proto.isSameOrAfter = isSameOrAfter;
3924 proto.isSameOrBefore = isSameOrBefore;
3925 proto.isValid = isValid$2;
3926 proto.lang = lang;
3927 proto.locale = locale;
3928 proto.localeData = localeData;
3929 proto.max = prototypeMax;
3930 proto.min = prototypeMin;
3931 proto.parsingFlags = parsingFlags;
3932 proto.set = stringSet;
3933 proto.startOf = startOf;
3934 proto.subtract = subtract;
3935 proto.toArray = toArray;
3936 proto.toObject = toObject;
3937 proto.toDate = toDate;
3938 proto.toISOString = toISOString;
3939 proto.inspect = inspect;
3940 proto.toJSON = toJSON;
3941 proto.toString = toString;
3942 proto.unix = unix;
3943 proto.valueOf = valueOf;
3944 proto.creationData = creationData;
3945 proto.year = getSetYear;
3946 proto.isLeapYear = getIsLeapYear;
3947 proto.weekYear = getSetWeekYear;
3948 proto.isoWeekYear = getSetISOWeekYear;
3949 proto.quarter = proto.quarters = getSetQuarter;
3950 proto.month = getSetMonth;
3951 proto.daysInMonth = getDaysInMonth;
3952 proto.week = proto.weeks = getSetWeek;
3953 proto.isoWeek = proto.isoWeeks = getSetISOWeek;
3954 proto.weeksInYear = getWeeksInYear;
3955 proto.isoWeeksInYear = getISOWeeksInYear;
3956 proto.date = getSetDayOfMonth;
3957 proto.day = proto.days = getSetDayOfWeek;
3958 proto.weekday = getSetLocaleDayOfWeek;
3959 proto.isoWeekday = getSetISODayOfWeek;
3960 proto.dayOfYear = getSetDayOfYear;
3961 proto.hour = proto.hours = getSetHour;
3962 proto.minute = proto.minutes = getSetMinute;
3963 proto.second = proto.seconds = getSetSecond;
3964 proto.millisecond = proto.milliseconds = getSetMillisecond;
3965 proto.utcOffset = getSetOffset;
3966 proto.utc = setOffsetToUTC;
3967 proto.local = setOffsetToLocal;
3968 proto.parseZone = setOffsetToParsedOffset;
3969 proto.hasAlignedHourOffset = hasAlignedHourOffset;
3970 proto.isDST = isDaylightSavingTime;
3971 proto.isLocal = isLocal;
3972 proto.isUtcOffset = isUtcOffset;
3973 proto.isUtc = isUtc;
3974 proto.isUTC = isUtc;
3975 proto.zoneAbbr = getZoneAbbr;
3976 proto.zoneName = getZoneName;
3977 proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
3978 proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
3979 proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
3980 proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
3981 proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
3982
3983 function createUnix (input) {
3984 return createLocal(input * 1000);
3985 }
3986
3987 function createInZone () {
3988 return createLocal.apply(null, arguments).parseZone();
3989 }
3990
3991 function preParsePostFormat (string) {
3992 return string;
3993 }
3994
3995 var proto$1 = Locale.prototype;
3996
3997 proto$1.calendar = calendar;
3998 proto$1.longDateFormat = longDateFormat;
3999 proto$1.invalidDate = invalidDate;
4000 proto$1.ordinal = ordinal;
4001 proto$1.preparse = preParsePostFormat;
4002 proto$1.postformat = preParsePostFormat;
4003 proto$1.relativeTime = relativeTime;
4004 proto$1.pastFuture = pastFuture;
4005 proto$1.set = set;
4006
4007 proto$1.months = localeMonths;
4008 proto$1.monthsShort = localeMonthsShort;
4009 proto$1.monthsParse = localeMonthsParse;
4010 proto$1.monthsRegex = monthsRegex;
4011 proto$1.monthsShortRegex = monthsShortRegex;
4012 proto$1.week = localeWeek;
4013 proto$1.firstDayOfYear = localeFirstDayOfYear;
4014 proto$1.firstDayOfWeek = localeFirstDayOfWeek;
4015
4016 proto$1.weekdays = localeWeekdays;
4017 proto$1.weekdaysMin = localeWeekdaysMin;
4018 proto$1.weekdaysShort = localeWeekdaysShort;
4019 proto$1.weekdaysParse = localeWeekdaysParse;
4020
4021 proto$1.weekdaysRegex = weekdaysRegex;
4022 proto$1.weekdaysShortRegex = weekdaysShortRegex;
4023 proto$1.weekdaysMinRegex = weekdaysMinRegex;
4024
4025 proto$1.isPM = localeIsPM;
4026 proto$1.meridiem = localeMeridiem;
4027
4028 function get$1 (format, index, field, setter) {
4029 var locale = getLocale();
4030 var utc = createUTC().set(setter, index);
4031 return locale[field](utc, format);
4032 }
4033
4034 function listMonthsImpl (format, index, field) {
4035 if (isNumber(format)) {
4036 index = format;
4037 format = undefined;
4038 }
4039
4040 format = format || '';
4041
4042 if (index != null) {
4043 return get$1(format, index, field, 'month');
4044 }
4045
4046 var i;
4047 var out = [];
4048 for (i = 0; i < 12; i++) {
4049 out[i] = get$1(format, i, field, 'month');
4050 }
4051 return out;
4052 }
4053
4054 // ()
4055 // (5)
4056 // (fmt, 5)
4057 // (fmt)
4058 // (true)
4059 // (true, 5)
4060 // (true, fmt, 5)
4061 // (true, fmt)
4062 function listWeekdaysImpl (localeSorted, format, index, field) {
4063 if (typeof localeSorted === 'boolean') {
4064 if (isNumber(format)) {
4065 index = format;
4066 format = undefined;
4067 }
4068
4069 format = format || '';
4070 } else {
4071 format = localeSorted;
4072 index = format;
4073 localeSorted = false;
4074
4075 if (isNumber(format)) {
4076 index = format;
4077 format = undefined;
4078 }
4079
4080 format = format || '';
4081 }
4082
4083 var locale = getLocale(),
4084 shift = localeSorted ? locale._week.dow : 0;
4085
4086 if (index != null) {
4087 return get$1(format, (index + shift) % 7, field, 'day');
4088 }
4089
4090 var i;
4091 var out = [];
4092 for (i = 0; i < 7; i++) {
4093 out[i] = get$1(format, (i + shift) % 7, field, 'day');
4094 }
4095 return out;
4096 }
4097
4098 function listMonths (format, index) {
4099 return listMonthsImpl(format, index, 'months');
4100 }
4101
4102 function listMonthsShort (format, index) {
4103 return listMonthsImpl(format, index, 'monthsShort');
4104 }
4105
4106 function listWeekdays (localeSorted, format, index) {
4107 return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
4108 }
4109
4110 function listWeekdaysShort (localeSorted, format, index) {
4111 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
4112 }
4113
4114 function listWeekdaysMin (localeSorted, format, index) {
4115 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
4116 }
4117
4118 getSetGlobalLocale('en', {
4119 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
4120 ordinal : function (number) {
4121 var b = number % 10,
4122 output = (toInt(number % 100 / 10) === 1) ? 'th' :
4123 (b === 1) ? 'st' :
4124 (b === 2) ? 'nd' :
4125 (b === 3) ? 'rd' : 'th';
4126 return number + output;
4127 }
4128 });
4129
4130 // Side effect imports
4131
4132 hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
4133 hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
4134
4135 var mathAbs = Math.abs;
4136
4137 function abs () {
4138 var data = this._data;
4139
4140 this._milliseconds = mathAbs(this._milliseconds);
4141 this._days = mathAbs(this._days);
4142 this._months = mathAbs(this._months);
4143
4144 data.milliseconds = mathAbs(data.milliseconds);
4145 data.seconds = mathAbs(data.seconds);
4146 data.minutes = mathAbs(data.minutes);
4147 data.hours = mathAbs(data.hours);
4148 data.months = mathAbs(data.months);
4149 data.years = mathAbs(data.years);
4150
4151 return this;
4152 }
4153
4154 function addSubtract$1 (duration, input, value, direction) {
4155 var other = createDuration(input, value);
4156
4157 duration._milliseconds += direction * other._milliseconds;
4158 duration._days += direction * other._days;
4159 duration._months += direction * other._months;
4160
4161 return duration._bubble();
4162 }
4163
4164 // supports only 2.0-style add(1, 's') or add(duration)
4165 function add$1 (input, value) {
4166 return addSubtract$1(this, input, value, 1);
4167 }
4168
4169 // supports only 2.0-style subtract(1, 's') or subtract(duration)
4170 function subtract$1 (input, value) {
4171 return addSubtract$1(this, input, value, -1);
4172 }
4173
4174 function absCeil (number) {
4175 if (number < 0) {
4176 return Math.floor(number);
4177 } else {
4178 return Math.ceil(number);
4179 }
4180 }
4181
4182 function bubble () {
4183 var milliseconds = this._milliseconds;
4184 var days = this._days;
4185 var months = this._months;
4186 var data = this._data;
4187 var seconds, minutes, hours, years, monthsFromDays;
4188
4189 // if we have a mix of positive and negative values, bubble down first
4190 // check: https://github.com/moment/moment/issues/2166
4191 if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
4192 (milliseconds <= 0 && days <= 0 && months <= 0))) {
4193 milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
4194 days = 0;
4195 months = 0;
4196 }
4197
4198 // The following code bubbles up values, see the tests for
4199 // examples of what that means.
4200 data.milliseconds = milliseconds % 1000;
4201
4202 seconds = absFloor(milliseconds / 1000);
4203 data.seconds = seconds % 60;
4204
4205 minutes = absFloor(seconds / 60);
4206 data.minutes = minutes % 60;
4207
4208 hours = absFloor(minutes / 60);
4209 data.hours = hours % 24;
4210
4211 days += absFloor(hours / 24);
4212
4213 // convert days to months
4214 monthsFromDays = absFloor(daysToMonths(days));
4215 months += monthsFromDays;
4216 days -= absCeil(monthsToDays(monthsFromDays));
4217
4218 // 12 months -> 1 year
4219 years = absFloor(months / 12);
4220 months %= 12;
4221
4222 data.days = days;
4223 data.months = months;
4224 data.years = years;
4225
4226 return this;
4227 }
4228
4229 function daysToMonths (days) {
4230 // 400 years have 146097 days (taking into account leap year rules)
4231 // 400 years have 12 months === 4800
4232 return days * 4800 / 146097;
4233 }
4234
4235 function monthsToDays (months) {
4236 // the reverse of daysToMonths
4237 return months * 146097 / 4800;
4238 }
4239
4240 function as (units) {
4241 if (!this.isValid()) {
4242 return NaN;
4243 }
4244 var days;
4245 var months;
4246 var milliseconds = this._milliseconds;
4247
4248 units = normalizeUnits(units);
4249
4250 if (units === 'month' || units === 'year') {
4251 days = this._days + milliseconds / 864e5;
4252 months = this._months + daysToMonths(days);
4253 return units === 'month' ? months : months / 12;
4254 } else {
4255 // handle milliseconds separately because of floating point math errors (issue #1867)
4256 days = this._days + Math.round(monthsToDays(this._months));
4257 switch (units) {
4258 case 'week' : return days / 7 + milliseconds / 6048e5;
4259 case 'day' : return days + milliseconds / 864e5;
4260 case 'hour' : return days * 24 + milliseconds / 36e5;
4261 case 'minute' : return days * 1440 + milliseconds / 6e4;
4262 case 'second' : return days * 86400 + milliseconds / 1000;
4263 // Math.floor prevents floating point math errors here
4264 case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
4265 default: throw new Error('Unknown unit ' + units);
4266 }
4267 }
4268 }
4269
4270 // TODO: Use this.as('ms')?
4271 function valueOf$1 () {
4272 if (!this.isValid()) {
4273 return NaN;
4274 }
4275 return (
4276 this._milliseconds +
4277 this._days * 864e5 +
4278 (this._months % 12) * 2592e6 +
4279 toInt(this._months / 12) * 31536e6
4280 );
4281 }
4282
4283 function makeAs (alias) {
4284 return function () {
4285 return this.as(alias);
4286 };
4287 }
4288
4289 var asMilliseconds = makeAs('ms');
4290 var asSeconds = makeAs('s');
4291 var asMinutes = makeAs('m');
4292 var asHours = makeAs('h');
4293 var asDays = makeAs('d');
4294 var asWeeks = makeAs('w');
4295 var asMonths = makeAs('M');
4296 var asYears = makeAs('y');
4297
4298 function clone$1 () {
4299 return createDuration(this);
4300 }
4301
4302 function get$2 (units) {
4303 units = normalizeUnits(units);
4304 return this.isValid() ? this[units + 's']() : NaN;
4305 }
4306
4307 function makeGetter(name) {
4308 return function () {
4309 return this.isValid() ? this._data[name] : NaN;
4310 };
4311 }
4312
4313 var milliseconds = makeGetter('milliseconds');
4314 var seconds = makeGetter('seconds');
4315 var minutes = makeGetter('minutes');
4316 var hours = makeGetter('hours');
4317 var days = makeGetter('days');
4318 var months = makeGetter('months');
4319 var years = makeGetter('years');
4320
4321 function weeks () {
4322 return absFloor(this.days() / 7);
4323 }
4324
4325 var round = Math.round;
4326 var thresholds = {
4327 ss: 44, // a few seconds to seconds
4328 s : 45, // seconds to minute
4329 m : 45, // minutes to hour
4330 h : 22, // hours to day
4331 d : 26, // days to month
4332 M : 11 // months to year
4333 };
4334
4335 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
4336 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
4337 return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
4338 }
4339
4340 function relativeTime$1 (posNegDuration, withoutSuffix, locale) {
4341 var duration = createDuration(posNegDuration).abs();
4342 var seconds = round(duration.as('s'));
4343 var minutes = round(duration.as('m'));
4344 var hours = round(duration.as('h'));
4345 var days = round(duration.as('d'));
4346 var months = round(duration.as('M'));
4347 var years = round(duration.as('y'));
4348
4349 var a = seconds <= thresholds.ss && ['s', seconds] ||
4350 seconds < thresholds.s && ['ss', seconds] ||
4351 minutes <= 1 && ['m'] ||
4352 minutes < thresholds.m && ['mm', minutes] ||
4353 hours <= 1 && ['h'] ||
4354 hours < thresholds.h && ['hh', hours] ||
4355 days <= 1 && ['d'] ||
4356 days < thresholds.d && ['dd', days] ||
4357 months <= 1 && ['M'] ||
4358 months < thresholds.M && ['MM', months] ||
4359 years <= 1 && ['y'] || ['yy', years];
4360
4361 a[2] = withoutSuffix;
4362 a[3] = +posNegDuration > 0;
4363 a[4] = locale;
4364 return substituteTimeAgo.apply(null, a);
4365 }
4366
4367 // This function allows you to set the rounding function for relative time strings
4368 function getSetRelativeTimeRounding (roundingFunction) {
4369 if (roundingFunction === undefined) {
4370 return round;
4371 }
4372 if (typeof(roundingFunction) === 'function') {
4373 round = roundingFunction;
4374 return true;
4375 }
4376 return false;
4377 }
4378
4379 // This function allows you to set a threshold for relative time strings
4380 function getSetRelativeTimeThreshold (threshold, limit) {
4381 if (thresholds[threshold] === undefined) {
4382 return false;
4383 }
4384 if (limit === undefined) {
4385 return thresholds[threshold];
4386 }
4387 thresholds[threshold] = limit;
4388 if (threshold === 's') {
4389 thresholds.ss = limit - 1;
4390 }
4391 return true;
4392 }
4393
4394 function humanize (withSuffix) {
4395 if (!this.isValid()) {
4396 return this.localeData().invalidDate();
4397 }
4398
4399 var locale = this.localeData();
4400 var output = relativeTime$1(this, !withSuffix, locale);
4401
4402 if (withSuffix) {
4403 output = locale.pastFuture(+this, output);
4404 }
4405
4406 return locale.postformat(output);
4407 }
4408
4409 var abs$1 = Math.abs;
4410
4411 function sign(x) {
4412 return ((x > 0) - (x < 0)) || +x;
4413 }
4414
4415 function toISOString$1() {
4416 // for ISO strings we do not use the normal bubbling rules:
4417 // * milliseconds bubble up until they become hours
4418 // * days do not bubble at all
4419 // * months bubble up until they become years
4420 // This is because there is no context-free conversion between hours and days
4421 // (think of clock changes)
4422 // and also not between days and months (28-31 days per month)
4423 if (!this.isValid()) {
4424 return this.localeData().invalidDate();
4425 }
4426
4427 var seconds = abs$1(this._milliseconds) / 1000;
4428 var days = abs$1(this._days);
4429 var months = abs$1(this._months);
4430 var minutes, hours, years;
4431
4432 // 3600 seconds -> 60 minutes -> 1 hour
4433 minutes = absFloor(seconds / 60);
4434 hours = absFloor(minutes / 60);
4435 seconds %= 60;
4436 minutes %= 60;
4437
4438 // 12 months -> 1 year
4439 years = absFloor(months / 12);
4440 months %= 12;
4441
4442
4443 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
4444 var Y = years;
4445 var M = months;
4446 var D = days;
4447 var h = hours;
4448 var m = minutes;
4449 var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
4450 var total = this.asSeconds();
4451
4452 if (!total) {
4453 // this is the same as C#'s (Noda) and python (isodate)...
4454 // but not other JS (goog.date)
4455 return 'P0D';
4456 }
4457
4458 var totalSign = total < 0 ? '-' : '';
4459 var ymSign = sign(this._months) !== sign(total) ? '-' : '';
4460 var daysSign = sign(this._days) !== sign(total) ? '-' : '';
4461 var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
4462
4463 return totalSign + 'P' +
4464 (Y ? ymSign + Y + 'Y' : '') +
4465 (M ? ymSign + M + 'M' : '') +
4466 (D ? daysSign + D + 'D' : '') +
4467 ((h || m || s) ? 'T' : '') +
4468 (h ? hmsSign + h + 'H' : '') +
4469 (m ? hmsSign + m + 'M' : '') +
4470 (s ? hmsSign + s + 'S' : '');
4471 }
4472
4473 var proto$2 = Duration.prototype;
4474
4475 proto$2.isValid = isValid$1;
4476 proto$2.abs = abs;
4477 proto$2.add = add$1;
4478 proto$2.subtract = subtract$1;
4479 proto$2.as = as;
4480 proto$2.asMilliseconds = asMilliseconds;
4481 proto$2.asSeconds = asSeconds;
4482 proto$2.asMinutes = asMinutes;
4483 proto$2.asHours = asHours;
4484 proto$2.asDays = asDays;
4485 proto$2.asWeeks = asWeeks;
4486 proto$2.asMonths = asMonths;
4487 proto$2.asYears = asYears;
4488 proto$2.valueOf = valueOf$1;
4489 proto$2._bubble = bubble;
4490 proto$2.clone = clone$1;
4491 proto$2.get = get$2;
4492 proto$2.milliseconds = milliseconds;
4493 proto$2.seconds = seconds;
4494 proto$2.minutes = minutes;
4495 proto$2.hours = hours;
4496 proto$2.days = days;
4497 proto$2.weeks = weeks;
4498 proto$2.months = months;
4499 proto$2.years = years;
4500 proto$2.humanize = humanize;
4501 proto$2.toISOString = toISOString$1;
4502 proto$2.toString = toISOString$1;
4503 proto$2.toJSON = toISOString$1;
4504 proto$2.locale = locale;
4505 proto$2.localeData = localeData;
4506
4507 proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
4508 proto$2.lang = lang;
4509
4510 // Side effect imports
4511
4512 // FORMATTING
4513
4514 addFormatToken('X', 0, 0, 'unix');
4515 addFormatToken('x', 0, 0, 'valueOf');
4516
4517 // PARSING
4518
4519 addRegexToken('x', matchSigned);
4520 addRegexToken('X', matchTimestamp);
4521 addParseToken('X', function (input, array, config) {
4522 config._d = new Date(parseFloat(input, 10) * 1000);
4523 });
4524 addParseToken('x', function (input, array, config) {
4525 config._d = new Date(toInt(input));
4526 });
4527
4528 // Side effect imports
4529
4530
4531 hooks.version = '2.22.2';
4532
4533 setHookCallback(createLocal);
4534
4535 hooks.fn = proto;
4536 hooks.min = min;
4537 hooks.max = max;
4538 hooks.now = now;
4539 hooks.utc = createUTC;
4540 hooks.unix = createUnix;
4541 hooks.months = listMonths;
4542 hooks.isDate = isDate;
4543 hooks.locale = getSetGlobalLocale;
4544 hooks.invalid = createInvalid;
4545 hooks.duration = createDuration;
4546 hooks.isMoment = isMoment;
4547 hooks.weekdays = listWeekdays;
4548 hooks.parseZone = createInZone;
4549 hooks.localeData = getLocale;
4550 hooks.isDuration = isDuration;
4551 hooks.monthsShort = listMonthsShort;
4552 hooks.weekdaysMin = listWeekdaysMin;
4553 hooks.defineLocale = defineLocale;
4554 hooks.updateLocale = updateLocale;
4555 hooks.locales = listLocales;
4556 hooks.weekdaysShort = listWeekdaysShort;
4557 hooks.normalizeUnits = normalizeUnits;
4558 hooks.relativeTimeRounding = getSetRelativeTimeRounding;
4559 hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
4560 hooks.calendarFormat = getCalendarFormat;
4561 hooks.prototype = proto;
4562
4563 // currently HTML5 input type only supports 24-hour formats
4564 hooks.HTML5_FMT = {
4565 DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" />
4566 DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" />
4567 DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" />
4568 DATE: 'YYYY-MM-DD', // <input type="date" />
4569 TIME: 'HH:mm', // <input type="time" />
4570 TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" />
4571 TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" />
4572 WEEK: 'YYYY-[W]WW', // <input type="week" />
4573 MONTH: 'YYYY-MM' // <input type="month" />
4574 };
4575
4576 return hooks;
4577
4578})));
4579
4580/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(6)(module)))
4581
4582/***/ }),
4583/* 1 */,
4584/* 2 */,
4585/* 3 */,
4586/* 4 */,
4587/* 5 */,
4588/* 6 */
4589/***/ (function(module, exports) {
4590
4591module.exports = function(module) {
4592 if(!module.webpackPolyfill) {
4593 module.deprecate = function() {};
4594 module.paths = [];
4595 // module.parent = undefined by default
4596 if(!module.children) module.children = [];
4597 Object.defineProperty(module, "loaded", {
4598 enumerable: true,
4599 get: function() {
4600 return module.l;
4601 }
4602 });
4603 Object.defineProperty(module, "id", {
4604 enumerable: true,
4605 get: function() {
4606 return module.i;
4607 }
4608 });
4609 module.webpackPolyfill = 1;
4610 }
4611 return module;
4612};
4613
4614
4615/***/ }),
4616/* 7 */,
4617/* 8 */,
4618/* 9 */,
4619/* 10 */,
4620/* 11 */,
4621/* 12 */
4622/***/ (function(module, exports, __webpack_require__) {
4623
4624//! moment.js locale configuration
4625
4626;(function (global, factory) {
4627 true ? factory(__webpack_require__(0)) :
4628 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
4629 factory(global.moment)
4630}(this, (function (moment) { 'use strict';
4631
4632
4633 var af = moment.defineLocale('af', {
4634 months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
4635 monthsShort : 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
4636 weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
4637 weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
4638 weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
4639 meridiemParse: /vm|nm/i,
4640 isPM : function (input) {
4641 return /^nm$/i.test(input);
4642 },
4643 meridiem : function (hours, minutes, isLower) {
4644 if (hours < 12) {
4645 return isLower ? 'vm' : 'VM';
4646 } else {
4647 return isLower ? 'nm' : 'NM';
4648 }
4649 },
4650 longDateFormat : {
4651 LT : 'HH:mm',
4652 LTS : 'HH:mm:ss',
4653 L : 'DD/MM/YYYY',
4654 LL : 'D MMMM YYYY',
4655 LLL : 'D MMMM YYYY HH:mm',
4656 LLLL : 'dddd, D MMMM YYYY HH:mm'
4657 },
4658 calendar : {
4659 sameDay : '[Vandag om] LT',
4660 nextDay : '[Môre om] LT',
4661 nextWeek : 'dddd [om] LT',
4662 lastDay : '[Gister om] LT',
4663 lastWeek : '[Laas] dddd [om] LT',
4664 sameElse : 'L'
4665 },
4666 relativeTime : {
4667 future : 'oor %s',
4668 past : '%s gelede',
4669 s : '\'n paar sekondes',
4670 ss : '%d sekondes',
4671 m : '\'n minuut',
4672 mm : '%d minute',
4673 h : '\'n uur',
4674 hh : '%d ure',
4675 d : '\'n dag',
4676 dd : '%d dae',
4677 M : '\'n maand',
4678 MM : '%d maande',
4679 y : '\'n jaar',
4680 yy : '%d jaar'
4681 },
4682 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
4683 ordinal : function (number) {
4684 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
4685 },
4686 week : {
4687 dow : 1, // Maandag is die eerste dag van die week.
4688 doy : 4 // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
4689 }
4690 });
4691
4692 return af;
4693
4694})));
4695
4696
4697/***/ }),
4698/* 13 */
4699/***/ (function(module, exports, __webpack_require__) {
4700
4701//! moment.js locale configuration
4702
4703;(function (global, factory) {
4704 true ? factory(__webpack_require__(0)) :
4705 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
4706 factory(global.moment)
4707}(this, (function (moment) { 'use strict';
4708
4709
4710 var arDz = moment.defineLocale('ar-dz', {
4711 months : 'جانÙÙŠ_ÙÙŠÙري_مارس_Ø£Ùريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوÙمبر_ديسمبر'.split('_'),
4712 monthsShort : 'جانÙÙŠ_ÙÙŠÙري_مارس_Ø£Ùريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوÙمبر_ديسمبر'.split('_'),
4713 weekdays : 'الأØد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4714 weekdaysShort : 'اØد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4715 weekdaysMin : 'Ø£Ø_إث_ثلا_أر_خم_جم_سب'.split('_'),
4716 weekdaysParseExact : true,
4717 longDateFormat : {
4718 LT : 'HH:mm',
4719 LTS : 'HH:mm:ss',
4720 L : 'DD/MM/YYYY',
4721 LL : 'D MMMM YYYY',
4722 LLL : 'D MMMM YYYY HH:mm',
4723 LLLL : 'dddd D MMMM YYYY HH:mm'
4724 },
4725 calendar : {
4726 sameDay: '[اليوم على الساعة] LT',
4727 nextDay: '[غدا على الساعة] LT',
4728 nextWeek: 'dddd [على الساعة] LT',
4729 lastDay: '[أمس على الساعة] LT',
4730 lastWeek: 'dddd [على الساعة] LT',
4731 sameElse: 'L'
4732 },
4733 relativeTime : {
4734 future : 'ÙÙŠ %s',
4735 past : 'منذ %s',
4736 s : 'ثوان',
4737 ss : '%d ثانية',
4738 m : 'دقيقة',
4739 mm : '%d دقائق',
4740 h : 'ساعة',
4741 hh : '%d ساعات',
4742 d : 'يوم',
4743 dd : '%d أيام',
4744 M : 'شهر',
4745 MM : '%d أشهر',
4746 y : 'سنة',
4747 yy : '%d سنوات'
4748 },
4749 week : {
4750 dow : 0, // Sunday is the first day of the week.
4751 doy : 4 // The week that contains Jan 1st is the first week of the year.
4752 }
4753 });
4754
4755 return arDz;
4756
4757})));
4758
4759
4760/***/ }),
4761/* 14 */
4762/***/ (function(module, exports, __webpack_require__) {
4763
4764//! moment.js locale configuration
4765
4766;(function (global, factory) {
4767 true ? factory(__webpack_require__(0)) :
4768 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
4769 factory(global.moment)
4770}(this, (function (moment) { 'use strict';
4771
4772
4773 var arKw = moment.defineLocale('ar-kw', {
4774 months : 'يناير_Ùبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4775 monthsShort : 'يناير_Ùبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4776 weekdays : 'الأØد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4777 weekdaysShort : 'اØد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4778 weekdaysMin : 'Ø_Ù†_Ø«_ر_Ø®_ج_س'.split('_'),
4779 weekdaysParseExact : true,
4780 longDateFormat : {
4781 LT : 'HH:mm',
4782 LTS : 'HH:mm:ss',
4783 L : 'DD/MM/YYYY',
4784 LL : 'D MMMM YYYY',
4785 LLL : 'D MMMM YYYY HH:mm',
4786 LLLL : 'dddd D MMMM YYYY HH:mm'
4787 },
4788 calendar : {
4789 sameDay: '[اليوم على الساعة] LT',
4790 nextDay: '[غدا على الساعة] LT',
4791 nextWeek: 'dddd [على الساعة] LT',
4792 lastDay: '[أمس على الساعة] LT',
4793 lastWeek: 'dddd [على الساعة] LT',
4794 sameElse: 'L'
4795 },
4796 relativeTime : {
4797 future : 'ÙÙŠ %s',
4798 past : 'منذ %s',
4799 s : 'ثوان',
4800 ss : '%d ثانية',
4801 m : 'دقيقة',
4802 mm : '%d دقائق',
4803 h : 'ساعة',
4804 hh : '%d ساعات',
4805 d : 'يوم',
4806 dd : '%d أيام',
4807 M : 'شهر',
4808 MM : '%d أشهر',
4809 y : 'سنة',
4810 yy : '%d سنوات'
4811 },
4812 week : {
4813 dow : 0, // Sunday is the first day of the week.
4814 doy : 12 // The week that contains Jan 1st is the first week of the year.
4815 }
4816 });
4817
4818 return arKw;
4819
4820})));
4821
4822
4823/***/ }),
4824/* 15 */
4825/***/ (function(module, exports, __webpack_require__) {
4826
4827//! moment.js locale configuration
4828
4829;(function (global, factory) {
4830 true ? factory(__webpack_require__(0)) :
4831 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
4832 factory(global.moment)
4833}(this, (function (moment) { 'use strict';
4834
4835
4836 var symbolMap = {
4837 '1': '1',
4838 '2': '2',
4839 '3': '3',
4840 '4': '4',
4841 '5': '5',
4842 '6': '6',
4843 '7': '7',
4844 '8': '8',
4845 '9': '9',
4846 '0': '0'
4847 }, pluralForm = function (n) {
4848 return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
4849 }, plurals = {
4850 s : ['أقل من ثانية', 'ثانية واØدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
4851 m : ['أقل من دقيقة', 'دقيقة واØدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
4852 h : ['أقل من ساعة', 'ساعة واØدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
4853 d : ['أقل من يوم', 'يوم واØد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
4854 M : ['أقل من شهر', 'شهر واØد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
4855 y : ['أقل من عام', 'عام واØد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
4856 }, pluralize = function (u) {
4857 return function (number, withoutSuffix, string, isFuture) {
4858 var f = pluralForm(number),
4859 str = plurals[u][pluralForm(number)];
4860 if (f === 2) {
4861 str = str[withoutSuffix ? 0 : 1];
4862 }
4863 return str.replace(/%d/i, number);
4864 };
4865 }, months = [
4866 'يناير',
4867 'Ùبراير',
4868 'مارس',
4869 'أبريل',
4870 'مايو',
4871 'يونيو',
4872 'يوليو',
4873 'أغسطس',
4874 'سبتمبر',
4875 'أكتوبر',
4876 'نوÙمبر',
4877 'ديسمبر'
4878 ];
4879
4880 var arLy = moment.defineLocale('ar-ly', {
4881 months : months,
4882 monthsShort : months,
4883 weekdays : 'الأØد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4884 weekdaysShort : 'Ø£Øد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4885 weekdaysMin : 'Ø_Ù†_Ø«_ر_Ø®_ج_س'.split('_'),
4886 weekdaysParseExact : true,
4887 longDateFormat : {
4888 LT : 'HH:mm',
4889 LTS : 'HH:mm:ss',
4890 L : 'D/\u200FM/\u200FYYYY',
4891 LL : 'D MMMM YYYY',
4892 LLL : 'D MMMM YYYY HH:mm',
4893 LLLL : 'dddd D MMMM YYYY HH:mm'
4894 },
4895 meridiemParse: /ص|م/,
4896 isPM : function (input) {
4897 return 'Ù…' === input;
4898 },
4899 meridiem : function (hour, minute, isLower) {
4900 if (hour < 12) {
4901 return 'ص';
4902 } else {
4903 return 'Ù…';
4904 }
4905 },
4906 calendar : {
4907 sameDay: '[اليوم عند الساعة] LT',
4908 nextDay: '[غدًا عند الساعة] LT',
4909 nextWeek: 'dddd [عند الساعة] LT',
4910 lastDay: '[أمس عند الساعة] LT',
4911 lastWeek: 'dddd [عند الساعة] LT',
4912 sameElse: 'L'
4913 },
4914 relativeTime : {
4915 future : 'بعد %s',
4916 past : 'منذ %s',
4917 s : pluralize('s'),
4918 ss : pluralize('s'),
4919 m : pluralize('m'),
4920 mm : pluralize('m'),
4921 h : pluralize('h'),
4922 hh : pluralize('h'),
4923 d : pluralize('d'),
4924 dd : pluralize('d'),
4925 M : pluralize('M'),
4926 MM : pluralize('M'),
4927 y : pluralize('y'),
4928 yy : pluralize('y')
4929 },
4930 preparse: function (string) {
4931 return string.replace(/،/g, ',');
4932 },
4933 postformat: function (string) {
4934 return string.replace(/\d/g, function (match) {
4935 return symbolMap[match];
4936 }).replace(/,/g, '،');
4937 },
4938 week : {
4939 dow : 6, // Saturday is the first day of the week.
4940 doy : 12 // The week that contains Jan 1st is the first week of the year.
4941 }
4942 });
4943
4944 return arLy;
4945
4946})));
4947
4948
4949/***/ }),
4950/* 16 */
4951/***/ (function(module, exports, __webpack_require__) {
4952
4953//! moment.js locale configuration
4954
4955;(function (global, factory) {
4956 true ? factory(__webpack_require__(0)) :
4957 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
4958 factory(global.moment)
4959}(this, (function (moment) { 'use strict';
4960
4961
4962 var arMa = moment.defineLocale('ar-ma', {
4963 months : 'يناير_Ùبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4964 monthsShort : 'يناير_Ùبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4965 weekdays : 'الأØد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4966 weekdaysShort : 'اØد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4967 weekdaysMin : 'Ø_Ù†_Ø«_ر_Ø®_ج_س'.split('_'),
4968 weekdaysParseExact : true,
4969 longDateFormat : {
4970 LT : 'HH:mm',
4971 LTS : 'HH:mm:ss',
4972 L : 'DD/MM/YYYY',
4973 LL : 'D MMMM YYYY',
4974 LLL : 'D MMMM YYYY HH:mm',
4975 LLLL : 'dddd D MMMM YYYY HH:mm'
4976 },
4977 calendar : {
4978 sameDay: '[اليوم على الساعة] LT',
4979 nextDay: '[غدا على الساعة] LT',
4980 nextWeek: 'dddd [على الساعة] LT',
4981 lastDay: '[أمس على الساعة] LT',
4982 lastWeek: 'dddd [على الساعة] LT',
4983 sameElse: 'L'
4984 },
4985 relativeTime : {
4986 future : 'ÙÙŠ %s',
4987 past : 'منذ %s',
4988 s : 'ثوان',
4989 ss : '%d ثانية',
4990 m : 'دقيقة',
4991 mm : '%d دقائق',
4992 h : 'ساعة',
4993 hh : '%d ساعات',
4994 d : 'يوم',
4995 dd : '%d أيام',
4996 M : 'شهر',
4997 MM : '%d أشهر',
4998 y : 'سنة',
4999 yy : '%d سنوات'
5000 },
5001 week : {
5002 dow : 6, // Saturday is the first day of the week.
5003 doy : 12 // The week that contains Jan 1st is the first week of the year.
5004 }
5005 });
5006
5007 return arMa;
5008
5009})));
5010
5011
5012/***/ }),
5013/* 17 */
5014/***/ (function(module, exports, __webpack_require__) {
5015
5016//! moment.js locale configuration
5017
5018;(function (global, factory) {
5019 true ? factory(__webpack_require__(0)) :
5020 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5021 factory(global.moment)
5022}(this, (function (moment) { 'use strict';
5023
5024
5025 var symbolMap = {
5026 '1': 'Ù¡',
5027 '2': 'Ù¢',
5028 '3': 'Ù£',
5029 '4': 'Ù¤',
5030 '5': 'Ù¥',
5031 '6': 'Ù¦',
5032 '7': 'Ù§',
5033 '8': 'Ù¨',
5034 '9': 'Ù©',
5035 '0': 'Ù '
5036 }, numberMap = {
5037 'Ù¡': '1',
5038 'Ù¢': '2',
5039 'Ù£': '3',
5040 'Ù¤': '4',
5041 'Ù¥': '5',
5042 'Ù¦': '6',
5043 'Ù§': '7',
5044 'Ù¨': '8',
5045 'Ù©': '9',
5046 'Ù ': '0'
5047 };
5048
5049 var arSa = moment.defineLocale('ar-sa', {
5050 months : 'يناير_Ùبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوÙمبر_ديسمبر'.split('_'),
5051 monthsShort : 'يناير_Ùبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوÙمبر_ديسمبر'.split('_'),
5052 weekdays : 'الأØد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5053 weekdaysShort : 'Ø£Øد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
5054 weekdaysMin : 'Ø_Ù†_Ø«_ر_Ø®_ج_س'.split('_'),
5055 weekdaysParseExact : true,
5056 longDateFormat : {
5057 LT : 'HH:mm',
5058 LTS : 'HH:mm:ss',
5059 L : 'DD/MM/YYYY',
5060 LL : 'D MMMM YYYY',
5061 LLL : 'D MMMM YYYY HH:mm',
5062 LLLL : 'dddd D MMMM YYYY HH:mm'
5063 },
5064 meridiemParse: /ص|م/,
5065 isPM : function (input) {
5066 return 'Ù…' === input;
5067 },
5068 meridiem : function (hour, minute, isLower) {
5069 if (hour < 12) {
5070 return 'ص';
5071 } else {
5072 return 'Ù…';
5073 }
5074 },
5075 calendar : {
5076 sameDay: '[اليوم على الساعة] LT',
5077 nextDay: '[غدا على الساعة] LT',
5078 nextWeek: 'dddd [على الساعة] LT',
5079 lastDay: '[أمس على الساعة] LT',
5080 lastWeek: 'dddd [على الساعة] LT',
5081 sameElse: 'L'
5082 },
5083 relativeTime : {
5084 future : 'ÙÙŠ %s',
5085 past : 'منذ %s',
5086 s : 'ثوان',
5087 ss : '%d ثانية',
5088 m : 'دقيقة',
5089 mm : '%d دقائق',
5090 h : 'ساعة',
5091 hh : '%d ساعات',
5092 d : 'يوم',
5093 dd : '%d أيام',
5094 M : 'شهر',
5095 MM : '%d أشهر',
5096 y : 'سنة',
5097 yy : '%d سنوات'
5098 },
5099 preparse: function (string) {
5100 return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
5101 return numberMap[match];
5102 }).replace(/،/g, ',');
5103 },
5104 postformat: function (string) {
5105 return string.replace(/\d/g, function (match) {
5106 return symbolMap[match];
5107 }).replace(/,/g, '،');
5108 },
5109 week : {
5110 dow : 0, // Sunday is the first day of the week.
5111 doy : 6 // The week that contains Jan 1st is the first week of the year.
5112 }
5113 });
5114
5115 return arSa;
5116
5117})));
5118
5119
5120/***/ }),
5121/* 18 */
5122/***/ (function(module, exports, __webpack_require__) {
5123
5124//! moment.js locale configuration
5125
5126;(function (global, factory) {
5127 true ? factory(__webpack_require__(0)) :
5128 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5129 factory(global.moment)
5130}(this, (function (moment) { 'use strict';
5131
5132
5133 var arTn = moment.defineLocale('ar-tn', {
5134 months: 'جانÙÙŠ_ÙÙŠÙري_مارس_Ø£Ùريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوÙمبر_ديسمبر'.split('_'),
5135 monthsShort: 'جانÙÙŠ_ÙÙŠÙري_مارس_Ø£Ùريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوÙمبر_ديسمبر'.split('_'),
5136 weekdays: 'الأØد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5137 weekdaysShort: 'Ø£Øد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
5138 weekdaysMin: 'Ø_Ù†_Ø«_ر_Ø®_ج_س'.split('_'),
5139 weekdaysParseExact : true,
5140 longDateFormat: {
5141 LT: 'HH:mm',
5142 LTS: 'HH:mm:ss',
5143 L: 'DD/MM/YYYY',
5144 LL: 'D MMMM YYYY',
5145 LLL: 'D MMMM YYYY HH:mm',
5146 LLLL: 'dddd D MMMM YYYY HH:mm'
5147 },
5148 calendar: {
5149 sameDay: '[اليوم على الساعة] LT',
5150 nextDay: '[غدا على الساعة] LT',
5151 nextWeek: 'dddd [على الساعة] LT',
5152 lastDay: '[أمس على الساعة] LT',
5153 lastWeek: 'dddd [على الساعة] LT',
5154 sameElse: 'L'
5155 },
5156 relativeTime: {
5157 future: 'ÙÙŠ %s',
5158 past: 'منذ %s',
5159 s: 'ثوان',
5160 ss : '%d ثانية',
5161 m: 'دقيقة',
5162 mm: '%d دقائق',
5163 h: 'ساعة',
5164 hh: '%d ساعات',
5165 d: 'يوم',
5166 dd: '%d أيام',
5167 M: 'شهر',
5168 MM: '%d أشهر',
5169 y: 'سنة',
5170 yy: '%d سنوات'
5171 },
5172 week: {
5173 dow: 1, // Monday is the first day of the week.
5174 doy: 4 // The week that contains Jan 4th is the first week of the year.
5175 }
5176 });
5177
5178 return arTn;
5179
5180})));
5181
5182
5183/***/ }),
5184/* 19 */
5185/***/ (function(module, exports, __webpack_require__) {
5186
5187//! moment.js locale configuration
5188
5189;(function (global, factory) {
5190 true ? factory(__webpack_require__(0)) :
5191 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5192 factory(global.moment)
5193}(this, (function (moment) { 'use strict';
5194
5195
5196 var symbolMap = {
5197 '1': 'Ù¡',
5198 '2': 'Ù¢',
5199 '3': 'Ù£',
5200 '4': 'Ù¤',
5201 '5': 'Ù¥',
5202 '6': 'Ù¦',
5203 '7': 'Ù§',
5204 '8': 'Ù¨',
5205 '9': 'Ù©',
5206 '0': 'Ù '
5207 }, numberMap = {
5208 'Ù¡': '1',
5209 'Ù¢': '2',
5210 'Ù£': '3',
5211 'Ù¤': '4',
5212 'Ù¥': '5',
5213 'Ù¦': '6',
5214 'Ù§': '7',
5215 'Ù¨': '8',
5216 'Ù©': '9',
5217 'Ù ': '0'
5218 }, pluralForm = function (n) {
5219 return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
5220 }, plurals = {
5221 s : ['أقل من ثانية', 'ثانية واØدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
5222 m : ['أقل من دقيقة', 'دقيقة واØدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
5223 h : ['أقل من ساعة', 'ساعة واØدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
5224 d : ['أقل من يوم', 'يوم واØد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
5225 M : ['أقل من شهر', 'شهر واØد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
5226 y : ['أقل من عام', 'عام واØد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
5227 }, pluralize = function (u) {
5228 return function (number, withoutSuffix, string, isFuture) {
5229 var f = pluralForm(number),
5230 str = plurals[u][pluralForm(number)];
5231 if (f === 2) {
5232 str = str[withoutSuffix ? 0 : 1];
5233 }
5234 return str.replace(/%d/i, number);
5235 };
5236 }, months = [
5237 'يناير',
5238 'Ùبراير',
5239 'مارس',
5240 'أبريل',
5241 'مايو',
5242 'يونيو',
5243 'يوليو',
5244 'أغسطس',
5245 'سبتمبر',
5246 'أكتوبر',
5247 'نوÙمبر',
5248 'ديسمبر'
5249 ];
5250
5251 var ar = moment.defineLocale('ar', {
5252 months : months,
5253 monthsShort : months,
5254 weekdays : 'الأØد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5255 weekdaysShort : 'Ø£Øد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
5256 weekdaysMin : 'Ø_Ù†_Ø«_ر_Ø®_ج_س'.split('_'),
5257 weekdaysParseExact : true,
5258 longDateFormat : {
5259 LT : 'HH:mm',
5260 LTS : 'HH:mm:ss',
5261 L : 'D/\u200FM/\u200FYYYY',
5262 LL : 'D MMMM YYYY',
5263 LLL : 'D MMMM YYYY HH:mm',
5264 LLLL : 'dddd D MMMM YYYY HH:mm'
5265 },
5266 meridiemParse: /ص|م/,
5267 isPM : function (input) {
5268 return 'Ù…' === input;
5269 },
5270 meridiem : function (hour, minute, isLower) {
5271 if (hour < 12) {
5272 return 'ص';
5273 } else {
5274 return 'Ù…';
5275 }
5276 },
5277 calendar : {
5278 sameDay: '[اليوم عند الساعة] LT',
5279 nextDay: '[غدًا عند الساعة] LT',
5280 nextWeek: 'dddd [عند الساعة] LT',
5281 lastDay: '[أمس عند الساعة] LT',
5282 lastWeek: 'dddd [عند الساعة] LT',
5283 sameElse: 'L'
5284 },
5285 relativeTime : {
5286 future : 'بعد %s',
5287 past : 'منذ %s',
5288 s : pluralize('s'),
5289 ss : pluralize('s'),
5290 m : pluralize('m'),
5291 mm : pluralize('m'),
5292 h : pluralize('h'),
5293 hh : pluralize('h'),
5294 d : pluralize('d'),
5295 dd : pluralize('d'),
5296 M : pluralize('M'),
5297 MM : pluralize('M'),
5298 y : pluralize('y'),
5299 yy : pluralize('y')
5300 },
5301 preparse: function (string) {
5302 return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
5303 return numberMap[match];
5304 }).replace(/،/g, ',');
5305 },
5306 postformat: function (string) {
5307 return string.replace(/\d/g, function (match) {
5308 return symbolMap[match];
5309 }).replace(/,/g, '،');
5310 },
5311 week : {
5312 dow : 6, // Saturday is the first day of the week.
5313 doy : 12 // The week that contains Jan 1st is the first week of the year.
5314 }
5315 });
5316
5317 return ar;
5318
5319})));
5320
5321
5322/***/ }),
5323/* 20 */
5324/***/ (function(module, exports, __webpack_require__) {
5325
5326//! moment.js locale configuration
5327
5328;(function (global, factory) {
5329 true ? factory(__webpack_require__(0)) :
5330 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5331 factory(global.moment)
5332}(this, (function (moment) { 'use strict';
5333
5334
5335 var suffixes = {
5336 1: '-inci',
5337 5: '-inci',
5338 8: '-inci',
5339 70: '-inci',
5340 80: '-inci',
5341 2: '-nci',
5342 7: '-nci',
5343 20: '-nci',
5344 50: '-nci',
5345 3: '-üncü',
5346 4: '-üncü',
5347 100: '-üncü',
5348 6: '-ncı',
5349 9: '-uncu',
5350 10: '-uncu',
5351 30: '-uncu',
5352 60: '-ıncı',
5353 90: '-ıncı'
5354 };
5355
5356 var az = moment.defineLocale('az', {
5357 months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
5358 monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
5359 weekdays : 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
5360 weekdaysShort : 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
5361 weekdaysMin : 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
5362 weekdaysParseExact : true,
5363 longDateFormat : {
5364 LT : 'HH:mm',
5365 LTS : 'HH:mm:ss',
5366 L : 'DD.MM.YYYY',
5367 LL : 'D MMMM YYYY',
5368 LLL : 'D MMMM YYYY HH:mm',
5369 LLLL : 'dddd, D MMMM YYYY HH:mm'
5370 },
5371 calendar : {
5372 sameDay : '[bugün saat] LT',
5373 nextDay : '[sabah saat] LT',
5374 nextWeek : '[gələn həftə] dddd [saat] LT',
5375 lastDay : '[dünən] LT',
5376 lastWeek : '[keçən həftə] dddd [saat] LT',
5377 sameElse : 'L'
5378 },
5379 relativeTime : {
5380 future : '%s sonra',
5381 past : '%s əvvəl',
5382 s : 'birneçə saniyə',
5383 ss : '%d saniyÉ™',
5384 m : 'bir dəqiqə',
5385 mm : '%d dəqiqə',
5386 h : 'bir saat',
5387 hh : '%d saat',
5388 d : 'bir gün',
5389 dd : '%d gün',
5390 M : 'bir ay',
5391 MM : '%d ay',
5392 y : 'bir il',
5393 yy : '%d il'
5394 },
5395 meridiemParse: /gecə|səhər|gündüz|axşam/,
5396 isPM : function (input) {
5397 return /^(gündüz|axşam)$/.test(input);
5398 },
5399 meridiem : function (hour, minute, isLower) {
5400 if (hour < 4) {
5401 return 'gecÉ™';
5402 } else if (hour < 12) {
5403 return 'səhər';
5404 } else if (hour < 17) {
5405 return 'gündüz';
5406 } else {
5407 return 'axÅŸam';
5408 }
5409 },
5410 dayOfMonthOrdinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
5411 ordinal : function (number) {
5412 if (number === 0) { // special case for zero
5413 return number + '-ıncı';
5414 }
5415 var a = number % 10,
5416 b = number % 100 - a,
5417 c = number >= 100 ? 100 : null;
5418 return number + (suffixes[a] || suffixes[b] || suffixes[c]);
5419 },
5420 week : {
5421 dow : 1, // Monday is the first day of the week.
5422 doy : 7 // The week that contains Jan 1st is the first week of the year.
5423 }
5424 });
5425
5426 return az;
5427
5428})));
5429
5430
5431/***/ }),
5432/* 21 */
5433/***/ (function(module, exports, __webpack_require__) {
5434
5435//! moment.js locale configuration
5436
5437;(function (global, factory) {
5438 true ? factory(__webpack_require__(0)) :
5439 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5440 factory(global.moment)
5441}(this, (function (moment) { 'use strict';
5442
5443
5444 function plural(word, num) {
5445 var forms = word.split('_');
5446 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]);
5447 }
5448 function relativeTimeWithPlural(number, withoutSuffix, key) {
5449 var format = {
5450 'ss': withoutSuffix ? 'Ñекунда_Ñекунды_Ñекунд' : 'Ñекунду_Ñекунды_Ñекунд',
5451 'mm': withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
5452 'hh': withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
5453 'dd': 'дзень_дні_дзён',
5454 'MM': 'меÑÑц_меÑÑцы_меÑÑцаў',
5455 'yy': 'год_гады_гадоў'
5456 };
5457 if (key === 'm') {
5458 return withoutSuffix ? 'хвіліна' : 'хвіліну';
5459 }
5460 else if (key === 'h') {
5461 return withoutSuffix ? 'гадзіна' : 'гадзіну';
5462 }
5463 else {
5464 return number + ' ' + plural(format[key], +number);
5465 }
5466 }
5467
5468 var be = moment.defineLocale('be', {
5469 months : {
5470 format: 'ÑтудзенÑ_лютага_Ñакавіка_краÑавіка_траўнÑ_чÑрвенÑ_ліпенÑ_жніўнÑ_вераÑнÑ_каÑтрычніка_ліÑтапада_ÑнежнÑ'.split('_'),
5471 standalone: 'Ñтудзень_люты_Ñакавік_краÑавік_травень_чÑрвень_ліпень_жнівень_вераÑень_каÑтрычнік_ліÑтапад_Ñнежань'.split('_')
5472 },
5473 monthsShort : 'Ñтуд_лют_Ñак_краÑ_трав_чÑрв_ліп_жнів_вер_каÑÑ‚_ліÑÑ‚_Ñнеж'.split('_'),
5474 weekdays : {
5475 format: 'нÑдзелю_панÑдзелак_аўторак_Ñераду_чацвер_пÑтніцу_Ñуботу'.split('_'),
5476 standalone: 'нÑдзелÑ_панÑдзелак_аўторак_Ñерада_чацвер_пÑтніца_Ñубота'.split('_'),
5477 isFormat: /\[ ?[Ууў] ?(?:мінулую|наÑтупную)? ?\] ?dddd/
5478 },
5479 weekdaysShort : 'нд_пн_ат_ÑÑ€_чц_пт_Ñб'.split('_'),
5480 weekdaysMin : 'нд_пн_ат_ÑÑ€_чц_пт_Ñб'.split('_'),
5481 longDateFormat : {
5482 LT : 'HH:mm',
5483 LTS : 'HH:mm:ss',
5484 L : 'DD.MM.YYYY',
5485 LL : 'D MMMM YYYY г.',
5486 LLL : 'D MMMM YYYY г., HH:mm',
5487 LLLL : 'dddd, D MMMM YYYY г., HH:mm'
5488 },
5489 calendar : {
5490 sameDay: '[Ð¡Ñ‘Ð½Ð½Ñ Ñž] LT',
5491 nextDay: '[Заўтра ў] LT',
5492 lastDay: '[Учора ў] LT',
5493 nextWeek: function () {
5494 return '[У] dddd [ў] LT';
5495 },
5496 lastWeek: function () {
5497 switch (this.day()) {
5498 case 0:
5499 case 3:
5500 case 5:
5501 case 6:
5502 return '[У мінулую] dddd [ў] LT';
5503 case 1:
5504 case 2:
5505 case 4:
5506 return '[У мінулы] dddd [ў] LT';
5507 }
5508 },
5509 sameElse: 'L'
5510 },
5511 relativeTime : {
5512 future : 'праз %s',
5513 past : '%s таму',
5514 s : 'некалькі Ñекунд',
5515 m : relativeTimeWithPlural,
5516 mm : relativeTimeWithPlural,
5517 h : relativeTimeWithPlural,
5518 hh : relativeTimeWithPlural,
5519 d : 'дзень',
5520 dd : relativeTimeWithPlural,
5521 M : 'меÑÑц',
5522 MM : relativeTimeWithPlural,
5523 y : 'год',
5524 yy : relativeTimeWithPlural
5525 },
5526 meridiemParse: /ночы|раніцы|днÑ|вечара/,
5527 isPM : function (input) {
5528 return /^(днÑ|вечара)$/.test(input);
5529 },
5530 meridiem : function (hour, minute, isLower) {
5531 if (hour < 4) {
5532 return 'ночы';
5533 } else if (hour < 12) {
5534 return 'раніцы';
5535 } else if (hour < 17) {
5536 return 'днÑ';
5537 } else {
5538 return 'вечара';
5539 }
5540 },
5541 dayOfMonthOrdinalParse: /\d{1,2}-(і|ы|га)/,
5542 ordinal: function (number, period) {
5543 switch (period) {
5544 case 'M':
5545 case 'd':
5546 case 'DDD':
5547 case 'w':
5548 case 'W':
5549 return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-Ñ–' : number + '-Ñ‹';
5550 case 'D':
5551 return number + '-га';
5552 default:
5553 return number;
5554 }
5555 },
5556 week : {
5557 dow : 1, // Monday is the first day of the week.
5558 doy : 7 // The week that contains Jan 1st is the first week of the year.
5559 }
5560 });
5561
5562 return be;
5563
5564})));
5565
5566
5567/***/ }),
5568/* 22 */
5569/***/ (function(module, exports, __webpack_require__) {
5570
5571//! moment.js locale configuration
5572
5573;(function (global, factory) {
5574 true ? factory(__webpack_require__(0)) :
5575 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5576 factory(global.moment)
5577}(this, (function (moment) { 'use strict';
5578
5579
5580 var bg = moment.defineLocale('bg', {
5581 months : 'Ñнуари_февруари_март_април_май_юни_юли_авгуÑÑ‚_Ñептември_октомври_ноември_декември'.split('_'),
5582 monthsShort : 'Ñнр_фев_мар_апр_май_юни_юли_авг_Ñеп_окт_ное_дек'.split('_'),
5583 weekdays : 'неделÑ_понеделник_вторник_ÑÑ€Ñда_четвъртък_петък_Ñъбота'.split('_'),
5584 weekdaysShort : 'нед_пон_вто_ÑÑ€Ñ_чет_пет_Ñъб'.split('_'),
5585 weekdaysMin : 'нд_пн_вт_ÑÑ€_чт_пт_Ñб'.split('_'),
5586 longDateFormat : {
5587 LT : 'H:mm',
5588 LTS : 'H:mm:ss',
5589 L : 'D.MM.YYYY',
5590 LL : 'D MMMM YYYY',
5591 LLL : 'D MMMM YYYY H:mm',
5592 LLLL : 'dddd, D MMMM YYYY H:mm'
5593 },
5594 calendar : {
5595 sameDay : '[Ð”Ð½ÐµÑ Ð²] LT',
5596 nextDay : '[Утре в] LT',
5597 nextWeek : 'dddd [в] LT',
5598 lastDay : '[Вчера в] LT',
5599 lastWeek : function () {
5600 switch (this.day()) {
5601 case 0:
5602 case 3:
5603 case 6:
5604 return '[В изминалата] dddd [в] LT';
5605 case 1:
5606 case 2:
5607 case 4:
5608 case 5:
5609 return '[Ð’ изминалиÑ] dddd [в] LT';
5610 }
5611 },
5612 sameElse : 'L'
5613 },
5614 relativeTime : {
5615 future : 'Ñлед %s',
5616 past : 'преди %s',
5617 s : 'нÑколко Ñекунди',
5618 ss : '%d Ñекунди',
5619 m : 'минута',
5620 mm : '%d минути',
5621 h : 'чаÑ',
5622 hh : '%d чаÑа',
5623 d : 'ден',
5624 dd : '%d дни',
5625 M : 'меÑец',
5626 MM : '%d меÑеца',
5627 y : 'година',
5628 yy : '%d години'
5629 },
5630 dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
5631 ordinal : function (number) {
5632 var lastDigit = number % 10,
5633 last2Digits = number % 100;
5634 if (number === 0) {
5635 return number + '-ев';
5636 } else if (last2Digits === 0) {
5637 return number + '-ен';
5638 } else if (last2Digits > 10 && last2Digits < 20) {
5639 return number + '-ти';
5640 } else if (lastDigit === 1) {
5641 return number + '-ви';
5642 } else if (lastDigit === 2) {
5643 return number + '-ри';
5644 } else if (lastDigit === 7 || lastDigit === 8) {
5645 return number + '-ми';
5646 } else {
5647 return number + '-ти';
5648 }
5649 },
5650 week : {
5651 dow : 1, // Monday is the first day of the week.
5652 doy : 7 // The week that contains Jan 1st is the first week of the year.
5653 }
5654 });
5655
5656 return bg;
5657
5658})));
5659
5660
5661/***/ }),
5662/* 23 */
5663/***/ (function(module, exports, __webpack_require__) {
5664
5665//! moment.js locale configuration
5666
5667;(function (global, factory) {
5668 true ? factory(__webpack_require__(0)) :
5669 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5670 factory(global.moment)
5671}(this, (function (moment) { 'use strict';
5672
5673
5674 var bm = moment.defineLocale('bm', {
5675 months : 'Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo'.split('_'),
5676 monthsShort : 'Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des'.split('_'),
5677 weekdays : 'Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri'.split('_'),
5678 weekdaysShort : 'Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib'.split('_'),
5679 weekdaysMin : 'Ka_Nt_Ta_Ar_Al_Ju_Si'.split('_'),
5680 longDateFormat : {
5681 LT : 'HH:mm',
5682 LTS : 'HH:mm:ss',
5683 L : 'DD/MM/YYYY',
5684 LL : 'MMMM [tile] D [san] YYYY',
5685 LLL : 'MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm',
5686 LLLL : 'dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm'
5687 },
5688 calendar : {
5689 sameDay : '[Bi lɛrɛ] LT',
5690 nextDay : '[Sini lɛrɛ] LT',
5691 nextWeek : 'dddd [don lɛrɛ] LT',
5692 lastDay : '[Kunu lɛrɛ] LT',
5693 lastWeek : 'dddd [tɛmɛnen lɛrɛ] LT',
5694 sameElse : 'L'
5695 },
5696 relativeTime : {
5697 future : '%s kɔnɔ',
5698 past : 'a bÉ› %s bÉ”',
5699 s : 'sanga dama dama',
5700 ss : 'sekondi %d',
5701 m : 'miniti kelen',
5702 mm : 'miniti %d',
5703 h : 'lɛrɛ kelen',
5704 hh : 'lɛrɛ %d',
5705 d : 'tile kelen',
5706 dd : 'tile %d',
5707 M : 'kalo kelen',
5708 MM : 'kalo %d',
5709 y : 'san kelen',
5710 yy : 'san %d'
5711 },
5712 week : {
5713 dow : 1, // Monday is the first day of the week.
5714 doy : 4 // The week that contains Jan 4th is the first week of the year.
5715 }
5716 });
5717
5718 return bm;
5719
5720})));
5721
5722
5723/***/ }),
5724/* 24 */
5725/***/ (function(module, exports, __webpack_require__) {
5726
5727//! moment.js locale configuration
5728
5729;(function (global, factory) {
5730 true ? factory(__webpack_require__(0)) :
5731 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5732 factory(global.moment)
5733}(this, (function (moment) { 'use strict';
5734
5735
5736 var symbolMap = {
5737 '1': '১',
5738 '2': '২',
5739 '3': '৩',
5740 '4': '৪',
5741 '5': '৫',
5742 '6': '৬',
5743 '7': 'à§',
5744 '8': '৮',
5745 '9': '৯',
5746 '0': '০'
5747 },
5748 numberMap = {
5749 '১': '1',
5750 '২': '2',
5751 '৩': '3',
5752 '৪': '4',
5753 '৫': '5',
5754 '৬': '6',
5755 'à§': '7',
5756 '৮': '8',
5757 '৯': '9',
5758 '০': '0'
5759 };
5760
5761 var bn = moment.defineLocale('bn', {
5762 months : 'জানà§à§Ÿà¦¾à¦°à§€_ফেবà§à¦°à§à§Ÿà¦¾à¦°à¦¿_মারà§à¦š_à¦à¦ªà§à¦°à¦¿à¦²_মে_জà§à¦¨_জà§à¦²à¦¾à¦‡_আগসà§à¦Ÿ_সেপà§à¦Ÿà§‡à¦®à§à¦¬à¦°_অকà§à¦Ÿà§‹à¦¬à¦°_নà¦à§‡à¦®à§à¦¬à¦°_ডিসেমà§à¦¬à¦°'.split('_'),
5763 monthsShort : 'জানà§_ফেব_মারà§à¦š_à¦à¦ªà§à¦°_মে_জà§à¦¨_জà§à¦²_আগ_সেপà§à¦Ÿ_অকà§à¦Ÿà§‹_নà¦à§‡_ডিসে'.split('_'),
5764 weekdays : 'রবিবার_সোমবার_মঙà§à¦—লবার_বà§à¦§à¦¬à¦¾à¦°_বৃহসà§à¦ªà¦¤à¦¿à¦¬à¦¾à¦°_শà§à¦•à§à¦°à¦¬à¦¾à¦°_শনিবার'.split('_'),
5765 weekdaysShort : 'রবি_সোম_মঙà§à¦—ল_বà§à¦§_বৃহসà§à¦ªà¦¤à¦¿_শà§à¦•à§à¦°_শনি'.split('_'),
5766 weekdaysMin : 'রবি_সোম_মঙà§à¦—_বà§à¦§_বৃহঃ_শà§à¦•à§à¦°_শনি'.split('_'),
5767 longDateFormat : {
5768 LT : 'A h:mm সময়',
5769 LTS : 'A h:mm:ss সময়',
5770 L : 'DD/MM/YYYY',
5771 LL : 'D MMMM YYYY',
5772 LLL : 'D MMMM YYYY, A h:mm সময়',
5773 LLLL : 'dddd, D MMMM YYYY, A h:mm সময়'
5774 },
5775 calendar : {
5776 sameDay : '[আজ] LT',
5777 nextDay : '[আগামীকাল] LT',
5778 nextWeek : 'dddd, LT',
5779 lastDay : '[গতকাল] LT',
5780 lastWeek : '[গত] dddd, LT',
5781 sameElse : 'L'
5782 },
5783 relativeTime : {
5784 future : '%s পরে',
5785 past : '%s আগে',
5786 s : 'কয়েক সেকেনà§à¦¡',
5787 ss : '%d সেকেনà§à¦¡',
5788 m : 'à¦à¦• মিনিট',
5789 mm : '%d মিনিট',
5790 h : 'à¦à¦• ঘনà§à¦Ÿà¦¾',
5791 hh : '%d ঘনà§à¦Ÿà¦¾',
5792 d : 'à¦à¦• দিন',
5793 dd : '%d দিন',
5794 M : 'à¦à¦• মাস',
5795 MM : '%d মাস',
5796 y : 'à¦à¦• বছর',
5797 yy : '%d বছর'
5798 },
5799 preparse: function (string) {
5800 return string.replace(/[১২৩৪৫৬à§à§®à§¯à§¦]/g, function (match) {
5801 return numberMap[match];
5802 });
5803 },
5804 postformat: function (string) {
5805 return string.replace(/\d/g, function (match) {
5806 return symbolMap[match];
5807 });
5808 },
5809 meridiemParse: /রাত|সকাল|দà§à¦ªà§à¦°|বিকাল|রাত/,
5810 meridiemHour : function (hour, meridiem) {
5811 if (hour === 12) {
5812 hour = 0;
5813 }
5814 if ((meridiem === 'রাত' && hour >= 4) ||
5815 (meridiem === 'দà§à¦ªà§à¦°' && hour < 5) ||
5816 meridiem === 'বিকাল') {
5817 return hour + 12;
5818 } else {
5819 return hour;
5820 }
5821 },
5822 meridiem : function (hour, minute, isLower) {
5823 if (hour < 4) {
5824 return 'রাত';
5825 } else if (hour < 10) {
5826 return 'সকাল';
5827 } else if (hour < 17) {
5828 return 'দà§à¦ªà§à¦°';
5829 } else if (hour < 20) {
5830 return 'বিকাল';
5831 } else {
5832 return 'রাত';
5833 }
5834 },
5835 week : {
5836 dow : 0, // Sunday is the first day of the week.
5837 doy : 6 // The week that contains Jan 1st is the first week of the year.
5838 }
5839 });
5840
5841 return bn;
5842
5843})));
5844
5845
5846/***/ }),
5847/* 25 */
5848/***/ (function(module, exports, __webpack_require__) {
5849
5850//! moment.js locale configuration
5851
5852;(function (global, factory) {
5853 true ? factory(__webpack_require__(0)) :
5854 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5855 factory(global.moment)
5856}(this, (function (moment) { 'use strict';
5857
5858
5859 var symbolMap = {
5860 '1': '༡',
5861 '2': '༢',
5862 '3': '༣',
5863 '4': '༤',
5864 '5': '༥',
5865 '6': '༦',
5866 '7': '༧',
5867 '8': '༨',
5868 '9': '༩',
5869 '0': '༠'
5870 },
5871 numberMap = {
5872 '༡': '1',
5873 '༢': '2',
5874 '༣': '3',
5875 '༤': '4',
5876 '༥': '5',
5877 '༦': '6',
5878 '༧': '7',
5879 '༨': '8',
5880 '༩': '9',
5881 '༠': '0'
5882 };
5883
5884 var bo = moment.defineLocale('bo', {
5885 months : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
5886 monthsShort : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
5887 weekdays : 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
5888 weekdaysShort : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
5889 weekdaysMin : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
5890 longDateFormat : {
5891 LT : 'A h:mm',
5892 LTS : 'A h:mm:ss',
5893 L : 'DD/MM/YYYY',
5894 LL : 'D MMMM YYYY',
5895 LLL : 'D MMMM YYYY, A h:mm',
5896 LLLL : 'dddd, D MMMM YYYY, A h:mm'
5897 },
5898 calendar : {
5899 sameDay : '[དི་རིང] LT',
5900 nextDay : '[སང་ཉིན] LT',
5901 nextWeek : '[བདུན་ཕྲག་རྗེས་མ], LT',
5902 lastDay : '[à½à¼‹à½¦à½„] LT',
5903 lastWeek : '[བདུན་ཕྲག་མà½à½ ་མ] dddd, LT',
5904 sameElse : 'L'
5905 },
5906 relativeTime : {
5907 future : '%s ལ་',
5908 past : '%s སྔན་ལ',
5909 s : 'ལམ་སང',
5910 ss : '%d སà¾à½¢à¼‹à½†à¼',
5911 m : 'སà¾à½¢à¼‹à½˜à¼‹à½‚ཅིག',
5912 mm : '%d སà¾à½¢à¼‹à½˜',
5913 h : 'ཆུ་ཚོད་གཅིག',
5914 hh : '%d ཆུ་ཚོད',
5915 d : 'ཉིན་གཅིག',
5916 dd : '%d ཉིན་',
5917 M : 'ཟླ་བ་གཅིག',
5918 MM : '%d ཟླ་བ',
5919 y : 'ལོ་གཅིག',
5920 yy : '%d ལོ'
5921 },
5922 preparse: function (string) {
5923 return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
5924 return numberMap[match];
5925 });
5926 },
5927 postformat: function (string) {
5928 return string.replace(/\d/g, function (match) {
5929 return symbolMap[match];
5930 });
5931 },
5932 meridiemParse: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
5933 meridiemHour : function (hour, meridiem) {
5934 if (hour === 12) {
5935 hour = 0;
5936 }
5937 if ((meridiem === 'མཚན་མོ' && hour >= 4) ||
5938 (meridiem === 'ཉིན་གུང' && hour < 5) ||
5939 meridiem === 'དགོང་དག') {
5940 return hour + 12;
5941 } else {
5942 return hour;
5943 }
5944 },
5945 meridiem : function (hour, minute, isLower) {
5946 if (hour < 4) {
5947 return 'མཚན་མོ';
5948 } else if (hour < 10) {
5949 return 'ཞོགས་ཀས';
5950 } else if (hour < 17) {
5951 return 'ཉིན་གུང';
5952 } else if (hour < 20) {
5953 return 'དགོང་དག';
5954 } else {
5955 return 'མཚན་མོ';
5956 }
5957 },
5958 week : {
5959 dow : 0, // Sunday is the first day of the week.
5960 doy : 6 // The week that contains Jan 1st is the first week of the year.
5961 }
5962 });
5963
5964 return bo;
5965
5966})));
5967
5968
5969/***/ }),
5970/* 26 */
5971/***/ (function(module, exports, __webpack_require__) {
5972
5973//! moment.js locale configuration
5974
5975;(function (global, factory) {
5976 true ? factory(__webpack_require__(0)) :
5977 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
5978 factory(global.moment)
5979}(this, (function (moment) { 'use strict';
5980
5981
5982 function relativeTimeWithMutation(number, withoutSuffix, key) {
5983 var format = {
5984 'mm': 'munutenn',
5985 'MM': 'miz',
5986 'dd': 'devezh'
5987 };
5988 return number + ' ' + mutation(format[key], number);
5989 }
5990 function specialMutationForYears(number) {
5991 switch (lastNumber(number)) {
5992 case 1:
5993 case 3:
5994 case 4:
5995 case 5:
5996 case 9:
5997 return number + ' bloaz';
5998 default:
5999 return number + ' vloaz';
6000 }
6001 }
6002 function lastNumber(number) {
6003 if (number > 9) {
6004 return lastNumber(number % 10);
6005 }
6006 return number;
6007 }
6008 function mutation(text, number) {
6009 if (number === 2) {
6010 return softMutation(text);
6011 }
6012 return text;
6013 }
6014 function softMutation(text) {
6015 var mutationTable = {
6016 'm': 'v',
6017 'b': 'v',
6018 'd': 'z'
6019 };
6020 if (mutationTable[text.charAt(0)] === undefined) {
6021 return text;
6022 }
6023 return mutationTable[text.charAt(0)] + text.substring(1);
6024 }
6025
6026 var br = moment.defineLocale('br', {
6027 months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
6028 monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
6029 weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
6030 weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
6031 weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
6032 weekdaysParseExact : true,
6033 longDateFormat : {
6034 LT : 'h[e]mm A',
6035 LTS : 'h[e]mm:ss A',
6036 L : 'DD/MM/YYYY',
6037 LL : 'D [a viz] MMMM YYYY',
6038 LLL : 'D [a viz] MMMM YYYY h[e]mm A',
6039 LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A'
6040 },
6041 calendar : {
6042 sameDay : '[Hiziv da] LT',
6043 nextDay : '[Warc\'hoazh da] LT',
6044 nextWeek : 'dddd [da] LT',
6045 lastDay : '[Dec\'h da] LT',
6046 lastWeek : 'dddd [paset da] LT',
6047 sameElse : 'L'
6048 },
6049 relativeTime : {
6050 future : 'a-benn %s',
6051 past : '%s \'zo',
6052 s : 'un nebeud segondennoù',
6053 ss : '%d eilenn',
6054 m : 'ur vunutenn',
6055 mm : relativeTimeWithMutation,
6056 h : 'un eur',
6057 hh : '%d eur',
6058 d : 'un devezh',
6059 dd : relativeTimeWithMutation,
6060 M : 'ur miz',
6061 MM : relativeTimeWithMutation,
6062 y : 'ur bloaz',
6063 yy : specialMutationForYears
6064 },
6065 dayOfMonthOrdinalParse: /\d{1,2}(añ|vet)/,
6066 ordinal : function (number) {
6067 var output = (number === 1) ? 'añ' : 'vet';
6068 return number + output;
6069 },
6070 week : {
6071 dow : 1, // Monday is the first day of the week.
6072 doy : 4 // The week that contains Jan 4th is the first week of the year.
6073 }
6074 });
6075
6076 return br;
6077
6078})));
6079
6080
6081/***/ }),
6082/* 27 */
6083/***/ (function(module, exports, __webpack_require__) {
6084
6085//! moment.js locale configuration
6086
6087;(function (global, factory) {
6088 true ? factory(__webpack_require__(0)) :
6089 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6090 factory(global.moment)
6091}(this, (function (moment) { 'use strict';
6092
6093
6094 function translate(number, withoutSuffix, key) {
6095 var result = number + ' ';
6096 switch (key) {
6097 case 'ss':
6098 if (number === 1) {
6099 result += 'sekunda';
6100 } else if (number === 2 || number === 3 || number === 4) {
6101 result += 'sekunde';
6102 } else {
6103 result += 'sekundi';
6104 }
6105 return result;
6106 case 'm':
6107 return withoutSuffix ? 'jedna minuta' : 'jedne minute';
6108 case 'mm':
6109 if (number === 1) {
6110 result += 'minuta';
6111 } else if (number === 2 || number === 3 || number === 4) {
6112 result += 'minute';
6113 } else {
6114 result += 'minuta';
6115 }
6116 return result;
6117 case 'h':
6118 return withoutSuffix ? 'jedan sat' : 'jednog sata';
6119 case 'hh':
6120 if (number === 1) {
6121 result += 'sat';
6122 } else if (number === 2 || number === 3 || number === 4) {
6123 result += 'sata';
6124 } else {
6125 result += 'sati';
6126 }
6127 return result;
6128 case 'dd':
6129 if (number === 1) {
6130 result += 'dan';
6131 } else {
6132 result += 'dana';
6133 }
6134 return result;
6135 case 'MM':
6136 if (number === 1) {
6137 result += 'mjesec';
6138 } else if (number === 2 || number === 3 || number === 4) {
6139 result += 'mjeseca';
6140 } else {
6141 result += 'mjeseci';
6142 }
6143 return result;
6144 case 'yy':
6145 if (number === 1) {
6146 result += 'godina';
6147 } else if (number === 2 || number === 3 || number === 4) {
6148 result += 'godine';
6149 } else {
6150 result += 'godina';
6151 }
6152 return result;
6153 }
6154 }
6155
6156 var bs = moment.defineLocale('bs', {
6157 months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
6158 monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
6159 monthsParseExact: true,
6160 weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'),
6161 weekdaysShort : 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'),
6162 weekdaysMin : 'ne_po_ut_sr_Äe_pe_su'.split('_'),
6163 weekdaysParseExact : true,
6164 longDateFormat : {
6165 LT : 'H:mm',
6166 LTS : 'H:mm:ss',
6167 L : 'DD.MM.YYYY',
6168 LL : 'D. MMMM YYYY',
6169 LLL : 'D. MMMM YYYY H:mm',
6170 LLLL : 'dddd, D. MMMM YYYY H:mm'
6171 },
6172 calendar : {
6173 sameDay : '[danas u] LT',
6174 nextDay : '[sutra u] LT',
6175 nextWeek : function () {
6176 switch (this.day()) {
6177 case 0:
6178 return '[u] [nedjelju] [u] LT';
6179 case 3:
6180 return '[u] [srijedu] [u] LT';
6181 case 6:
6182 return '[u] [subotu] [u] LT';
6183 case 1:
6184 case 2:
6185 case 4:
6186 case 5:
6187 return '[u] dddd [u] LT';
6188 }
6189 },
6190 lastDay : '[juÄer u] LT',
6191 lastWeek : function () {
6192 switch (this.day()) {
6193 case 0:
6194 case 3:
6195 return '[prošlu] dddd [u] LT';
6196 case 6:
6197 return '[prošle] [subote] [u] LT';
6198 case 1:
6199 case 2:
6200 case 4:
6201 case 5:
6202 return '[prošli] dddd [u] LT';
6203 }
6204 },
6205 sameElse : 'L'
6206 },
6207 relativeTime : {
6208 future : 'za %s',
6209 past : 'prije %s',
6210 s : 'par sekundi',
6211 ss : translate,
6212 m : translate,
6213 mm : translate,
6214 h : translate,
6215 hh : translate,
6216 d : 'dan',
6217 dd : translate,
6218 M : 'mjesec',
6219 MM : translate,
6220 y : 'godinu',
6221 yy : translate
6222 },
6223 dayOfMonthOrdinalParse: /\d{1,2}\./,
6224 ordinal : '%d.',
6225 week : {
6226 dow : 1, // Monday is the first day of the week.
6227 doy : 7 // The week that contains Jan 1st is the first week of the year.
6228 }
6229 });
6230
6231 return bs;
6232
6233})));
6234
6235
6236/***/ }),
6237/* 28 */
6238/***/ (function(module, exports, __webpack_require__) {
6239
6240//! moment.js locale configuration
6241
6242;(function (global, factory) {
6243 true ? factory(__webpack_require__(0)) :
6244 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6245 factory(global.moment)
6246}(this, (function (moment) { 'use strict';
6247
6248
6249 var ca = moment.defineLocale('ca', {
6250 months : {
6251 standalone: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
6252 format: 'de gener_de febrer_de març_d\'abril_de maig_de juny_de juliol_d\'agost_de setembre_d\'octubre_de novembre_de desembre'.split('_'),
6253 isFormat: /D[oD]?(\s)+MMMM/
6254 },
6255 monthsShort : 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split('_'),
6256 monthsParseExact : true,
6257 weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
6258 weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
6259 weekdaysMin : 'dg_dl_dt_dc_dj_dv_ds'.split('_'),
6260 weekdaysParseExact : true,
6261 longDateFormat : {
6262 LT : 'H:mm',
6263 LTS : 'H:mm:ss',
6264 L : 'DD/MM/YYYY',
6265 LL : 'D MMMM [de] YYYY',
6266 ll : 'D MMM YYYY',
6267 LLL : 'D MMMM [de] YYYY [a les] H:mm',
6268 lll : 'D MMM YYYY, H:mm',
6269 LLLL : 'dddd D MMMM [de] YYYY [a les] H:mm',
6270 llll : 'ddd D MMM YYYY, H:mm'
6271 },
6272 calendar : {
6273 sameDay : function () {
6274 return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6275 },
6276 nextDay : function () {
6277 return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6278 },
6279 nextWeek : function () {
6280 return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6281 },
6282 lastDay : function () {
6283 return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6284 },
6285 lastWeek : function () {
6286 return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6287 },
6288 sameElse : 'L'
6289 },
6290 relativeTime : {
6291 future : 'd\'aquà %s',
6292 past : 'fa %s',
6293 s : 'uns segons',
6294 ss : '%d segons',
6295 m : 'un minut',
6296 mm : '%d minuts',
6297 h : 'una hora',
6298 hh : '%d hores',
6299 d : 'un dia',
6300 dd : '%d dies',
6301 M : 'un mes',
6302 MM : '%d mesos',
6303 y : 'un any',
6304 yy : '%d anys'
6305 },
6306 dayOfMonthOrdinalParse: /\d{1,2}(r|n|t|è|a)/,
6307 ordinal : function (number, period) {
6308 var output = (number === 1) ? 'r' :
6309 (number === 2) ? 'n' :
6310 (number === 3) ? 'r' :
6311 (number === 4) ? 't' : 'è';
6312 if (period === 'w' || period === 'W') {
6313 output = 'a';
6314 }
6315 return number + output;
6316 },
6317 week : {
6318 dow : 1, // Monday is the first day of the week.
6319 doy : 4 // The week that contains Jan 4th is the first week of the year.
6320 }
6321 });
6322
6323 return ca;
6324
6325})));
6326
6327
6328/***/ }),
6329/* 29 */
6330/***/ (function(module, exports, __webpack_require__) {
6331
6332//! moment.js locale configuration
6333
6334;(function (global, factory) {
6335 true ? factory(__webpack_require__(0)) :
6336 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6337 factory(global.moment)
6338}(this, (function (moment) { 'use strict';
6339
6340
6341 var months = 'leden_únor_bÅ™ezen_duben_kvÄ›ten_Äerven_Äervenec_srpen_zářÃ_Å™Ãjen_listopad_prosinec'.split('_'),
6342 monthsShort = 'led_úno_bÅ™e_dub_kvÄ›_Ävn_Ävc_srp_zář_Å™Ãj_lis_pro'.split('_');
6343 function plural(n) {
6344 return (n > 1) && (n < 5) && (~~(n / 10) !== 1);
6345 }
6346 function translate(number, withoutSuffix, key, isFuture) {
6347 var result = number + ' ';
6348 switch (key) {
6349 case 's': // a few seconds / in a few seconds / a few seconds ago
6350 return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
6351 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
6352 if (withoutSuffix || isFuture) {
6353 return result + (plural(number) ? 'sekundy' : 'sekund');
6354 } else {
6355 return result + 'sekundami';
6356 }
6357 break;
6358 case 'm': // a minute / in a minute / a minute ago
6359 return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
6360 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
6361 if (withoutSuffix || isFuture) {
6362 return result + (plural(number) ? 'minuty' : 'minut');
6363 } else {
6364 return result + 'minutami';
6365 }
6366 break;
6367 case 'h': // an hour / in an hour / an hour ago
6368 return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
6369 case 'hh': // 9 hours / in 9 hours / 9 hours ago
6370 if (withoutSuffix || isFuture) {
6371 return result + (plural(number) ? 'hodiny' : 'hodin');
6372 } else {
6373 return result + 'hodinami';
6374 }
6375 break;
6376 case 'd': // a day / in a day / a day ago
6377 return (withoutSuffix || isFuture) ? 'den' : 'dnem';
6378 case 'dd': // 9 days / in 9 days / 9 days ago
6379 if (withoutSuffix || isFuture) {
6380 return result + (plural(number) ? 'dny' : 'dnÃ');
6381 } else {
6382 return result + 'dny';
6383 }
6384 break;
6385 case 'M': // a month / in a month / a month ago
6386 return (withoutSuffix || isFuture) ? 'mÄ›sÃc' : 'mÄ›sÃcem';
6387 case 'MM': // 9 months / in 9 months / 9 months ago
6388 if (withoutSuffix || isFuture) {
6389 return result + (plural(number) ? 'mÄ›sÃce' : 'mÄ›sÃců');
6390 } else {
6391 return result + 'mÄ›sÃci';
6392 }
6393 break;
6394 case 'y': // a year / in a year / a year ago
6395 return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
6396 case 'yy': // 9 years / in 9 years / 9 years ago
6397 if (withoutSuffix || isFuture) {
6398 return result + (plural(number) ? 'roky' : 'let');
6399 } else {
6400 return result + 'lety';
6401 }
6402 break;
6403 }
6404 }
6405
6406 var cs = moment.defineLocale('cs', {
6407 months : months,
6408 monthsShort : monthsShort,
6409 monthsParse : (function (months, monthsShort) {
6410 var i, _monthsParse = [];
6411 for (i = 0; i < 12; i++) {
6412 // use custom parser to solve problem with July (Äervenec)
6413 _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
6414 }
6415 return _monthsParse;
6416 }(months, monthsShort)),
6417 shortMonthsParse : (function (monthsShort) {
6418 var i, _shortMonthsParse = [];
6419 for (i = 0; i < 12; i++) {
6420 _shortMonthsParse[i] = new RegExp('^' + monthsShort[i] + '$', 'i');
6421 }
6422 return _shortMonthsParse;
6423 }(monthsShort)),
6424 longMonthsParse : (function (months) {
6425 var i, _longMonthsParse = [];
6426 for (i = 0; i < 12; i++) {
6427 _longMonthsParse[i] = new RegExp('^' + months[i] + '$', 'i');
6428 }
6429 return _longMonthsParse;
6430 }(months)),
6431 weekdays : 'nedÄ›le_pondÄ›lÃ_úterý_stÅ™eda_Ätvrtek_pátek_sobota'.split('_'),
6432 weekdaysShort : 'ne_po_út_st_Ät_pá_so'.split('_'),
6433 weekdaysMin : 'ne_po_út_st_Ät_pá_so'.split('_'),
6434 longDateFormat : {
6435 LT: 'H:mm',
6436 LTS : 'H:mm:ss',
6437 L : 'DD.MM.YYYY',
6438 LL : 'D. MMMM YYYY',
6439 LLL : 'D. MMMM YYYY H:mm',
6440 LLLL : 'dddd D. MMMM YYYY H:mm',
6441 l : 'D. M. YYYY'
6442 },
6443 calendar : {
6444 sameDay: '[dnes v] LT',
6445 nextDay: '[zÃtra v] LT',
6446 nextWeek: function () {
6447 switch (this.day()) {
6448 case 0:
6449 return '[v neděli v] LT';
6450 case 1:
6451 case 2:
6452 return '[v] dddd [v] LT';
6453 case 3:
6454 return '[ve středu v] LT';
6455 case 4:
6456 return '[ve Ätvrtek v] LT';
6457 case 5:
6458 return '[v pátek v] LT';
6459 case 6:
6460 return '[v sobotu v] LT';
6461 }
6462 },
6463 lastDay: '[vÄera v] LT',
6464 lastWeek: function () {
6465 switch (this.day()) {
6466 case 0:
6467 return '[minulou neděli v] LT';
6468 case 1:
6469 case 2:
6470 return '[minulé] dddd [v] LT';
6471 case 3:
6472 return '[minulou středu v] LT';
6473 case 4:
6474 case 5:
6475 return '[minulý] dddd [v] LT';
6476 case 6:
6477 return '[minulou sobotu v] LT';
6478 }
6479 },
6480 sameElse: 'L'
6481 },
6482 relativeTime : {
6483 future : 'za %s',
6484 past : 'před %s',
6485 s : translate,
6486 ss : translate,
6487 m : translate,
6488 mm : translate,
6489 h : translate,
6490 hh : translate,
6491 d : translate,
6492 dd : translate,
6493 M : translate,
6494 MM : translate,
6495 y : translate,
6496 yy : translate
6497 },
6498 dayOfMonthOrdinalParse : /\d{1,2}\./,
6499 ordinal : '%d.',
6500 week : {
6501 dow : 1, // Monday is the first day of the week.
6502 doy : 4 // The week that contains Jan 4th is the first week of the year.
6503 }
6504 });
6505
6506 return cs;
6507
6508})));
6509
6510
6511/***/ }),
6512/* 30 */
6513/***/ (function(module, exports, __webpack_require__) {
6514
6515//! moment.js locale configuration
6516
6517;(function (global, factory) {
6518 true ? factory(__webpack_require__(0)) :
6519 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6520 factory(global.moment)
6521}(this, (function (moment) { 'use strict';
6522
6523
6524 var cv = moment.defineLocale('cv', {
6525 months : 'кӑрлач_нарӑÑ_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split('_'),
6526 monthsShort : 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
6527 weekdays : 'вырÑарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_Ñрнекун_шӑматкун'.split('_'),
6528 weekdaysShort : 'выр_тун_ытл_юн_кӗҫ_Ñрн_шӑм'.split('_'),
6529 weekdaysMin : 'вр_тн_Ñ‹Ñ‚_юн_кҫ_ÑÑ€_шм'.split('_'),
6530 longDateFormat : {
6531 LT : 'HH:mm',
6532 LTS : 'HH:mm:ss',
6533 L : 'DD-MM-YYYY',
6534 LL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
6535 LLL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
6536 LLLL : 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm'
6537 },
6538 calendar : {
6539 sameDay: '[ПаÑн] LT [Ñехетре]',
6540 nextDay: '[Ыран] LT [Ñехетре]',
6541 lastDay: '[Ӗнер] LT [Ñехетре]',
6542 nextWeek: '[ҪитеÑ] dddd LT [Ñехетре]',
6543 lastWeek: '[Иртнӗ] dddd LT [Ñехетре]',
6544 sameElse: 'L'
6545 },
6546 relativeTime : {
6547 future : function (output) {
6548 var affix = /Ñехет$/i.exec(output) ? 'рен' : /ҫул$/i.exec(output) ? 'тан' : 'ран';
6549 return output + affix;
6550 },
6551 past : '%s каÑлла',
6552 s : 'пӗр-ик ҫеккунт',
6553 ss : '%d ҫеккунт',
6554 m : 'пӗр минут',
6555 mm : '%d минут',
6556 h : 'пӗр Ñехет',
6557 hh : '%d Ñехет',
6558 d : 'пӗр кун',
6559 dd : '%d кун',
6560 M : 'пӗр уйӑх',
6561 MM : '%d уйӑх',
6562 y : 'пӗр ҫул',
6563 yy : '%d ҫул'
6564 },
6565 dayOfMonthOrdinalParse: /\d{1,2}-мӗш/,
6566 ordinal : '%d-мӗш',
6567 week : {
6568 dow : 1, // Monday is the first day of the week.
6569 doy : 7 // The week that contains Jan 1st is the first week of the year.
6570 }
6571 });
6572
6573 return cv;
6574
6575})));
6576
6577
6578/***/ }),
6579/* 31 */
6580/***/ (function(module, exports, __webpack_require__) {
6581
6582//! moment.js locale configuration
6583
6584;(function (global, factory) {
6585 true ? factory(__webpack_require__(0)) :
6586 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6587 factory(global.moment)
6588}(this, (function (moment) { 'use strict';
6589
6590
6591 var cy = moment.defineLocale('cy', {
6592 months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
6593 monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
6594 weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
6595 weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
6596 weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
6597 weekdaysParseExact : true,
6598 // time formats are the same as en-gb
6599 longDateFormat: {
6600 LT: 'HH:mm',
6601 LTS : 'HH:mm:ss',
6602 L: 'DD/MM/YYYY',
6603 LL: 'D MMMM YYYY',
6604 LLL: 'D MMMM YYYY HH:mm',
6605 LLLL: 'dddd, D MMMM YYYY HH:mm'
6606 },
6607 calendar: {
6608 sameDay: '[Heddiw am] LT',
6609 nextDay: '[Yfory am] LT',
6610 nextWeek: 'dddd [am] LT',
6611 lastDay: '[Ddoe am] LT',
6612 lastWeek: 'dddd [diwethaf am] LT',
6613 sameElse: 'L'
6614 },
6615 relativeTime: {
6616 future: 'mewn %s',
6617 past: '%s yn ôl',
6618 s: 'ychydig eiliadau',
6619 ss: '%d eiliad',
6620 m: 'munud',
6621 mm: '%d munud',
6622 h: 'awr',
6623 hh: '%d awr',
6624 d: 'diwrnod',
6625 dd: '%d diwrnod',
6626 M: 'mis',
6627 MM: '%d mis',
6628 y: 'blwyddyn',
6629 yy: '%d flynedd'
6630 },
6631 dayOfMonthOrdinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
6632 // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
6633 ordinal: function (number) {
6634 var b = number,
6635 output = '',
6636 lookup = [
6637 '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
6638 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
6639 ];
6640 if (b > 20) {
6641 if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
6642 output = 'fed'; // not 30ain, 70ain or 90ain
6643 } else {
6644 output = 'ain';
6645 }
6646 } else if (b > 0) {
6647 output = lookup[b];
6648 }
6649 return number + output;
6650 },
6651 week : {
6652 dow : 1, // Monday is the first day of the week.
6653 doy : 4 // The week that contains Jan 4th is the first week of the year.
6654 }
6655 });
6656
6657 return cy;
6658
6659})));
6660
6661
6662/***/ }),
6663/* 32 */
6664/***/ (function(module, exports, __webpack_require__) {
6665
6666//! moment.js locale configuration
6667
6668;(function (global, factory) {
6669 true ? factory(__webpack_require__(0)) :
6670 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6671 factory(global.moment)
6672}(this, (function (moment) { 'use strict';
6673
6674
6675 var da = moment.defineLocale('da', {
6676 months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
6677 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
6678 weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
6679 weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'),
6680 weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
6681 longDateFormat : {
6682 LT : 'HH:mm',
6683 LTS : 'HH:mm:ss',
6684 L : 'DD.MM.YYYY',
6685 LL : 'D. MMMM YYYY',
6686 LLL : 'D. MMMM YYYY HH:mm',
6687 LLLL : 'dddd [d.] D. MMMM YYYY [kl.] HH:mm'
6688 },
6689 calendar : {
6690 sameDay : '[i dag kl.] LT',
6691 nextDay : '[i morgen kl.] LT',
6692 nextWeek : 'på dddd [kl.] LT',
6693 lastDay : '[i går kl.] LT',
6694 lastWeek : '[i] dddd[s kl.] LT',
6695 sameElse : 'L'
6696 },
6697 relativeTime : {
6698 future : 'om %s',
6699 past : '%s siden',
6700 s : 'få sekunder',
6701 ss : '%d sekunder',
6702 m : 'et minut',
6703 mm : '%d minutter',
6704 h : 'en time',
6705 hh : '%d timer',
6706 d : 'en dag',
6707 dd : '%d dage',
6708 M : 'en måned',
6709 MM : '%d måneder',
6710 y : 'et år',
6711 yy : '%d år'
6712 },
6713 dayOfMonthOrdinalParse: /\d{1,2}\./,
6714 ordinal : '%d.',
6715 week : {
6716 dow : 1, // Monday is the first day of the week.
6717 doy : 4 // The week that contains Jan 4th is the first week of the year.
6718 }
6719 });
6720
6721 return da;
6722
6723})));
6724
6725
6726/***/ }),
6727/* 33 */
6728/***/ (function(module, exports, __webpack_require__) {
6729
6730//! moment.js locale configuration
6731
6732;(function (global, factory) {
6733 true ? factory(__webpack_require__(0)) :
6734 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6735 factory(global.moment)
6736}(this, (function (moment) { 'use strict';
6737
6738
6739 function processRelativeTime(number, withoutSuffix, key, isFuture) {
6740 var format = {
6741 'm': ['eine Minute', 'einer Minute'],
6742 'h': ['eine Stunde', 'einer Stunde'],
6743 'd': ['ein Tag', 'einem Tag'],
6744 'dd': [number + ' Tage', number + ' Tagen'],
6745 'M': ['ein Monat', 'einem Monat'],
6746 'MM': [number + ' Monate', number + ' Monaten'],
6747 'y': ['ein Jahr', 'einem Jahr'],
6748 'yy': [number + ' Jahre', number + ' Jahren']
6749 };
6750 return withoutSuffix ? format[key][0] : format[key][1];
6751 }
6752
6753 var deAt = moment.defineLocale('de-at', {
6754 months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6755 monthsShort : 'Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6756 monthsParseExact : true,
6757 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6758 weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6759 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6760 weekdaysParseExact : true,
6761 longDateFormat : {
6762 LT: 'HH:mm',
6763 LTS: 'HH:mm:ss',
6764 L : 'DD.MM.YYYY',
6765 LL : 'D. MMMM YYYY',
6766 LLL : 'D. MMMM YYYY HH:mm',
6767 LLLL : 'dddd, D. MMMM YYYY HH:mm'
6768 },
6769 calendar : {
6770 sameDay: '[heute um] LT [Uhr]',
6771 sameElse: 'L',
6772 nextDay: '[morgen um] LT [Uhr]',
6773 nextWeek: 'dddd [um] LT [Uhr]',
6774 lastDay: '[gestern um] LT [Uhr]',
6775 lastWeek: '[letzten] dddd [um] LT [Uhr]'
6776 },
6777 relativeTime : {
6778 future : 'in %s',
6779 past : 'vor %s',
6780 s : 'ein paar Sekunden',
6781 ss : '%d Sekunden',
6782 m : processRelativeTime,
6783 mm : '%d Minuten',
6784 h : processRelativeTime,
6785 hh : '%d Stunden',
6786 d : processRelativeTime,
6787 dd : processRelativeTime,
6788 M : processRelativeTime,
6789 MM : processRelativeTime,
6790 y : processRelativeTime,
6791 yy : processRelativeTime
6792 },
6793 dayOfMonthOrdinalParse: /\d{1,2}\./,
6794 ordinal : '%d.',
6795 week : {
6796 dow : 1, // Monday is the first day of the week.
6797 doy : 4 // The week that contains Jan 4th is the first week of the year.
6798 }
6799 });
6800
6801 return deAt;
6802
6803})));
6804
6805
6806/***/ }),
6807/* 34 */
6808/***/ (function(module, exports, __webpack_require__) {
6809
6810//! moment.js locale configuration
6811
6812;(function (global, factory) {
6813 true ? factory(__webpack_require__(0)) :
6814 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6815 factory(global.moment)
6816}(this, (function (moment) { 'use strict';
6817
6818
6819 function processRelativeTime(number, withoutSuffix, key, isFuture) {
6820 var format = {
6821 'm': ['eine Minute', 'einer Minute'],
6822 'h': ['eine Stunde', 'einer Stunde'],
6823 'd': ['ein Tag', 'einem Tag'],
6824 'dd': [number + ' Tage', number + ' Tagen'],
6825 'M': ['ein Monat', 'einem Monat'],
6826 'MM': [number + ' Monate', number + ' Monaten'],
6827 'y': ['ein Jahr', 'einem Jahr'],
6828 'yy': [number + ' Jahre', number + ' Jahren']
6829 };
6830 return withoutSuffix ? format[key][0] : format[key][1];
6831 }
6832
6833 var deCh = moment.defineLocale('de-ch', {
6834 months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6835 monthsShort : 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6836 monthsParseExact : true,
6837 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6838 weekdaysShort : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6839 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6840 weekdaysParseExact : true,
6841 longDateFormat : {
6842 LT: 'HH:mm',
6843 LTS: 'HH:mm:ss',
6844 L : 'DD.MM.YYYY',
6845 LL : 'D. MMMM YYYY',
6846 LLL : 'D. MMMM YYYY HH:mm',
6847 LLLL : 'dddd, D. MMMM YYYY HH:mm'
6848 },
6849 calendar : {
6850 sameDay: '[heute um] LT [Uhr]',
6851 sameElse: 'L',
6852 nextDay: '[morgen um] LT [Uhr]',
6853 nextWeek: 'dddd [um] LT [Uhr]',
6854 lastDay: '[gestern um] LT [Uhr]',
6855 lastWeek: '[letzten] dddd [um] LT [Uhr]'
6856 },
6857 relativeTime : {
6858 future : 'in %s',
6859 past : 'vor %s',
6860 s : 'ein paar Sekunden',
6861 ss : '%d Sekunden',
6862 m : processRelativeTime,
6863 mm : '%d Minuten',
6864 h : processRelativeTime,
6865 hh : '%d Stunden',
6866 d : processRelativeTime,
6867 dd : processRelativeTime,
6868 M : processRelativeTime,
6869 MM : processRelativeTime,
6870 y : processRelativeTime,
6871 yy : processRelativeTime
6872 },
6873 dayOfMonthOrdinalParse: /\d{1,2}\./,
6874 ordinal : '%d.',
6875 week : {
6876 dow : 1, // Monday is the first day of the week.
6877 doy : 4 // The week that contains Jan 4th is the first week of the year.
6878 }
6879 });
6880
6881 return deCh;
6882
6883})));
6884
6885
6886/***/ }),
6887/* 35 */
6888/***/ (function(module, exports, __webpack_require__) {
6889
6890//! moment.js locale configuration
6891
6892;(function (global, factory) {
6893 true ? factory(__webpack_require__(0)) :
6894 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6895 factory(global.moment)
6896}(this, (function (moment) { 'use strict';
6897
6898
6899 function processRelativeTime(number, withoutSuffix, key, isFuture) {
6900 var format = {
6901 'm': ['eine Minute', 'einer Minute'],
6902 'h': ['eine Stunde', 'einer Stunde'],
6903 'd': ['ein Tag', 'einem Tag'],
6904 'dd': [number + ' Tage', number + ' Tagen'],
6905 'M': ['ein Monat', 'einem Monat'],
6906 'MM': [number + ' Monate', number + ' Monaten'],
6907 'y': ['ein Jahr', 'einem Jahr'],
6908 'yy': [number + ' Jahre', number + ' Jahren']
6909 };
6910 return withoutSuffix ? format[key][0] : format[key][1];
6911 }
6912
6913 var de = moment.defineLocale('de', {
6914 months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6915 monthsShort : 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6916 monthsParseExact : true,
6917 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6918 weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6919 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6920 weekdaysParseExact : true,
6921 longDateFormat : {
6922 LT: 'HH:mm',
6923 LTS: 'HH:mm:ss',
6924 L : 'DD.MM.YYYY',
6925 LL : 'D. MMMM YYYY',
6926 LLL : 'D. MMMM YYYY HH:mm',
6927 LLLL : 'dddd, D. MMMM YYYY HH:mm'
6928 },
6929 calendar : {
6930 sameDay: '[heute um] LT [Uhr]',
6931 sameElse: 'L',
6932 nextDay: '[morgen um] LT [Uhr]',
6933 nextWeek: 'dddd [um] LT [Uhr]',
6934 lastDay: '[gestern um] LT [Uhr]',
6935 lastWeek: '[letzten] dddd [um] LT [Uhr]'
6936 },
6937 relativeTime : {
6938 future : 'in %s',
6939 past : 'vor %s',
6940 s : 'ein paar Sekunden',
6941 ss : '%d Sekunden',
6942 m : processRelativeTime,
6943 mm : '%d Minuten',
6944 h : processRelativeTime,
6945 hh : '%d Stunden',
6946 d : processRelativeTime,
6947 dd : processRelativeTime,
6948 M : processRelativeTime,
6949 MM : processRelativeTime,
6950 y : processRelativeTime,
6951 yy : processRelativeTime
6952 },
6953 dayOfMonthOrdinalParse: /\d{1,2}\./,
6954 ordinal : '%d.',
6955 week : {
6956 dow : 1, // Monday is the first day of the week.
6957 doy : 4 // The week that contains Jan 4th is the first week of the year.
6958 }
6959 });
6960
6961 return de;
6962
6963})));
6964
6965
6966/***/ }),
6967/* 36 */
6968/***/ (function(module, exports, __webpack_require__) {
6969
6970//! moment.js locale configuration
6971
6972;(function (global, factory) {
6973 true ? factory(__webpack_require__(0)) :
6974 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
6975 factory(global.moment)
6976}(this, (function (moment) { 'use strict';
6977
6978
6979 var months = [
6980 'Þ–Þ¬Þ‚ÞªÞ‡Þ¦ÞƒÞ©',
6981 'ÞŠÞ¬Þ„Þ°ÞƒÞªÞ‡Þ¦ÞƒÞ©',
6982 'Þ‰Þ§ÞƒÞ¨Þ—Þª',
6983 'Þ‡ÞÞ•Þ°ÞƒÞ©ÞÞª',
6984 'Þ‰Þ',
6985 'Þ–Þ«Þ‚Þ°',
6986 'Þ–ÞªÞÞ¦Þ‡Þ¨',
6987 'Þ‡Þ¯ÞŽÞ¦ÞÞ°Þ“Þª',
6988 'ÞÞ¬Þ•Þ°Þ“Þ¬Þ‰Þ°Þ„Þ¦ÞƒÞª',
6989 'Þ‡Þ®Þ†Þ°Þ“Þ¯Þ„Þ¦ÞƒÞª',
6990 'Þ‚Þ®ÞˆÞ¬Þ‰Þ°Þ„Þ¦ÞƒÞª',
6991 'Þ‘Þ¨ÞÞ¬Þ‰Þ°Þ„Þ¦ÞƒÞª'
6992 ], weekdays = [
6993 'އާދިއްތަ',
6994 'Þ€Þ¯Þ‰Þ¦',
6995 'Þ‡Þ¦Þ‚Þ°ÞŽÞ§ÞƒÞ¦',
6996 'Þ„ÞªÞ‹Þ¦',
6997 'Þ„ÞªÞƒÞ§Þްފަތި',
6998 'Þ€ÞªÞ†ÞªÞƒÞª',
6999 'Þ€Þ®Þ‚Þ¨Þ€Þ¨ÞƒÞª'
7000 ];
7001
7002 var dv = moment.defineLocale('dv', {
7003 months : months,
7004 monthsShort : months,
7005 weekdays : weekdays,
7006 weekdaysShort : weekdays,
7007 weekdaysMin : 'Þ‡Þ§Þ‹Þ¨_Þ€Þ¯Þ‰Þ¦_Þ‡Þ¦Þ‚Þ°_Þ„ÞªÞ‹Þ¦_Þ„ÞªÞƒÞ§_Þ€ÞªÞ†Þª_Þ€Þ®Þ‚Þ¨'.split('_'),
7008 longDateFormat : {
7009
7010 LT : 'HH:mm',
7011 LTS : 'HH:mm:ss',
7012 L : 'D/M/YYYY',
7013 LL : 'D MMMM YYYY',
7014 LLL : 'D MMMM YYYY HH:mm',
7015 LLLL : 'dddd D MMMM YYYY HH:mm'
7016 },
7017 meridiemParse: /Þ‰Þ†|Þ‰ÞŠ/,
7018 isPM : function (input) {
7019 return 'Þ‰ÞŠ' === input;
7020 },
7021 meridiem : function (hour, minute, isLower) {
7022 if (hour < 12) {
7023 return 'Þ‰Þ†';
7024 } else {
7025 return 'Þ‰ÞŠ';
7026 }
7027 },
7028 calendar : {
7029 sameDay : '[Þ‰Þ¨Þ‡Þ¦Þ‹Þª] LT',
7030 nextDay : '[Þ‰Þ§Þ‹Þ¦Þ‰Þ§] LT',
7031 nextWeek : 'dddd LT',
7032 lastDay : '[Þ‡Þ¨Þ‡Þ°Þ”Þ¬] LT',
7033 lastWeek : '[ފާއިތުވި] dddd LT',
7034 sameElse : 'L'
7035 },
7036 relativeTime : {
7037 future : 'ތެރÞÞŽÞ¦Þ‡Þ¨ %s',
7038 past : 'Þ†ÞªÞƒÞ¨Þ‚Þ° %s',
7039 s : 'Þިކުންތުކޮޅެއް',
7040 ss : 'd% Þިކުންތު',
7041 m : 'Þ‰Þ¨Þ‚Þ¨Þ“Þ¬Þ‡Þ°',
7042 mm : 'Þ‰Þ¨Þ‚Þ¨Þ“Þª %d',
7043 h : 'ÞŽÞ¦Þ‘Þ¨Þ‡Þ¨ÞƒÞ¬Þ‡Þ°',
7044 hh : 'ÞŽÞ¦Þ‘Þ¨Þ‡Þ¨ÞƒÞª %d',
7045 d : 'Þ‹ÞªÞˆÞ¦Þ€Þ¬Þ‡Þ°',
7046 dd : 'Þ‹ÞªÞˆÞ¦ÞÞ° %d',
7047 M : 'Þ‰Þ¦Þ€Þ¬Þ‡Þ°',
7048 MM : 'Þ‰Þ¦ÞÞ° %d',
7049 y : 'Þ‡Þ¦Þ€Þ¦ÞƒÞ¬Þ‡Þ°',
7050 yy : 'Þ‡Þ¦Þ€Þ¦ÞƒÞª %d'
7051 },
7052 preparse: function (string) {
7053 return string.replace(/،/g, ',');
7054 },
7055 postformat: function (string) {
7056 return string.replace(/,/g, '،');
7057 },
7058 week : {
7059 dow : 7, // Sunday is the first day of the week.
7060 doy : 12 // The week that contains Jan 1st is the first week of the year.
7061 }
7062 });
7063
7064 return dv;
7065
7066})));
7067
7068
7069/***/ }),
7070/* 37 */
7071/***/ (function(module, exports, __webpack_require__) {
7072
7073//! moment.js locale configuration
7074
7075;(function (global, factory) {
7076 true ? factory(__webpack_require__(0)) :
7077 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7078 factory(global.moment)
7079}(this, (function (moment) { 'use strict';
7080
7081 function isFunction(input) {
7082 return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
7083 }
7084
7085
7086 var el = moment.defineLocale('el', {
7087 monthsNominativeEl : 'ΙανουάÏιος_ΦεβÏουάÏιος_ΜάÏτιος_ΑπÏίλιος_Μάιος_ΙοÏνιος_ΙοÏλιος_ΑÏγουστος_ΣεπτÎμβÏιος_ΟκτώβÏιος_ÎοÎμβÏιος_ΔεκÎμβÏιος'.split('_'),
7088 monthsGenitiveEl : 'ΙανουαÏίου_ΦεβÏουαÏίου_ΜαÏτίου_ΑπÏιλίου_ΜαÎου_Ιουνίου_Ιουλίου_ΑυγοÏστου_ΣεπτεμβÏίου_ΟκτωβÏίου_ÎοεμβÏίου_ΔεκεμβÏίου'.split('_'),
7089 months : function (momentToFormat, format) {
7090 if (!momentToFormat) {
7091 return this._monthsNominativeEl;
7092 } else if (typeof format === 'string' && /D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
7093 return this._monthsGenitiveEl[momentToFormat.month()];
7094 } else {
7095 return this._monthsNominativeEl[momentToFormat.month()];
7096 }
7097 },
7098 monthsShort : 'Ιαν_Φεβ_ΜαÏ_ΑπÏ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Îοε_Δεκ'.split('_'),
7099 weekdays : 'ΚυÏιακή_ΔευτÎÏα_ΤÏίτη_ΤετάÏτη_Î Îμπτη_ΠαÏασκευή_Σάββατο'.split('_'),
7100 weekdaysShort : 'ΚυÏ_Δευ_ΤÏι_Τετ_Πεμ_ΠαÏ_Σαβ'.split('_'),
7101 weekdaysMin : 'Κυ_Δε_ΤÏ_Τε_Πε_Πα_Σα'.split('_'),
7102 meridiem : function (hours, minutes, isLower) {
7103 if (hours > 11) {
7104 return isLower ? 'μμ' : 'ΜΜ';
7105 } else {
7106 return isLower ? 'πμ' : 'ΠΜ';
7107 }
7108 },
7109 isPM : function (input) {
7110 return ((input + '').toLowerCase()[0] === 'μ');
7111 },
7112 meridiemParse : /[ΠΜ]\.?Μ?\.?/i,
7113 longDateFormat : {
7114 LT : 'h:mm A',
7115 LTS : 'h:mm:ss A',
7116 L : 'DD/MM/YYYY',
7117 LL : 'D MMMM YYYY',
7118 LLL : 'D MMMM YYYY h:mm A',
7119 LLLL : 'dddd, D MMMM YYYY h:mm A'
7120 },
7121 calendarEl : {
7122 sameDay : '[ΣήμεÏα {}] LT',
7123 nextDay : '[ΑÏÏιο {}] LT',
7124 nextWeek : 'dddd [{}] LT',
7125 lastDay : '[Χθες {}] LT',
7126 lastWeek : function () {
7127 switch (this.day()) {
7128 case 6:
7129 return '[το Ï€ÏοηγοÏμενο] dddd [{}] LT';
7130 default:
7131 return '[την Ï€ÏοηγοÏμενη] dddd [{}] LT';
7132 }
7133 },
7134 sameElse : 'L'
7135 },
7136 calendar : function (key, mom) {
7137 var output = this._calendarEl[key],
7138 hours = mom && mom.hours();
7139 if (isFunction(output)) {
7140 output = output.apply(mom);
7141 }
7142 return output.replace('{}', (hours % 12 === 1 ? 'στη' : 'στις'));
7143 },
7144 relativeTime : {
7145 future : 'σε %s',
7146 past : '%s Ï€Ïιν',
7147 s : 'λίγα δευτεÏόλεπτα',
7148 ss : '%d δευτεÏόλεπτα',
7149 m : 'Îνα λεπτό',
7150 mm : '%d λεπτά',
7151 h : 'μία ÏŽÏα',
7152 hh : '%d ÏŽÏες',
7153 d : 'μία μÎÏα',
7154 dd : '%d μÎÏες',
7155 M : 'Îνας μήνας',
7156 MM : '%d μήνες',
7157 y : 'Îνας χÏόνος',
7158 yy : '%d χÏόνια'
7159 },
7160 dayOfMonthOrdinalParse: /\d{1,2}η/,
7161 ordinal: '%dη',
7162 week : {
7163 dow : 1, // Monday is the first day of the week.
7164 doy : 4 // The week that contains Jan 4st is the first week of the year.
7165 }
7166 });
7167
7168 return el;
7169
7170})));
7171
7172
7173/***/ }),
7174/* 38 */
7175/***/ (function(module, exports, __webpack_require__) {
7176
7177//! moment.js locale configuration
7178
7179;(function (global, factory) {
7180 true ? factory(__webpack_require__(0)) :
7181 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7182 factory(global.moment)
7183}(this, (function (moment) { 'use strict';
7184
7185
7186 var enAu = moment.defineLocale('en-au', {
7187 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7188 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7189 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7190 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7191 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7192 longDateFormat : {
7193 LT : 'h:mm A',
7194 LTS : 'h:mm:ss A',
7195 L : 'DD/MM/YYYY',
7196 LL : 'D MMMM YYYY',
7197 LLL : 'D MMMM YYYY h:mm A',
7198 LLLL : 'dddd, D MMMM YYYY h:mm A'
7199 },
7200 calendar : {
7201 sameDay : '[Today at] LT',
7202 nextDay : '[Tomorrow at] LT',
7203 nextWeek : 'dddd [at] LT',
7204 lastDay : '[Yesterday at] LT',
7205 lastWeek : '[Last] dddd [at] LT',
7206 sameElse : 'L'
7207 },
7208 relativeTime : {
7209 future : 'in %s',
7210 past : '%s ago',
7211 s : 'a few seconds',
7212 ss : '%d seconds',
7213 m : 'a minute',
7214 mm : '%d minutes',
7215 h : 'an hour',
7216 hh : '%d hours',
7217 d : 'a day',
7218 dd : '%d days',
7219 M : 'a month',
7220 MM : '%d months',
7221 y : 'a year',
7222 yy : '%d years'
7223 },
7224 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7225 ordinal : function (number) {
7226 var b = number % 10,
7227 output = (~~(number % 100 / 10) === 1) ? 'th' :
7228 (b === 1) ? 'st' :
7229 (b === 2) ? 'nd' :
7230 (b === 3) ? 'rd' : 'th';
7231 return number + output;
7232 },
7233 week : {
7234 dow : 1, // Monday is the first day of the week.
7235 doy : 4 // The week that contains Jan 4th is the first week of the year.
7236 }
7237 });
7238
7239 return enAu;
7240
7241})));
7242
7243
7244/***/ }),
7245/* 39 */
7246/***/ (function(module, exports, __webpack_require__) {
7247
7248//! moment.js locale configuration
7249
7250;(function (global, factory) {
7251 true ? factory(__webpack_require__(0)) :
7252 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7253 factory(global.moment)
7254}(this, (function (moment) { 'use strict';
7255
7256
7257 var enCa = moment.defineLocale('en-ca', {
7258 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7259 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7260 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7261 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7262 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7263 longDateFormat : {
7264 LT : 'h:mm A',
7265 LTS : 'h:mm:ss A',
7266 L : 'YYYY-MM-DD',
7267 LL : 'MMMM D, YYYY',
7268 LLL : 'MMMM D, YYYY h:mm A',
7269 LLLL : 'dddd, MMMM D, YYYY h:mm A'
7270 },
7271 calendar : {
7272 sameDay : '[Today at] LT',
7273 nextDay : '[Tomorrow at] LT',
7274 nextWeek : 'dddd [at] LT',
7275 lastDay : '[Yesterday at] LT',
7276 lastWeek : '[Last] dddd [at] LT',
7277 sameElse : 'L'
7278 },
7279 relativeTime : {
7280 future : 'in %s',
7281 past : '%s ago',
7282 s : 'a few seconds',
7283 ss : '%d seconds',
7284 m : 'a minute',
7285 mm : '%d minutes',
7286 h : 'an hour',
7287 hh : '%d hours',
7288 d : 'a day',
7289 dd : '%d days',
7290 M : 'a month',
7291 MM : '%d months',
7292 y : 'a year',
7293 yy : '%d years'
7294 },
7295 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7296 ordinal : function (number) {
7297 var b = number % 10,
7298 output = (~~(number % 100 / 10) === 1) ? 'th' :
7299 (b === 1) ? 'st' :
7300 (b === 2) ? 'nd' :
7301 (b === 3) ? 'rd' : 'th';
7302 return number + output;
7303 }
7304 });
7305
7306 return enCa;
7307
7308})));
7309
7310
7311/***/ }),
7312/* 40 */
7313/***/ (function(module, exports, __webpack_require__) {
7314
7315//! moment.js locale configuration
7316
7317;(function (global, factory) {
7318 true ? factory(__webpack_require__(0)) :
7319 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7320 factory(global.moment)
7321}(this, (function (moment) { 'use strict';
7322
7323
7324 var enGb = moment.defineLocale('en-gb', {
7325 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7326 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7327 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7328 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7329 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7330 longDateFormat : {
7331 LT : 'HH:mm',
7332 LTS : 'HH:mm:ss',
7333 L : 'DD/MM/YYYY',
7334 LL : 'D MMMM YYYY',
7335 LLL : 'D MMMM YYYY HH:mm',
7336 LLLL : 'dddd, D MMMM YYYY HH:mm'
7337 },
7338 calendar : {
7339 sameDay : '[Today at] LT',
7340 nextDay : '[Tomorrow at] LT',
7341 nextWeek : 'dddd [at] LT',
7342 lastDay : '[Yesterday at] LT',
7343 lastWeek : '[Last] dddd [at] LT',
7344 sameElse : 'L'
7345 },
7346 relativeTime : {
7347 future : 'in %s',
7348 past : '%s ago',
7349 s : 'a few seconds',
7350 ss : '%d seconds',
7351 m : 'a minute',
7352 mm : '%d minutes',
7353 h : 'an hour',
7354 hh : '%d hours',
7355 d : 'a day',
7356 dd : '%d days',
7357 M : 'a month',
7358 MM : '%d months',
7359 y : 'a year',
7360 yy : '%d years'
7361 },
7362 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7363 ordinal : function (number) {
7364 var b = number % 10,
7365 output = (~~(number % 100 / 10) === 1) ? 'th' :
7366 (b === 1) ? 'st' :
7367 (b === 2) ? 'nd' :
7368 (b === 3) ? 'rd' : 'th';
7369 return number + output;
7370 },
7371 week : {
7372 dow : 1, // Monday is the first day of the week.
7373 doy : 4 // The week that contains Jan 4th is the first week of the year.
7374 }
7375 });
7376
7377 return enGb;
7378
7379})));
7380
7381
7382/***/ }),
7383/* 41 */
7384/***/ (function(module, exports, __webpack_require__) {
7385
7386//! moment.js locale configuration
7387
7388;(function (global, factory) {
7389 true ? factory(__webpack_require__(0)) :
7390 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7391 factory(global.moment)
7392}(this, (function (moment) { 'use strict';
7393
7394
7395 var enIe = moment.defineLocale('en-ie', {
7396 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7397 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7398 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7399 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7400 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7401 longDateFormat : {
7402 LT : 'HH:mm',
7403 LTS : 'HH:mm:ss',
7404 L : 'DD-MM-YYYY',
7405 LL : 'D MMMM YYYY',
7406 LLL : 'D MMMM YYYY HH:mm',
7407 LLLL : 'dddd D MMMM YYYY HH:mm'
7408 },
7409 calendar : {
7410 sameDay : '[Today at] LT',
7411 nextDay : '[Tomorrow at] LT',
7412 nextWeek : 'dddd [at] LT',
7413 lastDay : '[Yesterday at] LT',
7414 lastWeek : '[Last] dddd [at] LT',
7415 sameElse : 'L'
7416 },
7417 relativeTime : {
7418 future : 'in %s',
7419 past : '%s ago',
7420 s : 'a few seconds',
7421 ss : '%d seconds',
7422 m : 'a minute',
7423 mm : '%d minutes',
7424 h : 'an hour',
7425 hh : '%d hours',
7426 d : 'a day',
7427 dd : '%d days',
7428 M : 'a month',
7429 MM : '%d months',
7430 y : 'a year',
7431 yy : '%d years'
7432 },
7433 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7434 ordinal : function (number) {
7435 var b = number % 10,
7436 output = (~~(number % 100 / 10) === 1) ? 'th' :
7437 (b === 1) ? 'st' :
7438 (b === 2) ? 'nd' :
7439 (b === 3) ? 'rd' : 'th';
7440 return number + output;
7441 },
7442 week : {
7443 dow : 1, // Monday is the first day of the week.
7444 doy : 4 // The week that contains Jan 4th is the first week of the year.
7445 }
7446 });
7447
7448 return enIe;
7449
7450})));
7451
7452
7453/***/ }),
7454/* 42 */
7455/***/ (function(module, exports, __webpack_require__) {
7456
7457//! moment.js locale configuration
7458
7459;(function (global, factory) {
7460 true ? factory(__webpack_require__(0)) :
7461 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7462 factory(global.moment)
7463}(this, (function (moment) { 'use strict';
7464
7465
7466 var enIl = moment.defineLocale('en-il', {
7467 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7468 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7469 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7470 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7471 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7472 longDateFormat : {
7473 LT : 'HH:mm',
7474 LTS : 'HH:mm:ss',
7475 L : 'DD/MM/YYYY',
7476 LL : 'D MMMM YYYY',
7477 LLL : 'D MMMM YYYY HH:mm',
7478 LLLL : 'dddd, D MMMM YYYY HH:mm'
7479 },
7480 calendar : {
7481 sameDay : '[Today at] LT',
7482 nextDay : '[Tomorrow at] LT',
7483 nextWeek : 'dddd [at] LT',
7484 lastDay : '[Yesterday at] LT',
7485 lastWeek : '[Last] dddd [at] LT',
7486 sameElse : 'L'
7487 },
7488 relativeTime : {
7489 future : 'in %s',
7490 past : '%s ago',
7491 s : 'a few seconds',
7492 m : 'a minute',
7493 mm : '%d minutes',
7494 h : 'an hour',
7495 hh : '%d hours',
7496 d : 'a day',
7497 dd : '%d days',
7498 M : 'a month',
7499 MM : '%d months',
7500 y : 'a year',
7501 yy : '%d years'
7502 },
7503 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7504 ordinal : function (number) {
7505 var b = number % 10,
7506 output = (~~(number % 100 / 10) === 1) ? 'th' :
7507 (b === 1) ? 'st' :
7508 (b === 2) ? 'nd' :
7509 (b === 3) ? 'rd' : 'th';
7510 return number + output;
7511 }
7512 });
7513
7514 return enIl;
7515
7516})));
7517
7518
7519/***/ }),
7520/* 43 */
7521/***/ (function(module, exports, __webpack_require__) {
7522
7523//! moment.js locale configuration
7524
7525;(function (global, factory) {
7526 true ? factory(__webpack_require__(0)) :
7527 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7528 factory(global.moment)
7529}(this, (function (moment) { 'use strict';
7530
7531
7532 var enNz = moment.defineLocale('en-nz', {
7533 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7534 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7535 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7536 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7537 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7538 longDateFormat : {
7539 LT : 'h:mm A',
7540 LTS : 'h:mm:ss A',
7541 L : 'DD/MM/YYYY',
7542 LL : 'D MMMM YYYY',
7543 LLL : 'D MMMM YYYY h:mm A',
7544 LLLL : 'dddd, D MMMM YYYY h:mm A'
7545 },
7546 calendar : {
7547 sameDay : '[Today at] LT',
7548 nextDay : '[Tomorrow at] LT',
7549 nextWeek : 'dddd [at] LT',
7550 lastDay : '[Yesterday at] LT',
7551 lastWeek : '[Last] dddd [at] LT',
7552 sameElse : 'L'
7553 },
7554 relativeTime : {
7555 future : 'in %s',
7556 past : '%s ago',
7557 s : 'a few seconds',
7558 ss : '%d seconds',
7559 m : 'a minute',
7560 mm : '%d minutes',
7561 h : 'an hour',
7562 hh : '%d hours',
7563 d : 'a day',
7564 dd : '%d days',
7565 M : 'a month',
7566 MM : '%d months',
7567 y : 'a year',
7568 yy : '%d years'
7569 },
7570 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7571 ordinal : function (number) {
7572 var b = number % 10,
7573 output = (~~(number % 100 / 10) === 1) ? 'th' :
7574 (b === 1) ? 'st' :
7575 (b === 2) ? 'nd' :
7576 (b === 3) ? 'rd' : 'th';
7577 return number + output;
7578 },
7579 week : {
7580 dow : 1, // Monday is the first day of the week.
7581 doy : 4 // The week that contains Jan 4th is the first week of the year.
7582 }
7583 });
7584
7585 return enNz;
7586
7587})));
7588
7589
7590/***/ }),
7591/* 44 */
7592/***/ (function(module, exports, __webpack_require__) {
7593
7594//! moment.js locale configuration
7595
7596;(function (global, factory) {
7597 true ? factory(__webpack_require__(0)) :
7598 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7599 factory(global.moment)
7600}(this, (function (moment) { 'use strict';
7601
7602
7603 var eo = moment.defineLocale('eo', {
7604 months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aÅgusto_septembro_oktobro_novembro_decembro'.split('_'),
7605 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aÅg_sep_okt_nov_dec'.split('_'),
7606 weekdays : 'dimanĉo_lundo_mardo_merkredo_ĵaÅdo_vendredo_sabato'.split('_'),
7607 weekdaysShort : 'dim_lun_mard_merk_ĵaÅ_ven_sab'.split('_'),
7608 weekdaysMin : 'di_lu_ma_me_ĵa_ve_sa'.split('_'),
7609 longDateFormat : {
7610 LT : 'HH:mm',
7611 LTS : 'HH:mm:ss',
7612 L : 'YYYY-MM-DD',
7613 LL : 'D[-a de] MMMM, YYYY',
7614 LLL : 'D[-a de] MMMM, YYYY HH:mm',
7615 LLLL : 'dddd, [la] D[-a de] MMMM, YYYY HH:mm'
7616 },
7617 meridiemParse: /[ap]\.t\.m/i,
7618 isPM: function (input) {
7619 return input.charAt(0).toLowerCase() === 'p';
7620 },
7621 meridiem : function (hours, minutes, isLower) {
7622 if (hours > 11) {
7623 return isLower ? 'p.t.m.' : 'P.T.M.';
7624 } else {
7625 return isLower ? 'a.t.m.' : 'A.T.M.';
7626 }
7627 },
7628 calendar : {
7629 sameDay : '[HodiaÅ je] LT',
7630 nextDay : '[MorgaÅ je] LT',
7631 nextWeek : 'dddd [je] LT',
7632 lastDay : '[HieraÅ je] LT',
7633 lastWeek : '[pasinta] dddd [je] LT',
7634 sameElse : 'L'
7635 },
7636 relativeTime : {
7637 future : 'post %s',
7638 past : 'antaÅ %s',
7639 s : 'sekundoj',
7640 ss : '%d sekundoj',
7641 m : 'minuto',
7642 mm : '%d minutoj',
7643 h : 'horo',
7644 hh : '%d horoj',
7645 d : 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
7646 dd : '%d tagoj',
7647 M : 'monato',
7648 MM : '%d monatoj',
7649 y : 'jaro',
7650 yy : '%d jaroj'
7651 },
7652 dayOfMonthOrdinalParse: /\d{1,2}a/,
7653 ordinal : '%da',
7654 week : {
7655 dow : 1, // Monday is the first day of the week.
7656 doy : 7 // The week that contains Jan 1st is the first week of the year.
7657 }
7658 });
7659
7660 return eo;
7661
7662})));
7663
7664
7665/***/ }),
7666/* 45 */
7667/***/ (function(module, exports, __webpack_require__) {
7668
7669//! moment.js locale configuration
7670
7671;(function (global, factory) {
7672 true ? factory(__webpack_require__(0)) :
7673 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7674 factory(global.moment)
7675}(this, (function (moment) { 'use strict';
7676
7677
7678 var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7679 monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7680
7681 var monthsParse = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i];
7682 var monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
7683
7684 var esDo = moment.defineLocale('es-do', {
7685 months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7686 monthsShort : function (m, format) {
7687 if (!m) {
7688 return monthsShortDot;
7689 } else if (/-MMM-/.test(format)) {
7690 return monthsShort[m.month()];
7691 } else {
7692 return monthsShortDot[m.month()];
7693 }
7694 },
7695 monthsRegex: monthsRegex,
7696 monthsShortRegex: monthsRegex,
7697 monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
7698 monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
7699 monthsParse: monthsParse,
7700 longMonthsParse: monthsParse,
7701 shortMonthsParse: monthsParse,
7702 weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7703 weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7704 weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7705 weekdaysParseExact : true,
7706 longDateFormat : {
7707 LT : 'h:mm A',
7708 LTS : 'h:mm:ss A',
7709 L : 'DD/MM/YYYY',
7710 LL : 'D [de] MMMM [de] YYYY',
7711 LLL : 'D [de] MMMM [de] YYYY h:mm A',
7712 LLLL : 'dddd, D [de] MMMM [de] YYYY h:mm A'
7713 },
7714 calendar : {
7715 sameDay : function () {
7716 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7717 },
7718 nextDay : function () {
7719 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7720 },
7721 nextWeek : function () {
7722 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7723 },
7724 lastDay : function () {
7725 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7726 },
7727 lastWeek : function () {
7728 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7729 },
7730 sameElse : 'L'
7731 },
7732 relativeTime : {
7733 future : 'en %s',
7734 past : 'hace %s',
7735 s : 'unos segundos',
7736 ss : '%d segundos',
7737 m : 'un minuto',
7738 mm : '%d minutos',
7739 h : 'una hora',
7740 hh : '%d horas',
7741 d : 'un dÃa',
7742 dd : '%d dÃas',
7743 M : 'un mes',
7744 MM : '%d meses',
7745 y : 'un año',
7746 yy : '%d años'
7747 },
7748 dayOfMonthOrdinalParse : /\d{1,2}º/,
7749 ordinal : '%dº',
7750 week : {
7751 dow : 1, // Monday is the first day of the week.
7752 doy : 4 // The week that contains Jan 4th is the first week of the year.
7753 }
7754 });
7755
7756 return esDo;
7757
7758})));
7759
7760
7761/***/ }),
7762/* 46 */
7763/***/ (function(module, exports, __webpack_require__) {
7764
7765//! moment.js locale configuration
7766
7767;(function (global, factory) {
7768 true ? factory(__webpack_require__(0)) :
7769 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7770 factory(global.moment)
7771}(this, (function (moment) { 'use strict';
7772
7773
7774 var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7775 monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7776
7777 var esUs = moment.defineLocale('es-us', {
7778 months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7779 monthsShort : function (m, format) {
7780 if (!m) {
7781 return monthsShortDot;
7782 } else if (/-MMM-/.test(format)) {
7783 return monthsShort[m.month()];
7784 } else {
7785 return monthsShortDot[m.month()];
7786 }
7787 },
7788 monthsParseExact : true,
7789 weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7790 weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7791 weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7792 weekdaysParseExact : true,
7793 longDateFormat : {
7794 LT : 'h:mm A',
7795 LTS : 'h:mm:ss A',
7796 L : 'MM/DD/YYYY',
7797 LL : 'MMMM [de] D [de] YYYY',
7798 LLL : 'MMMM [de] D [de] YYYY h:mm A',
7799 LLLL : 'dddd, MMMM [de] D [de] YYYY h:mm A'
7800 },
7801 calendar : {
7802 sameDay : function () {
7803 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7804 },
7805 nextDay : function () {
7806 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7807 },
7808 nextWeek : function () {
7809 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7810 },
7811 lastDay : function () {
7812 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7813 },
7814 lastWeek : function () {
7815 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7816 },
7817 sameElse : 'L'
7818 },
7819 relativeTime : {
7820 future : 'en %s',
7821 past : 'hace %s',
7822 s : 'unos segundos',
7823 ss : '%d segundos',
7824 m : 'un minuto',
7825 mm : '%d minutos',
7826 h : 'una hora',
7827 hh : '%d horas',
7828 d : 'un dÃa',
7829 dd : '%d dÃas',
7830 M : 'un mes',
7831 MM : '%d meses',
7832 y : 'un año',
7833 yy : '%d años'
7834 },
7835 dayOfMonthOrdinalParse : /\d{1,2}º/,
7836 ordinal : '%dº',
7837 week : {
7838 dow : 0, // Sunday is the first day of the week.
7839 doy : 6 // The week that contains Jan 1st is the first week of the year.
7840 }
7841 });
7842
7843 return esUs;
7844
7845})));
7846
7847
7848/***/ }),
7849/* 47 */
7850/***/ (function(module, exports, __webpack_require__) {
7851
7852//! moment.js locale configuration
7853
7854;(function (global, factory) {
7855 true ? factory(__webpack_require__(0)) :
7856 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7857 factory(global.moment)
7858}(this, (function (moment) { 'use strict';
7859
7860
7861 var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7862 monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7863
7864 var monthsParse = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i];
7865 var monthsRegex = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
7866
7867 var es = moment.defineLocale('es', {
7868 months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7869 monthsShort : function (m, format) {
7870 if (!m) {
7871 return monthsShortDot;
7872 } else if (/-MMM-/.test(format)) {
7873 return monthsShort[m.month()];
7874 } else {
7875 return monthsShortDot[m.month()];
7876 }
7877 },
7878 monthsRegex : monthsRegex,
7879 monthsShortRegex : monthsRegex,
7880 monthsStrictRegex : /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
7881 monthsShortStrictRegex : /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
7882 monthsParse : monthsParse,
7883 longMonthsParse : monthsParse,
7884 shortMonthsParse : monthsParse,
7885 weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7886 weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7887 weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7888 weekdaysParseExact : true,
7889 longDateFormat : {
7890 LT : 'H:mm',
7891 LTS : 'H:mm:ss',
7892 L : 'DD/MM/YYYY',
7893 LL : 'D [de] MMMM [de] YYYY',
7894 LLL : 'D [de] MMMM [de] YYYY H:mm',
7895 LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
7896 },
7897 calendar : {
7898 sameDay : function () {
7899 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7900 },
7901 nextDay : function () {
7902 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7903 },
7904 nextWeek : function () {
7905 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7906 },
7907 lastDay : function () {
7908 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7909 },
7910 lastWeek : function () {
7911 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7912 },
7913 sameElse : 'L'
7914 },
7915 relativeTime : {
7916 future : 'en %s',
7917 past : 'hace %s',
7918 s : 'unos segundos',
7919 ss : '%d segundos',
7920 m : 'un minuto',
7921 mm : '%d minutos',
7922 h : 'una hora',
7923 hh : '%d horas',
7924 d : 'un dÃa',
7925 dd : '%d dÃas',
7926 M : 'un mes',
7927 MM : '%d meses',
7928 y : 'un año',
7929 yy : '%d años'
7930 },
7931 dayOfMonthOrdinalParse : /\d{1,2}º/,
7932 ordinal : '%dº',
7933 week : {
7934 dow : 1, // Monday is the first day of the week.
7935 doy : 4 // The week that contains Jan 4th is the first week of the year.
7936 }
7937 });
7938
7939 return es;
7940
7941})));
7942
7943
7944/***/ }),
7945/* 48 */
7946/***/ (function(module, exports, __webpack_require__) {
7947
7948//! moment.js locale configuration
7949
7950;(function (global, factory) {
7951 true ? factory(__webpack_require__(0)) :
7952 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
7953 factory(global.moment)
7954}(this, (function (moment) { 'use strict';
7955
7956
7957 function processRelativeTime(number, withoutSuffix, key, isFuture) {
7958 var format = {
7959 's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
7960 'ss': [number + 'sekundi', number + 'sekundit'],
7961 'm' : ['ühe minuti', 'üks minut'],
7962 'mm': [number + ' minuti', number + ' minutit'],
7963 'h' : ['ühe tunni', 'tund aega', 'üks tund'],
7964 'hh': [number + ' tunni', number + ' tundi'],
7965 'd' : ['ühe päeva', 'üks päev'],
7966 'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
7967 'MM': [number + ' kuu', number + ' kuud'],
7968 'y' : ['ühe aasta', 'aasta', 'üks aasta'],
7969 'yy': [number + ' aasta', number + ' aastat']
7970 };
7971 if (withoutSuffix) {
7972 return format[key][2] ? format[key][2] : format[key][1];
7973 }
7974 return isFuture ? format[key][0] : format[key][1];
7975 }
7976
7977 var et = moment.defineLocale('et', {
7978 months : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
7979 monthsShort : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
7980 weekdays : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
7981 weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
7982 weekdaysMin : 'P_E_T_K_N_R_L'.split('_'),
7983 longDateFormat : {
7984 LT : 'H:mm',
7985 LTS : 'H:mm:ss',
7986 L : 'DD.MM.YYYY',
7987 LL : 'D. MMMM YYYY',
7988 LLL : 'D. MMMM YYYY H:mm',
7989 LLLL : 'dddd, D. MMMM YYYY H:mm'
7990 },
7991 calendar : {
7992 sameDay : '[Täna,] LT',
7993 nextDay : '[Homme,] LT',
7994 nextWeek : '[Järgmine] dddd LT',
7995 lastDay : '[Eile,] LT',
7996 lastWeek : '[Eelmine] dddd LT',
7997 sameElse : 'L'
7998 },
7999 relativeTime : {
8000 future : '%s pärast',
8001 past : '%s tagasi',
8002 s : processRelativeTime,
8003 ss : processRelativeTime,
8004 m : processRelativeTime,
8005 mm : processRelativeTime,
8006 h : processRelativeTime,
8007 hh : processRelativeTime,
8008 d : processRelativeTime,
8009 dd : '%d päeva',
8010 M : processRelativeTime,
8011 MM : processRelativeTime,
8012 y : processRelativeTime,
8013 yy : processRelativeTime
8014 },
8015 dayOfMonthOrdinalParse: /\d{1,2}\./,
8016 ordinal : '%d.',
8017 week : {
8018 dow : 1, // Monday is the first day of the week.
8019 doy : 4 // The week that contains Jan 4th is the first week of the year.
8020 }
8021 });
8022
8023 return et;
8024
8025})));
8026
8027
8028/***/ }),
8029/* 49 */
8030/***/ (function(module, exports, __webpack_require__) {
8031
8032//! moment.js locale configuration
8033
8034;(function (global, factory) {
8035 true ? factory(__webpack_require__(0)) :
8036 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8037 factory(global.moment)
8038}(this, (function (moment) { 'use strict';
8039
8040
8041 var eu = moment.defineLocale('eu', {
8042 months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
8043 monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
8044 monthsParseExact : true,
8045 weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
8046 weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
8047 weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
8048 weekdaysParseExact : true,
8049 longDateFormat : {
8050 LT : 'HH:mm',
8051 LTS : 'HH:mm:ss',
8052 L : 'YYYY-MM-DD',
8053 LL : 'YYYY[ko] MMMM[ren] D[a]',
8054 LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm',
8055 LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
8056 l : 'YYYY-M-D',
8057 ll : 'YYYY[ko] MMM D[a]',
8058 lll : 'YYYY[ko] MMM D[a] HH:mm',
8059 llll : 'ddd, YYYY[ko] MMM D[a] HH:mm'
8060 },
8061 calendar : {
8062 sameDay : '[gaur] LT[etan]',
8063 nextDay : '[bihar] LT[etan]',
8064 nextWeek : 'dddd LT[etan]',
8065 lastDay : '[atzo] LT[etan]',
8066 lastWeek : '[aurreko] dddd LT[etan]',
8067 sameElse : 'L'
8068 },
8069 relativeTime : {
8070 future : '%s barru',
8071 past : 'duela %s',
8072 s : 'segundo batzuk',
8073 ss : '%d segundo',
8074 m : 'minutu bat',
8075 mm : '%d minutu',
8076 h : 'ordu bat',
8077 hh : '%d ordu',
8078 d : 'egun bat',
8079 dd : '%d egun',
8080 M : 'hilabete bat',
8081 MM : '%d hilabete',
8082 y : 'urte bat',
8083 yy : '%d urte'
8084 },
8085 dayOfMonthOrdinalParse: /\d{1,2}\./,
8086 ordinal : '%d.',
8087 week : {
8088 dow : 1, // Monday is the first day of the week.
8089 doy : 7 // The week that contains Jan 1st is the first week of the year.
8090 }
8091 });
8092
8093 return eu;
8094
8095})));
8096
8097
8098/***/ }),
8099/* 50 */
8100/***/ (function(module, exports, __webpack_require__) {
8101
8102//! moment.js locale configuration
8103
8104;(function (global, factory) {
8105 true ? factory(__webpack_require__(0)) :
8106 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8107 factory(global.moment)
8108}(this, (function (moment) { 'use strict';
8109
8110
8111 var symbolMap = {
8112 '1': 'Û±',
8113 '2': 'Û²',
8114 '3': 'Û³',
8115 '4': 'Û´',
8116 '5': 'Ûµ',
8117 '6': 'Û¶',
8118 '7': 'Û·',
8119 '8': 'Û¸',
8120 '9': 'Û¹',
8121 '0': 'Û°'
8122 }, numberMap = {
8123 'Û±': '1',
8124 'Û²': '2',
8125 'Û³': '3',
8126 'Û´': '4',
8127 'Ûµ': '5',
8128 'Û¶': '6',
8129 'Û·': '7',
8130 'Û¸': '8',
8131 'Û¹': '9',
8132 'Û°': '0'
8133 };
8134
8135 var fa = moment.defineLocale('fa', {
8136 months : 'ژانویه_Ùوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
8137 monthsShort : 'ژانویه_Ùوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
8138 weekdays : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
8139 weekdaysShort : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
8140 weekdaysMin : 'ی_د_س_چ_پ_ج_ش'.split('_'),
8141 weekdaysParseExact : true,
8142 longDateFormat : {
8143 LT : 'HH:mm',
8144 LTS : 'HH:mm:ss',
8145 L : 'DD/MM/YYYY',
8146 LL : 'D MMMM YYYY',
8147 LLL : 'D MMMM YYYY HH:mm',
8148 LLLL : 'dddd, D MMMM YYYY HH:mm'
8149 },
8150 meridiemParse: /قبل از ظهر|بعد از ظهر/,
8151 isPM: function (input) {
8152 return /بعد از ظهر/.test(input);
8153 },
8154 meridiem : function (hour, minute, isLower) {
8155 if (hour < 12) {
8156 return 'قبل از ظهر';
8157 } else {
8158 return 'بعد از ظهر';
8159 }
8160 },
8161 calendar : {
8162 sameDay : '[امروز ساعت] LT',
8163 nextDay : '[Ùردا ساعت] LT',
8164 nextWeek : 'dddd [ساعت] LT',
8165 lastDay : '[دیروز ساعت] LT',
8166 lastWeek : 'dddd [پیش] [ساعت] LT',
8167 sameElse : 'L'
8168 },
8169 relativeTime : {
8170 future : 'در %s',
8171 past : '%s پیش',
8172 s : 'چند ثانیه',
8173 ss : 'ثانیه d%',
8174 m : 'یک دقیقه',
8175 mm : '%d دقیقه',
8176 h : 'یک ساعت',
8177 hh : '%d ساعت',
8178 d : 'یک روز',
8179 dd : '%d روز',
8180 M : 'یک ماه',
8181 MM : '%d ماه',
8182 y : 'یک سال',
8183 yy : '%d سال'
8184 },
8185 preparse: function (string) {
8186 return string.replace(/[Û°-Û¹]/g, function (match) {
8187 return numberMap[match];
8188 }).replace(/،/g, ',');
8189 },
8190 postformat: function (string) {
8191 return string.replace(/\d/g, function (match) {
8192 return symbolMap[match];
8193 }).replace(/,/g, '،');
8194 },
8195 dayOfMonthOrdinalParse: /\d{1,2}Ù…/,
8196 ordinal : '%dÙ…',
8197 week : {
8198 dow : 6, // Saturday is the first day of the week.
8199 doy : 12 // The week that contains Jan 1st is the first week of the year.
8200 }
8201 });
8202
8203 return fa;
8204
8205})));
8206
8207
8208/***/ }),
8209/* 51 */
8210/***/ (function(module, exports, __webpack_require__) {
8211
8212//! moment.js locale configuration
8213
8214;(function (global, factory) {
8215 true ? factory(__webpack_require__(0)) :
8216 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8217 factory(global.moment)
8218}(this, (function (moment) { 'use strict';
8219
8220
8221 var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '),
8222 numbersFuture = [
8223 'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
8224 numbersPast[7], numbersPast[8], numbersPast[9]
8225 ];
8226 function translate(number, withoutSuffix, key, isFuture) {
8227 var result = '';
8228 switch (key) {
8229 case 's':
8230 return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
8231 case 'ss':
8232 return isFuture ? 'sekunnin' : 'sekuntia';
8233 case 'm':
8234 return isFuture ? 'minuutin' : 'minuutti';
8235 case 'mm':
8236 result = isFuture ? 'minuutin' : 'minuuttia';
8237 break;
8238 case 'h':
8239 return isFuture ? 'tunnin' : 'tunti';
8240 case 'hh':
8241 result = isFuture ? 'tunnin' : 'tuntia';
8242 break;
8243 case 'd':
8244 return isFuture ? 'päivän' : 'päivä';
8245 case 'dd':
8246 result = isFuture ? 'päivän' : 'päivää';
8247 break;
8248 case 'M':
8249 return isFuture ? 'kuukauden' : 'kuukausi';
8250 case 'MM':
8251 result = isFuture ? 'kuukauden' : 'kuukautta';
8252 break;
8253 case 'y':
8254 return isFuture ? 'vuoden' : 'vuosi';
8255 case 'yy':
8256 result = isFuture ? 'vuoden' : 'vuotta';
8257 break;
8258 }
8259 result = verbalNumber(number, isFuture) + ' ' + result;
8260 return result;
8261 }
8262 function verbalNumber(number, isFuture) {
8263 return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;
8264 }
8265
8266 var fi = moment.defineLocale('fi', {
8267 months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
8268 monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
8269 weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
8270 weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
8271 weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
8272 longDateFormat : {
8273 LT : 'HH.mm',
8274 LTS : 'HH.mm.ss',
8275 L : 'DD.MM.YYYY',
8276 LL : 'Do MMMM[ta] YYYY',
8277 LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm',
8278 LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
8279 l : 'D.M.YYYY',
8280 ll : 'Do MMM YYYY',
8281 lll : 'Do MMM YYYY, [klo] HH.mm',
8282 llll : 'ddd, Do MMM YYYY, [klo] HH.mm'
8283 },
8284 calendar : {
8285 sameDay : '[tänään] [klo] LT',
8286 nextDay : '[huomenna] [klo] LT',
8287 nextWeek : 'dddd [klo] LT',
8288 lastDay : '[eilen] [klo] LT',
8289 lastWeek : '[viime] dddd[na] [klo] LT',
8290 sameElse : 'L'
8291 },
8292 relativeTime : {
8293 future : '%s päästä',
8294 past : '%s sitten',
8295 s : translate,
8296 ss : translate,
8297 m : translate,
8298 mm : translate,
8299 h : translate,
8300 hh : translate,
8301 d : translate,
8302 dd : translate,
8303 M : translate,
8304 MM : translate,
8305 y : translate,
8306 yy : translate
8307 },
8308 dayOfMonthOrdinalParse: /\d{1,2}\./,
8309 ordinal : '%d.',
8310 week : {
8311 dow : 1, // Monday is the first day of the week.
8312 doy : 4 // The week that contains Jan 4th is the first week of the year.
8313 }
8314 });
8315
8316 return fi;
8317
8318})));
8319
8320
8321/***/ }),
8322/* 52 */
8323/***/ (function(module, exports, __webpack_require__) {
8324
8325//! moment.js locale configuration
8326
8327;(function (global, factory) {
8328 true ? factory(__webpack_require__(0)) :
8329 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8330 factory(global.moment)
8331}(this, (function (moment) { 'use strict';
8332
8333
8334 var fo = moment.defineLocale('fo', {
8335 months : 'januar_februar_mars_aprÃl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
8336 monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
8337 weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_frÃggjadagur_leygardagur'.split('_'),
8338 weekdaysShort : 'sun_mán_týs_mik_hós_frÃ_ley'.split('_'),
8339 weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'),
8340 longDateFormat : {
8341 LT : 'HH:mm',
8342 LTS : 'HH:mm:ss',
8343 L : 'DD/MM/YYYY',
8344 LL : 'D MMMM YYYY',
8345 LLL : 'D MMMM YYYY HH:mm',
8346 LLLL : 'dddd D. MMMM, YYYY HH:mm'
8347 },
8348 calendar : {
8349 sameDay : '[Ã dag kl.] LT',
8350 nextDay : '[Ã morgin kl.] LT',
8351 nextWeek : 'dddd [kl.] LT',
8352 lastDay : '[à gjár kl.] LT',
8353 lastWeek : '[sÃðstu] dddd [kl] LT',
8354 sameElse : 'L'
8355 },
8356 relativeTime : {
8357 future : 'um %s',
8358 past : '%s sÃðani',
8359 s : 'fá sekund',
8360 ss : '%d sekundir',
8361 m : 'ein minutt',
8362 mm : '%d minuttir',
8363 h : 'ein tÃmi',
8364 hh : '%d tÃmar',
8365 d : 'ein dagur',
8366 dd : '%d dagar',
8367 M : 'ein mánaði',
8368 MM : '%d mánaðir',
8369 y : 'eitt ár',
8370 yy : '%d ár'
8371 },
8372 dayOfMonthOrdinalParse: /\d{1,2}\./,
8373 ordinal : '%d.',
8374 week : {
8375 dow : 1, // Monday is the first day of the week.
8376 doy : 4 // The week that contains Jan 4th is the first week of the year.
8377 }
8378 });
8379
8380 return fo;
8381
8382})));
8383
8384
8385/***/ }),
8386/* 53 */
8387/***/ (function(module, exports, __webpack_require__) {
8388
8389//! moment.js locale configuration
8390
8391;(function (global, factory) {
8392 true ? factory(__webpack_require__(0)) :
8393 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8394 factory(global.moment)
8395}(this, (function (moment) { 'use strict';
8396
8397
8398 var frCa = moment.defineLocale('fr-ca', {
8399 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
8400 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
8401 monthsParseExact : true,
8402 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
8403 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
8404 weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'),
8405 weekdaysParseExact : true,
8406 longDateFormat : {
8407 LT : 'HH:mm',
8408 LTS : 'HH:mm:ss',
8409 L : 'YYYY-MM-DD',
8410 LL : 'D MMMM YYYY',
8411 LLL : 'D MMMM YYYY HH:mm',
8412 LLLL : 'dddd D MMMM YYYY HH:mm'
8413 },
8414 calendar : {
8415 sameDay : '[Aujourd’hui à ] LT',
8416 nextDay : '[Demain à ] LT',
8417 nextWeek : 'dddd [Ã ] LT',
8418 lastDay : '[Hier à ] LT',
8419 lastWeek : 'dddd [dernier à ] LT',
8420 sameElse : 'L'
8421 },
8422 relativeTime : {
8423 future : 'dans %s',
8424 past : 'il y a %s',
8425 s : 'quelques secondes',
8426 ss : '%d secondes',
8427 m : 'une minute',
8428 mm : '%d minutes',
8429 h : 'une heure',
8430 hh : '%d heures',
8431 d : 'un jour',
8432 dd : '%d jours',
8433 M : 'un mois',
8434 MM : '%d mois',
8435 y : 'un an',
8436 yy : '%d ans'
8437 },
8438 dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
8439 ordinal : function (number, period) {
8440 switch (period) {
8441 // Words with masculine grammatical gender: mois, trimestre, jour
8442 default:
8443 case 'M':
8444 case 'Q':
8445 case 'D':
8446 case 'DDD':
8447 case 'd':
8448 return number + (number === 1 ? 'er' : 'e');
8449
8450 // Words with feminine grammatical gender: semaine
8451 case 'w':
8452 case 'W':
8453 return number + (number === 1 ? 're' : 'e');
8454 }
8455 }
8456 });
8457
8458 return frCa;
8459
8460})));
8461
8462
8463/***/ }),
8464/* 54 */
8465/***/ (function(module, exports, __webpack_require__) {
8466
8467//! moment.js locale configuration
8468
8469;(function (global, factory) {
8470 true ? factory(__webpack_require__(0)) :
8471 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8472 factory(global.moment)
8473}(this, (function (moment) { 'use strict';
8474
8475
8476 var frCh = moment.defineLocale('fr-ch', {
8477 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
8478 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
8479 monthsParseExact : true,
8480 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
8481 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
8482 weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'),
8483 weekdaysParseExact : true,
8484 longDateFormat : {
8485 LT : 'HH:mm',
8486 LTS : 'HH:mm:ss',
8487 L : 'DD.MM.YYYY',
8488 LL : 'D MMMM YYYY',
8489 LLL : 'D MMMM YYYY HH:mm',
8490 LLLL : 'dddd D MMMM YYYY HH:mm'
8491 },
8492 calendar : {
8493 sameDay : '[Aujourd’hui à ] LT',
8494 nextDay : '[Demain à ] LT',
8495 nextWeek : 'dddd [Ã ] LT',
8496 lastDay : '[Hier à ] LT',
8497 lastWeek : 'dddd [dernier à ] LT',
8498 sameElse : 'L'
8499 },
8500 relativeTime : {
8501 future : 'dans %s',
8502 past : 'il y a %s',
8503 s : 'quelques secondes',
8504 ss : '%d secondes',
8505 m : 'une minute',
8506 mm : '%d minutes',
8507 h : 'une heure',
8508 hh : '%d heures',
8509 d : 'un jour',
8510 dd : '%d jours',
8511 M : 'un mois',
8512 MM : '%d mois',
8513 y : 'un an',
8514 yy : '%d ans'
8515 },
8516 dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
8517 ordinal : function (number, period) {
8518 switch (period) {
8519 // Words with masculine grammatical gender: mois, trimestre, jour
8520 default:
8521 case 'M':
8522 case 'Q':
8523 case 'D':
8524 case 'DDD':
8525 case 'd':
8526 return number + (number === 1 ? 'er' : 'e');
8527
8528 // Words with feminine grammatical gender: semaine
8529 case 'w':
8530 case 'W':
8531 return number + (number === 1 ? 're' : 'e');
8532 }
8533 },
8534 week : {
8535 dow : 1, // Monday is the first day of the week.
8536 doy : 4 // The week that contains Jan 4th is the first week of the year.
8537 }
8538 });
8539
8540 return frCh;
8541
8542})));
8543
8544
8545/***/ }),
8546/* 55 */
8547/***/ (function(module, exports, __webpack_require__) {
8548
8549//! moment.js locale configuration
8550
8551;(function (global, factory) {
8552 true ? factory(__webpack_require__(0)) :
8553 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8554 factory(global.moment)
8555}(this, (function (moment) { 'use strict';
8556
8557
8558 var fr = moment.defineLocale('fr', {
8559 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
8560 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
8561 monthsParseExact : true,
8562 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
8563 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
8564 weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'),
8565 weekdaysParseExact : true,
8566 longDateFormat : {
8567 LT : 'HH:mm',
8568 LTS : 'HH:mm:ss',
8569 L : 'DD/MM/YYYY',
8570 LL : 'D MMMM YYYY',
8571 LLL : 'D MMMM YYYY HH:mm',
8572 LLLL : 'dddd D MMMM YYYY HH:mm'
8573 },
8574 calendar : {
8575 sameDay : '[Aujourd’hui à ] LT',
8576 nextDay : '[Demain à ] LT',
8577 nextWeek : 'dddd [Ã ] LT',
8578 lastDay : '[Hier à ] LT',
8579 lastWeek : 'dddd [dernier à ] LT',
8580 sameElse : 'L'
8581 },
8582 relativeTime : {
8583 future : 'dans %s',
8584 past : 'il y a %s',
8585 s : 'quelques secondes',
8586 ss : '%d secondes',
8587 m : 'une minute',
8588 mm : '%d minutes',
8589 h : 'une heure',
8590 hh : '%d heures',
8591 d : 'un jour',
8592 dd : '%d jours',
8593 M : 'un mois',
8594 MM : '%d mois',
8595 y : 'un an',
8596 yy : '%d ans'
8597 },
8598 dayOfMonthOrdinalParse: /\d{1,2}(er|)/,
8599 ordinal : function (number, period) {
8600 switch (period) {
8601 // TODO: Return 'e' when day of month > 1. Move this case inside
8602 // block for masculine words below.
8603 // See https://github.com/moment/moment/issues/3375
8604 case 'D':
8605 return number + (number === 1 ? 'er' : '');
8606
8607 // Words with masculine grammatical gender: mois, trimestre, jour
8608 default:
8609 case 'M':
8610 case 'Q':
8611 case 'DDD':
8612 case 'd':
8613 return number + (number === 1 ? 'er' : 'e');
8614
8615 // Words with feminine grammatical gender: semaine
8616 case 'w':
8617 case 'W':
8618 return number + (number === 1 ? 're' : 'e');
8619 }
8620 },
8621 week : {
8622 dow : 1, // Monday is the first day of the week.
8623 doy : 4 // The week that contains Jan 4th is the first week of the year.
8624 }
8625 });
8626
8627 return fr;
8628
8629})));
8630
8631
8632/***/ }),
8633/* 56 */
8634/***/ (function(module, exports, __webpack_require__) {
8635
8636//! moment.js locale configuration
8637
8638;(function (global, factory) {
8639 true ? factory(__webpack_require__(0)) :
8640 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8641 factory(global.moment)
8642}(this, (function (moment) { 'use strict';
8643
8644
8645 var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'),
8646 monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
8647
8648 var fy = moment.defineLocale('fy', {
8649 months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
8650 monthsShort : function (m, format) {
8651 if (!m) {
8652 return monthsShortWithDots;
8653 } else if (/-MMM-/.test(format)) {
8654 return monthsShortWithoutDots[m.month()];
8655 } else {
8656 return monthsShortWithDots[m.month()];
8657 }
8658 },
8659 monthsParseExact : true,
8660 weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
8661 weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'),
8662 weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
8663 weekdaysParseExact : true,
8664 longDateFormat : {
8665 LT : 'HH:mm',
8666 LTS : 'HH:mm:ss',
8667 L : 'DD-MM-YYYY',
8668 LL : 'D MMMM YYYY',
8669 LLL : 'D MMMM YYYY HH:mm',
8670 LLLL : 'dddd D MMMM YYYY HH:mm'
8671 },
8672 calendar : {
8673 sameDay: '[hjoed om] LT',
8674 nextDay: '[moarn om] LT',
8675 nextWeek: 'dddd [om] LT',
8676 lastDay: '[juster om] LT',
8677 lastWeek: '[ôfrûne] dddd [om] LT',
8678 sameElse: 'L'
8679 },
8680 relativeTime : {
8681 future : 'oer %s',
8682 past : '%s lyn',
8683 s : 'in pear sekonden',
8684 ss : '%d sekonden',
8685 m : 'ien minút',
8686 mm : '%d minuten',
8687 h : 'ien oere',
8688 hh : '%d oeren',
8689 d : 'ien dei',
8690 dd : '%d dagen',
8691 M : 'ien moanne',
8692 MM : '%d moannen',
8693 y : 'ien jier',
8694 yy : '%d jierren'
8695 },
8696 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
8697 ordinal : function (number) {
8698 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
8699 },
8700 week : {
8701 dow : 1, // Monday is the first day of the week.
8702 doy : 4 // The week that contains Jan 4th is the first week of the year.
8703 }
8704 });
8705
8706 return fy;
8707
8708})));
8709
8710
8711/***/ }),
8712/* 57 */
8713/***/ (function(module, exports, __webpack_require__) {
8714
8715//! moment.js locale configuration
8716
8717;(function (global, factory) {
8718 true ? factory(__webpack_require__(0)) :
8719 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8720 factory(global.moment)
8721}(this, (function (moment) { 'use strict';
8722
8723
8724 var months = [
8725 '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'
8726 ];
8727
8728 var monthsShort = ['Faoi', 'Gear', 'Mà rt', 'Gibl', 'Cèit', 'Ògmh', 'Iuch', 'Lùn', 'Sult', 'Dà mh', 'Samh', 'Dùbh'];
8729
8730 var weekdays = ['Didòmhnaich', 'Diluain', 'Dimà irt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];
8731
8732 var weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];
8733
8734 var weekdaysMin = ['Dò', 'Lu', 'Mà ', 'Ci', 'Ar', 'Ha', 'Sa'];
8735
8736 var gd = moment.defineLocale('gd', {
8737 months : months,
8738 monthsShort : monthsShort,
8739 monthsParseExact : true,
8740 weekdays : weekdays,
8741 weekdaysShort : weekdaysShort,
8742 weekdaysMin : weekdaysMin,
8743 longDateFormat : {
8744 LT : 'HH:mm',
8745 LTS : 'HH:mm:ss',
8746 L : 'DD/MM/YYYY',
8747 LL : 'D MMMM YYYY',
8748 LLL : 'D MMMM YYYY HH:mm',
8749 LLLL : 'dddd, D MMMM YYYY HH:mm'
8750 },
8751 calendar : {
8752 sameDay : '[An-diugh aig] LT',
8753 nextDay : '[A-mà ireach aig] LT',
8754 nextWeek : 'dddd [aig] LT',
8755 lastDay : '[An-dè aig] LT',
8756 lastWeek : 'dddd [seo chaidh] [aig] LT',
8757 sameElse : 'L'
8758 },
8759 relativeTime : {
8760 future : 'ann an %s',
8761 past : 'bho chionn %s',
8762 s : 'beagan diogan',
8763 ss : '%d diogan',
8764 m : 'mionaid',
8765 mm : '%d mionaidean',
8766 h : 'uair',
8767 hh : '%d uairean',
8768 d : 'latha',
8769 dd : '%d latha',
8770 M : 'mìos',
8771 MM : '%d mìosan',
8772 y : 'bliadhna',
8773 yy : '%d bliadhna'
8774 },
8775 dayOfMonthOrdinalParse : /\d{1,2}(d|na|mh)/,
8776 ordinal : function (number) {
8777 var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
8778 return number + output;
8779 },
8780 week : {
8781 dow : 1, // Monday is the first day of the week.
8782 doy : 4 // The week that contains Jan 4th is the first week of the year.
8783 }
8784 });
8785
8786 return gd;
8787
8788})));
8789
8790
8791/***/ }),
8792/* 58 */
8793/***/ (function(module, exports, __webpack_require__) {
8794
8795//! moment.js locale configuration
8796
8797;(function (global, factory) {
8798 true ? factory(__webpack_require__(0)) :
8799 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8800 factory(global.moment)
8801}(this, (function (moment) { 'use strict';
8802
8803
8804 var gl = moment.defineLocale('gl', {
8805 months : 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split('_'),
8806 monthsShort : 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split('_'),
8807 monthsParseExact: true,
8808 weekdays : 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'),
8809 weekdaysShort : 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'),
8810 weekdaysMin : 'do_lu_ma_mé_xo_ve_sá'.split('_'),
8811 weekdaysParseExact : true,
8812 longDateFormat : {
8813 LT : 'H:mm',
8814 LTS : 'H:mm:ss',
8815 L : 'DD/MM/YYYY',
8816 LL : 'D [de] MMMM [de] YYYY',
8817 LLL : 'D [de] MMMM [de] YYYY H:mm',
8818 LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
8819 },
8820 calendar : {
8821 sameDay : function () {
8822 return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
8823 },
8824 nextDay : function () {
8825 return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
8826 },
8827 nextWeek : function () {
8828 return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
8829 },
8830 lastDay : function () {
8831 return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
8832 },
8833 lastWeek : function () {
8834 return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
8835 },
8836 sameElse : 'L'
8837 },
8838 relativeTime : {
8839 future : function (str) {
8840 if (str.indexOf('un') === 0) {
8841 return 'n' + str;
8842 }
8843 return 'en ' + str;
8844 },
8845 past : 'hai %s',
8846 s : 'uns segundos',
8847 ss : '%d segundos',
8848 m : 'un minuto',
8849 mm : '%d minutos',
8850 h : 'unha hora',
8851 hh : '%d horas',
8852 d : 'un dÃa',
8853 dd : '%d dÃas',
8854 M : 'un mes',
8855 MM : '%d meses',
8856 y : 'un ano',
8857 yy : '%d anos'
8858 },
8859 dayOfMonthOrdinalParse : /\d{1,2}º/,
8860 ordinal : '%dº',
8861 week : {
8862 dow : 1, // Monday is the first day of the week.
8863 doy : 4 // The week that contains Jan 4th is the first week of the year.
8864 }
8865 });
8866
8867 return gl;
8868
8869})));
8870
8871
8872/***/ }),
8873/* 59 */
8874/***/ (function(module, exports, __webpack_require__) {
8875
8876//! moment.js locale configuration
8877
8878;(function (global, factory) {
8879 true ? factory(__webpack_require__(0)) :
8880 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
8881 factory(global.moment)
8882}(this, (function (moment) { 'use strict';
8883
8884
8885 function processRelativeTime(number, withoutSuffix, key, isFuture) {
8886 var format = {
8887 's': ['thodde secondanim', 'thodde second'],
8888 'ss': [number + ' secondanim', number + ' second'],
8889 'm': ['eka mintan', 'ek minute'],
8890 'mm': [number + ' mintanim', number + ' mintam'],
8891 'h': ['eka horan', 'ek hor'],
8892 'hh': [number + ' horanim', number + ' horam'],
8893 'd': ['eka disan', 'ek dis'],
8894 'dd': [number + ' disanim', number + ' dis'],
8895 'M': ['eka mhoinean', 'ek mhoino'],
8896 'MM': [number + ' mhoineanim', number + ' mhoine'],
8897 'y': ['eka vorsan', 'ek voros'],
8898 'yy': [number + ' vorsanim', number + ' vorsam']
8899 };
8900 return withoutSuffix ? format[key][0] : format[key][1];
8901 }
8902
8903 var gomLatn = moment.defineLocale('gom-latn', {
8904 months : 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split('_'),
8905 monthsShort : 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split('_'),
8906 monthsParseExact : true,
8907 weekdays : 'Aitar_Somar_Mongllar_Budvar_Brestar_Sukrar_Son\'var'.split('_'),
8908 weekdaysShort : 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'),
8909 weekdaysMin : 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'),
8910 weekdaysParseExact : true,
8911 longDateFormat : {
8912 LT : 'A h:mm [vazta]',
8913 LTS : 'A h:mm:ss [vazta]',
8914 L : 'DD-MM-YYYY',
8915 LL : 'D MMMM YYYY',
8916 LLL : 'D MMMM YYYY A h:mm [vazta]',
8917 LLLL : 'dddd, MMMM[achea] Do, YYYY, A h:mm [vazta]',
8918 llll: 'ddd, D MMM YYYY, A h:mm [vazta]'
8919 },
8920 calendar : {
8921 sameDay: '[Aiz] LT',
8922 nextDay: '[Faleam] LT',
8923 nextWeek: '[Ieta to] dddd[,] LT',
8924 lastDay: '[Kal] LT',
8925 lastWeek: '[Fatlo] dddd[,] LT',
8926 sameElse: 'L'
8927 },
8928 relativeTime : {
8929 future : '%s',
8930 past : '%s adim',
8931 s : processRelativeTime,
8932 ss : processRelativeTime,
8933 m : processRelativeTime,
8934 mm : processRelativeTime,
8935 h : processRelativeTime,
8936 hh : processRelativeTime,
8937 d : processRelativeTime,
8938 dd : processRelativeTime,
8939 M : processRelativeTime,
8940 MM : processRelativeTime,
8941 y : processRelativeTime,
8942 yy : processRelativeTime
8943 },
8944 dayOfMonthOrdinalParse : /\d{1,2}(er)/,
8945 ordinal : function (number, period) {
8946 switch (period) {
8947 // the ordinal 'er' only applies to day of the month
8948 case 'D':
8949 return number + 'er';
8950 default:
8951 case 'M':
8952 case 'Q':
8953 case 'DDD':
8954 case 'd':
8955 case 'w':
8956 case 'W':
8957 return number;
8958 }
8959 },
8960 week : {
8961 dow : 1, // Monday is the first day of the week.
8962 doy : 4 // The week that contains Jan 4th is the first week of the year.
8963 },
8964 meridiemParse: /rati|sokalli|donparam|sanje/,
8965 meridiemHour : function (hour, meridiem) {
8966 if (hour === 12) {
8967 hour = 0;
8968 }
8969 if (meridiem === 'rati') {
8970 return hour < 4 ? hour : hour + 12;
8971 } else if (meridiem === 'sokalli') {
8972 return hour;
8973 } else if (meridiem === 'donparam') {
8974 return hour > 12 ? hour : hour + 12;
8975 } else if (meridiem === 'sanje') {
8976 return hour + 12;
8977 }
8978 },
8979 meridiem : function (hour, minute, isLower) {
8980 if (hour < 4) {
8981 return 'rati';
8982 } else if (hour < 12) {
8983 return 'sokalli';
8984 } else if (hour < 16) {
8985 return 'donparam';
8986 } else if (hour < 20) {
8987 return 'sanje';
8988 } else {
8989 return 'rati';
8990 }
8991 }
8992 });
8993
8994 return gomLatn;
8995
8996})));
8997
8998
8999/***/ }),
9000/* 60 */
9001/***/ (function(module, exports, __webpack_require__) {
9002
9003//! moment.js locale configuration
9004
9005;(function (global, factory) {
9006 true ? factory(__webpack_require__(0)) :
9007 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9008 factory(global.moment)
9009}(this, (function (moment) { 'use strict';
9010
9011
9012 var symbolMap = {
9013 '1': '૧',
9014 '2': '૨',
9015 '3': 'à«©',
9016 '4': '૪',
9017 '5': 'à««',
9018 '6': '૬',
9019 '7': 'à«',
9020 '8': 'à«®',
9021 '9': '૯',
9022 '0': '૦'
9023 },
9024 numberMap = {
9025 '૧': '1',
9026 '૨': '2',
9027 'à«©': '3',
9028 '૪': '4',
9029 'à««': '5',
9030 '૬': '6',
9031 'à«': '7',
9032 'à«®': '8',
9033 '૯': '9',
9034 '૦': '0'
9035 };
9036
9037 var gu = moment.defineLocale('gu', {
9038 months: 'જાનà«àª¯à«àª†àª°à«€_ફેબà«àª°à«àª†àª°à«€_મારà«àªš_àªàªªà«àª°àª¿àª²_મે_જૂન_જà«àª²àª¾àªˆ_ઑગસà«àªŸ_સપà«àªŸà«‡àª®à«àª¬àª°_ઑકà«àªŸà«àª¬àª°_નવેમà«àª¬àª°_ડિસેમà«àª¬àª°'.split('_'),
9039 monthsShort: 'જાનà«àª¯à«._ફેબà«àª°à«._મારà«àªš_àªàªªà«àª°àª¿._મે_જૂન_જà«àª²àª¾._ઑગ._સપà«àªŸà«‡._ઑકà«àªŸà«._નવે._ડિસે.'.split('_'),
9040 monthsParseExact: true,
9041 weekdays: 'રવિવાર_સોમવાર_મંગળવાર_બà«àª§à«àªµàª¾àª°_ગà«àª°à«àªµàª¾àª°_શà«àª•à«àª°àªµàª¾àª°_શનિવાર'.split('_'),
9042 weekdaysShort: 'રવિ_સોમ_મંગળ_બà«àª§à«_ગà«àª°à«_શà«àª•à«àª°_શનિ'.split('_'),
9043 weekdaysMin: 'ર_સો_મં_બà«_ગà«_શà«_શ'.split('_'),
9044 longDateFormat: {
9045 LT: 'A h:mm વાગà«àª¯à«‡',
9046 LTS: 'A h:mm:ss વાગà«àª¯à«‡',
9047 L: 'DD/MM/YYYY',
9048 LL: 'D MMMM YYYY',
9049 LLL: 'D MMMM YYYY, A h:mm વાગà«àª¯à«‡',
9050 LLLL: 'dddd, D MMMM YYYY, A h:mm વાગà«àª¯à«‡'
9051 },
9052 calendar: {
9053 sameDay: '[આજ] LT',
9054 nextDay: '[કાલે] LT',
9055 nextWeek: 'dddd, LT',
9056 lastDay: '[ગઇકાલે] LT',
9057 lastWeek: '[પાછલા] dddd, LT',
9058 sameElse: 'L'
9059 },
9060 relativeTime: {
9061 future: '%s મા',
9062 past: '%s પેહલા',
9063 s: 'અમà«àª• પળો',
9064 ss: '%d સેકંડ',
9065 m: 'àªàª• મિનિટ',
9066 mm: '%d મિનિટ',
9067 h: 'àªàª• કલાક',
9068 hh: '%d કલાક',
9069 d: 'àªàª• દિવસ',
9070 dd: '%d દિવસ',
9071 M: 'àªàª• મહિનો',
9072 MM: '%d મહિનો',
9073 y: 'àªàª• વરà«àª·',
9074 yy: '%d વરà«àª·'
9075 },
9076 preparse: function (string) {
9077 return string.replace(/[૧૨૩૪૫૬à«à«®à«¯à«¦]/g, function (match) {
9078 return numberMap[match];
9079 });
9080 },
9081 postformat: function (string) {
9082 return string.replace(/\d/g, function (match) {
9083 return symbolMap[match];
9084 });
9085 },
9086 // Gujarati notation for meridiems are quite fuzzy in practice. While there exists
9087 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Gujarati.
9088 meridiemParse: /રાત|બપોર|સવાર|સાંજ/,
9089 meridiemHour: function (hour, meridiem) {
9090 if (hour === 12) {
9091 hour = 0;
9092 }
9093 if (meridiem === 'રાત') {
9094 return hour < 4 ? hour : hour + 12;
9095 } else if (meridiem === 'સવાર') {
9096 return hour;
9097 } else if (meridiem === 'બપોર') {
9098 return hour >= 10 ? hour : hour + 12;
9099 } else if (meridiem === 'સાંજ') {
9100 return hour + 12;
9101 }
9102 },
9103 meridiem: function (hour, minute, isLower) {
9104 if (hour < 4) {
9105 return 'રાત';
9106 } else if (hour < 10) {
9107 return 'સવાર';
9108 } else if (hour < 17) {
9109 return 'બપોર';
9110 } else if (hour < 20) {
9111 return 'સાંજ';
9112 } else {
9113 return 'રાત';
9114 }
9115 },
9116 week: {
9117 dow: 0, // Sunday is the first day of the week.
9118 doy: 6 // The week that contains Jan 1st is the first week of the year.
9119 }
9120 });
9121
9122 return gu;
9123
9124})));
9125
9126
9127/***/ }),
9128/* 61 */
9129/***/ (function(module, exports, __webpack_require__) {
9130
9131//! moment.js locale configuration
9132
9133;(function (global, factory) {
9134 true ? factory(__webpack_require__(0)) :
9135 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9136 factory(global.moment)
9137}(this, (function (moment) { 'use strict';
9138
9139
9140 var he = moment.defineLocale('he', {
9141 months : '×™× ×•×ר_פברו×ר_מרץ_×פריל_מ××™_×™×•× ×™_יולי_×וגוסט_ספטמבר_×וקטובר_× ×•×‘×ž×‘×¨_דצמבר'.split('_'),
9142 monthsShort : '×™× ×•×³_פבר׳_מרץ_×פר׳_מ××™_×™×•× ×™_יולי_×וג׳_ספט׳_×וק׳_× ×•×‘×³_דצמ׳'.split('_'),
9143 weekdays : 'ר×שון_×©× ×™_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
9144 weekdaysShort : '×׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
9145 weekdaysMin : '×_ב_×’_ד_×”_ו_ש'.split('_'),
9146 longDateFormat : {
9147 LT : 'HH:mm',
9148 LTS : 'HH:mm:ss',
9149 L : 'DD/MM/YYYY',
9150 LL : 'D [ב]MMMM YYYY',
9151 LLL : 'D [ב]MMMM YYYY HH:mm',
9152 LLLL : 'dddd, D [ב]MMMM YYYY HH:mm',
9153 l : 'D/M/YYYY',
9154 ll : 'D MMM YYYY',
9155 lll : 'D MMM YYYY HH:mm',
9156 llll : 'ddd, D MMM YYYY HH:mm'
9157 },
9158 calendar : {
9159 sameDay : '[×”×™×•× ×‘Ö¾]LT',
9160 nextDay : '[מחר ב־]LT',
9161 nextWeek : 'dddd [בשעה] LT',
9162 lastDay : '[×תמול ב־]LT',
9163 lastWeek : '[ביו×] dddd [×”×חרון בשעה] LT',
9164 sameElse : 'L'
9165 },
9166 relativeTime : {
9167 future : 'בעוד %s',
9168 past : '×œ×¤× ×™ %s',
9169 s : 'מספר ×©× ×™×•×ª',
9170 ss : '%d ×©× ×™×•×ª',
9171 m : 'דקה',
9172 mm : '%d דקות',
9173 h : 'שעה',
9174 hh : function (number) {
9175 if (number === 2) {
9176 return 'שעתיי×';
9177 }
9178 return number + ' שעות';
9179 },
9180 d : 'יו×',
9181 dd : function (number) {
9182 if (number === 2) {
9183 return 'יומיי×';
9184 }
9185 return number + ' ימי×';
9186 },
9187 M : 'חודש',
9188 MM : function (number) {
9189 if (number === 2) {
9190 return 'חודשיי×';
9191 }
9192 return number + ' חודשי×';
9193 },
9194 y : '×©× ×”',
9195 yy : function (number) {
9196 if (number === 2) {
9197 return '×©× ×ª×™×™×';
9198 } else if (number % 10 === 0 && number !== 10) {
9199 return number + ' ×©× ×”';
9200 }
9201 return number + ' ×©× ×™×';
9202 }
9203 },
9204 meridiemParse: /××—×”"צ|×œ×¤× ×”"צ|×חרי הצהריי×|×œ×¤× ×™ הצהריי×|×œ×¤× ×•×ª בוקר|בבוקר|בערב/i,
9205 isPM : function (input) {
9206 return /^(××—×”"צ|×חרי הצהריי×|בערב)$/.test(input);
9207 },
9208 meridiem : function (hour, minute, isLower) {
9209 if (hour < 5) {
9210 return '×œ×¤× ×•×ª בוקר';
9211 } else if (hour < 10) {
9212 return 'בבוקר';
9213 } else if (hour < 12) {
9214 return isLower ? '×œ×¤× ×”"צ' : '×œ×¤× ×™ הצהריי×';
9215 } else if (hour < 18) {
9216 return isLower ? '××—×”"צ' : '×חרי הצהריי×';
9217 } else {
9218 return 'בערב';
9219 }
9220 }
9221 });
9222
9223 return he;
9224
9225})));
9226
9227
9228/***/ }),
9229/* 62 */
9230/***/ (function(module, exports, __webpack_require__) {
9231
9232//! moment.js locale configuration
9233
9234;(function (global, factory) {
9235 true ? factory(__webpack_require__(0)) :
9236 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9237 factory(global.moment)
9238}(this, (function (moment) { 'use strict';
9239
9240
9241 var symbolMap = {
9242 '1': '१',
9243 '2': '२',
9244 '3': '३',
9245 '4': '४',
9246 '5': '५',
9247 '6': '६',
9248 '7': 'à¥',
9249 '8': '८',
9250 '9': '९',
9251 '0': '०'
9252 },
9253 numberMap = {
9254 '१': '1',
9255 '२': '2',
9256 '३': '3',
9257 '४': '4',
9258 '५': '5',
9259 '६': '6',
9260 'à¥': '7',
9261 '८': '8',
9262 '९': '9',
9263 '०': '0'
9264 };
9265
9266 var hi = moment.defineLocale('hi', {
9267 months : 'जनवरी_फ़रवरी_मारà¥à¤š_अपà¥à¤°à¥ˆà¤²_मई_जून_जà¥à¤²à¤¾à¤ˆ_अगसà¥à¤¤_सितमà¥à¤¬à¤°_अकà¥à¤Ÿà¥‚बर_नवमà¥à¤¬à¤°_दिसमà¥à¤¬à¤°'.split('_'),
9268 monthsShort : 'जन._फ़र._मारà¥à¤š_अपà¥à¤°à¥ˆ._मई_जून_जà¥à¤²._अग._सित._अकà¥à¤Ÿà¥‚._नव._दिस.'.split('_'),
9269 monthsParseExact: true,
9270 weekdays : 'रविवार_सोमवार_मंगलवार_बà¥à¤§à¤µà¤¾à¤°_गà¥à¤°à¥‚वार_शà¥à¤•à¥à¤°à¤µà¤¾à¤°_शनिवार'.split('_'),
9271 weekdaysShort : 'रवि_सोम_मंगल_बà¥à¤§_गà¥à¤°à¥‚_शà¥à¤•à¥à¤°_शनि'.split('_'),
9272 weekdaysMin : 'र_सो_मं_बà¥_गà¥_शà¥_श'.split('_'),
9273 longDateFormat : {
9274 LT : 'A h:mm बजे',
9275 LTS : 'A h:mm:ss बजे',
9276 L : 'DD/MM/YYYY',
9277 LL : 'D MMMM YYYY',
9278 LLL : 'D MMMM YYYY, A h:mm बजे',
9279 LLLL : 'dddd, D MMMM YYYY, A h:mm बजे'
9280 },
9281 calendar : {
9282 sameDay : '[आज] LT',
9283 nextDay : '[कल] LT',
9284 nextWeek : 'dddd, LT',
9285 lastDay : '[कल] LT',
9286 lastWeek : '[पिछले] dddd, LT',
9287 sameElse : 'L'
9288 },
9289 relativeTime : {
9290 future : '%s में',
9291 past : '%s पहले',
9292 s : 'कà¥à¤› ही कà¥à¤·à¤£',
9293 ss : '%d सेकंड',
9294 m : 'à¤à¤• मिनट',
9295 mm : '%d मिनट',
9296 h : 'à¤à¤• घंटा',
9297 hh : '%d घंटे',
9298 d : 'à¤à¤• दिन',
9299 dd : '%d दिन',
9300 M : 'à¤à¤• महीने',
9301 MM : '%d महीने',
9302 y : 'à¤à¤• वरà¥à¤·',
9303 yy : '%d वरà¥à¤·'
9304 },
9305 preparse: function (string) {
9306 return string.replace(/[१२३४५६à¥à¥®à¥¯à¥¦]/g, function (match) {
9307 return numberMap[match];
9308 });
9309 },
9310 postformat: function (string) {
9311 return string.replace(/\d/g, function (match) {
9312 return symbolMap[match];
9313 });
9314 },
9315 // Hindi notation for meridiems are quite fuzzy in practice. While there exists
9316 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
9317 meridiemParse: /रात|सà¥à¤¬à¤¹|दोपहर|शाम/,
9318 meridiemHour : function (hour, meridiem) {
9319 if (hour === 12) {
9320 hour = 0;
9321 }
9322 if (meridiem === 'रात') {
9323 return hour < 4 ? hour : hour + 12;
9324 } else if (meridiem === 'सà¥à¤¬à¤¹') {
9325 return hour;
9326 } else if (meridiem === 'दोपहर') {
9327 return hour >= 10 ? hour : hour + 12;
9328 } else if (meridiem === 'शाम') {
9329 return hour + 12;
9330 }
9331 },
9332 meridiem : function (hour, minute, isLower) {
9333 if (hour < 4) {
9334 return 'रात';
9335 } else if (hour < 10) {
9336 return 'सà¥à¤¬à¤¹';
9337 } else if (hour < 17) {
9338 return 'दोपहर';
9339 } else if (hour < 20) {
9340 return 'शाम';
9341 } else {
9342 return 'रात';
9343 }
9344 },
9345 week : {
9346 dow : 0, // Sunday is the first day of the week.
9347 doy : 6 // The week that contains Jan 1st is the first week of the year.
9348 }
9349 });
9350
9351 return hi;
9352
9353})));
9354
9355
9356/***/ }),
9357/* 63 */
9358/***/ (function(module, exports, __webpack_require__) {
9359
9360//! moment.js locale configuration
9361
9362;(function (global, factory) {
9363 true ? factory(__webpack_require__(0)) :
9364 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9365 factory(global.moment)
9366}(this, (function (moment) { 'use strict';
9367
9368
9369 function translate(number, withoutSuffix, key) {
9370 var result = number + ' ';
9371 switch (key) {
9372 case 'ss':
9373 if (number === 1) {
9374 result += 'sekunda';
9375 } else if (number === 2 || number === 3 || number === 4) {
9376 result += 'sekunde';
9377 } else {
9378 result += 'sekundi';
9379 }
9380 return result;
9381 case 'm':
9382 return withoutSuffix ? 'jedna minuta' : 'jedne minute';
9383 case 'mm':
9384 if (number === 1) {
9385 result += 'minuta';
9386 } else if (number === 2 || number === 3 || number === 4) {
9387 result += 'minute';
9388 } else {
9389 result += 'minuta';
9390 }
9391 return result;
9392 case 'h':
9393 return withoutSuffix ? 'jedan sat' : 'jednog sata';
9394 case 'hh':
9395 if (number === 1) {
9396 result += 'sat';
9397 } else if (number === 2 || number === 3 || number === 4) {
9398 result += 'sata';
9399 } else {
9400 result += 'sati';
9401 }
9402 return result;
9403 case 'dd':
9404 if (number === 1) {
9405 result += 'dan';
9406 } else {
9407 result += 'dana';
9408 }
9409 return result;
9410 case 'MM':
9411 if (number === 1) {
9412 result += 'mjesec';
9413 } else if (number === 2 || number === 3 || number === 4) {
9414 result += 'mjeseca';
9415 } else {
9416 result += 'mjeseci';
9417 }
9418 return result;
9419 case 'yy':
9420 if (number === 1) {
9421 result += 'godina';
9422 } else if (number === 2 || number === 3 || number === 4) {
9423 result += 'godine';
9424 } else {
9425 result += 'godina';
9426 }
9427 return result;
9428 }
9429 }
9430
9431 var hr = moment.defineLocale('hr', {
9432 months : {
9433 format: 'sijeÄnja_veljaÄe_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
9434 standalone: 'sijeÄanj_veljaÄa_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
9435 },
9436 monthsShort : 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
9437 monthsParseExact: true,
9438 weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'),
9439 weekdaysShort : 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'),
9440 weekdaysMin : 'ne_po_ut_sr_Äe_pe_su'.split('_'),
9441 weekdaysParseExact : true,
9442 longDateFormat : {
9443 LT : 'H:mm',
9444 LTS : 'H:mm:ss',
9445 L : 'DD.MM.YYYY',
9446 LL : 'D. MMMM YYYY',
9447 LLL : 'D. MMMM YYYY H:mm',
9448 LLLL : 'dddd, D. MMMM YYYY H:mm'
9449 },
9450 calendar : {
9451 sameDay : '[danas u] LT',
9452 nextDay : '[sutra u] LT',
9453 nextWeek : function () {
9454 switch (this.day()) {
9455 case 0:
9456 return '[u] [nedjelju] [u] LT';
9457 case 3:
9458 return '[u] [srijedu] [u] LT';
9459 case 6:
9460 return '[u] [subotu] [u] LT';
9461 case 1:
9462 case 2:
9463 case 4:
9464 case 5:
9465 return '[u] dddd [u] LT';
9466 }
9467 },
9468 lastDay : '[juÄer u] LT',
9469 lastWeek : function () {
9470 switch (this.day()) {
9471 case 0:
9472 case 3:
9473 return '[prošlu] dddd [u] LT';
9474 case 6:
9475 return '[prošle] [subote] [u] LT';
9476 case 1:
9477 case 2:
9478 case 4:
9479 case 5:
9480 return '[prošli] dddd [u] LT';
9481 }
9482 },
9483 sameElse : 'L'
9484 },
9485 relativeTime : {
9486 future : 'za %s',
9487 past : 'prije %s',
9488 s : 'par sekundi',
9489 ss : translate,
9490 m : translate,
9491 mm : translate,
9492 h : translate,
9493 hh : translate,
9494 d : 'dan',
9495 dd : translate,
9496 M : 'mjesec',
9497 MM : translate,
9498 y : 'godinu',
9499 yy : translate
9500 },
9501 dayOfMonthOrdinalParse: /\d{1,2}\./,
9502 ordinal : '%d.',
9503 week : {
9504 dow : 1, // Monday is the first day of the week.
9505 doy : 7 // The week that contains Jan 1st is the first week of the year.
9506 }
9507 });
9508
9509 return hr;
9510
9511})));
9512
9513
9514/***/ }),
9515/* 64 */
9516/***/ (function(module, exports, __webpack_require__) {
9517
9518//! moment.js locale configuration
9519
9520;(function (global, factory) {
9521 true ? factory(__webpack_require__(0)) :
9522 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9523 factory(global.moment)
9524}(this, (function (moment) { 'use strict';
9525
9526
9527 var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');
9528 function translate(number, withoutSuffix, key, isFuture) {
9529 var num = number;
9530 switch (key) {
9531 case 's':
9532 return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce';
9533 case 'ss':
9534 return num + (isFuture || withoutSuffix) ? ' másodperc' : ' másodperce';
9535 case 'm':
9536 return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
9537 case 'mm':
9538 return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
9539 case 'h':
9540 return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
9541 case 'hh':
9542 return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
9543 case 'd':
9544 return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
9545 case 'dd':
9546 return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
9547 case 'M':
9548 return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
9549 case 'MM':
9550 return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
9551 case 'y':
9552 return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
9553 case 'yy':
9554 return num + (isFuture || withoutSuffix ? ' év' : ' éve');
9555 }
9556 return '';
9557 }
9558 function week(isFuture) {
9559 return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';
9560 }
9561
9562 var hu = moment.defineLocale('hu', {
9563 months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
9564 monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
9565 weekdays : 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
9566 weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
9567 weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
9568 longDateFormat : {
9569 LT : 'H:mm',
9570 LTS : 'H:mm:ss',
9571 L : 'YYYY.MM.DD.',
9572 LL : 'YYYY. MMMM D.',
9573 LLL : 'YYYY. MMMM D. H:mm',
9574 LLLL : 'YYYY. MMMM D., dddd H:mm'
9575 },
9576 meridiemParse: /de|du/i,
9577 isPM: function (input) {
9578 return input.charAt(1).toLowerCase() === 'u';
9579 },
9580 meridiem : function (hours, minutes, isLower) {
9581 if (hours < 12) {
9582 return isLower === true ? 'de' : 'DE';
9583 } else {
9584 return isLower === true ? 'du' : 'DU';
9585 }
9586 },
9587 calendar : {
9588 sameDay : '[ma] LT[-kor]',
9589 nextDay : '[holnap] LT[-kor]',
9590 nextWeek : function () {
9591 return week.call(this, true);
9592 },
9593 lastDay : '[tegnap] LT[-kor]',
9594 lastWeek : function () {
9595 return week.call(this, false);
9596 },
9597 sameElse : 'L'
9598 },
9599 relativeTime : {
9600 future : '%s múlva',
9601 past : '%s',
9602 s : translate,
9603 ss : translate,
9604 m : translate,
9605 mm : translate,
9606 h : translate,
9607 hh : translate,
9608 d : translate,
9609 dd : translate,
9610 M : translate,
9611 MM : translate,
9612 y : translate,
9613 yy : translate
9614 },
9615 dayOfMonthOrdinalParse: /\d{1,2}\./,
9616 ordinal : '%d.',
9617 week : {
9618 dow : 1, // Monday is the first day of the week.
9619 doy : 4 // The week that contains Jan 4th is the first week of the year.
9620 }
9621 });
9622
9623 return hu;
9624
9625})));
9626
9627
9628/***/ }),
9629/* 65 */
9630/***/ (function(module, exports, __webpack_require__) {
9631
9632//! moment.js locale configuration
9633
9634;(function (global, factory) {
9635 true ? factory(__webpack_require__(0)) :
9636 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9637 factory(global.moment)
9638}(this, (function (moment) { 'use strict';
9639
9640
9641 var hyAm = moment.defineLocale('hy-am', {
9642 months : {
9643 format: 'Õ°Õ¸Ö‚Õ¶Õ¾Õ¡Ö€Õ«_ÖƒÕ¥Õ¿Ö€Õ¾Õ¡Ö€Õ«_Õ´Õ¡Ö€Õ¿Õ«_Õ¡ÕºÖ€Õ«Õ¬Õ«_Õ´Õ¡ÕµÕ«Õ½Õ«_Õ°Õ¸Ö‚Õ¶Õ«Õ½Õ«_Õ°Õ¸Ö‚Õ¬Õ«Õ½Õ«_Ö…Õ£Õ¸Õ½Õ¿Õ¸Õ½Õ«_Õ½Õ¥ÕºÕ¿Õ¥Õ´Õ¢Õ¥Ö€Õ«_Õ°Õ¸Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö€Õ«_Õ¶Õ¸ÕµÕ¥Õ´Õ¢Õ¥Ö€Õ«_Õ¤Õ¥Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö€Õ«'.split('_'),
9644 standalone: 'Õ°Õ¸Ö‚Õ¶Õ¾Õ¡Ö€_ÖƒÕ¥Õ¿Ö€Õ¾Õ¡Ö€_Õ´Õ¡Ö€Õ¿_Õ¡ÕºÖ€Õ«Õ¬_Õ´Õ¡ÕµÕ«Õ½_Õ°Õ¸Ö‚Õ¶Õ«Õ½_Õ°Õ¸Ö‚Õ¬Õ«Õ½_Ö…Õ£Õ¸Õ½Õ¿Õ¸Õ½_Õ½Õ¥ÕºÕ¿Õ¥Õ´Õ¢Õ¥Ö€_Õ°Õ¸Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö€_Õ¶Õ¸ÕµÕ¥Õ´Õ¢Õ¥Ö€_Õ¤Õ¥Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö€'.split('_')
9645 },
9646 monthsShort : 'Õ°Õ¶Õ¾_ÖƒÕ¿Ö€_Õ´Ö€Õ¿_Õ¡ÕºÖ€_Õ´ÕµÕ½_Õ°Õ¶Õ½_Õ°Õ¬Õ½_Ö…Õ£Õ½_Õ½ÕºÕ¿_Õ°Õ¯Õ¿_Õ¶Õ´Õ¢_Õ¤Õ¯Õ¿'.split('_'),
9647 weekdays : 'Õ¯Õ«Ö€Õ¡Õ¯Õ«_Õ¥Ö€Õ¯Õ¸Ö‚Õ·Õ¡Õ¢Õ©Õ«_Õ¥Ö€Õ¥Ö„Õ·Õ¡Õ¢Õ©Õ«_Õ¹Õ¸Ö€Õ¥Ö„Õ·Õ¡Õ¢Õ©Õ«_Õ°Õ«Õ¶Õ£Õ·Õ¡Õ¢Õ©Õ«_Õ¸Ö‚Ö€Õ¢Õ¡Õ©_Õ·Õ¡Õ¢Õ¡Õ©'.split('_'),
9648 weekdaysShort : 'Õ¯Ö€Õ¯_Õ¥Ö€Õ¯_Õ¥Ö€Ö„_Õ¹Ö€Ö„_Õ°Õ¶Õ£_Õ¸Ö‚Ö€Õ¢_Õ·Õ¢Õ©'.split('_'),
9649 weekdaysMin : 'Õ¯Ö€Õ¯_Õ¥Ö€Õ¯_Õ¥Ö€Ö„_Õ¹Ö€Ö„_Õ°Õ¶Õ£_Õ¸Ö‚Ö€Õ¢_Õ·Õ¢Õ©'.split('_'),
9650 longDateFormat : {
9651 LT : 'HH:mm',
9652 LTS : 'HH:mm:ss',
9653 L : 'DD.MM.YYYY',
9654 LL : 'D MMMM YYYY Õ©.',
9655 LLL : 'D MMMM YYYY Õ©., HH:mm',
9656 LLLL : 'dddd, D MMMM YYYY Õ©., HH:mm'
9657 },
9658 calendar : {
9659 sameDay: '[Õ¡ÕµÕ½Ö…Ö€] LT',
9660 nextDay: '[Õ¾Õ¡Õ²Õ¨] LT',
9661 lastDay: '[Õ¥Ö€Õ¥Õ¯] LT',
9662 nextWeek: function () {
9663 return 'dddd [Ö…Ö€Õ¨ ÕªÕ¡Õ´Õ¨] LT';
9664 },
9665 lastWeek: function () {
9666 return '[Õ¡Õ¶ÖÕ¡Õ®] dddd [Ö…Ö€Õ¨ ÕªÕ¡Õ´Õ¨] LT';
9667 },
9668 sameElse: 'L'
9669 },
9670 relativeTime : {
9671 future : '%s Õ°Õ¥Õ¿Õ¸',
9672 past : '%s Õ¡Õ¼Õ¡Õ»',
9673 s : 'Õ´Õ« Ö„Õ¡Õ¶Õ« Õ¾Õ¡ÕµÖ€Õ¯ÕµÕ¡Õ¶',
9674 ss : '%d Õ¾Õ¡ÕµÖ€Õ¯ÕµÕ¡Õ¶',
9675 m : 'Ö€Õ¸ÕºÕ¥',
9676 mm : '%d Ö€Õ¸ÕºÕ¥',
9677 h : 'ÕªÕ¡Õ´',
9678 hh : '%d ÕªÕ¡Õ´',
9679 d : 'Ö…Ö€',
9680 dd : '%d Ö…Ö€',
9681 M : 'Õ¡Õ´Õ«Õ½',
9682 MM : '%d Õ¡Õ´Õ«Õ½',
9683 y : 'Õ¿Õ¡Ö€Õ«',
9684 yy : '%d Õ¿Õ¡Ö€Õ«'
9685 },
9686 meridiemParse: /Õ£Õ«Õ·Õ¥Ö€Õ¾Õ¡|Õ¡Õ¼Õ¡Õ¾Õ¸Õ¿Õ¾Õ¡|ÖÕ¥Ö€Õ¥Õ¯Õ¾Õ¡|Õ¥Ö€Õ¥Õ¯Õ¸ÕµÕ¡Õ¶/,
9687 isPM: function (input) {
9688 return /^(ÖÕ¥Ö€Õ¥Õ¯Õ¾Õ¡|Õ¥Ö€Õ¥Õ¯Õ¸ÕµÕ¡Õ¶)$/.test(input);
9689 },
9690 meridiem : function (hour) {
9691 if (hour < 4) {
9692 return 'Õ£Õ«Õ·Õ¥Ö€Õ¾Õ¡';
9693 } else if (hour < 12) {
9694 return 'Õ¡Õ¼Õ¡Õ¾Õ¸Õ¿Õ¾Õ¡';
9695 } else if (hour < 17) {
9696 return 'ÖÕ¥Ö€Õ¥Õ¯Õ¾Õ¡';
9697 } else {
9698 return 'Õ¥Ö€Õ¥Õ¯Õ¸ÕµÕ¡Õ¶';
9699 }
9700 },
9701 dayOfMonthOrdinalParse: /\d{1,2}|\d{1,2}-(Õ«Õ¶|Ö€Õ¤)/,
9702 ordinal: function (number, period) {
9703 switch (period) {
9704 case 'DDD':
9705 case 'w':
9706 case 'W':
9707 case 'DDDo':
9708 if (number === 1) {
9709 return number + '-Õ«Õ¶';
9710 }
9711 return number + '-Ö€Õ¤';
9712 default:
9713 return number;
9714 }
9715 },
9716 week : {
9717 dow : 1, // Monday is the first day of the week.
9718 doy : 7 // The week that contains Jan 1st is the first week of the year.
9719 }
9720 });
9721
9722 return hyAm;
9723
9724})));
9725
9726
9727/***/ }),
9728/* 66 */
9729/***/ (function(module, exports, __webpack_require__) {
9730
9731//! moment.js locale configuration
9732
9733;(function (global, factory) {
9734 true ? factory(__webpack_require__(0)) :
9735 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9736 factory(global.moment)
9737}(this, (function (moment) { 'use strict';
9738
9739
9740 var id = moment.defineLocale('id', {
9741 months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
9742 monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des'.split('_'),
9743 weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
9744 weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
9745 weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
9746 longDateFormat : {
9747 LT : 'HH.mm',
9748 LTS : 'HH.mm.ss',
9749 L : 'DD/MM/YYYY',
9750 LL : 'D MMMM YYYY',
9751 LLL : 'D MMMM YYYY [pukul] HH.mm',
9752 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
9753 },
9754 meridiemParse: /pagi|siang|sore|malam/,
9755 meridiemHour : function (hour, meridiem) {
9756 if (hour === 12) {
9757 hour = 0;
9758 }
9759 if (meridiem === 'pagi') {
9760 return hour;
9761 } else if (meridiem === 'siang') {
9762 return hour >= 11 ? hour : hour + 12;
9763 } else if (meridiem === 'sore' || meridiem === 'malam') {
9764 return hour + 12;
9765 }
9766 },
9767 meridiem : function (hours, minutes, isLower) {
9768 if (hours < 11) {
9769 return 'pagi';
9770 } else if (hours < 15) {
9771 return 'siang';
9772 } else if (hours < 19) {
9773 return 'sore';
9774 } else {
9775 return 'malam';
9776 }
9777 },
9778 calendar : {
9779 sameDay : '[Hari ini pukul] LT',
9780 nextDay : '[Besok pukul] LT',
9781 nextWeek : 'dddd [pukul] LT',
9782 lastDay : '[Kemarin pukul] LT',
9783 lastWeek : 'dddd [lalu pukul] LT',
9784 sameElse : 'L'
9785 },
9786 relativeTime : {
9787 future : 'dalam %s',
9788 past : '%s yang lalu',
9789 s : 'beberapa detik',
9790 ss : '%d detik',
9791 m : 'semenit',
9792 mm : '%d menit',
9793 h : 'sejam',
9794 hh : '%d jam',
9795 d : 'sehari',
9796 dd : '%d hari',
9797 M : 'sebulan',
9798 MM : '%d bulan',
9799 y : 'setahun',
9800 yy : '%d tahun'
9801 },
9802 week : {
9803 dow : 1, // Monday is the first day of the week.
9804 doy : 7 // The week that contains Jan 1st is the first week of the year.
9805 }
9806 });
9807
9808 return id;
9809
9810})));
9811
9812
9813/***/ }),
9814/* 67 */
9815/***/ (function(module, exports, __webpack_require__) {
9816
9817//! moment.js locale configuration
9818
9819;(function (global, factory) {
9820 true ? factory(__webpack_require__(0)) :
9821 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9822 factory(global.moment)
9823}(this, (function (moment) { 'use strict';
9824
9825
9826 function plural(n) {
9827 if (n % 100 === 11) {
9828 return true;
9829 } else if (n % 10 === 1) {
9830 return false;
9831 }
9832 return true;
9833 }
9834 function translate(number, withoutSuffix, key, isFuture) {
9835 var result = number + ' ';
9836 switch (key) {
9837 case 's':
9838 return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
9839 case 'ss':
9840 if (plural(number)) {
9841 return result + (withoutSuffix || isFuture ? 'sekúndur' : 'sekúndum');
9842 }
9843 return result + 'sekúnda';
9844 case 'm':
9845 return withoutSuffix ? 'mÃnúta' : 'mÃnútu';
9846 case 'mm':
9847 if (plural(number)) {
9848 return result + (withoutSuffix || isFuture ? 'mÃnútur' : 'mÃnútum');
9849 } else if (withoutSuffix) {
9850 return result + 'mÃnúta';
9851 }
9852 return result + 'mÃnútu';
9853 case 'hh':
9854 if (plural(number)) {
9855 return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
9856 }
9857 return result + 'klukkustund';
9858 case 'd':
9859 if (withoutSuffix) {
9860 return 'dagur';
9861 }
9862 return isFuture ? 'dag' : 'degi';
9863 case 'dd':
9864 if (plural(number)) {
9865 if (withoutSuffix) {
9866 return result + 'dagar';
9867 }
9868 return result + (isFuture ? 'daga' : 'dögum');
9869 } else if (withoutSuffix) {
9870 return result + 'dagur';
9871 }
9872 return result + (isFuture ? 'dag' : 'degi');
9873 case 'M':
9874 if (withoutSuffix) {
9875 return 'mánuður';
9876 }
9877 return isFuture ? 'mánuð' : 'mánuði';
9878 case 'MM':
9879 if (plural(number)) {
9880 if (withoutSuffix) {
9881 return result + 'mánuðir';
9882 }
9883 return result + (isFuture ? 'mánuði' : 'mánuðum');
9884 } else if (withoutSuffix) {
9885 return result + 'mánuður';
9886 }
9887 return result + (isFuture ? 'mánuð' : 'mánuði');
9888 case 'y':
9889 return withoutSuffix || isFuture ? 'ár' : 'ári';
9890 case 'yy':
9891 if (plural(number)) {
9892 return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
9893 }
9894 return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
9895 }
9896 }
9897
9898 var is = moment.defineLocale('is', {
9899 months : 'janúar_febrúar_mars_aprÃl_maÃ_júnÃ_júlÃ_ágúst_september_október_nóvember_desember'.split('_'),
9900 monthsShort : 'jan_feb_mar_apr_maÃ_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
9901 weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
9902 weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
9903 weekdaysMin : 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
9904 longDateFormat : {
9905 LT : 'H:mm',
9906 LTS : 'H:mm:ss',
9907 L : 'DD.MM.YYYY',
9908 LL : 'D. MMMM YYYY',
9909 LLL : 'D. MMMM YYYY [kl.] H:mm',
9910 LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm'
9911 },
9912 calendar : {
9913 sameDay : '[Ã dag kl.] LT',
9914 nextDay : '[á morgun kl.] LT',
9915 nextWeek : 'dddd [kl.] LT',
9916 lastDay : '[à gær kl.] LT',
9917 lastWeek : '[sÃðasta] dddd [kl.] LT',
9918 sameElse : 'L'
9919 },
9920 relativeTime : {
9921 future : 'eftir %s',
9922 past : 'fyrir %s sÃðan',
9923 s : translate,
9924 ss : translate,
9925 m : translate,
9926 mm : translate,
9927 h : 'klukkustund',
9928 hh : translate,
9929 d : translate,
9930 dd : translate,
9931 M : translate,
9932 MM : translate,
9933 y : translate,
9934 yy : translate
9935 },
9936 dayOfMonthOrdinalParse: /\d{1,2}\./,
9937 ordinal : '%d.',
9938 week : {
9939 dow : 1, // Monday is the first day of the week.
9940 doy : 4 // The week that contains Jan 4th is the first week of the year.
9941 }
9942 });
9943
9944 return is;
9945
9946})));
9947
9948
9949/***/ }),
9950/* 68 */
9951/***/ (function(module, exports, __webpack_require__) {
9952
9953//! moment.js locale configuration
9954
9955;(function (global, factory) {
9956 true ? factory(__webpack_require__(0)) :
9957 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
9958 factory(global.moment)
9959}(this, (function (moment) { 'use strict';
9960
9961
9962 var it = moment.defineLocale('it', {
9963 months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
9964 monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
9965 weekdays : 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
9966 weekdaysShort : 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
9967 weekdaysMin : 'do_lu_ma_me_gi_ve_sa'.split('_'),
9968 longDateFormat : {
9969 LT : 'HH:mm',
9970 LTS : 'HH:mm:ss',
9971 L : 'DD/MM/YYYY',
9972 LL : 'D MMMM YYYY',
9973 LLL : 'D MMMM YYYY HH:mm',
9974 LLLL : 'dddd D MMMM YYYY HH:mm'
9975 },
9976 calendar : {
9977 sameDay: '[Oggi alle] LT',
9978 nextDay: '[Domani alle] LT',
9979 nextWeek: 'dddd [alle] LT',
9980 lastDay: '[Ieri alle] LT',
9981 lastWeek: function () {
9982 switch (this.day()) {
9983 case 0:
9984 return '[la scorsa] dddd [alle] LT';
9985 default:
9986 return '[lo scorso] dddd [alle] LT';
9987 }
9988 },
9989 sameElse: 'L'
9990 },
9991 relativeTime : {
9992 future : function (s) {
9993 return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
9994 },
9995 past : '%s fa',
9996 s : 'alcuni secondi',
9997 ss : '%d secondi',
9998 m : 'un minuto',
9999 mm : '%d minuti',
10000 h : 'un\'ora',
10001 hh : '%d ore',
10002 d : 'un giorno',
10003 dd : '%d giorni',
10004 M : 'un mese',
10005 MM : '%d mesi',
10006 y : 'un anno',
10007 yy : '%d anni'
10008 },
10009 dayOfMonthOrdinalParse : /\d{1,2}º/,
10010 ordinal: '%dº',
10011 week : {
10012 dow : 1, // Monday is the first day of the week.
10013 doy : 4 // The week that contains Jan 4th is the first week of the year.
10014 }
10015 });
10016
10017 return it;
10018
10019})));
10020
10021
10022/***/ }),
10023/* 69 */
10024/***/ (function(module, exports, __webpack_require__) {
10025
10026//! moment.js locale configuration
10027
10028;(function (global, factory) {
10029 true ? factory(__webpack_require__(0)) :
10030 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10031 factory(global.moment)
10032}(this, (function (moment) { 'use strict';
10033
10034
10035 var ja = moment.defineLocale('ja', {
10036 months : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
10037 monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
10038 weekdays : '日曜日_月曜日_ç«æ›œæ—¥_水曜日_木曜日_金曜日_土曜日'.split('_'),
10039 weekdaysShort : 'æ—¥_月_ç«_æ°´_木_金_土'.split('_'),
10040 weekdaysMin : 'æ—¥_月_ç«_æ°´_木_金_土'.split('_'),
10041 longDateFormat : {
10042 LT : 'HH:mm',
10043 LTS : 'HH:mm:ss',
10044 L : 'YYYY/MM/DD',
10045 LL : 'YYYY年M月D日',
10046 LLL : 'YYYY年M月D日 HH:mm',
10047 LLLL : 'YYYY年M月D日 dddd HH:mm',
10048 l : 'YYYY/MM/DD',
10049 ll : 'YYYY年M月D日',
10050 lll : 'YYYY年M月D日 HH:mm',
10051 llll : 'YYYY年M月D日(ddd) HH:mm'
10052 },
10053 meridiemParse: /åˆå‰|åˆå¾Œ/i,
10054 isPM : function (input) {
10055 return input === 'åˆå¾Œ';
10056 },
10057 meridiem : function (hour, minute, isLower) {
10058 if (hour < 12) {
10059 return 'åˆå‰';
10060 } else {
10061 return 'åˆå¾Œ';
10062 }
10063 },
10064 calendar : {
10065 sameDay : '[今日] LT',
10066 nextDay : '[明日] LT',
10067 nextWeek : function (now) {
10068 if (now.week() < this.week()) {
10069 return '[æ¥é€±]dddd LT';
10070 } else {
10071 return 'dddd LT';
10072 }
10073 },
10074 lastDay : '[昨日] LT',
10075 lastWeek : function (now) {
10076 if (this.week() < now.week()) {
10077 return '[先週]dddd LT';
10078 } else {
10079 return 'dddd LT';
10080 }
10081 },
10082 sameElse : 'L'
10083 },
10084 dayOfMonthOrdinalParse : /\d{1,2}æ—¥/,
10085 ordinal : function (number, period) {
10086 switch (period) {
10087 case 'd':
10088 case 'D':
10089 case 'DDD':
10090 return number + 'æ—¥';
10091 default:
10092 return number;
10093 }
10094 },
10095 relativeTime : {
10096 future : '%s後',
10097 past : '%så‰',
10098 s : '数秒',
10099 ss : '%d秒',
10100 m : '1分',
10101 mm : '%d分',
10102 h : '1時間',
10103 hh : '%d時間',
10104 d : '1æ—¥',
10105 dd : '%dæ—¥',
10106 M : '1ヶ月',
10107 MM : '%dヶ月',
10108 y : '1å¹´',
10109 yy : '%då¹´'
10110 }
10111 });
10112
10113 return ja;
10114
10115})));
10116
10117
10118/***/ }),
10119/* 70 */
10120/***/ (function(module, exports, __webpack_require__) {
10121
10122//! moment.js locale configuration
10123
10124;(function (global, factory) {
10125 true ? factory(__webpack_require__(0)) :
10126 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10127 factory(global.moment)
10128}(this, (function (moment) { 'use strict';
10129
10130
10131 var jv = moment.defineLocale('jv', {
10132 months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
10133 monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
10134 weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
10135 weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
10136 weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
10137 longDateFormat : {
10138 LT : 'HH.mm',
10139 LTS : 'HH.mm.ss',
10140 L : 'DD/MM/YYYY',
10141 LL : 'D MMMM YYYY',
10142 LLL : 'D MMMM YYYY [pukul] HH.mm',
10143 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
10144 },
10145 meridiemParse: /enjing|siyang|sonten|ndalu/,
10146 meridiemHour : function (hour, meridiem) {
10147 if (hour === 12) {
10148 hour = 0;
10149 }
10150 if (meridiem === 'enjing') {
10151 return hour;
10152 } else if (meridiem === 'siyang') {
10153 return hour >= 11 ? hour : hour + 12;
10154 } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
10155 return hour + 12;
10156 }
10157 },
10158 meridiem : function (hours, minutes, isLower) {
10159 if (hours < 11) {
10160 return 'enjing';
10161 } else if (hours < 15) {
10162 return 'siyang';
10163 } else if (hours < 19) {
10164 return 'sonten';
10165 } else {
10166 return 'ndalu';
10167 }
10168 },
10169 calendar : {
10170 sameDay : '[Dinten puniko pukul] LT',
10171 nextDay : '[Mbenjang pukul] LT',
10172 nextWeek : 'dddd [pukul] LT',
10173 lastDay : '[Kala wingi pukul] LT',
10174 lastWeek : 'dddd [kepengker pukul] LT',
10175 sameElse : 'L'
10176 },
10177 relativeTime : {
10178 future : 'wonten ing %s',
10179 past : '%s ingkang kepengker',
10180 s : 'sawetawis detik',
10181 ss : '%d detik',
10182 m : 'setunggal menit',
10183 mm : '%d menit',
10184 h : 'setunggal jam',
10185 hh : '%d jam',
10186 d : 'sedinten',
10187 dd : '%d dinten',
10188 M : 'sewulan',
10189 MM : '%d wulan',
10190 y : 'setaun',
10191 yy : '%d taun'
10192 },
10193 week : {
10194 dow : 1, // Monday is the first day of the week.
10195 doy : 7 // The week that contains Jan 1st is the first week of the year.
10196 }
10197 });
10198
10199 return jv;
10200
10201})));
10202
10203
10204/***/ }),
10205/* 71 */
10206/***/ (function(module, exports, __webpack_require__) {
10207
10208//! moment.js locale configuration
10209
10210;(function (global, factory) {
10211 true ? factory(__webpack_require__(0)) :
10212 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10213 factory(global.moment)
10214}(this, (function (moment) { 'use strict';
10215
10216
10217 var ka = moment.defineLocale('ka', {
10218 months : {
10219 standalone: 'იáƒáƒœáƒ•áƒáƒ ი_თებერვáƒáƒšáƒ˜_მáƒáƒ ტი_áƒáƒžáƒ ილი_მáƒáƒ˜áƒ¡áƒ˜_ივნისი_ივლისი_áƒáƒ’ვისტáƒ_სექტემბერი_áƒáƒ¥áƒ¢áƒáƒ›áƒ‘ერი_ნáƒáƒ”მბერი_დეკემბერი'.split('_'),
10220 format: 'იáƒáƒœáƒ•áƒáƒ ს_თებერვáƒáƒšáƒ¡_მáƒáƒ ტს_áƒáƒžáƒ ილის_მáƒáƒ˜áƒ¡áƒ¡_ივნისს_ივლისს_áƒáƒ’ვისტს_სექტემბერს_áƒáƒ¥áƒ¢áƒáƒ›áƒ‘ერს_ნáƒáƒ”მბერს_დეკემბერს'.split('_')
10221 },
10222 monthsShort : 'იáƒáƒœ_თებ_მáƒáƒ _áƒáƒžáƒ _მáƒáƒ˜_ივნ_ივლ_áƒáƒ’ვ_სექ_áƒáƒ¥áƒ¢_ნáƒáƒ”_დეკ'.split('_'),
10223 weekdays : {
10224 standalone: 'კვირáƒ_áƒáƒ შáƒáƒ‘áƒáƒ—ი_სáƒáƒ›áƒ¨áƒáƒ‘áƒáƒ—ი_áƒáƒ—ხშáƒáƒ‘áƒáƒ—ი_ხუთშáƒáƒ‘áƒáƒ—ი_პáƒáƒ áƒáƒ¡áƒ™áƒ”ვი_შáƒáƒ‘áƒáƒ—ი'.split('_'),
10225 format: 'კვირáƒáƒ¡_áƒáƒ შáƒáƒ‘áƒáƒ—ს_სáƒáƒ›áƒ¨áƒáƒ‘áƒáƒ—ს_áƒáƒ—ხშáƒáƒ‘áƒáƒ—ს_ხუთშáƒáƒ‘áƒáƒ—ს_პáƒáƒ áƒáƒ¡áƒ™áƒ”ვს_შáƒáƒ‘áƒáƒ—ს'.split('_'),
10226 isFormat: /(წინáƒ|შემდეგ)/
10227 },
10228 weekdaysShort : 'კვი_áƒáƒ შ_სáƒáƒ›_áƒáƒ—ხ_ხუთ_პáƒáƒ _შáƒáƒ‘'.split('_'),
10229 weekdaysMin : 'კვ_áƒáƒ _სáƒ_áƒáƒ—_ხუ_პáƒ_შáƒ'.split('_'),
10230 longDateFormat : {
10231 LT : 'h:mm A',
10232 LTS : 'h:mm:ss A',
10233 L : 'DD/MM/YYYY',
10234 LL : 'D MMMM YYYY',
10235 LLL : 'D MMMM YYYY h:mm A',
10236 LLLL : 'dddd, D MMMM YYYY h:mm A'
10237 },
10238 calendar : {
10239 sameDay : '[დღეს] LT[-ზე]',
10240 nextDay : '[ხვáƒáƒš] LT[-ზე]',
10241 lastDay : '[გუშინ] LT[-ზე]',
10242 nextWeek : '[შემდეგ] dddd LT[-ზე]',
10243 lastWeek : '[წინáƒ] dddd LT-ზე',
10244 sameElse : 'L'
10245 },
10246 relativeTime : {
10247 future : function (s) {
10248 return (/(წáƒáƒ›áƒ˜|წუთი|სáƒáƒáƒ—ი|წელი)/).test(s) ?
10249 s.replace(/ი$/, 'ში') :
10250 s + 'ში';
10251 },
10252 past : function (s) {
10253 if ((/(წáƒáƒ›áƒ˜|წუთი|სáƒáƒáƒ—ი|დღე|თვე)/).test(s)) {
10254 return s.replace(/(ი|ე)$/, 'ის წინ');
10255 }
10256 if ((/წელი/).test(s)) {
10257 return s.replace(/წელი$/, 'წლის წინ');
10258 }
10259 },
10260 s : 'რáƒáƒ›áƒ“ენიმე წáƒáƒ›áƒ˜',
10261 ss : '%d წáƒáƒ›áƒ˜',
10262 m : 'წუთი',
10263 mm : '%d წუთი',
10264 h : 'სáƒáƒáƒ—ი',
10265 hh : '%d სáƒáƒáƒ—ი',
10266 d : 'დღე',
10267 dd : '%d დღე',
10268 M : 'თვე',
10269 MM : '%d თვე',
10270 y : 'წელი',
10271 yy : '%d წელი'
10272 },
10273 dayOfMonthOrdinalParse: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
10274 ordinal : function (number) {
10275 if (number === 0) {
10276 return number;
10277 }
10278 if (number === 1) {
10279 return number + '-ლი';
10280 }
10281 if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
10282 return 'მე-' + number;
10283 }
10284 return number + '-ე';
10285 },
10286 week : {
10287 dow : 1,
10288 doy : 7
10289 }
10290 });
10291
10292 return ka;
10293
10294})));
10295
10296
10297/***/ }),
10298/* 72 */
10299/***/ (function(module, exports, __webpack_require__) {
10300
10301//! moment.js locale configuration
10302
10303;(function (global, factory) {
10304 true ? factory(__webpack_require__(0)) :
10305 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10306 factory(global.moment)
10307}(this, (function (moment) { 'use strict';
10308
10309
10310 var suffixes = {
10311 0: '-ші',
10312 1: '-ші',
10313 2: '-ші',
10314 3: '-ші',
10315 4: '-ші',
10316 5: '-ші',
10317 6: '-шы',
10318 7: '-ші',
10319 8: '-ші',
10320 9: '-шы',
10321 10: '-шы',
10322 20: '-шы',
10323 30: '-шы',
10324 40: '-шы',
10325 50: '-ші',
10326 60: '-шы',
10327 70: '-ші',
10328 80: '-ші',
10329 90: '-шы',
10330 100: '-ші'
10331 };
10332
10333 var kk = moment.defineLocale('kk', {
10334 months : 'қаңтар_ақпан_наурыз_Ñәуір_мамыр_мауÑым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқÑан'.split('_'),
10335 monthsShort : 'қаң_ақп_нау_Ñәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
10336 weekdays : 'жекÑенбі_дүйÑенбі_ÑейÑенбі_ÑәрÑенбі_бейÑенбі_жұма_Ñенбі'.split('_'),
10337 weekdaysShort : 'жек_дүй_Ñей_Ñәр_бей_жұм_Ñен'.split('_'),
10338 weekdaysMin : 'жк_дй_Ñй_ÑÑ€_бй_жм_Ñн'.split('_'),
10339 longDateFormat : {
10340 LT : 'HH:mm',
10341 LTS : 'HH:mm:ss',
10342 L : 'DD.MM.YYYY',
10343 LL : 'D MMMM YYYY',
10344 LLL : 'D MMMM YYYY HH:mm',
10345 LLLL : 'dddd, D MMMM YYYY HH:mm'
10346 },
10347 calendar : {
10348 sameDay : '[Бүгін Ñағат] LT',
10349 nextDay : '[Ертең Ñағат] LT',
10350 nextWeek : 'dddd [Ñағат] LT',
10351 lastDay : '[Кеше Ñағат] LT',
10352 lastWeek : '[Өткен аптаның] dddd [Ñағат] LT',
10353 sameElse : 'L'
10354 },
10355 relativeTime : {
10356 future : '%s ішінде',
10357 past : '%s бұрын',
10358 s : 'бірнеше Ñекунд',
10359 ss : '%d Ñекунд',
10360 m : 'бір минут',
10361 mm : '%d минут',
10362 h : 'бір Ñағат',
10363 hh : '%d Ñағат',
10364 d : 'бір күн',
10365 dd : '%d күн',
10366 M : 'бір ай',
10367 MM : '%d ай',
10368 y : 'бір жыл',
10369 yy : '%d жыл'
10370 },
10371 dayOfMonthOrdinalParse: /\d{1,2}-(ші|шы)/,
10372 ordinal : function (number) {
10373 var a = number % 10,
10374 b = number >= 100 ? 100 : null;
10375 return number + (suffixes[number] || suffixes[a] || suffixes[b]);
10376 },
10377 week : {
10378 dow : 1, // Monday is the first day of the week.
10379 doy : 7 // The week that contains Jan 1st is the first week of the year.
10380 }
10381 });
10382
10383 return kk;
10384
10385})));
10386
10387
10388/***/ }),
10389/* 73 */
10390/***/ (function(module, exports, __webpack_require__) {
10391
10392//! moment.js locale configuration
10393
10394;(function (global, factory) {
10395 true ? factory(__webpack_require__(0)) :
10396 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10397 factory(global.moment)
10398}(this, (function (moment) { 'use strict';
10399
10400
10401 var symbolMap = {
10402 '1': '១',
10403 '2': '២',
10404 '3': '៣',
10405 '4': '៤',
10406 '5': '៥',
10407 '6': '៦',
10408 '7': '៧',
10409 '8': '៨',
10410 '9': '៩',
10411 '0': '០'
10412 }, numberMap = {
10413 '១': '1',
10414 '២': '2',
10415 '៣': '3',
10416 '៤': '4',
10417 '៥': '5',
10418 '៦': '6',
10419 '៧': '7',
10420 '៨': '8',
10421 '៩': '9',
10422 '០': '0'
10423 };
10424
10425 var km = moment.defineLocale('km', {
10426 months: 'មករា_កុម្ភៈ_មីនា_មáŸážŸáž¶_ឧសភា_មិážáž»áž“ា_កក្កដា_សីហា_កញ្ញា_ážáž»áž›áž¶_វិច្ឆិកា_ធ្នូ'.split(
10427 '_'
10428 ),
10429 monthsShort: 'មករា_កុម្ភៈ_មីនា_មáŸážŸáž¶_ឧសភា_មិážáž»áž“ា_កក្កដា_សីហា_កញ្ញា_ážáž»áž›áž¶_វិច្ឆិកា_ធ្នូ'.split(
10430 '_'
10431 ),
10432 weekdays: 'អាទិážáŸ’áž™_áž…áŸáž“្ទ_អង្គារ_ពុធ_ព្រហស្បážáž·áŸ_សុក្រ_សៅរáŸ'.split('_'),
10433 weekdaysShort: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
10434 weekdaysMin: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
10435 weekdaysParseExact: true,
10436 longDateFormat: {
10437 LT: 'HH:mm',
10438 LTS: 'HH:mm:ss',
10439 L: 'DD/MM/YYYY',
10440 LL: 'D MMMM YYYY',
10441 LLL: 'D MMMM YYYY HH:mm',
10442 LLLL: 'dddd, D MMMM YYYY HH:mm'
10443 },
10444 meridiemParse: /ព្រឹក|ល្ងាច/,
10445 isPM: function (input) {
10446 return input === 'ល្ងាច';
10447 },
10448 meridiem: function (hour, minute, isLower) {
10449 if (hour < 12) {
10450 return 'ព្រឹក';
10451 } else {
10452 return 'ល្ងាច';
10453 }
10454 },
10455 calendar: {
10456 sameDay: '[ážáŸ’ងៃនáŸáŸ‡ ម៉ោង] LT',
10457 nextDay: '[ស្អែក ម៉ោង] LT',
10458 nextWeek: 'dddd [ម៉ោង] LT',
10459 lastDay: '[ម្សិលមិញ ម៉ោង] LT',
10460 lastWeek: 'dddd [សប្ážáž¶áž áŸáž˜áž»áž“] [ម៉ោង] LT',
10461 sameElse: 'L'
10462 },
10463 relativeTime: {
10464 future: '%sទៀáž',
10465 past: '%sមុន',
10466 s: 'ប៉ុន្មានវិនាទី',
10467 ss: '%d វិនាទី',
10468 m: 'មួយនាទី',
10469 mm: '%d នាទី',
10470 h: 'មួយម៉ោង',
10471 hh: '%d ម៉ោង',
10472 d: 'មួយážáŸ’ងៃ',
10473 dd: '%d ážáŸ’ងៃ',
10474 M: 'មួយážáŸ‚',
10475 MM: '%d ážáŸ‚',
10476 y: 'មួយឆ្នាំ',
10477 yy: '%d ឆ្នាំ'
10478 },
10479 dayOfMonthOrdinalParse : /ទី\d{1,2}/,
10480 ordinal : 'ទី%d',
10481 preparse: function (string) {
10482 return string.replace(/[១២៣៤៥៦៧៨៩០]/g, function (match) {
10483 return numberMap[match];
10484 });
10485 },
10486 postformat: function (string) {
10487 return string.replace(/\d/g, function (match) {
10488 return symbolMap[match];
10489 });
10490 },
10491 week: {
10492 dow: 1, // Monday is the first day of the week.
10493 doy: 4 // The week that contains Jan 4th is the first week of the year.
10494 }
10495 });
10496
10497 return km;
10498
10499})));
10500
10501
10502/***/ }),
10503/* 74 */
10504/***/ (function(module, exports, __webpack_require__) {
10505
10506//! moment.js locale configuration
10507
10508;(function (global, factory) {
10509 true ? factory(__webpack_require__(0)) :
10510 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10511 factory(global.moment)
10512}(this, (function (moment) { 'use strict';
10513
10514
10515 var symbolMap = {
10516 '1': '೧',
10517 '2': '೨',
10518 '3': '೩',
10519 '4': '೪',
10520 '5': '೫',
10521 '6': '೬',
10522 '7': 'à³',
10523 '8': 'à³®',
10524 '9': '೯',
10525 '0': '೦'
10526 },
10527 numberMap = {
10528 '೧': '1',
10529 '೨': '2',
10530 '೩': '3',
10531 '೪': '4',
10532 '೫': '5',
10533 '೬': '6',
10534 'à³': '7',
10535 'à³®': '8',
10536 '೯': '9',
10537 '೦': '0'
10538 };
10539
10540 var kn = moment.defineLocale('kn', {
10541 months : 'ಜನವರಿ_ಫೆಬà³à²°à²µà²°à²¿_ಮಾರà³à²šà³_à²à²ªà³à²°à²¿à²²à³_ಮೇ_ಜೂನà³_ಜà³à²²à³†à³–_ಆಗಸà³à²Ÿà³_ಸೆಪà³à²Ÿà³†à²‚ಬರà³_ಅಕà³à²Ÿà³†à³‚ೕಬರà³_ನವೆಂಬರà³_ಡಿಸೆಂಬರà³'.split('_'),
10542 monthsShort : 'ಜನ_ಫೆಬà³à²°_ಮಾರà³à²šà³_à²à²ªà³à²°à²¿à²²à³_ಮೇ_ಜೂನà³_ಜà³à²²à³†à³–_ಆಗಸà³à²Ÿà³_ಸೆಪà³à²Ÿà³†à²‚_ಅಕà³à²Ÿà³†à³‚ೕ_ನವೆಂ_ಡಿಸೆಂ'.split('_'),
10543 monthsParseExact: true,
10544 weekdays : 'à²à²¾à²¨à³à²µà²¾à²°_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬà³à²§à²µà²¾à²°_ಗà³à²°à³à²µà²¾à²°_ಶà³à²•à³à²°à²µà²¾à²°_ಶನಿವಾರ'.split('_'),
10545 weekdaysShort : 'à²à²¾à²¨à³_ಸೋಮ_ಮಂಗಳ_ಬà³à²§_ಗà³à²°à³_ಶà³à²•à³à²°_ಶನಿ'.split('_'),
10546 weekdaysMin : 'à²à²¾_ಸೋ_ಮಂ_ಬà³_ಗà³_ಶà³_ಶ'.split('_'),
10547 longDateFormat : {
10548 LT : 'A h:mm',
10549 LTS : 'A h:mm:ss',
10550 L : 'DD/MM/YYYY',
10551 LL : 'D MMMM YYYY',
10552 LLL : 'D MMMM YYYY, A h:mm',
10553 LLLL : 'dddd, D MMMM YYYY, A h:mm'
10554 },
10555 calendar : {
10556 sameDay : '[ಇಂದà³] LT',
10557 nextDay : '[ನಾಳೆ] LT',
10558 nextWeek : 'dddd, LT',
10559 lastDay : '[ನಿನà³à²¨à³†] LT',
10560 lastWeek : '[ಕೊನೆಯ] dddd, LT',
10561 sameElse : 'L'
10562 },
10563 relativeTime : {
10564 future : '%s ನಂತರ',
10565 past : '%s ಹಿಂದೆ',
10566 s : 'ಕೆಲವೠಕà³à²·à²£à²—ಳà³',
10567 ss : '%d ಸೆಕೆಂಡà³à²—ಳà³',
10568 m : 'ಒಂದೠನಿಮಿಷ',
10569 mm : '%d ನಿಮಿಷ',
10570 h : 'ಒಂದೠಗಂಟೆ',
10571 hh : '%d ಗಂಟೆ',
10572 d : 'ಒಂದೠದಿನ',
10573 dd : '%d ದಿನ',
10574 M : 'ಒಂದೠತಿಂಗಳà³',
10575 MM : '%d ತಿಂಗಳà³',
10576 y : 'ಒಂದೠವರà³à²·',
10577 yy : '%d ವರà³à²·'
10578 },
10579 preparse: function (string) {
10580 return string.replace(/[೧೨೩೪೫೬à³à³®à³¯à³¦]/g, function (match) {
10581 return numberMap[match];
10582 });
10583 },
10584 postformat: function (string) {
10585 return string.replace(/\d/g, function (match) {
10586 return symbolMap[match];
10587 });
10588 },
10589 meridiemParse: /ರಾತà³à²°à²¿|ಬೆಳಿಗà³à²—ೆ|ಮಧà³à²¯à²¾à²¹à³à²¨|ಸಂಜೆ/,
10590 meridiemHour : function (hour, meridiem) {
10591 if (hour === 12) {
10592 hour = 0;
10593 }
10594 if (meridiem === 'ರಾತà³à²°à²¿') {
10595 return hour < 4 ? hour : hour + 12;
10596 } else if (meridiem === 'ಬೆಳಿಗà³à²—ೆ') {
10597 return hour;
10598 } else if (meridiem === 'ಮಧà³à²¯à²¾à²¹à³à²¨') {
10599 return hour >= 10 ? hour : hour + 12;
10600 } else if (meridiem === 'ಸಂಜೆ') {
10601 return hour + 12;
10602 }
10603 },
10604 meridiem : function (hour, minute, isLower) {
10605 if (hour < 4) {
10606 return 'ರಾತà³à²°à²¿';
10607 } else if (hour < 10) {
10608 return 'ಬೆಳಿಗà³à²—ೆ';
10609 } else if (hour < 17) {
10610 return 'ಮಧà³à²¯à²¾à²¹à³à²¨';
10611 } else if (hour < 20) {
10612 return 'ಸಂಜೆ';
10613 } else {
10614 return 'ರಾತà³à²°à²¿';
10615 }
10616 },
10617 dayOfMonthOrdinalParse: /\d{1,2}(ನೇ)/,
10618 ordinal : function (number) {
10619 return number + 'ನೇ';
10620 },
10621 week : {
10622 dow : 0, // Sunday is the first day of the week.
10623 doy : 6 // The week that contains Jan 1st is the first week of the year.
10624 }
10625 });
10626
10627 return kn;
10628
10629})));
10630
10631
10632/***/ }),
10633/* 75 */
10634/***/ (function(module, exports, __webpack_require__) {
10635
10636//! moment.js locale configuration
10637
10638;(function (global, factory) {
10639 true ? factory(__webpack_require__(0)) :
10640 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10641 factory(global.moment)
10642}(this, (function (moment) { 'use strict';
10643
10644
10645 var ko = moment.defineLocale('ko', {
10646 months : '1ì›”_2ì›”_3ì›”_4ì›”_5ì›”_6ì›”_7ì›”_8ì›”_9ì›”_10ì›”_11ì›”_12ì›”'.split('_'),
10647 monthsShort : '1ì›”_2ì›”_3ì›”_4ì›”_5ì›”_6ì›”_7ì›”_8ì›”_9ì›”_10ì›”_11ì›”_12ì›”'.split('_'),
10648 weekdays : 'ì¼ìš”ì¼_월요ì¼_화요ì¼_수요ì¼_목요ì¼_금요ì¼_í† ìš”ì¼'.split('_'),
10649 weekdaysShort : 'ì¼_ì›”_í™”_수_목_금_í† '.split('_'),
10650 weekdaysMin : 'ì¼_ì›”_í™”_수_목_금_í† '.split('_'),
10651 longDateFormat : {
10652 LT : 'A h:mm',
10653 LTS : 'A h:mm:ss',
10654 L : 'YYYY.MM.DD.',
10655 LL : 'YYYYë…„ MMMM Dì¼',
10656 LLL : 'YYYYë…„ MMMM Dì¼ A h:mm',
10657 LLLL : 'YYYYë…„ MMMM Dì¼ dddd A h:mm',
10658 l : 'YYYY.MM.DD.',
10659 ll : 'YYYYë…„ MMMM Dì¼',
10660 lll : 'YYYYë…„ MMMM Dì¼ A h:mm',
10661 llll : 'YYYYë…„ MMMM Dì¼ dddd A h:mm'
10662 },
10663 calendar : {
10664 sameDay : '오늘 LT',
10665 nextDay : 'ë‚´ì¼ LT',
10666 nextWeek : 'dddd LT',
10667 lastDay : 'ì–´ì œ LT',
10668 lastWeek : '지난주 dddd LT',
10669 sameElse : 'L'
10670 },
10671 relativeTime : {
10672 future : '%s 후',
10673 past : '%s ì „',
10674 s : '몇 초',
10675 ss : '%dì´ˆ',
10676 m : '1분',
10677 mm : '%d분',
10678 h : '한 시간',
10679 hh : '%d시간',
10680 d : '하루',
10681 dd : '%dì¼',
10682 M : '한 달',
10683 MM : '%d달',
10684 y : 'ì¼ ë…„',
10685 yy : '%dë…„'
10686 },
10687 dayOfMonthOrdinalParse : /\d{1,2}(ì¼|ì›”|주)/,
10688 ordinal : function (number, period) {
10689 switch (period) {
10690 case 'd':
10691 case 'D':
10692 case 'DDD':
10693 return number + 'ì¼';
10694 case 'M':
10695 return number + 'ì›”';
10696 case 'w':
10697 case 'W':
10698 return number + '주';
10699 default:
10700 return number;
10701 }
10702 },
10703 meridiemParse : /ì˜¤ì „|오후/,
10704 isPM : function (token) {
10705 return token === '오후';
10706 },
10707 meridiem : function (hour, minute, isUpper) {
10708 return hour < 12 ? 'ì˜¤ì „' : '오후';
10709 }
10710 });
10711
10712 return ko;
10713
10714})));
10715
10716
10717/***/ }),
10718/* 76 */
10719/***/ (function(module, exports, __webpack_require__) {
10720
10721//! moment.js locale configuration
10722
10723;(function (global, factory) {
10724 true ? factory(__webpack_require__(0)) :
10725 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10726 factory(global.moment)
10727}(this, (function (moment) { 'use strict';
10728
10729
10730 var suffixes = {
10731 0: '-чү',
10732 1: '-чи',
10733 2: '-чи',
10734 3: '-чү',
10735 4: '-чү',
10736 5: '-чи',
10737 6: '-чы',
10738 7: '-чи',
10739 8: '-чи',
10740 9: '-чу',
10741 10: '-чу',
10742 20: '-чы',
10743 30: '-чу',
10744 40: '-чы',
10745 50: '-чү',
10746 60: '-чы',
10747 70: '-чи',
10748 80: '-чи',
10749 90: '-чу',
10750 100: '-чү'
10751 };
10752
10753 var ky = moment.defineLocale('ky', {
10754 months : 'Ñнварь_февраль_март_апрель_май_июнь_июль_авгуÑÑ‚_ÑентÑбрь_октÑбрь_ноÑбрь_декабрь'.split('_'),
10755 monthsShort : 'Ñнв_фев_март_апр_май_июнь_июль_авг_Ñен_окт_ноÑ_дек'.split('_'),
10756 weekdays : 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split('_'),
10757 weekdaysShort : 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
10758 weekdaysMin : 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
10759 longDateFormat : {
10760 LT : 'HH:mm',
10761 LTS : 'HH:mm:ss',
10762 L : 'DD.MM.YYYY',
10763 LL : 'D MMMM YYYY',
10764 LLL : 'D MMMM YYYY HH:mm',
10765 LLLL : 'dddd, D MMMM YYYY HH:mm'
10766 },
10767 calendar : {
10768 sameDay : '[Бүгүн Ñаат] LT',
10769 nextDay : '[Ðртең Ñаат] LT',
10770 nextWeek : 'dddd [Ñаат] LT',
10771 lastDay : '[Кече Ñаат] LT',
10772 lastWeek : '[Өткен аптанын] dddd [күнү] [Ñаат] LT',
10773 sameElse : 'L'
10774 },
10775 relativeTime : {
10776 future : '%s ичинде',
10777 past : '%s мурун',
10778 s : 'бирнече Ñекунд',
10779 ss : '%d Ñекунд',
10780 m : 'бир мүнөт',
10781 mm : '%d мүнөт',
10782 h : 'бир Ñаат',
10783 hh : '%d Ñаат',
10784 d : 'бир күн',
10785 dd : '%d күн',
10786 M : 'бир ай',
10787 MM : '%d ай',
10788 y : 'бир жыл',
10789 yy : '%d жыл'
10790 },
10791 dayOfMonthOrdinalParse: /\d{1,2}-(чи|чы|чү|чу)/,
10792 ordinal : function (number) {
10793 var a = number % 10,
10794 b = number >= 100 ? 100 : null;
10795 return number + (suffixes[number] || suffixes[a] || suffixes[b]);
10796 },
10797 week : {
10798 dow : 1, // Monday is the first day of the week.
10799 doy : 7 // The week that contains Jan 1st is the first week of the year.
10800 }
10801 });
10802
10803 return ky;
10804
10805})));
10806
10807
10808/***/ }),
10809/* 77 */
10810/***/ (function(module, exports, __webpack_require__) {
10811
10812//! moment.js locale configuration
10813
10814;(function (global, factory) {
10815 true ? factory(__webpack_require__(0)) :
10816 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10817 factory(global.moment)
10818}(this, (function (moment) { 'use strict';
10819
10820
10821 function processRelativeTime(number, withoutSuffix, key, isFuture) {
10822 var format = {
10823 'm': ['eng Minutt', 'enger Minutt'],
10824 'h': ['eng Stonn', 'enger Stonn'],
10825 'd': ['een Dag', 'engem Dag'],
10826 'M': ['ee Mount', 'engem Mount'],
10827 'y': ['ee Joer', 'engem Joer']
10828 };
10829 return withoutSuffix ? format[key][0] : format[key][1];
10830 }
10831 function processFutureTime(string) {
10832 var number = string.substr(0, string.indexOf(' '));
10833 if (eifelerRegelAppliesToNumber(number)) {
10834 return 'a ' + string;
10835 }
10836 return 'an ' + string;
10837 }
10838 function processPastTime(string) {
10839 var number = string.substr(0, string.indexOf(' '));
10840 if (eifelerRegelAppliesToNumber(number)) {
10841 return 'viru ' + string;
10842 }
10843 return 'virun ' + string;
10844 }
10845 /**
10846 * Returns true if the word before the given number loses the '-n' ending.
10847 * e.g. 'an 10 Deeg' but 'a 5 Deeg'
10848 *
10849 * @param number {integer}
10850 * @returns {boolean}
10851 */
10852 function eifelerRegelAppliesToNumber(number) {
10853 number = parseInt(number, 10);
10854 if (isNaN(number)) {
10855 return false;
10856 }
10857 if (number < 0) {
10858 // Negative Number --> always true
10859 return true;
10860 } else if (number < 10) {
10861 // Only 1 digit
10862 if (4 <= number && number <= 7) {
10863 return true;
10864 }
10865 return false;
10866 } else if (number < 100) {
10867 // 2 digits
10868 var lastDigit = number % 10, firstDigit = number / 10;
10869 if (lastDigit === 0) {
10870 return eifelerRegelAppliesToNumber(firstDigit);
10871 }
10872 return eifelerRegelAppliesToNumber(lastDigit);
10873 } else if (number < 10000) {
10874 // 3 or 4 digits --> recursively check first digit
10875 while (number >= 10) {
10876 number = number / 10;
10877 }
10878 return eifelerRegelAppliesToNumber(number);
10879 } else {
10880 // Anything larger than 4 digits: recursively check first n-3 digits
10881 number = number / 1000;
10882 return eifelerRegelAppliesToNumber(number);
10883 }
10884 }
10885
10886 var lb = moment.defineLocale('lb', {
10887 months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
10888 monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
10889 monthsParseExact : true,
10890 weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
10891 weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
10892 weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
10893 weekdaysParseExact : true,
10894 longDateFormat: {
10895 LT: 'H:mm [Auer]',
10896 LTS: 'H:mm:ss [Auer]',
10897 L: 'DD.MM.YYYY',
10898 LL: 'D. MMMM YYYY',
10899 LLL: 'D. MMMM YYYY H:mm [Auer]',
10900 LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]'
10901 },
10902 calendar: {
10903 sameDay: '[Haut um] LT',
10904 sameElse: 'L',
10905 nextDay: '[Muer um] LT',
10906 nextWeek: 'dddd [um] LT',
10907 lastDay: '[Gëschter um] LT',
10908 lastWeek: function () {
10909 // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
10910 switch (this.day()) {
10911 case 2:
10912 case 4:
10913 return '[Leschten] dddd [um] LT';
10914 default:
10915 return '[Leschte] dddd [um] LT';
10916 }
10917 }
10918 },
10919 relativeTime : {
10920 future : processFutureTime,
10921 past : processPastTime,
10922 s : 'e puer Sekonnen',
10923 ss : '%d Sekonnen',
10924 m : processRelativeTime,
10925 mm : '%d Minutten',
10926 h : processRelativeTime,
10927 hh : '%d Stonnen',
10928 d : processRelativeTime,
10929 dd : '%d Deeg',
10930 M : processRelativeTime,
10931 MM : '%d Méint',
10932 y : processRelativeTime,
10933 yy : '%d Joer'
10934 },
10935 dayOfMonthOrdinalParse: /\d{1,2}\./,
10936 ordinal: '%d.',
10937 week: {
10938 dow: 1, // Monday is the first day of the week.
10939 doy: 4 // The week that contains Jan 4th is the first week of the year.
10940 }
10941 });
10942
10943 return lb;
10944
10945})));
10946
10947
10948/***/ }),
10949/* 78 */
10950/***/ (function(module, exports, __webpack_require__) {
10951
10952//! moment.js locale configuration
10953
10954;(function (global, factory) {
10955 true ? factory(__webpack_require__(0)) :
10956 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
10957 factory(global.moment)
10958}(this, (function (moment) { 'use strict';
10959
10960
10961 var lo = moment.defineLocale('lo', {
10962 months : 'ມັງàºàºàº™_àºàº¸àº¡àºžàº²_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_àºà»àº¥àº°àºàº»àº”_ສິງຫາ_àºàº±àº™àºàº²_ຕຸລາ_ພະຈິàº_ທັນວາ'.split('_'),
10963 monthsShort : 'ມັງàºàºàº™_àºàº¸àº¡àºžàº²_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_àºà»àº¥àº°àºàº»àº”_ສິງຫາ_àºàº±àº™àºàº²_ຕຸລາ_ພະຈິàº_ທັນວາ'.split('_'),
10964 weekdays : 'àºàº²àº—ິດ_ຈັນ_àºàº±àº‡àº„ານ_ພຸດ_ພະຫັດ_ສຸàº_ເສົາ'.split('_'),
10965 weekdaysShort : 'ທິດ_ຈັນ_àºàº±àº‡àº„ານ_ພຸດ_ພະຫັດ_ສຸàº_ເສົາ'.split('_'),
10966 weekdaysMin : 'ທ_ຈ_àºàº„_ພ_ພຫ_ສàº_ສ'.split('_'),
10967 weekdaysParseExact : true,
10968 longDateFormat : {
10969 LT : 'HH:mm',
10970 LTS : 'HH:mm:ss',
10971 L : 'DD/MM/YYYY',
10972 LL : 'D MMMM YYYY',
10973 LLL : 'D MMMM YYYY HH:mm',
10974 LLLL : 'ວັນdddd D MMMM YYYY HH:mm'
10975 },
10976 meridiemParse: /ຕàºàº™à»€àºŠàº»à»‰àº²|ຕàºàº™à»àº¥àº‡/,
10977 isPM: function (input) {
10978 return input === 'ຕàºàº™à»àº¥àº‡';
10979 },
10980 meridiem : function (hour, minute, isLower) {
10981 if (hour < 12) {
10982 return 'ຕàºàº™à»€àºŠàº»à»‰àº²';
10983 } else {
10984 return 'ຕàºàº™à»àº¥àº‡';
10985 }
10986 },
10987 calendar : {
10988 sameDay : '[ມື້ນີ້ເວລາ] LT',
10989 nextDay : '[ມື້àºàº·à»ˆàº™à»€àº§àº¥àº²] LT',
10990 nextWeek : '[ວັນ]dddd[ໜ້າເວລາ] LT',
10991 lastDay : '[ມື້ວານນີ້ເວລາ] LT',
10992 lastWeek : '[ວັນ]dddd[à»àº¥à»‰àº§àº™àºµà»‰à»€àº§àº¥àº²] LT',
10993 sameElse : 'L'
10994 },
10995 relativeTime : {
10996 future : 'àºàºµàº %s',
10997 past : '%sຜ່ານມາ',
10998 s : 'ບà»à»ˆà»€àº—ົ່າໃດວິນາທີ',
10999 ss : '%d ວິນາທີ' ,
11000 m : '1 ນາທີ',
11001 mm : '%d ນາທີ',
11002 h : '1 ຊົ່ວໂມງ',
11003 hh : '%d ຊົ່ວໂມງ',
11004 d : '1 ມື້',
11005 dd : '%d ມື້',
11006 M : '1 ເດືàºàº™',
11007 MM : '%d ເດືàºàº™',
11008 y : '1 ປີ',
11009 yy : '%d ປີ'
11010 },
11011 dayOfMonthOrdinalParse: /(ທີ່)\d{1,2}/,
11012 ordinal : function (number) {
11013 return 'ທີ່' + number;
11014 }
11015 });
11016
11017 return lo;
11018
11019})));
11020
11021
11022/***/ }),
11023/* 79 */
11024/***/ (function(module, exports, __webpack_require__) {
11025
11026//! moment.js locale configuration
11027
11028;(function (global, factory) {
11029 true ? factory(__webpack_require__(0)) :
11030 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11031 factory(global.moment)
11032}(this, (function (moment) { 'use strict';
11033
11034
11035 var units = {
11036 'ss' : 'sekundė_sekundžių_sekundes',
11037 'm' : 'minutÄ—_minutÄ—s_minutÄ™',
11038 'mm': 'minutÄ—s_minuÄių_minutes',
11039 'h' : 'valanda_valandos_valandÄ…',
11040 'hh': 'valandos_valandų_valandas',
11041 'd' : 'diena_dienos_dienÄ…',
11042 'dd': 'dienos_dienų_dienas',
11043 'M' : 'mėnuo_mėnesio_mėnesį',
11044 'MM': 'mėnesiai_mėnesių_mėnesius',
11045 'y' : 'metai_metų_metus',
11046 'yy': 'metai_metų_metus'
11047 };
11048 function translateSeconds(number, withoutSuffix, key, isFuture) {
11049 if (withoutSuffix) {
11050 return 'kelios sekundÄ—s';
11051 } else {
11052 return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
11053 }
11054 }
11055 function translateSingular(number, withoutSuffix, key, isFuture) {
11056 return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);
11057 }
11058 function special(number) {
11059 return number % 10 === 0 || (number > 10 && number < 20);
11060 }
11061 function forms(key) {
11062 return units[key].split('_');
11063 }
11064 function translate(number, withoutSuffix, key, isFuture) {
11065 var result = number + ' ';
11066 if (number === 1) {
11067 return result + translateSingular(number, withoutSuffix, key[0], isFuture);
11068 } else if (withoutSuffix) {
11069 return result + (special(number) ? forms(key)[1] : forms(key)[0]);
11070 } else {
11071 if (isFuture) {
11072 return result + forms(key)[1];
11073 } else {
11074 return result + (special(number) ? forms(key)[1] : forms(key)[2]);
11075 }
11076 }
11077 }
11078 var lt = moment.defineLocale('lt', {
11079 months : {
11080 format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjÅ«Äio_rugsÄ—jo_spalio_lapkriÄio_gruodžio'.split('_'),
11081 standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_'),
11082 isFormat: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/
11083 },
11084 monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
11085 weekdays : {
11086 format: 'sekmadienį_pirmadienį_antradienį_treÄiadienį_ketvirtadienį_penktadienį_Å¡eÅ¡tadienį'.split('_'),
11087 standalone: 'sekmadienis_pirmadienis_antradienis_treÄiadienis_ketvirtadienis_penktadienis_Å¡eÅ¡tadienis'.split('_'),
11088 isFormat: /dddd HH:mm/
11089 },
11090 weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
11091 weekdaysMin : 'S_P_A_T_K_Pn_Å '.split('_'),
11092 weekdaysParseExact : true,
11093 longDateFormat : {
11094 LT : 'HH:mm',
11095 LTS : 'HH:mm:ss',
11096 L : 'YYYY-MM-DD',
11097 LL : 'YYYY [m.] MMMM D [d.]',
11098 LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
11099 LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
11100 l : 'YYYY-MM-DD',
11101 ll : 'YYYY [m.] MMMM D [d.]',
11102 lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
11103 llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
11104 },
11105 calendar : {
11106 sameDay : '[Å iandien] LT',
11107 nextDay : '[Rytoj] LT',
11108 nextWeek : 'dddd LT',
11109 lastDay : '[Vakar] LT',
11110 lastWeek : '[Praėjusį] dddd LT',
11111 sameElse : 'L'
11112 },
11113 relativeTime : {
11114 future : 'po %s',
11115 past : 'prieš %s',
11116 s : translateSeconds,
11117 ss : translate,
11118 m : translateSingular,
11119 mm : translate,
11120 h : translateSingular,
11121 hh : translate,
11122 d : translateSingular,
11123 dd : translate,
11124 M : translateSingular,
11125 MM : translate,
11126 y : translateSingular,
11127 yy : translate
11128 },
11129 dayOfMonthOrdinalParse: /\d{1,2}-oji/,
11130 ordinal : function (number) {
11131 return number + '-oji';
11132 },
11133 week : {
11134 dow : 1, // Monday is the first day of the week.
11135 doy : 4 // The week that contains Jan 4th is the first week of the year.
11136 }
11137 });
11138
11139 return lt;
11140
11141})));
11142
11143
11144/***/ }),
11145/* 80 */
11146/***/ (function(module, exports, __webpack_require__) {
11147
11148//! moment.js locale configuration
11149
11150;(function (global, factory) {
11151 true ? factory(__webpack_require__(0)) :
11152 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11153 factory(global.moment)
11154}(this, (function (moment) { 'use strict';
11155
11156
11157 var units = {
11158 'ss': 'sekundes_sekundēm_sekunde_sekundes'.split('_'),
11159 'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
11160 'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
11161 'h': 'stundas_stundÄm_stunda_stundas'.split('_'),
11162 'hh': 'stundas_stundÄm_stunda_stundas'.split('_'),
11163 'd': 'dienas_dienÄm_diena_dienas'.split('_'),
11164 'dd': 'dienas_dienÄm_diena_dienas'.split('_'),
11165 'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
11166 'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
11167 'y': 'gada_gadiem_gads_gadi'.split('_'),
11168 'yy': 'gada_gadiem_gads_gadi'.split('_')
11169 };
11170 /**
11171 * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
11172 */
11173 function format(forms, number, withoutSuffix) {
11174 if (withoutSuffix) {
11175 // E.g. "21 minūte", "3 minūtes".
11176 return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3];
11177 } else {
11178 // E.g. "21 minūtes" as in "pēc 21 minūtes".
11179 // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
11180 return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1];
11181 }
11182 }
11183 function relativeTimeWithPlural(number, withoutSuffix, key) {
11184 return number + ' ' + format(units[key], number, withoutSuffix);
11185 }
11186 function relativeTimeWithSingular(number, withoutSuffix, key) {
11187 return format(units[key], number, withoutSuffix);
11188 }
11189 function relativeSeconds(number, withoutSuffix) {
11190 return withoutSuffix ? 'dažas sekundes' : 'dažÄm sekundÄ“m';
11191 }
11192
11193 var lv = moment.defineLocale('lv', {
11194 months : 'janvÄris_februÄris_marts_aprÄ«lis_maijs_jÅ«nijs_jÅ«lijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
11195 monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
11196 weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
11197 weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
11198 weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
11199 weekdaysParseExact : true,
11200 longDateFormat : {
11201 LT : 'HH:mm',
11202 LTS : 'HH:mm:ss',
11203 L : 'DD.MM.YYYY.',
11204 LL : 'YYYY. [gada] D. MMMM',
11205 LLL : 'YYYY. [gada] D. MMMM, HH:mm',
11206 LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
11207 },
11208 calendar : {
11209 sameDay : '[Å odien pulksten] LT',
11210 nextDay : '[RÄ«t pulksten] LT',
11211 nextWeek : 'dddd [pulksten] LT',
11212 lastDay : '[Vakar pulksten] LT',
11213 lastWeek : '[PagÄjuÅ¡Ä] dddd [pulksten] LT',
11214 sameElse : 'L'
11215 },
11216 relativeTime : {
11217 future : 'pēc %s',
11218 past : 'pirms %s',
11219 s : relativeSeconds,
11220 ss : relativeTimeWithPlural,
11221 m : relativeTimeWithSingular,
11222 mm : relativeTimeWithPlural,
11223 h : relativeTimeWithSingular,
11224 hh : relativeTimeWithPlural,
11225 d : relativeTimeWithSingular,
11226 dd : relativeTimeWithPlural,
11227 M : relativeTimeWithSingular,
11228 MM : relativeTimeWithPlural,
11229 y : relativeTimeWithSingular,
11230 yy : relativeTimeWithPlural
11231 },
11232 dayOfMonthOrdinalParse: /\d{1,2}\./,
11233 ordinal : '%d.',
11234 week : {
11235 dow : 1, // Monday is the first day of the week.
11236 doy : 4 // The week that contains Jan 4th is the first week of the year.
11237 }
11238 });
11239
11240 return lv;
11241
11242})));
11243
11244
11245/***/ }),
11246/* 81 */
11247/***/ (function(module, exports, __webpack_require__) {
11248
11249//! moment.js locale configuration
11250
11251;(function (global, factory) {
11252 true ? factory(__webpack_require__(0)) :
11253 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11254 factory(global.moment)
11255}(this, (function (moment) { 'use strict';
11256
11257
11258 var translator = {
11259 words: { //Different grammatical cases
11260 ss: ['sekund', 'sekunda', 'sekundi'],
11261 m: ['jedan minut', 'jednog minuta'],
11262 mm: ['minut', 'minuta', 'minuta'],
11263 h: ['jedan sat', 'jednog sata'],
11264 hh: ['sat', 'sata', 'sati'],
11265 dd: ['dan', 'dana', 'dana'],
11266 MM: ['mjesec', 'mjeseca', 'mjeseci'],
11267 yy: ['godina', 'godine', 'godina']
11268 },
11269 correctGrammaticalCase: function (number, wordKey) {
11270 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
11271 },
11272 translate: function (number, withoutSuffix, key) {
11273 var wordKey = translator.words[key];
11274 if (key.length === 1) {
11275 return withoutSuffix ? wordKey[0] : wordKey[1];
11276 } else {
11277 return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
11278 }
11279 }
11280 };
11281
11282 var me = moment.defineLocale('me', {
11283 months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
11284 monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
11285 monthsParseExact : true,
11286 weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'),
11287 weekdaysShort: 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'),
11288 weekdaysMin: 'ne_po_ut_sr_Äe_pe_su'.split('_'),
11289 weekdaysParseExact : true,
11290 longDateFormat: {
11291 LT: 'H:mm',
11292 LTS : 'H:mm:ss',
11293 L: 'DD.MM.YYYY',
11294 LL: 'D. MMMM YYYY',
11295 LLL: 'D. MMMM YYYY H:mm',
11296 LLLL: 'dddd, D. MMMM YYYY H:mm'
11297 },
11298 calendar: {
11299 sameDay: '[danas u] LT',
11300 nextDay: '[sjutra u] LT',
11301
11302 nextWeek: function () {
11303 switch (this.day()) {
11304 case 0:
11305 return '[u] [nedjelju] [u] LT';
11306 case 3:
11307 return '[u] [srijedu] [u] LT';
11308 case 6:
11309 return '[u] [subotu] [u] LT';
11310 case 1:
11311 case 2:
11312 case 4:
11313 case 5:
11314 return '[u] dddd [u] LT';
11315 }
11316 },
11317 lastDay : '[juÄe u] LT',
11318 lastWeek : function () {
11319 var lastWeekDays = [
11320 '[prošle] [nedjelje] [u] LT',
11321 '[prošlog] [ponedjeljka] [u] LT',
11322 '[prošlog] [utorka] [u] LT',
11323 '[prošle] [srijede] [u] LT',
11324 '[proÅ¡log] [Äetvrtka] [u] LT',
11325 '[prošlog] [petka] [u] LT',
11326 '[prošle] [subote] [u] LT'
11327 ];
11328 return lastWeekDays[this.day()];
11329 },
11330 sameElse : 'L'
11331 },
11332 relativeTime : {
11333 future : 'za %s',
11334 past : 'prije %s',
11335 s : 'nekoliko sekundi',
11336 ss : translator.translate,
11337 m : translator.translate,
11338 mm : translator.translate,
11339 h : translator.translate,
11340 hh : translator.translate,
11341 d : 'dan',
11342 dd : translator.translate,
11343 M : 'mjesec',
11344 MM : translator.translate,
11345 y : 'godinu',
11346 yy : translator.translate
11347 },
11348 dayOfMonthOrdinalParse: /\d{1,2}\./,
11349 ordinal : '%d.',
11350 week : {
11351 dow : 1, // Monday is the first day of the week.
11352 doy : 7 // The week that contains Jan 1st is the first week of the year.
11353 }
11354 });
11355
11356 return me;
11357
11358})));
11359
11360
11361/***/ }),
11362/* 82 */
11363/***/ (function(module, exports, __webpack_require__) {
11364
11365//! moment.js locale configuration
11366
11367;(function (global, factory) {
11368 true ? factory(__webpack_require__(0)) :
11369 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11370 factory(global.moment)
11371}(this, (function (moment) { 'use strict';
11372
11373
11374 var mi = moment.defineLocale('mi', {
11375 months: 'Kohi-tÄte_Hui-tanguru_PoutÅ«-te-rangi_Paenga-whÄwhÄ_Haratua_Pipiri_HÅngoingoi_Here-turi-kÅkÄ_Mahuru_Whiringa-Ä-nuku_Whiringa-Ä-rangi_Hakihea'.split('_'),
11376 monthsShort: 'Kohi_Hui_Pou_Pae_Hara_Pipi_HÅngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split('_'),
11377 monthsRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
11378 monthsStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
11379 monthsShortRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
11380 monthsShortStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
11381 weekdays: 'RÄtapu_Mane_TÅ«rei_Wenerei_TÄite_Paraire_HÄtarei'.split('_'),
11382 weekdaysShort: 'Ta_Ma_TÅ«_We_TÄi_Pa_HÄ'.split('_'),
11383 weekdaysMin: 'Ta_Ma_TÅ«_We_TÄi_Pa_HÄ'.split('_'),
11384 longDateFormat: {
11385 LT: 'HH:mm',
11386 LTS: 'HH:mm:ss',
11387 L: 'DD/MM/YYYY',
11388 LL: 'D MMMM YYYY',
11389 LLL: 'D MMMM YYYY [i] HH:mm',
11390 LLLL: 'dddd, D MMMM YYYY [i] HH:mm'
11391 },
11392 calendar: {
11393 sameDay: '[i teie mahana, i] LT',
11394 nextDay: '[apopo i] LT',
11395 nextWeek: 'dddd [i] LT',
11396 lastDay: '[inanahi i] LT',
11397 lastWeek: 'dddd [whakamutunga i] LT',
11398 sameElse: 'L'
11399 },
11400 relativeTime: {
11401 future: 'i roto i %s',
11402 past: '%s i mua',
11403 s: 'te hēkona ruarua',
11404 ss: '%d hēkona',
11405 m: 'he meneti',
11406 mm: '%d meneti',
11407 h: 'te haora',
11408 hh: '%d haora',
11409 d: 'he ra',
11410 dd: '%d ra',
11411 M: 'he marama',
11412 MM: '%d marama',
11413 y: 'he tau',
11414 yy: '%d tau'
11415 },
11416 dayOfMonthOrdinalParse: /\d{1,2}º/,
11417 ordinal: '%dº',
11418 week : {
11419 dow : 1, // Monday is the first day of the week.
11420 doy : 4 // The week that contains Jan 4th is the first week of the year.
11421 }
11422 });
11423
11424 return mi;
11425
11426})));
11427
11428
11429/***/ }),
11430/* 83 */
11431/***/ (function(module, exports, __webpack_require__) {
11432
11433//! moment.js locale configuration
11434
11435;(function (global, factory) {
11436 true ? factory(__webpack_require__(0)) :
11437 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11438 factory(global.moment)
11439}(this, (function (moment) { 'use strict';
11440
11441
11442 var mk = moment.defineLocale('mk', {
11443 months : 'јануари_февруари_март_април_мај_јуни_јули_авгуÑÑ‚_Ñептември_октомври_ноември_декември'.split('_'),
11444 monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_Ñеп_окт_ное_дек'.split('_'),
11445 weekdays : 'недела_понеделник_вторник_Ñреда_четврток_петок_Ñабота'.split('_'),
11446 weekdaysShort : 'нед_пон_вто_Ñре_чет_пет_Ñаб'.split('_'),
11447 weekdaysMin : 'нe_пo_вт_ÑÑ€_че_пе_Ña'.split('_'),
11448 longDateFormat : {
11449 LT : 'H:mm',
11450 LTS : 'H:mm:ss',
11451 L : 'D.MM.YYYY',
11452 LL : 'D MMMM YYYY',
11453 LLL : 'D MMMM YYYY H:mm',
11454 LLLL : 'dddd, D MMMM YYYY H:mm'
11455 },
11456 calendar : {
11457 sameDay : '[Ð”ÐµÐ½ÐµÑ Ð²Ð¾] LT',
11458 nextDay : '[Утре во] LT',
11459 nextWeek : '[Во] dddd [во] LT',
11460 lastDay : '[Вчера во] LT',
11461 lastWeek : function () {
11462 switch (this.day()) {
11463 case 0:
11464 case 3:
11465 case 6:
11466 return '[Изминатата] dddd [во] LT';
11467 case 1:
11468 case 2:
11469 case 4:
11470 case 5:
11471 return '[Изминатиот] dddd [во] LT';
11472 }
11473 },
11474 sameElse : 'L'
11475 },
11476 relativeTime : {
11477 future : 'поÑле %s',
11478 past : 'пред %s',
11479 s : 'неколку Ñекунди',
11480 ss : '%d Ñекунди',
11481 m : 'минута',
11482 mm : '%d минути',
11483 h : 'чаÑ',
11484 hh : '%d чаÑа',
11485 d : 'ден',
11486 dd : '%d дена',
11487 M : 'меÑец',
11488 MM : '%d меÑеци',
11489 y : 'година',
11490 yy : '%d години'
11491 },
11492 dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
11493 ordinal : function (number) {
11494 var lastDigit = number % 10,
11495 last2Digits = number % 100;
11496 if (number === 0) {
11497 return number + '-ев';
11498 } else if (last2Digits === 0) {
11499 return number + '-ен';
11500 } else if (last2Digits > 10 && last2Digits < 20) {
11501 return number + '-ти';
11502 } else if (lastDigit === 1) {
11503 return number + '-ви';
11504 } else if (lastDigit === 2) {
11505 return number + '-ри';
11506 } else if (lastDigit === 7 || lastDigit === 8) {
11507 return number + '-ми';
11508 } else {
11509 return number + '-ти';
11510 }
11511 },
11512 week : {
11513 dow : 1, // Monday is the first day of the week.
11514 doy : 7 // The week that contains Jan 1st is the first week of the year.
11515 }
11516 });
11517
11518 return mk;
11519
11520})));
11521
11522
11523/***/ }),
11524/* 84 */
11525/***/ (function(module, exports, __webpack_require__) {
11526
11527//! moment.js locale configuration
11528
11529;(function (global, factory) {
11530 true ? factory(__webpack_require__(0)) :
11531 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11532 factory(global.moment)
11533}(this, (function (moment) { 'use strict';
11534
11535
11536 var ml = moment.defineLocale('ml', {
11537 months : 'ജനàµà´µà´°à´¿_ഫെബàµà´°àµà´µà´°à´¿_മാർചàµà´šàµ_à´à´ªàµà´°à´¿àµ½_മേയàµ_ജൂൺ_ജൂലൈ_à´“à´—à´¸àµà´±àµà´±àµ_സെപàµà´±àµà´±à´‚ബർ_à´’à´•àµà´Ÿàµ‹à´¬àµ¼_നവംബർ_ഡിസംബർ'.split('_'),
11538 monthsShort : 'ജനàµ._ഫെബàµà´°àµ._മാർ._à´à´ªàµà´°à´¿._മേയàµ_ജൂൺ_ജൂലൈ._à´“à´—._സെപàµà´±àµà´±._à´’à´•àµà´Ÿàµ‹._നവം._ഡിസം.'.split('_'),
11539 monthsParseExact : true,
11540 weekdays : 'ഞായറാഴàµà´š_തിങàµà´•à´³à´¾à´´àµà´š_ചൊവàµà´µà´¾à´´àµà´š_à´¬àµà´§à´¨à´¾à´´àµà´š_à´µàµà´¯à´¾à´´à´¾à´´àµà´š_വെളàµà´³à´¿à´¯à´¾à´´àµà´š_ശനിയാഴàµà´š'.split('_'),
11541 weekdaysShort : 'ഞായർ_തിങàµà´•àµ¾_ചൊവàµà´µ_à´¬àµà´§àµ»_à´µàµà´¯à´¾à´´à´‚_വെളàµà´³à´¿_ശനി'.split('_'),
11542 weekdaysMin : 'à´žà´¾_തി_ചൊ_à´¬àµ_à´µàµà´¯à´¾_വെ_à´¶'.split('_'),
11543 longDateFormat : {
11544 LT : 'A h:mm -à´¨àµ',
11545 LTS : 'A h:mm:ss -à´¨àµ',
11546 L : 'DD/MM/YYYY',
11547 LL : 'D MMMM YYYY',
11548 LLL : 'D MMMM YYYY, A h:mm -à´¨àµ',
11549 LLLL : 'dddd, D MMMM YYYY, A h:mm -à´¨àµ'
11550 },
11551 calendar : {
11552 sameDay : '[ഇനàµà´¨àµ] LT',
11553 nextDay : '[നാളെ] LT',
11554 nextWeek : 'dddd, LT',
11555 lastDay : '[ഇനàµà´¨à´²àµ†] LT',
11556 lastWeek : '[à´•à´´à´¿à´žàµà´ž] dddd, LT',
11557 sameElse : 'L'
11558 },
11559 relativeTime : {
11560 future : '%s à´•à´´à´¿à´žàµà´žàµ',
11561 past : '%s à´®àµàµ»à´ªàµ',
11562 s : 'അൽപ നിമിഷങàµà´™àµ¾',
11563 ss : '%d സെകàµà´•àµ»à´¡àµ',
11564 m : 'ഒരൠമിനിറàµà´±àµ',
11565 mm : '%d മിനിറàµà´±àµ',
11566 h : 'ഒരൠമണികàµà´•àµ‚ർ',
11567 hh : '%d മണികàµà´•àµ‚ർ',
11568 d : 'ഒരൠദിവസം',
11569 dd : '%d ദിവസം',
11570 M : 'ഒരൠമാസം',
11571 MM : '%d മാസം',
11572 y : 'ഒരൠവർഷം',
11573 yy : '%d വർഷം'
11574 },
11575 meridiemParse: /രാതàµà´°à´¿|രാവിലെ|ഉചàµà´š à´•à´´à´¿à´žàµà´žàµ|വൈകàµà´¨àµà´¨àµ‡à´°à´‚|രാതàµà´°à´¿/i,
11576 meridiemHour : function (hour, meridiem) {
11577 if (hour === 12) {
11578 hour = 0;
11579 }
11580 if ((meridiem === 'രാതàµà´°à´¿' && hour >= 4) ||
11581 meridiem === 'ഉചàµà´š à´•à´´à´¿à´žàµà´žàµ' ||
11582 meridiem === 'വൈകàµà´¨àµà´¨àµ‡à´°à´‚') {
11583 return hour + 12;
11584 } else {
11585 return hour;
11586 }
11587 },
11588 meridiem : function (hour, minute, isLower) {
11589 if (hour < 4) {
11590 return 'രാതàµà´°à´¿';
11591 } else if (hour < 12) {
11592 return 'രാവിലെ';
11593 } else if (hour < 17) {
11594 return 'ഉചàµà´š à´•à´´à´¿à´žàµà´žàµ';
11595 } else if (hour < 20) {
11596 return 'വൈകàµà´¨àµà´¨àµ‡à´°à´‚';
11597 } else {
11598 return 'രാതàµà´°à´¿';
11599 }
11600 }
11601 });
11602
11603 return ml;
11604
11605})));
11606
11607
11608/***/ }),
11609/* 85 */
11610/***/ (function(module, exports, __webpack_require__) {
11611
11612//! moment.js locale configuration
11613
11614;(function (global, factory) {
11615 true ? factory(__webpack_require__(0)) :
11616 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11617 factory(global.moment)
11618}(this, (function (moment) { 'use strict';
11619
11620
11621 function translate(number, withoutSuffix, key, isFuture) {
11622 switch (key) {
11623 case 's':
11624 return withoutSuffix ? 'Ñ…ÑдхÑн Ñекунд' : 'Ñ…ÑдхÑн Ñекундын';
11625 case 'ss':
11626 return number + (withoutSuffix ? ' Ñекунд' : ' Ñекундын');
11627 case 'm':
11628 case 'mm':
11629 return number + (withoutSuffix ? ' минут' : ' минутын');
11630 case 'h':
11631 case 'hh':
11632 return number + (withoutSuffix ? ' цаг' : ' цагийн');
11633 case 'd':
11634 case 'dd':
11635 return number + (withoutSuffix ? ' өдөр' : ' өдрийн');
11636 case 'M':
11637 case 'MM':
11638 return number + (withoutSuffix ? ' Ñар' : ' Ñарын');
11639 case 'y':
11640 case 'yy':
11641 return number + (withoutSuffix ? ' жил' : ' жилийн');
11642 default:
11643 return number;
11644 }
11645 }
11646
11647 var mn = moment.defineLocale('mn', {
11648 months : 'ÐÑгдүгÑÑÑ€ Ñар_Хоёрдугаар Ñар_Гуравдугаар Ñар_ДөрөвдүгÑÑÑ€ Ñар_Тавдугаар Ñар_Зургадугаар Ñар_Долдугаар Ñар_Ðаймдугаар Ñар_ЕÑдүгÑÑÑ€ Ñар_Ðравдугаар Ñар_Ðрван нÑгдүгÑÑÑ€ Ñар_Ðрван хоёрдугаар Ñар'.split('_'),
11649 monthsShort : '1 Ñар_2 Ñар_3 Ñар_4 Ñар_5 Ñар_6 Ñар_7 Ñар_8 Ñар_9 Ñар_10 Ñар_11 Ñар_12 Ñар'.split('_'),
11650 monthsParseExact : true,
11651 weekdays : 'ÐÑм_Даваа_ÐœÑгмар_Лхагва_ПүрÑв_БааÑан_БÑмба'.split('_'),
11652 weekdaysShort : 'ÐÑм_Дав_ÐœÑг_Лха_Пүр_Баа_БÑм'.split('_'),
11653 weekdaysMin : 'ÐÑ_Да_ÐœÑ_Лх_Пү_Ба_БÑ'.split('_'),
11654 weekdaysParseExact : true,
11655 longDateFormat : {
11656 LT : 'HH:mm',
11657 LTS : 'HH:mm:ss',
11658 L : 'YYYY-MM-DD',
11659 LL : 'YYYY оны MMMMын D',
11660 LLL : 'YYYY оны MMMMын D HH:mm',
11661 LLLL : 'dddd, YYYY оны MMMMын D HH:mm'
11662 },
11663 meridiemParse: /ҮӨ|ҮХ/i,
11664 isPM : function (input) {
11665 return input === 'ҮХ';
11666 },
11667 meridiem : function (hour, minute, isLower) {
11668 if (hour < 12) {
11669 return 'Ò®Ó¨';
11670 } else {
11671 return 'ҮХ';
11672 }
11673 },
11674 calendar : {
11675 sameDay : '[Өнөөдөр] LT',
11676 nextDay : '[Маргааш] LT',
11677 nextWeek : '[ИрÑÑ…] dddd LT',
11678 lastDay : '[Өчигдөр] LT',
11679 lastWeek : '[ӨнгөрÑөн] dddd LT',
11680 sameElse : 'L'
11681 },
11682 relativeTime : {
11683 future : '%s дараа',
11684 past : '%s өмнө',
11685 s : translate,
11686 ss : translate,
11687 m : translate,
11688 mm : translate,
11689 h : translate,
11690 hh : translate,
11691 d : translate,
11692 dd : translate,
11693 M : translate,
11694 MM : translate,
11695 y : translate,
11696 yy : translate
11697 },
11698 dayOfMonthOrdinalParse: /\d{1,2} өдөр/,
11699 ordinal : function (number, period) {
11700 switch (period) {
11701 case 'd':
11702 case 'D':
11703 case 'DDD':
11704 return number + ' өдөр';
11705 default:
11706 return number;
11707 }
11708 }
11709 });
11710
11711 return mn;
11712
11713})));
11714
11715
11716/***/ }),
11717/* 86 */
11718/***/ (function(module, exports, __webpack_require__) {
11719
11720//! moment.js locale configuration
11721
11722;(function (global, factory) {
11723 true ? factory(__webpack_require__(0)) :
11724 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11725 factory(global.moment)
11726}(this, (function (moment) { 'use strict';
11727
11728
11729 var symbolMap = {
11730 '1': '१',
11731 '2': '२',
11732 '3': '३',
11733 '4': '४',
11734 '5': '५',
11735 '6': '६',
11736 '7': 'à¥',
11737 '8': '८',
11738 '9': '९',
11739 '0': '०'
11740 },
11741 numberMap = {
11742 '१': '1',
11743 '२': '2',
11744 '३': '3',
11745 '४': '4',
11746 '५': '5',
11747 '६': '6',
11748 'à¥': '7',
11749 '८': '8',
11750 '९': '9',
11751 '०': '0'
11752 };
11753
11754 function relativeTimeMr(number, withoutSuffix, string, isFuture)
11755 {
11756 var output = '';
11757 if (withoutSuffix) {
11758 switch (string) {
11759 case 's': output = 'काही सेकंद'; break;
11760 case 'ss': output = '%d सेकंद'; break;
11761 case 'm': output = 'à¤à¤• मिनिट'; break;
11762 case 'mm': output = '%d मिनिटे'; break;
11763 case 'h': output = 'à¤à¤• तास'; break;
11764 case 'hh': output = '%d तास'; break;
11765 case 'd': output = 'à¤à¤• दिवस'; break;
11766 case 'dd': output = '%d दिवस'; break;
11767 case 'M': output = 'à¤à¤• महिना'; break;
11768 case 'MM': output = '%d महिने'; break;
11769 case 'y': output = 'à¤à¤• वरà¥à¤·'; break;
11770 case 'yy': output = '%d वरà¥à¤·à¥‡'; break;
11771 }
11772 }
11773 else {
11774 switch (string) {
11775 case 's': output = 'काही सेकंदां'; break;
11776 case 'ss': output = '%d सेकंदां'; break;
11777 case 'm': output = 'à¤à¤•à¤¾ मिनिटा'; break;
11778 case 'mm': output = '%d मिनिटां'; break;
11779 case 'h': output = 'à¤à¤•à¤¾ तासा'; break;
11780 case 'hh': output = '%d तासां'; break;
11781 case 'd': output = 'à¤à¤•à¤¾ दिवसा'; break;
11782 case 'dd': output = '%d दिवसां'; break;
11783 case 'M': output = 'à¤à¤•à¤¾ महिनà¥à¤¯à¤¾'; break;
11784 case 'MM': output = '%d महिनà¥à¤¯à¤¾à¤‚'; break;
11785 case 'y': output = 'à¤à¤•à¤¾ वरà¥à¤·à¤¾'; break;
11786 case 'yy': output = '%d वरà¥à¤·à¤¾à¤‚'; break;
11787 }
11788 }
11789 return output.replace(/%d/i, number);
11790 }
11791
11792 var mr = moment.defineLocale('mr', {
11793 months : 'जानेवारी_फेबà¥à¤°à¥à¤µà¤¾à¤°à¥€_मारà¥à¤š_à¤à¤ªà¥à¤°à¤¿à¤²_मे_जून_जà¥à¤²à¥ˆ_ऑगसà¥à¤Ÿ_सपà¥à¤Ÿà¥‡à¤‚बर_ऑकà¥à¤Ÿà¥‹à¤¬à¤°_नोवà¥à¤¹à¥‡à¤‚बर_डिसेंबर'.split('_'),
11794 monthsShort: 'जाने._फेबà¥à¤°à¥._मारà¥à¤š._à¤à¤ªà¥à¤°à¤¿._मे._जून._जà¥à¤²à¥ˆ._ऑग._सपà¥à¤Ÿà¥‡à¤‚._ऑकà¥à¤Ÿà¥‹._नोवà¥à¤¹à¥‡à¤‚._डिसें.'.split('_'),
11795 monthsParseExact : true,
11796 weekdays : 'रविवार_सोमवार_मंगळवार_बà¥à¤§à¤µà¤¾à¤°_गà¥à¤°à¥‚वार_शà¥à¤•à¥à¤°à¤µà¤¾à¤°_शनिवार'.split('_'),
11797 weekdaysShort : 'रवि_सोम_मंगळ_बà¥à¤§_गà¥à¤°à¥‚_शà¥à¤•à¥à¤°_शनि'.split('_'),
11798 weekdaysMin : 'र_सो_मं_बà¥_गà¥_शà¥_श'.split('_'),
11799 longDateFormat : {
11800 LT : 'A h:mm वाजता',
11801 LTS : 'A h:mm:ss वाजता',
11802 L : 'DD/MM/YYYY',
11803 LL : 'D MMMM YYYY',
11804 LLL : 'D MMMM YYYY, A h:mm वाजता',
11805 LLLL : 'dddd, D MMMM YYYY, A h:mm वाजता'
11806 },
11807 calendar : {
11808 sameDay : '[आज] LT',
11809 nextDay : '[उदà¥à¤¯à¤¾] LT',
11810 nextWeek : 'dddd, LT',
11811 lastDay : '[काल] LT',
11812 lastWeek: '[मागील] dddd, LT',
11813 sameElse : 'L'
11814 },
11815 relativeTime : {
11816 future: '%sमधà¥à¤¯à¥‡',
11817 past: '%sपूरà¥à¤µà¥€',
11818 s: relativeTimeMr,
11819 ss: relativeTimeMr,
11820 m: relativeTimeMr,
11821 mm: relativeTimeMr,
11822 h: relativeTimeMr,
11823 hh: relativeTimeMr,
11824 d: relativeTimeMr,
11825 dd: relativeTimeMr,
11826 M: relativeTimeMr,
11827 MM: relativeTimeMr,
11828 y: relativeTimeMr,
11829 yy: relativeTimeMr
11830 },
11831 preparse: function (string) {
11832 return string.replace(/[१२३४५६à¥à¥®à¥¯à¥¦]/g, function (match) {
11833 return numberMap[match];
11834 });
11835 },
11836 postformat: function (string) {
11837 return string.replace(/\d/g, function (match) {
11838 return symbolMap[match];
11839 });
11840 },
11841 meridiemParse: /रातà¥à¤°à¥€|सकाळी|दà¥à¤ªà¤¾à¤°à¥€|सायंकाळी/,
11842 meridiemHour : function (hour, meridiem) {
11843 if (hour === 12) {
11844 hour = 0;
11845 }
11846 if (meridiem === 'रातà¥à¤°à¥€') {
11847 return hour < 4 ? hour : hour + 12;
11848 } else if (meridiem === 'सकाळी') {
11849 return hour;
11850 } else if (meridiem === 'दà¥à¤ªà¤¾à¤°à¥€') {
11851 return hour >= 10 ? hour : hour + 12;
11852 } else if (meridiem === 'सायंकाळी') {
11853 return hour + 12;
11854 }
11855 },
11856 meridiem: function (hour, minute, isLower) {
11857 if (hour < 4) {
11858 return 'रातà¥à¤°à¥€';
11859 } else if (hour < 10) {
11860 return 'सकाळी';
11861 } else if (hour < 17) {
11862 return 'दà¥à¤ªà¤¾à¤°à¥€';
11863 } else if (hour < 20) {
11864 return 'सायंकाळी';
11865 } else {
11866 return 'रातà¥à¤°à¥€';
11867 }
11868 },
11869 week : {
11870 dow : 0, // Sunday is the first day of the week.
11871 doy : 6 // The week that contains Jan 1st is the first week of the year.
11872 }
11873 });
11874
11875 return mr;
11876
11877})));
11878
11879
11880/***/ }),
11881/* 87 */
11882/***/ (function(module, exports, __webpack_require__) {
11883
11884//! moment.js locale configuration
11885
11886;(function (global, factory) {
11887 true ? factory(__webpack_require__(0)) :
11888 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11889 factory(global.moment)
11890}(this, (function (moment) { 'use strict';
11891
11892
11893 var msMy = moment.defineLocale('ms-my', {
11894 months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
11895 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
11896 weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
11897 weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
11898 weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
11899 longDateFormat : {
11900 LT : 'HH.mm',
11901 LTS : 'HH.mm.ss',
11902 L : 'DD/MM/YYYY',
11903 LL : 'D MMMM YYYY',
11904 LLL : 'D MMMM YYYY [pukul] HH.mm',
11905 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
11906 },
11907 meridiemParse: /pagi|tengahari|petang|malam/,
11908 meridiemHour: function (hour, meridiem) {
11909 if (hour === 12) {
11910 hour = 0;
11911 }
11912 if (meridiem === 'pagi') {
11913 return hour;
11914 } else if (meridiem === 'tengahari') {
11915 return hour >= 11 ? hour : hour + 12;
11916 } else if (meridiem === 'petang' || meridiem === 'malam') {
11917 return hour + 12;
11918 }
11919 },
11920 meridiem : function (hours, minutes, isLower) {
11921 if (hours < 11) {
11922 return 'pagi';
11923 } else if (hours < 15) {
11924 return 'tengahari';
11925 } else if (hours < 19) {
11926 return 'petang';
11927 } else {
11928 return 'malam';
11929 }
11930 },
11931 calendar : {
11932 sameDay : '[Hari ini pukul] LT',
11933 nextDay : '[Esok pukul] LT',
11934 nextWeek : 'dddd [pukul] LT',
11935 lastDay : '[Kelmarin pukul] LT',
11936 lastWeek : 'dddd [lepas pukul] LT',
11937 sameElse : 'L'
11938 },
11939 relativeTime : {
11940 future : 'dalam %s',
11941 past : '%s yang lepas',
11942 s : 'beberapa saat',
11943 ss : '%d saat',
11944 m : 'seminit',
11945 mm : '%d minit',
11946 h : 'sejam',
11947 hh : '%d jam',
11948 d : 'sehari',
11949 dd : '%d hari',
11950 M : 'sebulan',
11951 MM : '%d bulan',
11952 y : 'setahun',
11953 yy : '%d tahun'
11954 },
11955 week : {
11956 dow : 1, // Monday is the first day of the week.
11957 doy : 7 // The week that contains Jan 1st is the first week of the year.
11958 }
11959 });
11960
11961 return msMy;
11962
11963})));
11964
11965
11966/***/ }),
11967/* 88 */
11968/***/ (function(module, exports, __webpack_require__) {
11969
11970//! moment.js locale configuration
11971
11972;(function (global, factory) {
11973 true ? factory(__webpack_require__(0)) :
11974 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
11975 factory(global.moment)
11976}(this, (function (moment) { 'use strict';
11977
11978
11979 var ms = moment.defineLocale('ms', {
11980 months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
11981 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
11982 weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
11983 weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
11984 weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
11985 longDateFormat : {
11986 LT : 'HH.mm',
11987 LTS : 'HH.mm.ss',
11988 L : 'DD/MM/YYYY',
11989 LL : 'D MMMM YYYY',
11990 LLL : 'D MMMM YYYY [pukul] HH.mm',
11991 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
11992 },
11993 meridiemParse: /pagi|tengahari|petang|malam/,
11994 meridiemHour: function (hour, meridiem) {
11995 if (hour === 12) {
11996 hour = 0;
11997 }
11998 if (meridiem === 'pagi') {
11999 return hour;
12000 } else if (meridiem === 'tengahari') {
12001 return hour >= 11 ? hour : hour + 12;
12002 } else if (meridiem === 'petang' || meridiem === 'malam') {
12003 return hour + 12;
12004 }
12005 },
12006 meridiem : function (hours, minutes, isLower) {
12007 if (hours < 11) {
12008 return 'pagi';
12009 } else if (hours < 15) {
12010 return 'tengahari';
12011 } else if (hours < 19) {
12012 return 'petang';
12013 } else {
12014 return 'malam';
12015 }
12016 },
12017 calendar : {
12018 sameDay : '[Hari ini pukul] LT',
12019 nextDay : '[Esok pukul] LT',
12020 nextWeek : 'dddd [pukul] LT',
12021 lastDay : '[Kelmarin pukul] LT',
12022 lastWeek : 'dddd [lepas pukul] LT',
12023 sameElse : 'L'
12024 },
12025 relativeTime : {
12026 future : 'dalam %s',
12027 past : '%s yang lepas',
12028 s : 'beberapa saat',
12029 ss : '%d saat',
12030 m : 'seminit',
12031 mm : '%d minit',
12032 h : 'sejam',
12033 hh : '%d jam',
12034 d : 'sehari',
12035 dd : '%d hari',
12036 M : 'sebulan',
12037 MM : '%d bulan',
12038 y : 'setahun',
12039 yy : '%d tahun'
12040 },
12041 week : {
12042 dow : 1, // Monday is the first day of the week.
12043 doy : 7 // The week that contains Jan 1st is the first week of the year.
12044 }
12045 });
12046
12047 return ms;
12048
12049})));
12050
12051
12052/***/ }),
12053/* 89 */
12054/***/ (function(module, exports, __webpack_require__) {
12055
12056//! moment.js locale configuration
12057
12058;(function (global, factory) {
12059 true ? factory(__webpack_require__(0)) :
12060 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12061 factory(global.moment)
12062}(this, (function (moment) { 'use strict';
12063
12064
12065 var mt = moment.defineLocale('mt', {
12066 months : 'Jannar_Frar_Marzu_April_Mejju_Ä unju_Lulju_Awwissu_Settembru_Ottubru_Novembru_DiÄ‹embru'.split('_'),
12067 monthsShort : 'Jan_Fra_Mar_Apr_Mej_Ä un_Lul_Aww_Set_Ott_Nov_DiÄ‹'.split('_'),
12068 weekdays : 'Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ä imgħa_Is-Sibt'.split('_'),
12069 weekdaysShort : 'Ħad_Tne_Tli_Erb_Ħam_Ä im_Sib'.split('_'),
12070 weekdaysMin : 'Ħa_Tn_Tl_Er_Ħa_Ä i_Si'.split('_'),
12071 longDateFormat : {
12072 LT : 'HH:mm',
12073 LTS : 'HH:mm:ss',
12074 L : 'DD/MM/YYYY',
12075 LL : 'D MMMM YYYY',
12076 LLL : 'D MMMM YYYY HH:mm',
12077 LLLL : 'dddd, D MMMM YYYY HH:mm'
12078 },
12079 calendar : {
12080 sameDay : '[Illum fil-]LT',
12081 nextDay : '[Għada fil-]LT',
12082 nextWeek : 'dddd [fil-]LT',
12083 lastDay : '[Il-bieraħ fil-]LT',
12084 lastWeek : 'dddd [li għadda] [fil-]LT',
12085 sameElse : 'L'
12086 },
12087 relativeTime : {
12088 future : 'f’ %s',
12089 past : '%s ilu',
12090 s : 'ftit sekondi',
12091 ss : '%d sekondi',
12092 m : 'minuta',
12093 mm : '%d minuti',
12094 h : 'siegħa',
12095 hh : '%d siegħat',
12096 d : 'Ä¡urnata',
12097 dd : '%d Ä¡ranet',
12098 M : 'xahar',
12099 MM : '%d xhur',
12100 y : 'sena',
12101 yy : '%d sni'
12102 },
12103 dayOfMonthOrdinalParse : /\d{1,2}º/,
12104 ordinal: '%dº',
12105 week : {
12106 dow : 1, // Monday is the first day of the week.
12107 doy : 4 // The week that contains Jan 4th is the first week of the year.
12108 }
12109 });
12110
12111 return mt;
12112
12113})));
12114
12115
12116/***/ }),
12117/* 90 */
12118/***/ (function(module, exports, __webpack_require__) {
12119
12120//! moment.js locale configuration
12121
12122;(function (global, factory) {
12123 true ? factory(__webpack_require__(0)) :
12124 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12125 factory(global.moment)
12126}(this, (function (moment) { 'use strict';
12127
12128
12129 var symbolMap = {
12130 '1': 'á',
12131 '2': 'á‚',
12132 '3': 'áƒ',
12133 '4': 'á„',
12134 '5': 'á…',
12135 '6': 'á†',
12136 '7': 'á‡',
12137 '8': 'áˆ',
12138 '9': 'á‰',
12139 '0': 'á€'
12140 }, numberMap = {
12141 'á': '1',
12142 'á‚': '2',
12143 'áƒ': '3',
12144 'á„': '4',
12145 'á…': '5',
12146 'á†': '6',
12147 'á‡': '7',
12148 'áˆ': '8',
12149 'á‰': '9',
12150 'á€': '0'
12151 };
12152
12153 var my = moment.defineLocale('my', {
12154 months: 'ဇန်နá€á€«á€›á€®_ဖေဖော်á€á€«á€›á€®_မá€á€º_ဧပြီ_မေ_ဇွန်_ဇူလá€á€¯á€„်_သြဂုá€á€º_စက်á€á€„်ဘာ_အောက်á€á€á€¯á€˜á€¬_နá€á€¯á€á€„်ဘာ_ဒီဇင်ဘာ'.split('_'),
12155 monthsShort: 'ဇန်_ဖေ_မá€á€º_ပြီ_မေ_ဇွန်_လá€á€¯á€„်_သြ_စက်_အောက်_နá€á€¯_ဒီ'.split('_'),
12156 weekdays: 'á€á€”င်္ဂနွေ_á€á€”င်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပá€á€±á€¸_သောကြာ_စနေ'.split('_'),
12157 weekdaysShort: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
12158 weekdaysMin: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
12159
12160 longDateFormat: {
12161 LT: 'HH:mm',
12162 LTS: 'HH:mm:ss',
12163 L: 'DD/MM/YYYY',
12164 LL: 'D MMMM YYYY',
12165 LLL: 'D MMMM YYYY HH:mm',
12166 LLLL: 'dddd D MMMM YYYY HH:mm'
12167 },
12168 calendar: {
12169 sameDay: '[ယနေ.] LT [မှာ]',
12170 nextDay: '[မနက်ဖြန်] LT [မှာ]',
12171 nextWeek: 'dddd LT [မှာ]',
12172 lastDay: '[မနေ.က] LT [မှာ]',
12173 lastWeek: '[ပြီးá€á€²á€·á€žá€±á€¬] dddd LT [မှာ]',
12174 sameElse: 'L'
12175 },
12176 relativeTime: {
12177 future: 'လာမည့် %s မှာ',
12178 past: 'လွန်á€á€²á€·á€žá€±á€¬ %s က',
12179 s: 'စက္ကန်.အနည်းငယ်',
12180 ss : '%d စက္ကန့်',
12181 m: 'á€á€…်မá€á€”စ်',
12182 mm: '%d မá€á€”စ်',
12183 h: 'á€á€…်နာရီ',
12184 hh: '%d နာရီ',
12185 d: 'á€á€…်ရက်',
12186 dd: '%d ရက်',
12187 M: 'á€á€…်လ',
12188 MM: '%d လ',
12189 y: 'á€á€…်နှစ်',
12190 yy: '%d နှစ်'
12191 },
12192 preparse: function (string) {
12193 return string.replace(/[áá‚áƒá„á…á†á‡áˆá‰á€]/g, function (match) {
12194 return numberMap[match];
12195 });
12196 },
12197 postformat: function (string) {
12198 return string.replace(/\d/g, function (match) {
12199 return symbolMap[match];
12200 });
12201 },
12202 week: {
12203 dow: 1, // Monday is the first day of the week.
12204 doy: 4 // The week that contains Jan 1st is the first week of the year.
12205 }
12206 });
12207
12208 return my;
12209
12210})));
12211
12212
12213/***/ }),
12214/* 91 */
12215/***/ (function(module, exports, __webpack_require__) {
12216
12217//! moment.js locale configuration
12218
12219;(function (global, factory) {
12220 true ? factory(__webpack_require__(0)) :
12221 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12222 factory(global.moment)
12223}(this, (function (moment) { 'use strict';
12224
12225
12226 var nb = moment.defineLocale('nb', {
12227 months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
12228 monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
12229 monthsParseExact : true,
12230 weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
12231 weekdaysShort : 'sø._ma._ti._on._to._fr._lø.'.split('_'),
12232 weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
12233 weekdaysParseExact : true,
12234 longDateFormat : {
12235 LT : 'HH:mm',
12236 LTS : 'HH:mm:ss',
12237 L : 'DD.MM.YYYY',
12238 LL : 'D. MMMM YYYY',
12239 LLL : 'D. MMMM YYYY [kl.] HH:mm',
12240 LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
12241 },
12242 calendar : {
12243 sameDay: '[i dag kl.] LT',
12244 nextDay: '[i morgen kl.] LT',
12245 nextWeek: 'dddd [kl.] LT',
12246 lastDay: '[i går kl.] LT',
12247 lastWeek: '[forrige] dddd [kl.] LT',
12248 sameElse: 'L'
12249 },
12250 relativeTime : {
12251 future : 'om %s',
12252 past : '%s siden',
12253 s : 'noen sekunder',
12254 ss : '%d sekunder',
12255 m : 'ett minutt',
12256 mm : '%d minutter',
12257 h : 'en time',
12258 hh : '%d timer',
12259 d : 'en dag',
12260 dd : '%d dager',
12261 M : 'en måned',
12262 MM : '%d måneder',
12263 y : 'ett år',
12264 yy : '%d år'
12265 },
12266 dayOfMonthOrdinalParse: /\d{1,2}\./,
12267 ordinal : '%d.',
12268 week : {
12269 dow : 1, // Monday is the first day of the week.
12270 doy : 4 // The week that contains Jan 4th is the first week of the year.
12271 }
12272 });
12273
12274 return nb;
12275
12276})));
12277
12278
12279/***/ }),
12280/* 92 */
12281/***/ (function(module, exports, __webpack_require__) {
12282
12283//! moment.js locale configuration
12284
12285;(function (global, factory) {
12286 true ? factory(__webpack_require__(0)) :
12287 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12288 factory(global.moment)
12289}(this, (function (moment) { 'use strict';
12290
12291
12292 var symbolMap = {
12293 '1': '१',
12294 '2': '२',
12295 '3': '३',
12296 '4': '४',
12297 '5': '५',
12298 '6': '६',
12299 '7': 'à¥',
12300 '8': '८',
12301 '9': '९',
12302 '0': '०'
12303 },
12304 numberMap = {
12305 '१': '1',
12306 '२': '2',
12307 '३': '3',
12308 '४': '4',
12309 '५': '5',
12310 '६': '6',
12311 'à¥': '7',
12312 '८': '8',
12313 '९': '9',
12314 '०': '0'
12315 };
12316
12317 var ne = moment.defineLocale('ne', {
12318 months : 'जनवरी_फेबà¥à¤°à¥à¤µà¤°à¥€_मारà¥à¤š_अपà¥à¤°à¤¿à¤²_मई_जà¥à¤¨_जà¥à¤²à¤¾à¤ˆ_अगषà¥à¤Ÿ_सेपà¥à¤Ÿà¥‡à¤®à¥à¤¬à¤°_अकà¥à¤Ÿà¥‹à¤¬à¤°_नोà¤à¥‡à¤®à¥à¤¬à¤°_डिसेमà¥à¤¬à¤°'.split('_'),
12319 monthsShort : 'जन._फेबà¥à¤°à¥._मारà¥à¤š_अपà¥à¤°à¤¿._मई_जà¥à¤¨_जà¥à¤²à¤¾à¤ˆ._अग._सेपà¥à¤Ÿ._अकà¥à¤Ÿà¥‹._नोà¤à¥‡._डिसे.'.split('_'),
12320 monthsParseExact : true,
12321 weekdays : 'आइतबार_सोमबार_मङà¥à¤—लबार_बà¥à¤§à¤¬à¤¾à¤°_बिहिबार_शà¥à¤•à¥à¤°à¤¬à¤¾à¤°_शनिबार'.split('_'),
12322 weekdaysShort : 'आइत._सोम._मङà¥à¤—ल._बà¥à¤§._बिहि._शà¥à¤•à¥à¤°._शनि.'.split('_'),
12323 weekdaysMin : 'आ._सो._मं._बà¥._बि._शà¥._श.'.split('_'),
12324 weekdaysParseExact : true,
12325 longDateFormat : {
12326 LT : 'Aको h:mm बजे',
12327 LTS : 'Aको h:mm:ss बजे',
12328 L : 'DD/MM/YYYY',
12329 LL : 'D MMMM YYYY',
12330 LLL : 'D MMMM YYYY, Aको h:mm बजे',
12331 LLLL : 'dddd, D MMMM YYYY, Aको h:mm बजे'
12332 },
12333 preparse: function (string) {
12334 return string.replace(/[१२३४५६à¥à¥®à¥¯à¥¦]/g, function (match) {
12335 return numberMap[match];
12336 });
12337 },
12338 postformat: function (string) {
12339 return string.replace(/\d/g, function (match) {
12340 return symbolMap[match];
12341 });
12342 },
12343 meridiemParse: /राति|बिहान|दिउà¤à¤¸à¥‹|साà¤à¤/,
12344 meridiemHour : function (hour, meridiem) {
12345 if (hour === 12) {
12346 hour = 0;
12347 }
12348 if (meridiem === 'राति') {
12349 return hour < 4 ? hour : hour + 12;
12350 } else if (meridiem === 'बिहान') {
12351 return hour;
12352 } else if (meridiem === 'दिउà¤à¤¸à¥‹') {
12353 return hour >= 10 ? hour : hour + 12;
12354 } else if (meridiem === 'साà¤à¤') {
12355 return hour + 12;
12356 }
12357 },
12358 meridiem : function (hour, minute, isLower) {
12359 if (hour < 3) {
12360 return 'राति';
12361 } else if (hour < 12) {
12362 return 'बिहान';
12363 } else if (hour < 16) {
12364 return 'दिउà¤à¤¸à¥‹';
12365 } else if (hour < 20) {
12366 return 'साà¤à¤';
12367 } else {
12368 return 'राति';
12369 }
12370 },
12371 calendar : {
12372 sameDay : '[आज] LT',
12373 nextDay : '[à¤à¥‹à¤²à¤¿] LT',
12374 nextWeek : '[आउà¤à¤¦à¥‹] dddd[,] LT',
12375 lastDay : '[हिजो] LT',
12376 lastWeek : '[गà¤à¤•à¥‹] dddd[,] LT',
12377 sameElse : 'L'
12378 },
12379 relativeTime : {
12380 future : '%sमा',
12381 past : '%s अगाडि',
12382 s : 'केही कà¥à¤·à¤£',
12383 ss : '%d सेकेणà¥à¤¡',
12384 m : 'à¤à¤• मिनेट',
12385 mm : '%d मिनेट',
12386 h : 'à¤à¤• घणà¥à¤Ÿà¤¾',
12387 hh : '%d घणà¥à¤Ÿà¤¾',
12388 d : 'à¤à¤• दिन',
12389 dd : '%d दिन',
12390 M : 'à¤à¤• महिना',
12391 MM : '%d महिना',
12392 y : 'à¤à¤• बरà¥à¤·',
12393 yy : '%d बरà¥à¤·'
12394 },
12395 week : {
12396 dow : 0, // Sunday is the first day of the week.
12397 doy : 6 // The week that contains Jan 1st is the first week of the year.
12398 }
12399 });
12400
12401 return ne;
12402
12403})));
12404
12405
12406/***/ }),
12407/* 93 */
12408/***/ (function(module, exports, __webpack_require__) {
12409
12410//! moment.js locale configuration
12411
12412;(function (global, factory) {
12413 true ? factory(__webpack_require__(0)) :
12414 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12415 factory(global.moment)
12416}(this, (function (moment) { 'use strict';
12417
12418
12419 var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
12420 monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
12421
12422 var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
12423 var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
12424
12425 var nlBe = moment.defineLocale('nl-be', {
12426 months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
12427 monthsShort : function (m, format) {
12428 if (!m) {
12429 return monthsShortWithDots;
12430 } else if (/-MMM-/.test(format)) {
12431 return monthsShortWithoutDots[m.month()];
12432 } else {
12433 return monthsShortWithDots[m.month()];
12434 }
12435 },
12436
12437 monthsRegex: monthsRegex,
12438 monthsShortRegex: monthsRegex,
12439 monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
12440 monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
12441
12442 monthsParse : monthsParse,
12443 longMonthsParse : monthsParse,
12444 shortMonthsParse : monthsParse,
12445
12446 weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
12447 weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
12448 weekdaysMin : 'zo_ma_di_wo_do_vr_za'.split('_'),
12449 weekdaysParseExact : true,
12450 longDateFormat : {
12451 LT : 'HH:mm',
12452 LTS : 'HH:mm:ss',
12453 L : 'DD/MM/YYYY',
12454 LL : 'D MMMM YYYY',
12455 LLL : 'D MMMM YYYY HH:mm',
12456 LLLL : 'dddd D MMMM YYYY HH:mm'
12457 },
12458 calendar : {
12459 sameDay: '[vandaag om] LT',
12460 nextDay: '[morgen om] LT',
12461 nextWeek: 'dddd [om] LT',
12462 lastDay: '[gisteren om] LT',
12463 lastWeek: '[afgelopen] dddd [om] LT',
12464 sameElse: 'L'
12465 },
12466 relativeTime : {
12467 future : 'over %s',
12468 past : '%s geleden',
12469 s : 'een paar seconden',
12470 ss : '%d seconden',
12471 m : 'één minuut',
12472 mm : '%d minuten',
12473 h : 'één uur',
12474 hh : '%d uur',
12475 d : 'één dag',
12476 dd : '%d dagen',
12477 M : 'één maand',
12478 MM : '%d maanden',
12479 y : 'één jaar',
12480 yy : '%d jaar'
12481 },
12482 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
12483 ordinal : function (number) {
12484 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
12485 },
12486 week : {
12487 dow : 1, // Monday is the first day of the week.
12488 doy : 4 // The week that contains Jan 4th is the first week of the year.
12489 }
12490 });
12491
12492 return nlBe;
12493
12494})));
12495
12496
12497/***/ }),
12498/* 94 */
12499/***/ (function(module, exports, __webpack_require__) {
12500
12501//! moment.js locale configuration
12502
12503;(function (global, factory) {
12504 true ? factory(__webpack_require__(0)) :
12505 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12506 factory(global.moment)
12507}(this, (function (moment) { 'use strict';
12508
12509
12510 var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
12511 monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
12512
12513 var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
12514 var monthsRegex = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
12515
12516 var nl = moment.defineLocale('nl', {
12517 months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
12518 monthsShort : function (m, format) {
12519 if (!m) {
12520 return monthsShortWithDots;
12521 } else if (/-MMM-/.test(format)) {
12522 return monthsShortWithoutDots[m.month()];
12523 } else {
12524 return monthsShortWithDots[m.month()];
12525 }
12526 },
12527
12528 monthsRegex: monthsRegex,
12529 monthsShortRegex: monthsRegex,
12530 monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
12531 monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
12532
12533 monthsParse : monthsParse,
12534 longMonthsParse : monthsParse,
12535 shortMonthsParse : monthsParse,
12536
12537 weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
12538 weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
12539 weekdaysMin : 'zo_ma_di_wo_do_vr_za'.split('_'),
12540 weekdaysParseExact : true,
12541 longDateFormat : {
12542 LT : 'HH:mm',
12543 LTS : 'HH:mm:ss',
12544 L : 'DD-MM-YYYY',
12545 LL : 'D MMMM YYYY',
12546 LLL : 'D MMMM YYYY HH:mm',
12547 LLLL : 'dddd D MMMM YYYY HH:mm'
12548 },
12549 calendar : {
12550 sameDay: '[vandaag om] LT',
12551 nextDay: '[morgen om] LT',
12552 nextWeek: 'dddd [om] LT',
12553 lastDay: '[gisteren om] LT',
12554 lastWeek: '[afgelopen] dddd [om] LT',
12555 sameElse: 'L'
12556 },
12557 relativeTime : {
12558 future : 'over %s',
12559 past : '%s geleden',
12560 s : 'een paar seconden',
12561 ss : '%d seconden',
12562 m : 'één minuut',
12563 mm : '%d minuten',
12564 h : 'één uur',
12565 hh : '%d uur',
12566 d : 'één dag',
12567 dd : '%d dagen',
12568 M : 'één maand',
12569 MM : '%d maanden',
12570 y : 'één jaar',
12571 yy : '%d jaar'
12572 },
12573 dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
12574 ordinal : function (number) {
12575 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
12576 },
12577 week : {
12578 dow : 1, // Monday is the first day of the week.
12579 doy : 4 // The week that contains Jan 4th is the first week of the year.
12580 }
12581 });
12582
12583 return nl;
12584
12585})));
12586
12587
12588/***/ }),
12589/* 95 */
12590/***/ (function(module, exports, __webpack_require__) {
12591
12592//! moment.js locale configuration
12593
12594;(function (global, factory) {
12595 true ? factory(__webpack_require__(0)) :
12596 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12597 factory(global.moment)
12598}(this, (function (moment) { 'use strict';
12599
12600
12601 var nn = moment.defineLocale('nn', {
12602 months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
12603 monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
12604 weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
12605 weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
12606 weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),
12607 longDateFormat : {
12608 LT : 'HH:mm',
12609 LTS : 'HH:mm:ss',
12610 L : 'DD.MM.YYYY',
12611 LL : 'D. MMMM YYYY',
12612 LLL : 'D. MMMM YYYY [kl.] H:mm',
12613 LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
12614 },
12615 calendar : {
12616 sameDay: '[I dag klokka] LT',
12617 nextDay: '[I morgon klokka] LT',
12618 nextWeek: 'dddd [klokka] LT',
12619 lastDay: '[I går klokka] LT',
12620 lastWeek: '[Føregåande] dddd [klokka] LT',
12621 sameElse: 'L'
12622 },
12623 relativeTime : {
12624 future : 'om %s',
12625 past : '%s sidan',
12626 s : 'nokre sekund',
12627 ss : '%d sekund',
12628 m : 'eit minutt',
12629 mm : '%d minutt',
12630 h : 'ein time',
12631 hh : '%d timar',
12632 d : 'ein dag',
12633 dd : '%d dagar',
12634 M : 'ein månad',
12635 MM : '%d månader',
12636 y : 'eit år',
12637 yy : '%d år'
12638 },
12639 dayOfMonthOrdinalParse: /\d{1,2}\./,
12640 ordinal : '%d.',
12641 week : {
12642 dow : 1, // Monday is the first day of the week.
12643 doy : 4 // The week that contains Jan 4th is the first week of the year.
12644 }
12645 });
12646
12647 return nn;
12648
12649})));
12650
12651
12652/***/ }),
12653/* 96 */
12654/***/ (function(module, exports, __webpack_require__) {
12655
12656//! moment.js locale configuration
12657
12658;(function (global, factory) {
12659 true ? factory(__webpack_require__(0)) :
12660 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12661 factory(global.moment)
12662}(this, (function (moment) { 'use strict';
12663
12664
12665 var symbolMap = {
12666 '1': '੧',
12667 '2': '੨',
12668 '3': 'à©©',
12669 '4': '੪',
12670 '5': 'à©«',
12671 '6': '੬',
12672 '7': 'à©',
12673 '8': 'à©®',
12674 '9': '੯',
12675 '0': '੦'
12676 },
12677 numberMap = {
12678 '੧': '1',
12679 '੨': '2',
12680 'à©©': '3',
12681 '੪': '4',
12682 'à©«': '5',
12683 '੬': '6',
12684 'à©': '7',
12685 'à©®': '8',
12686 '੯': '9',
12687 '੦': '0'
12688 };
12689
12690 var paIn = moment.defineLocale('pa-in', {
12691 // There are months name as per Nanakshahi Calender but they are not used as rigidly in modern Punjabi.
12692 months : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪà©à¨°à©ˆà¨²_ਮਈ_ਜੂਨ_ਜà©à¨²à¨¾à¨ˆ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
12693 monthsShort : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪà©à¨°à©ˆà¨²_ਮਈ_ਜੂਨ_ਜà©à¨²à¨¾à¨ˆ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
12694 weekdays : 'à¨à¨¤à¨µà¨¾à¨°_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬà©à¨§à¨µà¨¾à¨°_ਵੀਰਵਾਰ_ਸ਼à©à©±à¨•à¨°à¨µà¨¾à¨°_ਸ਼ਨੀਚਰਵਾਰ'.split('_'),
12695 weekdaysShort : 'à¨à¨¤_ਸੋਮ_ਮੰਗਲ_ਬà©à¨§_ਵੀਰ_ਸ਼à©à¨•à¨°_ਸ਼ਨੀ'.split('_'),
12696 weekdaysMin : 'à¨à¨¤_ਸੋਮ_ਮੰਗਲ_ਬà©à¨§_ਵੀਰ_ਸ਼à©à¨•à¨°_ਸ਼ਨੀ'.split('_'),
12697 longDateFormat : {
12698 LT : 'A h:mm ਵਜੇ',
12699 LTS : 'A h:mm:ss ਵਜੇ',
12700 L : 'DD/MM/YYYY',
12701 LL : 'D MMMM YYYY',
12702 LLL : 'D MMMM YYYY, A h:mm ਵਜੇ',
12703 LLLL : 'dddd, D MMMM YYYY, A h:mm ਵਜੇ'
12704 },
12705 calendar : {
12706 sameDay : '[ਅਜ] LT',
12707 nextDay : '[ਕਲ] LT',
12708 nextWeek : '[ਅਗਲਾ] dddd, LT',
12709 lastDay : '[ਕਲ] LT',
12710 lastWeek : '[ਪਿਛਲੇ] dddd, LT',
12711 sameElse : 'L'
12712 },
12713 relativeTime : {
12714 future : '%s ਵਿੱਚ',
12715 past : '%s ਪਿਛਲੇ',
12716 s : 'ਕà©à¨ ਸਕਿੰਟ',
12717 ss : '%d ਸਕਿੰਟ',
12718 m : 'ਇਕ ਮਿੰਟ',
12719 mm : '%d ਮਿੰਟ',
12720 h : 'ਇੱਕ ਘੰਟਾ',
12721 hh : '%d ਘੰਟੇ',
12722 d : 'ਇੱਕ ਦਿਨ',
12723 dd : '%d ਦਿਨ',
12724 M : 'ਇੱਕ ਮਹੀਨਾ',
12725 MM : '%d ਮਹੀਨੇ',
12726 y : 'ਇੱਕ ਸਾਲ',
12727 yy : '%d ਸਾਲ'
12728 },
12729 preparse: function (string) {
12730 return string.replace(/[੧੨੩੪੫੬à©à©®à©¯à©¦]/g, function (match) {
12731 return numberMap[match];
12732 });
12733 },
12734 postformat: function (string) {
12735 return string.replace(/\d/g, function (match) {
12736 return symbolMap[match];
12737 });
12738 },
12739 // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
12740 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
12741 meridiemParse: /ਰਾਤ|ਸਵੇਰ|ਦà©à¨ªà¨¹à¨¿à¨°|ਸ਼ਾਮ/,
12742 meridiemHour : function (hour, meridiem) {
12743 if (hour === 12) {
12744 hour = 0;
12745 }
12746 if (meridiem === 'ਰਾਤ') {
12747 return hour < 4 ? hour : hour + 12;
12748 } else if (meridiem === 'ਸਵੇਰ') {
12749 return hour;
12750 } else if (meridiem === 'ਦà©à¨ªà¨¹à¨¿à¨°') {
12751 return hour >= 10 ? hour : hour + 12;
12752 } else if (meridiem === 'ਸ਼ਾਮ') {
12753 return hour + 12;
12754 }
12755 },
12756 meridiem : function (hour, minute, isLower) {
12757 if (hour < 4) {
12758 return 'ਰਾਤ';
12759 } else if (hour < 10) {
12760 return 'ਸਵੇਰ';
12761 } else if (hour < 17) {
12762 return 'ਦà©à¨ªà¨¹à¨¿à¨°';
12763 } else if (hour < 20) {
12764 return 'ਸ਼ਾਮ';
12765 } else {
12766 return 'ਰਾਤ';
12767 }
12768 },
12769 week : {
12770 dow : 0, // Sunday is the first day of the week.
12771 doy : 6 // The week that contains Jan 1st is the first week of the year.
12772 }
12773 });
12774
12775 return paIn;
12776
12777})));
12778
12779
12780/***/ }),
12781/* 97 */
12782/***/ (function(module, exports, __webpack_require__) {
12783
12784//! moment.js locale configuration
12785
12786;(function (global, factory) {
12787 true ? factory(__webpack_require__(0)) :
12788 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12789 factory(global.moment)
12790}(this, (function (moment) { 'use strict';
12791
12792
12793 var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'),
12794 monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');
12795 function plural(n) {
12796 return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);
12797 }
12798 function translate(number, withoutSuffix, key) {
12799 var result = number + ' ';
12800 switch (key) {
12801 case 'ss':
12802 return result + (plural(number) ? 'sekundy' : 'sekund');
12803 case 'm':
12804 return withoutSuffix ? 'minuta' : 'minutÄ™';
12805 case 'mm':
12806 return result + (plural(number) ? 'minuty' : 'minut');
12807 case 'h':
12808 return withoutSuffix ? 'godzina' : 'godzinÄ™';
12809 case 'hh':
12810 return result + (plural(number) ? 'godziny' : 'godzin');
12811 case 'MM':
12812 return result + (plural(number) ? 'miesiące' : 'miesięcy');
12813 case 'yy':
12814 return result + (plural(number) ? 'lata' : 'lat');
12815 }
12816 }
12817
12818 var pl = moment.defineLocale('pl', {
12819 months : function (momentToFormat, format) {
12820 if (!momentToFormat) {
12821 return monthsNominative;
12822 } else if (format === '') {
12823 // Hack: if format empty we know this is used to generate
12824 // RegExp by moment. Give then back both valid forms of months
12825 // in RegExp ready format.
12826 return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')';
12827 } else if (/D MMMM/.test(format)) {
12828 return monthsSubjective[momentToFormat.month()];
12829 } else {
12830 return monthsNominative[momentToFormat.month()];
12831 }
12832 },
12833 monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
12834 weekdays : 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
12835 weekdaysShort : 'ndz_pon_wt_śr_czw_pt_sob'.split('_'),
12836 weekdaysMin : 'Nd_Pn_Wt_Åšr_Cz_Pt_So'.split('_'),
12837 longDateFormat : {
12838 LT : 'HH:mm',
12839 LTS : 'HH:mm:ss',
12840 L : 'DD.MM.YYYY',
12841 LL : 'D MMMM YYYY',
12842 LLL : 'D MMMM YYYY HH:mm',
12843 LLLL : 'dddd, D MMMM YYYY HH:mm'
12844 },
12845 calendar : {
12846 sameDay: '[DziÅ› o] LT',
12847 nextDay: '[Jutro o] LT',
12848 nextWeek: function () {
12849 switch (this.day()) {
12850 case 0:
12851 return '[W niedzielÄ™ o] LT';
12852
12853 case 2:
12854 return '[We wtorek o] LT';
12855
12856 case 3:
12857 return '[W środę o] LT';
12858
12859 case 6:
12860 return '[W sobotÄ™ o] LT';
12861
12862 default:
12863 return '[W] dddd [o] LT';
12864 }
12865 },
12866 lastDay: '[Wczoraj o] LT',
12867 lastWeek: function () {
12868 switch (this.day()) {
12869 case 0:
12870 return '[W zeszłą niedzielę o] LT';
12871 case 3:
12872 return '[W zeszłą środę o] LT';
12873 case 6:
12874 return '[W zeszłą sobotę o] LT';
12875 default:
12876 return '[W zeszły] dddd [o] LT';
12877 }
12878 },
12879 sameElse: 'L'
12880 },
12881 relativeTime : {
12882 future : 'za %s',
12883 past : '%s temu',
12884 s : 'kilka sekund',
12885 ss : translate,
12886 m : translate,
12887 mm : translate,
12888 h : translate,
12889 hh : translate,
12890 d : '1 dzień',
12891 dd : '%d dni',
12892 M : 'miesiÄ…c',
12893 MM : translate,
12894 y : 'rok',
12895 yy : translate
12896 },
12897 dayOfMonthOrdinalParse: /\d{1,2}\./,
12898 ordinal : '%d.',
12899 week : {
12900 dow : 1, // Monday is the first day of the week.
12901 doy : 4 // The week that contains Jan 4th is the first week of the year.
12902 }
12903 });
12904
12905 return pl;
12906
12907})));
12908
12909
12910/***/ }),
12911/* 98 */
12912/***/ (function(module, exports, __webpack_require__) {
12913
12914//! moment.js locale configuration
12915
12916;(function (global, factory) {
12917 true ? factory(__webpack_require__(0)) :
12918 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12919 factory(global.moment)
12920}(this, (function (moment) { 'use strict';
12921
12922
12923 var ptBr = moment.defineLocale('pt-br', {
12924 months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
12925 monthsShort : 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
12926 weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
12927 weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
12928 weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
12929 weekdaysParseExact : true,
12930 longDateFormat : {
12931 LT : 'HH:mm',
12932 LTS : 'HH:mm:ss',
12933 L : 'DD/MM/YYYY',
12934 LL : 'D [de] MMMM [de] YYYY',
12935 LLL : 'D [de] MMMM [de] YYYY [Ã s] HH:mm',
12936 LLLL : 'dddd, D [de] MMMM [de] YYYY [Ã s] HH:mm'
12937 },
12938 calendar : {
12939 sameDay: '[Hoje à s] LT',
12940 nextDay: '[Amanhã à s] LT',
12941 nextWeek: 'dddd [Ã s] LT',
12942 lastDay: '[Ontem à s] LT',
12943 lastWeek: function () {
12944 return (this.day() === 0 || this.day() === 6) ?
12945 '[Último] dddd [à s] LT' : // Saturday + Sunday
12946 '[Última] dddd [à s] LT'; // Monday - Friday
12947 },
12948 sameElse: 'L'
12949 },
12950 relativeTime : {
12951 future : 'em %s',
12952 past : 'há %s',
12953 s : 'poucos segundos',
12954 ss : '%d segundos',
12955 m : 'um minuto',
12956 mm : '%d minutos',
12957 h : 'uma hora',
12958 hh : '%d horas',
12959 d : 'um dia',
12960 dd : '%d dias',
12961 M : 'um mês',
12962 MM : '%d meses',
12963 y : 'um ano',
12964 yy : '%d anos'
12965 },
12966 dayOfMonthOrdinalParse: /\d{1,2}º/,
12967 ordinal : '%dº'
12968 });
12969
12970 return ptBr;
12971
12972})));
12973
12974
12975/***/ }),
12976/* 99 */
12977/***/ (function(module, exports, __webpack_require__) {
12978
12979//! moment.js locale configuration
12980
12981;(function (global, factory) {
12982 true ? factory(__webpack_require__(0)) :
12983 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
12984 factory(global.moment)
12985}(this, (function (moment) { 'use strict';
12986
12987
12988 var pt = moment.defineLocale('pt', {
12989 months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
12990 monthsShort : 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
12991 weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
12992 weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
12993 weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
12994 weekdaysParseExact : true,
12995 longDateFormat : {
12996 LT : 'HH:mm',
12997 LTS : 'HH:mm:ss',
12998 L : 'DD/MM/YYYY',
12999 LL : 'D [de] MMMM [de] YYYY',
13000 LLL : 'D [de] MMMM [de] YYYY HH:mm',
13001 LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm'
13002 },
13003 calendar : {
13004 sameDay: '[Hoje à s] LT',
13005 nextDay: '[Amanhã à s] LT',
13006 nextWeek: 'dddd [Ã s] LT',
13007 lastDay: '[Ontem à s] LT',
13008 lastWeek: function () {
13009 return (this.day() === 0 || this.day() === 6) ?
13010 '[Último] dddd [à s] LT' : // Saturday + Sunday
13011 '[Última] dddd [à s] LT'; // Monday - Friday
13012 },
13013 sameElse: 'L'
13014 },
13015 relativeTime : {
13016 future : 'em %s',
13017 past : 'há %s',
13018 s : 'segundos',
13019 ss : '%d segundos',
13020 m : 'um minuto',
13021 mm : '%d minutos',
13022 h : 'uma hora',
13023 hh : '%d horas',
13024 d : 'um dia',
13025 dd : '%d dias',
13026 M : 'um mês',
13027 MM : '%d meses',
13028 y : 'um ano',
13029 yy : '%d anos'
13030 },
13031 dayOfMonthOrdinalParse: /\d{1,2}º/,
13032 ordinal : '%dº',
13033 week : {
13034 dow : 1, // Monday is the first day of the week.
13035 doy : 4 // The week that contains Jan 4th is the first week of the year.
13036 }
13037 });
13038
13039 return pt;
13040
13041})));
13042
13043
13044/***/ }),
13045/* 100 */
13046/***/ (function(module, exports, __webpack_require__) {
13047
13048//! moment.js locale configuration
13049
13050;(function (global, factory) {
13051 true ? factory(__webpack_require__(0)) :
13052 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13053 factory(global.moment)
13054}(this, (function (moment) { 'use strict';
13055
13056
13057 function relativeTimeWithPlural(number, withoutSuffix, key) {
13058 var format = {
13059 'ss': 'secunde',
13060 'mm': 'minute',
13061 'hh': 'ore',
13062 'dd': 'zile',
13063 'MM': 'luni',
13064 'yy': 'ani'
13065 },
13066 separator = ' ';
13067 if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
13068 separator = ' de ';
13069 }
13070 return number + separator + format[key];
13071 }
13072
13073 var ro = moment.defineLocale('ro', {
13074 months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
13075 monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
13076 monthsParseExact: true,
13077 weekdays : 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
13078 weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
13079 weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
13080 longDateFormat : {
13081 LT : 'H:mm',
13082 LTS : 'H:mm:ss',
13083 L : 'DD.MM.YYYY',
13084 LL : 'D MMMM YYYY',
13085 LLL : 'D MMMM YYYY H:mm',
13086 LLLL : 'dddd, D MMMM YYYY H:mm'
13087 },
13088 calendar : {
13089 sameDay: '[azi la] LT',
13090 nextDay: '[mâine la] LT',
13091 nextWeek: 'dddd [la] LT',
13092 lastDay: '[ieri la] LT',
13093 lastWeek: '[fosta] dddd [la] LT',
13094 sameElse: 'L'
13095 },
13096 relativeTime : {
13097 future : 'peste %s',
13098 past : '%s în urmă',
13099 s : 'câteva secunde',
13100 ss : relativeTimeWithPlural,
13101 m : 'un minut',
13102 mm : relativeTimeWithPlural,
13103 h : 'o oră',
13104 hh : relativeTimeWithPlural,
13105 d : 'o zi',
13106 dd : relativeTimeWithPlural,
13107 M : 'o lună',
13108 MM : relativeTimeWithPlural,
13109 y : 'un an',
13110 yy : relativeTimeWithPlural
13111 },
13112 week : {
13113 dow : 1, // Monday is the first day of the week.
13114 doy : 7 // The week that contains Jan 1st is the first week of the year.
13115 }
13116 });
13117
13118 return ro;
13119
13120})));
13121
13122
13123/***/ }),
13124/* 101 */
13125/***/ (function(module, exports, __webpack_require__) {
13126
13127//! moment.js locale configuration
13128
13129;(function (global, factory) {
13130 true ? factory(__webpack_require__(0)) :
13131 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13132 factory(global.moment)
13133}(this, (function (moment) { 'use strict';
13134
13135
13136 function plural(word, num) {
13137 var forms = word.split('_');
13138 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]);
13139 }
13140 function relativeTimeWithPlural(number, withoutSuffix, key) {
13141 var format = {
13142 'ss': withoutSuffix ? 'Ñекунда_Ñекунды_Ñекунд' : 'Ñекунду_Ñекунды_Ñекунд',
13143 'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
13144 'hh': 'чаÑ_чаÑа_чаÑов',
13145 'dd': 'день_днÑ_дней',
13146 'MM': 'меÑÑц_меÑÑца_меÑÑцев',
13147 'yy': 'год_года_лет'
13148 };
13149 if (key === 'm') {
13150 return withoutSuffix ? 'минута' : 'минуту';
13151 }
13152 else {
13153 return number + ' ' + plural(format[key], +number);
13154 }
13155 }
13156 var monthsParse = [/^Ñнв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[йÑ]/i, /^июн/i, /^июл/i, /^авг/i, /^Ñен/i, /^окт/i, /^ноÑ/i, /^дек/i];
13157
13158 // http://new.gramota.ru/spravka/rules/139-prop : § 103
13159 // Ð¡Ð¾ÐºÑ€Ð°Ñ‰ÐµÐ½Ð¸Ñ Ð¼ÐµÑÑцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637
13160 // CLDR data: http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
13161 var ru = moment.defineLocale('ru', {
13162 months : {
13163 format: 'ÑнварÑ_февралÑ_марта_апрелÑ_маÑ_июнÑ_июлÑ_авгуÑта_ÑентÑбрÑ_октÑбрÑ_ноÑбрÑ_декабрÑ'.split('_'),
13164 standalone: 'Ñнварь_февраль_март_апрель_май_июнь_июль_авгуÑÑ‚_ÑентÑбрь_октÑбрь_ноÑбрь_декабрь'.split('_')
13165 },
13166 monthsShort : {
13167 // по CLDR именно "июл." и "июн.", но какой ÑмыÑл менÑÑ‚ÑŒ букву на точку ?
13168 format: 'Ñнв._февр._мар._апр._маÑ_июнÑ_июлÑ_авг._Ñент._окт._ноÑб._дек.'.split('_'),
13169 standalone: 'Ñнв._февр._март_апр._май_июнь_июль_авг._Ñент._окт._ноÑб._дек.'.split('_')
13170 },
13171 weekdays : {
13172 standalone: 'воÑкреÑенье_понедельник_вторник_Ñреда_четверг_пÑтница_Ñуббота'.split('_'),
13173 format: 'воÑкреÑенье_понедельник_вторник_Ñреду_четверг_пÑтницу_Ñубботу'.split('_'),
13174 isFormat: /\[ ?[Вв] ?(?:прошлую|Ñледующую|Ñту)? ?\] ?dddd/
13175 },
13176 weekdaysShort : 'вÑ_пн_вт_ÑÑ€_чт_пт_Ñб'.split('_'),
13177 weekdaysMin : 'вÑ_пн_вт_ÑÑ€_чт_пт_Ñб'.split('_'),
13178 monthsParse : monthsParse,
13179 longMonthsParse : monthsParse,
13180 shortMonthsParse : monthsParse,
13181
13182 // полные Ð½Ð°Ð·Ð²Ð°Ð½Ð¸Ñ Ñ Ð¿Ð°Ð´ÐµÐ¶Ð°Ð¼Ð¸, по три буквы, Ð´Ð»Ñ Ð½ÐµÐºÐ¾Ñ‚Ð¾Ñ€Ñ‹Ñ…, по 4 буквы, ÑÐ¾ÐºÑ€Ð°Ñ‰ÐµÐ½Ð¸Ñ Ñ Ñ‚Ð¾Ñ‡ÐºÐ¾Ð¹ и без точки
13183 monthsRegex: /^(Ñнвар[ÑŒÑ]|Ñнв\.?|феврал[ÑŒÑ]|февр?\.?|марта?|мар\.?|апрел[ÑŒÑ]|апр\.?|ма[йÑ]|июн[ÑŒÑ]|июн\.?|июл[ÑŒÑ]|июл\.?|авгуÑта?|авг\.?|ÑентÑбр[ÑŒÑ]|Ñент?\.?|октÑбр[ÑŒÑ]|окт\.?|ноÑбр[ÑŒÑ]|ноÑб?\.?|декабр[ÑŒÑ]|дек\.?)/i,
13184
13185 // ÐºÐ¾Ð¿Ð¸Ñ Ð¿Ñ€ÐµÐ´Ñ‹Ð´ÑƒÑ‰ÐµÐ³Ð¾
13186 monthsShortRegex: /^(Ñнвар[ÑŒÑ]|Ñнв\.?|феврал[ÑŒÑ]|февр?\.?|марта?|мар\.?|апрел[ÑŒÑ]|апр\.?|ма[йÑ]|июн[ÑŒÑ]|июн\.?|июл[ÑŒÑ]|июл\.?|авгуÑта?|авг\.?|ÑентÑбр[ÑŒÑ]|Ñент?\.?|октÑбр[ÑŒÑ]|окт\.?|ноÑбр[ÑŒÑ]|ноÑб?\.?|декабр[ÑŒÑ]|дек\.?)/i,
13187
13188 // полные Ð½Ð°Ð·Ð²Ð°Ð½Ð¸Ñ Ñ Ð¿Ð°Ð´ÐµÐ¶Ð°Ð¼Ð¸
13189 monthsStrictRegex: /^(Ñнвар[ÑÑŒ]|феврал[ÑÑŒ]|марта?|апрел[ÑÑŒ]|ма[Ñй]|июн[ÑÑŒ]|июл[ÑÑŒ]|авгуÑта?|ÑентÑбр[ÑÑŒ]|октÑбр[ÑÑŒ]|ноÑбр[ÑÑŒ]|декабр[ÑÑŒ])/i,
13190
13191 // Выражение, которое ÑоотвеÑтвует только Ñокращённым формам
13192 monthsShortStrictRegex: /^(Ñнв\.|февр?\.|мар[Ñ‚.]|апр\.|ма[Ñй]|июн[ÑŒÑ.]|июл[ÑŒÑ.]|авг\.|Ñент?\.|окт\.|ноÑб?\.|дек\.)/i,
13193 longDateFormat : {
13194 LT : 'H:mm',
13195 LTS : 'H:mm:ss',
13196 L : 'DD.MM.YYYY',
13197 LL : 'D MMMM YYYY г.',
13198 LLL : 'D MMMM YYYY г., H:mm',
13199 LLLL : 'dddd, D MMMM YYYY г., H:mm'
13200 },
13201 calendar : {
13202 sameDay: '[СегоднÑ, в] LT',
13203 nextDay: '[Завтра, в] LT',
13204 lastDay: '[Вчера, в] LT',
13205 nextWeek: function (now) {
13206 if (now.week() !== this.week()) {
13207 switch (this.day()) {
13208 case 0:
13209 return '[Ð’ Ñледующее] dddd, [в] LT';
13210 case 1:
13211 case 2:
13212 case 4:
13213 return '[Ð’ Ñледующий] dddd, [в] LT';
13214 case 3:
13215 case 5:
13216 case 6:
13217 return '[Ð’ Ñледующую] dddd, [в] LT';
13218 }
13219 } else {
13220 if (this.day() === 2) {
13221 return '[Во] dddd, [в] LT';
13222 } else {
13223 return '[В] dddd, [в] LT';
13224 }
13225 }
13226 },
13227 lastWeek: function (now) {
13228 if (now.week() !== this.week()) {
13229 switch (this.day()) {
13230 case 0:
13231 return '[В прошлое] dddd, [в] LT';
13232 case 1:
13233 case 2:
13234 case 4:
13235 return '[В прошлый] dddd, [в] LT';
13236 case 3:
13237 case 5:
13238 case 6:
13239 return '[В прошлую] dddd, [в] LT';
13240 }
13241 } else {
13242 if (this.day() === 2) {
13243 return '[Во] dddd, [в] LT';
13244 } else {
13245 return '[В] dddd, [в] LT';
13246 }
13247 }
13248 },
13249 sameElse: 'L'
13250 },
13251 relativeTime : {
13252 future : 'через %s',
13253 past : '%s назад',
13254 s : 'неÑколько Ñекунд',
13255 ss : relativeTimeWithPlural,
13256 m : relativeTimeWithPlural,
13257 mm : relativeTimeWithPlural,
13258 h : 'чаÑ',
13259 hh : relativeTimeWithPlural,
13260 d : 'день',
13261 dd : relativeTimeWithPlural,
13262 M : 'меÑÑц',
13263 MM : relativeTimeWithPlural,
13264 y : 'год',
13265 yy : relativeTimeWithPlural
13266 },
13267 meridiemParse: /ночи|утра|днÑ|вечера/i,
13268 isPM : function (input) {
13269 return /^(днÑ|вечера)$/.test(input);
13270 },
13271 meridiem : function (hour, minute, isLower) {
13272 if (hour < 4) {
13273 return 'ночи';
13274 } else if (hour < 12) {
13275 return 'утра';
13276 } else if (hour < 17) {
13277 return 'днÑ';
13278 } else {
13279 return 'вечера';
13280 }
13281 },
13282 dayOfMonthOrdinalParse: /\d{1,2}-(й|го|Ñ)/,
13283 ordinal: function (number, period) {
13284 switch (period) {
13285 case 'M':
13286 case 'd':
13287 case 'DDD':
13288 return number + '-й';
13289 case 'D':
13290 return number + '-го';
13291 case 'w':
13292 case 'W':
13293 return number + '-Ñ';
13294 default:
13295 return number;
13296 }
13297 },
13298 week : {
13299 dow : 1, // Monday is the first day of the week.
13300 doy : 4 // The week that contains Jan 4th is the first week of the year.
13301 }
13302 });
13303
13304 return ru;
13305
13306})));
13307
13308
13309/***/ }),
13310/* 102 */
13311/***/ (function(module, exports, __webpack_require__) {
13312
13313//! moment.js locale configuration
13314
13315;(function (global, factory) {
13316 true ? factory(__webpack_require__(0)) :
13317 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13318 factory(global.moment)
13319}(this, (function (moment) { 'use strict';
13320
13321
13322 var months = [
13323 'جنوري',
13324 'Ùيبروري',
13325 'مارچ',
13326 'اپريل',
13327 'مئي',
13328 'جون',
13329 'جولاءÙ',
13330 'آگسٽ',
13331 'سيپٽمبر',
13332 'آڪٽوبر',
13333 'نومبر',
13334 'ڊسمبر'
13335 ];
13336 var days = [
13337 'آچر',
13338 'سومر',
13339 'اڱارو',
13340 'اربع',
13341 'خميس',
13342 'جمع',
13343 'ڇنڇر'
13344 ];
13345
13346 var sd = moment.defineLocale('sd', {
13347 months : months,
13348 monthsShort : months,
13349 weekdays : days,
13350 weekdaysShort : days,
13351 weekdaysMin : days,
13352 longDateFormat : {
13353 LT : 'HH:mm',
13354 LTS : 'HH:mm:ss',
13355 L : 'DD/MM/YYYY',
13356 LL : 'D MMMM YYYY',
13357 LLL : 'D MMMM YYYY HH:mm',
13358 LLLL : 'dddd، D MMMM YYYY HH:mm'
13359 },
13360 meridiemParse: /صبØ|شام/,
13361 isPM : function (input) {
13362 return 'شام' === input;
13363 },
13364 meridiem : function (hour, minute, isLower) {
13365 if (hour < 12) {
13366 return 'صبØ';
13367 }
13368 return 'شام';
13369 },
13370 calendar : {
13371 sameDay : '[اڄ] LT',
13372 nextDay : '[سڀاڻي] LT',
13373 nextWeek : 'dddd [اڳين Ù‡Ùتي تي] LT',
13374 lastDay : '[ڪالهه] LT',
13375 lastWeek : '[گزريل Ù‡Ùتي] dddd [تي] LT',
13376 sameElse : 'L'
13377 },
13378 relativeTime : {
13379 future : '%s پوء',
13380 past : '%s اڳ',
13381 s : 'چند سيڪنڊ',
13382 ss : '%d سيڪنڊ',
13383 m : 'هڪ منٽ',
13384 mm : '%d منٽ',
13385 h : 'هڪ ڪلاڪ',
13386 hh : '%d ڪلاڪ',
13387 d : 'Ù‡Úª Úينهن',
13388 dd : '%d Úينهن',
13389 M : 'هڪ مهينو',
13390 MM : '%d مهينا',
13391 y : 'هڪ سال',
13392 yy : '%d سال'
13393 },
13394 preparse: function (string) {
13395 return string.replace(/،/g, ',');
13396 },
13397 postformat: function (string) {
13398 return string.replace(/,/g, '،');
13399 },
13400 week : {
13401 dow : 1, // Monday is the first day of the week.
13402 doy : 4 // The week that contains Jan 4th is the first week of the year.
13403 }
13404 });
13405
13406 return sd;
13407
13408})));
13409
13410
13411/***/ }),
13412/* 103 */
13413/***/ (function(module, exports, __webpack_require__) {
13414
13415//! moment.js locale configuration
13416
13417;(function (global, factory) {
13418 true ? factory(__webpack_require__(0)) :
13419 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13420 factory(global.moment)
13421}(this, (function (moment) { 'use strict';
13422
13423
13424 var se = moment.defineLocale('se', {
13425 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('_'),
13426 monthsShort : 'oÄ‘Ä‘j_guov_njuk_cuo_mies_geas_suoi_borg_ÄakÄ_golg_skáb_juov'.split('_'),
13427 weekdays : 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),
13428 weekdaysShort : 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
13429 weekdaysMin : 's_v_m_g_d_b_L'.split('_'),
13430 longDateFormat : {
13431 LT : 'HH:mm',
13432 LTS : 'HH:mm:ss',
13433 L : 'DD.MM.YYYY',
13434 LL : 'MMMM D. [b.] YYYY',
13435 LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',
13436 LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
13437 },
13438 calendar : {
13439 sameDay: '[otne ti] LT',
13440 nextDay: '[ihttin ti] LT',
13441 nextWeek: 'dddd [ti] LT',
13442 lastDay: '[ikte ti] LT',
13443 lastWeek: '[ovddit] dddd [ti] LT',
13444 sameElse: 'L'
13445 },
13446 relativeTime : {
13447 future : '%s geažes',
13448 past : 'maŋit %s',
13449 s : 'moadde sekunddat',
13450 ss: '%d sekunddat',
13451 m : 'okta minuhta',
13452 mm : '%d minuhtat',
13453 h : 'okta diimmu',
13454 hh : '%d diimmut',
13455 d : 'okta beaivi',
13456 dd : '%d beaivvit',
13457 M : 'okta mánnu',
13458 MM : '%d mánut',
13459 y : 'okta jahki',
13460 yy : '%d jagit'
13461 },
13462 dayOfMonthOrdinalParse: /\d{1,2}\./,
13463 ordinal : '%d.',
13464 week : {
13465 dow : 1, // Monday is the first day of the week.
13466 doy : 4 // The week that contains Jan 4th is the first week of the year.
13467 }
13468 });
13469
13470 return se;
13471
13472})));
13473
13474
13475/***/ }),
13476/* 104 */
13477/***/ (function(module, exports, __webpack_require__) {
13478
13479//! moment.js locale configuration
13480
13481;(function (global, factory) {
13482 true ? factory(__webpack_require__(0)) :
13483 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13484 factory(global.moment)
13485}(this, (function (moment) { 'use strict';
13486
13487
13488 /*jshint -W100*/
13489 var si = moment.defineLocale('si', {
13490 months : 'ජනවà·à¶»à·’_පෙබරවà·à¶»à·’_මà·à¶»à·Šà¶à·”_අප්â€à¶»à·šà¶½à·Š_මà·à¶ºà·’_ජූනි_ජූලි_අගà·à·ƒà·Šà¶à·”_à·ƒà·à¶´à·Šà¶à·à¶¸à·Šà¶¶à¶»à·Š_ඔක්à¶à·à¶¶à¶»à·Š_නොවà·à¶¸à·Šà¶¶à¶»à·Š_දෙසà·à¶¸à·Šà¶¶à¶»à·Š'.split('_'),
13491 monthsShort : 'ජන_පෙබ_මà·à¶»à·Š_අප්_මà·à¶ºà·’_ජූනි_ජූලි_අගà·_à·ƒà·à¶´à·Š_ඔක්_නොවà·_දෙසà·'.split('_'),
13492 weekdays : 'ඉරිදà·_සඳුදà·_අඟහරුවà·à¶¯à·_බදà·à¶¯à·_බ්â€à¶»à·„ස්පà¶à·’න්දà·_සිකුරà·à¶¯à·_සෙනසුරà·à¶¯à·'.split('_'),
13493 weekdaysShort : 'ඉරි_සඳු_අඟ_බදà·_බ්â€à¶»à·„_සිකු_සෙන'.split('_'),
13494 weekdaysMin : 'ඉ_à·ƒ_අ_බ_බ්â€à¶»_සි_සෙ'.split('_'),
13495 weekdaysParseExact : true,
13496 longDateFormat : {
13497 LT : 'a h:mm',
13498 LTS : 'a h:mm:ss',
13499 L : 'YYYY/MM/DD',
13500 LL : 'YYYY MMMM D',
13501 LLL : 'YYYY MMMM D, a h:mm',
13502 LLLL : 'YYYY MMMM D [à·€à·à¶±à·’] dddd, a h:mm:ss'
13503 },
13504 calendar : {
13505 sameDay : '[අද] LT[ට]',
13506 nextDay : '[හෙට] LT[ට]',
13507 nextWeek : 'dddd LT[ට]',
13508 lastDay : '[ඊයේ] LT[ට]',
13509 lastWeek : '[පසුගිය] dddd LT[ට]',
13510 sameElse : 'L'
13511 },
13512 relativeTime : {
13513 future : '%sකින්',
13514 past : '%sකට පෙර',
13515 s : 'à¶à¶à·Šà¶´à¶» කිහිපය',
13516 ss : 'à¶à¶à·Šà¶´à¶» %d',
13517 m : 'මිනිà¶à·Šà¶à·”à·€',
13518 mm : 'මිනිà¶à·Šà¶à·” %d',
13519 h : 'පà·à¶º',
13520 hh : 'පà·à¶º %d',
13521 d : 'දිනය',
13522 dd : 'දින %d',
13523 M : 'මà·à·ƒà¶º',
13524 MM : 'මà·à·ƒ %d',
13525 y : 'වසර',
13526 yy : 'වසර %d'
13527 },
13528 dayOfMonthOrdinalParse: /\d{1,2} à·€à·à¶±à·’/,
13529 ordinal : function (number) {
13530 return number + ' à·€à·à¶±à·’';
13531 },
13532 meridiemParse : /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
13533 isPM : function (input) {
13534 return input === 'ප.ව.' || input === 'පස් වරු';
13535 },
13536 meridiem : function (hours, minutes, isLower) {
13537 if (hours > 11) {
13538 return isLower ? 'ප.ව.' : 'පස් වරු';
13539 } else {
13540 return isLower ? 'පෙ.ව.' : 'පෙර වරු';
13541 }
13542 }
13543 });
13544
13545 return si;
13546
13547})));
13548
13549
13550/***/ }),
13551/* 105 */
13552/***/ (function(module, exports, __webpack_require__) {
13553
13554//! moment.js locale configuration
13555
13556;(function (global, factory) {
13557 true ? factory(__webpack_require__(0)) :
13558 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13559 factory(global.moment)
13560}(this, (function (moment) { 'use strict';
13561
13562
13563 var months = 'január_február_marec_aprÃl_máj_jún_júl_august_september_október_november_december'.split('_'),
13564 monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
13565 function plural(n) {
13566 return (n > 1) && (n < 5);
13567 }
13568 function translate(number, withoutSuffix, key, isFuture) {
13569 var result = number + ' ';
13570 switch (key) {
13571 case 's': // a few seconds / in a few seconds / a few seconds ago
13572 return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
13573 case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
13574 if (withoutSuffix || isFuture) {
13575 return result + (plural(number) ? 'sekundy' : 'sekúnd');
13576 } else {
13577 return result + 'sekundami';
13578 }
13579 break;
13580 case 'm': // a minute / in a minute / a minute ago
13581 return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou');
13582 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
13583 if (withoutSuffix || isFuture) {
13584 return result + (plural(number) ? 'minúty' : 'minút');
13585 } else {
13586 return result + 'minútami';
13587 }
13588 break;
13589 case 'h': // an hour / in an hour / an hour ago
13590 return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
13591 case 'hh': // 9 hours / in 9 hours / 9 hours ago
13592 if (withoutSuffix || isFuture) {
13593 return result + (plural(number) ? 'hodiny' : 'hodÃn');
13594 } else {
13595 return result + 'hodinami';
13596 }
13597 break;
13598 case 'd': // a day / in a day / a day ago
13599 return (withoutSuffix || isFuture) ? 'deň' : 'dňom';
13600 case 'dd': // 9 days / in 9 days / 9 days ago
13601 if (withoutSuffix || isFuture) {
13602 return result + (plural(number) ? 'dni' : 'dnÃ');
13603 } else {
13604 return result + 'dňami';
13605 }
13606 break;
13607 case 'M': // a month / in a month / a month ago
13608 return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
13609 case 'MM': // 9 months / in 9 months / 9 months ago
13610 if (withoutSuffix || isFuture) {
13611 return result + (plural(number) ? 'mesiace' : 'mesiacov');
13612 } else {
13613 return result + 'mesiacmi';
13614 }
13615 break;
13616 case 'y': // a year / in a year / a year ago
13617 return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
13618 case 'yy': // 9 years / in 9 years / 9 years ago
13619 if (withoutSuffix || isFuture) {
13620 return result + (plural(number) ? 'roky' : 'rokov');
13621 } else {
13622 return result + 'rokmi';
13623 }
13624 break;
13625 }
13626 }
13627
13628 var sk = moment.defineLocale('sk', {
13629 months : months,
13630 monthsShort : monthsShort,
13631 weekdays : 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
13632 weekdaysShort : 'ne_po_ut_st_Å¡t_pi_so'.split('_'),
13633 weekdaysMin : 'ne_po_ut_st_Å¡t_pi_so'.split('_'),
13634 longDateFormat : {
13635 LT: 'H:mm',
13636 LTS : 'H:mm:ss',
13637 L : 'DD.MM.YYYY',
13638 LL : 'D. MMMM YYYY',
13639 LLL : 'D. MMMM YYYY H:mm',
13640 LLLL : 'dddd D. MMMM YYYY H:mm'
13641 },
13642 calendar : {
13643 sameDay: '[dnes o] LT',
13644 nextDay: '[zajtra o] LT',
13645 nextWeek: function () {
13646 switch (this.day()) {
13647 case 0:
13648 return '[v nedeľu o] LT';
13649 case 1:
13650 case 2:
13651 return '[v] dddd [o] LT';
13652 case 3:
13653 return '[v stredu o] LT';
13654 case 4:
13655 return '[vo Å¡tvrtok o] LT';
13656 case 5:
13657 return '[v piatok o] LT';
13658 case 6:
13659 return '[v sobotu o] LT';
13660 }
13661 },
13662 lastDay: '[vÄera o] LT',
13663 lastWeek: function () {
13664 switch (this.day()) {
13665 case 0:
13666 return '[minulú nedeľu o] LT';
13667 case 1:
13668 case 2:
13669 return '[minulý] dddd [o] LT';
13670 case 3:
13671 return '[minulú stredu o] LT';
13672 case 4:
13673 case 5:
13674 return '[minulý] dddd [o] LT';
13675 case 6:
13676 return '[minulú sobotu o] LT';
13677 }
13678 },
13679 sameElse: 'L'
13680 },
13681 relativeTime : {
13682 future : 'za %s',
13683 past : 'pred %s',
13684 s : translate,
13685 ss : translate,
13686 m : translate,
13687 mm : translate,
13688 h : translate,
13689 hh : translate,
13690 d : translate,
13691 dd : translate,
13692 M : translate,
13693 MM : translate,
13694 y : translate,
13695 yy : translate
13696 },
13697 dayOfMonthOrdinalParse: /\d{1,2}\./,
13698 ordinal : '%d.',
13699 week : {
13700 dow : 1, // Monday is the first day of the week.
13701 doy : 4 // The week that contains Jan 4th is the first week of the year.
13702 }
13703 });
13704
13705 return sk;
13706
13707})));
13708
13709
13710/***/ }),
13711/* 106 */
13712/***/ (function(module, exports, __webpack_require__) {
13713
13714//! moment.js locale configuration
13715
13716;(function (global, factory) {
13717 true ? factory(__webpack_require__(0)) :
13718 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13719 factory(global.moment)
13720}(this, (function (moment) { 'use strict';
13721
13722
13723 function processRelativeTime(number, withoutSuffix, key, isFuture) {
13724 var result = number + ' ';
13725 switch (key) {
13726 case 's':
13727 return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami';
13728 case 'ss':
13729 if (number === 1) {
13730 result += withoutSuffix ? 'sekundo' : 'sekundi';
13731 } else if (number === 2) {
13732 result += withoutSuffix || isFuture ? 'sekundi' : 'sekundah';
13733 } else if (number < 5) {
13734 result += withoutSuffix || isFuture ? 'sekunde' : 'sekundah';
13735 } else {
13736 result += withoutSuffix || isFuture ? 'sekund' : 'sekund';
13737 }
13738 return result;
13739 case 'm':
13740 return withoutSuffix ? 'ena minuta' : 'eno minuto';
13741 case 'mm':
13742 if (number === 1) {
13743 result += withoutSuffix ? 'minuta' : 'minuto';
13744 } else if (number === 2) {
13745 result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
13746 } else if (number < 5) {
13747 result += withoutSuffix || isFuture ? 'minute' : 'minutami';
13748 } else {
13749 result += withoutSuffix || isFuture ? 'minut' : 'minutami';
13750 }
13751 return result;
13752 case 'h':
13753 return withoutSuffix ? 'ena ura' : 'eno uro';
13754 case 'hh':
13755 if (number === 1) {
13756 result += withoutSuffix ? 'ura' : 'uro';
13757 } else if (number === 2) {
13758 result += withoutSuffix || isFuture ? 'uri' : 'urama';
13759 } else if (number < 5) {
13760 result += withoutSuffix || isFuture ? 'ure' : 'urami';
13761 } else {
13762 result += withoutSuffix || isFuture ? 'ur' : 'urami';
13763 }
13764 return result;
13765 case 'd':
13766 return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
13767 case 'dd':
13768 if (number === 1) {
13769 result += withoutSuffix || isFuture ? 'dan' : 'dnem';
13770 } else if (number === 2) {
13771 result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
13772 } else {
13773 result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
13774 }
13775 return result;
13776 case 'M':
13777 return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
13778 case 'MM':
13779 if (number === 1) {
13780 result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
13781 } else if (number === 2) {
13782 result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
13783 } else if (number < 5) {
13784 result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
13785 } else {
13786 result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
13787 }
13788 return result;
13789 case 'y':
13790 return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
13791 case 'yy':
13792 if (number === 1) {
13793 result += withoutSuffix || isFuture ? 'leto' : 'letom';
13794 } else if (number === 2) {
13795 result += withoutSuffix || isFuture ? 'leti' : 'letoma';
13796 } else if (number < 5) {
13797 result += withoutSuffix || isFuture ? 'leta' : 'leti';
13798 } else {
13799 result += withoutSuffix || isFuture ? 'let' : 'leti';
13800 }
13801 return result;
13802 }
13803 }
13804
13805 var sl = moment.defineLocale('sl', {
13806 months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
13807 monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
13808 monthsParseExact: true,
13809 weekdays : 'nedelja_ponedeljek_torek_sreda_Äetrtek_petek_sobota'.split('_'),
13810 weekdaysShort : 'ned._pon._tor._sre._Äet._pet._sob.'.split('_'),
13811 weekdaysMin : 'ne_po_to_sr_Äe_pe_so'.split('_'),
13812 weekdaysParseExact : true,
13813 longDateFormat : {
13814 LT : 'H:mm',
13815 LTS : 'H:mm:ss',
13816 L : 'DD.MM.YYYY',
13817 LL : 'D. MMMM YYYY',
13818 LLL : 'D. MMMM YYYY H:mm',
13819 LLLL : 'dddd, D. MMMM YYYY H:mm'
13820 },
13821 calendar : {
13822 sameDay : '[danes ob] LT',
13823 nextDay : '[jutri ob] LT',
13824
13825 nextWeek : function () {
13826 switch (this.day()) {
13827 case 0:
13828 return '[v] [nedeljo] [ob] LT';
13829 case 3:
13830 return '[v] [sredo] [ob] LT';
13831 case 6:
13832 return '[v] [soboto] [ob] LT';
13833 case 1:
13834 case 2:
13835 case 4:
13836 case 5:
13837 return '[v] dddd [ob] LT';
13838 }
13839 },
13840 lastDay : '[vÄeraj ob] LT',
13841 lastWeek : function () {
13842 switch (this.day()) {
13843 case 0:
13844 return '[prejšnjo] [nedeljo] [ob] LT';
13845 case 3:
13846 return '[prejšnjo] [sredo] [ob] LT';
13847 case 6:
13848 return '[prejšnjo] [soboto] [ob] LT';
13849 case 1:
13850 case 2:
13851 case 4:
13852 case 5:
13853 return '[prejšnji] dddd [ob] LT';
13854 }
13855 },
13856 sameElse : 'L'
13857 },
13858 relativeTime : {
13859 future : 'Äez %s',
13860 past : 'pred %s',
13861 s : processRelativeTime,
13862 ss : processRelativeTime,
13863 m : processRelativeTime,
13864 mm : processRelativeTime,
13865 h : processRelativeTime,
13866 hh : processRelativeTime,
13867 d : processRelativeTime,
13868 dd : processRelativeTime,
13869 M : processRelativeTime,
13870 MM : processRelativeTime,
13871 y : processRelativeTime,
13872 yy : processRelativeTime
13873 },
13874 dayOfMonthOrdinalParse: /\d{1,2}\./,
13875 ordinal : '%d.',
13876 week : {
13877 dow : 1, // Monday is the first day of the week.
13878 doy : 7 // The week that contains Jan 1st is the first week of the year.
13879 }
13880 });
13881
13882 return sl;
13883
13884})));
13885
13886
13887/***/ }),
13888/* 107 */
13889/***/ (function(module, exports, __webpack_require__) {
13890
13891//! moment.js locale configuration
13892
13893;(function (global, factory) {
13894 true ? factory(__webpack_require__(0)) :
13895 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13896 factory(global.moment)
13897}(this, (function (moment) { 'use strict';
13898
13899
13900 var sq = moment.defineLocale('sq', {
13901 months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
13902 monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
13903 weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
13904 weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
13905 weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'),
13906 weekdaysParseExact : true,
13907 meridiemParse: /PD|MD/,
13908 isPM: function (input) {
13909 return input.charAt(0) === 'M';
13910 },
13911 meridiem : function (hours, minutes, isLower) {
13912 return hours < 12 ? 'PD' : 'MD';
13913 },
13914 longDateFormat : {
13915 LT : 'HH:mm',
13916 LTS : 'HH:mm:ss',
13917 L : 'DD/MM/YYYY',
13918 LL : 'D MMMM YYYY',
13919 LLL : 'D MMMM YYYY HH:mm',
13920 LLLL : 'dddd, D MMMM YYYY HH:mm'
13921 },
13922 calendar : {
13923 sameDay : '[Sot në] LT',
13924 nextDay : '[Nesër në] LT',
13925 nextWeek : 'dddd [në] LT',
13926 lastDay : '[Dje në] LT',
13927 lastWeek : 'dddd [e kaluar në] LT',
13928 sameElse : 'L'
13929 },
13930 relativeTime : {
13931 future : 'në %s',
13932 past : '%s më parë',
13933 s : 'disa sekonda',
13934 ss : '%d sekonda',
13935 m : 'një minutë',
13936 mm : '%d minuta',
13937 h : 'një orë',
13938 hh : '%d orë',
13939 d : 'një ditë',
13940 dd : '%d ditë',
13941 M : 'një muaj',
13942 MM : '%d muaj',
13943 y : 'një vit',
13944 yy : '%d vite'
13945 },
13946 dayOfMonthOrdinalParse: /\d{1,2}\./,
13947 ordinal : '%d.',
13948 week : {
13949 dow : 1, // Monday is the first day of the week.
13950 doy : 4 // The week that contains Jan 4th is the first week of the year.
13951 }
13952 });
13953
13954 return sq;
13955
13956})));
13957
13958
13959/***/ }),
13960/* 108 */
13961/***/ (function(module, exports, __webpack_require__) {
13962
13963//! moment.js locale configuration
13964
13965;(function (global, factory) {
13966 true ? factory(__webpack_require__(0)) :
13967 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
13968 factory(global.moment)
13969}(this, (function (moment) { 'use strict';
13970
13971
13972 var translator = {
13973 words: { //Different grammatical cases
13974 ss: ['Ñекунда', 'Ñекунде', 'Ñекунди'],
13975 m: ['један минут', 'једне минуте'],
13976 mm: ['минут', 'минуте', 'минута'],
13977 h: ['један Ñат', 'једног Ñата'],
13978 hh: ['Ñат', 'Ñата', 'Ñати'],
13979 dd: ['дан', 'дана', 'дана'],
13980 MM: ['меÑец', 'меÑеца', 'меÑеци'],
13981 yy: ['година', 'године', 'година']
13982 },
13983 correctGrammaticalCase: function (number, wordKey) {
13984 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
13985 },
13986 translate: function (number, withoutSuffix, key) {
13987 var wordKey = translator.words[key];
13988 if (key.length === 1) {
13989 return withoutSuffix ? wordKey[0] : wordKey[1];
13990 } else {
13991 return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
13992 }
13993 }
13994 };
13995
13996 var srCyrl = moment.defineLocale('sr-cyrl', {
13997 months: 'јануар_фебруар_март_април_мај_јун_јул_авгуÑÑ‚_Ñептембар_октобар_новембар_децембар'.split('_'),
13998 monthsShort: 'јан._феб._мар._апр._мај_јун_јул_авг._Ñеп._окт._нов._дец.'.split('_'),
13999 monthsParseExact: true,
14000 weekdays: 'недеља_понедељак_уторак_Ñреда_четвртак_петак_Ñубота'.split('_'),
14001 weekdaysShort: 'нед._пон._уто._Ñре._чет._пет._Ñуб.'.split('_'),
14002 weekdaysMin: 'не_по_ут_ÑÑ€_че_пе_Ñу'.split('_'),
14003 weekdaysParseExact : true,
14004 longDateFormat: {
14005 LT: 'H:mm',
14006 LTS : 'H:mm:ss',
14007 L: 'DD.MM.YYYY',
14008 LL: 'D. MMMM YYYY',
14009 LLL: 'D. MMMM YYYY H:mm',
14010 LLLL: 'dddd, D. MMMM YYYY H:mm'
14011 },
14012 calendar: {
14013 sameDay: '[Ð´Ð°Ð½Ð°Ñ Ñƒ] LT',
14014 nextDay: '[Ñутра у] LT',
14015 nextWeek: function () {
14016 switch (this.day()) {
14017 case 0:
14018 return '[у] [недељу] [у] LT';
14019 case 3:
14020 return '[у] [Ñреду] [у] LT';
14021 case 6:
14022 return '[у] [Ñуботу] [у] LT';
14023 case 1:
14024 case 2:
14025 case 4:
14026 case 5:
14027 return '[у] dddd [у] LT';
14028 }
14029 },
14030 lastDay : '[јуче у] LT',
14031 lastWeek : function () {
14032 var lastWeekDays = [
14033 '[прошле] [недеље] [у] LT',
14034 '[прошлог] [понедељка] [у] LT',
14035 '[прошлог] [уторка] [у] LT',
14036 '[прошле] [Ñреде] [у] LT',
14037 '[прошлог] [четвртка] [у] LT',
14038 '[прошлог] [петка] [у] LT',
14039 '[прошле] [Ñуботе] [у] LT'
14040 ];
14041 return lastWeekDays[this.day()];
14042 },
14043 sameElse : 'L'
14044 },
14045 relativeTime : {
14046 future : 'за %s',
14047 past : 'пре %s',
14048 s : 'неколико Ñекунди',
14049 ss : translator.translate,
14050 m : translator.translate,
14051 mm : translator.translate,
14052 h : translator.translate,
14053 hh : translator.translate,
14054 d : 'дан',
14055 dd : translator.translate,
14056 M : 'меÑец',
14057 MM : translator.translate,
14058 y : 'годину',
14059 yy : translator.translate
14060 },
14061 dayOfMonthOrdinalParse: /\d{1,2}\./,
14062 ordinal : '%d.',
14063 week : {
14064 dow : 1, // Monday is the first day of the week.
14065 doy : 7 // The week that contains Jan 1st is the first week of the year.
14066 }
14067 });
14068
14069 return srCyrl;
14070
14071})));
14072
14073
14074/***/ }),
14075/* 109 */
14076/***/ (function(module, exports, __webpack_require__) {
14077
14078//! moment.js locale configuration
14079
14080;(function (global, factory) {
14081 true ? factory(__webpack_require__(0)) :
14082 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14083 factory(global.moment)
14084}(this, (function (moment) { 'use strict';
14085
14086
14087 var translator = {
14088 words: { //Different grammatical cases
14089 ss: ['sekunda', 'sekunde', 'sekundi'],
14090 m: ['jedan minut', 'jedne minute'],
14091 mm: ['minut', 'minute', 'minuta'],
14092 h: ['jedan sat', 'jednog sata'],
14093 hh: ['sat', 'sata', 'sati'],
14094 dd: ['dan', 'dana', 'dana'],
14095 MM: ['mesec', 'meseca', 'meseci'],
14096 yy: ['godina', 'godine', 'godina']
14097 },
14098 correctGrammaticalCase: function (number, wordKey) {
14099 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
14100 },
14101 translate: function (number, withoutSuffix, key) {
14102 var wordKey = translator.words[key];
14103 if (key.length === 1) {
14104 return withoutSuffix ? wordKey[0] : wordKey[1];
14105 } else {
14106 return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
14107 }
14108 }
14109 };
14110
14111 var sr = moment.defineLocale('sr', {
14112 months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
14113 monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
14114 monthsParseExact: true,
14115 weekdays: 'nedelja_ponedeljak_utorak_sreda_Äetvrtak_petak_subota'.split('_'),
14116 weekdaysShort: 'ned._pon._uto._sre._Äet._pet._sub.'.split('_'),
14117 weekdaysMin: 'ne_po_ut_sr_Äe_pe_su'.split('_'),
14118 weekdaysParseExact : true,
14119 longDateFormat: {
14120 LT: 'H:mm',
14121 LTS : 'H:mm:ss',
14122 L: 'DD.MM.YYYY',
14123 LL: 'D. MMMM YYYY',
14124 LLL: 'D. MMMM YYYY H:mm',
14125 LLLL: 'dddd, D. MMMM YYYY H:mm'
14126 },
14127 calendar: {
14128 sameDay: '[danas u] LT',
14129 nextDay: '[sutra u] LT',
14130 nextWeek: function () {
14131 switch (this.day()) {
14132 case 0:
14133 return '[u] [nedelju] [u] LT';
14134 case 3:
14135 return '[u] [sredu] [u] LT';
14136 case 6:
14137 return '[u] [subotu] [u] LT';
14138 case 1:
14139 case 2:
14140 case 4:
14141 case 5:
14142 return '[u] dddd [u] LT';
14143 }
14144 },
14145 lastDay : '[juÄe u] LT',
14146 lastWeek : function () {
14147 var lastWeekDays = [
14148 '[prošle] [nedelje] [u] LT',
14149 '[prošlog] [ponedeljka] [u] LT',
14150 '[prošlog] [utorka] [u] LT',
14151 '[prošle] [srede] [u] LT',
14152 '[proÅ¡log] [Äetvrtka] [u] LT',
14153 '[prošlog] [petka] [u] LT',
14154 '[prošle] [subote] [u] LT'
14155 ];
14156 return lastWeekDays[this.day()];
14157 },
14158 sameElse : 'L'
14159 },
14160 relativeTime : {
14161 future : 'za %s',
14162 past : 'pre %s',
14163 s : 'nekoliko sekundi',
14164 ss : translator.translate,
14165 m : translator.translate,
14166 mm : translator.translate,
14167 h : translator.translate,
14168 hh : translator.translate,
14169 d : 'dan',
14170 dd : translator.translate,
14171 M : 'mesec',
14172 MM : translator.translate,
14173 y : 'godinu',
14174 yy : translator.translate
14175 },
14176 dayOfMonthOrdinalParse: /\d{1,2}\./,
14177 ordinal : '%d.',
14178 week : {
14179 dow : 1, // Monday is the first day of the week.
14180 doy : 7 // The week that contains Jan 1st is the first week of the year.
14181 }
14182 });
14183
14184 return sr;
14185
14186})));
14187
14188
14189/***/ }),
14190/* 110 */
14191/***/ (function(module, exports, __webpack_require__) {
14192
14193//! moment.js locale configuration
14194
14195;(function (global, factory) {
14196 true ? factory(__webpack_require__(0)) :
14197 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14198 factory(global.moment)
14199}(this, (function (moment) { 'use strict';
14200
14201
14202 var ss = moment.defineLocale('ss', {
14203 months : "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'),
14204 monthsShort : 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
14205 weekdays : 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'),
14206 weekdaysShort : 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
14207 weekdaysMin : 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
14208 weekdaysParseExact : true,
14209 longDateFormat : {
14210 LT : 'h:mm A',
14211 LTS : 'h:mm:ss A',
14212 L : 'DD/MM/YYYY',
14213 LL : 'D MMMM YYYY',
14214 LLL : 'D MMMM YYYY h:mm A',
14215 LLLL : 'dddd, D MMMM YYYY h:mm A'
14216 },
14217 calendar : {
14218 sameDay : '[Namuhla nga] LT',
14219 nextDay : '[Kusasa nga] LT',
14220 nextWeek : 'dddd [nga] LT',
14221 lastDay : '[Itolo nga] LT',
14222 lastWeek : 'dddd [leliphelile] [nga] LT',
14223 sameElse : 'L'
14224 },
14225 relativeTime : {
14226 future : 'nga %s',
14227 past : 'wenteka nga %s',
14228 s : 'emizuzwana lomcane',
14229 ss : '%d mzuzwana',
14230 m : 'umzuzu',
14231 mm : '%d emizuzu',
14232 h : 'lihora',
14233 hh : '%d emahora',
14234 d : 'lilanga',
14235 dd : '%d emalanga',
14236 M : 'inyanga',
14237 MM : '%d tinyanga',
14238 y : 'umnyaka',
14239 yy : '%d iminyaka'
14240 },
14241 meridiemParse: /ekuseni|emini|entsambama|ebusuku/,
14242 meridiem : function (hours, minutes, isLower) {
14243 if (hours < 11) {
14244 return 'ekuseni';
14245 } else if (hours < 15) {
14246 return 'emini';
14247 } else if (hours < 19) {
14248 return 'entsambama';
14249 } else {
14250 return 'ebusuku';
14251 }
14252 },
14253 meridiemHour : function (hour, meridiem) {
14254 if (hour === 12) {
14255 hour = 0;
14256 }
14257 if (meridiem === 'ekuseni') {
14258 return hour;
14259 } else if (meridiem === 'emini') {
14260 return hour >= 11 ? hour : hour + 12;
14261 } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') {
14262 if (hour === 0) {
14263 return 0;
14264 }
14265 return hour + 12;
14266 }
14267 },
14268 dayOfMonthOrdinalParse: /\d{1,2}/,
14269 ordinal : '%d',
14270 week : {
14271 dow : 1, // Monday is the first day of the week.
14272 doy : 4 // The week that contains Jan 4th is the first week of the year.
14273 }
14274 });
14275
14276 return ss;
14277
14278})));
14279
14280
14281/***/ }),
14282/* 111 */
14283/***/ (function(module, exports, __webpack_require__) {
14284
14285//! moment.js locale configuration
14286
14287;(function (global, factory) {
14288 true ? factory(__webpack_require__(0)) :
14289 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14290 factory(global.moment)
14291}(this, (function (moment) { 'use strict';
14292
14293
14294 var sv = moment.defineLocale('sv', {
14295 months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
14296 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
14297 weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
14298 weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
14299 weekdaysMin : 'sö_må_ti_on_to_fr_lö'.split('_'),
14300 longDateFormat : {
14301 LT : 'HH:mm',
14302 LTS : 'HH:mm:ss',
14303 L : 'YYYY-MM-DD',
14304 LL : 'D MMMM YYYY',
14305 LLL : 'D MMMM YYYY [kl.] HH:mm',
14306 LLLL : 'dddd D MMMM YYYY [kl.] HH:mm',
14307 lll : 'D MMM YYYY HH:mm',
14308 llll : 'ddd D MMM YYYY HH:mm'
14309 },
14310 calendar : {
14311 sameDay: '[Idag] LT',
14312 nextDay: '[Imorgon] LT',
14313 lastDay: '[Igår] LT',
14314 nextWeek: '[PÃ¥] dddd LT',
14315 lastWeek: '[I] dddd[s] LT',
14316 sameElse: 'L'
14317 },
14318 relativeTime : {
14319 future : 'om %s',
14320 past : 'för %s sedan',
14321 s : 'några sekunder',
14322 ss : '%d sekunder',
14323 m : 'en minut',
14324 mm : '%d minuter',
14325 h : 'en timme',
14326 hh : '%d timmar',
14327 d : 'en dag',
14328 dd : '%d dagar',
14329 M : 'en månad',
14330 MM : '%d månader',
14331 y : 'ett år',
14332 yy : '%d år'
14333 },
14334 dayOfMonthOrdinalParse: /\d{1,2}(e|a)/,
14335 ordinal : function (number) {
14336 var b = number % 10,
14337 output = (~~(number % 100 / 10) === 1) ? 'e' :
14338 (b === 1) ? 'a' :
14339 (b === 2) ? 'a' :
14340 (b === 3) ? 'e' : 'e';
14341 return number + output;
14342 },
14343 week : {
14344 dow : 1, // Monday is the first day of the week.
14345 doy : 4 // The week that contains Jan 4th is the first week of the year.
14346 }
14347 });
14348
14349 return sv;
14350
14351})));
14352
14353
14354/***/ }),
14355/* 112 */
14356/***/ (function(module, exports, __webpack_require__) {
14357
14358//! moment.js locale configuration
14359
14360;(function (global, factory) {
14361 true ? factory(__webpack_require__(0)) :
14362 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14363 factory(global.moment)
14364}(this, (function (moment) { 'use strict';
14365
14366
14367 var sw = moment.defineLocale('sw', {
14368 months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
14369 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
14370 weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
14371 weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
14372 weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
14373 weekdaysParseExact : true,
14374 longDateFormat : {
14375 LT : 'HH:mm',
14376 LTS : 'HH:mm:ss',
14377 L : 'DD.MM.YYYY',
14378 LL : 'D MMMM YYYY',
14379 LLL : 'D MMMM YYYY HH:mm',
14380 LLLL : 'dddd, D MMMM YYYY HH:mm'
14381 },
14382 calendar : {
14383 sameDay : '[leo saa] LT',
14384 nextDay : '[kesho saa] LT',
14385 nextWeek : '[wiki ijayo] dddd [saat] LT',
14386 lastDay : '[jana] LT',
14387 lastWeek : '[wiki iliyopita] dddd [saat] LT',
14388 sameElse : 'L'
14389 },
14390 relativeTime : {
14391 future : '%s baadaye',
14392 past : 'tokea %s',
14393 s : 'hivi punde',
14394 ss : 'sekunde %d',
14395 m : 'dakika moja',
14396 mm : 'dakika %d',
14397 h : 'saa limoja',
14398 hh : 'masaa %d',
14399 d : 'siku moja',
14400 dd : 'masiku %d',
14401 M : 'mwezi mmoja',
14402 MM : 'miezi %d',
14403 y : 'mwaka mmoja',
14404 yy : 'miaka %d'
14405 },
14406 week : {
14407 dow : 1, // Monday is the first day of the week.
14408 doy : 7 // The week that contains Jan 1st is the first week of the year.
14409 }
14410 });
14411
14412 return sw;
14413
14414})));
14415
14416
14417/***/ }),
14418/* 113 */
14419/***/ (function(module, exports, __webpack_require__) {
14420
14421//! moment.js locale configuration
14422
14423;(function (global, factory) {
14424 true ? factory(__webpack_require__(0)) :
14425 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14426 factory(global.moment)
14427}(this, (function (moment) { 'use strict';
14428
14429
14430 var symbolMap = {
14431 '1': '௧',
14432 '2': '௨',
14433 '3': '௩',
14434 '4': '௪',
14435 '5': '௫',
14436 '6': '௬',
14437 '7': 'à¯',
14438 '8': '௮',
14439 '9': '௯',
14440 '0': '௦'
14441 }, numberMap = {
14442 '௧': '1',
14443 '௨': '2',
14444 '௩': '3',
14445 '௪': '4',
14446 '௫': '5',
14447 '௬': '6',
14448 'à¯': '7',
14449 '௮': '8',
14450 '௯': '9',
14451 '௦': '0'
14452 };
14453
14454 var ta = moment.defineLocale('ta', {
14455 months : 'ஜனவரி_பிபà¯à®°à®µà®°à®¿_மாரà¯à®šà¯_à®à®ªà¯à®°à®²à¯_மே_ஜூனà¯_ஜூலை_ஆகஸà¯à®Ÿà¯_செபà¯à®Ÿà¯†à®®à¯à®ªà®°à¯_அகà¯à®Ÿà¯‡à®¾à®ªà®°à¯_நவமà¯à®ªà®°à¯_டிசமà¯à®ªà®°à¯'.split('_'),
14456 monthsShort : 'ஜனவரி_பிபà¯à®°à®µà®°à®¿_மாரà¯à®šà¯_à®à®ªà¯à®°à®²à¯_மே_ஜூனà¯_ஜூலை_ஆகஸà¯à®Ÿà¯_செபà¯à®Ÿà¯†à®®à¯à®ªà®°à¯_அகà¯à®Ÿà¯‡à®¾à®ªà®°à¯_நவமà¯à®ªà®°à¯_டிசமà¯à®ªà®°à¯'.split('_'),
14457 weekdays : 'ஞாயிறà¯à®±à¯à®•à¯à®•à®¿à®´à®®à¯ˆ_திஙà¯à®•à®Ÿà¯à®•à®¿à®´à®®à¯ˆ_செவà¯à®µà®¾à®¯à¯à®•à®¿à®´à®®à¯ˆ_பà¯à®¤à®©à¯à®•à®¿à®´à®®à¯ˆ_வியாழகà¯à®•à®¿à®´à®®à¯ˆ_வெளà¯à®³à®¿à®•à¯à®•à®¿à®´à®®à¯ˆ_சனிகà¯à®•à®¿à®´à®®à¯ˆ'.split('_'),
14458 weekdaysShort : 'ஞாயிறà¯_திஙà¯à®•à®³à¯_செவà¯à®µà®¾à®¯à¯_பà¯à®¤à®©à¯_வியாழனà¯_வெளà¯à®³à®¿_சனி'.split('_'),
14459 weekdaysMin : 'ஞா_தி_செ_பà¯_வி_வெ_ச'.split('_'),
14460 longDateFormat : {
14461 LT : 'HH:mm',
14462 LTS : 'HH:mm:ss',
14463 L : 'DD/MM/YYYY',
14464 LL : 'D MMMM YYYY',
14465 LLL : 'D MMMM YYYY, HH:mm',
14466 LLLL : 'dddd, D MMMM YYYY, HH:mm'
14467 },
14468 calendar : {
14469 sameDay : '[இனà¯à®±à¯] LT',
14470 nextDay : '[நாளை] LT',
14471 nextWeek : 'dddd, LT',
14472 lastDay : '[நேறà¯à®±à¯] LT',
14473 lastWeek : '[கடநà¯à®¤ வாரமà¯] dddd, LT',
14474 sameElse : 'L'
14475 },
14476 relativeTime : {
14477 future : '%s இலà¯',
14478 past : '%s à®®à¯à®©à¯',
14479 s : 'ஒர௠சில விநாடிகளà¯',
14480 ss : '%d விநாடிகளà¯',
14481 m : 'ஒர௠நிமிடமà¯',
14482 mm : '%d நிமிடஙà¯à®•à®³à¯',
14483 h : 'ஒர௠மணி நேரமà¯',
14484 hh : '%d மணி நேரமà¯',
14485 d : 'ஒர௠நாளà¯',
14486 dd : '%d நாடà¯à®•à®³à¯',
14487 M : 'ஒர௠மாதமà¯',
14488 MM : '%d மாதஙà¯à®•à®³à¯',
14489 y : 'ஒர௠வரà¯à®Ÿà®®à¯',
14490 yy : '%d ஆணà¯à®Ÿà¯à®•à®³à¯'
14491 },
14492 dayOfMonthOrdinalParse: /\d{1,2}வதà¯/,
14493 ordinal : function (number) {
14494 return number + 'வதà¯';
14495 },
14496 preparse: function (string) {
14497 return string.replace(/[௧௨௩௪௫௬à¯à¯®à¯¯à¯¦]/g, function (match) {
14498 return numberMap[match];
14499 });
14500 },
14501 postformat: function (string) {
14502 return string.replace(/\d/g, function (match) {
14503 return symbolMap[match];
14504 });
14505 },
14506 // refer http://ta.wikipedia.org/s/1er1
14507 meridiemParse: /யாமமà¯|வைகறை|காலை|நணà¯à®ªà®•à®²à¯|எறà¯à®ªà®¾à®Ÿà¯|மாலை/,
14508 meridiem : function (hour, minute, isLower) {
14509 if (hour < 2) {
14510 return ' யாமமà¯';
14511 } else if (hour < 6) {
14512 return ' வைகறை'; // வைகறை
14513 } else if (hour < 10) {
14514 return ' காலை'; // காலை
14515 } else if (hour < 14) {
14516 return ' நணà¯à®ªà®•à®²à¯'; // நணà¯à®ªà®•à®²à¯
14517 } else if (hour < 18) {
14518 return ' எறà¯à®ªà®¾à®Ÿà¯'; // எறà¯à®ªà®¾à®Ÿà¯
14519 } else if (hour < 22) {
14520 return ' மாலை'; // மாலை
14521 } else {
14522 return ' யாமமà¯';
14523 }
14524 },
14525 meridiemHour : function (hour, meridiem) {
14526 if (hour === 12) {
14527 hour = 0;
14528 }
14529 if (meridiem === 'யாமமà¯') {
14530 return hour < 2 ? hour : hour + 12;
14531 } else if (meridiem === 'வைகறை' || meridiem === 'காலை') {
14532 return hour;
14533 } else if (meridiem === 'நணà¯à®ªà®•à®²à¯') {
14534 return hour >= 10 ? hour : hour + 12;
14535 } else {
14536 return hour + 12;
14537 }
14538 },
14539 week : {
14540 dow : 0, // Sunday is the first day of the week.
14541 doy : 6 // The week that contains Jan 1st is the first week of the year.
14542 }
14543 });
14544
14545 return ta;
14546
14547})));
14548
14549
14550/***/ }),
14551/* 114 */
14552/***/ (function(module, exports, __webpack_require__) {
14553
14554//! moment.js locale configuration
14555
14556;(function (global, factory) {
14557 true ? factory(__webpack_require__(0)) :
14558 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14559 factory(global.moment)
14560}(this, (function (moment) { 'use strict';
14561
14562
14563 var te = moment.defineLocale('te', {
14564 months : 'జనవరి_à°«à°¿à°¬à±à°°à°µà°°à°¿_మారà±à°šà°¿_à°à°ªà±à°°à°¿à°²à±_మే_జూనà±_జూలై_ఆగసà±à°Ÿà±_సెపà±à°Ÿà±†à°‚బరà±_à°…à°•à±à°Ÿà±‹à°¬à°°à±_నవంబరà±_డిసెంబరà±'.split('_'),
14565 monthsShort : 'జన._à°«à°¿à°¬à±à°°._మారà±à°šà°¿_à°à°ªà±à°°à°¿._మే_జూనà±_జూలై_ఆగ._సెపà±._à°…à°•à±à°Ÿà±‹._నవ._డిసె.'.split('_'),
14566 monthsParseExact : true,
14567 weekdays : 'ఆదివారం_సోమవారం_మంగళవారం_à°¬à±à°§à°µà°¾à°°à°‚_à°—à±à°°à±à°µà°¾à°°à°‚_à°¶à±à°•à±à°°à°µà°¾à°°à°‚_శనివారం'.split('_'),
14568 weekdaysShort : 'ఆది_సోమ_మంగళ_à°¬à±à°§_à°—à±à°°à±_à°¶à±à°•à±à°°_శని'.split('_'),
14569 weekdaysMin : 'à°†_సో_మం_à°¬à±_à°—à±_à°¶à±_à°¶'.split('_'),
14570 longDateFormat : {
14571 LT : 'A h:mm',
14572 LTS : 'A h:mm:ss',
14573 L : 'DD/MM/YYYY',
14574 LL : 'D MMMM YYYY',
14575 LLL : 'D MMMM YYYY, A h:mm',
14576 LLLL : 'dddd, D MMMM YYYY, A h:mm'
14577 },
14578 calendar : {
14579 sameDay : '[నేడà±] LT',
14580 nextDay : '[రేపà±] LT',
14581 nextWeek : 'dddd, LT',
14582 lastDay : '[నినà±à°¨] LT',
14583 lastWeek : '[à°—à°¤] dddd, LT',
14584 sameElse : 'L'
14585 },
14586 relativeTime : {
14587 future : '%s లో',
14588 past : '%s à°•à±à°°à°¿à°¤à°‚',
14589 s : 'కొనà±à°¨à°¿ à°•à±à°·à°£à°¾à°²à±',
14590 ss : '%d సెకనà±à°²à±',
14591 m : 'ఒక నిమిషం',
14592 mm : '%d నిమిషాలà±',
14593 h : 'à°’à°• à°—à°‚à°Ÿ',
14594 hh : '%d à°—à°‚à°Ÿà°²à±',
14595 d : 'à°’à°• రోజà±',
14596 dd : '%d రోజà±à°²à±',
14597 M : 'ఒక నెల',
14598 MM : '%d నెలలà±',
14599 y : 'à°’à°• సంవతà±à°¸à°°à°‚',
14600 yy : '%d సంవతà±à°¸à°°à°¾à°²à±'
14601 },
14602 dayOfMonthOrdinalParse : /\d{1,2}à°µ/,
14603 ordinal : '%dà°µ',
14604 meridiemParse: /రాతà±à°°à°¿|ఉదయం|మధà±à°¯à°¾à°¹à±à°¨à°‚|సాయంతà±à°°à°‚/,
14605 meridiemHour : function (hour, meridiem) {
14606 if (hour === 12) {
14607 hour = 0;
14608 }
14609 if (meridiem === 'రాతà±à°°à°¿') {
14610 return hour < 4 ? hour : hour + 12;
14611 } else if (meridiem === 'ఉదయం') {
14612 return hour;
14613 } else if (meridiem === 'మధà±à°¯à°¾à°¹à±à°¨à°‚') {
14614 return hour >= 10 ? hour : hour + 12;
14615 } else if (meridiem === 'సాయంతà±à°°à°‚') {
14616 return hour + 12;
14617 }
14618 },
14619 meridiem : function (hour, minute, isLower) {
14620 if (hour < 4) {
14621 return 'రాతà±à°°à°¿';
14622 } else if (hour < 10) {
14623 return 'ఉదయం';
14624 } else if (hour < 17) {
14625 return 'మధà±à°¯à°¾à°¹à±à°¨à°‚';
14626 } else if (hour < 20) {
14627 return 'సాయంతà±à°°à°‚';
14628 } else {
14629 return 'రాతà±à°°à°¿';
14630 }
14631 },
14632 week : {
14633 dow : 0, // Sunday is the first day of the week.
14634 doy : 6 // The week that contains Jan 1st is the first week of the year.
14635 }
14636 });
14637
14638 return te;
14639
14640})));
14641
14642
14643/***/ }),
14644/* 115 */
14645/***/ (function(module, exports, __webpack_require__) {
14646
14647//! moment.js locale configuration
14648
14649;(function (global, factory) {
14650 true ? factory(__webpack_require__(0)) :
14651 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14652 factory(global.moment)
14653}(this, (function (moment) { 'use strict';
14654
14655
14656 var tet = moment.defineLocale('tet', {
14657 months : 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru'.split('_'),
14658 monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
14659 weekdays : 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu'.split('_'),
14660 weekdaysShort : 'Dom_Seg_Ters_Kua_Kint_Sest_Sab'.split('_'),
14661 weekdaysMin : 'Do_Seg_Te_Ku_Ki_Ses_Sa'.split('_'),
14662 longDateFormat : {
14663 LT : 'HH:mm',
14664 LTS : 'HH:mm:ss',
14665 L : 'DD/MM/YYYY',
14666 LL : 'D MMMM YYYY',
14667 LLL : 'D MMMM YYYY HH:mm',
14668 LLLL : 'dddd, D MMMM YYYY HH:mm'
14669 },
14670 calendar : {
14671 sameDay: '[Ohin iha] LT',
14672 nextDay: '[Aban iha] LT',
14673 nextWeek: 'dddd [iha] LT',
14674 lastDay: '[Horiseik iha] LT',
14675 lastWeek: 'dddd [semana kotuk] [iha] LT',
14676 sameElse: 'L'
14677 },
14678 relativeTime : {
14679 future : 'iha %s',
14680 past : '%s liuba',
14681 s : 'minutu balun',
14682 ss : 'minutu %d',
14683 m : 'minutu ida',
14684 mm : 'minutu %d',
14685 h : 'oras ida',
14686 hh : 'oras %d',
14687 d : 'loron ida',
14688 dd : 'loron %d',
14689 M : 'fulan ida',
14690 MM : 'fulan %d',
14691 y : 'tinan ida',
14692 yy : 'tinan %d'
14693 },
14694 dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
14695 ordinal : function (number) {
14696 var b = number % 10,
14697 output = (~~(number % 100 / 10) === 1) ? 'th' :
14698 (b === 1) ? 'st' :
14699 (b === 2) ? 'nd' :
14700 (b === 3) ? 'rd' : 'th';
14701 return number + output;
14702 },
14703 week : {
14704 dow : 1, // Monday is the first day of the week.
14705 doy : 4 // The week that contains Jan 4th is the first week of the year.
14706 }
14707 });
14708
14709 return tet;
14710
14711})));
14712
14713
14714/***/ }),
14715/* 116 */
14716/***/ (function(module, exports, __webpack_require__) {
14717
14718//! moment.js locale configuration
14719
14720;(function (global, factory) {
14721 true ? factory(__webpack_require__(0)) :
14722 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14723 factory(global.moment)
14724}(this, (function (moment) { 'use strict';
14725
14726
14727 var suffixes = {
14728 0: '-ум',
14729 1: '-ум',
14730 2: '-юм',
14731 3: '-юм',
14732 4: '-ум',
14733 5: '-ум',
14734 6: '-ум',
14735 7: '-ум',
14736 8: '-ум',
14737 9: '-ум',
14738 10: '-ум',
14739 12: '-ум',
14740 13: '-ум',
14741 20: '-ум',
14742 30: '-юм',
14743 40: '-ум',
14744 50: '-ум',
14745 60: '-ум',
14746 70: '-ум',
14747 80: '-ум',
14748 90: '-ум',
14749 100: '-ум'
14750 };
14751
14752 var tg = moment.defineLocale('tg', {
14753 months : 'Ñнвар_феврал_март_апрел_май_июн_июл_авгуÑÑ‚_ÑентÑбр_октÑбр_ноÑбр_декабр'.split('_'),
14754 monthsShort : 'Ñнв_фев_мар_апр_май_июн_июл_авг_Ñен_окт_ноÑ_дек'.split('_'),
14755 weekdays : 'Ñкшанбе_душанбе_Ñешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе'.split('_'),
14756 weekdaysShort : 'Ñшб_дшб_Ñшб_чшб_пшб_ҷум_шнб'.split('_'),
14757 weekdaysMin : 'Ñш_дш_Ñш_чш_пш_ҷм_шб'.split('_'),
14758 longDateFormat : {
14759 LT : 'HH:mm',
14760 LTS : 'HH:mm:ss',
14761 L : 'DD/MM/YYYY',
14762 LL : 'D MMMM YYYY',
14763 LLL : 'D MMMM YYYY HH:mm',
14764 LLLL : 'dddd, D MMMM YYYY HH:mm'
14765 },
14766 calendar : {
14767 sameDay : '[Имрӯз Ñоати] LT',
14768 nextDay : '[Пагоҳ Ñоати] LT',
14769 lastDay : '[Дирӯз Ñоати] LT',
14770 nextWeek : 'dddd[и] [ҳафтаи оÑнда Ñоати] LT',
14771 lastWeek : 'dddd[и] [ҳафтаи гузашта Ñоати] LT',
14772 sameElse : 'L'
14773 },
14774 relativeTime : {
14775 future : 'баъди %s',
14776 past : '%s пеш',
14777 s : 'Ñкчанд ÑониÑ',
14778 m : 'Ñк дақиқа',
14779 mm : '%d дақиқа',
14780 h : 'Ñк Ñоат',
14781 hh : '%d Ñоат',
14782 d : 'Ñк рӯз',
14783 dd : '%d рӯз',
14784 M : 'Ñк моҳ',
14785 MM : '%d моҳ',
14786 y : 'Ñк Ñол',
14787 yy : '%d Ñол'
14788 },
14789 meridiemParse: /шаб|Ñубҳ|рӯз|бегоҳ/,
14790 meridiemHour: function (hour, meridiem) {
14791 if (hour === 12) {
14792 hour = 0;
14793 }
14794 if (meridiem === 'шаб') {
14795 return hour < 4 ? hour : hour + 12;
14796 } else if (meridiem === 'Ñубҳ') {
14797 return hour;
14798 } else if (meridiem === 'рӯз') {
14799 return hour >= 11 ? hour : hour + 12;
14800 } else if (meridiem === 'бегоҳ') {
14801 return hour + 12;
14802 }
14803 },
14804 meridiem: function (hour, minute, isLower) {
14805 if (hour < 4) {
14806 return 'шаб';
14807 } else if (hour < 11) {
14808 return 'Ñубҳ';
14809 } else if (hour < 16) {
14810 return 'рӯз';
14811 } else if (hour < 19) {
14812 return 'бегоҳ';
14813 } else {
14814 return 'шаб';
14815 }
14816 },
14817 dayOfMonthOrdinalParse: /\d{1,2}-(ум|юм)/,
14818 ordinal: function (number) {
14819 var a = number % 10,
14820 b = number >= 100 ? 100 : null;
14821 return number + (suffixes[number] || suffixes[a] || suffixes[b]);
14822 },
14823 week : {
14824 dow : 1, // Monday is the first day of the week.
14825 doy : 7 // The week that contains Jan 1th is the first week of the year.
14826 }
14827 });
14828
14829 return tg;
14830
14831})));
14832
14833
14834/***/ }),
14835/* 117 */
14836/***/ (function(module, exports, __webpack_require__) {
14837
14838//! moment.js locale configuration
14839
14840;(function (global, factory) {
14841 true ? factory(__webpack_require__(0)) :
14842 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14843 factory(global.moment)
14844}(this, (function (moment) { 'use strict';
14845
14846
14847 var th = moment.defineLocale('th', {
14848 months : 'มà¸à¸£à¸²à¸„ม_à¸à¸¸à¸¡à¸ าพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_à¸à¸£à¸à¸Žà¸²à¸„ม_สิงหาคม_à¸à¸±à¸™à¸¢à¸²à¸¢à¸™_ตุลาคม_พฤศจิà¸à¸²à¸¢à¸™_ธันวาคม'.split('_'),
14849 monthsShort : 'ม.ค._à¸.พ._มี.ค._เม.ย._พ.ค._มิ.ย._à¸.ค._ส.ค._à¸.ย._ต.ค._พ.ย._ธ.ค.'.split('_'),
14850 monthsParseExact: true,
14851 weekdays : 'à¸à¸²à¸—ิตย์_จันทร์_à¸à¸±à¸‡à¸„าร_พุธ_พฤหัสบดี_ศุà¸à¸£à¹Œ_เสาร์'.split('_'),
14852 weekdaysShort : 'à¸à¸²à¸—ิตย์_จันทร์_à¸à¸±à¸‡à¸„าร_พุธ_พฤหัส_ศุà¸à¸£à¹Œ_เสาร์'.split('_'), // yes, three characters difference
14853 weekdaysMin : 'à¸à¸²._จ._à¸._พ._พฤ._ศ._ส.'.split('_'),
14854 weekdaysParseExact : true,
14855 longDateFormat : {
14856 LT : 'H:mm',
14857 LTS : 'H:mm:ss',
14858 L : 'DD/MM/YYYY',
14859 LL : 'D MMMM YYYY',
14860 LLL : 'D MMMM YYYY เวลา H:mm',
14861 LLLL : 'วันddddที่ D MMMM YYYY เวลา H:mm'
14862 },
14863 meridiemParse: /à¸à¹ˆà¸à¸™à¹€à¸—ี่ยง|หลังเที่ยง/,
14864 isPM: function (input) {
14865 return input === 'หลังเที่ยง';
14866 },
14867 meridiem : function (hour, minute, isLower) {
14868 if (hour < 12) {
14869 return 'à¸à¹ˆà¸à¸™à¹€à¸—ี่ยง';
14870 } else {
14871 return 'หลังเที่ยง';
14872 }
14873 },
14874 calendar : {
14875 sameDay : '[วันนี้ เวลา] LT',
14876 nextDay : '[พรุ่งนี้ เวลา] LT',
14877 nextWeek : 'dddd[หน้า เวลา] LT',
14878 lastDay : '[เมื่à¸à¸§à¸²à¸™à¸™à¸µà¹‰ เวลา] LT',
14879 lastWeek : '[วัน]dddd[ที่à¹à¸¥à¹‰à¸§ เวลา] LT',
14880 sameElse : 'L'
14881 },
14882 relativeTime : {
14883 future : 'à¸à¸µà¸ %s',
14884 past : '%sที่à¹à¸¥à¹‰à¸§',
14885 s : 'ไม่à¸à¸µà¹ˆà¸§à¸´à¸™à¸²à¸—ี',
14886 ss : '%d วินาที',
14887 m : '1 นาที',
14888 mm : '%d นาที',
14889 h : '1 ชั่วโมง',
14890 hh : '%d ชั่วโมง',
14891 d : '1 วัน',
14892 dd : '%d วัน',
14893 M : '1 เดืà¸à¸™',
14894 MM : '%d เดืà¸à¸™',
14895 y : '1 ปี',
14896 yy : '%d ปี'
14897 }
14898 });
14899
14900 return th;
14901
14902})));
14903
14904
14905/***/ }),
14906/* 118 */
14907/***/ (function(module, exports, __webpack_require__) {
14908
14909//! moment.js locale configuration
14910
14911;(function (global, factory) {
14912 true ? factory(__webpack_require__(0)) :
14913 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14914 factory(global.moment)
14915}(this, (function (moment) { 'use strict';
14916
14917
14918 var tlPh = moment.defineLocale('tl-ph', {
14919 months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
14920 monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
14921 weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
14922 weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
14923 weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
14924 longDateFormat : {
14925 LT : 'HH:mm',
14926 LTS : 'HH:mm:ss',
14927 L : 'MM/D/YYYY',
14928 LL : 'MMMM D, YYYY',
14929 LLL : 'MMMM D, YYYY HH:mm',
14930 LLLL : 'dddd, MMMM DD, YYYY HH:mm'
14931 },
14932 calendar : {
14933 sameDay: 'LT [ngayong araw]',
14934 nextDay: '[Bukas ng] LT',
14935 nextWeek: 'LT [sa susunod na] dddd',
14936 lastDay: 'LT [kahapon]',
14937 lastWeek: 'LT [noong nakaraang] dddd',
14938 sameElse: 'L'
14939 },
14940 relativeTime : {
14941 future : 'sa loob ng %s',
14942 past : '%s ang nakalipas',
14943 s : 'ilang segundo',
14944 ss : '%d segundo',
14945 m : 'isang minuto',
14946 mm : '%d minuto',
14947 h : 'isang oras',
14948 hh : '%d oras',
14949 d : 'isang araw',
14950 dd : '%d araw',
14951 M : 'isang buwan',
14952 MM : '%d buwan',
14953 y : 'isang taon',
14954 yy : '%d taon'
14955 },
14956 dayOfMonthOrdinalParse: /\d{1,2}/,
14957 ordinal : function (number) {
14958 return number;
14959 },
14960 week : {
14961 dow : 1, // Monday is the first day of the week.
14962 doy : 4 // The week that contains Jan 4th is the first week of the year.
14963 }
14964 });
14965
14966 return tlPh;
14967
14968})));
14969
14970
14971/***/ }),
14972/* 119 */
14973/***/ (function(module, exports, __webpack_require__) {
14974
14975//! moment.js locale configuration
14976
14977;(function (global, factory) {
14978 true ? factory(__webpack_require__(0)) :
14979 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
14980 factory(global.moment)
14981}(this, (function (moment) { 'use strict';
14982
14983
14984 var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
14985
14986 function translateFuture(output) {
14987 var time = output;
14988 time = (output.indexOf('jaj') !== -1) ?
14989 time.slice(0, -3) + 'leS' :
14990 (output.indexOf('jar') !== -1) ?
14991 time.slice(0, -3) + 'waQ' :
14992 (output.indexOf('DIS') !== -1) ?
14993 time.slice(0, -3) + 'nem' :
14994 time + ' pIq';
14995 return time;
14996 }
14997
14998 function translatePast(output) {
14999 var time = output;
15000 time = (output.indexOf('jaj') !== -1) ?
15001 time.slice(0, -3) + 'Hu’' :
15002 (output.indexOf('jar') !== -1) ?
15003 time.slice(0, -3) + 'wen' :
15004 (output.indexOf('DIS') !== -1) ?
15005 time.slice(0, -3) + 'ben' :
15006 time + ' ret';
15007 return time;
15008 }
15009
15010 function translate(number, withoutSuffix, string, isFuture) {
15011 var numberNoun = numberAsNoun(number);
15012 switch (string) {
15013 case 'ss':
15014 return numberNoun + ' lup';
15015 case 'mm':
15016 return numberNoun + ' tup';
15017 case 'hh':
15018 return numberNoun + ' rep';
15019 case 'dd':
15020 return numberNoun + ' jaj';
15021 case 'MM':
15022 return numberNoun + ' jar';
15023 case 'yy':
15024 return numberNoun + ' DIS';
15025 }
15026 }
15027
15028 function numberAsNoun(number) {
15029 var hundred = Math.floor((number % 1000) / 100),
15030 ten = Math.floor((number % 100) / 10),
15031 one = number % 10,
15032 word = '';
15033 if (hundred > 0) {
15034 word += numbersNouns[hundred] + 'vatlh';
15035 }
15036 if (ten > 0) {
15037 word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH';
15038 }
15039 if (one > 0) {
15040 word += ((word !== '') ? ' ' : '') + numbersNouns[one];
15041 }
15042 return (word === '') ? 'pagh' : word;
15043 }
15044
15045 var tlh = moment.defineLocale('tlh', {
15046 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('_'),
15047 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('_'),
15048 monthsParseExact : true,
15049 weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
15050 weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
15051 weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
15052 longDateFormat : {
15053 LT : 'HH:mm',
15054 LTS : 'HH:mm:ss',
15055 L : 'DD.MM.YYYY',
15056 LL : 'D MMMM YYYY',
15057 LLL : 'D MMMM YYYY HH:mm',
15058 LLLL : 'dddd, D MMMM YYYY HH:mm'
15059 },
15060 calendar : {
15061 sameDay: '[DaHjaj] LT',
15062 nextDay: '[wa’leS] LT',
15063 nextWeek: 'LLL',
15064 lastDay: '[wa’Hu’] LT',
15065 lastWeek: 'LLL',
15066 sameElse: 'L'
15067 },
15068 relativeTime : {
15069 future : translateFuture,
15070 past : translatePast,
15071 s : 'puS lup',
15072 ss : translate,
15073 m : 'wa’ tup',
15074 mm : translate,
15075 h : 'wa’ rep',
15076 hh : translate,
15077 d : 'wa’ jaj',
15078 dd : translate,
15079 M : 'wa’ jar',
15080 MM : translate,
15081 y : 'wa’ DIS',
15082 yy : translate
15083 },
15084 dayOfMonthOrdinalParse: /\d{1,2}\./,
15085 ordinal : '%d.',
15086 week : {
15087 dow : 1, // Monday is the first day of the week.
15088 doy : 4 // The week that contains Jan 4th is the first week of the year.
15089 }
15090 });
15091
15092 return tlh;
15093
15094})));
15095
15096
15097/***/ }),
15098/* 120 */
15099/***/ (function(module, exports, __webpack_require__) {
15100
15101
15102;(function (global, factory) {
15103 true ? factory(__webpack_require__(0)) :
15104 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15105 factory(global.moment)
15106}(this, (function (moment) { 'use strict';
15107
15108 var suffixes = {
15109 1: '\'inci',
15110 5: '\'inci',
15111 8: '\'inci',
15112 70: '\'inci',
15113 80: '\'inci',
15114 2: '\'nci',
15115 7: '\'nci',
15116 20: '\'nci',
15117 50: '\'nci',
15118 3: '\'üncü',
15119 4: '\'üncü',
15120 100: '\'üncü',
15121 6: '\'ncı',
15122 9: '\'uncu',
15123 10: '\'uncu',
15124 30: '\'uncu',
15125 60: '\'ıncı',
15126 90: '\'ıncı'
15127 };
15128
15129 var tr = moment.defineLocale('tr', {
15130 months : 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
15131 monthsShort : 'Oca_Åžub_Mar_Nis_May_Haz_Tem_AÄŸu_Eyl_Eki_Kas_Ara'.split('_'),
15132 weekdays : 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
15133 weekdaysShort : 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
15134 weekdaysMin : 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
15135 longDateFormat : {
15136 LT : 'HH:mm',
15137 LTS : 'HH:mm:ss',
15138 L : 'DD.MM.YYYY',
15139 LL : 'D MMMM YYYY',
15140 LLL : 'D MMMM YYYY HH:mm',
15141 LLLL : 'dddd, D MMMM YYYY HH:mm'
15142 },
15143 calendar : {
15144 sameDay : '[bugün saat] LT',
15145 nextDay : '[yarın saat] LT',
15146 nextWeek : '[gelecek] dddd [saat] LT',
15147 lastDay : '[dün] LT',
15148 lastWeek : '[geçen] dddd [saat] LT',
15149 sameElse : 'L'
15150 },
15151 relativeTime : {
15152 future : '%s sonra',
15153 past : '%s önce',
15154 s : 'birkaç saniye',
15155 ss : '%d saniye',
15156 m : 'bir dakika',
15157 mm : '%d dakika',
15158 h : 'bir saat',
15159 hh : '%d saat',
15160 d : 'bir gün',
15161 dd : '%d gün',
15162 M : 'bir ay',
15163 MM : '%d ay',
15164 y : 'bir yıl',
15165 yy : '%d yıl'
15166 },
15167 ordinal: function (number, period) {
15168 switch (period) {
15169 case 'd':
15170 case 'D':
15171 case 'Do':
15172 case 'DD':
15173 return number;
15174 default:
15175 if (number === 0) { // special case for zero
15176 return number + '\'ıncı';
15177 }
15178 var a = number % 10,
15179 b = number % 100 - a,
15180 c = number >= 100 ? 100 : null;
15181 return number + (suffixes[a] || suffixes[b] || suffixes[c]);
15182 }
15183 },
15184 week : {
15185 dow : 1, // Monday is the first day of the week.
15186 doy : 7 // The week that contains Jan 1st is the first week of the year.
15187 }
15188 });
15189
15190 return tr;
15191
15192})));
15193
15194
15195/***/ }),
15196/* 121 */
15197/***/ (function(module, exports, __webpack_require__) {
15198
15199//! moment.js locale configuration
15200
15201;(function (global, factory) {
15202 true ? factory(__webpack_require__(0)) :
15203 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15204 factory(global.moment)
15205}(this, (function (moment) { 'use strict';
15206
15207
15208 // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
15209 // This is currently too difficult (maybe even impossible) to add.
15210 var tzl = moment.defineLocale('tzl', {
15211 months : 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'),
15212 monthsShort : 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
15213 weekdays : 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
15214 weekdaysShort : 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
15215 weekdaysMin : 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
15216 longDateFormat : {
15217 LT : 'HH.mm',
15218 LTS : 'HH.mm.ss',
15219 L : 'DD.MM.YYYY',
15220 LL : 'D. MMMM [dallas] YYYY',
15221 LLL : 'D. MMMM [dallas] YYYY HH.mm',
15222 LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
15223 },
15224 meridiemParse: /d\'o|d\'a/i,
15225 isPM : function (input) {
15226 return 'd\'o' === input.toLowerCase();
15227 },
15228 meridiem : function (hours, minutes, isLower) {
15229 if (hours > 11) {
15230 return isLower ? 'd\'o' : 'D\'O';
15231 } else {
15232 return isLower ? 'd\'a' : 'D\'A';
15233 }
15234 },
15235 calendar : {
15236 sameDay : '[oxhi à ] LT',
15237 nextDay : '[demà à ] LT',
15238 nextWeek : 'dddd [Ã ] LT',
15239 lastDay : '[ieiri à ] LT',
15240 lastWeek : '[sür el] dddd [lasteu à ] LT',
15241 sameElse : 'L'
15242 },
15243 relativeTime : {
15244 future : 'osprei %s',
15245 past : 'ja%s',
15246 s : processRelativeTime,
15247 ss : processRelativeTime,
15248 m : processRelativeTime,
15249 mm : processRelativeTime,
15250 h : processRelativeTime,
15251 hh : processRelativeTime,
15252 d : processRelativeTime,
15253 dd : processRelativeTime,
15254 M : processRelativeTime,
15255 MM : processRelativeTime,
15256 y : processRelativeTime,
15257 yy : processRelativeTime
15258 },
15259 dayOfMonthOrdinalParse: /\d{1,2}\./,
15260 ordinal : '%d.',
15261 week : {
15262 dow : 1, // Monday is the first day of the week.
15263 doy : 4 // The week that contains Jan 4th is the first week of the year.
15264 }
15265 });
15266
15267 function processRelativeTime(number, withoutSuffix, key, isFuture) {
15268 var format = {
15269 's': ['viensas secunds', '\'iensas secunds'],
15270 'ss': [number + ' secunds', '' + number + ' secunds'],
15271 'm': ['\'n mÃut', '\'iens mÃut'],
15272 'mm': [number + ' mÃuts', '' + number + ' mÃuts'],
15273 'h': ['\'n þora', '\'iensa þora'],
15274 'hh': [number + ' þoras', '' + number + ' þoras'],
15275 'd': ['\'n ziua', '\'iensa ziua'],
15276 'dd': [number + ' ziuas', '' + number + ' ziuas'],
15277 'M': ['\'n mes', '\'iens mes'],
15278 'MM': [number + ' mesen', '' + number + ' mesen'],
15279 'y': ['\'n ar', '\'iens ar'],
15280 'yy': [number + ' ars', '' + number + ' ars']
15281 };
15282 return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]);
15283 }
15284
15285 return tzl;
15286
15287})));
15288
15289
15290/***/ }),
15291/* 122 */
15292/***/ (function(module, exports, __webpack_require__) {
15293
15294//! moment.js locale configuration
15295
15296;(function (global, factory) {
15297 true ? factory(__webpack_require__(0)) :
15298 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15299 factory(global.moment)
15300}(this, (function (moment) { 'use strict';
15301
15302
15303 var tzmLatn = moment.defineLocale('tzm-latn', {
15304 months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
15305 monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
15306 weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'),
15307 weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'),
15308 weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'),
15309 longDateFormat : {
15310 LT : 'HH:mm',
15311 LTS : 'HH:mm:ss',
15312 L : 'DD/MM/YYYY',
15313 LL : 'D MMMM YYYY',
15314 LLL : 'D MMMM YYYY HH:mm',
15315 LLLL : 'dddd D MMMM YYYY HH:mm'
15316 },
15317 calendar : {
15318 sameDay: '[asdkh g] LT',
15319 nextDay: '[aska g] LT',
15320 nextWeek: 'dddd [g] LT',
15321 lastDay: '[assant g] LT',
15322 lastWeek: 'dddd [g] LT',
15323 sameElse: 'L'
15324 },
15325 relativeTime : {
15326 future : 'dadkh s yan %s',
15327 past : 'yan %s',
15328 s : 'imik',
15329 ss : '%d imik',
15330 m : 'minuá¸',
15331 mm : '%d minuá¸',
15332 h : 'saɛa',
15333 hh : '%d tassaɛin',
15334 d : 'ass',
15335 dd : '%d ossan',
15336 M : 'ayowr',
15337 MM : '%d iyyirn',
15338 y : 'asgas',
15339 yy : '%d isgasn'
15340 },
15341 week : {
15342 dow : 6, // Saturday is the first day of the week.
15343 doy : 12 // The week that contains Jan 1st is the first week of the year.
15344 }
15345 });
15346
15347 return tzmLatn;
15348
15349})));
15350
15351
15352/***/ }),
15353/* 123 */
15354/***/ (function(module, exports, __webpack_require__) {
15355
15356//! moment.js locale configuration
15357
15358;(function (global, factory) {
15359 true ? factory(__webpack_require__(0)) :
15360 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15361 factory(global.moment)
15362}(this, (function (moment) { 'use strict';
15363
15364
15365 var tzm = moment.defineLocale('tzm', {
15366 months : 'ⵉâµâµâ´°âµ¢âµ”_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓâµâµ¢âµ“_ⵢⵓâµâµ¢âµ“âµ£_ⵖⵓⵛⵜ_ⵛⵓⵜⴰâµâ´±âµ‰âµ”_ⴽⵟⵓⴱⵕ_âµâµ“ⵡⴰâµâ´±âµ‰âµ”_ⴷⵓⵊâµâ´±âµ‰âµ”'.split('_'),
15367 monthsShort : 'ⵉâµâµâ´°âµ¢âµ”_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓâµâµ¢âµ“_ⵢⵓâµâµ¢âµ“âµ£_ⵖⵓⵛⵜ_ⵛⵓⵜⴰâµâ´±âµ‰âµ”_ⴽⵟⵓⴱⵕ_âµâµ“ⵡⴰâµâ´±âµ‰âµ”_ⴷⵓⵊâµâ´±âµ‰âµ”'.split('_'),
15368 weekdays : 'ⴰⵙⴰⵎⴰⵙ_â´°âµ¢âµâ´°âµ™_ⴰⵙⵉâµâ´°âµ™_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
15369 weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_â´°âµ¢âµâ´°âµ™_ⴰⵙⵉâµâ´°âµ™_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
15370 weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_â´°âµ¢âµâ´°âµ™_ⴰⵙⵉâµâ´°âµ™_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
15371 longDateFormat : {
15372 LT : 'HH:mm',
15373 LTS: 'HH:mm:ss',
15374 L : 'DD/MM/YYYY',
15375 LL : 'D MMMM YYYY',
15376 LLL : 'D MMMM YYYY HH:mm',
15377 LLLL : 'dddd D MMMM YYYY HH:mm'
15378 },
15379 calendar : {
15380 sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
15381 nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
15382 nextWeek: 'dddd [â´´] LT',
15383 lastDay: '[ⴰⵚⴰâµâµœ â´´] LT',
15384 lastWeek: 'dddd [â´´] LT',
15385 sameElse: 'L'
15386 },
15387 relativeTime : {
15388 future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵠ%s',
15389 past : 'ⵢⴰⵠ%s',
15390 s : 'ⵉⵎⵉⴽ',
15391 ss : '%d ⵉⵎⵉⴽ',
15392 m : 'ⵎⵉâµâµ“â´º',
15393 mm : '%d ⵎⵉâµâµ“â´º',
15394 h : 'ⵙⴰⵄⴰ',
15395 hh : '%d ⵜⴰⵙⵙⴰⵄⵉâµ',
15396 d : 'ⴰⵙⵙ',
15397 dd : '%d oⵙⵙⴰâµ',
15398 M : 'ⴰⵢoⵓⵔ',
15399 MM : '%d ⵉⵢⵢⵉⵔâµ',
15400 y : 'ⴰⵙⴳⴰⵙ',
15401 yy : '%d ⵉⵙⴳⴰⵙâµ'
15402 },
15403 week : {
15404 dow : 6, // Saturday is the first day of the week.
15405 doy : 12 // The week that contains Jan 1st is the first week of the year.
15406 }
15407 });
15408
15409 return tzm;
15410
15411})));
15412
15413
15414/***/ }),
15415/* 124 */
15416/***/ (function(module, exports, __webpack_require__) {
15417
15418//! moment.js language configuration
15419
15420;(function (global, factory) {
15421 true ? factory(__webpack_require__(0)) :
15422 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15423 factory(global.moment)
15424}(this, (function (moment) { 'use strict';
15425
15426
15427 var ugCn = moment.defineLocale('ug-cn', {
15428 months: 'يانۋار_ÙÛۋرال_مارت_ئاپرÛÙ„_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سÛنتەبىر_ئۆكتەبىر_نويابىر_دÛكابىر'.split(
15429 '_'
15430 ),
15431 monthsShort: 'يانۋار_ÙÛۋرال_مارت_ئاپرÛÙ„_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سÛنتەبىر_ئۆكتەبىر_نويابىر_دÛكابىر'.split(
15432 '_'
15433 ),
15434 weekdays: 'يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە'.split(
15435 '_'
15436 ),
15437 weekdaysShort: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
15438 weekdaysMin: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
15439 longDateFormat: {
15440 LT: 'HH:mm',
15441 LTS: 'HH:mm:ss',
15442 L: 'YYYY-MM-DD',
15443 LL: 'YYYY-يىلىM-ئاينىÚD-كۈنى',
15444 LLL: 'YYYY-يىلىM-ئاينىÚD-كۈنى، HH:mm',
15445 LLLL: 'ddddØŒ YYYY-يىلىM-ئاينىÚD-كۈنى، HH:mm'
15446 },
15447 meridiemParse: /ÙŠÛرىم ÙƒÛÚ†Û•|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن ÙƒÛيىن|ÙƒÛ•Ú†/,
15448 meridiemHour: function (hour, meridiem) {
15449 if (hour === 12) {
15450 hour = 0;
15451 }
15452 if (
15453 meridiem === 'ÙŠÛرىم ÙƒÛÚ†Û•' ||
15454 meridiem === 'سەھەر' ||
15455 meridiem === 'چۈشتىن بۇرۇن'
15456 ) {
15457 return hour;
15458 } else if (meridiem === 'چۈشتىن ÙƒÛيىن' || meridiem === 'ÙƒÛ•Ú†') {
15459 return hour + 12;
15460 } else {
15461 return hour >= 11 ? hour : hour + 12;
15462 }
15463 },
15464 meridiem: function (hour, minute, isLower) {
15465 var hm = hour * 100 + minute;
15466 if (hm < 600) {
15467 return 'ÙŠÛرىم ÙƒÛÚ†Û•';
15468 } else if (hm < 900) {
15469 return 'سەھەر';
15470 } else if (hm < 1130) {
15471 return 'چۈشتىن بۇرۇن';
15472 } else if (hm < 1230) {
15473 return 'چۈش';
15474 } else if (hm < 1800) {
15475 return 'چۈشتىن ÙƒÛيىن';
15476 } else {
15477 return 'ÙƒÛ•Ú†';
15478 }
15479 },
15480 calendar: {
15481 sameDay: '[بۈگۈن سائەت] LT',
15482 nextDay: '[ئەتە سائەت] LT',
15483 nextWeek: '[ÙƒÛلەركى] dddd [سائەت] LT',
15484 lastDay: '[تۆنۈگۈن] LT',
15485 lastWeek: '[ئالدىنقى] dddd [سائەت] LT',
15486 sameElse: 'L'
15487 },
15488 relativeTime: {
15489 future: '%s ÙƒÛيىن',
15490 past: '%s بۇرۇن',
15491 s: 'Ù†Û•Ú†Ú†Û• سÛكونت',
15492 ss: '%d سÛكونت',
15493 m: 'بىر مىنۇت',
15494 mm: '%d مىنۇت',
15495 h: 'بىر سائەت',
15496 hh: '%d سائەت',
15497 d: 'بىر كۈن',
15498 dd: '%d ÙƒÛˆÙ†',
15499 M: 'بىر ئاي',
15500 MM: '%d ئاي',
15501 y: 'بىر يىل',
15502 yy: '%d يىل'
15503 },
15504
15505 dayOfMonthOrdinalParse: /\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,
15506 ordinal: function (number, period) {
15507 switch (period) {
15508 case 'd':
15509 case 'D':
15510 case 'DDD':
15511 return number + '-كۈنى';
15512 case 'w':
15513 case 'W':
15514 return number + '-ھەپتە';
15515 default:
15516 return number;
15517 }
15518 },
15519 preparse: function (string) {
15520 return string.replace(/،/g, ',');
15521 },
15522 postformat: function (string) {
15523 return string.replace(/,/g, '،');
15524 },
15525 week: {
15526 // GB/T 7408-1994《数æ®å…ƒå’Œäº¤æ¢æ ¼å¼Â·ä¿¡æ¯äº¤æ¢Â·æ—¥æœŸå’Œæ—¶é—´è¡¨ç¤ºæ³•ã€‹ä¸ŽISO 8601:1988ç‰æ•ˆ
15527 dow: 1, // Monday is the first day of the week.
15528 doy: 7 // The week that contains Jan 1st is the first week of the year.
15529 }
15530 });
15531
15532 return ugCn;
15533
15534})));
15535
15536
15537/***/ }),
15538/* 125 */
15539/***/ (function(module, exports, __webpack_require__) {
15540
15541//! moment.js locale configuration
15542
15543;(function (global, factory) {
15544 true ? factory(__webpack_require__(0)) :
15545 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15546 factory(global.moment)
15547}(this, (function (moment) { 'use strict';
15548
15549
15550 function plural(word, num) {
15551 var forms = word.split('_');
15552 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]);
15553 }
15554 function relativeTimeWithPlural(number, withoutSuffix, key) {
15555 var format = {
15556 'ss': withoutSuffix ? 'Ñекунда_Ñекунди_Ñекунд' : 'Ñекунду_Ñекунди_Ñекунд',
15557 'mm': withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
15558 'hh': withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
15559 'dd': 'день_дні_днів',
15560 'MM': 'міÑÑць_міÑÑці_міÑÑців',
15561 'yy': 'рік_роки_років'
15562 };
15563 if (key === 'm') {
15564 return withoutSuffix ? 'хвилина' : 'хвилину';
15565 }
15566 else if (key === 'h') {
15567 return withoutSuffix ? 'година' : 'годину';
15568 }
15569 else {
15570 return number + ' ' + plural(format[key], +number);
15571 }
15572 }
15573 function weekdaysCaseReplace(m, format) {
15574 var weekdays = {
15575 'nominative': 'неділÑ_понеділок_вівторок_Ñереда_четвер_п’ÑтницÑ_Ñубота'.split('_'),
15576 'accusative': 'неділю_понеділок_вівторок_Ñереду_четвер_п’Ñтницю_Ñуботу'.split('_'),
15577 'genitive': 'неділі_понеділка_вівторка_Ñереди_четверга_п’Ñтниці_Ñуботи'.split('_')
15578 };
15579
15580 if (!m) {
15581 return weekdays['nominative'];
15582 }
15583
15584 var nounCase = (/(\[[ВвУу]\]) ?dddd/).test(format) ?
15585 'accusative' :
15586 ((/\[?(?:минулої|наÑтупної)? ?\] ?dddd/).test(format) ?
15587 'genitive' :
15588 'nominative');
15589 return weekdays[nounCase][m.day()];
15590 }
15591 function processHoursFunction(str) {
15592 return function () {
15593 return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
15594 };
15595 }
15596
15597 var uk = moment.defineLocale('uk', {
15598 months : {
15599 'format': 'ÑічнÑ_лютого_березнÑ_квітнÑ_травнÑ_червнÑ_липнÑ_ÑерпнÑ_вереÑнÑ_жовтнÑ_лиÑтопада_груднÑ'.split('_'),
15600 'standalone': 'Ñічень_лютий_березень_квітень_травень_червень_липень_Ñерпень_вереÑень_жовтень_лиÑтопад_грудень'.split('_')
15601 },
15602 monthsShort : 'Ñіч_лют_бер_квіт_трав_черв_лип_Ñерп_вер_жовт_лиÑÑ‚_груд'.split('_'),
15603 weekdays : weekdaysCaseReplace,
15604 weekdaysShort : 'нд_пн_вт_ÑÑ€_чт_пт_Ñб'.split('_'),
15605 weekdaysMin : 'нд_пн_вт_ÑÑ€_чт_пт_Ñб'.split('_'),
15606 longDateFormat : {
15607 LT : 'HH:mm',
15608 LTS : 'HH:mm:ss',
15609 L : 'DD.MM.YYYY',
15610 LL : 'D MMMM YYYY р.',
15611 LLL : 'D MMMM YYYY р., HH:mm',
15612 LLLL : 'dddd, D MMMM YYYY р., HH:mm'
15613 },
15614 calendar : {
15615 sameDay: processHoursFunction('[Сьогодні '),
15616 nextDay: processHoursFunction('[Завтра '),
15617 lastDay: processHoursFunction('[Вчора '),
15618 nextWeek: processHoursFunction('[У] dddd ['),
15619 lastWeek: function () {
15620 switch (this.day()) {
15621 case 0:
15622 case 3:
15623 case 5:
15624 case 6:
15625 return processHoursFunction('[Минулої] dddd [').call(this);
15626 case 1:
15627 case 2:
15628 case 4:
15629 return processHoursFunction('[Минулого] dddd [').call(this);
15630 }
15631 },
15632 sameElse: 'L'
15633 },
15634 relativeTime : {
15635 future : 'за %s',
15636 past : '%s тому',
15637 s : 'декілька Ñекунд',
15638 ss : relativeTimeWithPlural,
15639 m : relativeTimeWithPlural,
15640 mm : relativeTimeWithPlural,
15641 h : 'годину',
15642 hh : relativeTimeWithPlural,
15643 d : 'день',
15644 dd : relativeTimeWithPlural,
15645 M : 'міÑÑць',
15646 MM : relativeTimeWithPlural,
15647 y : 'рік',
15648 yy : relativeTimeWithPlural
15649 },
15650 // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
15651 meridiemParse: /ночі|ранку|днÑ|вечора/,
15652 isPM: function (input) {
15653 return /^(днÑ|вечора)$/.test(input);
15654 },
15655 meridiem : function (hour, minute, isLower) {
15656 if (hour < 4) {
15657 return 'ночі';
15658 } else if (hour < 12) {
15659 return 'ранку';
15660 } else if (hour < 17) {
15661 return 'днÑ';
15662 } else {
15663 return 'вечора';
15664 }
15665 },
15666 dayOfMonthOrdinalParse: /\d{1,2}-(й|го)/,
15667 ordinal: function (number, period) {
15668 switch (period) {
15669 case 'M':
15670 case 'd':
15671 case 'DDD':
15672 case 'w':
15673 case 'W':
15674 return number + '-й';
15675 case 'D':
15676 return number + '-го';
15677 default:
15678 return number;
15679 }
15680 },
15681 week : {
15682 dow : 1, // Monday is the first day of the week.
15683 doy : 7 // The week that contains Jan 1st is the first week of the year.
15684 }
15685 });
15686
15687 return uk;
15688
15689})));
15690
15691
15692/***/ }),
15693/* 126 */
15694/***/ (function(module, exports, __webpack_require__) {
15695
15696//! moment.js locale configuration
15697
15698;(function (global, factory) {
15699 true ? factory(__webpack_require__(0)) :
15700 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15701 factory(global.moment)
15702}(this, (function (moment) { 'use strict';
15703
15704
15705 var months = [
15706 'جنوری',
15707 'Ùروری',
15708 'مارچ',
15709 'اپریل',
15710 'مئی',
15711 'جون',
15712 'جولائی',
15713 'اگست',
15714 'ستمبر',
15715 'اکتوبر',
15716 'نومبر',
15717 'دسمبر'
15718 ];
15719 var days = [
15720 'اتوار',
15721 'پیر',
15722 'منگل',
15723 'بدھ',
15724 'جمعرات',
15725 'جمعÛ',
15726 'ÛÙتÛ'
15727 ];
15728
15729 var ur = moment.defineLocale('ur', {
15730 months : months,
15731 monthsShort : months,
15732 weekdays : days,
15733 weekdaysShort : days,
15734 weekdaysMin : days,
15735 longDateFormat : {
15736 LT : 'HH:mm',
15737 LTS : 'HH:mm:ss',
15738 L : 'DD/MM/YYYY',
15739 LL : 'D MMMM YYYY',
15740 LLL : 'D MMMM YYYY HH:mm',
15741 LLLL : 'dddd، D MMMM YYYY HH:mm'
15742 },
15743 meridiemParse: /صبØ|شام/,
15744 isPM : function (input) {
15745 return 'شام' === input;
15746 },
15747 meridiem : function (hour, minute, isLower) {
15748 if (hour < 12) {
15749 return 'صبØ';
15750 }
15751 return 'شام';
15752 },
15753 calendar : {
15754 sameDay : '[آج بوقت] LT',
15755 nextDay : '[کل بوقت] LT',
15756 nextWeek : 'dddd [بوقت] LT',
15757 lastDay : '[Ú¯Ø°Ø´ØªÛ Ø±ÙˆØ² بوقت] LT',
15758 lastWeek : '[گذشتÛ] dddd [بوقت] LT',
15759 sameElse : 'L'
15760 },
15761 relativeTime : {
15762 future : '%s بعد',
15763 past : '%s قبل',
15764 s : 'چند سیکنڈ',
15765 ss : '%d سیکنڈ',
15766 m : 'ایک منٹ',
15767 mm : '%d منٹ',
15768 h : 'ایک گھنٹÛ',
15769 hh : '%d گھنٹے',
15770 d : 'ایک دن',
15771 dd : '%d دن',
15772 M : 'ایک ماÛ',
15773 MM : '%d ماÛ',
15774 y : 'ایک سال',
15775 yy : '%d سال'
15776 },
15777 preparse: function (string) {
15778 return string.replace(/،/g, ',');
15779 },
15780 postformat: function (string) {
15781 return string.replace(/,/g, '،');
15782 },
15783 week : {
15784 dow : 1, // Monday is the first day of the week.
15785 doy : 4 // The week that contains Jan 4th is the first week of the year.
15786 }
15787 });
15788
15789 return ur;
15790
15791})));
15792
15793
15794/***/ }),
15795/* 127 */
15796/***/ (function(module, exports, __webpack_require__) {
15797
15798//! moment.js locale configuration
15799
15800;(function (global, factory) {
15801 true ? factory(__webpack_require__(0)) :
15802 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15803 factory(global.moment)
15804}(this, (function (moment) { 'use strict';
15805
15806
15807 var uzLatn = moment.defineLocale('uz-latn', {
15808 months : 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split('_'),
15809 monthsShort : 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'),
15810 weekdays : 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split('_'),
15811 weekdaysShort : 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'),
15812 weekdaysMin : 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'),
15813 longDateFormat : {
15814 LT : 'HH:mm',
15815 LTS : 'HH:mm:ss',
15816 L : 'DD/MM/YYYY',
15817 LL : 'D MMMM YYYY',
15818 LLL : 'D MMMM YYYY HH:mm',
15819 LLLL : 'D MMMM YYYY, dddd HH:mm'
15820 },
15821 calendar : {
15822 sameDay : '[Bugun soat] LT [da]',
15823 nextDay : '[Ertaga] LT [da]',
15824 nextWeek : 'dddd [kuni soat] LT [da]',
15825 lastDay : '[Kecha soat] LT [da]',
15826 lastWeek : '[O\'tgan] dddd [kuni soat] LT [da]',
15827 sameElse : 'L'
15828 },
15829 relativeTime : {
15830 future : 'Yaqin %s ichida',
15831 past : 'Bir necha %s oldin',
15832 s : 'soniya',
15833 ss : '%d soniya',
15834 m : 'bir daqiqa',
15835 mm : '%d daqiqa',
15836 h : 'bir soat',
15837 hh : '%d soat',
15838 d : 'bir kun',
15839 dd : '%d kun',
15840 M : 'bir oy',
15841 MM : '%d oy',
15842 y : 'bir yil',
15843 yy : '%d yil'
15844 },
15845 week : {
15846 dow : 1, // Monday is the first day of the week.
15847 doy : 7 // The week that contains Jan 1st is the first week of the year.
15848 }
15849 });
15850
15851 return uzLatn;
15852
15853})));
15854
15855
15856/***/ }),
15857/* 128 */
15858/***/ (function(module, exports, __webpack_require__) {
15859
15860//! moment.js locale configuration
15861
15862;(function (global, factory) {
15863 true ? factory(__webpack_require__(0)) :
15864 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15865 factory(global.moment)
15866}(this, (function (moment) { 'use strict';
15867
15868
15869 var uz = moment.defineLocale('uz', {
15870 months : 'Ñнвар_феврал_март_апрел_май_июн_июл_авгуÑÑ‚_ÑентÑбр_октÑбр_ноÑбр_декабр'.split('_'),
15871 monthsShort : 'Ñнв_фев_мар_апр_май_июн_июл_авг_Ñен_окт_ноÑ_дек'.split('_'),
15872 weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
15873 weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
15874 weekdaysMin : 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
15875 longDateFormat : {
15876 LT : 'HH:mm',
15877 LTS : 'HH:mm:ss',
15878 L : 'DD/MM/YYYY',
15879 LL : 'D MMMM YYYY',
15880 LLL : 'D MMMM YYYY HH:mm',
15881 LLLL : 'D MMMM YYYY, dddd HH:mm'
15882 },
15883 calendar : {
15884 sameDay : '[Бугун Ñоат] LT [да]',
15885 nextDay : '[Ðртага] LT [да]',
15886 nextWeek : 'dddd [куни Ñоат] LT [да]',
15887 lastDay : '[Кеча Ñоат] LT [да]',
15888 lastWeek : '[Утган] dddd [куни Ñоат] LT [да]',
15889 sameElse : 'L'
15890 },
15891 relativeTime : {
15892 future : 'Якин %s ичида',
15893 past : 'Бир неча %s олдин',
15894 s : 'фурÑат',
15895 ss : '%d фурÑат',
15896 m : 'бир дакика',
15897 mm : '%d дакика',
15898 h : 'бир Ñоат',
15899 hh : '%d Ñоат',
15900 d : 'бир кун',
15901 dd : '%d кун',
15902 M : 'бир ой',
15903 MM : '%d ой',
15904 y : 'бир йил',
15905 yy : '%d йил'
15906 },
15907 week : {
15908 dow : 1, // Monday is the first day of the week.
15909 doy : 7 // The week that contains Jan 4th is the first week of the year.
15910 }
15911 });
15912
15913 return uz;
15914
15915})));
15916
15917
15918/***/ }),
15919/* 129 */
15920/***/ (function(module, exports, __webpack_require__) {
15921
15922//! moment.js locale configuration
15923
15924;(function (global, factory) {
15925 true ? factory(__webpack_require__(0)) :
15926 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
15927 factory(global.moment)
15928}(this, (function (moment) { 'use strict';
15929
15930
15931 var vi = moment.defineLocale('vi', {
15932 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('_'),
15933 monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
15934 monthsParseExact : true,
15935 weekdays : 'chủ nháºt_thứ hai_thứ ba_thứ tÆ°_thứ năm_thứ sáu_thứ bảy'.split('_'),
15936 weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
15937 weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
15938 weekdaysParseExact : true,
15939 meridiemParse: /sa|ch/i,
15940 isPM : function (input) {
15941 return /^ch$/i.test(input);
15942 },
15943 meridiem : function (hours, minutes, isLower) {
15944 if (hours < 12) {
15945 return isLower ? 'sa' : 'SA';
15946 } else {
15947 return isLower ? 'ch' : 'CH';
15948 }
15949 },
15950 longDateFormat : {
15951 LT : 'HH:mm',
15952 LTS : 'HH:mm:ss',
15953 L : 'DD/MM/YYYY',
15954 LL : 'D MMMM [năm] YYYY',
15955 LLL : 'D MMMM [năm] YYYY HH:mm',
15956 LLLL : 'dddd, D MMMM [năm] YYYY HH:mm',
15957 l : 'DD/M/YYYY',
15958 ll : 'D MMM YYYY',
15959 lll : 'D MMM YYYY HH:mm',
15960 llll : 'ddd, D MMM YYYY HH:mm'
15961 },
15962 calendar : {
15963 sameDay: '[Hôm nay lúc] LT',
15964 nextDay: '[Ngà y mai lúc] LT',
15965 nextWeek: 'dddd [tuần tới lúc] LT',
15966 lastDay: '[Hôm qua lúc] LT',
15967 lastWeek: 'dddd [tuần rồi lúc] LT',
15968 sameElse: 'L'
15969 },
15970 relativeTime : {
15971 future : '%s tá»›i',
15972 past : '%s trÆ°á»›c',
15973 s : 'và i giây',
15974 ss : '%d giây' ,
15975 m : 'một phút',
15976 mm : '%d phút',
15977 h : 'má»™t giá»',
15978 hh : '%d giá»',
15979 d : 'một ngà y',
15980 dd : '%d ngà y',
15981 M : 'một tháng',
15982 MM : '%d tháng',
15983 y : 'một năm',
15984 yy : '%d năm'
15985 },
15986 dayOfMonthOrdinalParse: /\d{1,2}/,
15987 ordinal : function (number) {
15988 return number;
15989 },
15990 week : {
15991 dow : 1, // Monday is the first day of the week.
15992 doy : 4 // The week that contains Jan 4th is the first week of the year.
15993 }
15994 });
15995
15996 return vi;
15997
15998})));
15999
16000
16001/***/ }),
16002/* 130 */
16003/***/ (function(module, exports, __webpack_require__) {
16004
16005//! moment.js locale configuration
16006
16007;(function (global, factory) {
16008 true ? factory(__webpack_require__(0)) :
16009 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
16010 factory(global.moment)
16011}(this, (function (moment) { 'use strict';
16012
16013
16014 var xPseudo = moment.defineLocale('x-pseudo', {
16015 months : 'J~áñúá~rý_F~ébrú~árý_~Márc~h_Ãp~rÃl_~Máý_~Júñé~_Júl~ý_Ãú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér'.split('_'),
16016 monthsShort : 'J~áñ_~Féb_~Már_~Ãpr_~Máý_~Júñ_~Júl_~Ãúg_~Sép_~Óct_~Ñóv_~Déc'.split('_'),
16017 monthsParseExact : true,
16018 weekdays : 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~FrÃd~áý_S~átúr~dáý'.split('_'),
16019 weekdaysShort : 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~FrÃ_~Sát'.split('_'),
16020 weekdaysMin : 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
16021 weekdaysParseExact : true,
16022 longDateFormat : {
16023 LT : 'HH:mm',
16024 L : 'DD/MM/YYYY',
16025 LL : 'D MMMM YYYY',
16026 LLL : 'D MMMM YYYY HH:mm',
16027 LLLL : 'dddd, D MMMM YYYY HH:mm'
16028 },
16029 calendar : {
16030 sameDay : '[T~ódá~ý át] LT',
16031 nextDay : '[T~ómó~rró~w át] LT',
16032 nextWeek : 'dddd [át] LT',
16033 lastDay : '[Ã~ést~érdá~ý át] LT',
16034 lastWeek : '[L~ást] dddd [át] LT',
16035 sameElse : 'L'
16036 },
16037 relativeTime : {
16038 future : 'Ã~ñ %s',
16039 past : '%s á~gó',
16040 s : 'á ~féw ~sécó~ñds',
16041 ss : '%d s~écóñ~ds',
16042 m : 'á ~mÃñ~úté',
16043 mm : '%d m~Ãñú~tés',
16044 h : 'á~ñ hó~úr',
16045 hh : '%d h~óúrs',
16046 d : 'á ~dáý',
16047 dd : '%d d~áýs',
16048 M : 'á ~móñ~th',
16049 MM : '%d m~óñt~hs',
16050 y : 'á ~ýéár',
16051 yy : '%d ý~éárs'
16052 },
16053 dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
16054 ordinal : function (number) {
16055 var b = number % 10,
16056 output = (~~(number % 100 / 10) === 1) ? 'th' :
16057 (b === 1) ? 'st' :
16058 (b === 2) ? 'nd' :
16059 (b === 3) ? 'rd' : 'th';
16060 return number + output;
16061 },
16062 week : {
16063 dow : 1, // Monday is the first day of the week.
16064 doy : 4 // The week that contains Jan 4th is the first week of the year.
16065 }
16066 });
16067
16068 return xPseudo;
16069
16070})));
16071
16072
16073/***/ }),
16074/* 131 */
16075/***/ (function(module, exports, __webpack_require__) {
16076
16077//! moment.js locale configuration
16078
16079;(function (global, factory) {
16080 true ? factory(__webpack_require__(0)) :
16081 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
16082 factory(global.moment)
16083}(this, (function (moment) { 'use strict';
16084
16085
16086 var yo = moment.defineLocale('yo', {
16087 months : 'SẹÌrẹÌ_EÌ€reÌ€leÌ€_Ẹrẹ̀naÌ€_IÌ€gbeÌ_EÌ€bibi_OÌ€kuÌ€du_Agẹmo_OÌ€guÌn_Owewe_Ọ̀waÌ€raÌ€_BeÌluÌ_Ọ̀pẹ̀̀'.split('_'),
16088 monthsShort : 'SẹÌr_EÌ€rl_Ẹrn_IÌ€gb_EÌ€bi_OÌ€kuÌ€_Agẹ_OÌ€guÌ_Owe_Ọ̀waÌ€_BeÌl_Ọ̀pẹ̀̀'.split('_'),
16089 weekdays : 'AÌ€iÌ€kuÌ_AjeÌ_IÌ€sẹÌgun_Ọjá»ÌruÌ_Ọjá»Ìbá»_ẸtiÌ€_AÌ€baÌmẹÌta'.split('_'),
16090 weekdaysShort : 'AÌ€iÌ€k_AjeÌ_IÌ€sẹÌ_Ọjr_Ọjb_ẸtiÌ€_AÌ€baÌ'.split('_'),
16091 weekdaysMin : 'Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb'.split('_'),
16092 longDateFormat : {
16093 LT : 'h:mm A',
16094 LTS : 'h:mm:ss A',
16095 L : 'DD/MM/YYYY',
16096 LL : 'D MMMM YYYY',
16097 LLL : 'D MMMM YYYY h:mm A',
16098 LLLL : 'dddd, D MMMM YYYY h:mm A'
16099 },
16100 calendar : {
16101 sameDay : '[Ònì ni] LT',
16102 nextDay : '[Ọ̀la ni] LT',
16103 nextWeek : 'dddd [Ọsẹ̀ toÌn\'bá»] [ni] LT',
16104 lastDay : '[AÌ€na ni] LT',
16105 lastWeek : 'dddd [Ọsẹ̀ toÌlá»Ì] [ni] LT',
16106 sameElse : 'L'
16107 },
16108 relativeTime : {
16109 future : 'niÌ %s',
16110 past : '%s ká»jaÌ',
16111 s : 'iÌ€sẹjuÌ aayaÌ die',
16112 ss :'aayaÌ %d',
16113 m : 'iÌ€sẹjuÌ kan',
16114 mm : 'iÌ€sẹjuÌ %d',
16115 h : 'waÌkati kan',
16116 hh : 'waÌkati %d',
16117 d : 'á»já»Ì kan',
16118 dd : 'á»já»Ì %d',
16119 M : 'osù kan',
16120 MM : 'osù %d',
16121 y : 'á»duÌn kan',
16122 yy : 'á»duÌn %d'
16123 },
16124 dayOfMonthOrdinalParse : /á»já»Ì\s\d{1,2}/,
16125 ordinal : 'á»já»Ì %d',
16126 week : {
16127 dow : 1, // Monday is the first day of the week.
16128 doy : 4 // The week that contains Jan 4th is the first week of the year.
16129 }
16130 });
16131
16132 return yo;
16133
16134})));
16135
16136
16137/***/ }),
16138/* 132 */
16139/***/ (function(module, exports, __webpack_require__) {
16140
16141//! moment.js locale configuration
16142
16143;(function (global, factory) {
16144 true ? factory(__webpack_require__(0)) :
16145 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
16146 factory(global.moment)
16147}(this, (function (moment) { 'use strict';
16148
16149
16150 var zhCn = moment.defineLocale('zh-cn', {
16151 months : '一月_二月_三月_四月_五月_å…月_七月_八月_ä¹æœˆ_å月_å一月_å二月'.split('_'),
16152 monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
16153 weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期å…'.split('_'),
16154 weekdaysShort : '周日_周一_周二_周三_周四_周五_周å…'.split('_'),
16155 weekdaysMin : 'æ—¥_一_二_三_å››_五_å…'.split('_'),
16156 longDateFormat : {
16157 LT : 'HH:mm',
16158 LTS : 'HH:mm:ss',
16159 L : 'YYYY/MM/DD',
16160 LL : 'YYYY年M月D日',
16161 LLL : 'YYYY年M月D日Ah点mm分',
16162 LLLL : 'YYYY年M月D日ddddAh点mm分',
16163 l : 'YYYY/M/D',
16164 ll : 'YYYY年M月D日',
16165 lll : 'YYYY年M月D日 HH:mm',
16166 llll : 'YYYY年M月D日dddd HH:mm'
16167 },
16168 meridiemParse: /凌晨|早上|上åˆ|ä¸åˆ|下åˆ|晚上/,
16169 meridiemHour: function (hour, meridiem) {
16170 if (hour === 12) {
16171 hour = 0;
16172 }
16173 if (meridiem === '凌晨' || meridiem === '早上' ||
16174 meridiem === '上åˆ') {
16175 return hour;
16176 } else if (meridiem === '下åˆ' || meridiem === '晚上') {
16177 return hour + 12;
16178 } else {
16179 // 'ä¸åˆ'
16180 return hour >= 11 ? hour : hour + 12;
16181 }
16182 },
16183 meridiem : function (hour, minute, isLower) {
16184 var hm = hour * 100 + minute;
16185 if (hm < 600) {
16186 return '凌晨';
16187 } else if (hm < 900) {
16188 return '早上';
16189 } else if (hm < 1130) {
16190 return '上åˆ';
16191 } else if (hm < 1230) {
16192 return 'ä¸åˆ';
16193 } else if (hm < 1800) {
16194 return '下åˆ';
16195 } else {
16196 return '晚上';
16197 }
16198 },
16199 calendar : {
16200 sameDay : '[今天]LT',
16201 nextDay : '[明天]LT',
16202 nextWeek : '[下]ddddLT',
16203 lastDay : '[昨天]LT',
16204 lastWeek : '[上]ddddLT',
16205 sameElse : 'L'
16206 },
16207 dayOfMonthOrdinalParse: /\d{1,2}(日|月|周)/,
16208 ordinal : function (number, period) {
16209 switch (period) {
16210 case 'd':
16211 case 'D':
16212 case 'DDD':
16213 return number + 'æ—¥';
16214 case 'M':
16215 return number + '月';
16216 case 'w':
16217 case 'W':
16218 return number + '周';
16219 default:
16220 return number;
16221 }
16222 },
16223 relativeTime : {
16224 future : '%s内',
16225 past : '%så‰',
16226 s : 'å‡ ç§’',
16227 ss : '%d 秒',
16228 m : '1 分钟',
16229 mm : '%d 分钟',
16230 h : '1 å°æ—¶',
16231 hh : '%d å°æ—¶',
16232 d : '1 天',
16233 dd : '%d 天',
16234 M : '1 个月',
16235 MM : '%d 个月',
16236 y : '1 å¹´',
16237 yy : '%d å¹´'
16238 },
16239 week : {
16240 // GB/T 7408-1994《数æ®å…ƒå’Œäº¤æ¢æ ¼å¼Â·ä¿¡æ¯äº¤æ¢Â·æ—¥æœŸå’Œæ—¶é—´è¡¨ç¤ºæ³•ã€‹ä¸ŽISO 8601:1988ç‰æ•ˆ
16241 dow : 1, // Monday is the first day of the week.
16242 doy : 4 // The week that contains Jan 4th is the first week of the year.
16243 }
16244 });
16245
16246 return zhCn;
16247
16248})));
16249
16250
16251/***/ }),
16252/* 133 */
16253/***/ (function(module, exports, __webpack_require__) {
16254
16255//! moment.js locale configuration
16256
16257;(function (global, factory) {
16258 true ? factory(__webpack_require__(0)) :
16259 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
16260 factory(global.moment)
16261}(this, (function (moment) { 'use strict';
16262
16263
16264 var zhHk = moment.defineLocale('zh-hk', {
16265 months : '一月_二月_三月_四月_五月_å…月_七月_八月_ä¹æœˆ_å月_å一月_å二月'.split('_'),
16266 monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
16267 weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期å…'.split('_'),
16268 weekdaysShort : '週日_週一_週二_週三_週四_週五_週å…'.split('_'),
16269 weekdaysMin : 'æ—¥_一_二_三_å››_五_å…'.split('_'),
16270 longDateFormat : {
16271 LT : 'HH:mm',
16272 LTS : 'HH:mm:ss',
16273 L : 'YYYY/MM/DD',
16274 LL : 'YYYY年M月D日',
16275 LLL : 'YYYY年M月D日 HH:mm',
16276 LLLL : 'YYYY年M月D日dddd HH:mm',
16277 l : 'YYYY/M/D',
16278 ll : 'YYYY年M月D日',
16279 lll : 'YYYY年M月D日 HH:mm',
16280 llll : 'YYYY年M月D日dddd HH:mm'
16281 },
16282 meridiemParse: /凌晨|早上|上åˆ|ä¸åˆ|下åˆ|晚上/,
16283 meridiemHour : function (hour, meridiem) {
16284 if (hour === 12) {
16285 hour = 0;
16286 }
16287 if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上åˆ') {
16288 return hour;
16289 } else if (meridiem === 'ä¸åˆ') {
16290 return hour >= 11 ? hour : hour + 12;
16291 } else if (meridiem === '下åˆ' || meridiem === '晚上') {
16292 return hour + 12;
16293 }
16294 },
16295 meridiem : function (hour, minute, isLower) {
16296 var hm = hour * 100 + minute;
16297 if (hm < 600) {
16298 return '凌晨';
16299 } else if (hm < 900) {
16300 return '早上';
16301 } else if (hm < 1130) {
16302 return '上åˆ';
16303 } else if (hm < 1230) {
16304 return 'ä¸åˆ';
16305 } else if (hm < 1800) {
16306 return '下åˆ';
16307 } else {
16308 return '晚上';
16309 }
16310 },
16311 calendar : {
16312 sameDay : '[今天]LT',
16313 nextDay : '[明天]LT',
16314 nextWeek : '[下]ddddLT',
16315 lastDay : '[昨天]LT',
16316 lastWeek : '[上]ddddLT',
16317 sameElse : 'L'
16318 },
16319 dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
16320 ordinal : function (number, period) {
16321 switch (period) {
16322 case 'd' :
16323 case 'D' :
16324 case 'DDD' :
16325 return number + 'æ—¥';
16326 case 'M' :
16327 return number + '月';
16328 case 'w' :
16329 case 'W' :
16330 return number + '週';
16331 default :
16332 return number;
16333 }
16334 },
16335 relativeTime : {
16336 future : '%så…§',
16337 past : '%så‰',
16338 s : '幾秒',
16339 ss : '%d 秒',
16340 m : '1 分é˜',
16341 mm : '%d 分é˜',
16342 h : '1 å°æ™‚',
16343 hh : '%d å°æ™‚',
16344 d : '1 天',
16345 dd : '%d 天',
16346 M : '1 個月',
16347 MM : '%d 個月',
16348 y : '1 å¹´',
16349 yy : '%d å¹´'
16350 }
16351 });
16352
16353 return zhHk;
16354
16355})));
16356
16357
16358/***/ }),
16359/* 134 */
16360/***/ (function(module, exports, __webpack_require__) {
16361
16362//! moment.js locale configuration
16363
16364;(function (global, factory) {
16365 true ? factory(__webpack_require__(0)) :
16366 typeof define === 'function' && define.amd ? define(['../moment'], factory) :
16367 factory(global.moment)
16368}(this, (function (moment) { 'use strict';
16369
16370
16371 var zhTw = moment.defineLocale('zh-tw', {
16372 months : '一月_二月_三月_四月_五月_å…月_七月_八月_ä¹æœˆ_å月_å一月_å二月'.split('_'),
16373 monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
16374 weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期å…'.split('_'),
16375 weekdaysShort : '週日_週一_週二_週三_週四_週五_週å…'.split('_'),
16376 weekdaysMin : 'æ—¥_一_二_三_å››_五_å…'.split('_'),
16377 longDateFormat : {
16378 LT : 'HH:mm',
16379 LTS : 'HH:mm:ss',
16380 L : 'YYYY/MM/DD',
16381 LL : 'YYYY年M月D日',
16382 LLL : 'YYYY年M月D日 HH:mm',
16383 LLLL : 'YYYY年M月D日dddd HH:mm',
16384 l : 'YYYY/M/D',
16385 ll : 'YYYY年M月D日',
16386 lll : 'YYYY年M月D日 HH:mm',
16387 llll : 'YYYY年M月D日dddd HH:mm'
16388 },
16389 meridiemParse: /凌晨|早上|上åˆ|ä¸åˆ|下åˆ|晚上/,
16390 meridiemHour : function (hour, meridiem) {
16391 if (hour === 12) {
16392 hour = 0;
16393 }
16394 if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上åˆ') {
16395 return hour;
16396 } else if (meridiem === 'ä¸åˆ') {
16397 return hour >= 11 ? hour : hour + 12;
16398 } else if (meridiem === '下åˆ' || meridiem === '晚上') {
16399 return hour + 12;
16400 }
16401 },
16402 meridiem : function (hour, minute, isLower) {
16403 var hm = hour * 100 + minute;
16404 if (hm < 600) {
16405 return '凌晨';
16406 } else if (hm < 900) {
16407 return '早上';
16408 } else if (hm < 1130) {
16409 return '上åˆ';
16410 } else if (hm < 1230) {
16411 return 'ä¸åˆ';
16412 } else if (hm < 1800) {
16413 return '下åˆ';
16414 } else {
16415 return '晚上';
16416 }
16417 },
16418 calendar : {
16419 sameDay : '[今天] LT',
16420 nextDay : '[明天] LT',
16421 nextWeek : '[下]dddd LT',
16422 lastDay : '[昨天] LT',
16423 lastWeek : '[上]dddd LT',
16424 sameElse : 'L'
16425 },
16426 dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
16427 ordinal : function (number, period) {
16428 switch (period) {
16429 case 'd' :
16430 case 'D' :
16431 case 'DDD' :
16432 return number + 'æ—¥';
16433 case 'M' :
16434 return number + '月';
16435 case 'w' :
16436 case 'W' :
16437 return number + '週';
16438 default :
16439 return number;
16440 }
16441 },
16442 relativeTime : {
16443 future : '%så…§',
16444 past : '%så‰',
16445 s : '幾秒',
16446 ss : '%d 秒',
16447 m : '1 分é˜',
16448 mm : '%d 分é˜',
16449 h : '1 å°æ™‚',
16450 hh : '%d å°æ™‚',
16451 d : '1 天',
16452 dd : '%d 天',
16453 M : '1 個月',
16454 MM : '%d 個月',
16455 y : '1 å¹´',
16456 yy : '%d å¹´'
16457 }
16458 });
16459
16460 return zhTw;
16461
16462})));
16463
16464
16465/***/ }),
16466/* 135 */,
16467/* 136 */,
16468/* 137 */,
16469/* 138 */,
16470/* 139 */,
16471/* 140 */,
16472/* 141 */
16473/***/ (function(module, exports, __webpack_require__) {
16474
16475var map = {
16476 "./af": 12,
16477 "./af.js": 12,
16478 "./ar": 19,
16479 "./ar-dz": 13,
16480 "./ar-dz.js": 13,
16481 "./ar-kw": 14,
16482 "./ar-kw.js": 14,
16483 "./ar-ly": 15,
16484 "./ar-ly.js": 15,
16485 "./ar-ma": 16,
16486 "./ar-ma.js": 16,
16487 "./ar-sa": 17,
16488 "./ar-sa.js": 17,
16489 "./ar-tn": 18,
16490 "./ar-tn.js": 18,
16491 "./ar.js": 19,
16492 "./az": 20,
16493 "./az.js": 20,
16494 "./be": 21,
16495 "./be.js": 21,
16496 "./bg": 22,
16497 "./bg.js": 22,
16498 "./bm": 23,
16499 "./bm.js": 23,
16500 "./bn": 24,
16501 "./bn.js": 24,
16502 "./bo": 25,
16503 "./bo.js": 25,
16504 "./br": 26,
16505 "./br.js": 26,
16506 "./bs": 27,
16507 "./bs.js": 27,
16508 "./ca": 28,
16509 "./ca.js": 28,
16510 "./cs": 29,
16511 "./cs.js": 29,
16512 "./cv": 30,
16513 "./cv.js": 30,
16514 "./cy": 31,
16515 "./cy.js": 31,
16516 "./da": 32,
16517 "./da.js": 32,
16518 "./de": 35,
16519 "./de-at": 33,
16520 "./de-at.js": 33,
16521 "./de-ch": 34,
16522 "./de-ch.js": 34,
16523 "./de.js": 35,
16524 "./dv": 36,
16525 "./dv.js": 36,
16526 "./el": 37,
16527 "./el.js": 37,
16528 "./en-au": 38,
16529 "./en-au.js": 38,
16530 "./en-ca": 39,
16531 "./en-ca.js": 39,
16532 "./en-gb": 40,
16533 "./en-gb.js": 40,
16534 "./en-ie": 41,
16535 "./en-ie.js": 41,
16536 "./en-il": 42,
16537 "./en-il.js": 42,
16538 "./en-nz": 43,
16539 "./en-nz.js": 43,
16540 "./eo": 44,
16541 "./eo.js": 44,
16542 "./es": 47,
16543 "./es-do": 45,
16544 "./es-do.js": 45,
16545 "./es-us": 46,
16546 "./es-us.js": 46,
16547 "./es.js": 47,
16548 "./et": 48,
16549 "./et.js": 48,
16550 "./eu": 49,
16551 "./eu.js": 49,
16552 "./fa": 50,
16553 "./fa.js": 50,
16554 "./fi": 51,
16555 "./fi.js": 51,
16556 "./fo": 52,
16557 "./fo.js": 52,
16558 "./fr": 55,
16559 "./fr-ca": 53,
16560 "./fr-ca.js": 53,
16561 "./fr-ch": 54,
16562 "./fr-ch.js": 54,
16563 "./fr.js": 55,
16564 "./fy": 56,
16565 "./fy.js": 56,
16566 "./gd": 57,
16567 "./gd.js": 57,
16568 "./gl": 58,
16569 "./gl.js": 58,
16570 "./gom-latn": 59,
16571 "./gom-latn.js": 59,
16572 "./gu": 60,
16573 "./gu.js": 60,
16574 "./he": 61,
16575 "./he.js": 61,
16576 "./hi": 62,
16577 "./hi.js": 62,
16578 "./hr": 63,
16579 "./hr.js": 63,
16580 "./hu": 64,
16581 "./hu.js": 64,
16582 "./hy-am": 65,
16583 "./hy-am.js": 65,
16584 "./id": 66,
16585 "./id.js": 66,
16586 "./is": 67,
16587 "./is.js": 67,
16588 "./it": 68,
16589 "./it.js": 68,
16590 "./ja": 69,
16591 "./ja.js": 69,
16592 "./jv": 70,
16593 "./jv.js": 70,
16594 "./ka": 71,
16595 "./ka.js": 71,
16596 "./kk": 72,
16597 "./kk.js": 72,
16598 "./km": 73,
16599 "./km.js": 73,
16600 "./kn": 74,
16601 "./kn.js": 74,
16602 "./ko": 75,
16603 "./ko.js": 75,
16604 "./ky": 76,
16605 "./ky.js": 76,
16606 "./lb": 77,
16607 "./lb.js": 77,
16608 "./lo": 78,
16609 "./lo.js": 78,
16610 "./lt": 79,
16611 "./lt.js": 79,
16612 "./lv": 80,
16613 "./lv.js": 80,
16614 "./me": 81,
16615 "./me.js": 81,
16616 "./mi": 82,
16617 "./mi.js": 82,
16618 "./mk": 83,
16619 "./mk.js": 83,
16620 "./ml": 84,
16621 "./ml.js": 84,
16622 "./mn": 85,
16623 "./mn.js": 85,
16624 "./mr": 86,
16625 "./mr.js": 86,
16626 "./ms": 88,
16627 "./ms-my": 87,
16628 "./ms-my.js": 87,
16629 "./ms.js": 88,
16630 "./mt": 89,
16631 "./mt.js": 89,
16632 "./my": 90,
16633 "./my.js": 90,
16634 "./nb": 91,
16635 "./nb.js": 91,
16636 "./ne": 92,
16637 "./ne.js": 92,
16638 "./nl": 94,
16639 "./nl-be": 93,
16640 "./nl-be.js": 93,
16641 "./nl.js": 94,
16642 "./nn": 95,
16643 "./nn.js": 95,
16644 "./pa-in": 96,
16645 "./pa-in.js": 96,
16646 "./pl": 97,
16647 "./pl.js": 97,
16648 "./pt": 99,
16649 "./pt-br": 98,
16650 "./pt-br.js": 98,
16651 "./pt.js": 99,
16652 "./ro": 100,
16653 "./ro.js": 100,
16654 "./ru": 101,
16655 "./ru.js": 101,
16656 "./sd": 102,
16657 "./sd.js": 102,
16658 "./se": 103,
16659 "./se.js": 103,
16660 "./si": 104,
16661 "./si.js": 104,
16662 "./sk": 105,
16663 "./sk.js": 105,
16664 "./sl": 106,
16665 "./sl.js": 106,
16666 "./sq": 107,
16667 "./sq.js": 107,
16668 "./sr": 109,
16669 "./sr-cyrl": 108,
16670 "./sr-cyrl.js": 108,
16671 "./sr.js": 109,
16672 "./ss": 110,
16673 "./ss.js": 110,
16674 "./sv": 111,
16675 "./sv.js": 111,
16676 "./sw": 112,
16677 "./sw.js": 112,
16678 "./ta": 113,
16679 "./ta.js": 113,
16680 "./te": 114,
16681 "./te.js": 114,
16682 "./tet": 115,
16683 "./tet.js": 115,
16684 "./tg": 116,
16685 "./tg.js": 116,
16686 "./th": 117,
16687 "./th.js": 117,
16688 "./tl-ph": 118,
16689 "./tl-ph.js": 118,
16690 "./tlh": 119,
16691 "./tlh.js": 119,
16692 "./tr": 120,
16693 "./tr.js": 120,
16694 "./tzl": 121,
16695 "./tzl.js": 121,
16696 "./tzm": 123,
16697 "./tzm-latn": 122,
16698 "./tzm-latn.js": 122,
16699 "./tzm.js": 123,
16700 "./ug-cn": 124,
16701 "./ug-cn.js": 124,
16702 "./uk": 125,
16703 "./uk.js": 125,
16704 "./ur": 126,
16705 "./ur.js": 126,
16706 "./uz": 128,
16707 "./uz-latn": 127,
16708 "./uz-latn.js": 127,
16709 "./uz.js": 128,
16710 "./vi": 129,
16711 "./vi.js": 129,
16712 "./x-pseudo": 130,
16713 "./x-pseudo.js": 130,
16714 "./yo": 131,
16715 "./yo.js": 131,
16716 "./zh-cn": 132,
16717 "./zh-cn.js": 132,
16718 "./zh-hk": 133,
16719 "./zh-hk.js": 133,
16720 "./zh-tw": 134,
16721 "./zh-tw.js": 134
16722};
16723function webpackContext(req) {
16724 return __webpack_require__(webpackContextResolve(req));
16725};
16726function webpackContextResolve(req) {
16727 var id = map[req];
16728 if(!(id + 1)) // check for number or string
16729 throw new Error("Cannot find module '" + req + "'.");
16730 return id;
16731};
16732webpackContext.keys = function webpackContextKeys() {
16733 return Object.keys(map);
16734};
16735webpackContext.resolve = webpackContextResolve;
16736module.exports = webpackContext;
16737webpackContext.id = 141;
16738
16739/***/ }),
16740/* 142 */,
16741/* 143 */,
16742/* 144 */,
16743/* 145 */,
16744/* 146 */,
16745/* 147 */,
16746/* 148 */,
16747/* 149 */,
16748/* 150 */,
16749/* 151 */,
16750/* 152 */,
16751/* 153 */,
16752/* 154 */,
16753/* 155 */,
16754/* 156 */,
16755/* 157 */,
16756/* 158 */,
16757/* 159 */,
16758/* 160 */,
16759/* 161 */,
16760/* 162 */
16761/***/ (function(module, exports, __webpack_require__) {
16762
16763__webpack_require__(185);
16764__webpack_require__(184);
16765
16766/***/ }),
16767/* 163 */,
16768/* 164 */,
16769/* 165 */,
16770/* 166 */,
16771/* 167 */,
16772/* 168 */,
16773/* 169 */,
16774/* 170 */,
16775/* 171 */,
16776/* 172 */,
16777/* 173 */,
16778/* 174 */,
16779/* 175 */,
16780/* 176 */,
16781/* 177 */,
16782/* 178 */,
16783/* 179 */,
16784/* 180 */,
16785/* 181 */,
16786/* 182 */,
16787/* 183 */,
16788/* 184 */
16789/***/ (function(module, exports) {
16790
16791$(document).ready(function () {
16792
16793 $('[name="origin_description"]').on('input', function () {
16794 $('input[name="origin"]').val('');
16795 $('input[name="origin_short"]').val('');
16796 });
16797
16798 $('.search-submit').click(function (e) {
16799 if ($('.search-origin').is(':visible')) {
16800 $('.search').attr('action', 'book/transport/' + $('[name="affiliate_id"]').val());
16801 } else {
16802 $('.search').attr('action', 'book/accommodation/' + $('[name="affiliate_id"]').val());
16803 }
16804
16805 validation(e);
16806 });
16807
16808 $('.search-rooms > div:not(.hidden) [name^="persons"]').change(function (e) {
16809 $('.search-rooms > div:not(.hidden) [name^="persons"]').closest('.form-group').removeClass('has-error');
16810 $('div.text-danger').addClass('hidden');
16811
16812 // validation(e);
16813 });
16814
16815 function validation(e) {
16816 $sgl = parseInt($('[name="persons_single"]').val());
16817 $dbl = parseInt($('[name="persons_double"]').val());
16818 $mlt = parseInt($('[name="persons_multi"]').val());
16819 $pthree = parseInt($('[name="persons_3_bed"]').val());
16820 $pfour = parseInt($('[name="persons_4_bed"]').val());
16821 $pfive = parseInt($('[name="persons_5_bed"]').val());
16822 $psix = parseInt($('[name="persons_6_bed"]').val());
16823
16824 if ($('[name="persons_multi"]').is(':disabled')) {
16825 $mlt = 0;
16826 } else {
16827 $pthree = 0;
16828 $pfour = 0;
16829 $pfive = 0;
16830 $psix = 0;
16831 }
16832
16833 $all = $sgl + $dbl + $mlt + $pthree + $pfour + $pfive + $psix;
16834
16835 if ($all < 6) {
16836 e.preventDefault();
16837 $('.search-rooms > div:not(.hidden) [name^="persons"]').closest('.form-group').addClass('has-error');
16838 $('.form-group.text-danger').removeClass('hidden');
16839 }
16840
16841 selector = 'form .row:not(.hidden) [name="tripstart"], form .row:not(.hidden) [name="tripend"]';
16842
16843 if (new Date($(selector).val()).getTime() >= new Date($('div.last_date').attr('last-date')).getTime()) {
16844 e.preventDefault();
16845 $('div.last_date').removeClass('hidden');
16846 $(selector).closest('.form-group').addClass('has-error');
16847 }
16848 };
16849
16850 //Specific sizes
16851 $('.specified_beds_label').on('click', function () {
16852 $('.specified_beds').toggleClass('hidden');
16853 $('.mlt').prop('disabled', function (i, v) {
16854 return !v;
16855 });
16856 });
16857
16858 $('#enableTransport').on('change', function () {
16859 if ($(this).is(":checked")) {
16860 $('.origin, .glyphicon-ok').show();
16861 $('[name="origin_description"]').focus();
16862 } else {
16863 $('.origin, .glyphicon-ok').hide();
16864 }
16865 });
16866});
16867
16868/***/ }),
16869/* 185 */
16870/***/ (function(module, exports, __webpack_require__) {
16871
16872var moment = __webpack_require__(0);
16873var selector = '.date-input';
16874var options = {
16875 selector: '.date-range',
16876 dateFromName: 'tripstart',
16877 dateToName: 'tripend',
16878 origin: 'front-end'
16879};
16880
16881destroy(selector);
16882createDateRange(options);
16883
16884function destroy(selector) {
16885 $(selector).datepicker('destroy');
16886 $(selector).removeClass('hasDatepicker').removeAttr('id');
16887}
16888
16889function createDateRange(options) {
16890 var _this = this;
16891
16892 options = options || {};
16893 var self = this;
16894 this.options = options;
16895 this.date_from = $(options.selector + ':not(.hidden) [name="' + options.dateFromName + '"]');
16896 this.date_to = $(options.selector + ':not(.hidden) [name="' + options.dateToName + '"]');
16897 var date_from_date = new Date(this.date_from.val());
16898
16899 this.dateFromMoment = function () {
16900 return moment(_this.date_from.val(), 'DD MMMM YYYY');
16901 };
16902 this.dateToMoment = function () {
16903 return moment(_this.date_to.val(), 'DD MMMM YYYY');
16904 };
16905 this.difference = function () {
16906 var date_from = moment().format(_this.date_from.val(), 'DD MMMM YYYY');
16907 var date_to = moment().format(_this.date_to.val(), 'DD MMMM YYYY');
16908 return date_to.diff(date_from, 'days');
16909 };
16910
16911 $(options.selector + ' .date-input').datepicker({
16912 dateFormat: 'd M yy',
16913 minDate: 0,
16914 numberOfMonths: 2,
16915 firstDay: 1,
16916 changeMonth: options.changeMonth ? options.changeMonth : false,
16917 changeYear: options.changeYear ? options.changeYear : false,
16918 beforeShow: function beforeShow() {
16919 highlightDates($(this).attr('name'), options.selector, options.dateFromName, options.dateToName);
16920 },
16921 beforeShowDay: function beforeShowDay(date) {
16922 var date_from = new Date($(options.selector + ':not(.hidden) [name="' + options.dateFromName + '"]').val());
16923 var date_to = new Date($(options.selector + ':not(.hidden) [name="' + options.dateToName + '"]').val());
16924
16925 var classes = 'date-range-between selected-dates';
16926 if (date >= date_from && date <= date_to) {
16927 if (date.toDateString() == date_from.toDateString()) {
16928 classes = 'date-range-start';
16929 }
16930 if (date.toDateString() == date_to.toDateString()) {
16931 classes = 'date-range-end';
16932 }
16933
16934 return [true, classes];
16935 }
16936 return [true, ''];
16937 },
16938 onSelect: function onSelect(dateText, inst) {
16939 var name = $(this).attr('name');
16940 var date = new Date($(this).val());
16941 var dayName = date.toString().split(' ')[0].toUpperCase();
16942 var newDate = $.datepicker.formatDate('yy-mm-dd', new Date(inst.selectedYear, inst.selectedMonth, inst.selectedDay));
16943 var sameDay = $(this).hasClass('sameDay');
16944
16945 $(this).next('.date-input-weekday').text(dayName);
16946
16947 switch (name) {
16948 case options.dateFromName:
16949 var date_to = $(options.selector + ':not(.hidden) [name="' + options.dateToName + '"]');
16950 if (options.origin == 'front-end') {
16951 $(date_to).datepicker('option', 'maxDate', moment(date).add(30, 'days').toDate());
16952 }
16953
16954 var period = 1;
16955
16956 date.setDate(date.getDate() + parseInt(period));
16957 dayName = date.toString().split(' ')[0].toUpperCase();
16958 $(date_to).datepicker('setDate', date);
16959 $(date_to).next('.date-input-weekday').text(dayName);
16960
16961 break;
16962 case options.dateToName:
16963 var date_from = $(options.selector + ':not(.hidden) [name="' + options.dateFromName + '"]');
16964 if (new Date($(date_from).val()).getTime() >= date.getTime()) {
16965 if (!sameDay) {
16966 date.setDate(date.getDate() - 1);
16967 }
16968
16969 dayName = date.toString().split(' ')[0].toUpperCase();
16970 $(date_from).datepicker('setDate', date);
16971 $(date_from).next('.date-input-weekday').text(dayName);
16972 }
16973 var dateFrom = $.datepicker.formatDate('yy-mm-dd', new Date($(date_from).val()));
16974 var period = getNumberOfDaysBetweenDates(dateFrom, newDate);
16975
16976 break;
16977 };
16978 options.onSelect && options.onSelect(options);
16979 }
16980 }).keydown(false);
16981 var date_to = $(options.selector + ':not(.hidden) [name="' + options.dateToName + '"]');
16982 if (options.origin == 'front-end') {
16983 $(date_to).datepicker('option', 'maxDate', moment(date_from_date).add(30, 'days').toDate());
16984 }
16985}
16986function highlightDates(name, selector, dateFromName, dateToName) {
16987 var date_from = new Date($(selector + ':not(.hidden) [name="' + dateFromName + '"]').val());
16988 var date_to = new Date($(selector + ':not(.hidden) [name="' + dateToName + '"]').val());
16989
16990 // Preserve the selected date range if the mouse leaves the datepicker calendar
16991 $('body').on('mouseleave', '#ui-datepicker-div', function () {
16992 var startDate = $('td[data-year="' + date_from.getFullYear() + '"][data-month="' + date_from.getMonth() + '"]').filter(function (index) {
16993 return $(this).find('a').text() == date_from.getDate();
16994 });
16995 var endDate = $('td[data-year="' + date_to.getFullYear() + '"][data-month="' + date_to.getMonth() + '"]').filter(function (index) {
16996 return $(this).find('a').text() == date_to.getDate();
16997 });
16998
16999 $('#ui-datepicker-div td').removeClass('date-range-start').removeClass('date-range-between').removeClass('date-range-end').removeClass('date-range-single');
17000
17001 $(this).find('td.selected-dates').addClass('date-range-between');
17002 startDate.addClass('date-range-start').removeClass('date-range-between');
17003 endDate.addClass('date-range-end').removeClass('date-range-between').removeClass('date-range-single');
17004 });
17005 // Create date range on mouse enter
17006 $('body').on('mouseenter', '#ui-datepicker-div td', function () {
17007 // Get start date, current date and end date elements
17008 var startDate = $('td[data-year="' + date_from.getFullYear() + '"][data-month="' + date_from.getMonth() + '"]').filter(function (index) {
17009 return $(this).find('a').text() == date_from.getDate();
17010 });
17011 var endDate = $('td[data-year="' + date_to.getFullYear() + '"][data-month="' + date_to.getMonth() + '"]').filter(function (index) {
17012 return $(this).find('a').text() == date_to.getDate();
17013 });
17014 var currentDate = new Date($(this).attr('data-year') + "/" + (parseInt($(this).attr('data-month')) + 1) + "/" + $(this).text());
17015
17016 $('#ui-datepicker-div td').removeClass('ui-datepicker-current-day');
17017 // Get all table cells within the current month
17018 var allTds = $(this).parents('.ui-datepicker-calendar').find('td:not(.ui-datepicker-unselectable)');
17019 // Merge all table cell within the 2 visible months
17020 if ($(this).parents('.ui-datepicker-group').hasClass('ui-datepicker-group-first')) {
17021 allTds = $.merge(allTds, $('.ui-datepicker-group-last').find('td:not(.ui-datepicker-unselectable)'));
17022 } else if ($(this).parents('.ui-datepicker-group').hasClass('ui-datepicker-group-last')) {
17023 allTds = $.merge($('.ui-datepicker-group-first').find('td:not(.ui-datepicker-unselectable)'), allTds);
17024 }
17025
17026 allTds.removeClass('date-range-start').removeClass('date-range-between').removeClass('date-range-end').removeClass('date-range-single');
17027
17028 var found = false;
17029 if (name == dateFromName) {
17030 // Creates date ranges until the end date
17031 if (currentDate < date_to) {
17032 //$(this).addClass('date-range-start');
17033 //endDate.addClass('date-range-end');
17034 $(this).addClass('date-range-single');
17035 endDate.addClass('date-range-single');
17036 for (var i = 0; i < allTds.length; i++) {
17037 if (allTds[i] == this) {
17038 found = true;
17039 }
17040 if ($(allTds[i]).hasClass('date-range-end')) {
17041 break;
17042 }
17043 if (found && !$(allTds[i]).hasClass('date-range-start')) {
17044 //$(allTds[i]).addClass('date-range-between');
17045 }
17046 }
17047 } else {
17048 $(this).addClass('date-range-single');
17049 endDate.addClass('date-range-single').removeClass('date-range-end');
17050 }
17051 } else if (name == dateToName) {
17052 // Creates date ranges from the start date
17053 if (currentDate > date_from) {
17054 startDate.addClass('date-range-start');
17055 $(this).addClass('date-range-end');
17056 for (i = 0; i < allTds.length; i++) {
17057 if (found && !$(allTds[i]).hasClass('date-range-end')) {
17058 $(allTds[i]).addClass('date-range-between');
17059 }
17060 if ($(allTds[i]).hasClass('date-range-start') || startDate.length == 0) {
17061 found = true;
17062 if (startDate.length == 0) {
17063 $('#ui-datepicker-div').find('td:not(.ui-datepicker-unselectable):first').addClass('date-range-between');
17064 }
17065 }
17066 if (allTds[i] == this) {
17067 break;
17068 }
17069 }
17070 } else {
17071 $(this).addClass('date-range-single');
17072 startDate.addClass('date-range-single').removeClass('date-range-start');
17073 }
17074 }
17075 });
17076}
17077function createDateType(selector, dateFromName, dateToName) {
17078 $(selector + ' .date-input').datepicker({
17079 dateFormat: 'd M yy',
17080 minDate: 0,
17081 numberOfMonths: 1,
17082 firstDay: 1,
17083 beforeShow: function beforeShow() {
17084 highlightDates($(this).attr('name'), selector, dateFromName, dateToName);
17085 },
17086 beforeShowDay: function beforeShowDay(date) {
17087 var date_from = new Date($(selector + ':not(.hidden) [name="' + dateFromName + '"]').val());
17088 var date_to = new Date($(selector + ':not(.hidden) [name="' + dateToName + '"]').val());
17089
17090 var classes = 'date-range-between selected-dates';
17091 if (date >= date_from && date <= date_to) {
17092 if (date.toDateString() == date_from.toDateString()) {
17093 classes = 'date-range-start';
17094 }
17095 if (date.toDateString() == date_to.toDateString()) {
17096 classes = 'date-range-end';
17097 }
17098
17099 return [true, classes];
17100 }
17101 return [true, ''];
17102 },
17103 onSelect: function onSelect(dateText, inst) {
17104 var name = $(this).attr('name');
17105 var date = new Date($(this).val());
17106 var dayName = date.toString().split(' ')[0].toUpperCase();
17107 var newDate = $.datepicker.formatDate('yy-mm-dd', new Date(inst.selectedYear, inst.selectedMonth, inst.selectedDay));
17108 $(this).next('.date-input-weekday').text(dayName);
17109
17110 switch (name) {
17111 case dateFromName:
17112 var date_to = $(selector + ':not(.hidden) [name="' + dateToName + '"]');
17113 if (new Date($(date_to).val()).getTime() <= date.getTime()) {
17114 date.setDate(date.getDate() + 1);
17115 dayName = date.toString().split(' ')[0].toUpperCase();
17116 $(date_to).datepicker('setDate', date);
17117 $(date_to).next('.date-input-weekday').text(dayName);
17118 }
17119 break;
17120 case dateToName:
17121 var date_from = $(selector + ':not(.hidden) [name="' + dateFromName + '"]');
17122 if (new Date($(date_from).val()).getTime() >= date.getTime()) {
17123 date.setDate(date.getDate() - 1);
17124 dayName = date.toString().split(' ')[0].toUpperCase();
17125 $(date_from).datepicker('setDate', date);
17126 $(date_from).next('.date-input-weekday').text(dayName);
17127 }
17128 break;
17129 };
17130 }
17131 });
17132}
17133function getNumberOfDaysBetweenDates(firstDate, secondDate) {
17134 var oneDay = 24 * 60 * 60 * 1000; // hours*minutes*seconds*milliseconds
17135 firstDate = new Date(firstDate);
17136 secondDate = new Date(secondDate);
17137
17138 return Math.round(Math.abs((firstDate.getTime() - secondDate.getTime()) / oneDay));
17139}
17140
17141/***/ }),
17142/* 186 */,
17143/* 187 */,
17144/* 188 */,
17145/* 189 */,
17146/* 190 */,
17147/* 191 */,
17148/* 192 */,
17149/* 193 */,
17150/* 194 */,
17151/* 195 */,
17152/* 196 */,
17153/* 197 */,
17154/* 198 */,
17155/* 199 */,
17156/* 200 */,
17157/* 201 */,
17158/* 202 */,
17159/* 203 */,
17160/* 204 */,
17161/* 205 */,
17162/* 206 */,
17163/* 207 */,
17164/* 208 */,
17165/* 209 */,
17166/* 210 */,
17167/* 211 */,
17168/* 212 */,
17169/* 213 */,
17170/* 214 */,
17171/* 215 */,
17172/* 216 */,
17173/* 217 */,
17174/* 218 */,
17175/* 219 */,
17176/* 220 */,
17177/* 221 */,
17178/* 222 */,
17179/* 223 */,
17180/* 224 */,
17181/* 225 */,
17182/* 226 */,
17183/* 227 */,
17184/* 228 */,
17185/* 229 */,
17186/* 230 */,
17187/* 231 */,
17188/* 232 */,
17189/* 233 */,
17190/* 234 */,
17191/* 235 */,
17192/* 236 */,
17193/* 237 */,
17194/* 238 */,
17195/* 239 */,
17196/* 240 */,
17197/* 241 */,
17198/* 242 */,
17199/* 243 */,
17200/* 244 */,
17201/* 245 */,
17202/* 246 */,
17203/* 247 */,
17204/* 248 */,
17205/* 249 */,
17206/* 250 */
17207/***/ (function(module, exports, __webpack_require__) {
17208
17209module.exports = __webpack_require__(162);
17210
17211
17212/***/ })
17213/******/ ]);