| blob | b8f0313f462140f122e1ca4b6cf6e900a81b72f1 |
1 ;(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
3 typeof define === 'function' && define.amd ? define(factory) :
4 global.moment = factory()
5 }(this, function () { 'use strict';
7 var hookCallback;
9 function utils_hooks__hooks () {
10 return hookCallback.apply(null, arguments);
11 }
13 // This is done to register the method called with moment()
14 // without creating circular dependencies.
15 function setHookCallback (callback) {
16 hookCallback = callback;
17 }
19 function isArray(input) {
20 return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
21 }
23 function isDate(input) {
24 return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
25 }
27 function map(arr, fn) {
28 var res = [], i;
29 for (i = 0; i < arr.length; ++i) {
30 res.push(fn(arr[i], i));
31 }
32 return res;
33 }
35 function hasOwnProp(a, b) {
36 return Object.prototype.hasOwnProperty.call(a, b);
37 }
39 function extend(a, b) {
40 for (var i in b) {
41 if (hasOwnProp(b, i)) {
42 a[i] = b[i];
43 }
44 }
46 if (hasOwnProp(b, 'toString')) {
47 a.toString = b.toString;
48 }
50 if (hasOwnProp(b, 'valueOf')) {
51 a.valueOf = b.valueOf;
52 }
54 return a;
55 }
57 function create_utc__createUTC (input, format, locale, strict) {
58 return createLocalOrUTC(input, format, locale, strict, true).utc();
59 }
61 function defaultParsingFlags() {
62 // We need to deep clone this object.
63 return {
64 empty : false,
65 unusedTokens : [],
66 unusedInput : [],
67 overflow : -2,
68 charsLeftOver : 0,
69 nullInput : false,
70 invalidMonth : null,
71 invalidFormat : false,
72 userInvalidated : false,
73 iso : false,
74 parsedDateParts : [],
75 meridiem : null
76 };
77 }
79 function getParsingFlags(m) {
80 if (m._pf == null) {
81 m._pf = defaultParsingFlags();
82 }
83 return m._pf;
84 }
86 var some;
87 if (Array.prototype.some) {
88 some = Array.prototype.some;
89 } else {
90 some = function (fun) {
91 var t = Object(this);
92 var len = t.length >>> 0;
94 for (var i = 0; i < len; i++) {
95 if (i in t && fun.call(this, t[i], i, t)) {
96 return true;
97 }
98 }
100 return false;
101 };
102 }
104 function valid__isValid(m) {
105 if (m._isValid == null) {
106 var flags = getParsingFlags(m);
107 var parsedParts = some.call(flags.parsedDateParts, function (i) {
108 return i != null;
109 });
110 m._isValid = !isNaN(m._d.getTime()) &&
111 flags.overflow < 0 &&
112 !flags.empty &&
113 !flags.invalidMonth &&
114 !flags.invalidWeekday &&
115 !flags.nullInput &&
116 !flags.invalidFormat &&
117 !flags.userInvalidated &&
118 (!flags.meridiem || (flags.meridiem && parsedParts));
120 if (m._strict) {
121 m._isValid = m._isValid &&
122 flags.charsLeftOver === 0 &&
123 flags.unusedTokens.length === 0 &&
124 flags.bigHour === undefined;
125 }
126 }
127 return m._isValid;
128 }
130 function valid__createInvalid (flags) {
131 var m = create_utc__createUTC(NaN);
132 if (flags != null) {
133 extend(getParsingFlags(m), flags);
134 }
135 else {
136 getParsingFlags(m).userInvalidated = true;
137 }
139 return m;
140 }
142 function isUndefined(input) {
143 return input === void 0;
144 }
146 // Plugins that add properties should also add the key here (null value),
147 // so we can properly clone ourselves.
148 var momentProperties = utils_hooks__hooks.momentProperties = [];
150 function copyConfig(to, from) {
151 var i, prop, val;
153 if (!isUndefined(from._isAMomentObject)) {
154 to._isAMomentObject = from._isAMomentObject;
155 }
156 if (!isUndefined(from._i)) {
157 to._i = from._i;
158 }
159 if (!isUndefined(from._f)) {
160 to._f = from._f;
161 }
162 if (!isUndefined(from._l)) {
163 to._l = from._l;
164 }
165 if (!isUndefined(from._strict)) {
166 to._strict = from._strict;
167 }
168 if (!isUndefined(from._tzm)) {
169 to._tzm = from._tzm;
170 }
171 if (!isUndefined(from._isUTC)) {
172 to._isUTC = from._isUTC;
173 }
174 if (!isUndefined(from._offset)) {
175 to._offset = from._offset;
176 }
177 if (!isUndefined(from._pf)) {
178 to._pf = getParsingFlags(from);
179 }
180 if (!isUndefined(from._locale)) {
181 to._locale = from._locale;
182 }
184 if (momentProperties.length > 0) {
185 for (i in momentProperties) {
186 prop = momentProperties[i];
187 val = from[prop];
188 if (!isUndefined(val)) {
189 to[prop] = val;
190 }
191 }
192 }
194 return to;
195 }
197 var updateInProgress = false;
199 // Moment prototype object
200 function Moment(config) {
201 copyConfig(this, config);
202 this._d = new Date(config._d != null ? config._d.getTime() : NaN);
203 // Prevent infinite loop in case updateOffset creates new moment
204 // objects.
205 if (updateInProgress === false) {
206 updateInProgress = true;
207 utils_hooks__hooks.updateOffset(this);
208 updateInProgress = false;
209 }
210 }
212 function isMoment (obj) {
213 return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
214 }
216 function absFloor (number) {
217 if (number < 0) {
218 return Math.ceil(number);
219 } else {
220 return Math.floor(number);
221 }
222 }
224 function toInt(argumentForCoercion) {
225 var coercedNumber = +argumentForCoercion,
226 value = 0;
228 if (coercedNumber !== 0 && isFinite(coercedNumber)) {
229 value = absFloor(coercedNumber);
230 }
232 return value;
233 }
235 // compare two arrays, return the number of differences
236 function compareArrays(array1, array2, dontConvert) {
237 var len = Math.min(array1.length, array2.length),
238 lengthDiff = Math.abs(array1.length - array2.length),
239 diffs = 0,
240 i;
241 for (i = 0; i < len; i++) {
242 if ((dontConvert && array1[i] !== array2[i]) ||
243 (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
244 diffs++;
245 }
246 }
247 return diffs + lengthDiff;
248 }
250 function warn(msg) {
251 if (utils_hooks__hooks.suppressDeprecationWarnings === false &&
252 (typeof console !== 'undefined') && console.warn) {
253 console.warn('Deprecation warning: ' + msg);
254 }
255 }
257 function deprecate(msg, fn) {
258 var firstTime = true;
260 return extend(function () {
261 if (utils_hooks__hooks.deprecationHandler != null) {
262 utils_hooks__hooks.deprecationHandler(null, msg);
263 }
264 if (firstTime) {
265 warn(msg + '\nArguments: ' + Array.prototype.slice.call(arguments).join(', ') + '\n' + (new Error()).stack);
266 firstTime = false;
267 }
268 return fn.apply(this, arguments);
269 }, fn);
270 }
272 var deprecations = {};
274 function deprecateSimple(name, msg) {
275 if (utils_hooks__hooks.deprecationHandler != null) {
276 utils_hooks__hooks.deprecationHandler(name, msg);
277 }
278 if (!deprecations[name]) {
279 warn(msg);
280 deprecations[name] = true;
281 }
282 }
284 utils_hooks__hooks.suppressDeprecationWarnings = false;
285 utils_hooks__hooks.deprecationHandler = null;
287 function isFunction(input) {
288 return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
289 }
291 function isObject(input) {
292 return Object.prototype.toString.call(input) === '[object Object]';
293 }
295 function locale_set__set (config) {
296 var prop, i;
297 for (i in config) {
298 prop = config[i];
299 if (isFunction(prop)) {
300 this[i] = prop;
301 } else {
302 this['_' + i] = prop;
303 }
304 }
305 this._config = config;
306 // Lenient ordinal parsing accepts just a number in addition to
307 // number + (possibly) stuff coming from _ordinalParseLenient.
308 this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
309 }
311 function mergeConfigs(parentConfig, childConfig) {
312 var res = extend({}, parentConfig), prop;
313 for (prop in childConfig) {
314 if (hasOwnProp(childConfig, prop)) {
315 if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
316 res[prop] = {};
317 extend(res[prop], parentConfig[prop]);
318 extend(res[prop], childConfig[prop]);
319 } else if (childConfig[prop] != null) {
320 res[prop] = childConfig[prop];
321 } else {
322 delete res[prop];
323 }
324 }
325 }
326 return res;
327 }
329 function Locale(config) {
330 if (config != null) {
331 this.set(config);
332 }
333 }
335 var keys;
337 if (Object.keys) {
338 keys = Object.keys;
339 } else {
340 keys = function (obj) {
341 var i, res = [];
342 for (i in obj) {
343 if (hasOwnProp(obj, i)) {
344 res.push(i);
345 }
346 }
347 return res;
348 };
349 }
351 // internal storage for locale config files
352 var locales = {};
353 var globalLocale;
355 function normalizeLocale(key) {
356 return key ? key.toLowerCase().replace('_', '-') : key;
357 }
359 // pick the locale from the array
360 // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
361 // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
362 function chooseLocale(names) {
363 var i = 0, j, next, locale, split;
365 while (i < names.length) {
366 split = normalizeLocale(names[i]).split('-');
367 j = split.length;
368 next = normalizeLocale(names[i + 1]);
369 next = next ? next.split('-') : null;
370 while (j > 0) {
371 locale = loadLocale(split.slice(0, j).join('-'));
372 if (locale) {
373 return locale;
374 }
375 if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
376 //the next array item is better than a shallower substring of this one
377 break;
378 }
379 j--;
380 }
381 i++;
382 }
383 return null;
384 }
386 function loadLocale(name) {
387 var oldLocale = null;
388 // TODO: Find a better way to register and load all the locales in Node
389 if (!locales[name] && (typeof module !== 'undefined') &&
390 module && module.exports) {
391 try {
392 oldLocale = globalLocale._abbr;
393 require('./locale/' + name);
394 // because defineLocale currently also sets the global locale, we
395 // want to undo that for lazy loaded locales
396 locale_locales__getSetGlobalLocale(oldLocale);
397 } catch (e) { }
398 }
399 return locales[name];
400 }
402 // This function will load locale and then set the global locale. If
403 // no arguments are passed in, it will simply return the current global
404 // locale key.
405 function locale_locales__getSetGlobalLocale (key, values) {
406 var data;
407 if (key) {
408 if (isUndefined(values)) {
409 data = locale_locales__getLocale(key);
410 }
411 else {
412 data = defineLocale(key, values);
413 }
415 if (data) {
416 // moment.duration._locale = moment._locale = data;
417 globalLocale = data;
418 }
419 }
421 return globalLocale._abbr;
422 }
424 function defineLocale (name, config) {
425 if (config !== null) {
426 config.abbr = name;
427 if (locales[name] != null) {
428 deprecateSimple('defineLocaleOverride',
429 'use moment.updateLocale(localeName, config) to change ' +
430 'an existing locale. moment.defineLocale(localeName, ' +
431 'config) should only be used for creating a new locale');
432 config = mergeConfigs(locales[name]._config, config);
433 } else if (config.parentLocale != null) {
434 if (locales[config.parentLocale] != null) {
435 config = mergeConfigs(locales[config.parentLocale]._config, config);
436 } else {
437 // treat as if there is no base config
438 deprecateSimple('parentLocaleUndefined',
439 'specified parentLocale is not defined yet');
440 }
441 }
442 locales[name] = new Locale(config);
444 // backwards compat for now: also set the locale
445 locale_locales__getSetGlobalLocale(name);
447 return locales[name];
448 } else {
449 // useful for testing
450 delete locales[name];
451 return null;
452 }
453 }
455 function updateLocale(name, config) {
456 if (config != null) {
457 var locale;
458 if (locales[name] != null) {
459 config = mergeConfigs(locales[name]._config, config);
460 }
461 locale = new Locale(config);
462 locale.parentLocale = locales[name];
463 locales[name] = locale;
465 // backwards compat for now: also set the locale
466 locale_locales__getSetGlobalLocale(name);
467 } else {
468 // pass null for config to unupdate, useful for tests
469 if (locales[name] != null) {
470 if (locales[name].parentLocale != null) {
471 locales[name] = locales[name].parentLocale;
472 } else if (locales[name] != null) {
473 delete locales[name];
474 }
475 }
476 }
477 return locales[name];
478 }
480 // returns locale data
481 function locale_locales__getLocale (key) {
482 var locale;
484 if (key && key._locale && key._locale._abbr) {
485 key = key._locale._abbr;
486 }
488 if (!key) {
489 return globalLocale;
490 }
492 if (!isArray(key)) {
493 //short-circuit everything else
494 locale = loadLocale(key);
495 if (locale) {
496 return locale;
497 }
498 key = [key];
499 }
501 return chooseLocale(key);
502 }
504 function locale_locales__listLocales() {
505 return keys(locales);
506 }
508 var aliases = {};
510 function addUnitAlias (unit, shorthand) {
511 var lowerCase = unit.toLowerCase();
512 aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
513 }
515 function normalizeUnits(units) {
516 return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
517 }
519 function normalizeObjectUnits(inputObject) {
520 var normalizedInput = {},
521 normalizedProp,
522 prop;
524 for (prop in inputObject) {
525 if (hasOwnProp(inputObject, prop)) {
526 normalizedProp = normalizeUnits(prop);
527 if (normalizedProp) {
528 normalizedInput[normalizedProp] = inputObject[prop];
529 }
530 }
531 }
533 return normalizedInput;
534 }
536 function makeGetSet (unit, keepTime) {
537 return function (value) {
538 if (value != null) {
539 get_set__set(this, unit, value);
540 utils_hooks__hooks.updateOffset(this, keepTime);
541 return this;
542 } else {
543 return get_set__get(this, unit);
544 }
545 };
546 }
548 function get_set__get (mom, unit) {
549 return mom.isValid() ?
550 mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
551 }
553 function get_set__set (mom, unit, value) {
554 if (mom.isValid()) {
555 mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
556 }
557 }
559 // MOMENTS
561 function getSet (units, value) {
562 var unit;
563 if (typeof units === 'object') {
564 for (unit in units) {
565 this.set(unit, units[unit]);
566 }
567 } else {
568 units = normalizeUnits(units);
569 if (isFunction(this[units])) {
570 return this[units](value);
571 }
572 }
573 return this;
574 }
576 function zeroFill(number, targetLength, forceSign) {
577 var absNumber = '' + Math.abs(number),
578 zerosToFill = targetLength - absNumber.length,
579 sign = number >= 0;
580 return (sign ? (forceSign ? '+' : '') : '-') +
581 Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
582 }
584 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;
586 var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
588 var formatFunctions = {};
590 var formatTokenFunctions = {};
592 // token: 'M'
593 // padded: ['MM', 2]
594 // ordinal: 'Mo'
595 // callback: function () { this.month() + 1 }
596 function addFormatToken (token, padded, ordinal, callback) {
597 var func = callback;
598 if (typeof callback === 'string') {
599 func = function () {
600 return this[callback]();
601 };
602 }
603 if (token) {
604 formatTokenFunctions[token] = func;
605 }
606 if (padded) {
607 formatTokenFunctions[padded[0]] = function () {
608 return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
609 };
610 }
611 if (ordinal) {
612 formatTokenFunctions[ordinal] = function () {
613 return this.localeData().ordinal(func.apply(this, arguments), token);
614 };
615 }
616 }
618 function removeFormattingTokens(input) {
619 if (input.match(/\[[\s\S]/)) {
620 return input.replace(/^\[|\]$/g, '');
621 }
622 return input.replace(/\\/g, '');
623 }
625 function makeFormatFunction(format) {
626 var array = format.match(formattingTokens), i, length;
628 for (i = 0, length = array.length; i < length; i++) {
629 if (formatTokenFunctions[array[i]]) {
630 array[i] = formatTokenFunctions[array[i]];
631 } else {
632 array[i] = removeFormattingTokens(array[i]);
633 }
634 }
636 return function (mom) {
637 var output = '', i;
638 for (i = 0; i < length; i++) {
639 output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
640 }
641 return output;
642 };
643 }
645 // format date using native date object
646 function formatMoment(m, format) {
647 if (!m.isValid()) {
648 return m.localeData().invalidDate();
649 }
651 format = expandFormat(format, m.localeData());
652 formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
654 return formatFunctions[format](m);
655 }
657 function expandFormat(format, locale) {
658 var i = 5;
660 function replaceLongDateFormatTokens(input) {
661 return locale.longDateFormat(input) || input;
662 }
664 localFormattingTokens.lastIndex = 0;
665 while (i >= 0 && localFormattingTokens.test(format)) {
666 format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
667 localFormattingTokens.lastIndex = 0;
668 i -= 1;
669 }
671 return format;
672 }
674 var match1 = /\d/; // 0 - 9
675 var match2 = /\d\d/; // 00 - 99
676 var match3 = /\d{3}/; // 000 - 999
677 var match4 = /\d{4}/; // 0000 - 9999
678 var match6 = /[+-]?\d{6}/; // -999999 - 999999
679 var match1to2 = /\d\d?/; // 0 - 99
680 var match3to4 = /\d\d\d\d?/; // 999 - 9999
681 var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999
682 var match1to3 = /\d{1,3}/; // 0 - 999
683 var match1to4 = /\d{1,4}/; // 0 - 9999
684 var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
686 var matchUnsigned = /\d+/; // 0 - inf
687 var matchSigned = /[+-]?\d+/; // -inf - inf
689 var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
690 var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
692 var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
694 // any word (or two) characters or numbers including two/three word month in arabic.
695 // includes scottish gaelic two word and hyphenated months
696 var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
699 var regexes = {};
701 function addRegexToken (token, regex, strictRegex) {
702 regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
703 return (isStrict && strictRegex) ? strictRegex : regex;
704 };
705 }
707 function getParseRegexForToken (token, config) {
708 if (!hasOwnProp(regexes, token)) {
709 return new RegExp(unescapeFormat(token));
710 }
712 return regexes[token](config._strict, config._locale);
713 }
715 // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
716 function unescapeFormat(s) {
717 return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
718 return p1 || p2 || p3 || p4;
719 }));
720 }
722 function regexEscape(s) {
723 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
724 }
726 var tokens = {};
728 function addParseToken (token, callback) {
729 var i, func = callback;
730 if (typeof token === 'string') {
731 token = [token];
732 }
733 if (typeof callback === 'number') {
734 func = function (input, array) {
735 array[callback] = toInt(input);
736 };
737 }
738 for (i = 0; i < token.length; i++) {
739 tokens[token[i]] = func;
740 }
741 }
743 function addWeekParseToken (token, callback) {
744 addParseToken(token, function (input, array, config, token) {
745 config._w = config._w || {};
746 callback(input, config._w, config, token);
747 });
748 }
750 function addTimeToArrayFromToken(token, input, config) {
751 if (input != null && hasOwnProp(tokens, token)) {
752 tokens[token](input, config._a, config, token);
753 }
754 }
756 var YEAR = 0;
757 var MONTH = 1;
758 var DATE = 2;
759 var HOUR = 3;
760 var MINUTE = 4;
761 var SECOND = 5;
762 var MILLISECOND = 6;
763 var WEEK = 7;
764 var WEEKDAY = 8;
766 var indexOf;
768 if (Array.prototype.indexOf) {
769 indexOf = Array.prototype.indexOf;
770 } else {
771 indexOf = function (o) {
772 // I know
773 var i;
774 for (i = 0; i < this.length; ++i) {
775 if (this[i] === o) {
776 return i;
777 }
778 }
779 return -1;
780 };
781 }
783 function daysInMonth(year, month) {
784 return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
785 }
787 // FORMATTING
789 addFormatToken('M', ['MM', 2], 'Mo', function () {
790 return this.month() + 1;
791 });
793 addFormatToken('MMM', 0, 0, function (format) {
794 return this.localeData().monthsShort(this, format);
795 });
797 addFormatToken('MMMM', 0, 0, function (format) {
798 return this.localeData().months(this, format);
799 });
801 // ALIASES
803 addUnitAlias('month', 'M');
805 // PARSING
807 addRegexToken('M', match1to2);
808 addRegexToken('MM', match1to2, match2);
809 addRegexToken('MMM', function (isStrict, locale) {
810 return locale.monthsShortRegex(isStrict);
811 });
812 addRegexToken('MMMM', function (isStrict, locale) {
813 return locale.monthsRegex(isStrict);
814 });
816 addParseToken(['M', 'MM'], function (input, array) {
817 array[MONTH] = toInt(input) - 1;
818 });
820 addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
821 var month = config._locale.monthsParse(input, token, config._strict);
822 // if we didn't find a month name, mark the date as invalid.
823 if (month != null) {
824 array[MONTH] = month;
825 } else {
826 getParsingFlags(config).invalidMonth = input;
827 }
828 });
830 // LOCALES
832 var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/;
833 var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
834 function localeMonths (m, format) {
835 return isArray(this._months) ? this._months[m.month()] :
836 this._months[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
837 }
839 var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
840 function localeMonthsShort (m, format) {
841 return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
842 this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
843 }
845 function units_month__handleStrictParse(monthName, format, strict) {
846 var i, ii, mom, llc = monthName.toLocaleLowerCase();
847 if (!this._monthsParse) {
848 // this is not used
849 this._monthsParse = [];
850 this._longMonthsParse = [];
851 this._shortMonthsParse = [];
852 for (i = 0; i < 12; ++i) {
853 mom = create_utc__createUTC([2000, i]);
854 this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
855 this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
856 }
857 }
859 if (strict) {
860 if (format === 'MMM') {
861 ii = indexOf.call(this._shortMonthsParse, llc);
862 return ii !== -1 ? ii : null;
863 } else {
864 ii = indexOf.call(this._longMonthsParse, llc);
865 return ii !== -1 ? ii : null;
866 }
867 } else {
868 if (format === 'MMM') {
869 ii = indexOf.call(this._shortMonthsParse, llc);
870 if (ii !== -1) {
871 return ii;
872 }
873 ii = indexOf.call(this._longMonthsParse, llc);
874 return ii !== -1 ? ii : null;
875 } else {
876 ii = indexOf.call(this._longMonthsParse, llc);
877 if (ii !== -1) {
878 return ii;
879 }
880 ii = indexOf.call(this._shortMonthsParse, llc);
881 return ii !== -1 ? ii : null;
882 }
883 }
884 }
886 function localeMonthsParse (monthName, format, strict) {
887 var i, mom, regex;
889 if (this._monthsParseExact) {
890 return units_month__handleStrictParse.call(this, monthName, format, strict);
891 }
893 if (!this._monthsParse) {
894 this._monthsParse = [];
895 this._longMonthsParse = [];
896 this._shortMonthsParse = [];
897 }
899 // TODO: add sorting
900 // Sorting makes sure if one month (or abbr) is a prefix of another
901 // see sorting in computeMonthsParse
902 for (i = 0; i < 12; i++) {
903 // make the regex if we don't have it already
904 mom = create_utc__createUTC([2000, i]);
905 if (strict && !this._longMonthsParse[i]) {
906 this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
907 this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
908 }
909 if (!strict && !this._monthsParse[i]) {
910 regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
911 this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
912 }
913 // test the regex
914 if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
915 return i;
916 } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
917 return i;
918 } else if (!strict && this._monthsParse[i].test(monthName)) {
919 return i;
920 }
921 }
922 }
924 // MOMENTS
926 function setMonth (mom, value) {
927 var dayOfMonth;
929 if (!mom.isValid()) {
930 // No op
931 return mom;
932 }
934 if (typeof value === 'string') {
935 if (/^\d+$/.test(value)) {
936 value = toInt(value);
937 } else {
938 value = mom.localeData().monthsParse(value);
939 // TODO: Another silent failure?
940 if (typeof value !== 'number') {
941 return mom;
942 }
943 }
944 }
946 dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
947 mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
948 return mom;
949 }
951 function getSetMonth (value) {
952 if (value != null) {
953 setMonth(this, value);
954 utils_hooks__hooks.updateOffset(this, true);
955 return this;
956 } else {
957 return get_set__get(this, 'Month');
958 }
959 }
961 function getDaysInMonth () {
962 return daysInMonth(this.year(), this.month());
963 }
965 var defaultMonthsShortRegex = matchWord;
966 function monthsShortRegex (isStrict) {
967 if (this._monthsParseExact) {
968 if (!hasOwnProp(this, '_monthsRegex')) {
969 computeMonthsParse.call(this);
970 }
971 if (isStrict) {
972 return this._monthsShortStrictRegex;
973 } else {
974 return this._monthsShortRegex;
975 }
976 } else {
977 return this._monthsShortStrictRegex && isStrict ?
978 this._monthsShortStrictRegex : this._monthsShortRegex;
979 }
980 }
982 var defaultMonthsRegex = matchWord;
983 function monthsRegex (isStrict) {
984 if (this._monthsParseExact) {
985 if (!hasOwnProp(this, '_monthsRegex')) {
986 computeMonthsParse.call(this);
987 }
988 if (isStrict) {
989 return this._monthsStrictRegex;
990 } else {
991 return this._monthsRegex;
992 }
993 } else {
994 return this._monthsStrictRegex && isStrict ?
995 this._monthsStrictRegex : this._monthsRegex;
996 }
997 }
999 function computeMonthsParse () {
1000 function cmpLenRev(a, b) {
1001 return b.length - a.length;
1002 }
1004 var shortPieces = [], longPieces = [], mixedPieces = [],
1005 i, mom;
1006 for (i = 0; i < 12; i++) {
1007 // make the regex if we don't have it already
1008 mom = create_utc__createUTC([2000, i]);
1009 shortPieces.push(this.monthsShort(mom, ''));
1010 longPieces.push(this.months(mom, ''));
1011 mixedPieces.push(this.months(mom, ''));
1012 mixedPieces.push(this.monthsShort(mom, ''));
1013 }
1014 // Sorting makes sure if one month (or abbr) is a prefix of another it
1015 // will match the longer piece.
1016 shortPieces.sort(cmpLenRev);
1017 longPieces.sort(cmpLenRev);
1018 mixedPieces.sort(cmpLenRev);
1019 for (i = 0; i < 12; i++) {
1020 shortPieces[i] = regexEscape(shortPieces[i]);
1021 longPieces[i] = regexEscape(longPieces[i]);
1022 mixedPieces[i] = regexEscape(mixedPieces[i]);
1023 }
1025 this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1026 this._monthsShortRegex = this._monthsRegex;
1027 this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1028 this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1029 }
1031 function checkOverflow (m) {
1032 var overflow;
1033 var a = m._a;
1035 if (a && getParsingFlags(m).overflow === -2) {
1036 overflow =
1037 a[MONTH] < 0 || a[MONTH] > 11 ? MONTH :
1038 a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
1039 a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
1040 a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE :
1041 a[SECOND] < 0 || a[SECOND] > 59 ? SECOND :
1042 a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
1043 -1;
1045 if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
1046 overflow = DATE;
1047 }
1048 if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
1049 overflow = WEEK;
1050 }
1051 if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
1052 overflow = WEEKDAY;
1053 }
1055 getParsingFlags(m).overflow = overflow;
1056 }
1058 return m;
1059 }
1061 // iso 8601 regex
1062 // 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)
1063 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)?)?/;
1064 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)?)?/;
1066 var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
1068 var isoDates = [
1069 ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
1070 ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
1071 ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
1072 ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
1073 ['YYYY-DDD', /\d{4}-\d{3}/],
1074 ['YYYY-MM', /\d{4}-\d\d/, false],
1075 ['YYYYYYMMDD', /[+-]\d{10}/],
1076 ['YYYYMMDD', /\d{8}/],
1077 // YYYYMM is NOT allowed by the standard
1078 ['GGGG[W]WWE', /\d{4}W\d{3}/],
1079 ['GGGG[W]WW', /\d{4}W\d{2}/, false],
1080 ['YYYYDDD', /\d{7}/]
1081 ];
1083 // iso time formats and regexes
1084 var isoTimes = [
1085 ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
1086 ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
1087 ['HH:mm:ss', /\d\d:\d\d:\d\d/],
1088 ['HH:mm', /\d\d:\d\d/],
1089 ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
1090 ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
1091 ['HHmmss', /\d\d\d\d\d\d/],
1092 ['HHmm', /\d\d\d\d/],
1093 ['HH', /\d\d/]
1094 ];
1096 var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
1098 // date from iso format
1099 function configFromISO(config) {
1100 var i, l,
1101 string = config._i,
1102 match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
1103 allowTime, dateFormat, timeFormat, tzFormat;
1105 if (match) {
1106 getParsingFlags(config).iso = true;
1108 for (i = 0, l = isoDates.length; i < l; i++) {
1109 if (isoDates[i][1].exec(match[1])) {
1110 dateFormat = isoDates[i][0];
1111 allowTime = isoDates[i][2] !== false;
1112 break;
1113 }
1114 }
1115 if (dateFormat == null) {
1116 config._isValid = false;
1117 return;
1118 }
1119 if (match[3]) {
1120 for (i = 0, l = isoTimes.length; i < l; i++) {
1121 if (isoTimes[i][1].exec(match[3])) {
1122 // match[2] should be 'T' or space
1123 timeFormat = (match[2] || ' ') + isoTimes[i][0];
1124 break;
1125 }
1126 }
1127 if (timeFormat == null) {
1128 config._isValid = false;
1129 return;
1130 }
1131 }
1132 if (!allowTime && timeFormat != null) {
1133 config._isValid = false;
1134 return;
1135 }
1136 if (match[4]) {
1137 if (tzRegex.exec(match[4])) {
1138 tzFormat = 'Z';
1139 } else {
1140 config._isValid = false;
1141 return;
1142 }
1143 }
1144 config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
1145 configFromStringAndFormat(config);
1146 } else {
1147 config._isValid = false;
1148 }
1149 }
1151 // date from iso format or fallback
1152 function configFromString(config) {
1153 var matched = aspNetJsonRegex.exec(config._i);
1155 if (matched !== null) {
1156 config._d = new Date(+matched[1]);
1157 return;
1158 }
1160 configFromISO(config);
1161 if (config._isValid === false) {
1162 delete config._isValid;
1163 utils_hooks__hooks.createFromInputFallback(config);
1164 }
1165 }
1167 utils_hooks__hooks.createFromInputFallback = deprecate(
1168 'moment construction falls back to js Date. This is ' +
1169 'discouraged and will be removed in upcoming major ' +
1170 'release. Please refer to ' +
1171 'https://github.com/moment/moment/issues/1407 for more info.',
1172 function (config) {
1173 config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
1174 }
1175 );
1177 function createDate (y, m, d, h, M, s, ms) {
1178 //can't just apply() to create a date:
1179 //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
1180 var date = new Date(y, m, d, h, M, s, ms);
1182 //the date constructor remaps years 0-99 to 1900-1999
1183 if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
1184 date.setFullYear(y);
1185 }
1186 return date;
1187 }
1189 function createUTCDate (y) {
1190 var date = new Date(Date.UTC.apply(null, arguments));
1192 //the Date.UTC function remaps years 0-99 to 1900-1999
1193 if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
1194 date.setUTCFullYear(y);
1195 }
1196 return date;
1197 }
1199 // FORMATTING
1201 addFormatToken('Y', 0, 0, function () {
1202 var y = this.year();
1203 return y <= 9999 ? '' + y : '+' + y;
1204 });
1206 addFormatToken(0, ['YY', 2], 0, function () {
1207 return this.year() % 100;
1208 });
1210 addFormatToken(0, ['YYYY', 4], 0, 'year');
1211 addFormatToken(0, ['YYYYY', 5], 0, 'year');
1212 addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
1214 // ALIASES
1216 addUnitAlias('year', 'y');
1218 // PARSING
1220 addRegexToken('Y', matchSigned);
1221 addRegexToken('YY', match1to2, match2);
1222 addRegexToken('YYYY', match1to4, match4);
1223 addRegexToken('YYYYY', match1to6, match6);
1224 addRegexToken('YYYYYY', match1to6, match6);
1226 addParseToken(['YYYYY', 'YYYYYY'], YEAR);
1227 addParseToken('YYYY', function (input, array) {
1228 array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input);
1229 });
1230 addParseToken('YY', function (input, array) {
1231 array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
1232 });
1233 addParseToken('Y', function (input, array) {
1234 array[YEAR] = parseInt(input, 10);
1235 });
1237 // HELPERS
1239 function daysInYear(year) {
1240 return isLeapYear(year) ? 366 : 365;
1241 }
1243 function isLeapYear(year) {
1244 return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
1245 }
1247 // HOOKS
1249 utils_hooks__hooks.parseTwoDigitYear = function (input) {
1250 return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
1251 };
1253 // MOMENTS
1255 var getSetYear = makeGetSet('FullYear', true);
1257 function getIsLeapYear () {
1258 return isLeapYear(this.year());
1259 }
1261 // start-of-first-week - start-of-year
1262 function firstWeekOffset(year, dow, doy) {
1263 var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1264 fwd = 7 + dow - doy,
1265 // first-week day local weekday -- which local weekday is fwd
1266 fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1268 return -fwdlw + fwd - 1;
1269 }
1271 //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1272 function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1273 var localWeekday = (7 + weekday - dow) % 7,
1274 weekOffset = firstWeekOffset(year, dow, doy),
1275 dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1276 resYear, resDayOfYear;
1278 if (dayOfYear <= 0) {
1279 resYear = year - 1;
1280 resDayOfYear = daysInYear(resYear) + dayOfYear;
1281 } else if (dayOfYear > daysInYear(year)) {
1282 resYear = year + 1;
1283 resDayOfYear = dayOfYear - daysInYear(year);
1284 } else {
1285 resYear = year;
1286 resDayOfYear = dayOfYear;
1287 }
1289 return {
1290 year: resYear,
1291 dayOfYear: resDayOfYear
1292 };
1293 }
1295 function weekOfYear(mom, dow, doy) {
1296 var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1297 week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1298 resWeek, resYear;
1300 if (week < 1) {
1301 resYear = mom.year() - 1;
1302 resWeek = week + weeksInYear(resYear, dow, doy);
1303 } else if (week > weeksInYear(mom.year(), dow, doy)) {
1304 resWeek = week - weeksInYear(mom.year(), dow, doy);
1305 resYear = mom.year() + 1;
1306 } else {
1307 resYear = mom.year();
1308 resWeek = week;
1309 }
1311 return {
1312 week: resWeek,
1313 year: resYear
1314 };
1315 }
1317 function weeksInYear(year, dow, doy) {
1318 var weekOffset = firstWeekOffset(year, dow, doy),
1319 weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1320 return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1321 }
1323 // Pick the first defined of two or three arguments.
1324 function defaults(a, b, c) {
1325 if (a != null) {
1326 return a;
1327 }
1328 if (b != null) {
1329 return b;
1330 }
1331 return c;
1332 }
1334 function currentDateArray(config) {
1335 // hooks is actually the exported moment object
1336 var nowValue = new Date(utils_hooks__hooks.now());
1337 if (config._useUTC) {
1338 return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
1339 }
1340 return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
1341 }
1343 // convert an array to a date.
1344 // the array should mirror the parameters below
1345 // note: all values past the year are optional and will default to the lowest possible value.
1346 // [year, month, day , hour, minute, second, millisecond]
1347 function configFromArray (config) {
1348 var i, date, input = [], currentDate, yearToUse;
1350 if (config._d) {
1351 return;
1352 }
1354 currentDate = currentDateArray(config);
1356 //compute day of the year from weeks and weekdays
1357 if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
1358 dayOfYearFromWeekInfo(config);
1359 }
1361 //if the day of the year is set, figure out what it is
1362 if (config._dayOfYear) {
1363 yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
1365 if (config._dayOfYear > daysInYear(yearToUse)) {
1366 getParsingFlags(config)._overflowDayOfYear = true;
1367 }
1369 date = createUTCDate(yearToUse, 0, config._dayOfYear);
1370 config._a[MONTH] = date.getUTCMonth();
1371 config._a[DATE] = date.getUTCDate();
1372 }
1374 // Default to current date.
1375 // * if no year, month, day of month are given, default to today
1376 // * if day of month is given, default month and year
1377 // * if month is given, default only year
1378 // * if year is given, don't default anything
1379 for (i = 0; i < 3 && config._a[i] == null; ++i) {
1380 config._a[i] = input[i] = currentDate[i];
1381 }
1383 // Zero out whatever was not defaulted, including time
1384 for (; i < 7; i++) {
1385 config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
1386 }
1388 // Check for 24:00:00.000
1389 if (config._a[HOUR] === 24 &&
1390 config._a[MINUTE] === 0 &&
1391 config._a[SECOND] === 0 &&
1392 config._a[MILLISECOND] === 0) {
1393 config._nextDay = true;
1394 config._a[HOUR] = 0;
1395 }
1397 config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
1398 // Apply timezone offset from input. The actual utcOffset can be changed
1399 // with parseZone.
1400 if (config._tzm != null) {
1401 config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
1402 }
1404 if (config._nextDay) {
1405 config._a[HOUR] = 24;
1406 }
1407 }
1409 function dayOfYearFromWeekInfo(config) {
1410 var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
1412 w = config._w;
1413 if (w.GG != null || w.W != null || w.E != null) {
1414 dow = 1;
1415 doy = 4;
1417 // TODO: We need to take the current isoWeekYear, but that depends on
1418 // how we interpret now (local, utc, fixed offset). So create
1419 // a now version of current config (take local/utc/offset flags, and
1420 // create now).
1421 weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
1422 week = defaults(w.W, 1);
1423 weekday = defaults(w.E, 1);
1424 if (weekday < 1 || weekday > 7) {
1425 weekdayOverflow = true;
1426 }
1427 } else {
1428 dow = config._locale._week.dow;
1429 doy = config._locale._week.doy;
1431 weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
1432 week = defaults(w.w, 1);
1434 if (w.d != null) {
1435 // weekday -- low day numbers are considered next week
1436 weekday = w.d;
1437 if (weekday < 0 || weekday > 6) {
1438 weekdayOverflow = true;
1439 }
1440 } else if (w.e != null) {
1441 // local weekday -- counting starts from begining of week
1442 weekday = w.e + dow;
1443 if (w.e < 0 || w.e > 6) {
1444 weekdayOverflow = true;
1445 }
1446 } else {
1447 // default to begining of week
1448 weekday = dow;
1449 }
1450 }
1451 if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
1452 getParsingFlags(config)._overflowWeeks = true;
1453 } else if (weekdayOverflow != null) {
1454 getParsingFlags(config)._overflowWeekday = true;
1455 } else {
1456 temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
1457 config._a[YEAR] = temp.year;
1458 config._dayOfYear = temp.dayOfYear;
1459 }
1460 }
1462 // constant that refers to the ISO standard
1463 utils_hooks__hooks.ISO_8601 = function () {};
1465 // date from string and format string
1466 function configFromStringAndFormat(config) {
1467 // TODO: Move this to another part of the creation flow to prevent circular deps
1468 if (config._f === utils_hooks__hooks.ISO_8601) {
1469 configFromISO(config);
1470 return;
1471 }
1473 config._a = [];
1474 getParsingFlags(config).empty = true;
1476 // This array is used to make a Date, either with `new Date` or `Date.UTC`
1477 var string = '' + config._i,
1478 i, parsedInput, tokens, token, skipped,
1479 stringLength = string.length,
1480 totalParsedInputLength = 0;
1482 tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
1484 for (i = 0; i < tokens.length; i++) {
1485 token = tokens[i];
1486 parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
1487 // console.log('token', token, 'parsedInput', parsedInput,
1488 // 'regex', getParseRegexForToken(token, config));
1489 if (parsedInput) {
1490 skipped = string.substr(0, string.indexOf(parsedInput));
1491 if (skipped.length > 0) {
1492 getParsingFlags(config).unusedInput.push(skipped);
1493 }
1494 string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
1495 totalParsedInputLength += parsedInput.length;
1496 }
1497 // don't parse if it's not a known token
1498 if (formatTokenFunctions[token]) {
1499 if (parsedInput) {
1500 getParsingFlags(config).empty = false;
1501 }
1502 else {
1503 getParsingFlags(config).unusedTokens.push(token);
1504 }
1505 addTimeToArrayFromToken(token, parsedInput, config);
1506 }
1507 else if (config._strict && !parsedInput) {
1508 getParsingFlags(config).unusedTokens.push(token);
1509 }
1510 }
1512 // add remaining unparsed input length to the string
1513 getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
1514 if (string.length > 0) {
1515 getParsingFlags(config).unusedInput.push(string);
1516 }
1518 // clear _12h flag if hour is <= 12
1519 if (getParsingFlags(config).bigHour === true &&
1520 config._a[HOUR] <= 12 &&
1521 config._a[HOUR] > 0) {
1522 getParsingFlags(config).bigHour = undefined;
1523 }
1525 getParsingFlags(config).parsedDateParts = config._a.slice(0);
1526 getParsingFlags(config).meridiem = config._meridiem;
1527 // handle meridiem
1528 config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
1530 configFromArray(config);
1531 checkOverflow(config);
1532 }
1535 function meridiemFixWrap (locale, hour, meridiem) {
1536 var isPm;
1538 if (meridiem == null) {
1539 // nothing to do
1540 return hour;
1541 }
1542 if (locale.meridiemHour != null) {
1543 return locale.meridiemHour(hour, meridiem);
1544 } else if (locale.isPM != null) {
1545 // Fallback
1546 isPm = locale.isPM(meridiem);
1547 if (isPm && hour < 12) {
1548 hour += 12;
1549 }
1550 if (!isPm && hour === 12) {
1551 hour = 0;
1552 }
1553 return hour;
1554 } else {
1555 // this is not supposed to happen
1556 return hour;
1557 }
1558 }
1560 // date from string and array of format strings
1561 function configFromStringAndArray(config) {
1562 var tempConfig,
1563 bestMoment,
1565 scoreToBeat,
1566 i,
1567 currentScore;
1569 if (config._f.length === 0) {
1570 getParsingFlags(config).invalidFormat = true;
1571 config._d = new Date(NaN);
1572 return;
1573 }
1575 for (i = 0; i < config._f.length; i++) {
1576 currentScore = 0;
1577 tempConfig = copyConfig({}, config);
1578 if (config._useUTC != null) {
1579 tempConfig._useUTC = config._useUTC;
1580 }
1581 tempConfig._f = config._f[i];
1582 configFromStringAndFormat(tempConfig);
1584 if (!valid__isValid(tempConfig)) {
1585 continue;
1586 }
1588 // if there is any input that was not parsed add a penalty for that format
1589 currentScore += getParsingFlags(tempConfig).charsLeftOver;
1591 //or tokens
1592 currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
1594 getParsingFlags(tempConfig).score = currentScore;
1596 if (scoreToBeat == null || currentScore < scoreToBeat) {
1597 scoreToBeat = currentScore;
1598 bestMoment = tempConfig;
1599 }
1600 }
1602 extend(config, bestMoment || tempConfig);
1603 }
1605 function configFromObject(config) {
1606 if (config._d) {
1607 return;
1608 }
1610 var i = normalizeObjectUnits(config._i);
1611 config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
1612 return obj && parseInt(obj, 10);
1613 });
1615 configFromArray(config);
1616 }
1618 function createFromConfig (config) {
1619 var res = new Moment(checkOverflow(prepareConfig(config)));
1620 if (res._nextDay) {
1621 // Adding is smart enough around DST
1622 res.add(1, 'd');
1623 res._nextDay = undefined;
1624 }
1626 return res;
1627 }
1629 function prepareConfig (config) {
1630 var input = config._i,
1631 format = config._f;
1633 config._locale = config._locale || locale_locales__getLocale(config._l);
1635 if (input === null || (format === undefined && input === '')) {
1636 return valid__createInvalid({nullInput: true});
1637 }
1639 if (typeof input === 'string') {
1640 config._i = input = config._locale.preparse(input);
1641 }
1643 if (isMoment(input)) {
1644 return new Moment(checkOverflow(input));
1645 } else if (isArray(format)) {
1646 configFromStringAndArray(config);
1647 } else if (format) {
1648 configFromStringAndFormat(config);
1649 } else if (isDate(input)) {
1650 config._d = input;
1651 } else {
1652 configFromInput(config);
1653 }
1655 if (!valid__isValid(config)) {
1656 config._d = null;
1657 }
1659 return config;
1660 }
1662 function configFromInput(config) {
1663 var input = config._i;
1664 if (input === undefined) {
1665 config._d = new Date(utils_hooks__hooks.now());
1666 } else if (isDate(input)) {
1667 config._d = new Date(input.valueOf());
1668 } else if (typeof input === 'string') {
1669 configFromString(config);
1670 } else if (isArray(input)) {
1671 config._a = map(input.slice(0), function (obj) {
1672 return parseInt(obj, 10);
1673 });
1674 configFromArray(config);
1675 } else if (typeof(input) === 'object') {
1676 configFromObject(config);
1677 } else if (typeof(input) === 'number') {
1678 // from milliseconds
1679 config._d = new Date(input);
1680 } else {
1681 utils_hooks__hooks.createFromInputFallback(config);
1682 }
1683 }
1685 function createLocalOrUTC (input, format, locale, strict, isUTC) {
1686 var c = {};
1688 if (typeof(locale) === 'boolean') {
1689 strict = locale;
1690 locale = undefined;
1691 }
1692 // object construction must be done this way.
1693 // https://github.com/moment/moment/issues/1423
1694 c._isAMomentObject = true;
1695 c._useUTC = c._isUTC = isUTC;
1696 c._l = locale;
1697 c._i = input;
1698 c._f = format;
1699 c._strict = strict;
1701 return createFromConfig(c);
1702 }
1704 function local__createLocal (input, format, locale, strict) {
1705 return createLocalOrUTC(input, format, locale, strict, false);
1706 }
1708 var prototypeMin = deprecate(
1709 'moment().min is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
1710 function () {
1711 var other = local__createLocal.apply(null, arguments);
1712 if (this.isValid() && other.isValid()) {
1713 return other < this ? this : other;
1714 } else {
1715 return valid__createInvalid();
1716 }
1717 }
1718 );
1720 var prototypeMax = deprecate(
1721 'moment().max is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
1722 function () {
1723 var other = local__createLocal.apply(null, arguments);
1724 if (this.isValid() && other.isValid()) {
1725 return other > this ? this : other;
1726 } else {
1727 return valid__createInvalid();
1728 }
1729 }
1730 );
1732 // Pick a moment m from moments so that m[fn](other) is true for all
1733 // other. This relies on the function fn to be transitive.
1734 //
1735 // moments should either be an array of moment objects or an array, whose
1736 // first element is an array of moment objects.
1737 function pickBy(fn, moments) {
1738 var res, i;
1739 if (moments.length === 1 && isArray(moments[0])) {
1740 moments = moments[0];
1741 }
1742 if (!moments.length) {
1743 return local__createLocal();
1744 }
1745 res = moments[0];
1746 for (i = 1; i < moments.length; ++i) {
1747 if (!moments[i].isValid() || moments[i][fn](res)) {
1748 res = moments[i];
1749 }
1750 }
1751 return res;
1752 }
1754 // TODO: Use [].sort instead?
1755 function min () {
1756 var args = [].slice.call(arguments, 0);
1758 return pickBy('isBefore', args);
1759 }
1761 function max () {
1762 var args = [].slice.call(arguments, 0);
1764 return pickBy('isAfter', args);
1765 }
1767 var now = function () {
1768 return Date.now ? Date.now() : +(new Date());
1769 };
1771 function Duration (duration) {
1772 var normalizedInput = normalizeObjectUnits(duration),
1773 years = normalizedInput.year || 0,
1774 quarters = normalizedInput.quarter || 0,
1775 months = normalizedInput.month || 0,
1776 weeks = normalizedInput.week || 0,
1777 days = normalizedInput.day || 0,
1778 hours = normalizedInput.hour || 0,
1779 minutes = normalizedInput.minute || 0,
1780 seconds = normalizedInput.second || 0,
1781 milliseconds = normalizedInput.millisecond || 0;
1783 // representation for dateAddRemove
1784 this._milliseconds = +milliseconds +
1785 seconds * 1e3 + // 1000
1786 minutes * 6e4 + // 1000 * 60
1787 hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
1788 // Because of dateAddRemove treats 24 hours as different from a
1789 // day when working around DST, we need to store them separately
1790 this._days = +days +
1791 weeks * 7;
1792 // It is impossible translate months into days without knowing
1793 // which months you are are talking about, so we have to store
1794 // it separately.
1795 this._months = +months +
1796 quarters * 3 +
1797 years * 12;
1799 this._data = {};
1801 this._locale = locale_locales__getLocale();
1803 this._bubble();
1804 }
1806 function isDuration (obj) {
1807 return obj instanceof Duration;
1808 }
1810 // FORMATTING
1812 function offset (token, separator) {
1813 addFormatToken(token, 0, 0, function () {
1814 var offset = this.utcOffset();
1815 var sign = '+';
1816 if (offset < 0) {
1817 offset = -offset;
1818 sign = '-';
1819 }
1820 return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
1821 });
1822 }
1824 offset('Z', ':');
1825 offset('ZZ', '');
1827 // PARSING
1829 addRegexToken('Z', matchShortOffset);
1830 addRegexToken('ZZ', matchShortOffset);
1831 addParseToken(['Z', 'ZZ'], function (input, array, config) {
1832 config._useUTC = true;
1833 config._tzm = offsetFromString(matchShortOffset, input);
1834 });
1836 // HELPERS
1838 // timezone chunker
1839 // '+10:00' > ['10', '00']
1840 // '-1530' > ['-15', '30']
1841 var chunkOffset = /([\+\-]|\d\d)/gi;
1843 function offsetFromString(matcher, string) {
1844 var matches = ((string || '').match(matcher) || []);
1845 var chunk = matches[matches.length - 1] || [];
1846 var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
1847 var minutes = +(parts[1] * 60) + toInt(parts[2]);
1849 return parts[0] === '+' ? minutes : -minutes;
1850 }
1852 // Return a moment from input, that is local/utc/zone equivalent to model.
1853 function cloneWithOffset(input, model) {
1854 var res, diff;
1855 if (model._isUTC) {
1856 res = model.clone();
1857 diff = (isMoment(input) || isDate(input) ? input.valueOf() : local__createLocal(input).valueOf()) - res.valueOf();
1858 // Use low-level api, because this fn is low-level api.
1859 res._d.setTime(res._d.valueOf() + diff);
1860 utils_hooks__hooks.updateOffset(res, false);
1861 return res;
1862 } else {
1863 return local__createLocal(input).local();
1864 }
1865 }
1867 function getDateOffset (m) {
1868 // On Firefox.24 Date#getTimezoneOffset returns a floating point.
1869 // https://github.com/moment/moment/pull/1871
1870 return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
1871 }
1873 // HOOKS
1875 // This function will be called whenever a moment is mutated.
1876 // It is intended to keep the offset in sync with the timezone.
1877 utils_hooks__hooks.updateOffset = function () {};
1879 // MOMENTS
1881 // keepLocalTime = true means only change the timezone, without
1882 // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
1883 // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
1884 // +0200, so we adjust the time as needed, to be valid.
1885 //
1886 // Keeping the time actually adds/subtracts (one hour)
1887 // from the actual represented time. That is why we call updateOffset
1888 // a second time. In case it wants us to change the offset again
1889 // _changeInProgress == true case, then we have to adjust, because
1890 // there is no such time in the given timezone.
1891 function getSetOffset (input, keepLocalTime) {
1892 var offset = this._offset || 0,
1893 localAdjust;
1894 if (!this.isValid()) {
1895 return input != null ? this : NaN;
1896 }
1897 if (input != null) {
1898 if (typeof input === 'string') {
1899 input = offsetFromString(matchShortOffset, input);
1900 } else if (Math.abs(input) < 16) {
1901 input = input * 60;
1902 }
1903 if (!this._isUTC && keepLocalTime) {
1904 localAdjust = getDateOffset(this);
1905 }
1906 this._offset = input;
1907 this._isUTC = true;
1908 if (localAdjust != null) {
1909 this.add(localAdjust, 'm');
1910 }
1911 if (offset !== input) {
1912 if (!keepLocalTime || this._changeInProgress) {
1913 add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
1914 } else if (!this._changeInProgress) {
1915 this._changeInProgress = true;
1916 utils_hooks__hooks.updateOffset(this, true);
1917 this._changeInProgress = null;
1918 }
1919 }
1920 return this;
1921 } else {
1922 return this._isUTC ? offset : getDateOffset(this);
1923 }
1924 }
1926 function getSetZone (input, keepLocalTime) {
1927 if (input != null) {
1928 if (typeof input !== 'string') {
1929 input = -input;
1930 }
1932 this.utcOffset(input, keepLocalTime);
1934 return this;
1935 } else {
1936 return -this.utcOffset();
1937 }
1938 }
1940 function setOffsetToUTC (keepLocalTime) {
1941 return this.utcOffset(0, keepLocalTime);
1942 }
1944 function setOffsetToLocal (keepLocalTime) {
1945 if (this._isUTC) {
1946 this.utcOffset(0, keepLocalTime);
1947 this._isUTC = false;
1949 if (keepLocalTime) {
1950 this.subtract(getDateOffset(this), 'm');
1951 }
1952 }
1953 return this;
1954 }
1956 function setOffsetToParsedOffset () {
1957 if (this._tzm) {
1958 this.utcOffset(this._tzm);
1959 } else if (typeof this._i === 'string') {
1960 this.utcOffset(offsetFromString(matchOffset, this._i));
1961 }
1962 return this;
1963 }
1965 function hasAlignedHourOffset (input) {
1966 if (!this.isValid()) {
1967 return false;
1968 }
1969 input = input ? local__createLocal(input).utcOffset() : 0;
1971 return (this.utcOffset() - input) % 60 === 0;
1972 }
1974 function isDaylightSavingTime () {
1975 return (
1976 this.utcOffset() > this.clone().month(0).utcOffset() ||
1977 this.utcOffset() > this.clone().month(5).utcOffset()
1978 );
1979 }
1981 function isDaylightSavingTimeShifted () {
1982 if (!isUndefined(this._isDSTShifted)) {
1983 return this._isDSTShifted;
1984 }
1986 var c = {};
1988 copyConfig(c, this);
1989 c = prepareConfig(c);
1991 if (c._a) {
1992 var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
1993 this._isDSTShifted = this.isValid() &&
1994 compareArrays(c._a, other.toArray()) > 0;
1995 } else {
1996 this._isDSTShifted = false;
1997 }
1999 return this._isDSTShifted;
2000 }
2002 function isLocal () {
2003 return this.isValid() ? !this._isUTC : false;
2004 }
2006 function isUtcOffset () {
2007 return this.isValid() ? this._isUTC : false;
2008 }
2010 function isUtc () {
2011 return this.isValid() ? this._isUTC && this._offset === 0 : false;
2012 }
2014 // ASP.NET json date format regex
2015 var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/;
2017 // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
2018 // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
2019 // and further modified to allow for strings containing both week and day
2020 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)?)?$/;
2022 function create__createDuration (input, key) {
2023 var duration = input,
2024 // matching against regexp is expensive, do it on demand
2025 match = null,
2026 sign,
2027 ret,
2028 diffRes;
2030 if (isDuration(input)) {
2031 duration = {
2032 ms : input._milliseconds,
2033 d : input._days,
2034 M : input._months
2035 };
2036 } else if (typeof input === 'number') {
2037 duration = {};
2038 if (key) {
2039 duration[key] = input;
2040 } else {
2041 duration.milliseconds = input;
2042 }
2043 } else if (!!(match = aspNetRegex.exec(input))) {
2044 sign = (match[1] === '-') ? -1 : 1;
2045 duration = {
2046 y : 0,
2047 d : toInt(match[DATE]) * sign,
2048 h : toInt(match[HOUR]) * sign,
2049 m : toInt(match[MINUTE]) * sign,
2050 s : toInt(match[SECOND]) * sign,
2051 ms : toInt(match[MILLISECOND]) * sign
2052 };
2053 } else if (!!(match = isoRegex.exec(input))) {
2054 sign = (match[1] === '-') ? -1 : 1;
2055 duration = {
2056 y : parseIso(match[2], sign),
2057 M : parseIso(match[3], sign),
2058 w : parseIso(match[4], sign),
2059 d : parseIso(match[5], sign),
2060 h : parseIso(match[6], sign),
2061 m : parseIso(match[7], sign),
2062 s : parseIso(match[8], sign)
2063 };
2064 } else if (duration == null) {// checks for null or undefined
2065 duration = {};
2066 } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
2067 diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
2069 duration = {};
2070 duration.ms = diffRes.milliseconds;
2071 duration.M = diffRes.months;
2072 }
2074 ret = new Duration(duration);
2076 if (isDuration(input) && hasOwnProp(input, '_locale')) {
2077 ret._locale = input._locale;
2078 }
2080 return ret;
2081 }
2083 create__createDuration.fn = Duration.prototype;
2085 function parseIso (inp, sign) {
2086 // We'd normally use ~~inp for this, but unfortunately it also
2087 // converts floats to ints.
2088 // inp may be undefined, so careful calling replace on it.
2089 var res = inp && parseFloat(inp.replace(',', '.'));
2090 // apply sign while we're at it
2091 return (isNaN(res) ? 0 : res) * sign;
2092 }
2094 function positiveMomentsDifference(base, other) {
2095 var res = {milliseconds: 0, months: 0};
2097 res.months = other.month() - base.month() +
2098 (other.year() - base.year()) * 12;
2099 if (base.clone().add(res.months, 'M').isAfter(other)) {
2100 --res.months;
2101 }
2103 res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
2105 return res;
2106 }
2108 function momentsDifference(base, other) {
2109 var res;
2110 if (!(base.isValid() && other.isValid())) {
2111 return {milliseconds: 0, months: 0};
2112 }
2114 other = cloneWithOffset(other, base);
2115 if (base.isBefore(other)) {
2116 res = positiveMomentsDifference(base, other);
2117 } else {
2118 res = positiveMomentsDifference(other, base);
2119 res.milliseconds = -res.milliseconds;
2120 res.months = -res.months;
2121 }
2123 return res;
2124 }
2126 function absRound (number) {
2127 if (number < 0) {
2128 return Math.round(-1 * number) * -1;
2129 } else {
2130 return Math.round(number);
2131 }
2132 }
2134 // TODO: remove 'name' arg after deprecation is removed
2135 function createAdder(direction, name) {
2136 return function (val, period) {
2137 var dur, tmp;
2138 //invert the arguments, but complain about it
2139 if (period !== null && !isNaN(+period)) {
2140 deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
2141 tmp = val; val = period; period = tmp;
2142 }
2144 val = typeof val === 'string' ? +val : val;
2145 dur = create__createDuration(val, period);
2146 add_subtract__addSubtract(this, dur, direction);
2147 return this;
2148 };
2149 }
2151 function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
2152 var milliseconds = duration._milliseconds,
2153 days = absRound(duration._days),
2154 months = absRound(duration._months);
2156 if (!mom.isValid()) {
2157 // No op
2158 return;
2159 }
2161 updateOffset = updateOffset == null ? true : updateOffset;
2163 if (milliseconds) {
2164 mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
2165 }
2166 if (days) {
2167 get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
2168 }
2169 if (months) {
2170 setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
2171 }
2172 if (updateOffset) {
2173 utils_hooks__hooks.updateOffset(mom, days || months);
2174 }
2175 }
2177 var add_subtract__add = createAdder(1, 'add');
2178 var add_subtract__subtract = createAdder(-1, 'subtract');
2180 function moment_calendar__calendar (time, formats) {
2181 // We want to compare the start of today, vs this.
2182 // Getting start-of-today depends on whether we're local/utc/offset or not.
2183 var now = time || local__createLocal(),
2184 sod = cloneWithOffset(now, this).startOf('day'),
2185 diff = this.diff(sod, 'days', true),
2186 format = diff < -6 ? 'sameElse' :
2187 diff < -1 ? 'lastWeek' :
2188 diff < 0 ? 'lastDay' :
2189 diff < 1 ? 'sameDay' :
2190 diff < 2 ? 'nextDay' :
2191 diff < 7 ? 'nextWeek' : 'sameElse';
2193 var output = formats && (isFunction(formats[format]) ? formats[format]() : formats[format]);
2195 return this.format(output || this.localeData().calendar(format, this, local__createLocal(now)));
2196 }
2198 function clone () {
2199 return new Moment(this);
2200 }
2202 function isAfter (input, units) {
2203 var localInput = isMoment(input) ? input : local__createLocal(input);
2204 if (!(this.isValid() && localInput.isValid())) {
2205 return false;
2206 }
2207 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
2208 if (units === 'millisecond') {
2209 return this.valueOf() > localInput.valueOf();
2210 } else {
2211 return localInput.valueOf() < this.clone().startOf(units).valueOf();
2212 }
2213 }
2215 function isBefore (input, units) {
2216 var localInput = isMoment(input) ? input : local__createLocal(input);
2217 if (!(this.isValid() && localInput.isValid())) {
2218 return false;
2219 }
2220 units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
2221 if (units === 'millisecond') {
2222 return this.valueOf() < localInput.valueOf();
2223 } else {
2224 return this.clone().endOf(units).valueOf() < localInput.valueOf();
2225 }
2226 }
2228 function isBetween (from, to, units, inclusivity) {
2229 inclusivity = inclusivity || '()';
2230 return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
2231 (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
2232 }
2234 function isSame (input, units) {
2235 var localInput = isMoment(input) ? input : local__createLocal(input),
2236 inputMs;
2237 if (!(this.isValid() && localInput.isValid())) {
2238 return false;
2239 }
2240 units = normalizeUnits(units || 'millisecond');
2241 if (units === 'millisecond') {
2242 return this.valueOf() === localInput.valueOf();
2243 } else {
2244 inputMs = localInput.valueOf();
2245 return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
2246 }
2247 }
2249 function isSameOrAfter (input, units) {
2250 return this.isSame(input, units) || this.isAfter(input,units);
2251 }
2253 function isSameOrBefore (input, units) {
2254 return this.isSame(input, units) || this.isBefore(input,units);
2255 }
2257 function diff (input, units, asFloat) {
2258 var that,
2259 zoneDelta,
2260 delta, output;
2262 if (!this.isValid()) {
2263 return NaN;
2264 }
2266 that = cloneWithOffset(input, this);
2268 if (!that.isValid()) {
2269 return NaN;
2270 }
2272 zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
2274 units = normalizeUnits(units);
2276 if (units === 'year' || units === 'month' || units === 'quarter') {
2277 output = monthDiff(this, that);
2278 if (units === 'quarter') {
2279 output = output / 3;
2280 } else if (units === 'year') {
2281 output = output / 12;
2282 }
2283 } else {
2284 delta = this - that;
2285 output = units === 'second' ? delta / 1e3 : // 1000
2286 units === 'minute' ? delta / 6e4 : // 1000 * 60
2287 units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
2288 units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
2289 units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
2290 delta;
2291 }
2292 return asFloat ? output : absFloor(output);
2293 }
2295 function monthDiff (a, b) {
2296 // difference in months
2297 var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
2298 // b is in (anchor - 1 month, anchor + 1 month)
2299 anchor = a.clone().add(wholeMonthDiff, 'months'),
2300 anchor2, adjust;
2302 if (b - anchor < 0) {
2303 anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
2304 // linear across the month
2305 adjust = (b - anchor) / (anchor - anchor2);
2306 } else {
2307 anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
2308 // linear across the month
2309 adjust = (b - anchor) / (anchor2 - anchor);
2310 }
2312 //check for negative zero, return zero if negative zero
2313 return -(wholeMonthDiff + adjust) || 0;
2314 }
2316 utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
2317 utils_hooks__hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
2319 function toString () {
2320 return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
2321 }
2323 function moment_format__toISOString () {
2324 var m = this.clone().utc();
2325 if (0 < m.year() && m.year() <= 9999) {
2326 if (isFunction(Date.prototype.toISOString)) {
2327 // native implementation is ~50x faster, use it when we can
2328 return this.toDate().toISOString();
2329 } else {
2330 return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
2331 }
2332 } else {
2333 return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
2334 }
2335 }
2337 function moment_format__format (inputString) {
2338 if (!inputString) {
2339 inputString = this.isUtc() ? utils_hooks__hooks.defaultFormatUtc : utils_hooks__hooks.defaultFormat;
2340 }
2341 var output = formatMoment(this, inputString);
2342 return this.localeData().postformat(output);
2343 }
2345 function from (time, withoutSuffix) {
2346 if (this.isValid() &&
2347 ((isMoment(time) && time.isValid()) ||
2348 local__createLocal(time).isValid())) {
2349 return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
2350 } else {
2351 return this.localeData().invalidDate();
2352 }
2353 }
2355 function fromNow (withoutSuffix) {
2356 return this.from(local__createLocal(), withoutSuffix);
2357 }
2359 function to (time, withoutSuffix) {
2360 if (this.isValid() &&
2361 ((isMoment(time) && time.isValid()) ||
2362 local__createLocal(time).isValid())) {
2363 return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
2364 } else {
2365 return this.localeData().invalidDate();
2366 }
2367 }
2369 function toNow (withoutSuffix) {
2370 return this.to(local__createLocal(), withoutSuffix);
2371 }
2373 // If passed a locale key, it will set the locale for this
2374 // instance. Otherwise, it will return the locale configuration
2375 // variables for this instance.
2376 function locale (key) {
2377 var newLocaleData;
2379 if (key === undefined) {
2380 return this._locale._abbr;
2381 } else {
2382 newLocaleData = locale_locales__getLocale(key);
2383 if (newLocaleData != null) {
2384 this._locale = newLocaleData;
2385 }
2386 return this;
2387 }
2388 }
2390 var lang = deprecate(
2391 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
2392 function (key) {
2393 if (key === undefined) {
2394 return this.localeData();
2395 } else {
2396 return this.locale(key);
2397 }
2398 }
2399 );
2401 function localeData () {
2402 return this._locale;
2403 }
2405 function startOf (units) {
2406 units = normalizeUnits(units);
2407 // the following switch intentionally omits break keywords
2408 // to utilize falling through the cases.
2409 switch (units) {
2410 case 'year':
2411 this.month(0);
2412 /* falls through */
2413 case 'quarter':
2414 case 'month':
2415 this.date(1);
2416 /* falls through */
2417 case 'week':
2418 case 'isoWeek':
2419 case 'day':
2420 case 'date':
2421 this.hours(0);
2422 /* falls through */
2423 case 'hour':
2424 this.minutes(0);
2425 /* falls through */
2426 case 'minute':
2427 this.seconds(0);
2428 /* falls through */
2429 case 'second':
2430 this.milliseconds(0);
2431 }
2433 // weeks are a special case
2434 if (units === 'week') {
2435 this.weekday(0);
2436 }
2437 if (units === 'isoWeek') {
2438 this.isoWeekday(1);
2439 }
2441 // quarters are also special
2442 if (units === 'quarter') {
2443 this.month(Math.floor(this.month() / 3) * 3);
2444 }
2446 return this;
2447 }
2449 function endOf (units) {
2450 units = normalizeUnits(units);
2451 if (units === undefined || units === 'millisecond') {
2452 return this;
2453 }
2455 // 'date' is an alias for 'day', so it should be considered as such.
2456 if (units === 'date') {
2457 units = 'day';
2458 }
2460 return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
2461 }
2463 function to_type__valueOf () {
2464 return this._d.valueOf() - ((this._offset || 0) * 60000);
2465 }
2467 function unix () {
2468 return Math.floor(this.valueOf() / 1000);
2469 }
2471 function toDate () {
2472 return this._offset ? new Date(this.valueOf()) : this._d;
2473 }
2475 function toArray () {
2476 var m = this;
2477 return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
2478 }
2480 function toObject () {
2481 var m = this;
2482 return {
2483 years: m.year(),
2484 months: m.month(),
2485 date: m.date(),
2486 hours: m.hours(),
2487 minutes: m.minutes(),
2488 seconds: m.seconds(),
2489 milliseconds: m.milliseconds()
2490 };
2491 }
2493 function toJSON () {
2494 // new Date(NaN).toJSON() === null
2495 return this.isValid() ? this.toISOString() : null;
2496 }
2498 function moment_valid__isValid () {
2499 return valid__isValid(this);
2500 }
2502 function parsingFlags () {
2503 return extend({}, getParsingFlags(this));
2504 }
2506 function invalidAt () {
2507 return getParsingFlags(this).overflow;
2508 }
2510 function creationData() {
2511 return {
2512 input: this._i,
2513 format: this._f,
2514 locale: this._locale,
2515 isUTC: this._isUTC,
2516 strict: this._strict
2517 };
2518 }
2520 // FORMATTING
2522 addFormatToken(0, ['gg', 2], 0, function () {
2523 return this.weekYear() % 100;
2524 });
2526 addFormatToken(0, ['GG', 2], 0, function () {
2527 return this.isoWeekYear() % 100;
2528 });
2530 function addWeekYearFormatToken (token, getter) {
2531 addFormatToken(0, [token, token.length], 0, getter);
2532 }
2534 addWeekYearFormatToken('gggg', 'weekYear');
2535 addWeekYearFormatToken('ggggg', 'weekYear');
2536 addWeekYearFormatToken('GGGG', 'isoWeekYear');
2537 addWeekYearFormatToken('GGGGG', 'isoWeekYear');
2539 // ALIASES
2541 addUnitAlias('weekYear', 'gg');
2542 addUnitAlias('isoWeekYear', 'GG');
2544 // PARSING
2546 addRegexToken('G', matchSigned);
2547 addRegexToken('g', matchSigned);
2548 addRegexToken('GG', match1to2, match2);
2549 addRegexToken('gg', match1to2, match2);
2550 addRegexToken('GGGG', match1to4, match4);
2551 addRegexToken('gggg', match1to4, match4);
2552 addRegexToken('GGGGG', match1to6, match6);
2553 addRegexToken('ggggg', match1to6, match6);
2555 addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
2556 week[token.substr(0, 2)] = toInt(input);
2557 });
2559 addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
2560 week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
2561 });
2563 // MOMENTS
2565 function getSetWeekYear (input) {
2566 return getSetWeekYearHelper.call(this,
2567 input,
2568 this.week(),
2569 this.weekday(),
2570 this.localeData()._week.dow,
2571 this.localeData()._week.doy);
2572 }
2574 function getSetISOWeekYear (input) {
2575 return getSetWeekYearHelper.call(this,
2576 input, this.isoWeek(), this.isoWeekday(), 1, 4);
2577 }
2579 function getISOWeeksInYear () {
2580 return weeksInYear(this.year(), 1, 4);
2581 }
2583 function getWeeksInYear () {
2584 var weekInfo = this.localeData()._week;
2585 return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
2586 }
2588 function getSetWeekYearHelper(input, week, weekday, dow, doy) {
2589 var weeksTarget;
2590 if (input == null) {
2591 return weekOfYear(this, dow, doy).year;
2592 } else {
2593 weeksTarget = weeksInYear(input, dow, doy);
2594 if (week > weeksTarget) {
2595 week = weeksTarget;
2596 }
2597 return setWeekAll.call(this, input, week, weekday, dow, doy);
2598 }
2599 }
2601 function setWeekAll(weekYear, week, weekday, dow, doy) {
2602 var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
2603 date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
2605 this.year(date.getUTCFullYear());
2606 this.month(date.getUTCMonth());
2607 this.date(date.getUTCDate());
2608 return this;
2609 }
2611 // FORMATTING
2613 addFormatToken('Q', 0, 'Qo', 'quarter');
2615 // ALIASES
2617 addUnitAlias('quarter', 'Q');
2619 // PARSING
2621 addRegexToken('Q', match1);
2622 addParseToken('Q', function (input, array) {
2623 array[MONTH] = (toInt(input) - 1) * 3;
2624 });
2626 // MOMENTS
2628 function getSetQuarter (input) {
2629 return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
2630 }
2632 // FORMATTING
2634 addFormatToken('w', ['ww', 2], 'wo', 'week');
2635 addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
2637 // ALIASES
2639 addUnitAlias('week', 'w');
2640 addUnitAlias('isoWeek', 'W');
2642 // PARSING
2644 addRegexToken('w', match1to2);
2645 addRegexToken('ww', match1to2, match2);
2646 addRegexToken('W', match1to2);
2647 addRegexToken('WW', match1to2, match2);
2649 addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
2650 week[token.substr(0, 1)] = toInt(input);
2651 });
2653 // HELPERS
2655 // LOCALES
2657 function localeWeek (mom) {
2658 return weekOfYear(mom, this._week.dow, this._week.doy).week;
2659 }
2661 var defaultLocaleWeek = {
2662 dow : 0, // Sunday is the first day of the week.
2663 doy : 6 // The week that contains Jan 1st is the first week of the year.
2664 };
2666 function localeFirstDayOfWeek () {
2667 return this._week.dow;
2668 }
2670 function localeFirstDayOfYear () {
2671 return this._week.doy;
2672 }
2674 // MOMENTS
2676 function getSetWeek (input) {
2677 var week = this.localeData().week(this);
2678 return input == null ? week : this.add((input - week) * 7, 'd');
2679 }
2681 function getSetISOWeek (input) {
2682 var week = weekOfYear(this, 1, 4).week;
2683 return input == null ? week : this.add((input - week) * 7, 'd');
2684 }
2686 // FORMATTING
2688 addFormatToken('D', ['DD', 2], 'Do', 'date');
2690 // ALIASES
2692 addUnitAlias('date', 'D');
2694 // PARSING
2696 addRegexToken('D', match1to2);
2697 addRegexToken('DD', match1to2, match2);
2698 addRegexToken('Do', function (isStrict, locale) {
2699 return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
2700 });
2702 addParseToken(['D', 'DD'], DATE);
2703 addParseToken('Do', function (input, array) {
2704 array[DATE] = toInt(input.match(match1to2)[0], 10);
2705 });
2707 // MOMENTS
2709 var getSetDayOfMonth = makeGetSet('Date', true);
2711 // FORMATTING
2713 addFormatToken('d', 0, 'do', 'day');
2715 addFormatToken('dd', 0, 0, function (format) {
2716 return this.localeData().weekdaysMin(this, format);
2717 });
2719 addFormatToken('ddd', 0, 0, function (format) {
2720 return this.localeData().weekdaysShort(this, format);
2721 });
2723 addFormatToken('dddd', 0, 0, function (format) {
2724 return this.localeData().weekdays(this, format);
2725 });
2727 addFormatToken('e', 0, 0, 'weekday');
2728 addFormatToken('E', 0, 0, 'isoWeekday');
2730 // ALIASES
2732 addUnitAlias('day', 'd');
2733 addUnitAlias('weekday', 'e');
2734 addUnitAlias('isoWeekday', 'E');
2736 // PARSING
2738 addRegexToken('d', match1to2);
2739 addRegexToken('e', match1to2);
2740 addRegexToken('E', match1to2);
2741 addRegexToken('dd', function (isStrict, locale) {
2742 return locale.weekdaysMinRegex(isStrict);
2743 });
2744 addRegexToken('ddd', function (isStrict, locale) {
2745 return locale.weekdaysShortRegex(isStrict);
2746 });
2747 addRegexToken('dddd', function (isStrict, locale) {
2748 return locale.weekdaysRegex(isStrict);
2749 });
2751 addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
2752 var weekday = config._locale.weekdaysParse(input, token, config._strict);
2753 // if we didn't get a weekday name, mark the date as invalid
2754 if (weekday != null) {
2755 week.d = weekday;
2756 } else {
2757 getParsingFlags(config).invalidWeekday = input;
2758 }
2759 });
2761 addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
2762 week[token] = toInt(input);
2763 });
2765 // HELPERS
2767 function parseWeekday(input, locale) {
2768 if (typeof input !== 'string') {
2769 return input;
2770 }
2772 if (!isNaN(input)) {
2773 return parseInt(input, 10);
2774 }
2776 input = locale.weekdaysParse(input);
2777 if (typeof input === 'number') {
2778 return input;
2779 }
2781 return null;
2782 }
2784 // LOCALES
2786 var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
2787 function localeWeekdays (m, format) {
2788 return isArray(this._weekdays) ? this._weekdays[m.day()] :
2789 this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
2790 }
2792 var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
2793 function localeWeekdaysShort (m) {
2794 return this._weekdaysShort[m.day()];
2795 }
2797 var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
2798 function localeWeekdaysMin (m) {
2799 return this._weekdaysMin[m.day()];
2800 }
2802 function day_of_week__handleStrictParse(weekdayName, format, strict) {
2803 var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
2804 if (!this._weekdaysParse) {
2805 this._weekdaysParse = [];
2806 this._shortWeekdaysParse = [];
2807 this._minWeekdaysParse = [];
2809 for (i = 0; i < 7; ++i) {
2810 mom = create_utc__createUTC([2000, 1]).day(i);
2811 this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
2812 this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
2813 this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
2814 }
2815 }
2817 if (strict) {
2818 if (format === 'dddd') {
2819 ii = indexOf.call(this._weekdaysParse, llc);
2820 return ii !== -1 ? ii : null;
2821 } else if (format === 'ddd') {
2822 ii = indexOf.call(this._shortWeekdaysParse, llc);
2823 return ii !== -1 ? ii : null;
2824 } else {
2825 ii = indexOf.call(this._minWeekdaysParse, llc);
2826 return ii !== -1 ? ii : null;
2827 }
2828 } else {
2829 if (format === 'dddd') {
2830 ii = indexOf.call(this._weekdaysParse, llc);
2831 if (ii !== -1) {
2832 return ii;
2833 }
2834 ii = indexOf.call(this._shortWeekdaysParse, llc);
2835 if (ii !== -1) {
2836 return ii;
2837 }
2838 ii = indexOf.call(this._minWeekdaysParse, llc);
2839 return ii !== -1 ? ii : null;
2840 } else if (format === 'ddd') {
2841 ii = indexOf.call(this._shortWeekdaysParse, llc);
2842 if (ii !== -1) {
2843 return ii;
2844 }
2845 ii = indexOf.call(this._weekdaysParse, llc);
2846 if (ii !== -1) {
2847 return ii;
2848 }
2849 ii = indexOf.call(this._minWeekdaysParse, llc);
2850 return ii !== -1 ? ii : null;
2851 } else {
2852 ii = indexOf.call(this._minWeekdaysParse, llc);
2853 if (ii !== -1) {
2854 return ii;
2855 }
2856 ii = indexOf.call(this._weekdaysParse, llc);
2857 if (ii !== -1) {
2858 return ii;
2859 }
2860 ii = indexOf.call(this._shortWeekdaysParse, llc);
2861 return ii !== -1 ? ii : null;
2862 }
2863 }
2864 }
2866 function localeWeekdaysParse (weekdayName, format, strict) {
2867 var i, mom, regex;
2869 if (this._weekdaysParseExact) {
2870 return day_of_week__handleStrictParse.call(this, weekdayName, format, strict);
2871 }
2873 if (!this._weekdaysParse) {
2874 this._weekdaysParse = [];
2875 this._minWeekdaysParse = [];
2876 this._shortWeekdaysParse = [];
2877 this._fullWeekdaysParse = [];
2878 }
2880 for (i = 0; i < 7; i++) {
2881 // make the regex if we don't have it already
2883 mom = create_utc__createUTC([2000, 1]).day(i);
2884 if (strict && !this._fullWeekdaysParse[i]) {
2885 this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
2886 this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
2887 this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
2888 }
2889 if (!this._weekdaysParse[i]) {
2890 regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
2891 this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
2892 }
2893 // test the regex
2894 if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
2895 return i;
2896 } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
2897 return i;
2898 } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
2899 return i;
2900 } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
2901 return i;
2902 }
2903 }
2904 }
2906 // MOMENTS
2908 function getSetDayOfWeek (input) {
2909 if (!this.isValid()) {
2910 return input != null ? this : NaN;
2911 }
2912 var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
2913 if (input != null) {
2914 input = parseWeekday(input, this.localeData());
2915 return this.add(input - day, 'd');
2916 } else {
2917 return day;
2918 }
2919 }
2921 function getSetLocaleDayOfWeek (input) {
2922 if (!this.isValid()) {
2923 return input != null ? this : NaN;
2924 }
2925 var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
2926 return input == null ? weekday : this.add(input - weekday, 'd');
2927 }
2929 function getSetISODayOfWeek (input) {
2930 if (!this.isValid()) {
2931 return input != null ? this : NaN;
2932 }
2933 // behaves the same as moment#day except
2934 // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
2935 // as a setter, sunday should belong to the previous week.
2936 return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
2937 }
2939 var defaultWeekdaysRegex = matchWord;
2940 function weekdaysRegex (isStrict) {
2941 if (this._weekdaysParseExact) {
2942 if (!hasOwnProp(this, '_weekdaysRegex')) {
2943 computeWeekdaysParse.call(this);
2944 }
2945 if (isStrict) {
2946 return this._weekdaysStrictRegex;
2947 } else {
2948 return this._weekdaysRegex;
2949 }
2950 } else {
2951 return this._weekdaysStrictRegex && isStrict ?
2952 this._weekdaysStrictRegex : this._weekdaysRegex;
2953 }
2954 }
2956 var defaultWeekdaysShortRegex = matchWord;
2957 function weekdaysShortRegex (isStrict) {
2958 if (this._weekdaysParseExact) {
2959 if (!hasOwnProp(this, '_weekdaysRegex')) {
2960 computeWeekdaysParse.call(this);
2961 }
2962 if (isStrict) {
2963 return this._weekdaysShortStrictRegex;
2964 } else {
2965 return this._weekdaysShortRegex;
2966 }
2967 } else {
2968 return this._weekdaysShortStrictRegex && isStrict ?
2969 this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
2970 }
2971 }
2973 var defaultWeekdaysMinRegex = matchWord;
2974 function weekdaysMinRegex (isStrict) {
2975 if (this._weekdaysParseExact) {
2976 if (!hasOwnProp(this, '_weekdaysRegex')) {
2977 computeWeekdaysParse.call(this);
2978 }
2979 if (isStrict) {
2980 return this._weekdaysMinStrictRegex;
2981 } else {
2982 return this._weekdaysMinRegex;
2983 }
2984 } else {
2985 return this._weekdaysMinStrictRegex && isStrict ?
2986 this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
2987 }
2988 }
2991 function computeWeekdaysParse () {
2992 function cmpLenRev(a, b) {
2993 return b.length - a.length;
2994 }
2996 var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
2997 i, mom, minp, shortp, longp;
2998 for (i = 0; i < 7; i++) {
2999 // make the regex if we don't have it already
3000 mom = create_utc__createUTC([2000, 1]).day(i);
3001 minp = this.weekdaysMin(mom, '');
3002 shortp = this.weekdaysShort(mom, '');
3003 longp = this.weekdays(mom, '');
3004 minPieces.push(minp);
3005 shortPieces.push(shortp);
3006 longPieces.push(longp);
3007 mixedPieces.push(minp);
3008 mixedPieces.push(shortp);
3009 mixedPieces.push(longp);
3010 }
3011 // Sorting makes sure if one weekday (or abbr) is a prefix of another it
3012 // will match the longer piece.
3013 minPieces.sort(cmpLenRev);
3014 shortPieces.sort(cmpLenRev);
3015 longPieces.sort(cmpLenRev);
3016 mixedPieces.sort(cmpLenRev);
3017 for (i = 0; i < 7; i++) {
3018 shortPieces[i] = regexEscape(shortPieces[i]);
3019 longPieces[i] = regexEscape(longPieces[i]);
3020 mixedPieces[i] = regexEscape(mixedPieces[i]);
3021 }
3023 this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
3024 this._weekdaysShortRegex = this._weekdaysRegex;
3025 this._weekdaysMinRegex = this._weekdaysRegex;
3027 this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
3028 this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
3029 this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
3030 }
3032 // FORMATTING
3034 addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
3036 // ALIASES
3038 addUnitAlias('dayOfYear', 'DDD');
3040 // PARSING
3042 addRegexToken('DDD', match1to3);
3043 addRegexToken('DDDD', match3);
3044 addParseToken(['DDD', 'DDDD'], function (input, array, config) {
3045 config._dayOfYear = toInt(input);
3046 });
3048 // HELPERS
3050 // MOMENTS
3052 function getSetDayOfYear (input) {
3053 var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
3054 return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
3055 }
3057 // FORMATTING
3059 function hFormat() {
3060 return this.hours() % 12 || 12;
3061 }
3063 function kFormat() {
3064 return this.hours() || 24;
3065 }
3067 addFormatToken('H', ['HH', 2], 0, 'hour');
3068 addFormatToken('h', ['hh', 2], 0, hFormat);
3069 addFormatToken('k', ['kk', 2], 0, kFormat);
3071 addFormatToken('hmm', 0, 0, function () {
3072 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
3073 });
3075 addFormatToken('hmmss', 0, 0, function () {
3076 return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
3077 zeroFill(this.seconds(), 2);
3078 });
3080 addFormatToken('Hmm', 0, 0, function () {
3081 return '' + this.hours() + zeroFill(this.minutes(), 2);
3082 });
3084 addFormatToken('Hmmss', 0, 0, function () {
3085 return '' + this.hours() + zeroFill(this.minutes(), 2) +
3086 zeroFill(this.seconds(), 2);
3087 });
3089 function meridiem (token, lowercase) {
3090 addFormatToken(token, 0, 0, function () {
3091 return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
3092 });
3093 }
3095 meridiem('a', true);
3096 meridiem('A', false);
3098 // ALIASES
3100 addUnitAlias('hour', 'h');
3102 // PARSING
3104 function matchMeridiem (isStrict, locale) {
3105 return locale._meridiemParse;
3106 }
3108 addRegexToken('a', matchMeridiem);
3109 addRegexToken('A', matchMeridiem);
3110 addRegexToken('H', match1to2);
3111 addRegexToken('h', match1to2);
3112 addRegexToken('HH', match1to2, match2);
3113 addRegexToken('hh', match1to2, match2);
3115 addRegexToken('hmm', match3to4);
3116 addRegexToken('hmmss', match5to6);
3117 addRegexToken('Hmm', match3to4);
3118 addRegexToken('Hmmss', match5to6);
3120 addParseToken(['H', 'HH'], HOUR);
3121 addParseToken(['a', 'A'], function (input, array, config) {
3122 config._isPm = config._locale.isPM(input);
3123 config._meridiem = input;
3124 });
3125 addParseToken(['h', 'hh'], function (input, array, config) {
3126 array[HOUR] = toInt(input);
3127 getParsingFlags(config).bigHour = true;
3128 });
3129 addParseToken('hmm', function (input, array, config) {
3130 var pos = input.length - 2;
3131 array[HOUR] = toInt(input.substr(0, pos));
3132 array[MINUTE] = toInt(input.substr(pos));
3133 getParsingFlags(config).bigHour = true;
3134 });
3135 addParseToken('hmmss', function (input, array, config) {
3136 var pos1 = input.length - 4;
3137 var pos2 = input.length - 2;
3138 array[HOUR] = toInt(input.substr(0, pos1));
3139 array[MINUTE] = toInt(input.substr(pos1, 2));
3140 array[SECOND] = toInt(input.substr(pos2));
3141 getParsingFlags(config).bigHour = true;
3142 });
3143 addParseToken('Hmm', function (input, array, config) {
3144 var pos = input.length - 2;
3145 array[HOUR] = toInt(input.substr(0, pos));
3146 array[MINUTE] = toInt(input.substr(pos));
3147 });
3148 addParseToken('Hmmss', function (input, array, config) {
3149 var pos1 = input.length - 4;
3150 var pos2 = input.length - 2;
3151 array[HOUR] = toInt(input.substr(0, pos1));
3152 array[MINUTE] = toInt(input.substr(pos1, 2));
3153 array[SECOND] = toInt(input.substr(pos2));
3154 });
3156 // LOCALES
3158 function localeIsPM (input) {
3159 // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
3160 // Using charAt should be more compatible.
3161 return ((input + '').toLowerCase().charAt(0) === 'p');
3162 }
3164 var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
3165 function localeMeridiem (hours, minutes, isLower) {
3166 if (hours > 11) {
3167 return isLower ? 'pm' : 'PM';
3168 } else {
3169 return isLower ? 'am' : 'AM';
3170 }
3171 }
3174 // MOMENTS
3176 // Setting the hour should keep the time, because the user explicitly
3177 // specified which hour he wants. So trying to maintain the same hour (in
3178 // a new timezone) makes sense. Adding/subtracting hours does not follow
3179 // this rule.
3180 var getSetHour = makeGetSet('Hours', true);
3182 // FORMATTING
3184 addFormatToken('m', ['mm', 2], 0, 'minute');
3186 // ALIASES
3188 addUnitAlias('minute', 'm');
3190 // PARSING
3192 addRegexToken('m', match1to2);
3193 addRegexToken('mm', match1to2, match2);
3194 addParseToken(['m', 'mm'], MINUTE);
3196 // MOMENTS
3198 var getSetMinute = makeGetSet('Minutes', false);
3200 // FORMATTING
3202 addFormatToken('s', ['ss', 2], 0, 'second');
3204 // ALIASES
3206 addUnitAlias('second', 's');
3208 // PARSING
3210 addRegexToken('s', match1to2);
3211 addRegexToken('ss', match1to2, match2);
3212 addParseToken(['s', 'ss'], SECOND);
3214 // MOMENTS
3216 var getSetSecond = makeGetSet('Seconds', false);
3218 // FORMATTING
3220 addFormatToken('S', 0, 0, function () {
3221 return ~~(this.millisecond() / 100);
3222 });
3224 addFormatToken(0, ['SS', 2], 0, function () {
3225 return ~~(this.millisecond() / 10);
3226 });
3228 addFormatToken(0, ['SSS', 3], 0, 'millisecond');
3229 addFormatToken(0, ['SSSS', 4], 0, function () {
3230 return this.millisecond() * 10;
3231 });
3232 addFormatToken(0, ['SSSSS', 5], 0, function () {
3233 return this.millisecond() * 100;
3234 });
3235 addFormatToken(0, ['SSSSSS', 6], 0, function () {
3236 return this.millisecond() * 1000;
3237 });
3238 addFormatToken(0, ['SSSSSSS', 7], 0, function () {
3239 return this.millisecond() * 10000;
3240 });
3241 addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
3242 return this.millisecond() * 100000;
3243 });
3244 addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
3245 return this.millisecond() * 1000000;
3246 });
3249 // ALIASES
3251 addUnitAlias('millisecond', 'ms');
3253 // PARSING
3255 addRegexToken('S', match1to3, match1);
3256 addRegexToken('SS', match1to3, match2);
3257 addRegexToken('SSS', match1to3, match3);
3259 var token;
3260 for (token = 'SSSS'; token.length <= 9; token += 'S') {
3261 addRegexToken(token, matchUnsigned);
3262 }
3264 function parseMs(input, array) {
3265 array[MILLISECOND] = toInt(('0.' + input) * 1000);
3266 }
3268 for (token = 'S'; token.length <= 9; token += 'S') {
3269 addParseToken(token, parseMs);
3270 }
3271 // MOMENTS
3273 var getSetMillisecond = makeGetSet('Milliseconds', false);
3275 // FORMATTING
3277 addFormatToken('z', 0, 0, 'zoneAbbr');
3278 addFormatToken('zz', 0, 0, 'zoneName');
3280 // MOMENTS
3282 function getZoneAbbr () {
3283 return this._isUTC ? 'UTC' : '';
3284 }
3286 function getZoneName () {
3287 return this._isUTC ? 'Coordinated Universal Time' : '';
3288 }
3290 var momentPrototype__proto = Moment.prototype;
3292 momentPrototype__proto.add = add_subtract__add;
3293 momentPrototype__proto.calendar = moment_calendar__calendar;
3294 momentPrototype__proto.clone = clone;
3295 momentPrototype__proto.diff = diff;
3296 momentPrototype__proto.endOf = endOf;
3297 momentPrototype__proto.format = moment_format__format;
3298 momentPrototype__proto.from = from;
3299 momentPrototype__proto.fromNow = fromNow;
3300 momentPrototype__proto.to = to;
3301 momentPrototype__proto.toNow = toNow;
3302 momentPrototype__proto.get = getSet;
3303 momentPrototype__proto.invalidAt = invalidAt;
3304 momentPrototype__proto.isAfter = isAfter;
3305 momentPrototype__proto.isBefore = isBefore;
3306 momentPrototype__proto.isBetween = isBetween;
3307 momentPrototype__proto.isSame = isSame;
3308 momentPrototype__proto.isSameOrAfter = isSameOrAfter;
3309 momentPrototype__proto.isSameOrBefore = isSameOrBefore;
3310 momentPrototype__proto.isValid = moment_valid__isValid;
3311 momentPrototype__proto.lang = lang;
3312 momentPrototype__proto.locale = locale;
3313 momentPrototype__proto.localeData = localeData;
3314 momentPrototype__proto.max = prototypeMax;
3315 momentPrototype__proto.min = prototypeMin;
3316 momentPrototype__proto.parsingFlags = parsingFlags;
3317 momentPrototype__proto.set = getSet;
3318 momentPrototype__proto.startOf = startOf;
3319 momentPrototype__proto.subtract = add_subtract__subtract;
3320 momentPrototype__proto.toArray = toArray;
3321 momentPrototype__proto.toObject = toObject;
3322 momentPrototype__proto.toDate = toDate;
3323 momentPrototype__proto.toISOString = moment_format__toISOString;
3324 momentPrototype__proto.toJSON = toJSON;
3325 momentPrototype__proto.toString = toString;
3326 momentPrototype__proto.unix = unix;
3327 momentPrototype__proto.valueOf = to_type__valueOf;
3328 momentPrototype__proto.creationData = creationData;
3330 // Year
3331 momentPrototype__proto.year = getSetYear;
3332 momentPrototype__proto.isLeapYear = getIsLeapYear;
3334 // Week Year
3335 momentPrototype__proto.weekYear = getSetWeekYear;
3336 momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
3338 // Quarter
3339 momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
3341 // Month
3342 momentPrototype__proto.month = getSetMonth;
3343 momentPrototype__proto.daysInMonth = getDaysInMonth;
3345 // Week
3346 momentPrototype__proto.week = momentPrototype__proto.weeks = getSetWeek;
3347 momentPrototype__proto.isoWeek = momentPrototype__proto.isoWeeks = getSetISOWeek;
3348 momentPrototype__proto.weeksInYear = getWeeksInYear;
3349 momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
3351 // Day
3352 momentPrototype__proto.date = getSetDayOfMonth;
3353 momentPrototype__proto.day = momentPrototype__proto.days = getSetDayOfWeek;
3354 momentPrototype__proto.weekday = getSetLocaleDayOfWeek;
3355 momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
3356 momentPrototype__proto.dayOfYear = getSetDayOfYear;
3358 // Hour
3359 momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
3361 // Minute
3362 momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
3364 // Second
3365 momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
3367 // Millisecond
3368 momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
3370 // Offset
3371 momentPrototype__proto.utcOffset = getSetOffset;
3372 momentPrototype__proto.utc = setOffsetToUTC;
3373 momentPrototype__proto.local = setOffsetToLocal;
3374 momentPrototype__proto.parseZone = setOffsetToParsedOffset;
3375 momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
3376 momentPrototype__proto.isDST = isDaylightSavingTime;
3377 momentPrototype__proto.isDSTShifted = isDaylightSavingTimeShifted;
3378 momentPrototype__proto.isLocal = isLocal;
3379 momentPrototype__proto.isUtcOffset = isUtcOffset;
3380 momentPrototype__proto.isUtc = isUtc;
3381 momentPrototype__proto.isUTC = isUtc;
3383 // Timezone
3384 momentPrototype__proto.zoneAbbr = getZoneAbbr;
3385 momentPrototype__proto.zoneName = getZoneName;
3387 // Deprecations
3388 momentPrototype__proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
3389 momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
3390 momentPrototype__proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
3391 momentPrototype__proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
3393 var momentPrototype = momentPrototype__proto;
3395 function moment_moment__createUnix (input) {
3396 return local__createLocal(input * 1000);
3397 }
3399 function moment_moment__createInZone () {
3400 return local__createLocal.apply(null, arguments).parseZone();
3401 }
3403 var defaultCalendar = {
3404 sameDay : '[Today at] LT',
3405 nextDay : '[Tomorrow at] LT',
3406 nextWeek : 'dddd [at] LT',
3407 lastDay : '[Yesterday at] LT',
3408 lastWeek : '[Last] dddd [at] LT',
3409 sameElse : 'L'
3410 };
3412 function locale_calendar__calendar (key, mom, now) {
3413 var output = this._calendar[key];
3414 return isFunction(output) ? output.call(mom, now) : output;
3415 }
3417 var defaultLongDateFormat = {
3418 LTS : 'h:mm:ss A',
3419 LT : 'h:mm A',
3420 L : 'MM/DD/YYYY',
3421 LL : 'MMMM D, YYYY',
3422 LLL : 'MMMM D, YYYY h:mm A',
3423 LLLL : 'dddd, MMMM D, YYYY h:mm A'
3424 };
3426 function longDateFormat (key) {
3427 var format = this._longDateFormat[key],
3428 formatUpper = this._longDateFormat[key.toUpperCase()];
3430 if (format || !formatUpper) {
3431 return format;
3432 }
3434 this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
3435 return val.slice(1);
3436 });
3438 return this._longDateFormat[key];
3439 }
3441 var defaultInvalidDate = 'Invalid date';
3443 function invalidDate () {
3444 return this._invalidDate;
3445 }
3447 var defaultOrdinal = '%d';
3448 var defaultOrdinalParse = /\d{1,2}/;
3450 function ordinal (number) {
3451 return this._ordinal.replace('%d', number);
3452 }
3454 function preParsePostFormat (string) {
3455 return string;
3456 }
3458 var defaultRelativeTime = {
3459 future : 'in %s',
3460 past : '%s ago',
3461 s : 'a few seconds',
3462 m : 'a minute',
3463 mm : '%d minutes',
3464 h : 'an hour',
3465 hh : '%d hours',
3466 d : 'a day',
3467 dd : '%d days',
3468 M : 'a month',
3469 MM : '%d months',
3470 y : 'a year',
3471 yy : '%d years'
3472 };
3474 function relative__relativeTime (number, withoutSuffix, string, isFuture) {
3475 var output = this._relativeTime[string];
3476 return (isFunction(output)) ?
3477 output(number, withoutSuffix, string, isFuture) :
3478 output.replace(/%d/i, number);
3479 }
3481 function pastFuture (diff, output) {
3482 var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
3483 return isFunction(format) ? format(output) : format.replace(/%s/i, output);
3484 }
3486 var prototype__proto = Locale.prototype;
3488 prototype__proto._calendar = defaultCalendar;
3489 prototype__proto.calendar = locale_calendar__calendar;
3490 prototype__proto._longDateFormat = defaultLongDateFormat;
3491 prototype__proto.longDateFormat = longDateFormat;
3492 prototype__proto._invalidDate = defaultInvalidDate;
3493 prototype__proto.invalidDate = invalidDate;
3494 prototype__proto._ordinal = defaultOrdinal;
3495 prototype__proto.ordinal = ordinal;
3496 prototype__proto._ordinalParse = defaultOrdinalParse;
3497 prototype__proto.preparse = preParsePostFormat;
3498 prototype__proto.postformat = preParsePostFormat;
3499 prototype__proto._relativeTime = defaultRelativeTime;
3500 prototype__proto.relativeTime = relative__relativeTime;
3501 prototype__proto.pastFuture = pastFuture;
3502 prototype__proto.set = locale_set__set;
3504 // Month
3505 prototype__proto.months = localeMonths;
3506 prototype__proto._months = defaultLocaleMonths;
3507 prototype__proto.monthsShort = localeMonthsShort;
3508 prototype__proto._monthsShort = defaultLocaleMonthsShort;
3509 prototype__proto.monthsParse = localeMonthsParse;
3510 prototype__proto._monthsRegex = defaultMonthsRegex;
3511 prototype__proto.monthsRegex = monthsRegex;
3512 prototype__proto._monthsShortRegex = defaultMonthsShortRegex;
3513 prototype__proto.monthsShortRegex = monthsShortRegex;
3515 // Week
3516 prototype__proto.week = localeWeek;
3517 prototype__proto._week = defaultLocaleWeek;
3518 prototype__proto.firstDayOfYear = localeFirstDayOfYear;
3519 prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
3521 // Day of Week
3522 prototype__proto.weekdays = localeWeekdays;
3523 prototype__proto._weekdays = defaultLocaleWeekdays;
3524 prototype__proto.weekdaysMin = localeWeekdaysMin;
3525 prototype__proto._weekdaysMin = defaultLocaleWeekdaysMin;
3526 prototype__proto.weekdaysShort = localeWeekdaysShort;
3527 prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
3528 prototype__proto.weekdaysParse = localeWeekdaysParse;
3530 prototype__proto._weekdaysRegex = defaultWeekdaysRegex;
3531 prototype__proto.weekdaysRegex = weekdaysRegex;
3532 prototype__proto._weekdaysShortRegex = defaultWeekdaysShortRegex;
3533 prototype__proto.weekdaysShortRegex = weekdaysShortRegex;
3534 prototype__proto._weekdaysMinRegex = defaultWeekdaysMinRegex;
3535 prototype__proto.weekdaysMinRegex = weekdaysMinRegex;
3537 // Hours
3538 prototype__proto.isPM = localeIsPM;
3539 prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
3540 prototype__proto.meridiem = localeMeridiem;
3542 function lists__get (format, index, field, setter) {
3543 var locale = locale_locales__getLocale();
3544 var utc = create_utc__createUTC().set(setter, index);
3545 return locale[field](utc, format);
3546 }
3548 function listMonthsImpl (format, index, field) {
3549 if (typeof format === 'number') {
3550 index = format;
3551 format = undefined;
3552 }
3554 format = format || '';
3556 if (index != null) {
3557 return lists__get(format, index, field, 'month');
3558 }
3560 var i;
3561 var out = [];
3562 for (i = 0; i < 12; i++) {
3563 out[i] = lists__get(format, i, field, 'month');
3564 }
3565 return out;
3566 }
3568 // ()
3569 // (5)
3570 // (fmt, 5)
3571 // (fmt)
3572 // (true)
3573 // (true, 5)
3574 // (true, fmt, 5)
3575 // (true, fmt)
3576 function listWeekdaysImpl (localeSorted, format, index, field) {
3577 if (typeof localeSorted === 'boolean') {
3578 if (typeof format === 'number') {
3579 index = format;
3580 format = undefined;
3581 }
3583 format = format || '';
3584 } else {
3585 format = localeSorted;
3586 index = format;
3587 localeSorted = false;
3589 if (typeof format === 'number') {
3590 index = format;
3591 format = undefined;
3592 }
3594 format = format || '';
3595 }
3597 var locale = locale_locales__getLocale(),
3598 shift = localeSorted ? locale._week.dow : 0;
3600 if (index != null) {
3601 return lists__get(format, (index + shift) % 7, field, 'day');
3602 }
3604 var i;
3605 var out = [];
3606 for (i = 0; i < 7; i++) {
3607 out[i] = lists__get(format, (i + shift) % 7, field, 'day');
3608 }
3609 return out;
3610 }
3612 function lists__listMonths (format, index) {
3613 return listMonthsImpl(format, index, 'months');
3614 }
3616 function lists__listMonthsShort (format, index) {
3617 return listMonthsImpl(format, index, 'monthsShort');
3618 }
3620 function lists__listWeekdays (localeSorted, format, index) {
3621 return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
3622 }
3624 function lists__listWeekdaysShort (localeSorted, format, index) {
3625 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
3626 }
3628 function lists__listWeekdaysMin (localeSorted, format, index) {
3629 return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
3630 }
3632 locale_locales__getSetGlobalLocale('en', {
3633 ordinalParse: /\d{1,2}(th|st|nd|rd)/,
3634 ordinal : function (number) {
3635 var b = number % 10,
3636 output = (toInt(number % 100 / 10) === 1) ? 'th' :
3637 (b === 1) ? 'st' :
3638 (b === 2) ? 'nd' :
3639 (b === 3) ? 'rd' : 'th';
3640 return number + output;
3641 }
3642 });
3644 // Side effect imports
3645 utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
3646 utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
3648 var mathAbs = Math.abs;
3650 function duration_abs__abs () {
3651 var data = this._data;
3653 this._milliseconds = mathAbs(this._milliseconds);
3654 this._days = mathAbs(this._days);
3655 this._months = mathAbs(this._months);
3657 data.milliseconds = mathAbs(data.milliseconds);
3658 data.seconds = mathAbs(data.seconds);
3659 data.minutes = mathAbs(data.minutes);
3660 data.hours = mathAbs(data.hours);
3661 data.months = mathAbs(data.months);
3662 data.years = mathAbs(data.years);
3664 return this;
3665 }
3667 function duration_add_subtract__addSubtract (duration, input, value, direction) {
3668 var other = create__createDuration(input, value);
3670 duration._milliseconds += direction * other._milliseconds;
3671 duration._days += direction * other._days;
3672 duration._months += direction * other._months;
3674 return duration._bubble();
3675 }
3677 // supports only 2.0-style add(1, 's') or add(duration)
3678 function duration_add_subtract__add (input, value) {
3679 return duration_add_subtract__addSubtract(this, input, value, 1);
3680 }
3682 // supports only 2.0-style subtract(1, 's') or subtract(duration)
3683 function duration_add_subtract__subtract (input, value) {
3684 return duration_add_subtract__addSubtract(this, input, value, -1);
3685 }
3687 function absCeil (number) {
3688 if (number < 0) {
3689 return Math.floor(number);
3690 } else {
3691 return Math.ceil(number);
3692 }
3693 }
3695 function bubble () {
3696 var milliseconds = this._milliseconds;
3697 var days = this._days;
3698 var months = this._months;
3699 var data = this._data;
3700 var seconds, minutes, hours, years, monthsFromDays;
3702 // if we have a mix of positive and negative values, bubble down first
3703 // check: https://github.com/moment/moment/issues/2166
3704 if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
3705 (milliseconds <= 0 && days <= 0 && months <= 0))) {
3706 milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
3707 days = 0;
3708 months = 0;
3709 }
3711 // The following code bubbles up values, see the tests for
3712 // examples of what that means.
3713 data.milliseconds = milliseconds % 1000;
3715 seconds = absFloor(milliseconds / 1000);
3716 data.seconds = seconds % 60;
3718 minutes = absFloor(seconds / 60);
3719 data.minutes = minutes % 60;
3721 hours = absFloor(minutes / 60);
3722 data.hours = hours % 24;
3724 days += absFloor(hours / 24);
3726 // convert days to months
3727 monthsFromDays = absFloor(daysToMonths(days));
3728 months += monthsFromDays;
3729 days -= absCeil(monthsToDays(monthsFromDays));
3731 // 12 months -> 1 year
3732 years = absFloor(months / 12);
3733 months %= 12;
3735 data.days = days;
3736 data.months = months;
3737 data.years = years;
3739 return this;
3740 }
3742 function daysToMonths (days) {
3743 // 400 years have 146097 days (taking into account leap year rules)
3744 // 400 years have 12 months === 4800
3745 return days * 4800 / 146097;
3746 }
3748 function monthsToDays (months) {
3749 // the reverse of daysToMonths
3750 return months * 146097 / 4800;
3751 }
3753 function as (units) {
3754 var days;
3755 var months;
3756 var milliseconds = this._milliseconds;
3758 units = normalizeUnits(units);
3760 if (units === 'month' || units === 'year') {
3761 days = this._days + milliseconds / 864e5;
3762 months = this._months + daysToMonths(days);
3763 return units === 'month' ? months : months / 12;
3764 } else {
3765 // handle milliseconds separately because of floating point math errors (issue #1867)
3766 days = this._days + Math.round(monthsToDays(this._months));
3767 switch (units) {
3768 case 'week' : return days / 7 + milliseconds / 6048e5;
3769 case 'day' : return days + milliseconds / 864e5;
3770 case 'hour' : return days * 24 + milliseconds / 36e5;
3771 case 'minute' : return days * 1440 + milliseconds / 6e4;
3772 case 'second' : return days * 86400 + milliseconds / 1000;
3773 // Math.floor prevents floating point math errors here
3774 case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
3775 default: throw new Error('Unknown unit ' + units);
3776 }
3777 }
3778 }
3780 // TODO: Use this.as('ms')?
3781 function duration_as__valueOf () {
3782 return (
3783 this._milliseconds +
3784 this._days * 864e5 +
3785 (this._months % 12) * 2592e6 +
3786 toInt(this._months / 12) * 31536e6
3787 );
3788 }
3790 function makeAs (alias) {
3791 return function () {
3792 return this.as(alias);
3793 };
3794 }
3796 var asMilliseconds = makeAs('ms');
3797 var asSeconds = makeAs('s');
3798 var asMinutes = makeAs('m');
3799 var asHours = makeAs('h');
3800 var asDays = makeAs('d');
3801 var asWeeks = makeAs('w');
3802 var asMonths = makeAs('M');
3803 var asYears = makeAs('y');
3805 function duration_get__get (units) {
3806 units = normalizeUnits(units);
3807 return this[units + 's']();
3808 }
3810 function makeGetter(name) {
3811 return function () {
3812 return this._data[name];
3813 };
3814 }
3816 var milliseconds = makeGetter('milliseconds');
3817 var seconds = makeGetter('seconds');
3818 var minutes = makeGetter('minutes');
3819 var hours = makeGetter('hours');
3820 var days = makeGetter('days');
3821 var duration_get__months = makeGetter('months');
3822 var years = makeGetter('years');
3824 function weeks () {
3825 return absFloor(this.days() / 7);
3826 }
3828 var round = Math.round;
3829 var thresholds = {
3830 s: 45, // seconds to minute
3831 m: 45, // minutes to hour
3832 h: 22, // hours to day
3833 d: 26, // days to month
3834 M: 11 // months to year
3835 };
3837 // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
3838 function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
3839 return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
3840 }
3842 function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
3843 var duration = create__createDuration(posNegDuration).abs();
3844 var seconds = round(duration.as('s'));
3845 var minutes = round(duration.as('m'));
3846 var hours = round(duration.as('h'));
3847 var days = round(duration.as('d'));
3848 var months = round(duration.as('M'));
3849 var years = round(duration.as('y'));
3851 var a = seconds < thresholds.s && ['s', seconds] ||
3852 minutes <= 1 && ['m'] ||
3853 minutes < thresholds.m && ['mm', minutes] ||
3854 hours <= 1 && ['h'] ||
3855 hours < thresholds.h && ['hh', hours] ||
3856 days <= 1 && ['d'] ||
3857 days < thresholds.d && ['dd', days] ||
3858 months <= 1 && ['M'] ||
3859 months < thresholds.M && ['MM', months] ||
3860 years <= 1 && ['y'] || ['yy', years];
3862 a[2] = withoutSuffix;
3863 a[3] = +posNegDuration > 0;
3864 a[4] = locale;
3865 return substituteTimeAgo.apply(null, a);
3866 }
3868 // This function allows you to set a threshold for relative time strings
3869 function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
3870 if (thresholds[threshold] === undefined) {
3871 return false;
3872 }
3873 if (limit === undefined) {
3874 return thresholds[threshold];
3875 }
3876 thresholds[threshold] = limit;
3877 return true;
3878 }
3880 function humanize (withSuffix) {
3881 var locale = this.localeData();
3882 var output = duration_humanize__relativeTime(this, !withSuffix, locale);
3884 if (withSuffix) {
3885 output = locale.pastFuture(+this, output);
3886 }
3888 return locale.postformat(output);
3889 }
3891 var iso_string__abs = Math.abs;
3893 function iso_string__toISOString() {
3894 // for ISO strings we do not use the normal bubbling rules:
3895 // * milliseconds bubble up until they become hours
3896 // * days do not bubble at all
3897 // * months bubble up until they become years
3898 // This is because there is no context-free conversion between hours and days
3899 // (think of clock changes)
3900 // and also not between days and months (28-31 days per month)
3901 var seconds = iso_string__abs(this._milliseconds) / 1000;
3902 var days = iso_string__abs(this._days);
3903 var months = iso_string__abs(this._months);
3904 var minutes, hours, years;
3906 // 3600 seconds -> 60 minutes -> 1 hour
3907 minutes = absFloor(seconds / 60);
3908 hours = absFloor(minutes / 60);
3909 seconds %= 60;
3910 minutes %= 60;
3912 // 12 months -> 1 year
3913 years = absFloor(months / 12);
3914 months %= 12;
3917 // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
3918 var Y = years;
3919 var M = months;
3920 var D = days;
3921 var h = hours;
3922 var m = minutes;
3923 var s = seconds;
3924 var total = this.asSeconds();
3926 if (!total) {
3927 // this is the same as C#'s (Noda) and python (isodate)...
3928 // but not other JS (goog.date)
3929 return 'P0D';
3930 }
3932 return (total < 0 ? '-' : '') +
3933 'P' +
3934 (Y ? Y + 'Y' : '') +
3935 (M ? M + 'M' : '') +
3936 (D ? D + 'D' : '') +
3937 ((h || m || s) ? 'T' : '') +
3938 (h ? h + 'H' : '') +
3939 (m ? m + 'M' : '') +
3940 (s ? s + 'S' : '');
3941 }
3943 var duration_prototype__proto = Duration.prototype;
3945 duration_prototype__proto.abs = duration_abs__abs;
3946 duration_prototype__proto.add = duration_add_subtract__add;
3947 duration_prototype__proto.subtract = duration_add_subtract__subtract;
3948 duration_prototype__proto.as = as;
3949 duration_prototype__proto.asMilliseconds = asMilliseconds;
3950 duration_prototype__proto.asSeconds = asSeconds;
3951 duration_prototype__proto.asMinutes = asMinutes;
3952 duration_prototype__proto.asHours = asHours;
3953 duration_prototype__proto.asDays = asDays;
3954 duration_prototype__proto.asWeeks = asWeeks;
3955 duration_prototype__proto.asMonths = asMonths;
3956 duration_prototype__proto.asYears = asYears;
3957 duration_prototype__proto.valueOf = duration_as__valueOf;
3958 duration_prototype__proto._bubble = bubble;
3959 duration_prototype__proto.get = duration_get__get;
3960 duration_prototype__proto.milliseconds = milliseconds;
3961 duration_prototype__proto.seconds = seconds;
3962 duration_prototype__proto.minutes = minutes;
3963 duration_prototype__proto.hours = hours;
3964 duration_prototype__proto.days = days;
3965 duration_prototype__proto.weeks = weeks;
3966 duration_prototype__proto.months = duration_get__months;
3967 duration_prototype__proto.years = years;
3968 duration_prototype__proto.humanize = humanize;
3969 duration_prototype__proto.toISOString = iso_string__toISOString;
3970 duration_prototype__proto.toString = iso_string__toISOString;
3971 duration_prototype__proto.toJSON = iso_string__toISOString;
3972 duration_prototype__proto.locale = locale;
3973 duration_prototype__proto.localeData = localeData;
3975 // Deprecations
3976 duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
3977 duration_prototype__proto.lang = lang;
3979 // Side effect imports
3981 // FORMATTING
3983 addFormatToken('X', 0, 0, 'unix');
3984 addFormatToken('x', 0, 0, 'valueOf');
3986 // PARSING
3988 addRegexToken('x', matchSigned);
3989 addRegexToken('X', matchTimestamp);
3990 addParseToken('X', function (input, array, config) {
3991 config._d = new Date(parseFloat(input, 10) * 1000);
3992 });
3993 addParseToken('x', function (input, array, config) {
3994 config._d = new Date(toInt(input));
3995 });
3997 // Side effect imports
3999 ;
4001 //! moment.js
4002 //! version : 2.13.0
4003 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
4004 //! license : MIT
4005 //! momentjs.com
4007 utils_hooks__hooks.version = '2.13.0';
4009 setHookCallback(local__createLocal);
4011 utils_hooks__hooks.fn = momentPrototype;
4012 utils_hooks__hooks.min = min;
4013 utils_hooks__hooks.max = max;
4014 utils_hooks__hooks.now = now;
4015 utils_hooks__hooks.utc = create_utc__createUTC;
4016 utils_hooks__hooks.unix = moment_moment__createUnix;
4017 utils_hooks__hooks.months = lists__listMonths;
4018 utils_hooks__hooks.isDate = isDate;
4019 utils_hooks__hooks.locale = locale_locales__getSetGlobalLocale;
4020 utils_hooks__hooks.invalid = valid__createInvalid;
4021 utils_hooks__hooks.duration = create__createDuration;
4022 utils_hooks__hooks.isMoment = isMoment;
4023 utils_hooks__hooks.weekdays = lists__listWeekdays;
4024 utils_hooks__hooks.parseZone = moment_moment__createInZone;
4025 utils_hooks__hooks.localeData = locale_locales__getLocale;
4026 utils_hooks__hooks.isDuration = isDuration;
4027 utils_hooks__hooks.monthsShort = lists__listMonthsShort;
4028 utils_hooks__hooks.weekdaysMin = lists__listWeekdaysMin;
4029 utils_hooks__hooks.defineLocale = defineLocale;
4030 utils_hooks__hooks.updateLocale = updateLocale;
4031 utils_hooks__hooks.locales = locale_locales__listLocales;
4032 utils_hooks__hooks.weekdaysShort = lists__listWeekdaysShort;
4033 utils_hooks__hooks.normalizeUnits = normalizeUnits;
4034 utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
4035 utils_hooks__hooks.prototype = momentPrototype;
4037 var moment__default = utils_hooks__hooks;
4039 //! moment.js locale configuration
4040 //! locale : afrikaans (af)
4041 //! author : Werner Mollentze : https://github.com/wernerm
4043 var af = moment__default.defineLocale('af', {
4044 months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
4045 monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
4046 weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
4047 weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
4048 weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
4049 meridiemParse: /vm|nm/i,
4050 isPM : function (input) {
4051 return /^nm$/i.test(input);
4052 },
4053 meridiem : function (hours, minutes, isLower) {
4054 if (hours < 12) {
4055 return isLower ? 'vm' : 'VM';
4056 } else {
4057 return isLower ? 'nm' : 'NM';
4058 }
4059 },
4060 longDateFormat : {
4061 LT : 'HH:mm',
4062 LTS : 'HH:mm:ss',
4063 L : 'DD/MM/YYYY',
4064 LL : 'D MMMM YYYY',
4065 LLL : 'D MMMM YYYY HH:mm',
4066 LLLL : 'dddd, D MMMM YYYY HH:mm'
4067 },
4068 calendar : {
4069 sameDay : '[Vandag om] LT',
4070 nextDay : '[Môre om] LT',
4071 nextWeek : 'dddd [om] LT',
4072 lastDay : '[Gister om] LT',
4073 lastWeek : '[Laas] dddd [om] LT',
4074 sameElse : 'L'
4075 },
4076 relativeTime : {
4077 future : 'oor %s',
4078 past : '%s gelede',
4079 s : '\'n paar sekondes',
4080 m : '\'n minuut',
4081 mm : '%d minute',
4082 h : '\'n uur',
4083 hh : '%d ure',
4084 d : '\'n dag',
4085 dd : '%d dae',
4086 M : '\'n maand',
4087 MM : '%d maande',
4088 y : '\'n jaar',
4089 yy : '%d jaar'
4090 },
4091 ordinalParse: /\d{1,2}(ste|de)/,
4092 ordinal : function (number) {
4093 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
4094 },
4095 week : {
4096 dow : 1, // Maandag is die eerste dag van die week.
4097 doy : 4 // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
4098 }
4099 });
4101 //! moment.js locale configuration
4102 //! locale : Moroccan Arabic (ar-ma)
4103 //! author : ElFadili Yassine : https://github.com/ElFadiliY
4104 //! author : Abdel Said : https://github.com/abdelsaid
4106 var ar_ma = moment__default.defineLocale('ar-ma', {
4107 months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4108 monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4109 weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4110 weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4111 weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4112 weekdaysParseExact : true,
4113 longDateFormat : {
4114 LT : 'HH:mm',
4115 LTS : 'HH:mm:ss',
4116 L : 'DD/MM/YYYY',
4117 LL : 'D MMMM YYYY',
4118 LLL : 'D MMMM YYYY HH:mm',
4119 LLLL : 'dddd D MMMM YYYY HH:mm'
4120 },
4121 calendar : {
4122 sameDay: '[اليوم على الساعة] LT',
4123 nextDay: '[غدا على الساعة] LT',
4124 nextWeek: 'dddd [على الساعة] LT',
4125 lastDay: '[أمس على الساعة] LT',
4126 lastWeek: 'dddd [على الساعة] LT',
4127 sameElse: 'L'
4128 },
4129 relativeTime : {
4130 future : 'في %s',
4131 past : 'منذ %s',
4132 s : 'ثوان',
4133 m : 'دقيقة',
4134 mm : '%d دقائق',
4135 h : 'ساعة',
4136 hh : '%d ساعات',
4137 d : 'يوم',
4138 dd : '%d أيام',
4139 M : 'شهر',
4140 MM : '%d أشهر',
4141 y : 'سنة',
4142 yy : '%d سنوات'
4143 },
4144 week : {
4145 dow : 6, // Saturday is the first day of the week.
4146 doy : 12 // The week that contains Jan 1st is the first week of the year.
4147 }
4148 });
4150 //! moment.js locale configuration
4151 //! locale : Arabic Saudi Arabia (ar-sa)
4152 //! author : Suhail Alkowaileet : https://github.com/xsoh
4154 var ar_sa__symbolMap = {
4155 '1': '١',
4156 '2': '٢',
4157 '3': '٣',
4158 '4': '٤',
4159 '5': '٥',
4160 '6': '٦',
4161 '7': '٧',
4162 '8': '٨',
4163 '9': '٩',
4164 '0': '٠'
4165 }, ar_sa__numberMap = {
4166 '١': '1',
4167 '٢': '2',
4168 '٣': '3',
4169 '٤': '4',
4170 '٥': '5',
4171 '٦': '6',
4172 '٧': '7',
4173 '٨': '8',
4174 '٩': '9',
4175 '٠': '0'
4176 };
4178 var ar_sa = moment__default.defineLocale('ar-sa', {
4179 months : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4180 monthsShort : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4181 weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4182 weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4183 weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4184 weekdaysParseExact : true,
4185 longDateFormat : {
4186 LT : 'HH:mm',
4187 LTS : 'HH:mm:ss',
4188 L : 'DD/MM/YYYY',
4189 LL : 'D MMMM YYYY',
4190 LLL : 'D MMMM YYYY HH:mm',
4191 LLLL : 'dddd D MMMM YYYY HH:mm'
4192 },
4193 meridiemParse: /ص|م/,
4194 isPM : function (input) {
4195 return 'م' === input;
4196 },
4197 meridiem : function (hour, minute, isLower) {
4198 if (hour < 12) {
4199 return 'ص';
4200 } else {
4201 return 'م';
4202 }
4203 },
4204 calendar : {
4205 sameDay: '[اليوم على الساعة] LT',
4206 nextDay: '[غدا على الساعة] LT',
4207 nextWeek: 'dddd [على الساعة] LT',
4208 lastDay: '[أمس على الساعة] LT',
4209 lastWeek: 'dddd [على الساعة] LT',
4210 sameElse: 'L'
4211 },
4212 relativeTime : {
4213 future : 'في %s',
4214 past : 'منذ %s',
4215 s : 'ثوان',
4216 m : 'دقيقة',
4217 mm : '%d دقائق',
4218 h : 'ساعة',
4219 hh : '%d ساعات',
4220 d : 'يوم',
4221 dd : '%d أيام',
4222 M : 'شهر',
4223 MM : '%d أشهر',
4224 y : 'سنة',
4225 yy : '%d سنوات'
4226 },
4227 preparse: function (string) {
4228 return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
4229 return ar_sa__numberMap[match];
4230 }).replace(/،/g, ',');
4231 },
4232 postformat: function (string) {
4233 return string.replace(/\d/g, function (match) {
4234 return ar_sa__symbolMap[match];
4235 }).replace(/,/g, '،');
4236 },
4237 week : {
4238 dow : 6, // Saturday is the first day of the week.
4239 doy : 12 // The week that contains Jan 1st is the first week of the year.
4240 }
4241 });
4243 //! moment.js locale configuration
4244 //! locale : Tunisian Arabic (ar-tn)
4246 var ar_tn = moment__default.defineLocale('ar-tn', {
4247 months: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4248 monthsShort: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4249 weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4250 weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4251 weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4252 weekdaysParseExact : true,
4253 longDateFormat: {
4254 LT: 'HH:mm',
4255 LTS: 'HH:mm:ss',
4256 L: 'DD/MM/YYYY',
4257 LL: 'D MMMM YYYY',
4258 LLL: 'D MMMM YYYY HH:mm',
4259 LLLL: 'dddd D MMMM YYYY HH:mm'
4260 },
4261 calendar: {
4262 sameDay: '[اليوم على الساعة] LT',
4263 nextDay: '[غدا على الساعة] LT',
4264 nextWeek: 'dddd [على الساعة] LT',
4265 lastDay: '[أمس على الساعة] LT',
4266 lastWeek: 'dddd [على الساعة] LT',
4267 sameElse: 'L'
4268 },
4269 relativeTime: {
4270 future: 'في %s',
4271 past: 'منذ %s',
4272 s: 'ثوان',
4273 m: 'دقيقة',
4274 mm: '%d دقائق',
4275 h: 'ساعة',
4276 hh: '%d ساعات',
4277 d: 'يوم',
4278 dd: '%d أيام',
4279 M: 'شهر',
4280 MM: '%d أشهر',
4281 y: 'سنة',
4282 yy: '%d سنوات'
4283 },
4284 week: {
4285 dow: 1, // Monday is the first day of the week.
4286 doy: 4 // The week that contains Jan 4th is the first week of the year.
4287 }
4288 });
4290 //! moment.js locale configuration
4291 //! Locale: Arabic (ar)
4292 //! Author: Abdel Said: https://github.com/abdelsaid
4293 //! Changes in months, weekdays: Ahmed Elkhatib
4294 //! Native plural forms: forabi https://github.com/forabi
4296 var ar__symbolMap = {
4297 '1': '١',
4298 '2': '٢',
4299 '3': '٣',
4300 '4': '٤',
4301 '5': '٥',
4302 '6': '٦',
4303 '7': '٧',
4304 '8': '٨',
4305 '9': '٩',
4306 '0': '٠'
4307 }, ar__numberMap = {
4308 '١': '1',
4309 '٢': '2',
4310 '٣': '3',
4311 '٤': '4',
4312 '٥': '5',
4313 '٦': '6',
4314 '٧': '7',
4315 '٨': '8',
4316 '٩': '9',
4317 '٠': '0'
4318 }, pluralForm = function (n) {
4319 return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
4320 }, plurals = {
4321 s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
4322 m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
4323 h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
4324 d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
4325 M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
4326 y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
4327 }, pluralize = function (u) {
4328 return function (number, withoutSuffix, string, isFuture) {
4329 var f = pluralForm(number),
4330 str = plurals[u][pluralForm(number)];
4331 if (f === 2) {
4332 str = str[withoutSuffix ? 0 : 1];
4333 }
4334 return str.replace(/%d/i, number);
4335 };
4336 }, ar__months = [
4337 'كانون الثاني يناير',
4338 'شباط فبراير',
4339 'آذار مارس',
4340 'نيسان أبريل',
4341 'أيار مايو',
4342 'حزيران يونيو',
4343 'تموز يوليو',
4344 'آب أغسطس',
4345 'أيلول سبتمبر',
4346 'تشرين الأول أكتوبر',
4347 'تشرين الثاني نوفمبر',
4348 'كانون الأول ديسمبر'
4349 ];
4351 var ar = moment__default.defineLocale('ar', {
4352 months : ar__months,
4353 monthsShort : ar__months,
4354 weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4355 weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4356 weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4357 weekdaysParseExact : true,
4358 longDateFormat : {
4359 LT : 'HH:mm',
4360 LTS : 'HH:mm:ss',
4361 L : 'D/\u200FM/\u200FYYYY',
4362 LL : 'D MMMM YYYY',
4363 LLL : 'D MMMM YYYY HH:mm',
4364 LLLL : 'dddd D MMMM YYYY HH:mm'
4365 },
4366 meridiemParse: /ص|م/,
4367 isPM : function (input) {
4368 return 'م' === input;
4369 },
4370 meridiem : function (hour, minute, isLower) {
4371 if (hour < 12) {
4372 return 'ص';
4373 } else {
4374 return 'م';
4375 }
4376 },
4377 calendar : {
4378 sameDay: '[اليوم عند الساعة] LT',
4379 nextDay: '[غدًا عند الساعة] LT',
4380 nextWeek: 'dddd [عند الساعة] LT',
4381 lastDay: '[أمس عند الساعة] LT',
4382 lastWeek: 'dddd [عند الساعة] LT',
4383 sameElse: 'L'
4384 },
4385 relativeTime : {
4386 future : 'بعد %s',
4387 past : 'منذ %s',
4388 s : pluralize('s'),
4389 m : pluralize('m'),
4390 mm : pluralize('m'),
4391 h : pluralize('h'),
4392 hh : pluralize('h'),
4393 d : pluralize('d'),
4394 dd : pluralize('d'),
4395 M : pluralize('M'),
4396 MM : pluralize('M'),
4397 y : pluralize('y'),
4398 yy : pluralize('y')
4399 },
4400 preparse: function (string) {
4401 return string.replace(/\u200f/g, '').replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
4402 return ar__numberMap[match];
4403 }).replace(/،/g, ',');
4404 },
4405 postformat: function (string) {
4406 return string.replace(/\d/g, function (match) {
4407 return ar__symbolMap[match];
4408 }).replace(/,/g, '،');
4409 },
4410 week : {
4411 dow : 6, // Saturday is the first day of the week.
4412 doy : 12 // The week that contains Jan 1st is the first week of the year.
4413 }
4414 });
4416 //! moment.js locale configuration
4417 //! locale : azerbaijani (az)
4418 //! author : topchiyev : https://github.com/topchiyev
4420 var az__suffixes = {
4421 1: '-inci',
4422 5: '-inci',
4423 8: '-inci',
4424 70: '-inci',
4425 80: '-inci',
4426 2: '-nci',
4427 7: '-nci',
4428 20: '-nci',
4429 50: '-nci',
4430 3: '-üncü',
4431 4: '-üncü',
4432 100: '-üncü',
4433 6: '-ncı',
4434 9: '-uncu',
4435 10: '-uncu',
4436 30: '-uncu',
4437 60: '-ıncı',
4438 90: '-ıncı'
4439 };
4441 var az = moment__default.defineLocale('az', {
4442 months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
4443 monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
4444 weekdays : 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
4445 weekdaysShort : 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
4446 weekdaysMin : 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
4447 weekdaysParseExact : true,
4448 longDateFormat : {
4449 LT : 'HH:mm',
4450 LTS : 'HH:mm:ss',
4451 L : 'DD.MM.YYYY',
4452 LL : 'D MMMM YYYY',
4453 LLL : 'D MMMM YYYY HH:mm',
4454 LLLL : 'dddd, D MMMM YYYY HH:mm'
4455 },
4456 calendar : {
4457 sameDay : '[bugün saat] LT',
4458 nextDay : '[sabah saat] LT',
4459 nextWeek : '[gələn həftə] dddd [saat] LT',
4460 lastDay : '[dünən] LT',
4461 lastWeek : '[keçən həftə] dddd [saat] LT',
4462 sameElse : 'L'
4463 },
4464 relativeTime : {
4465 future : '%s sonra',
4466 past : '%s əvvəl',
4467 s : 'birneçə saniyyə',
4468 m : 'bir dəqiqə',
4469 mm : '%d dəqiqə',
4470 h : 'bir saat',
4471 hh : '%d saat',
4472 d : 'bir gün',
4473 dd : '%d gün',
4474 M : 'bir ay',
4475 MM : '%d ay',
4476 y : 'bir il',
4477 yy : '%d il'
4478 },
4479 meridiemParse: /gecə|səhər|gündüz|axşam/,
4480 isPM : function (input) {
4481 return /^(gündüz|axşam)$/.test(input);
4482 },
4483 meridiem : function (hour, minute, isLower) {
4484 if (hour < 4) {
4485 return 'gecə';
4486 } else if (hour < 12) {
4487 return 'səhər';
4488 } else if (hour < 17) {
4489 return 'gündüz';
4490 } else {
4491 return 'axşam';
4492 }
4493 },
4494 ordinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
4495 ordinal : function (number) {
4496 if (number === 0) { // special case for zero
4497 return number + '-ıncı';
4498 }
4499 var a = number % 10,
4500 b = number % 100 - a,
4501 c = number >= 100 ? 100 : null;
4502 return number + (az__suffixes[a] || az__suffixes[b] || az__suffixes[c]);
4503 },
4504 week : {
4505 dow : 1, // Monday is the first day of the week.
4506 doy : 7 // The week that contains Jan 1st is the first week of the year.
4507 }
4508 });
4510 //! moment.js locale configuration
4511 //! locale : belarusian (be)
4512 //! author : Dmitry Demidov : https://github.com/demidov91
4513 //! author: Praleska: http://praleska.pro/
4514 //! Author : Menelion Elensúle : https://github.com/Oire
4516 function be__plural(word, num) {
4517 var forms = word.split('_');
4518 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]);
4519 }
4520 function be__relativeTimeWithPlural(number, withoutSuffix, key) {
4521 var format = {
4522 'mm': withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
4523 'hh': withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
4524 'dd': 'дзень_дні_дзён',
4525 'MM': 'месяц_месяцы_месяцаў',
4526 'yy': 'год_гады_гадоў'
4527 };
4528 if (key === 'm') {
4529 return withoutSuffix ? 'хвіліна' : 'хвіліну';
4530 }
4531 else if (key === 'h') {
4532 return withoutSuffix ? 'гадзіна' : 'гадзіну';
4533 }
4534 else {
4535 return number + ' ' + be__plural(format[key], +number);
4536 }
4537 }
4539 var be = moment__default.defineLocale('be', {
4540 months : {
4541 format: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_'),
4542 standalone: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_')
4543 },
4544 monthsShort : 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split('_'),
4545 weekdays : {
4546 format: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_'),
4547 standalone: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
4548 isFormat: /\[ ?[Вв] ?(?:мінулую|наступную)? ?\] ?dddd/
4549 },
4550 weekdaysShort : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
4551 weekdaysMin : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
4552 longDateFormat : {
4553 LT : 'HH:mm',
4554 LTS : 'HH:mm:ss',
4555 L : 'DD.MM.YYYY',
4556 LL : 'D MMMM YYYY г.',
4557 LLL : 'D MMMM YYYY г., HH:mm',
4558 LLLL : 'dddd, D MMMM YYYY г., HH:mm'
4559 },
4560 calendar : {
4561 sameDay: '[Сёння ў] LT',
4562 nextDay: '[Заўтра ў] LT',
4563 lastDay: '[Учора ў] LT',
4564 nextWeek: function () {
4565 return '[У] dddd [ў] LT';
4566 },
4567 lastWeek: function () {
4568 switch (this.day()) {
4569 case 0:
4570 case 3:
4571 case 5:
4572 case 6:
4573 return '[У мінулую] dddd [ў] LT';
4574 case 1:
4575 case 2:
4576 case 4:
4577 return '[У мінулы] dddd [ў] LT';
4578 }
4579 },
4580 sameElse: 'L'
4581 },
4582 relativeTime : {
4583 future : 'праз %s',
4584 past : '%s таму',
4585 s : 'некалькі секунд',
4586 m : be__relativeTimeWithPlural,
4587 mm : be__relativeTimeWithPlural,
4588 h : be__relativeTimeWithPlural,
4589 hh : be__relativeTimeWithPlural,
4590 d : 'дзень',
4591 dd : be__relativeTimeWithPlural,
4592 M : 'месяц',
4593 MM : be__relativeTimeWithPlural,
4594 y : 'год',
4595 yy : be__relativeTimeWithPlural
4596 },
4597 meridiemParse: /ночы|раніцы|дня|вечара/,
4598 isPM : function (input) {
4599 return /^(дня|вечара)$/.test(input);
4600 },
4601 meridiem : function (hour, minute, isLower) {
4602 if (hour < 4) {
4603 return 'ночы';
4604 } else if (hour < 12) {
4605 return 'раніцы';
4606 } else if (hour < 17) {
4607 return 'дня';
4608 } else {
4609 return 'вечара';
4610 }
4611 },
4612 ordinalParse: /\d{1,2}-(і|ы|га)/,
4613 ordinal: function (number, period) {
4614 switch (period) {
4615 case 'M':
4616 case 'd':
4617 case 'DDD':
4618 case 'w':
4619 case 'W':
4620 return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-і' : number + '-ы';
4621 case 'D':
4622 return number + '-га';
4623 default:
4624 return number;
4625 }
4626 },
4627 week : {
4628 dow : 1, // Monday is the first day of the week.
4629 doy : 7 // The week that contains Jan 1st is the first week of the year.
4630 }
4631 });
4633 //! moment.js locale configuration
4634 //! locale : bulgarian (bg)
4635 //! author : Krasen Borisov : https://github.com/kraz
4637 var bg = moment__default.defineLocale('bg', {
4638 months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
4639 monthsShort : 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
4640 weekdays : 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
4641 weekdaysShort : 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
4642 weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
4643 longDateFormat : {
4644 LT : 'H:mm',
4645 LTS : 'H:mm:ss',
4646 L : 'D.MM.YYYY',
4647 LL : 'D MMMM YYYY',
4648 LLL : 'D MMMM YYYY H:mm',
4649 LLLL : 'dddd, D MMMM YYYY H:mm'
4650 },
4651 calendar : {
4652 sameDay : '[Днес в] LT',
4653 nextDay : '[Утре в] LT',
4654 nextWeek : 'dddd [в] LT',
4655 lastDay : '[Вчера в] LT',
4656 lastWeek : function () {
4657 switch (this.day()) {
4658 case 0:
4659 case 3:
4660 case 6:
4661 return '[В изминалата] dddd [в] LT';
4662 case 1:
4663 case 2:
4664 case 4:
4665 case 5:
4666 return '[В изминалия] dddd [в] LT';
4667 }
4668 },
4669 sameElse : 'L'
4670 },
4671 relativeTime : {
4672 future : 'след %s',
4673 past : 'преди %s',
4674 s : 'няколко секунди',
4675 m : 'минута',
4676 mm : '%d минути',
4677 h : 'час',
4678 hh : '%d часа',
4679 d : 'ден',
4680 dd : '%d дни',
4681 M : 'месец',
4682 MM : '%d месеца',
4683 y : 'година',
4684 yy : '%d години'
4685 },
4686 ordinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
4687 ordinal : function (number) {
4688 var lastDigit = number % 10,
4689 last2Digits = number % 100;
4690 if (number === 0) {
4691 return number + '-ев';
4692 } else if (last2Digits === 0) {
4693 return number + '-ен';
4694 } else if (last2Digits > 10 && last2Digits < 20) {
4695 return number + '-ти';
4696 } else if (lastDigit === 1) {
4697 return number + '-ви';
4698 } else if (lastDigit === 2) {
4699 return number + '-ри';
4700 } else if (lastDigit === 7 || lastDigit === 8) {
4701 return number + '-ми';
4702 } else {
4703 return number + '-ти';
4704 }
4705 },
4706 week : {
4707 dow : 1, // Monday is the first day of the week.
4708 doy : 7 // The week that contains Jan 1st is the first week of the year.
4709 }
4710 });
4712 //! moment.js locale configuration
4713 //! locale : Bengali (bn)
4714 //! author : Kaushik Gandhi : https://github.com/kaushikgandhi
4716 var bn__symbolMap = {
4717 '1': '১',
4718 '2': '২',
4719 '3': '৩',
4720 '4': '৪',
4721 '5': '৫',
4722 '6': '৬',
4723 '7': '৭',
4724 '8': '৮',
4725 '9': '৯',
4726 '0': '০'
4727 },
4728 bn__numberMap = {
4729 '১': '1',
4730 '২': '2',
4731 '৩': '3',
4732 '৪': '4',
4733 '৫': '5',
4734 '৬': '6',
4735 '৭': '7',
4736 '৮': '8',
4737 '৯': '9',
4738 '০': '0'
4739 };
4741 var bn = moment__default.defineLocale('bn', {
4742 months : 'জানুয়ারী_ফেবুয়ারী_মার্চ_এপ্রিল_মে_জুন_জুলাই_অগাস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split('_'),
4743 monthsShort : 'জানু_ফেব_মার্চ_এপর_মে_জুন_জুল_অগ_সেপ্ট_অক্টো_নভ_ডিসেম্'.split('_'),
4744 weekdays : 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পত্তিবার_শুক্রবার_শনিবার'.split('_'),
4745 weekdaysShort : 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পত্তি_শুক্র_শনি'.split('_'),
4746 weekdaysMin : 'রব_সম_মঙ্গ_বু_ব্রিহ_শু_শনি'.split('_'),
4747 longDateFormat : {
4748 LT : 'A h:mm সময়',
4749 LTS : 'A h:mm:ss সময়',
4750 L : 'DD/MM/YYYY',
4751 LL : 'D MMMM YYYY',
4752 LLL : 'D MMMM YYYY, A h:mm সময়',
4753 LLLL : 'dddd, D MMMM YYYY, A h:mm সময়'
4754 },
4755 calendar : {
4756 sameDay : '[আজ] LT',
4757 nextDay : '[আগামীকাল] LT',
4758 nextWeek : 'dddd, LT',
4759 lastDay : '[গতকাল] LT',
4760 lastWeek : '[গত] dddd, LT',
4761 sameElse : 'L'
4762 },
4763 relativeTime : {
4764 future : '%s পরে',
4765 past : '%s আগে',
4766 s : 'কয়েক সেকেন্ড',
4767 m : 'এক মিনিট',
4768 mm : '%d মিনিট',
4769 h : 'এক ঘন্টা',
4770 hh : '%d ঘন্টা',
4771 d : 'এক দিন',
4772 dd : '%d দিন',
4773 M : 'এক মাস',
4774 MM : '%d মাস',
4775 y : 'এক বছর',
4776 yy : '%d বছর'
4777 },
4778 preparse: function (string) {
4779 return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
4780 return bn__numberMap[match];
4781 });
4782 },
4783 postformat: function (string) {
4784 return string.replace(/\d/g, function (match) {
4785 return bn__symbolMap[match];
4786 });
4787 },
4788 meridiemParse: /রাত|সকাল|দুপুর|বিকাল|রাত/,
4789 meridiemHour : function (hour, meridiem) {
4790 if (hour === 12) {
4791 hour = 0;
4792 }
4793 if ((meridiem === 'রাত' && hour >= 4) ||
4794 (meridiem === 'দুপুর' && hour < 5) ||
4795 meridiem === 'বিকাল') {
4796 return hour + 12;
4797 } else {
4798 return hour;
4799 }
4800 },
4801 meridiem : function (hour, minute, isLower) {
4802 if (hour < 4) {
4803 return 'রাত';
4804 } else if (hour < 10) {
4805 return 'সকাল';
4806 } else if (hour < 17) {
4807 return 'দুপুর';
4808 } else if (hour < 20) {
4809 return 'বিকাল';
4810 } else {
4811 return 'রাত';
4812 }
4813 },
4814 week : {
4815 dow : 0, // Sunday is the first day of the week.
4816 doy : 6 // The week that contains Jan 1st is the first week of the year.
4817 }
4818 });
4820 //! moment.js locale configuration
4821 //! locale : tibetan (bo)
4822 //! author : Thupten N. Chakrishar : https://github.com/vajradog
4824 var bo__symbolMap = {
4825 '1': '༡',
4826 '2': '༢',
4827 '3': '༣',
4828 '4': '༤',
4829 '5': '༥',
4830 '6': '༦',
4831 '7': '༧',
4832 '8': '༨',
4833 '9': '༩',
4834 '0': '༠'
4835 },
4836 bo__numberMap = {
4837 '༡': '1',
4838 '༢': '2',
4839 '༣': '3',
4840 '༤': '4',
4841 '༥': '5',
4842 '༦': '6',
4843 '༧': '7',
4844 '༨': '8',
4845 '༩': '9',
4846 '༠': '0'
4847 };
4849 var bo = moment__default.defineLocale('bo', {
4850 months : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
4851 monthsShort : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
4852 weekdays : 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
4853 weekdaysShort : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
4854 weekdaysMin : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
4855 longDateFormat : {
4856 LT : 'A h:mm',
4857 LTS : 'A h:mm:ss',
4858 L : 'DD/MM/YYYY',
4859 LL : 'D MMMM YYYY',
4860 LLL : 'D MMMM YYYY, A h:mm',
4861 LLLL : 'dddd, D MMMM YYYY, A h:mm'
4862 },
4863 calendar : {
4864 sameDay : '[དི་རིང] LT',
4865 nextDay : '[སང་ཉིན] LT',
4866 nextWeek : '[བདུན་ཕྲག་རྗེས་མ], LT',
4867 lastDay : '[ཁ་སང] LT',
4868 lastWeek : '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
4869 sameElse : 'L'
4870 },
4871 relativeTime : {
4872 future : '%s ལ་',
4873 past : '%s སྔན་ལ',
4874 s : 'ལམ་སང',
4875 m : 'སྐར་མ་གཅིག',
4876 mm : '%d སྐར་མ',
4877 h : 'ཆུ་ཚོད་གཅིག',
4878 hh : '%d ཆུ་ཚོད',
4879 d : 'ཉིན་གཅིག',
4880 dd : '%d ཉིན་',
4881 M : 'ཟླ་བ་གཅིག',
4882 MM : '%d ཟླ་བ',
4883 y : 'ལོ་གཅིག',
4884 yy : '%d ལོ'
4885 },
4886 preparse: function (string) {
4887 return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
4888 return bo__numberMap[match];
4889 });
4890 },
4891 postformat: function (string) {
4892 return string.replace(/\d/g, function (match) {
4893 return bo__symbolMap[match];
4894 });
4895 },
4896 meridiemParse: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
4897 meridiemHour : function (hour, meridiem) {
4898 if (hour === 12) {
4899 hour = 0;
4900 }
4901 if ((meridiem === 'མཚན་མོ' && hour >= 4) ||
4902 (meridiem === 'ཉིན་གུང' && hour < 5) ||
4903 meridiem === 'དགོང་དག') {
4904 return hour + 12;
4905 } else {
4906 return hour;
4907 }
4908 },
4909 meridiem : function (hour, minute, isLower) {
4910 if (hour < 4) {
4911 return 'མཚན་མོ';
4912 } else if (hour < 10) {
4913 return 'ཞོགས་ཀས';
4914 } else if (hour < 17) {
4915 return 'ཉིན་གུང';
4916 } else if (hour < 20) {
4917 return 'དགོང་དག';
4918 } else {
4919 return 'མཚན་མོ';
4920 }
4921 },
4922 week : {
4923 dow : 0, // Sunday is the first day of the week.
4924 doy : 6 // The week that contains Jan 1st is the first week of the year.
4925 }
4926 });
4928 //! moment.js locale configuration
4929 //! locale : breton (br)
4930 //! author : Jean-Baptiste Le Duigou : https://github.com/jbleduigou
4932 function relativeTimeWithMutation(number, withoutSuffix, key) {
4933 var format = {
4934 'mm': 'munutenn',
4935 'MM': 'miz',
4936 'dd': 'devezh'
4937 };
4938 return number + ' ' + mutation(format[key], number);
4939 }
4940 function specialMutationForYears(number) {
4941 switch (lastNumber(number)) {
4942 case 1:
4943 case 3:
4944 case 4:
4945 case 5:
4946 case 9:
4947 return number + ' bloaz';
4948 default:
4949 return number + ' vloaz';
4950 }
4951 }
4952 function lastNumber(number) {
4953 if (number > 9) {
4954 return lastNumber(number % 10);
4955 }
4956 return number;
4957 }
4958 function mutation(text, number) {
4959 if (number === 2) {
4960 return softMutation(text);
4961 }
4962 return text;
4963 }
4964 function softMutation(text) {
4965 var mutationTable = {
4966 'm': 'v',
4967 'b': 'v',
4968 'd': 'z'
4969 };
4970 if (mutationTable[text.charAt(0)] === undefined) {
4971 return text;
4972 }
4973 return mutationTable[text.charAt(0)] + text.substring(1);
4974 }
4976 var br = moment__default.defineLocale('br', {
4977 months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
4978 monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
4979 weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
4980 weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
4981 weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
4982 weekdaysParseExact : true,
4983 longDateFormat : {
4984 LT : 'h[e]mm A',
4985 LTS : 'h[e]mm:ss A',
4986 L : 'DD/MM/YYYY',
4987 LL : 'D [a viz] MMMM YYYY',
4988 LLL : 'D [a viz] MMMM YYYY h[e]mm A',
4989 LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A'
4990 },
4991 calendar : {
4992 sameDay : '[Hiziv da] LT',
4993 nextDay : '[Warc\'hoazh da] LT',
4994 nextWeek : 'dddd [da] LT',
4995 lastDay : '[Dec\'h da] LT',
4996 lastWeek : 'dddd [paset da] LT',
4997 sameElse : 'L'
4998 },
4999 relativeTime : {
5000 future : 'a-benn %s',
5001 past : '%s \'zo',
5002 s : 'un nebeud segondennoù',
5003 m : 'ur vunutenn',
5004 mm : relativeTimeWithMutation,
5005 h : 'un eur',
5006 hh : '%d eur',
5007 d : 'un devezh',
5008 dd : relativeTimeWithMutation,
5009 M : 'ur miz',
5010 MM : relativeTimeWithMutation,
5011 y : 'ur bloaz',
5012 yy : specialMutationForYears
5013 },
5014 ordinalParse: /\d{1,2}(añ|vet)/,
5015 ordinal : function (number) {
5016 var output = (number === 1) ? 'añ' : 'vet';
5017 return number + output;
5018 },
5019 week : {
5020 dow : 1, // Monday is the first day of the week.
5021 doy : 4 // The week that contains Jan 4th is the first week of the year.
5022 }
5023 });
5025 //! moment.js locale configuration
5026 //! locale : bosnian (bs)
5027 //! author : Nedim Cholich : https://github.com/frontyard
5028 //! based on (hr) translation by Bojan Marković
5030 function bs__translate(number, withoutSuffix, key) {
5031 var result = number + ' ';
5032 switch (key) {
5033 case 'm':
5034 return withoutSuffix ? 'jedna minuta' : 'jedne minute';
5035 case 'mm':
5036 if (number === 1) {
5037 result += 'minuta';
5038 } else if (number === 2 || number === 3 || number === 4) {
5039 result += 'minute';
5040 } else {
5041 result += 'minuta';
5042 }
5043 return result;
5044 case 'h':
5045 return withoutSuffix ? 'jedan sat' : 'jednog sata';
5046 case 'hh':
5047 if (number === 1) {
5048 result += 'sat';
5049 } else if (number === 2 || number === 3 || number === 4) {
5050 result += 'sata';
5051 } else {
5052 result += 'sati';
5053 }
5054 return result;
5055 case 'dd':
5056 if (number === 1) {
5057 result += 'dan';
5058 } else {
5059 result += 'dana';
5060 }
5061 return result;
5062 case 'MM':
5063 if (number === 1) {
5064 result += 'mjesec';
5065 } else if (number === 2 || number === 3 || number === 4) {
5066 result += 'mjeseca';
5067 } else {
5068 result += 'mjeseci';
5069 }
5070 return result;
5071 case 'yy':
5072 if (number === 1) {
5073 result += 'godina';
5074 } else if (number === 2 || number === 3 || number === 4) {
5075 result += 'godine';
5076 } else {
5077 result += 'godina';
5078 }
5079 return result;
5080 }
5081 }
5083 var bs = moment__default.defineLocale('bs', {
5084 months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
5085 monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
5086 monthsParseExact: true,
5087 weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
5088 weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
5089 weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
5090 weekdaysParseExact : true,
5091 longDateFormat : {
5092 LT : 'H:mm',
5093 LTS : 'H:mm:ss',
5094 L : 'DD. MM. YYYY',
5095 LL : 'D. MMMM YYYY',
5096 LLL : 'D. MMMM YYYY H:mm',
5097 LLLL : 'dddd, D. MMMM YYYY H:mm'
5098 },
5099 calendar : {
5100 sameDay : '[danas u] LT',
5101 nextDay : '[sutra u] LT',
5102 nextWeek : function () {
5103 switch (this.day()) {
5104 case 0:
5105 return '[u] [nedjelju] [u] LT';
5106 case 3:
5107 return '[u] [srijedu] [u] LT';
5108 case 6:
5109 return '[u] [subotu] [u] LT';
5110 case 1:
5111 case 2:
5112 case 4:
5113 case 5:
5114 return '[u] dddd [u] LT';
5115 }
5116 },
5117 lastDay : '[jučer u] LT',
5118 lastWeek : function () {
5119 switch (this.day()) {
5120 case 0:
5121 case 3:
5122 return '[prošlu] dddd [u] LT';
5123 case 6:
5124 return '[prošle] [subote] [u] LT';
5125 case 1:
5126 case 2:
5127 case 4:
5128 case 5:
5129 return '[prošli] dddd [u] LT';
5130 }
5131 },
5132 sameElse : 'L'
5133 },
5134 relativeTime : {
5135 future : 'za %s',
5136 past : 'prije %s',
5137 s : 'par sekundi',
5138 m : bs__translate,
5139 mm : bs__translate,
5140 h : bs__translate,
5141 hh : bs__translate,
5142 d : 'dan',
5143 dd : bs__translate,
5144 M : 'mjesec',
5145 MM : bs__translate,
5146 y : 'godinu',
5147 yy : bs__translate
5148 },
5149 ordinalParse: /\d{1,2}\./,
5150 ordinal : '%d.',
5151 week : {
5152 dow : 1, // Monday is the first day of the week.
5153 doy : 7 // The week that contains Jan 1st is the first week of the year.
5154 }
5155 });
5157 //! moment.js locale configuration
5158 //! locale : catalan (ca)
5159 //! author : Juan G. Hurtado : https://github.com/juanghurtado
5161 var ca = moment__default.defineLocale('ca', {
5162 months : 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
5163 monthsShort : 'gen._febr._mar._abr._mai._jun._jul._ag._set._oct._nov._des.'.split('_'),
5164 monthsParseExact : true,
5165 weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
5166 weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
5167 weekdaysMin : 'Dg_Dl_Dt_Dc_Dj_Dv_Ds'.split('_'),
5168 weekdaysParseExact : true,
5169 longDateFormat : {
5170 LT : 'H:mm',
5171 LTS : 'H:mm:ss',
5172 L : 'DD/MM/YYYY',
5173 LL : 'D MMMM YYYY',
5174 LLL : 'D MMMM YYYY H:mm',
5175 LLLL : 'dddd D MMMM YYYY H:mm'
5176 },
5177 calendar : {
5178 sameDay : function () {
5179 return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5180 },
5181 nextDay : function () {
5182 return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5183 },
5184 nextWeek : function () {
5185 return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5186 },
5187 lastDay : function () {
5188 return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5189 },
5190 lastWeek : function () {
5191 return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5192 },
5193 sameElse : 'L'
5194 },
5195 relativeTime : {
5196 future : 'en %s',
5197 past : 'fa %s',
5198 s : 'uns segons',
5199 m : 'un minut',
5200 mm : '%d minuts',
5201 h : 'una hora',
5202 hh : '%d hores',
5203 d : 'un dia',
5204 dd : '%d dies',
5205 M : 'un mes',
5206 MM : '%d mesos',
5207 y : 'un any',
5208 yy : '%d anys'
5209 },
5210 ordinalParse: /\d{1,2}(r|n|t|è|a)/,
5211 ordinal : function (number, period) {
5212 var output = (number === 1) ? 'r' :
5213 (number === 2) ? 'n' :
5214 (number === 3) ? 'r' :
5215 (number === 4) ? 't' : 'è';
5216 if (period === 'w' || period === 'W') {
5217 output = 'a';
5218 }
5219 return number + output;
5220 },
5221 week : {
5222 dow : 1, // Monday is the first day of the week.
5223 doy : 4 // The week that contains Jan 4th is the first week of the year.
5224 }
5225 });
5227 //! moment.js locale configuration
5228 //! locale : czech (cs)
5229 //! author : petrbela : https://github.com/petrbela
5231 var cs__months = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_'),
5232 cs__monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_');
5233 function cs__plural(n) {
5234 return (n > 1) && (n < 5) && (~~(n / 10) !== 1);
5235 }
5236 function cs__translate(number, withoutSuffix, key, isFuture) {
5237 var result = number + ' ';
5238 switch (key) {
5239 case 's': // a few seconds / in a few seconds / a few seconds ago
5240 return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
5241 case 'm': // a minute / in a minute / a minute ago
5242 return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
5243 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
5244 if (withoutSuffix || isFuture) {
5245 return result + (cs__plural(number) ? 'minuty' : 'minut');
5246 } else {
5247 return result + 'minutami';
5248 }
5249 break;
5250 case 'h': // an hour / in an hour / an hour ago
5251 return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
5252 case 'hh': // 9 hours / in 9 hours / 9 hours ago
5253 if (withoutSuffix || isFuture) {
5254 return result + (cs__plural(number) ? 'hodiny' : 'hodin');
5255 } else {
5256 return result + 'hodinami';
5257 }
5258 break;
5259 case 'd': // a day / in a day / a day ago
5260 return (withoutSuffix || isFuture) ? 'den' : 'dnem';
5261 case 'dd': // 9 days / in 9 days / 9 days ago
5262 if (withoutSuffix || isFuture) {
5263 return result + (cs__plural(number) ? 'dny' : 'dní');
5264 } else {
5265 return result + 'dny';
5266 }
5267 break;
5268 case 'M': // a month / in a month / a month ago
5269 return (withoutSuffix || isFuture) ? 'měsíc' : 'měsícem';
5270 case 'MM': // 9 months / in 9 months / 9 months ago
5271 if (withoutSuffix || isFuture) {
5272 return result + (cs__plural(number) ? 'měsíce' : 'měsíců');
5273 } else {
5274 return result + 'měsíci';
5275 }
5276 break;
5277 case 'y': // a year / in a year / a year ago
5278 return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
5279 case 'yy': // 9 years / in 9 years / 9 years ago
5280 if (withoutSuffix || isFuture) {
5281 return result + (cs__plural(number) ? 'roky' : 'let');
5282 } else {
5283 return result + 'lety';
5284 }
5285 break;
5286 }
5287 }
5289 var cs = moment__default.defineLocale('cs', {
5290 months : cs__months,
5291 monthsShort : cs__monthsShort,
5292 monthsParse : (function (months, monthsShort) {
5293 var i, _monthsParse = [];
5294 for (i = 0; i < 12; i++) {
5295 // use custom parser to solve problem with July (červenec)
5296 _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
5297 }
5298 return _monthsParse;
5299 }(cs__months, cs__monthsShort)),
5300 shortMonthsParse : (function (monthsShort) {
5301 var i, _shortMonthsParse = [];
5302 for (i = 0; i < 12; i++) {
5303 _shortMonthsParse[i] = new RegExp('^' + monthsShort[i] + '$', 'i');
5304 }
5305 return _shortMonthsParse;
5306 }(cs__monthsShort)),
5307 longMonthsParse : (function (months) {
5308 var i, _longMonthsParse = [];
5309 for (i = 0; i < 12; i++) {
5310 _longMonthsParse[i] = new RegExp('^' + months[i] + '$', 'i');
5311 }
5312 return _longMonthsParse;
5313 }(cs__months)),
5314 weekdays : 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
5315 weekdaysShort : 'ne_po_út_st_čt_pá_so'.split('_'),
5316 weekdaysMin : 'ne_po_út_st_čt_pá_so'.split('_'),
5317 longDateFormat : {
5318 LT: 'H:mm',
5319 LTS : 'H:mm:ss',
5320 L : 'DD.MM.YYYY',
5321 LL : 'D. MMMM YYYY',
5322 LLL : 'D. MMMM YYYY H:mm',
5323 LLLL : 'dddd D. MMMM YYYY H:mm'
5324 },
5325 calendar : {
5326 sameDay: '[dnes v] LT',
5327 nextDay: '[zítra v] LT',
5328 nextWeek: function () {
5329 switch (this.day()) {
5330 case 0:
5331 return '[v neděli v] LT';
5332 case 1:
5333 case 2:
5334 return '[v] dddd [v] LT';
5335 case 3:
5336 return '[ve středu v] LT';
5337 case 4:
5338 return '[ve čtvrtek v] LT';
5339 case 5:
5340 return '[v pátek v] LT';
5341 case 6:
5342 return '[v sobotu v] LT';
5343 }
5344 },
5345 lastDay: '[včera v] LT',
5346 lastWeek: function () {
5347 switch (this.day()) {
5348 case 0:
5349 return '[minulou neděli v] LT';
5350 case 1:
5351 case 2:
5352 return '[minulé] dddd [v] LT';
5353 case 3:
5354 return '[minulou středu v] LT';
5355 case 4:
5356 case 5:
5357 return '[minulý] dddd [v] LT';
5358 case 6:
5359 return '[minulou sobotu v] LT';
5360 }
5361 },
5362 sameElse: 'L'
5363 },
5364 relativeTime : {
5365 future : 'za %s',
5366 past : 'před %s',
5367 s : cs__translate,
5368 m : cs__translate,
5369 mm : cs__translate,
5370 h : cs__translate,
5371 hh : cs__translate,
5372 d : cs__translate,
5373 dd : cs__translate,
5374 M : cs__translate,
5375 MM : cs__translate,
5376 y : cs__translate,
5377 yy : cs__translate
5378 },
5379 ordinalParse : /\d{1,2}\./,
5380 ordinal : '%d.',
5381 week : {
5382 dow : 1, // Monday is the first day of the week.
5383 doy : 4 // The week that contains Jan 4th is the first week of the year.
5384 }
5385 });
5387 //! moment.js locale configuration
5388 //! locale : chuvash (cv)
5389 //! author : Anatoly Mironov : https://github.com/mirontoli
5391 var cv = moment__default.defineLocale('cv', {
5392 months : 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split('_'),
5393 monthsShort : 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
5394 weekdays : 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split('_'),
5395 weekdaysShort : 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
5396 weekdaysMin : 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
5397 longDateFormat : {
5398 LT : 'HH:mm',
5399 LTS : 'HH:mm:ss',
5400 L : 'DD-MM-YYYY',
5401 LL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
5402 LLL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
5403 LLLL : 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm'
5404 },
5405 calendar : {
5406 sameDay: '[Паян] LT [сехетре]',
5407 nextDay: '[Ыран] LT [сехетре]',
5408 lastDay: '[Ӗнер] LT [сехетре]',
5409 nextWeek: '[Ҫитес] dddd LT [сехетре]',
5410 lastWeek: '[Иртнӗ] dddd LT [сехетре]',
5411 sameElse: 'L'
5412 },
5413 relativeTime : {
5414 future : function (output) {
5415 var affix = /сехет$/i.exec(output) ? 'рен' : /ҫул$/i.exec(output) ? 'тан' : 'ран';
5416 return output + affix;
5417 },
5418 past : '%s каялла',
5419 s : 'пӗр-ик ҫеккунт',
5420 m : 'пӗр минут',
5421 mm : '%d минут',
5422 h : 'пӗр сехет',
5423 hh : '%d сехет',
5424 d : 'пӗр кун',
5425 dd : '%d кун',
5426 M : 'пӗр уйӑх',
5427 MM : '%d уйӑх',
5428 y : 'пӗр ҫул',
5429 yy : '%d ҫул'
5430 },
5431 ordinalParse: /\d{1,2}-мӗш/,
5432 ordinal : '%d-мӗш',
5433 week : {
5434 dow : 1, // Monday is the first day of the week.
5435 doy : 7 // The week that contains Jan 1st is the first week of the year.
5436 }
5437 });
5439 //! moment.js locale configuration
5440 //! locale : Welsh (cy)
5441 //! author : Robert Allen
5443 var cy = moment__default.defineLocale('cy', {
5444 months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
5445 monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
5446 weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
5447 weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
5448 weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
5449 weekdaysParseExact : true,
5450 // time formats are the same as en-gb
5451 longDateFormat: {
5452 LT: 'HH:mm',
5453 LTS : 'HH:mm:ss',
5454 L: 'DD/MM/YYYY',
5455 LL: 'D MMMM YYYY',
5456 LLL: 'D MMMM YYYY HH:mm',
5457 LLLL: 'dddd, D MMMM YYYY HH:mm'
5458 },
5459 calendar: {
5460 sameDay: '[Heddiw am] LT',
5461 nextDay: '[Yfory am] LT',
5462 nextWeek: 'dddd [am] LT',
5463 lastDay: '[Ddoe am] LT',
5464 lastWeek: 'dddd [diwethaf am] LT',
5465 sameElse: 'L'
5466 },
5467 relativeTime: {
5468 future: 'mewn %s',
5469 past: '%s yn ôl',
5470 s: 'ychydig eiliadau',
5471 m: 'munud',
5472 mm: '%d munud',
5473 h: 'awr',
5474 hh: '%d awr',
5475 d: 'diwrnod',
5476 dd: '%d diwrnod',
5477 M: 'mis',
5478 MM: '%d mis',
5479 y: 'blwyddyn',
5480 yy: '%d flynedd'
5481 },
5482 ordinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
5483 // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
5484 ordinal: function (number) {
5485 var b = number,
5486 output = '',
5487 lookup = [
5488 '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
5489 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
5490 ];
5491 if (b > 20) {
5492 if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
5493 output = 'fed'; // not 30ain, 70ain or 90ain
5494 } else {
5495 output = 'ain';
5496 }
5497 } else if (b > 0) {
5498 output = lookup[b];
5499 }
5500 return number + output;
5501 },
5502 week : {
5503 dow : 1, // Monday is the first day of the week.
5504 doy : 4 // The week that contains Jan 4th is the first week of the year.
5505 }
5506 });
5508 //! moment.js locale configuration
5509 //! locale : danish (da)
5510 //! author : Ulrik Nielsen : https://github.com/mrbase
5512 var da = moment__default.defineLocale('da', {
5513 months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
5514 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
5515 weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
5516 weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'),
5517 weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
5518 longDateFormat : {
5519 LT : 'HH:mm',
5520 LTS : 'HH:mm:ss',
5521 L : 'DD/MM/YYYY',
5522 LL : 'D. MMMM YYYY',
5523 LLL : 'D. MMMM YYYY HH:mm',
5524 LLLL : 'dddd [d.] D. MMMM YYYY HH:mm'
5525 },
5526 calendar : {
5527 sameDay : '[I dag kl.] LT',
5528 nextDay : '[I morgen kl.] LT',
5529 nextWeek : 'dddd [kl.] LT',
5530 lastDay : '[I går kl.] LT',
5531 lastWeek : '[sidste] dddd [kl] LT',
5532 sameElse : 'L'
5533 },
5534 relativeTime : {
5535 future : 'om %s',
5536 past : '%s siden',
5537 s : 'få sekunder',
5538 m : 'et minut',
5539 mm : '%d minutter',
5540 h : 'en time',
5541 hh : '%d timer',
5542 d : 'en dag',
5543 dd : '%d dage',
5544 M : 'en måned',
5545 MM : '%d måneder',
5546 y : 'et år',
5547 yy : '%d år'
5548 },
5549 ordinalParse: /\d{1,2}\./,
5550 ordinal : '%d.',
5551 week : {
5552 dow : 1, // Monday is the first day of the week.
5553 doy : 4 // The week that contains Jan 4th is the first week of the year.
5554 }
5555 });
5557 //! moment.js locale configuration
5558 //! locale : austrian german (de-at)
5559 //! author : lluchs : https://github.com/lluchs
5560 //! author: Menelion Elensúle: https://github.com/Oire
5561 //! author : Martin Groller : https://github.com/MadMG
5562 //! author : Mikolaj Dadela : https://github.com/mik01aj
5564 function de_at__processRelativeTime(number, withoutSuffix, key, isFuture) {
5565 var format = {
5566 'm': ['eine Minute', 'einer Minute'],
5567 'h': ['eine Stunde', 'einer Stunde'],
5568 'd': ['ein Tag', 'einem Tag'],
5569 'dd': [number + ' Tage', number + ' Tagen'],
5570 'M': ['ein Monat', 'einem Monat'],
5571 'MM': [number + ' Monate', number + ' Monaten'],
5572 'y': ['ein Jahr', 'einem Jahr'],
5573 'yy': [number + ' Jahre', number + ' Jahren']
5574 };
5575 return withoutSuffix ? format[key][0] : format[key][1];
5576 }
5578 var de_at = moment__default.defineLocale('de-at', {
5579 months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
5580 monthsShort : 'Jän._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
5581 monthsParseExact : true,
5582 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
5583 weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
5584 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
5585 weekdaysParseExact : true,
5586 longDateFormat : {
5587 LT: 'HH:mm',
5588 LTS: 'HH:mm:ss',
5589 L : 'DD.MM.YYYY',
5590 LL : 'D. MMMM YYYY',
5591 LLL : 'D. MMMM YYYY HH:mm',
5592 LLLL : 'dddd, D. MMMM YYYY HH:mm'
5593 },
5594 calendar : {
5595 sameDay: '[heute um] LT [Uhr]',
5596 sameElse: 'L',
5597 nextDay: '[morgen um] LT [Uhr]',
5598 nextWeek: 'dddd [um] LT [Uhr]',
5599 lastDay: '[gestern um] LT [Uhr]',
5600 lastWeek: '[letzten] dddd [um] LT [Uhr]'
5601 },
5602 relativeTime : {
5603 future : 'in %s',
5604 past : 'vor %s',
5605 s : 'ein paar Sekunden',
5606 m : de_at__processRelativeTime,
5607 mm : '%d Minuten',
5608 h : de_at__processRelativeTime,
5609 hh : '%d Stunden',
5610 d : de_at__processRelativeTime,
5611 dd : de_at__processRelativeTime,
5612 M : de_at__processRelativeTime,
5613 MM : de_at__processRelativeTime,
5614 y : de_at__processRelativeTime,
5615 yy : de_at__processRelativeTime
5616 },
5617 ordinalParse: /\d{1,2}\./,
5618 ordinal : '%d.',
5619 week : {
5620 dow : 1, // Monday is the first day of the week.
5621 doy : 4 // The week that contains Jan 4th is the first week of the year.
5622 }
5623 });
5625 //! moment.js locale configuration
5626 //! locale : german (de)
5627 //! author : lluchs : https://github.com/lluchs
5628 //! author: Menelion Elensúle: https://github.com/Oire
5629 //! author : Mikolaj Dadela : https://github.com/mik01aj
5631 function de__processRelativeTime(number, withoutSuffix, key, isFuture) {
5632 var format = {
5633 'm': ['eine Minute', 'einer Minute'],
5634 'h': ['eine Stunde', 'einer Stunde'],
5635 'd': ['ein Tag', 'einem Tag'],
5636 'dd': [number + ' Tage', number + ' Tagen'],
5637 'M': ['ein Monat', 'einem Monat'],
5638 'MM': [number + ' Monate', number + ' Monaten'],
5639 'y': ['ein Jahr', 'einem Jahr'],
5640 'yy': [number + ' Jahre', number + ' Jahren']
5641 };
5642 return withoutSuffix ? format[key][0] : format[key][1];
5643 }
5645 var de = moment__default.defineLocale('de', {
5646 months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
5647 monthsShort : 'Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
5648 monthsParseExact : true,
5649 weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
5650 weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
5651 weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
5652 weekdaysParseExact : true,
5653 longDateFormat : {
5654 LT: 'HH:mm',
5655 LTS: 'HH:mm:ss',
5656 L : 'DD.MM.YYYY',
5657 LL : 'D. MMMM YYYY',
5658 LLL : 'D. MMMM YYYY HH:mm',
5659 LLLL : 'dddd, D. MMMM YYYY HH:mm'
5660 },
5661 calendar : {
5662 sameDay: '[heute um] LT [Uhr]',
5663 sameElse: 'L',
5664 nextDay: '[morgen um] LT [Uhr]',
5665 nextWeek: 'dddd [um] LT [Uhr]',
5666 lastDay: '[gestern um] LT [Uhr]',
5667 lastWeek: '[letzten] dddd [um] LT [Uhr]'
5668 },
5669 relativeTime : {
5670 future : 'in %s',
5671 past : 'vor %s',
5672 s : 'ein paar Sekunden',
5673 m : de__processRelativeTime,
5674 mm : '%d Minuten',
5675 h : de__processRelativeTime,
5676 hh : '%d Stunden',
5677 d : de__processRelativeTime,
5678 dd : de__processRelativeTime,
5679 M : de__processRelativeTime,
5680 MM : de__processRelativeTime,
5681 y : de__processRelativeTime,
5682 yy : de__processRelativeTime
5683 },
5684 ordinalParse: /\d{1,2}\./,
5685 ordinal : '%d.',
5686 week : {
5687 dow : 1, // Monday is the first day of the week.
5688 doy : 4 // The week that contains Jan 4th is the first week of the year.
5689 }
5690 });
5692 //! moment.js locale configuration
5693 //! locale : dhivehi (dv)
5694 //! author : Jawish Hameed : https://github.com/jawish
5696 var dv__months = [
5697 'ޖެނުއަރީ',
5698 'ފެބްރުއަރީ',
5699 'މާރިޗު',
5700 'އޭޕްރީލު',
5701 'މޭ',
5702 'ޖޫން',
5703 'ޖުލައި',
5704 'އޯގަސްޓު',
5705 'ސެޕްޓެމްބަރު',
5706 'އޮކްޓޯބަރު',
5707 'ނޮވެމްބަރު',
5708 'ޑިސެމްބަރު'
5709 ], dv__weekdays = [
5710 'އާދިއްތަ',
5711 'ހޯމަ',
5712 'އަންގާރަ',
5713 'ބުދަ',
5714 'ބުރާސްފަތި',
5715 'ހުކުރު',
5716 'ހޮނިހިރު'
5717 ];
5719 var dv = moment__default.defineLocale('dv', {
5720 months : dv__months,
5721 monthsShort : dv__months,
5722 weekdays : dv__weekdays,
5723 weekdaysShort : dv__weekdays,
5724 weekdaysMin : 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
5725 longDateFormat : {
5727 LT : 'HH:mm',
5728 LTS : 'HH:mm:ss',
5729 L : 'D/M/YYYY',
5730 LL : 'D MMMM YYYY',
5731 LLL : 'D MMMM YYYY HH:mm',
5732 LLLL : 'dddd D MMMM YYYY HH:mm'
5733 },
5734 meridiemParse: /މކ|މފ/,
5735 isPM : function (input) {
5736 return 'މފ' === input;
5737 },
5738 meridiem : function (hour, minute, isLower) {
5739 if (hour < 12) {
5740 return 'މކ';
5741 } else {
5742 return 'މފ';
5743 }
5744 },
5745 calendar : {
5746 sameDay : '[މިއަދު] LT',
5747 nextDay : '[މާދަމާ] LT',
5748 nextWeek : 'dddd LT',
5749 lastDay : '[އިއްޔެ] LT',
5750 lastWeek : '[ފާއިތުވި] dddd LT',
5751 sameElse : 'L'
5752 },
5753 relativeTime : {
5754 future : 'ތެރޭގައި %s',
5755 past : 'ކުރިން %s',
5756 s : 'ސިކުންތުކޮޅެއް',
5757 m : 'މިނިޓެއް',
5758 mm : 'މިނިޓު %d',
5759 h : 'ގަޑިއިރެއް',
5760 hh : 'ގަޑިއިރު %d',
5761 d : 'ދުވަހެއް',
5762 dd : 'ދުވަސް %d',
5763 M : 'މަހެއް',
5764 MM : 'މަސް %d',
5765 y : 'އަހަރެއް',
5766 yy : 'އަހަރު %d'
5767 },
5768 preparse: function (string) {
5769 return string.replace(/،/g, ',');
5770 },
5771 postformat: function (string) {
5772 return string.replace(/,/g, '،');
5773 },
5774 week : {
5775 dow : 7, // Sunday is the first day of the week.
5776 doy : 12 // The week that contains Jan 1st is the first week of the year.
5777 }
5778 });
5780 //! moment.js locale configuration
5781 //! locale : modern greek (el)
5782 //! author : Aggelos Karalias : https://github.com/mehiel
5784 var el = moment__default.defineLocale('el', {
5785 monthsNominativeEl : 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
5786 monthsGenitiveEl : 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split('_'),
5787 months : function (momentToFormat, format) {
5788 if (/D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
5789 return this._monthsGenitiveEl[momentToFormat.month()];
5790 } else {
5791 return this._monthsNominativeEl[momentToFormat.month()];
5792 }
5793 },
5794 monthsShort : 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
5795 weekdays : 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split('_'),
5796 weekdaysShort : 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
5797 weekdaysMin : 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
5798 meridiem : function (hours, minutes, isLower) {
5799 if (hours > 11) {
5800 return isLower ? 'μμ' : 'ΜΜ';
5801 } else {
5802 return isLower ? 'πμ' : 'ΠΜ';
5803 }
5804 },
5805 isPM : function (input) {
5806 return ((input + '').toLowerCase()[0] === 'μ');
5807 },
5808 meridiemParse : /[ΠΜ]\.?Μ?\.?/i,
5809 longDateFormat : {
5810 LT : 'h:mm A',
5811 LTS : 'h:mm:ss A',
5812 L : 'DD/MM/YYYY',
5813 LL : 'D MMMM YYYY',
5814 LLL : 'D MMMM YYYY h:mm A',
5815 LLLL : 'dddd, D MMMM YYYY h:mm A'
5816 },
5817 calendarEl : {
5818 sameDay : '[Σήμερα {}] LT',
5819 nextDay : '[Αύριο {}] LT',
5820 nextWeek : 'dddd [{}] LT',
5821 lastDay : '[Χθες {}] LT',
5822 lastWeek : function () {
5823 switch (this.day()) {
5824 case 6:
5825 return '[το προηγούμενο] dddd [{}] LT';
5826 default:
5827 return '[την προηγούμενη] dddd [{}] LT';
5828 }
5829 },
5830 sameElse : 'L'
5831 },
5832 calendar : function (key, mom) {
5833 var output = this._calendarEl[key],
5834 hours = mom && mom.hours();
5835 if (isFunction(output)) {
5836 output = output.apply(mom);
5837 }
5838 return output.replace('{}', (hours % 12 === 1 ? 'στη' : 'στις'));
5839 },
5840 relativeTime : {
5841 future : 'σε %s',
5842 past : '%s πριν',
5843 s : 'λίγα δευτερόλεπτα',
5844 m : 'ένα λεπτό',
5845 mm : '%d λεπτά',
5846 h : 'μία ώρα',
5847 hh : '%d ώρες',
5848 d : 'μία μέρα',
5849 dd : '%d μέρες',
5850 M : 'ένας μήνας',
5851 MM : '%d μήνες',
5852 y : 'ένας χρόνος',
5853 yy : '%d χρόνια'
5854 },
5855 ordinalParse: /\d{1,2}η/,
5856 ordinal: '%dη',
5857 week : {
5858 dow : 1, // Monday is the first day of the week.
5859 doy : 4 // The week that contains Jan 4st is the first week of the year.
5860 }
5861 });
5863 //! moment.js locale configuration
5864 //! locale : australian english (en-au)
5866 var en_au = moment__default.defineLocale('en-au', {
5867 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
5868 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
5869 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
5870 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
5871 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
5872 longDateFormat : {
5873 LT : 'h:mm A',
5874 LTS : 'h:mm:ss A',
5875 L : 'DD/MM/YYYY',
5876 LL : 'D MMMM YYYY',
5877 LLL : 'D MMMM YYYY h:mm A',
5878 LLLL : 'dddd, D MMMM YYYY h:mm A'
5879 },
5880 calendar : {
5881 sameDay : '[Today at] LT',
5882 nextDay : '[Tomorrow at] LT',
5883 nextWeek : 'dddd [at] LT',
5884 lastDay : '[Yesterday at] LT',
5885 lastWeek : '[Last] dddd [at] LT',
5886 sameElse : 'L'
5887 },
5888 relativeTime : {
5889 future : 'in %s',
5890 past : '%s ago',
5891 s : 'a few seconds',
5892 m : 'a minute',
5893 mm : '%d minutes',
5894 h : 'an hour',
5895 hh : '%d hours',
5896 d : 'a day',
5897 dd : '%d days',
5898 M : 'a month',
5899 MM : '%d months',
5900 y : 'a year',
5901 yy : '%d years'
5902 },
5903 ordinalParse: /\d{1,2}(st|nd|rd|th)/,
5904 ordinal : function (number) {
5905 var b = number % 10,
5906 output = (~~(number % 100 / 10) === 1) ? 'th' :
5907 (b === 1) ? 'st' :
5908 (b === 2) ? 'nd' :
5909 (b === 3) ? 'rd' : 'th';
5910 return number + output;
5911 },
5912 week : {
5913 dow : 1, // Monday is the first day of the week.
5914 doy : 4 // The week that contains Jan 4th is the first week of the year.
5915 }
5916 });
5918 //! moment.js locale configuration
5919 //! locale : canadian english (en-ca)
5920 //! author : Jonathan Abourbih : https://github.com/jonbca
5922 var en_ca = moment__default.defineLocale('en-ca', {
5923 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
5924 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
5925 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
5926 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
5927 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
5928 longDateFormat : {
5929 LT : 'h:mm A',
5930 LTS : 'h:mm:ss A',
5931 L : 'YYYY-MM-DD',
5932 LL : 'MMMM D, YYYY',
5933 LLL : 'MMMM D, YYYY h:mm A',
5934 LLLL : 'dddd, MMMM D, YYYY h:mm A'
5935 },
5936 calendar : {
5937 sameDay : '[Today at] LT',
5938 nextDay : '[Tomorrow at] LT',
5939 nextWeek : 'dddd [at] LT',
5940 lastDay : '[Yesterday at] LT',
5941 lastWeek : '[Last] dddd [at] LT',
5942 sameElse : 'L'
5943 },
5944 relativeTime : {
5945 future : 'in %s',
5946 past : '%s ago',
5947 s : 'a few seconds',
5948 m : 'a minute',
5949 mm : '%d minutes',
5950 h : 'an hour',
5951 hh : '%d hours',
5952 d : 'a day',
5953 dd : '%d days',
5954 M : 'a month',
5955 MM : '%d months',
5956 y : 'a year',
5957 yy : '%d years'
5958 },
5959 ordinalParse: /\d{1,2}(st|nd|rd|th)/,
5960 ordinal : function (number) {
5961 var b = number % 10,
5962 output = (~~(number % 100 / 10) === 1) ? 'th' :
5963 (b === 1) ? 'st' :
5964 (b === 2) ? 'nd' :
5965 (b === 3) ? 'rd' : 'th';
5966 return number + output;
5967 }
5968 });
5970 //! moment.js locale configuration
5971 //! locale : great britain english (en-gb)
5972 //! author : Chris Gedrim : https://github.com/chrisgedrim
5974 var en_gb = moment__default.defineLocale('en-gb', {
5975 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
5976 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
5977 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
5978 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
5979 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
5980 longDateFormat : {
5981 LT : 'HH:mm',
5982 LTS : 'HH:mm:ss',
5983 L : 'DD/MM/YYYY',
5984 LL : 'D MMMM YYYY',
5985 LLL : 'D MMMM YYYY HH:mm',
5986 LLLL : 'dddd, D MMMM YYYY HH:mm'
5987 },
5988 calendar : {
5989 sameDay : '[Today at] LT',
5990 nextDay : '[Tomorrow at] LT',
5991 nextWeek : 'dddd [at] LT',
5992 lastDay : '[Yesterday at] LT',
5993 lastWeek : '[Last] dddd [at] LT',
5994 sameElse : 'L'
5995 },
5996 relativeTime : {
5997 future : 'in %s',
5998 past : '%s ago',
5999 s : 'a few seconds',
6000 m : 'a minute',
6001 mm : '%d minutes',
6002 h : 'an hour',
6003 hh : '%d hours',
6004 d : 'a day',
6005 dd : '%d days',
6006 M : 'a month',
6007 MM : '%d months',
6008 y : 'a year',
6009 yy : '%d years'
6010 },
6011 ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6012 ordinal : function (number) {
6013 var b = number % 10,
6014 output = (~~(number % 100 / 10) === 1) ? 'th' :
6015 (b === 1) ? 'st' :
6016 (b === 2) ? 'nd' :
6017 (b === 3) ? 'rd' : 'th';
6018 return number + output;
6019 },
6020 week : {
6021 dow : 1, // Monday is the first day of the week.
6022 doy : 4 // The week that contains Jan 4th is the first week of the year.
6023 }
6024 });
6026 //! moment.js locale configuration
6027 //! locale : Irish english (en-ie)
6028 //! author : Chris Cartlidge : https://github.com/chriscartlidge
6030 var en_ie = moment__default.defineLocale('en-ie', {
6031 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6032 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6033 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6034 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6035 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6036 longDateFormat : {
6037 LT : 'HH:mm',
6038 LTS : 'HH:mm:ss',
6039 L : 'DD-MM-YYYY',
6040 LL : 'D MMMM YYYY',
6041 LLL : 'D MMMM YYYY HH:mm',
6042 LLLL : 'dddd D MMMM YYYY HH:mm'
6043 },
6044 calendar : {
6045 sameDay : '[Today at] LT',
6046 nextDay : '[Tomorrow at] LT',
6047 nextWeek : 'dddd [at] LT',
6048 lastDay : '[Yesterday at] LT',
6049 lastWeek : '[Last] dddd [at] LT',
6050 sameElse : 'L'
6051 },
6052 relativeTime : {
6053 future : 'in %s',
6054 past : '%s ago',
6055 s : 'a few seconds',
6056 m : 'a minute',
6057 mm : '%d minutes',
6058 h : 'an hour',
6059 hh : '%d hours',
6060 d : 'a day',
6061 dd : '%d days',
6062 M : 'a month',
6063 MM : '%d months',
6064 y : 'a year',
6065 yy : '%d years'
6066 },
6067 ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6068 ordinal : function (number) {
6069 var b = number % 10,
6070 output = (~~(number % 100 / 10) === 1) ? 'th' :
6071 (b === 1) ? 'st' :
6072 (b === 2) ? 'nd' :
6073 (b === 3) ? 'rd' : 'th';
6074 return number + output;
6075 },
6076 week : {
6077 dow : 1, // Monday is the first day of the week.
6078 doy : 4 // The week that contains Jan 4th is the first week of the year.
6079 }
6080 });
6082 //! moment.js locale configuration
6083 //! locale : New Zealand english (en-nz)
6085 var en_nz = moment__default.defineLocale('en-nz', {
6086 months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6087 monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6088 weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6089 weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6090 weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6091 longDateFormat : {
6092 LT : 'h:mm A',
6093 LTS : 'h:mm:ss A',
6094 L : 'DD/MM/YYYY',
6095 LL : 'D MMMM YYYY',
6096 LLL : 'D MMMM YYYY h:mm A',
6097 LLLL : 'dddd, D MMMM YYYY h:mm A'
6098 },
6099 calendar : {
6100 sameDay : '[Today at] LT',
6101 nextDay : '[Tomorrow at] LT',
6102 nextWeek : 'dddd [at] LT',
6103 lastDay : '[Yesterday at] LT',
6104 lastWeek : '[Last] dddd [at] LT',
6105 sameElse : 'L'
6106 },
6107 relativeTime : {
6108 future : 'in %s',
6109 past : '%s ago',
6110 s : 'a few seconds',
6111 m : 'a minute',
6112 mm : '%d minutes',
6113 h : 'an hour',
6114 hh : '%d hours',
6115 d : 'a day',
6116 dd : '%d days',
6117 M : 'a month',
6118 MM : '%d months',
6119 y : 'a year',
6120 yy : '%d years'
6121 },
6122 ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6123 ordinal : function (number) {
6124 var b = number % 10,
6125 output = (~~(number % 100 / 10) === 1) ? 'th' :
6126 (b === 1) ? 'st' :
6127 (b === 2) ? 'nd' :
6128 (b === 3) ? 'rd' : 'th';
6129 return number + output;
6130 },
6131 week : {
6132 dow : 1, // Monday is the first day of the week.
6133 doy : 4 // The week that contains Jan 4th is the first week of the year.
6134 }
6135 });
6137 //! moment.js locale configuration
6138 //! locale : esperanto (eo)
6139 //! author : Colin Dean : https://github.com/colindean
6140 //! komento: Mi estas malcerta se mi korekte traktis akuzativojn en tiu traduko.
6141 //! Se ne, bonvolu korekti kaj avizi min por ke mi povas lerni!
6143 var eo = moment__default.defineLocale('eo', {
6144 months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
6145 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec'.split('_'),
6146 weekdays : 'Dimanĉo_Lundo_Mardo_Merkredo_Ĵaŭdo_Vendredo_Sabato'.split('_'),
6147 weekdaysShort : 'Dim_Lun_Mard_Merk_Ĵaŭ_Ven_Sab'.split('_'),
6148 weekdaysMin : 'Di_Lu_Ma_Me_Ĵa_Ve_Sa'.split('_'),
6149 longDateFormat : {
6150 LT : 'HH:mm',
6151 LTS : 'HH:mm:ss',
6152 L : 'YYYY-MM-DD',
6153 LL : 'D[-an de] MMMM, YYYY',
6154 LLL : 'D[-an de] MMMM, YYYY HH:mm',
6155 LLLL : 'dddd, [la] D[-an de] MMMM, YYYY HH:mm'
6156 },
6157 meridiemParse: /[ap]\.t\.m/i,
6158 isPM: function (input) {
6159 return input.charAt(0).toLowerCase() === 'p';
6160 },
6161 meridiem : function (hours, minutes, isLower) {
6162 if (hours > 11) {
6163 return isLower ? 'p.t.m.' : 'P.T.M.';
6164 } else {
6165 return isLower ? 'a.t.m.' : 'A.T.M.';
6166 }
6167 },
6168 calendar : {
6169 sameDay : '[Hodiaŭ je] LT',
6170 nextDay : '[Morgaŭ je] LT',
6171 nextWeek : 'dddd [je] LT',
6172 lastDay : '[Hieraŭ je] LT',
6173 lastWeek : '[pasinta] dddd [je] LT',
6174 sameElse : 'L'
6175 },
6176 relativeTime : {
6177 future : 'je %s',
6178 past : 'antaŭ %s',
6179 s : 'sekundoj',
6180 m : 'minuto',
6181 mm : '%d minutoj',
6182 h : 'horo',
6183 hh : '%d horoj',
6184 d : 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
6185 dd : '%d tagoj',
6186 M : 'monato',
6187 MM : '%d monatoj',
6188 y : 'jaro',
6189 yy : '%d jaroj'
6190 },
6191 ordinalParse: /\d{1,2}a/,
6192 ordinal : '%da',
6193 week : {
6194 dow : 1, // Monday is the first day of the week.
6195 doy : 7 // The week that contains Jan 1st is the first week of the year.
6196 }
6197 });
6199 //! moment.js locale configuration
6200 //! locale : spanish (es)
6201 //! author : Julio Napurí : https://github.com/julionc
6203 var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
6204 es__monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
6206 var es = moment__default.defineLocale('es', {
6207 months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
6208 monthsShort : function (m, format) {
6209 if (/-MMM-/.test(format)) {
6210 return es__monthsShort[m.month()];
6211 } else {
6212 return monthsShortDot[m.month()];
6213 }
6214 },
6215 monthsParseExact : true,
6216 weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
6217 weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
6218 weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
6219 weekdaysParseExact : true,
6220 longDateFormat : {
6221 LT : 'H:mm',
6222 LTS : 'H:mm:ss',
6223 L : 'DD/MM/YYYY',
6224 LL : 'D [de] MMMM [de] YYYY',
6225 LLL : 'D [de] MMMM [de] YYYY H:mm',
6226 LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
6227 },
6228 calendar : {
6229 sameDay : function () {
6230 return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6231 },
6232 nextDay : function () {
6233 return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6234 },
6235 nextWeek : function () {
6236 return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6237 },
6238 lastDay : function () {
6239 return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6240 },
6241 lastWeek : function () {
6242 return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6243 },
6244 sameElse : 'L'
6245 },
6246 relativeTime : {
6247 future : 'en %s',
6248 past : 'hace %s',
6249 s : 'unos segundos',
6250 m : 'un minuto',
6251 mm : '%d minutos',
6252 h : 'una hora',
6253 hh : '%d horas',
6254 d : 'un día',
6255 dd : '%d días',
6256 M : 'un mes',
6257 MM : '%d meses',
6258 y : 'un año',
6259 yy : '%d años'
6260 },
6261 ordinalParse : /\d{1,2}º/,
6262 ordinal : '%dº',
6263 week : {
6264 dow : 1, // Monday is the first day of the week.
6265 doy : 4 // The week that contains Jan 4th is the first week of the year.
6266 }
6267 });
6269 //! moment.js locale configuration
6270 //! locale : estonian (et)
6271 //! author : Henry Kehlmann : https://github.com/madhenry
6272 //! improvements : Illimar Tambek : https://github.com/ragulka
6274 function et__processRelativeTime(number, withoutSuffix, key, isFuture) {
6275 var format = {
6276 's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
6277 'm' : ['ühe minuti', 'üks minut'],
6278 'mm': [number + ' minuti', number + ' minutit'],
6279 'h' : ['ühe tunni', 'tund aega', 'üks tund'],
6280 'hh': [number + ' tunni', number + ' tundi'],
6281 'd' : ['ühe päeva', 'üks päev'],
6282 'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
6283 'MM': [number + ' kuu', number + ' kuud'],
6284 'y' : ['ühe aasta', 'aasta', 'üks aasta'],
6285 'yy': [number + ' aasta', number + ' aastat']
6286 };
6287 if (withoutSuffix) {
6288 return format[key][2] ? format[key][2] : format[key][1];
6289 }
6290 return isFuture ? format[key][0] : format[key][1];
6291 }
6293 var et = moment__default.defineLocale('et', {
6294 months : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
6295 monthsShort : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
6296 weekdays : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
6297 weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
6298 weekdaysMin : 'P_E_T_K_N_R_L'.split('_'),
6299 longDateFormat : {
6300 LT : 'H:mm',
6301 LTS : 'H:mm:ss',
6302 L : 'DD.MM.YYYY',
6303 LL : 'D. MMMM YYYY',
6304 LLL : 'D. MMMM YYYY H:mm',
6305 LLLL : 'dddd, D. MMMM YYYY H:mm'
6306 },
6307 calendar : {
6308 sameDay : '[Täna,] LT',
6309 nextDay : '[Homme,] LT',
6310 nextWeek : '[Järgmine] dddd LT',
6311 lastDay : '[Eile,] LT',
6312 lastWeek : '[Eelmine] dddd LT',
6313 sameElse : 'L'
6314 },
6315 relativeTime : {
6316 future : '%s pärast',
6317 past : '%s tagasi',
6318 s : et__processRelativeTime,
6319 m : et__processRelativeTime,
6320 mm : et__processRelativeTime,
6321 h : et__processRelativeTime,
6322 hh : et__processRelativeTime,
6323 d : et__processRelativeTime,
6324 dd : '%d päeva',
6325 M : et__processRelativeTime,
6326 MM : et__processRelativeTime,
6327 y : et__processRelativeTime,
6328 yy : et__processRelativeTime
6329 },
6330 ordinalParse: /\d{1,2}\./,
6331 ordinal : '%d.',
6332 week : {
6333 dow : 1, // Monday is the first day of the week.
6334 doy : 4 // The week that contains Jan 4th is the first week of the year.
6335 }
6336 });
6338 //! moment.js locale configuration
6339 //! locale : euskara (eu)
6340 //! author : Eneko Illarramendi : https://github.com/eillarra
6342 var eu = moment__default.defineLocale('eu', {
6343 months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
6344 monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
6345 monthsParseExact : true,
6346 weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
6347 weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
6348 weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
6349 weekdaysParseExact : true,
6350 longDateFormat : {
6351 LT : 'HH:mm',
6352 LTS : 'HH:mm:ss',
6353 L : 'YYYY-MM-DD',
6354 LL : 'YYYY[ko] MMMM[ren] D[a]',
6355 LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm',
6356 LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
6357 l : 'YYYY-M-D',
6358 ll : 'YYYY[ko] MMM D[a]',
6359 lll : 'YYYY[ko] MMM D[a] HH:mm',
6360 llll : 'ddd, YYYY[ko] MMM D[a] HH:mm'
6361 },
6362 calendar : {
6363 sameDay : '[gaur] LT[etan]',
6364 nextDay : '[bihar] LT[etan]',
6365 nextWeek : 'dddd LT[etan]',
6366 lastDay : '[atzo] LT[etan]',
6367 lastWeek : '[aurreko] dddd LT[etan]',
6368 sameElse : 'L'
6369 },
6370 relativeTime : {
6371 future : '%s barru',
6372 past : 'duela %s',
6373 s : 'segundo batzuk',
6374 m : 'minutu bat',
6375 mm : '%d minutu',
6376 h : 'ordu bat',
6377 hh : '%d ordu',
6378 d : 'egun bat',
6379 dd : '%d egun',
6380 M : 'hilabete bat',
6381 MM : '%d hilabete',
6382 y : 'urte bat',
6383 yy : '%d urte'
6384 },
6385 ordinalParse: /\d{1,2}\./,
6386 ordinal : '%d.',
6387 week : {
6388 dow : 1, // Monday is the first day of the week.
6389 doy : 7 // The week that contains Jan 1st is the first week of the year.
6390 }
6391 });
6393 //! moment.js locale configuration
6394 //! locale : Persian (fa)
6395 //! author : Ebrahim Byagowi : https://github.com/ebraminio
6397 var fa__symbolMap = {
6398 '1': '۱',
6399 '2': '۲',
6400 '3': '۳',
6401 '4': '۴',
6402 '5': '۵',
6403 '6': '۶',
6404 '7': '۷',
6405 '8': '۸',
6406 '9': '۹',
6407 '0': '۰'
6408 }, fa__numberMap = {
6409 '۱': '1',
6410 '۲': '2',
6411 '۳': '3',
6412 '۴': '4',
6413 '۵': '5',
6414 '۶': '6',
6415 '۷': '7',
6416 '۸': '8',
6417 '۹': '9',
6418 '۰': '0'
6419 };
6421 var fa = moment__default.defineLocale('fa', {
6422 months : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
6423 monthsShort : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
6424 weekdays : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
6425 weekdaysShort : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
6426 weekdaysMin : 'ی_د_س_چ_پ_ج_ش'.split('_'),
6427 weekdaysParseExact : true,
6428 longDateFormat : {
6429 LT : 'HH:mm',
6430 LTS : 'HH:mm:ss',
6431 L : 'DD/MM/YYYY',
6432 LL : 'D MMMM YYYY',
6433 LLL : 'D MMMM YYYY HH:mm',
6434 LLLL : 'dddd, D MMMM YYYY HH:mm'
6435 },
6436 meridiemParse: /قبل از ظهر|بعد از ظهر/,
6437 isPM: function (input) {
6438 return /بعد از ظهر/.test(input);
6439 },
6440 meridiem : function (hour, minute, isLower) {
6441 if (hour < 12) {
6442 return 'قبل از ظهر';
6443 } else {
6444 return 'بعد از ظهر';
6445 }
6446 },
6447 calendar : {
6448 sameDay : '[امروز ساعت] LT',
6449 nextDay : '[فردا ساعت] LT',
6450 nextWeek : 'dddd [ساعت] LT',
6451 lastDay : '[دیروز ساعت] LT',
6452 lastWeek : 'dddd [پیش] [ساعت] LT',
6453 sameElse : 'L'
6454 },
6455 relativeTime : {
6456 future : 'در %s',
6457 past : '%s پیش',
6458 s : 'چندین ثانیه',
6459 m : 'یک دقیقه',
6460 mm : '%d دقیقه',
6461 h : 'یک ساعت',
6462 hh : '%d ساعت',
6463 d : 'یک روز',
6464 dd : '%d روز',
6465 M : 'یک ماه',
6466 MM : '%d ماه',
6467 y : 'یک سال',
6468 yy : '%d سال'
6469 },
6470 preparse: function (string) {
6471 return string.replace(/[۰-۹]/g, function (match) {
6472 return fa__numberMap[match];
6473 }).replace(/،/g, ',');
6474 },
6475 postformat: function (string) {
6476 return string.replace(/\d/g, function (match) {
6477 return fa__symbolMap[match];
6478 }).replace(/,/g, '،');
6479 },
6480 ordinalParse: /\d{1,2}م/,
6481 ordinal : '%dم',
6482 week : {
6483 dow : 6, // Saturday is the first day of the week.
6484 doy : 12 // The week that contains Jan 1st is the first week of the year.
6485 }
6486 });
6488 //! moment.js locale configuration
6489 //! locale : finnish (fi)
6490 //! author : Tarmo Aidantausta : https://github.com/bleadof
6492 var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '),
6493 numbersFuture = [
6494 'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
6495 numbersPast[7], numbersPast[8], numbersPast[9]
6496 ];
6497 function fi__translate(number, withoutSuffix, key, isFuture) {
6498 var result = '';
6499 switch (key) {
6500 case 's':
6501 return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
6502 case 'm':
6503 return isFuture ? 'minuutin' : 'minuutti';
6504 case 'mm':
6505 result = isFuture ? 'minuutin' : 'minuuttia';
6506 break;
6507 case 'h':
6508 return isFuture ? 'tunnin' : 'tunti';
6509 case 'hh':
6510 result = isFuture ? 'tunnin' : 'tuntia';
6511 break;
6512 case 'd':
6513 return isFuture ? 'päivän' : 'päivä';
6514 case 'dd':
6515 result = isFuture ? 'päivän' : 'päivää';
6516 break;
6517 case 'M':
6518 return isFuture ? 'kuukauden' : 'kuukausi';
6519 case 'MM':
6520 result = isFuture ? 'kuukauden' : 'kuukautta';
6521 break;
6522 case 'y':
6523 return isFuture ? 'vuoden' : 'vuosi';
6524 case 'yy':
6525 result = isFuture ? 'vuoden' : 'vuotta';
6526 break;
6527 }
6528 result = verbalNumber(number, isFuture) + ' ' + result;
6529 return result;
6530 }
6531 function verbalNumber(number, isFuture) {
6532 return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;
6533 }
6535 var fi = moment__default.defineLocale('fi', {
6536 months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
6537 monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
6538 weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
6539 weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
6540 weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
6541 longDateFormat : {
6542 LT : 'HH.mm',
6543 LTS : 'HH.mm.ss',
6544 L : 'DD.MM.YYYY',
6545 LL : 'Do MMMM[ta] YYYY',
6546 LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm',
6547 LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
6548 l : 'D.M.YYYY',
6549 ll : 'Do MMM YYYY',
6550 lll : 'Do MMM YYYY, [klo] HH.mm',
6551 llll : 'ddd, Do MMM YYYY, [klo] HH.mm'
6552 },
6553 calendar : {
6554 sameDay : '[tänään] [klo] LT',
6555 nextDay : '[huomenna] [klo] LT',
6556 nextWeek : 'dddd [klo] LT',
6557 lastDay : '[eilen] [klo] LT',
6558 lastWeek : '[viime] dddd[na] [klo] LT',
6559 sameElse : 'L'
6560 },
6561 relativeTime : {
6562 future : '%s päästä',
6563 past : '%s sitten',
6564 s : fi__translate,
6565 m : fi__translate,
6566 mm : fi__translate,
6567 h : fi__translate,
6568 hh : fi__translate,
6569 d : fi__translate,
6570 dd : fi__translate,
6571 M : fi__translate,
6572 MM : fi__translate,
6573 y : fi__translate,
6574 yy : fi__translate
6575 },
6576 ordinalParse: /\d{1,2}\./,
6577 ordinal : '%d.',
6578 week : {
6579 dow : 1, // Monday is the first day of the week.
6580 doy : 4 // The week that contains Jan 4th is the first week of the year.
6581 }
6582 });
6584 //! moment.js locale configuration
6585 //! locale : faroese (fo)
6586 //! author : Ragnar Johannesen : https://github.com/ragnar123
6588 var fo = moment__default.defineLocale('fo', {
6589 months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
6590 monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
6591 weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
6592 weekdaysShort : 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
6593 weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'),
6594 longDateFormat : {
6595 LT : 'HH:mm',
6596 LTS : 'HH:mm:ss',
6597 L : 'DD/MM/YYYY',
6598 LL : 'D MMMM YYYY',
6599 LLL : 'D MMMM YYYY HH:mm',
6600 LLLL : 'dddd D. MMMM, YYYY HH:mm'
6601 },
6602 calendar : {
6603 sameDay : '[Í dag kl.] LT',
6604 nextDay : '[Í morgin kl.] LT',
6605 nextWeek : 'dddd [kl.] LT',
6606 lastDay : '[Í gjár kl.] LT',
6607 lastWeek : '[síðstu] dddd [kl] LT',
6608 sameElse : 'L'
6609 },
6610 relativeTime : {
6611 future : 'um %s',
6612 past : '%s síðani',
6613 s : 'fá sekund',
6614 m : 'ein minutt',
6615 mm : '%d minuttir',
6616 h : 'ein tími',
6617 hh : '%d tímar',
6618 d : 'ein dagur',
6619 dd : '%d dagar',
6620 M : 'ein mánaði',
6621 MM : '%d mánaðir',
6622 y : 'eitt ár',
6623 yy : '%d ár'
6624 },
6625 ordinalParse: /\d{1,2}\./,
6626 ordinal : '%d.',
6627 week : {
6628 dow : 1, // Monday is the first day of the week.
6629 doy : 4 // The week that contains Jan 4th is the first week of the year.
6630 }
6631 });
6633 //! moment.js locale configuration
6634 //! locale : canadian french (fr-ca)
6635 //! author : Jonathan Abourbih : https://github.com/jonbca
6637 var fr_ca = moment__default.defineLocale('fr-ca', {
6638 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
6639 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
6640 monthsParseExact : true,
6641 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
6642 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
6643 weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
6644 weekdaysParseExact : true,
6645 longDateFormat : {
6646 LT : 'HH:mm',
6647 LTS : 'HH:mm:ss',
6648 L : 'YYYY-MM-DD',
6649 LL : 'D MMMM YYYY',
6650 LLL : 'D MMMM YYYY HH:mm',
6651 LLLL : 'dddd D MMMM YYYY HH:mm'
6652 },
6653 calendar : {
6654 sameDay: '[Aujourd\'hui à] LT',
6655 nextDay: '[Demain à] LT',
6656 nextWeek: 'dddd [à] LT',
6657 lastDay: '[Hier à] LT',
6658 lastWeek: 'dddd [dernier à] LT',
6659 sameElse: 'L'
6660 },
6661 relativeTime : {
6662 future : 'dans %s',
6663 past : 'il y a %s',
6664 s : 'quelques secondes',
6665 m : 'une minute',
6666 mm : '%d minutes',
6667 h : 'une heure',
6668 hh : '%d heures',
6669 d : 'un jour',
6670 dd : '%d jours',
6671 M : 'un mois',
6672 MM : '%d mois',
6673 y : 'un an',
6674 yy : '%d ans'
6675 },
6676 ordinalParse: /\d{1,2}(er|e)/,
6677 ordinal : function (number) {
6678 return number + (number === 1 ? 'er' : 'e');
6679 }
6680 });
6682 //! moment.js locale configuration
6683 //! locale : swiss french (fr)
6684 //! author : Gaspard Bucher : https://github.com/gaspard
6686 var fr_ch = moment__default.defineLocale('fr-ch', {
6687 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
6688 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
6689 monthsParseExact : true,
6690 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
6691 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
6692 weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
6693 weekdaysParseExact : true,
6694 longDateFormat : {
6695 LT : 'HH:mm',
6696 LTS : 'HH:mm:ss',
6697 L : 'DD.MM.YYYY',
6698 LL : 'D MMMM YYYY',
6699 LLL : 'D MMMM YYYY HH:mm',
6700 LLLL : 'dddd D MMMM YYYY HH:mm'
6701 },
6702 calendar : {
6703 sameDay: '[Aujourd\'hui à] LT',
6704 nextDay: '[Demain à] LT',
6705 nextWeek: 'dddd [à] LT',
6706 lastDay: '[Hier à] LT',
6707 lastWeek: 'dddd [dernier à] LT',
6708 sameElse: 'L'
6709 },
6710 relativeTime : {
6711 future : 'dans %s',
6712 past : 'il y a %s',
6713 s : 'quelques secondes',
6714 m : 'une minute',
6715 mm : '%d minutes',
6716 h : 'une heure',
6717 hh : '%d heures',
6718 d : 'un jour',
6719 dd : '%d jours',
6720 M : 'un mois',
6721 MM : '%d mois',
6722 y : 'un an',
6723 yy : '%d ans'
6724 },
6725 ordinalParse: /\d{1,2}(er|e)/,
6726 ordinal : function (number) {
6727 return number + (number === 1 ? 'er' : 'e');
6728 },
6729 week : {
6730 dow : 1, // Monday is the first day of the week.
6731 doy : 4 // The week that contains Jan 4th is the first week of the year.
6732 }
6733 });
6735 //! moment.js locale configuration
6736 //! locale : french (fr)
6737 //! author : John Fischer : https://github.com/jfroffice
6739 var fr = moment__default.defineLocale('fr', {
6740 months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
6741 monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
6742 monthsParseExact : true,
6743 weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
6744 weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
6745 weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
6746 weekdaysParseExact : true,
6747 longDateFormat : {
6748 LT : 'HH:mm',
6749 LTS : 'HH:mm:ss',
6750 L : 'DD/MM/YYYY',
6751 LL : 'D MMMM YYYY',
6752 LLL : 'D MMMM YYYY HH:mm',
6753 LLLL : 'dddd D MMMM YYYY HH:mm'
6754 },
6755 calendar : {
6756 sameDay: '[Aujourd\'hui à] LT',
6757 nextDay: '[Demain à] LT',
6758 nextWeek: 'dddd [à] LT',
6759 lastDay: '[Hier à] LT',
6760 lastWeek: 'dddd [dernier à] LT',
6761 sameElse: 'L'
6762 },
6763 relativeTime : {
6764 future : 'dans %s',
6765 past : 'il y a %s',
6766 s : 'quelques secondes',
6767 m : 'une minute',
6768 mm : '%d minutes',
6769 h : 'une heure',
6770 hh : '%d heures',
6771 d : 'un jour',
6772 dd : '%d jours',
6773 M : 'un mois',
6774 MM : '%d mois',
6775 y : 'un an',
6776 yy : '%d ans'
6777 },
6778 ordinalParse: /\d{1,2}(er|)/,
6779 ordinal : function (number) {
6780 return number + (number === 1 ? 'er' : '');
6781 },
6782 week : {
6783 dow : 1, // Monday is the first day of the week.
6784 doy : 4 // The week that contains Jan 4th is the first week of the year.
6785 }
6786 });
6788 //! moment.js locale configuration
6789 //! locale : frisian (fy)
6790 //! author : Robin van der Vliet : https://github.com/robin0van0der0v
6792 var fy__monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'),
6793 fy__monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
6795 var fy = moment__default.defineLocale('fy', {
6796 months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
6797 monthsShort : function (m, format) {
6798 if (/-MMM-/.test(format)) {
6799 return fy__monthsShortWithoutDots[m.month()];
6800 } else {
6801 return fy__monthsShortWithDots[m.month()];
6802 }
6803 },
6804 monthsParseExact : true,
6805 weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
6806 weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'),
6807 weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
6808 weekdaysParseExact : true,
6809 longDateFormat : {
6810 LT : 'HH:mm',
6811 LTS : 'HH:mm:ss',
6812 L : 'DD-MM-YYYY',
6813 LL : 'D MMMM YYYY',
6814 LLL : 'D MMMM YYYY HH:mm',
6815 LLLL : 'dddd D MMMM YYYY HH:mm'
6816 },
6817 calendar : {
6818 sameDay: '[hjoed om] LT',
6819 nextDay: '[moarn om] LT',
6820 nextWeek: 'dddd [om] LT',
6821 lastDay: '[juster om] LT',
6822 lastWeek: '[ôfrûne] dddd [om] LT',
6823 sameElse: 'L'
6824 },
6825 relativeTime : {
6826 future : 'oer %s',
6827 past : '%s lyn',
6828 s : 'in pear sekonden',
6829 m : 'ien minút',
6830 mm : '%d minuten',
6831 h : 'ien oere',
6832 hh : '%d oeren',
6833 d : 'ien dei',
6834 dd : '%d dagen',
6835 M : 'ien moanne',
6836 MM : '%d moannen',
6837 y : 'ien jier',
6838 yy : '%d jierren'
6839 },
6840 ordinalParse: /\d{1,2}(ste|de)/,
6841 ordinal : function (number) {
6842 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
6843 },
6844 week : {
6845 dow : 1, // Monday is the first day of the week.
6846 doy : 4 // The week that contains Jan 4th is the first week of the year.
6847 }
6848 });
6850 //! moment.js locale configuration
6851 //! locale : great britain scottish gealic (gd)
6852 //! author : Jon Ashdown : https://github.com/jonashdown
6854 var gd__months = [
6855 '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'
6856 ];
6858 var gd__monthsShort = ['Faoi', 'Gear', 'Màrt', 'Gibl', 'Cèit', 'Ògmh', 'Iuch', 'Lùn', 'Sult', 'Dàmh', 'Samh', 'Dùbh'];
6860 var gd__weekdays = ['Didòmhnaich', 'Diluain', 'Dimàirt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];
6862 var weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];
6864 var weekdaysMin = ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];
6866 var gd = moment__default.defineLocale('gd', {
6867 months : gd__months,
6868 monthsShort : gd__monthsShort,
6869 monthsParseExact : true,
6870 weekdays : gd__weekdays,
6871 weekdaysShort : weekdaysShort,
6872 weekdaysMin : weekdaysMin,
6873 longDateFormat : {
6874 LT : 'HH:mm',
6875 LTS : 'HH:mm:ss',
6876 L : 'DD/MM/YYYY',
6877 LL : 'D MMMM YYYY',
6878 LLL : 'D MMMM YYYY HH:mm',
6879 LLLL : 'dddd, D MMMM YYYY HH:mm'
6880 },
6881 calendar : {
6882 sameDay : '[An-diugh aig] LT',
6883 nextDay : '[A-màireach aig] LT',
6884 nextWeek : 'dddd [aig] LT',
6885 lastDay : '[An-dè aig] LT',
6886 lastWeek : 'dddd [seo chaidh] [aig] LT',
6887 sameElse : 'L'
6888 },
6889 relativeTime : {
6890 future : 'ann an %s',
6891 past : 'bho chionn %s',
6892 s : 'beagan diogan',
6893 m : 'mionaid',
6894 mm : '%d mionaidean',
6895 h : 'uair',
6896 hh : '%d uairean',
6897 d : 'latha',
6898 dd : '%d latha',
6899 M : 'mìos',
6900 MM : '%d mìosan',
6901 y : 'bliadhna',
6902 yy : '%d bliadhna'
6903 },
6904 ordinalParse : /\d{1,2}(d|na|mh)/,
6905 ordinal : function (number) {
6906 var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
6907 return number + output;
6908 },
6909 week : {
6910 dow : 1, // Monday is the first day of the week.
6911 doy : 4 // The week that contains Jan 4th is the first week of the year.
6912 }
6913 });
6915 //! moment.js locale configuration
6916 //! locale : galician (gl)
6917 //! author : Juan G. Hurtado : https://github.com/juanghurtado
6919 var gl = moment__default.defineLocale('gl', {
6920 months : 'Xaneiro_Febreiro_Marzo_Abril_Maio_Xuño_Xullo_Agosto_Setembro_Outubro_Novembro_Decembro'.split('_'),
6921 monthsShort : 'Xan._Feb._Mar._Abr._Mai._Xuñ._Xul._Ago._Set._Out._Nov._Dec.'.split('_'),
6922 monthsParseExact: true,
6923 weekdays : 'Domingo_Luns_Martes_Mércores_Xoves_Venres_Sábado'.split('_'),
6924 weekdaysShort : 'Dom._Lun._Mar._Mér._Xov._Ven._Sáb.'.split('_'),
6925 weekdaysMin : 'Do_Lu_Ma_Mé_Xo_Ve_Sá'.split('_'),
6926 weekdaysParseExact : true,
6927 longDateFormat : {
6928 LT : 'H:mm',
6929 LTS : 'H:mm:ss',
6930 L : 'DD/MM/YYYY',
6931 LL : 'D MMMM YYYY',
6932 LLL : 'D MMMM YYYY H:mm',
6933 LLLL : 'dddd D MMMM YYYY H:mm'
6934 },
6935 calendar : {
6936 sameDay : function () {
6937 return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
6938 },
6939 nextDay : function () {
6940 return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
6941 },
6942 nextWeek : function () {
6943 return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
6944 },
6945 lastDay : function () {
6946 return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
6947 },
6948 lastWeek : function () {
6949 return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
6950 },
6951 sameElse : 'L'
6952 },
6953 relativeTime : {
6954 future : function (str) {
6955 if (str === 'uns segundos') {
6956 return 'nuns segundos';
6957 }
6958 return 'en ' + str;
6959 },
6960 past : 'hai %s',
6961 s : 'uns segundos',
6962 m : 'un minuto',
6963 mm : '%d minutos',
6964 h : 'unha hora',
6965 hh : '%d horas',
6966 d : 'un día',
6967 dd : '%d días',
6968 M : 'un mes',
6969 MM : '%d meses',
6970 y : 'un ano',
6971 yy : '%d anos'
6972 },
6973 ordinalParse : /\d{1,2}º/,
6974 ordinal : '%dº',
6975 week : {
6976 dow : 1, // Monday is the first day of the week.
6977 doy : 7 // The week that contains Jan 1st is the first week of the year.
6978 }
6979 });
6981 //! moment.js locale configuration
6982 //! locale : Hebrew (he)
6983 //! author : Tomer Cohen : https://github.com/tomer
6984 //! author : Moshe Simantov : https://github.com/DevelopmentIL
6985 //! author : Tal Ater : https://github.com/TalAter
6987 var he = moment__default.defineLocale('he', {
6988 months : 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
6989 monthsShort : 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split('_'),
6990 weekdays : 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
6991 weekdaysShort : 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
6992 weekdaysMin : 'א_ב_ג_ד_ה_ו_ש'.split('_'),
6993 longDateFormat : {
6994 LT : 'HH:mm',
6995 LTS : 'HH:mm:ss',
6996 L : 'DD/MM/YYYY',
6997 LL : 'D [ב]MMMM YYYY',
6998 LLL : 'D [ב]MMMM YYYY HH:mm',
6999 LLLL : 'dddd, D [ב]MMMM YYYY HH:mm',
7000 l : 'D/M/YYYY',
7001 ll : 'D MMM YYYY',
7002 lll : 'D MMM YYYY HH:mm',
7003 llll : 'ddd, D MMM YYYY HH:mm'
7004 },
7005 calendar : {
7006 sameDay : '[היום ב־]LT',
7007 nextDay : '[מחר ב־]LT',
7008 nextWeek : 'dddd [בשעה] LT',
7009 lastDay : '[אתמול ב־]LT',
7010 lastWeek : '[ביום] dddd [האחרון בשעה] LT',
7011 sameElse : 'L'
7012 },
7013 relativeTime : {
7014 future : 'בעוד %s',
7015 past : 'לפני %s',
7016 s : 'מספר שניות',
7017 m : 'דקה',
7018 mm : '%d דקות',
7019 h : 'שעה',
7020 hh : function (number) {
7021 if (number === 2) {
7022 return 'שעתיים';
7023 }
7024 return number + ' שעות';
7025 },
7026 d : 'יום',
7027 dd : function (number) {
7028 if (number === 2) {
7029 return 'יומיים';
7030 }
7031 return number + ' ימים';
7032 },
7033 M : 'חודש',
7034 MM : function (number) {
7035 if (number === 2) {
7036 return 'חודשיים';
7037 }
7038 return number + ' חודשים';
7039 },
7040 y : 'שנה',
7041 yy : function (number) {
7042 if (number === 2) {
7043 return 'שנתיים';
7044 } else if (number % 10 === 0 && number !== 10) {
7045 return number + ' שנה';
7046 }
7047 return number + ' שנים';
7048 }
7049 },
7050 meridiemParse: /אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,
7051 isPM : function (input) {
7052 return /^(אחה"צ|אחרי הצהריים|בערב)$/.test(input);
7053 },
7054 meridiem : function (hour, minute, isLower) {
7055 if (hour < 5) {
7056 return 'לפנות בוקר';
7057 } else if (hour < 10) {
7058 return 'בבוקר';
7059 } else if (hour < 12) {
7060 return isLower ? 'לפנה"צ' : 'לפני הצהריים';
7061 } else if (hour < 18) {
7062 return isLower ? 'אחה"צ' : 'אחרי הצהריים';
7063 } else {
7064 return 'בערב';
7065 }
7066 }
7067 });
7069 //! moment.js locale configuration
7070 //! locale : hindi (hi)
7071 //! author : Mayank Singhal : https://github.com/mayanksinghal
7073 var hi__symbolMap = {
7074 '1': '१',
7075 '2': '२',
7076 '3': '३',
7077 '4': '४',
7078 '5': '५',
7079 '6': '६',
7080 '7': '७',
7081 '8': '८',
7082 '9': '९',
7083 '0': '०'
7084 },
7085 hi__numberMap = {
7086 '१': '1',
7087 '२': '2',
7088 '३': '3',
7089 '४': '4',
7090 '५': '5',
7091 '६': '6',
7092 '७': '7',
7093 '८': '8',
7094 '९': '9',
7095 '०': '0'
7096 };
7098 var hi = moment__default.defineLocale('hi', {
7099 months : 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split('_'),
7100 monthsShort : 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split('_'),
7101 monthsParseExact: true,
7102 weekdays : 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
7103 weekdaysShort : 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
7104 weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
7105 longDateFormat : {
7106 LT : 'A h:mm बजे',
7107 LTS : 'A h:mm:ss बजे',
7108 L : 'DD/MM/YYYY',
7109 LL : 'D MMMM YYYY',
7110 LLL : 'D MMMM YYYY, A h:mm बजे',
7111 LLLL : 'dddd, D MMMM YYYY, A h:mm बजे'
7112 },
7113 calendar : {
7114 sameDay : '[आज] LT',
7115 nextDay : '[कल] LT',
7116 nextWeek : 'dddd, LT',
7117 lastDay : '[कल] LT',
7118 lastWeek : '[पिछले] dddd, LT',
7119 sameElse : 'L'
7120 },
7121 relativeTime : {
7122 future : '%s में',
7123 past : '%s पहले',
7124 s : 'कुछ ही क्षण',
7125 m : 'एक मिनट',
7126 mm : '%d मिनट',
7127 h : 'एक घंटा',
7128 hh : '%d घंटे',
7129 d : 'एक दिन',
7130 dd : '%d दिन',
7131 M : 'एक महीने',
7132 MM : '%d महीने',
7133 y : 'एक वर्ष',
7134 yy : '%d वर्ष'
7135 },
7136 preparse: function (string) {
7137 return string.replace(/[१२३४५६७८९०]/g, function (match) {
7138 return hi__numberMap[match];
7139 });
7140 },
7141 postformat: function (string) {
7142 return string.replace(/\d/g, function (match) {
7143 return hi__symbolMap[match];
7144 });
7145 },
7146 // Hindi notation for meridiems are quite fuzzy in practice. While there exists
7147 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
7148 meridiemParse: /रात|सुबह|दोपहर|शाम/,
7149 meridiemHour : function (hour, meridiem) {
7150 if (hour === 12) {
7151 hour = 0;
7152 }
7153 if (meridiem === 'रात') {
7154 return hour < 4 ? hour : hour + 12;
7155 } else if (meridiem === 'सुबह') {
7156 return hour;
7157 } else if (meridiem === 'दोपहर') {
7158 return hour >= 10 ? hour : hour + 12;
7159 } else if (meridiem === 'शाम') {
7160 return hour + 12;
7161 }
7162 },
7163 meridiem : function (hour, minute, isLower) {
7164 if (hour < 4) {
7165 return 'रात';
7166 } else if (hour < 10) {
7167 return 'सुबह';
7168 } else if (hour < 17) {
7169 return 'दोपहर';
7170 } else if (hour < 20) {
7171 return 'शाम';
7172 } else {
7173 return 'रात';
7174 }
7175 },
7176 week : {
7177 dow : 0, // Sunday is the first day of the week.
7178 doy : 6 // The week that contains Jan 1st is the first week of the year.
7179 }
7180 });
7182 //! moment.js locale configuration
7183 //! locale : hrvatski (hr)
7184 //! author : Bojan Marković : https://github.com/bmarkovic
7186 function hr__translate(number, withoutSuffix, key) {
7187 var result = number + ' ';
7188 switch (key) {
7189 case 'm':
7190 return withoutSuffix ? 'jedna minuta' : 'jedne minute';
7191 case 'mm':
7192 if (number === 1) {
7193 result += 'minuta';
7194 } else if (number === 2 || number === 3 || number === 4) {
7195 result += 'minute';
7196 } else {
7197 result += 'minuta';
7198 }
7199 return result;
7200 case 'h':
7201 return withoutSuffix ? 'jedan sat' : 'jednog sata';
7202 case 'hh':
7203 if (number === 1) {
7204 result += 'sat';
7205 } else if (number === 2 || number === 3 || number === 4) {
7206 result += 'sata';
7207 } else {
7208 result += 'sati';
7209 }
7210 return result;
7211 case 'dd':
7212 if (number === 1) {
7213 result += 'dan';
7214 } else {
7215 result += 'dana';
7216 }
7217 return result;
7218 case 'MM':
7219 if (number === 1) {
7220 result += 'mjesec';
7221 } else if (number === 2 || number === 3 || number === 4) {
7222 result += 'mjeseca';
7223 } else {
7224 result += 'mjeseci';
7225 }
7226 return result;
7227 case 'yy':
7228 if (number === 1) {
7229 result += 'godina';
7230 } else if (number === 2 || number === 3 || number === 4) {
7231 result += 'godine';
7232 } else {
7233 result += 'godina';
7234 }
7235 return result;
7236 }
7237 }
7239 var hr = moment__default.defineLocale('hr', {
7240 months : {
7241 format: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
7242 standalone: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
7243 },
7244 monthsShort : 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
7245 monthsParseExact: true,
7246 weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
7247 weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
7248 weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
7249 weekdaysParseExact : true,
7250 longDateFormat : {
7251 LT : 'H:mm',
7252 LTS : 'H:mm:ss',
7253 L : 'DD. MM. YYYY',
7254 LL : 'D. MMMM YYYY',
7255 LLL : 'D. MMMM YYYY H:mm',
7256 LLLL : 'dddd, D. MMMM YYYY H:mm'
7257 },
7258 calendar : {
7259 sameDay : '[danas u] LT',
7260 nextDay : '[sutra u] LT',
7261 nextWeek : function () {
7262 switch (this.day()) {
7263 case 0:
7264 return '[u] [nedjelju] [u] LT';
7265 case 3:
7266 return '[u] [srijedu] [u] LT';
7267 case 6:
7268 return '[u] [subotu] [u] LT';
7269 case 1:
7270 case 2:
7271 case 4:
7272 case 5:
7273 return '[u] dddd [u] LT';
7274 }
7275 },
7276 lastDay : '[jučer u] LT',
7277 lastWeek : function () {
7278 switch (this.day()) {
7279 case 0:
7280 case 3:
7281 return '[prošlu] dddd [u] LT';
7282 case 6:
7283 return '[prošle] [subote] [u] LT';
7284 case 1:
7285 case 2:
7286 case 4:
7287 case 5:
7288 return '[prošli] dddd [u] LT';
7289 }
7290 },
7291 sameElse : 'L'
7292 },
7293 relativeTime : {
7294 future : 'za %s',
7295 past : 'prije %s',
7296 s : 'par sekundi',
7297 m : hr__translate,
7298 mm : hr__translate,
7299 h : hr__translate,
7300 hh : hr__translate,
7301 d : 'dan',
7302 dd : hr__translate,
7303 M : 'mjesec',
7304 MM : hr__translate,
7305 y : 'godinu',
7306 yy : hr__translate
7307 },
7308 ordinalParse: /\d{1,2}\./,
7309 ordinal : '%d.',
7310 week : {
7311 dow : 1, // Monday is the first day of the week.
7312 doy : 7 // The week that contains Jan 1st is the first week of the year.
7313 }
7314 });
7316 //! moment.js locale configuration
7317 //! locale : hungarian (hu)
7318 //! author : Adam Brunner : https://github.com/adambrunner
7320 var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');
7321 function hu__translate(number, withoutSuffix, key, isFuture) {
7322 var num = number,
7323 suffix;
7324 switch (key) {
7325 case 's':
7326 return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce';
7327 case 'm':
7328 return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
7329 case 'mm':
7330 return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
7331 case 'h':
7332 return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
7333 case 'hh':
7334 return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
7335 case 'd':
7336 return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
7337 case 'dd':
7338 return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
7339 case 'M':
7340 return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
7341 case 'MM':
7342 return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
7343 case 'y':
7344 return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
7345 case 'yy':
7346 return num + (isFuture || withoutSuffix ? ' év' : ' éve');
7347 }
7348 return '';
7349 }
7350 function week(isFuture) {
7351 return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';
7352 }
7354 var hu = moment__default.defineLocale('hu', {
7355 months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
7356 monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
7357 weekdays : 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
7358 weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
7359 weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
7360 longDateFormat : {
7361 LT : 'H:mm',
7362 LTS : 'H:mm:ss',
7363 L : 'YYYY.MM.DD.',
7364 LL : 'YYYY. MMMM D.',
7365 LLL : 'YYYY. MMMM D. H:mm',
7366 LLLL : 'YYYY. MMMM D., dddd H:mm'
7367 },
7368 meridiemParse: /de|du/i,
7369 isPM: function (input) {
7370 return input.charAt(1).toLowerCase() === 'u';
7371 },
7372 meridiem : function (hours, minutes, isLower) {
7373 if (hours < 12) {
7374 return isLower === true ? 'de' : 'DE';
7375 } else {
7376 return isLower === true ? 'du' : 'DU';
7377 }
7378 },
7379 calendar : {
7380 sameDay : '[ma] LT[-kor]',
7381 nextDay : '[holnap] LT[-kor]',
7382 nextWeek : function () {
7383 return week.call(this, true);
7384 },
7385 lastDay : '[tegnap] LT[-kor]',
7386 lastWeek : function () {
7387 return week.call(this, false);
7388 },
7389 sameElse : 'L'
7390 },
7391 relativeTime : {
7392 future : '%s múlva',
7393 past : '%s',
7394 s : hu__translate,
7395 m : hu__translate,
7396 mm : hu__translate,
7397 h : hu__translate,
7398 hh : hu__translate,
7399 d : hu__translate,
7400 dd : hu__translate,
7401 M : hu__translate,
7402 MM : hu__translate,
7403 y : hu__translate,
7404 yy : hu__translate
7405 },
7406 ordinalParse: /\d{1,2}\./,
7407 ordinal : '%d.',
7408 week : {
7409 dow : 1, // Monday is the first day of the week.
7410 doy : 7 // The week that contains Jan 1st is the first week of the year.
7411 }
7412 });
7414 //! moment.js locale configuration
7415 //! locale : Armenian (hy-am)
7416 //! author : Armendarabyan : https://github.com/armendarabyan
7418 var hy_am = moment__default.defineLocale('hy-am', {
7419 months : {
7420 format: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_'),
7421 standalone: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_')
7422 },
7423 monthsShort : 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
7424 weekdays : 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split('_'),
7425 weekdaysShort : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
7426 weekdaysMin : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
7427 longDateFormat : {
7428 LT : 'HH:mm',
7429 LTS : 'HH:mm:ss',
7430 L : 'DD.MM.YYYY',
7431 LL : 'D MMMM YYYY թ.',
7432 LLL : 'D MMMM YYYY թ., HH:mm',
7433 LLLL : 'dddd, D MMMM YYYY թ., HH:mm'
7434 },
7435 calendar : {
7436 sameDay: '[այսօր] LT',
7437 nextDay: '[վաղը] LT',
7438 lastDay: '[երեկ] LT',
7439 nextWeek: function () {
7440 return 'dddd [օրը ժամը] LT';
7441 },
7442 lastWeek: function () {
7443 return '[անցած] dddd [օրը ժամը] LT';
7444 },
7445 sameElse: 'L'
7446 },
7447 relativeTime : {
7448 future : '%s հետո',
7449 past : '%s առաջ',
7450 s : 'մի քանի վայրկյան',
7451 m : 'րոպե',
7452 mm : '%d րոպե',
7453 h : 'ժամ',
7454 hh : '%d ժամ',
7455 d : 'օր',
7456 dd : '%d օր',
7457 M : 'ամիս',
7458 MM : '%d ամիս',
7459 y : 'տարի',
7460 yy : '%d տարի'
7461 },
7462 meridiemParse: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
7463 isPM: function (input) {
7464 return /^(ցերեկվա|երեկոյան)$/.test(input);
7465 },
7466 meridiem : function (hour) {
7467 if (hour < 4) {
7468 return 'գիշերվա';
7469 } else if (hour < 12) {
7470 return 'առավոտվա';
7471 } else if (hour < 17) {
7472 return 'ցերեկվա';
7473 } else {
7474 return 'երեկոյան';
7475 }
7476 },
7477 ordinalParse: /\d{1,2}|\d{1,2}-(ին|րդ)/,
7478 ordinal: function (number, period) {
7479 switch (period) {
7480 case 'DDD':
7481 case 'w':
7482 case 'W':
7483 case 'DDDo':
7484 if (number === 1) {
7485 return number + '-ին';
7486 }
7487 return number + '-րդ';
7488 default:
7489 return number;
7490 }
7491 },
7492 week : {
7493 dow : 1, // Monday is the first day of the week.
7494 doy : 7 // The week that contains Jan 1st is the first week of the year.
7495 }
7496 });
7498 //! moment.js locale configuration
7499 //! locale : Bahasa Indonesia (id)
7500 //! author : Mohammad Satrio Utomo : https://github.com/tyok
7501 //! reference: http://id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan
7503 var id = moment__default.defineLocale('id', {
7504 months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
7505 monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des'.split('_'),
7506 weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
7507 weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
7508 weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
7509 longDateFormat : {
7510 LT : 'HH.mm',
7511 LTS : 'HH.mm.ss',
7512 L : 'DD/MM/YYYY',
7513 LL : 'D MMMM YYYY',
7514 LLL : 'D MMMM YYYY [pukul] HH.mm',
7515 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
7516 },
7517 meridiemParse: /pagi|siang|sore|malam/,
7518 meridiemHour : function (hour, meridiem) {
7519 if (hour === 12) {
7520 hour = 0;
7521 }
7522 if (meridiem === 'pagi') {
7523 return hour;
7524 } else if (meridiem === 'siang') {
7525 return hour >= 11 ? hour : hour + 12;
7526 } else if (meridiem === 'sore' || meridiem === 'malam') {
7527 return hour + 12;
7528 }
7529 },
7530 meridiem : function (hours, minutes, isLower) {
7531 if (hours < 11) {
7532 return 'pagi';
7533 } else if (hours < 15) {
7534 return 'siang';
7535 } else if (hours < 19) {
7536 return 'sore';
7537 } else {
7538 return 'malam';
7539 }
7540 },
7541 calendar : {
7542 sameDay : '[Hari ini pukul] LT',
7543 nextDay : '[Besok pukul] LT',
7544 nextWeek : 'dddd [pukul] LT',
7545 lastDay : '[Kemarin pukul] LT',
7546 lastWeek : 'dddd [lalu pukul] LT',
7547 sameElse : 'L'
7548 },
7549 relativeTime : {
7550 future : 'dalam %s',
7551 past : '%s yang lalu',
7552 s : 'beberapa detik',
7553 m : 'semenit',
7554 mm : '%d menit',
7555 h : 'sejam',
7556 hh : '%d jam',
7557 d : 'sehari',
7558 dd : '%d hari',
7559 M : 'sebulan',
7560 MM : '%d bulan',
7561 y : 'setahun',
7562 yy : '%d tahun'
7563 },
7564 week : {
7565 dow : 1, // Monday is the first day of the week.
7566 doy : 7 // The week that contains Jan 1st is the first week of the year.
7567 }
7568 });
7570 //! moment.js locale configuration
7571 //! locale : icelandic (is)
7572 //! author : Hinrik Örn Sigurðsson : https://github.com/hinrik
7574 function is__plural(n) {
7575 if (n % 100 === 11) {
7576 return true;
7577 } else if (n % 10 === 1) {
7578 return false;
7579 }
7580 return true;
7581 }
7582 function is__translate(number, withoutSuffix, key, isFuture) {
7583 var result = number + ' ';
7584 switch (key) {
7585 case 's':
7586 return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
7587 case 'm':
7588 return withoutSuffix ? 'mínúta' : 'mínútu';
7589 case 'mm':
7590 if (is__plural(number)) {
7591 return result + (withoutSuffix || isFuture ? 'mínútur' : 'mínútum');
7592 } else if (withoutSuffix) {
7593 return result + 'mínúta';
7594 }
7595 return result + 'mínútu';
7596 case 'hh':
7597 if (is__plural(number)) {
7598 return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
7599 }
7600 return result + 'klukkustund';
7601 case 'd':
7602 if (withoutSuffix) {
7603 return 'dagur';
7604 }
7605 return isFuture ? 'dag' : 'degi';
7606 case 'dd':
7607 if (is__plural(number)) {
7608 if (withoutSuffix) {
7609 return result + 'dagar';
7610 }
7611 return result + (isFuture ? 'daga' : 'dögum');
7612 } else if (withoutSuffix) {
7613 return result + 'dagur';
7614 }
7615 return result + (isFuture ? 'dag' : 'degi');
7616 case 'M':
7617 if (withoutSuffix) {
7618 return 'mánuður';
7619 }
7620 return isFuture ? 'mánuð' : 'mánuði';
7621 case 'MM':
7622 if (is__plural(number)) {
7623 if (withoutSuffix) {
7624 return result + 'mánuðir';
7625 }
7626 return result + (isFuture ? 'mánuði' : 'mánuðum');
7627 } else if (withoutSuffix) {
7628 return result + 'mánuður';
7629 }
7630 return result + (isFuture ? 'mánuð' : 'mánuði');
7631 case 'y':
7632 return withoutSuffix || isFuture ? 'ár' : 'ári';
7633 case 'yy':
7634 if (is__plural(number)) {
7635 return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
7636 }
7637 return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
7638 }
7639 }
7641 var is = moment__default.defineLocale('is', {
7642 months : 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split('_'),
7643 monthsShort : 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
7644 weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
7645 weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
7646 weekdaysMin : 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
7647 longDateFormat : {
7648 LT : 'H:mm',
7649 LTS : 'H:mm:ss',
7650 L : 'DD.MM.YYYY',
7651 LL : 'D. MMMM YYYY',
7652 LLL : 'D. MMMM YYYY [kl.] H:mm',
7653 LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm'
7654 },
7655 calendar : {
7656 sameDay : '[í dag kl.] LT',
7657 nextDay : '[á morgun kl.] LT',
7658 nextWeek : 'dddd [kl.] LT',
7659 lastDay : '[í gær kl.] LT',
7660 lastWeek : '[síðasta] dddd [kl.] LT',
7661 sameElse : 'L'
7662 },
7663 relativeTime : {
7664 future : 'eftir %s',
7665 past : 'fyrir %s síðan',
7666 s : is__translate,
7667 m : is__translate,
7668 mm : is__translate,
7669 h : 'klukkustund',
7670 hh : is__translate,
7671 d : is__translate,
7672 dd : is__translate,
7673 M : is__translate,
7674 MM : is__translate,
7675 y : is__translate,
7676 yy : is__translate
7677 },
7678 ordinalParse: /\d{1,2}\./,
7679 ordinal : '%d.',
7680 week : {
7681 dow : 1, // Monday is the first day of the week.
7682 doy : 4 // The week that contains Jan 4th is the first week of the year.
7683 }
7684 });
7686 //! moment.js locale configuration
7687 //! locale : italian (it)
7688 //! author : Lorenzo : https://github.com/aliem
7689 //! author: Mattia Larentis: https://github.com/nostalgiaz
7691 var it = moment__default.defineLocale('it', {
7692 months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
7693 monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
7694 weekdays : 'Domenica_Lunedì_Martedì_Mercoledì_Giovedì_Venerdì_Sabato'.split('_'),
7695 weekdaysShort : 'Dom_Lun_Mar_Mer_Gio_Ven_Sab'.split('_'),
7696 weekdaysMin : 'Do_Lu_Ma_Me_Gi_Ve_Sa'.split('_'),
7697 longDateFormat : {
7698 LT : 'HH:mm',
7699 LTS : 'HH:mm:ss',
7700 L : 'DD/MM/YYYY',
7701 LL : 'D MMMM YYYY',
7702 LLL : 'D MMMM YYYY HH:mm',
7703 LLLL : 'dddd, D MMMM YYYY HH:mm'
7704 },
7705 calendar : {
7706 sameDay: '[Oggi alle] LT',
7707 nextDay: '[Domani alle] LT',
7708 nextWeek: 'dddd [alle] LT',
7709 lastDay: '[Ieri alle] LT',
7710 lastWeek: function () {
7711 switch (this.day()) {
7712 case 0:
7713 return '[la scorsa] dddd [alle] LT';
7714 default:
7715 return '[lo scorso] dddd [alle] LT';
7716 }
7717 },
7718 sameElse: 'L'
7719 },
7720 relativeTime : {
7721 future : function (s) {
7722 return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
7723 },
7724 past : '%s fa',
7725 s : 'alcuni secondi',
7726 m : 'un minuto',
7727 mm : '%d minuti',
7728 h : 'un\'ora',
7729 hh : '%d ore',
7730 d : 'un giorno',
7731 dd : '%d giorni',
7732 M : 'un mese',
7733 MM : '%d mesi',
7734 y : 'un anno',
7735 yy : '%d anni'
7736 },
7737 ordinalParse : /\d{1,2}º/,
7738 ordinal: '%dº',
7739 week : {
7740 dow : 1, // Monday is the first day of the week.
7741 doy : 4 // The week that contains Jan 4th is the first week of the year.
7742 }
7743 });
7745 //! moment.js locale configuration
7746 //! locale : japanese (ja)
7747 //! author : LI Long : https://github.com/baryon
7749 var ja = moment__default.defineLocale('ja', {
7750 months : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
7751 monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
7752 weekdays : '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
7753 weekdaysShort : '日_月_火_水_木_金_土'.split('_'),
7754 weekdaysMin : '日_月_火_水_木_金_土'.split('_'),
7755 longDateFormat : {
7756 LT : 'Ah時m分',
7757 LTS : 'Ah時m分s秒',
7758 L : 'YYYY/MM/DD',
7759 LL : 'YYYY年M月D日',
7760 LLL : 'YYYY年M月D日Ah時m分',
7761 LLLL : 'YYYY年M月D日Ah時m分 dddd'
7762 },
7763 meridiemParse: /午前|午後/i,
7764 isPM : function (input) {
7765 return input === '午後';
7766 },
7767 meridiem : function (hour, minute, isLower) {
7768 if (hour < 12) {
7769 return '午前';
7770 } else {
7771 return '午後';
7772 }
7773 },
7774 calendar : {
7775 sameDay : '[今日] LT',
7776 nextDay : '[明日] LT',
7777 nextWeek : '[来週]dddd LT',
7778 lastDay : '[昨日] LT',
7779 lastWeek : '[前週]dddd LT',
7780 sameElse : 'L'
7781 },
7782 ordinalParse : /\d{1,2}日/,
7783 ordinal : function (number, period) {
7784 switch (period) {
7785 case 'd':
7786 case 'D':
7787 case 'DDD':
7788 return number + '日';
7789 default:
7790 return number;
7791 }
7792 },
7793 relativeTime : {
7794 future : '%s後',
7795 past : '%s前',
7796 s : '数秒',
7797 m : '1分',
7798 mm : '%d分',
7799 h : '1時間',
7800 hh : '%d時間',
7801 d : '1日',
7802 dd : '%d日',
7803 M : '1ヶ月',
7804 MM : '%dヶ月',
7805 y : '1年',
7806 yy : '%d年'
7807 }
7808 });
7810 //! moment.js locale configuration
7811 //! locale : Boso Jowo (jv)
7812 //! author : Rony Lantip : https://github.com/lantip
7813 //! reference: http://jv.wikipedia.org/wiki/Basa_Jawa
7815 var jv = moment__default.defineLocale('jv', {
7816 months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
7817 monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
7818 weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
7819 weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
7820 weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
7821 longDateFormat : {
7822 LT : 'HH.mm',
7823 LTS : 'HH.mm.ss',
7824 L : 'DD/MM/YYYY',
7825 LL : 'D MMMM YYYY',
7826 LLL : 'D MMMM YYYY [pukul] HH.mm',
7827 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
7828 },
7829 meridiemParse: /enjing|siyang|sonten|ndalu/,
7830 meridiemHour : function (hour, meridiem) {
7831 if (hour === 12) {
7832 hour = 0;
7833 }
7834 if (meridiem === 'enjing') {
7835 return hour;
7836 } else if (meridiem === 'siyang') {
7837 return hour >= 11 ? hour : hour + 12;
7838 } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
7839 return hour + 12;
7840 }
7841 },
7842 meridiem : function (hours, minutes, isLower) {
7843 if (hours < 11) {
7844 return 'enjing';
7845 } else if (hours < 15) {
7846 return 'siyang';
7847 } else if (hours < 19) {
7848 return 'sonten';
7849 } else {
7850 return 'ndalu';
7851 }
7852 },
7853 calendar : {
7854 sameDay : '[Dinten puniko pukul] LT',
7855 nextDay : '[Mbenjang pukul] LT',
7856 nextWeek : 'dddd [pukul] LT',
7857 lastDay : '[Kala wingi pukul] LT',
7858 lastWeek : 'dddd [kepengker pukul] LT',
7859 sameElse : 'L'
7860 },
7861 relativeTime : {
7862 future : 'wonten ing %s',
7863 past : '%s ingkang kepengker',
7864 s : 'sawetawis detik',
7865 m : 'setunggal menit',
7866 mm : '%d menit',
7867 h : 'setunggal jam',
7868 hh : '%d jam',
7869 d : 'sedinten',
7870 dd : '%d dinten',
7871 M : 'sewulan',
7872 MM : '%d wulan',
7873 y : 'setaun',
7874 yy : '%d taun'
7875 },
7876 week : {
7877 dow : 1, // Monday is the first day of the week.
7878 doy : 7 // The week that contains Jan 1st is the first week of the year.
7879 }
7880 });
7882 //! moment.js locale configuration
7883 //! locale : Georgian (ka)
7884 //! author : Irakli Janiashvili : https://github.com/irakli-janiashvili
7886 var ka = moment__default.defineLocale('ka', {
7887 months : {
7888 standalone: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
7889 format: 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
7890 },
7891 monthsShort : 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
7892 weekdays : {
7893 standalone: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
7894 format: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_'),
7895 isFormat: /(წინა|შემდეგ)/
7896 },
7897 weekdaysShort : 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
7898 weekdaysMin : 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
7899 longDateFormat : {
7900 LT : 'h:mm A',
7901 LTS : 'h:mm:ss A',
7902 L : 'DD/MM/YYYY',
7903 LL : 'D MMMM YYYY',
7904 LLL : 'D MMMM YYYY h:mm A',
7905 LLLL : 'dddd, D MMMM YYYY h:mm A'
7906 },
7907 calendar : {
7908 sameDay : '[დღეს] LT[-ზე]',
7909 nextDay : '[ხვალ] LT[-ზე]',
7910 lastDay : '[გუშინ] LT[-ზე]',
7911 nextWeek : '[შემდეგ] dddd LT[-ზე]',
7912 lastWeek : '[წინა] dddd LT-ზე',
7913 sameElse : 'L'
7914 },
7915 relativeTime : {
7916 future : function (s) {
7917 return (/(წამი|წუთი|საათი|წელი)/).test(s) ?
7918 s.replace(/ი$/, 'ში') :
7919 s + 'ში';
7920 },
7921 past : function (s) {
7922 if ((/(წამი|წუთი|საათი|დღე|თვე)/).test(s)) {
7923 return s.replace(/(ი|ე)$/, 'ის წინ');
7924 }
7925 if ((/წელი/).test(s)) {
7926 return s.replace(/წელი$/, 'წლის წინ');
7927 }
7928 },
7929 s : 'რამდენიმე წამი',
7930 m : 'წუთი',
7931 mm : '%d წუთი',
7932 h : 'საათი',
7933 hh : '%d საათი',
7934 d : 'დღე',
7935 dd : '%d დღე',
7936 M : 'თვე',
7937 MM : '%d თვე',
7938 y : 'წელი',
7939 yy : '%d წელი'
7940 },
7941 ordinalParse: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
7942 ordinal : function (number) {
7943 if (number === 0) {
7944 return number;
7945 }
7946 if (number === 1) {
7947 return number + '-ლი';
7948 }
7949 if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
7950 return 'მე-' + number;
7951 }
7952 return number + '-ე';
7953 },
7954 week : {
7955 dow : 1,
7956 doy : 7
7957 }
7958 });
7960 //! moment.js locale configuration
7961 //! locale : kazakh (kk)
7962 //! authors : Nurlan Rakhimzhanov : https://github.com/nurlan
7964 var kk__suffixes = {
7965 0: '-ші',
7966 1: '-ші',
7967 2: '-ші',
7968 3: '-ші',
7969 4: '-ші',
7970 5: '-ші',
7971 6: '-шы',
7972 7: '-ші',
7973 8: '-ші',
7974 9: '-шы',
7975 10: '-шы',
7976 20: '-шы',
7977 30: '-шы',
7978 40: '-шы',
7979 50: '-ші',
7980 60: '-шы',
7981 70: '-ші',
7982 80: '-ші',
7983 90: '-шы',
7984 100: '-ші'
7985 };
7987 var kk = moment__default.defineLocale('kk', {
7988 months : 'қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан'.split('_'),
7989 monthsShort : 'қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
7990 weekdays : 'жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі'.split('_'),
7991 weekdaysShort : 'жек_дүй_сей_сәр_бей_жұм_сен'.split('_'),
7992 weekdaysMin : 'жк_дй_сй_ср_бй_жм_сн'.split('_'),
7993 longDateFormat : {
7994 LT : 'HH:mm',
7995 LTS : 'HH:mm:ss',
7996 L : 'DD.MM.YYYY',
7997 LL : 'D MMMM YYYY',
7998 LLL : 'D MMMM YYYY HH:mm',
7999 LLLL : 'dddd, D MMMM YYYY HH:mm'
8000 },
8001 calendar : {
8002 sameDay : '[Бүгін сағат] LT',
8003 nextDay : '[Ертең сағат] LT',
8004 nextWeek : 'dddd [сағат] LT',
8005 lastDay : '[Кеше сағат] LT',
8006 lastWeek : '[Өткен аптаның] dddd [сағат] LT',
8007 sameElse : 'L'
8008 },
8009 relativeTime : {
8010 future : '%s ішінде',
8011 past : '%s бұрын',
8012 s : 'бірнеше секунд',
8013 m : 'бір минут',
8014 mm : '%d минут',
8015 h : 'бір сағат',
8016 hh : '%d сағат',
8017 d : 'бір күн',
8018 dd : '%d күн',
8019 M : 'бір ай',
8020 MM : '%d ай',
8021 y : 'бір жыл',
8022 yy : '%d жыл'
8023 },
8024 ordinalParse: /\d{1,2}-(ші|шы)/,
8025 ordinal : function (number) {
8026 var a = number % 10,
8027 b = number >= 100 ? 100 : null;
8028 return number + (kk__suffixes[number] || kk__suffixes[a] || kk__suffixes[b]);
8029 },
8030 week : {
8031 dow : 1, // Monday is the first day of the week.
8032 doy : 7 // The week that contains Jan 1st is the first week of the year.
8033 }
8034 });
8036 //! moment.js locale configuration
8037 //! locale : khmer (km)
8038 //! author : Kruy Vanna : https://github.com/kruyvanna
8040 var km = moment__default.defineLocale('km', {
8041 months: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
8042 monthsShort: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
8043 weekdays: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
8044 weekdaysShort: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
8045 weekdaysMin: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
8046 longDateFormat: {
8047 LT: 'HH:mm',
8048 LTS : 'HH:mm:ss',
8049 L: 'DD/MM/YYYY',
8050 LL: 'D MMMM YYYY',
8051 LLL: 'D MMMM YYYY HH:mm',
8052 LLLL: 'dddd, D MMMM YYYY HH:mm'
8053 },
8054 calendar: {
8055 sameDay: '[ថ្ងៃនេះ ម៉ោង] LT',
8056 nextDay: '[ស្អែក ម៉ោង] LT',
8057 nextWeek: 'dddd [ម៉ោង] LT',
8058 lastDay: '[ម្សិលមិញ ម៉ោង] LT',
8059 lastWeek: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
8060 sameElse: 'L'
8061 },
8062 relativeTime: {
8063 future: '%sទៀត',
8064 past: '%sមុន',
8065 s: 'ប៉ុន្មានវិនាទី',
8066 m: 'មួយនាទី',
8067 mm: '%d នាទី',
8068 h: 'មួយម៉ោង',
8069 hh: '%d ម៉ោង',
8070 d: 'មួយថ្ងៃ',
8071 dd: '%d ថ្ងៃ',
8072 M: 'មួយខែ',
8073 MM: '%d ខែ',
8074 y: 'មួយឆ្នាំ',
8075 yy: '%d ឆ្នាំ'
8076 },
8077 week: {
8078 dow: 1, // Monday is the first day of the week.
8079 doy: 4 // The week that contains Jan 4th is the first week of the year.
8080 }
8081 });
8083 //! moment.js locale configuration
8084 //! locale : korean (ko)
8085 //!
8086 //! authors
8087 //!
8088 //! - Kyungwook, Park : https://github.com/kyungw00k
8089 //! - Jeeeyul Lee <jeeeyul@gmail.com>
8091 var ko = moment__default.defineLocale('ko', {
8092 months : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
8093 monthsShort : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
8094 weekdays : '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
8095 weekdaysShort : '일_월_화_수_목_금_토'.split('_'),
8096 weekdaysMin : '일_월_화_수_목_금_토'.split('_'),
8097 longDateFormat : {
8098 LT : 'A h시 m분',
8099 LTS : 'A h시 m분 s초',
8100 L : 'YYYY.MM.DD',
8101 LL : 'YYYY년 MMMM D일',
8102 LLL : 'YYYY년 MMMM D일 A h시 m분',
8103 LLLL : 'YYYY년 MMMM D일 dddd A h시 m분'
8104 },
8105 calendar : {
8106 sameDay : '오늘 LT',
8107 nextDay : '내일 LT',
8108 nextWeek : 'dddd LT',
8109 lastDay : '어제 LT',
8110 lastWeek : '지난주 dddd LT',
8111 sameElse : 'L'
8112 },
8113 relativeTime : {
8114 future : '%s 후',
8115 past : '%s 전',
8116 s : '몇 초',
8117 ss : '%d초',
8118 m : '일분',
8119 mm : '%d분',
8120 h : '한 시간',
8121 hh : '%d시간',
8122 d : '하루',
8123 dd : '%d일',
8124 M : '한 달',
8125 MM : '%d달',
8126 y : '일 년',
8127 yy : '%d년'
8128 },
8129 ordinalParse : /\d{1,2}일/,
8130 ordinal : '%d일',
8131 meridiemParse : /오전|오후/,
8132 isPM : function (token) {
8133 return token === '오후';
8134 },
8135 meridiem : function (hour, minute, isUpper) {
8136 return hour < 12 ? '오전' : '오후';
8137 }
8138 });
8140 //! moment.js locale configuration
8141 //! locale : kyrgyz (ky)
8142 //! author : Chyngyz Arystan uulu : https://github.com/chyngyz
8145 var ky__suffixes = {
8146 0: '-чү',
8147 1: '-чи',
8148 2: '-чи',
8149 3: '-чү',
8150 4: '-чү',
8151 5: '-чи',
8152 6: '-чы',
8153 7: '-чи',
8154 8: '-чи',
8155 9: '-чу',
8156 10: '-чу',
8157 20: '-чы',
8158 30: '-чу',
8159 40: '-чы',
8160 50: '-чү',
8161 60: '-чы',
8162 70: '-чи',
8163 80: '-чи',
8164 90: '-чу',
8165 100: '-чү'
8166 };
8168 var ky = moment__default.defineLocale('ky', {
8169 months : 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
8170 monthsShort : 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
8171 weekdays : 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split('_'),
8172 weekdaysShort : 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
8173 weekdaysMin : 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
8174 longDateFormat : {
8175 LT : 'HH:mm',
8176 LTS : 'HH:mm:ss',
8177 L : 'DD.MM.YYYY',
8178 LL : 'D MMMM YYYY',
8179 LLL : 'D MMMM YYYY HH:mm',
8180 LLLL : 'dddd, D MMMM YYYY HH:mm'
8181 },
8182 calendar : {
8183 sameDay : '[Бүгүн саат] LT',
8184 nextDay : '[Эртең саат] LT',
8185 nextWeek : 'dddd [саат] LT',
8186 lastDay : '[Кече саат] LT',
8187 lastWeek : '[Өткен аптанын] dddd [күнү] [саат] LT',
8188 sameElse : 'L'
8189 },
8190 relativeTime : {
8191 future : '%s ичинде',
8192 past : '%s мурун',
8193 s : 'бирнече секунд',
8194 m : 'бир мүнөт',
8195 mm : '%d мүнөт',
8196 h : 'бир саат',
8197 hh : '%d саат',
8198 d : 'бир күн',
8199 dd : '%d күн',
8200 M : 'бир ай',
8201 MM : '%d ай',
8202 y : 'бир жыл',
8203 yy : '%d жыл'
8204 },
8205 ordinalParse: /\d{1,2}-(чи|чы|чү|чу)/,
8206 ordinal : function (number) {
8207 var a = number % 10,
8208 b = number >= 100 ? 100 : null;
8209 return number + (ky__suffixes[number] || ky__suffixes[a] || ky__suffixes[b]);
8210 },
8211 week : {
8212 dow : 1, // Monday is the first day of the week.
8213 doy : 7 // The week that contains Jan 1st is the first week of the year.
8214 }
8215 });
8217 //! moment.js locale configuration
8218 //! locale : Luxembourgish (lb)
8219 //! author : mweimerskirch : https://github.com/mweimerskirch, David Raison : https://github.com/kwisatz
8221 function lb__processRelativeTime(number, withoutSuffix, key, isFuture) {
8222 var format = {
8223 'm': ['eng Minutt', 'enger Minutt'],
8224 'h': ['eng Stonn', 'enger Stonn'],
8225 'd': ['een Dag', 'engem Dag'],
8226 'M': ['ee Mount', 'engem Mount'],
8227 'y': ['ee Joer', 'engem Joer']
8228 };
8229 return withoutSuffix ? format[key][0] : format[key][1];
8230 }
8231 function processFutureTime(string) {
8232 var number = string.substr(0, string.indexOf(' '));
8233 if (eifelerRegelAppliesToNumber(number)) {
8234 return 'a ' + string;
8235 }
8236 return 'an ' + string;
8237 }
8238 function processPastTime(string) {
8239 var number = string.substr(0, string.indexOf(' '));
8240 if (eifelerRegelAppliesToNumber(number)) {
8241 return 'viru ' + string;
8242 }
8243 return 'virun ' + string;
8244 }
8245 /**
8246 * Returns true if the word before the given number loses the '-n' ending.
8247 * e.g. 'an 10 Deeg' but 'a 5 Deeg'
8248 *
8249 * @param number {integer}
8250 * @returns {boolean}
8251 */
8252 function eifelerRegelAppliesToNumber(number) {
8253 number = parseInt(number, 10);
8254 if (isNaN(number)) {
8255 return false;
8256 }
8257 if (number < 0) {
8258 // Negative Number --> always true
8259 return true;
8260 } else if (number < 10) {
8261 // Only 1 digit
8262 if (4 <= number && number <= 7) {
8263 return true;
8264 }
8265 return false;
8266 } else if (number < 100) {
8267 // 2 digits
8268 var lastDigit = number % 10, firstDigit = number / 10;
8269 if (lastDigit === 0) {
8270 return eifelerRegelAppliesToNumber(firstDigit);
8271 }
8272 return eifelerRegelAppliesToNumber(lastDigit);
8273 } else if (number < 10000) {
8274 // 3 or 4 digits --> recursively check first digit
8275 while (number >= 10) {
8276 number = number / 10;
8277 }
8278 return eifelerRegelAppliesToNumber(number);
8279 } else {
8280 // Anything larger than 4 digits: recursively check first n-3 digits
8281 number = number / 1000;
8282 return eifelerRegelAppliesToNumber(number);
8283 }
8284 }
8286 var lb = moment__default.defineLocale('lb', {
8287 months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
8288 monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
8289 monthsParseExact : true,
8290 weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
8291 weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
8292 weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
8293 weekdaysParseExact : true,
8294 longDateFormat: {
8295 LT: 'H:mm [Auer]',
8296 LTS: 'H:mm:ss [Auer]',
8297 L: 'DD.MM.YYYY',
8298 LL: 'D. MMMM YYYY',
8299 LLL: 'D. MMMM YYYY H:mm [Auer]',
8300 LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]'
8301 },
8302 calendar: {
8303 sameDay: '[Haut um] LT',
8304 sameElse: 'L',
8305 nextDay: '[Muer um] LT',
8306 nextWeek: 'dddd [um] LT',
8307 lastDay: '[Gëschter um] LT',
8308 lastWeek: function () {
8309 // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
8310 switch (this.day()) {
8311 case 2:
8312 case 4:
8313 return '[Leschten] dddd [um] LT';
8314 default:
8315 return '[Leschte] dddd [um] LT';
8316 }
8317 }
8318 },
8319 relativeTime : {
8320 future : processFutureTime,
8321 past : processPastTime,
8322 s : 'e puer Sekonnen',
8323 m : lb__processRelativeTime,
8324 mm : '%d Minutten',
8325 h : lb__processRelativeTime,
8326 hh : '%d Stonnen',
8327 d : lb__processRelativeTime,
8328 dd : '%d Deeg',
8329 M : lb__processRelativeTime,
8330 MM : '%d Méint',
8331 y : lb__processRelativeTime,
8332 yy : '%d Joer'
8333 },
8334 ordinalParse: /\d{1,2}\./,
8335 ordinal: '%d.',
8336 week: {
8337 dow: 1, // Monday is the first day of the week.
8338 doy: 4 // The week that contains Jan 4th is the first week of the year.
8339 }
8340 });
8342 //! moment.js locale configuration
8343 //! locale : lao (lo)
8344 //! author : Ryan Hart : https://github.com/ryanhart2
8346 var lo = moment__default.defineLocale('lo', {
8347 months : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
8348 monthsShort : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
8349 weekdays : 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
8350 weekdaysShort : 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
8351 weekdaysMin : 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
8352 weekdaysParseExact : true,
8353 longDateFormat : {
8354 LT : 'HH:mm',
8355 LTS : 'HH:mm:ss',
8356 L : 'DD/MM/YYYY',
8357 LL : 'D MMMM YYYY',
8358 LLL : 'D MMMM YYYY HH:mm',
8359 LLLL : 'ວັນdddd D MMMM YYYY HH:mm'
8360 },
8361 meridiemParse: /ຕອນເຊົ້າ|ຕອນແລງ/,
8362 isPM: function (input) {
8363 return input === 'ຕອນແລງ';
8364 },
8365 meridiem : function (hour, minute, isLower) {
8366 if (hour < 12) {
8367 return 'ຕອນເຊົ້າ';
8368 } else {
8369 return 'ຕອນແລງ';
8370 }
8371 },
8372 calendar : {
8373 sameDay : '[ມື້ນີ້ເວລາ] LT',
8374 nextDay : '[ມື້ອື່ນເວລາ] LT',
8375 nextWeek : '[ວັນ]dddd[ໜ້າເວລາ] LT',
8376 lastDay : '[ມື້ວານນີ້ເວລາ] LT',
8377 lastWeek : '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
8378 sameElse : 'L'
8379 },
8380 relativeTime : {
8381 future : 'ອີກ %s',
8382 past : '%sຜ່ານມາ',
8383 s : 'ບໍ່ເທົ່າໃດວິນາທີ',
8384 m : '1 ນາທີ',
8385 mm : '%d ນາທີ',
8386 h : '1 ຊົ່ວໂມງ',
8387 hh : '%d ຊົ່ວໂມງ',
8388 d : '1 ມື້',
8389 dd : '%d ມື້',
8390 M : '1 ເດືອນ',
8391 MM : '%d ເດືອນ',
8392 y : '1 ປີ',
8393 yy : '%d ປີ'
8394 },
8395 ordinalParse: /(ທີ່)\d{1,2}/,
8396 ordinal : function (number) {
8397 return 'ທີ່' + number;
8398 }
8399 });
8401 //! moment.js locale configuration
8402 //! locale : Lithuanian (lt)
8403 //! author : Mindaugas Mozūras : https://github.com/mmozuras
8405 var lt__units = {
8406 'm' : 'minutė_minutės_minutę',
8407 'mm': 'minutės_minučių_minutes',
8408 'h' : 'valanda_valandos_valandą',
8409 'hh': 'valandos_valandų_valandas',
8410 'd' : 'diena_dienos_dieną',
8411 'dd': 'dienos_dienų_dienas',
8412 'M' : 'mėnuo_mėnesio_mėnesį',
8413 'MM': 'mėnesiai_mėnesių_mėnesius',
8414 'y' : 'metai_metų_metus',
8415 'yy': 'metai_metų_metus'
8416 };
8417 function translateSeconds(number, withoutSuffix, key, isFuture) {
8418 if (withoutSuffix) {
8419 return 'kelios sekundės';
8420 } else {
8421 return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
8422 }
8423 }
8424 function translateSingular(number, withoutSuffix, key, isFuture) {
8425 return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);
8426 }
8427 function special(number) {
8428 return number % 10 === 0 || (number > 10 && number < 20);
8429 }
8430 function forms(key) {
8431 return lt__units[key].split('_');
8432 }
8433 function lt__translate(number, withoutSuffix, key, isFuture) {
8434 var result = number + ' ';
8435 if (number === 1) {
8436 return result + translateSingular(number, withoutSuffix, key[0], isFuture);
8437 } else if (withoutSuffix) {
8438 return result + (special(number) ? forms(key)[1] : forms(key)[0]);
8439 } else {
8440 if (isFuture) {
8441 return result + forms(key)[1];
8442 } else {
8443 return result + (special(number) ? forms(key)[1] : forms(key)[2]);
8444 }
8445 }
8446 }
8447 var lt = moment__default.defineLocale('lt', {
8448 months : {
8449 format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
8450 standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_')
8451 },
8452 monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
8453 weekdays : {
8454 format: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split('_'),
8455 standalone: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split('_'),
8456 isFormat: /dddd HH:mm/
8457 },
8458 weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
8459 weekdaysMin : 'S_P_A_T_K_Pn_Š'.split('_'),
8460 weekdaysParseExact : true,
8461 longDateFormat : {
8462 LT : 'HH:mm',
8463 LTS : 'HH:mm:ss',
8464 L : 'YYYY-MM-DD',
8465 LL : 'YYYY [m.] MMMM D [d.]',
8466 LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
8467 LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
8468 l : 'YYYY-MM-DD',
8469 ll : 'YYYY [m.] MMMM D [d.]',
8470 lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
8471 llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
8472 },
8473 calendar : {
8474 sameDay : '[Šiandien] LT',
8475 nextDay : '[Rytoj] LT',
8476 nextWeek : 'dddd LT',
8477 lastDay : '[Vakar] LT',
8478 lastWeek : '[Praėjusį] dddd LT',
8479 sameElse : 'L'
8480 },
8481 relativeTime : {
8482 future : 'po %s',
8483 past : 'prieš %s',
8484 s : translateSeconds,
8485 m : translateSingular,
8486 mm : lt__translate,
8487 h : translateSingular,
8488 hh : lt__translate,
8489 d : translateSingular,
8490 dd : lt__translate,
8491 M : translateSingular,
8492 MM : lt__translate,
8493 y : translateSingular,
8494 yy : lt__translate
8495 },
8496 ordinalParse: /\d{1,2}-oji/,
8497 ordinal : function (number) {
8498 return number + '-oji';
8499 },
8500 week : {
8501 dow : 1, // Monday is the first day of the week.
8502 doy : 4 // The week that contains Jan 4th is the first week of the year.
8503 }
8504 });
8506 //! moment.js locale configuration
8507 //! locale : latvian (lv)
8508 //! author : Kristaps Karlsons : https://github.com/skakri
8509 //! author : Jānis Elmeris : https://github.com/JanisE
8511 var lv__units = {
8512 'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
8513 'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
8514 'h': 'stundas_stundām_stunda_stundas'.split('_'),
8515 'hh': 'stundas_stundām_stunda_stundas'.split('_'),
8516 'd': 'dienas_dienām_diena_dienas'.split('_'),
8517 'dd': 'dienas_dienām_diena_dienas'.split('_'),
8518 'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
8519 'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
8520 'y': 'gada_gadiem_gads_gadi'.split('_'),
8521 'yy': 'gada_gadiem_gads_gadi'.split('_')
8522 };
8523 /**
8524 * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
8525 */
8526 function lv__format(forms, number, withoutSuffix) {
8527 if (withoutSuffix) {
8528 // E.g. "21 minūte", "3 minūtes".
8529 return number % 10 === 1 && number !== 11 ? forms[2] : forms[3];
8530 } else {
8531 // E.g. "21 minūtes" as in "pēc 21 minūtes".
8532 // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
8533 return number % 10 === 1 && number !== 11 ? forms[0] : forms[1];
8534 }
8535 }
8536 function lv__relativeTimeWithPlural(number, withoutSuffix, key) {
8537 return number + ' ' + lv__format(lv__units[key], number, withoutSuffix);
8538 }
8539 function relativeTimeWithSingular(number, withoutSuffix, key) {
8540 return lv__format(lv__units[key], number, withoutSuffix);
8541 }
8542 function relativeSeconds(number, withoutSuffix) {
8543 return withoutSuffix ? 'dažas sekundes' : 'dažām sekundēm';
8544 }
8546 var lv = moment__default.defineLocale('lv', {
8547 months : 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
8548 monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
8549 weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
8550 weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
8551 weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
8552 weekdaysParseExact : true,
8553 longDateFormat : {
8554 LT : 'HH:mm',
8555 LTS : 'HH:mm:ss',
8556 L : 'DD.MM.YYYY.',
8557 LL : 'YYYY. [gada] D. MMMM',
8558 LLL : 'YYYY. [gada] D. MMMM, HH:mm',
8559 LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
8560 },
8561 calendar : {
8562 sameDay : '[Šodien pulksten] LT',
8563 nextDay : '[Rīt pulksten] LT',
8564 nextWeek : 'dddd [pulksten] LT',
8565 lastDay : '[Vakar pulksten] LT',
8566 lastWeek : '[Pagājušā] dddd [pulksten] LT',
8567 sameElse : 'L'
8568 },
8569 relativeTime : {
8570 future : 'pēc %s',
8571 past : 'pirms %s',
8572 s : relativeSeconds,
8573 m : relativeTimeWithSingular,
8574 mm : lv__relativeTimeWithPlural,
8575 h : relativeTimeWithSingular,
8576 hh : lv__relativeTimeWithPlural,
8577 d : relativeTimeWithSingular,
8578 dd : lv__relativeTimeWithPlural,
8579 M : relativeTimeWithSingular,
8580 MM : lv__relativeTimeWithPlural,
8581 y : relativeTimeWithSingular,
8582 yy : lv__relativeTimeWithPlural
8583 },
8584 ordinalParse: /\d{1,2}\./,
8585 ordinal : '%d.',
8586 week : {
8587 dow : 1, // Monday is the first day of the week.
8588 doy : 4 // The week that contains Jan 4th is the first week of the year.
8589 }
8590 });
8592 //! moment.js locale configuration
8593 //! locale : Montenegrin (me)
8594 //! author : Miodrag Nikač <miodrag@restartit.me> : https://github.com/miodragnikac
8596 var me__translator = {
8597 words: { //Different grammatical cases
8598 m: ['jedan minut', 'jednog minuta'],
8599 mm: ['minut', 'minuta', 'minuta'],
8600 h: ['jedan sat', 'jednog sata'],
8601 hh: ['sat', 'sata', 'sati'],
8602 dd: ['dan', 'dana', 'dana'],
8603 MM: ['mjesec', 'mjeseca', 'mjeseci'],
8604 yy: ['godina', 'godine', 'godina']
8605 },
8606 correctGrammaticalCase: function (number, wordKey) {
8607 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
8608 },
8609 translate: function (number, withoutSuffix, key) {
8610 var wordKey = me__translator.words[key];
8611 if (key.length === 1) {
8612 return withoutSuffix ? wordKey[0] : wordKey[1];
8613 } else {
8614 return number + ' ' + me__translator.correctGrammaticalCase(number, wordKey);
8615 }
8616 }
8617 };
8619 var me = moment__default.defineLocale('me', {
8620 months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
8621 monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
8622 monthsParseExact : true,
8623 weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
8624 weekdaysShort: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
8625 weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
8626 weekdaysParseExact : true,
8627 longDateFormat: {
8628 LT: 'H:mm',
8629 LTS : 'H:mm:ss',
8630 L: 'DD. MM. YYYY',
8631 LL: 'D. MMMM YYYY',
8632 LLL: 'D. MMMM YYYY H:mm',
8633 LLLL: 'dddd, D. MMMM YYYY H:mm'
8634 },
8635 calendar: {
8636 sameDay: '[danas u] LT',
8637 nextDay: '[sjutra u] LT',
8639 nextWeek: function () {
8640 switch (this.day()) {
8641 case 0:
8642 return '[u] [nedjelju] [u] LT';
8643 case 3:
8644 return '[u] [srijedu] [u] LT';
8645 case 6:
8646 return '[u] [subotu] [u] LT';
8647 case 1:
8648 case 2:
8649 case 4:
8650 case 5:
8651 return '[u] dddd [u] LT';
8652 }
8653 },
8654 lastDay : '[juče u] LT',
8655 lastWeek : function () {
8656 var lastWeekDays = [
8657 '[prošle] [nedjelje] [u] LT',
8658 '[prošlog] [ponedjeljka] [u] LT',
8659 '[prošlog] [utorka] [u] LT',
8660 '[prošle] [srijede] [u] LT',
8661 '[prošlog] [četvrtka] [u] LT',
8662 '[prošlog] [petka] [u] LT',
8663 '[prošle] [subote] [u] LT'
8664 ];
8665 return lastWeekDays[this.day()];
8666 },
8667 sameElse : 'L'
8668 },
8669 relativeTime : {
8670 future : 'za %s',
8671 past : 'prije %s',
8672 s : 'nekoliko sekundi',
8673 m : me__translator.translate,
8674 mm : me__translator.translate,
8675 h : me__translator.translate,
8676 hh : me__translator.translate,
8677 d : 'dan',
8678 dd : me__translator.translate,
8679 M : 'mjesec',
8680 MM : me__translator.translate,
8681 y : 'godinu',
8682 yy : me__translator.translate
8683 },
8684 ordinalParse: /\d{1,2}\./,
8685 ordinal : '%d.',
8686 week : {
8687 dow : 1, // Monday is the first day of the week.
8688 doy : 7 // The week that contains Jan 1st is the first week of the year.
8689 }
8690 });
8692 //! moment.js locale configuration
8693 //! locale : macedonian (mk)
8694 //! author : Borislav Mickov : https://github.com/B0k0
8696 var mk = moment__default.defineLocale('mk', {
8697 months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
8698 monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
8699 weekdays : 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
8700 weekdaysShort : 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
8701 weekdaysMin : 'нe_пo_вт_ср_че_пе_сa'.split('_'),
8702 longDateFormat : {
8703 LT : 'H:mm',
8704 LTS : 'H:mm:ss',
8705 L : 'D.MM.YYYY',
8706 LL : 'D MMMM YYYY',
8707 LLL : 'D MMMM YYYY H:mm',
8708 LLLL : 'dddd, D MMMM YYYY H:mm'
8709 },
8710 calendar : {
8711 sameDay : '[Денес во] LT',
8712 nextDay : '[Утре во] LT',
8713 nextWeek : '[Во] dddd [во] LT',
8714 lastDay : '[Вчера во] LT',
8715 lastWeek : function () {
8716 switch (this.day()) {
8717 case 0:
8718 case 3:
8719 case 6:
8720 return '[Изминатата] dddd [во] LT';
8721 case 1:
8722 case 2:
8723 case 4:
8724 case 5:
8725 return '[Изминатиот] dddd [во] LT';
8726 }
8727 },
8728 sameElse : 'L'
8729 },
8730 relativeTime : {
8731 future : 'после %s',
8732 past : 'пред %s',
8733 s : 'неколку секунди',
8734 m : 'минута',
8735 mm : '%d минути',
8736 h : 'час',
8737 hh : '%d часа',
8738 d : 'ден',
8739 dd : '%d дена',
8740 M : 'месец',
8741 MM : '%d месеци',
8742 y : 'година',
8743 yy : '%d години'
8744 },
8745 ordinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
8746 ordinal : function (number) {
8747 var lastDigit = number % 10,
8748 last2Digits = number % 100;
8749 if (number === 0) {
8750 return number + '-ев';
8751 } else if (last2Digits === 0) {
8752 return number + '-ен';
8753 } else if (last2Digits > 10 && last2Digits < 20) {
8754 return number + '-ти';
8755 } else if (lastDigit === 1) {
8756 return number + '-ви';
8757 } else if (lastDigit === 2) {
8758 return number + '-ри';
8759 } else if (lastDigit === 7 || lastDigit === 8) {
8760 return number + '-ми';
8761 } else {
8762 return number + '-ти';
8763 }
8764 },
8765 week : {
8766 dow : 1, // Monday is the first day of the week.
8767 doy : 7 // The week that contains Jan 1st is the first week of the year.
8768 }
8769 });
8771 //! moment.js locale configuration
8772 //! locale : malayalam (ml)
8773 //! author : Floyd Pink : https://github.com/floydpink
8775 var ml = moment__default.defineLocale('ml', {
8776 months : 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
8777 monthsShort : 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split('_'),
8778 monthsParseExact : true,
8779 weekdays : 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split('_'),
8780 weekdaysShort : 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
8781 weekdaysMin : 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
8782 longDateFormat : {
8783 LT : 'A h:mm -നു',
8784 LTS : 'A h:mm:ss -നു',
8785 L : 'DD/MM/YYYY',
8786 LL : 'D MMMM YYYY',
8787 LLL : 'D MMMM YYYY, A h:mm -നു',
8788 LLLL : 'dddd, D MMMM YYYY, A h:mm -നു'
8789 },
8790 calendar : {
8791 sameDay : '[ഇന്ന്] LT',
8792 nextDay : '[നാളെ] LT',
8793 nextWeek : 'dddd, LT',
8794 lastDay : '[ഇന്നലെ] LT',
8795 lastWeek : '[കഴിഞ്ഞ] dddd, LT',
8796 sameElse : 'L'
8797 },
8798 relativeTime : {
8799 future : '%s കഴിഞ്ഞ്',
8800 past : '%s മുൻപ്',
8801 s : 'അൽപ നിമിഷങ്ങൾ',
8802 m : 'ഒരു മിനിറ്റ്',
8803 mm : '%d മിനിറ്റ്',
8804 h : 'ഒരു മണിക്കൂർ',
8805 hh : '%d മണിക്കൂർ',
8806 d : 'ഒരു ദിവസം',
8807 dd : '%d ദിവസം',
8808 M : 'ഒരു മാസം',
8809 MM : '%d മാസം',
8810 y : 'ഒരു വർഷം',
8811 yy : '%d വർഷം'
8812 },
8813 meridiemParse: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
8814 meridiemHour : function (hour, meridiem) {
8815 if (hour === 12) {
8816 hour = 0;
8817 }
8818 if ((meridiem === 'രാത്രി' && hour >= 4) ||
8819 meridiem === 'ഉച്ച കഴിഞ്ഞ്' ||
8820 meridiem === 'വൈകുന്നേരം') {
8821 return hour + 12;
8822 } else {
8823 return hour;
8824 }
8825 },
8826 meridiem : function (hour, minute, isLower) {
8827 if (hour < 4) {
8828 return 'രാത്രി';
8829 } else if (hour < 12) {
8830 return 'രാവിലെ';
8831 } else if (hour < 17) {
8832 return 'ഉച്ച കഴിഞ്ഞ്';
8833 } else if (hour < 20) {
8834 return 'വൈകുന്നേരം';
8835 } else {
8836 return 'രാത്രി';
8837 }
8838 }
8839 });
8841 //! moment.js locale configuration
8842 //! locale : Marathi (mr)
8843 //! author : Harshad Kale : https://github.com/kalehv
8844 //! author : Vivek Athalye : https://github.com/vnathalye
8846 var mr__symbolMap = {
8847 '1': '१',
8848 '2': '२',
8849 '3': '३',
8850 '4': '४',
8851 '5': '५',
8852 '6': '६',
8853 '7': '७',
8854 '8': '८',
8855 '9': '९',
8856 '0': '०'
8857 },
8858 mr__numberMap = {
8859 '१': '1',
8860 '२': '2',
8861 '३': '3',
8862 '४': '4',
8863 '५': '5',
8864 '६': '6',
8865 '७': '7',
8866 '८': '8',
8867 '९': '9',
8868 '०': '0'
8869 };
8871 function relativeTimeMr(number, withoutSuffix, string, isFuture)
8872 {
8873 var output = '';
8874 if (withoutSuffix) {
8875 switch (string) {
8876 case 's': output = 'काही सेकंद'; break;
8877 case 'm': output = 'एक मिनिट'; break;
8878 case 'mm': output = '%d मिनिटे'; break;
8879 case 'h': output = 'एक तास'; break;
8880 case 'hh': output = '%d तास'; break;
8881 case 'd': output = 'एक दिवस'; break;
8882 case 'dd': output = '%d दिवस'; break;
8883 case 'M': output = 'एक महिना'; break;
8884 case 'MM': output = '%d महिने'; break;
8885 case 'y': output = 'एक वर्ष'; break;
8886 case 'yy': output = '%d वर्षे'; break;
8887 }
8888 }
8889 else {
8890 switch (string) {
8891 case 's': output = 'काही सेकंदां'; break;
8892 case 'm': output = 'एका मिनिटा'; break;
8893 case 'mm': output = '%d मिनिटां'; break;
8894 case 'h': output = 'एका तासा'; break;
8895 case 'hh': output = '%d तासां'; break;
8896 case 'd': output = 'एका दिवसा'; break;
8897 case 'dd': output = '%d दिवसां'; break;
8898 case 'M': output = 'एका महिन्या'; break;
8899 case 'MM': output = '%d महिन्यां'; break;
8900 case 'y': output = 'एका वर्षा'; break;
8901 case 'yy': output = '%d वर्षां'; break;
8902 }
8903 }
8904 return output.replace(/%d/i, number);
8905 }
8907 var mr = moment__default.defineLocale('mr', {
8908 months : 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split('_'),
8909 monthsShort: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split('_'),
8910 monthsParseExact : true,
8911 weekdays : 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
8912 weekdaysShort : 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
8913 weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
8914 longDateFormat : {
8915 LT : 'A h:mm वाजता',
8916 LTS : 'A h:mm:ss वाजता',
8917 L : 'DD/MM/YYYY',
8918 LL : 'D MMMM YYYY',
8919 LLL : 'D MMMM YYYY, A h:mm वाजता',
8920 LLLL : 'dddd, D MMMM YYYY, A h:mm वाजता'
8921 },
8922 calendar : {
8923 sameDay : '[आज] LT',
8924 nextDay : '[उद्या] LT',
8925 nextWeek : 'dddd, LT',
8926 lastDay : '[काल] LT',
8927 lastWeek: '[मागील] dddd, LT',
8928 sameElse : 'L'
8929 },
8930 relativeTime : {
8931 future: '%sमध्ये',
8932 past: '%sपूर्वी',
8933 s: relativeTimeMr,
8934 m: relativeTimeMr,
8935 mm: relativeTimeMr,
8936 h: relativeTimeMr,
8937 hh: relativeTimeMr,
8938 d: relativeTimeMr,
8939 dd: relativeTimeMr,
8940 M: relativeTimeMr,
8941 MM: relativeTimeMr,
8942 y: relativeTimeMr,
8943 yy: relativeTimeMr
8944 },
8945 preparse: function (string) {
8946 return string.replace(/[१२३४५६७८९०]/g, function (match) {
8947 return mr__numberMap[match];
8948 });
8949 },
8950 postformat: function (string) {
8951 return string.replace(/\d/g, function (match) {
8952 return mr__symbolMap[match];
8953 });
8954 },
8955 meridiemParse: /रात्री|सकाळी|दुपारी|सायंकाळी/,
8956 meridiemHour : function (hour, meridiem) {
8957 if (hour === 12) {
8958 hour = 0;
8959 }
8960 if (meridiem === 'रात्री') {
8961 return hour < 4 ? hour : hour + 12;
8962 } else if (meridiem === 'सकाळी') {
8963 return hour;
8964 } else if (meridiem === 'दुपारी') {
8965 return hour >= 10 ? hour : hour + 12;
8966 } else if (meridiem === 'सायंकाळी') {
8967 return hour + 12;
8968 }
8969 },
8970 meridiem: function (hour, minute, isLower) {
8971 if (hour < 4) {
8972 return 'रात्री';
8973 } else if (hour < 10) {
8974 return 'सकाळी';
8975 } else if (hour < 17) {
8976 return 'दुपारी';
8977 } else if (hour < 20) {
8978 return 'सायंकाळी';
8979 } else {
8980 return 'रात्री';
8981 }
8982 },
8983 week : {
8984 dow : 0, // Sunday is the first day of the week.
8985 doy : 6 // The week that contains Jan 1st is the first week of the year.
8986 }
8987 });
8989 //! moment.js locale configuration
8990 //! locale : Bahasa Malaysia (ms-MY)
8991 //! author : Weldan Jamili : https://github.com/weldan
8993 var ms_my = moment__default.defineLocale('ms-my', {
8994 months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
8995 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
8996 weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
8997 weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
8998 weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
8999 longDateFormat : {
9000 LT : 'HH.mm',
9001 LTS : 'HH.mm.ss',
9002 L : 'DD/MM/YYYY',
9003 LL : 'D MMMM YYYY',
9004 LLL : 'D MMMM YYYY [pukul] HH.mm',
9005 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
9006 },
9007 meridiemParse: /pagi|tengahari|petang|malam/,
9008 meridiemHour: function (hour, meridiem) {
9009 if (hour === 12) {
9010 hour = 0;
9011 }
9012 if (meridiem === 'pagi') {
9013 return hour;
9014 } else if (meridiem === 'tengahari') {
9015 return hour >= 11 ? hour : hour + 12;
9016 } else if (meridiem === 'petang' || meridiem === 'malam') {
9017 return hour + 12;
9018 }
9019 },
9020 meridiem : function (hours, minutes, isLower) {
9021 if (hours < 11) {
9022 return 'pagi';
9023 } else if (hours < 15) {
9024 return 'tengahari';
9025 } else if (hours < 19) {
9026 return 'petang';
9027 } else {
9028 return 'malam';
9029 }
9030 },
9031 calendar : {
9032 sameDay : '[Hari ini pukul] LT',
9033 nextDay : '[Esok pukul] LT',
9034 nextWeek : 'dddd [pukul] LT',
9035 lastDay : '[Kelmarin pukul] LT',
9036 lastWeek : 'dddd [lepas pukul] LT',
9037 sameElse : 'L'
9038 },
9039 relativeTime : {
9040 future : 'dalam %s',
9041 past : '%s yang lepas',
9042 s : 'beberapa saat',
9043 m : 'seminit',
9044 mm : '%d minit',
9045 h : 'sejam',
9046 hh : '%d jam',
9047 d : 'sehari',
9048 dd : '%d hari',
9049 M : 'sebulan',
9050 MM : '%d bulan',
9051 y : 'setahun',
9052 yy : '%d tahun'
9053 },
9054 week : {
9055 dow : 1, // Monday is the first day of the week.
9056 doy : 7 // The week that contains Jan 1st is the first week of the year.
9057 }
9058 });
9060 //! moment.js locale configuration
9061 //! locale : Bahasa Malaysia (ms-MY)
9062 //! author : Weldan Jamili : https://github.com/weldan
9064 var locale_ms = moment__default.defineLocale('ms', {
9065 months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
9066 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
9067 weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
9068 weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
9069 weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
9070 longDateFormat : {
9071 LT : 'HH.mm',
9072 LTS : 'HH.mm.ss',
9073 L : 'DD/MM/YYYY',
9074 LL : 'D MMMM YYYY',
9075 LLL : 'D MMMM YYYY [pukul] HH.mm',
9076 LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
9077 },
9078 meridiemParse: /pagi|tengahari|petang|malam/,
9079 meridiemHour: function (hour, meridiem) {
9080 if (hour === 12) {
9081 hour = 0;
9082 }
9083 if (meridiem === 'pagi') {
9084 return hour;
9085 } else if (meridiem === 'tengahari') {
9086 return hour >= 11 ? hour : hour + 12;
9087 } else if (meridiem === 'petang' || meridiem === 'malam') {
9088 return hour + 12;
9089 }
9090 },
9091 meridiem : function (hours, minutes, isLower) {
9092 if (hours < 11) {
9093 return 'pagi';
9094 } else if (hours < 15) {
9095 return 'tengahari';
9096 } else if (hours < 19) {
9097 return 'petang';
9098 } else {
9099 return 'malam';
9100 }
9101 },
9102 calendar : {
9103 sameDay : '[Hari ini pukul] LT',
9104 nextDay : '[Esok pukul] LT',
9105 nextWeek : 'dddd [pukul] LT',
9106 lastDay : '[Kelmarin pukul] LT',
9107 lastWeek : 'dddd [lepas pukul] LT',
9108 sameElse : 'L'
9109 },
9110 relativeTime : {
9111 future : 'dalam %s',
9112 past : '%s yang lepas',
9113 s : 'beberapa saat',
9114 m : 'seminit',
9115 mm : '%d minit',
9116 h : 'sejam',
9117 hh : '%d jam',
9118 d : 'sehari',
9119 dd : '%d hari',
9120 M : 'sebulan',
9121 MM : '%d bulan',
9122 y : 'setahun',
9123 yy : '%d tahun'
9124 },
9125 week : {
9126 dow : 1, // Monday is the first day of the week.
9127 doy : 7 // The week that contains Jan 1st is the first week of the year.
9128 }
9129 });
9131 //! moment.js locale configuration
9132 //! locale : Burmese (my)
9133 //! author : Squar team, mysquar.com
9135 var my__symbolMap = {
9136 '1': '၁',
9137 '2': '၂',
9138 '3': '၃',
9139 '4': '၄',
9140 '5': '၅',
9141 '6': '၆',
9142 '7': '၇',
9143 '8': '၈',
9144 '9': '၉',
9145 '0': '၀'
9146 }, my__numberMap = {
9147 '၁': '1',
9148 '၂': '2',
9149 '၃': '3',
9150 '၄': '4',
9151 '၅': '5',
9152 '၆': '6',
9153 '၇': '7',
9154 '၈': '8',
9155 '၉': '9',
9156 '၀': '0'
9157 };
9159 var my = moment__default.defineLocale('my', {
9160 months: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split('_'),
9161 monthsShort: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
9162 weekdays: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split('_'),
9163 weekdaysShort: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
9164 weekdaysMin: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
9166 longDateFormat: {
9167 LT: 'HH:mm',
9168 LTS: 'HH:mm:ss',
9169 L: 'DD/MM/YYYY',
9170 LL: 'D MMMM YYYY',
9171 LLL: 'D MMMM YYYY HH:mm',
9172 LLLL: 'dddd D MMMM YYYY HH:mm'
9173 },
9174 calendar: {
9175 sameDay: '[ယနေ.] LT [မှာ]',
9176 nextDay: '[မနက်ဖြန်] LT [မှာ]',
9177 nextWeek: 'dddd LT [မှာ]',
9178 lastDay: '[မနေ.က] LT [မှာ]',
9179 lastWeek: '[ပြီးခဲ့သော] dddd LT [မှာ]',
9180 sameElse: 'L'
9181 },
9182 relativeTime: {
9183 future: 'လာမည့် %s မှာ',
9184 past: 'လွန်ခဲ့သော %s က',
9185 s: 'စက္ကန်.အနည်းငယ်',
9186 m: 'တစ်မိနစ်',
9187 mm: '%d မိနစ်',
9188 h: 'တစ်နာရီ',
9189 hh: '%d နာရီ',
9190 d: 'တစ်ရက်',
9191 dd: '%d ရက်',
9192 M: 'တစ်လ',
9193 MM: '%d လ',
9194 y: 'တစ်နှစ်',
9195 yy: '%d နှစ်'
9196 },
9197 preparse: function (string) {
9198 return string.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match) {
9199 return my__numberMap[match];
9200 });
9201 },
9202 postformat: function (string) {
9203 return string.replace(/\d/g, function (match) {
9204 return my__symbolMap[match];
9205 });
9206 },
9207 week: {
9208 dow: 1, // Monday is the first day of the week.
9209 doy: 4 // The week that contains Jan 1st is the first week of the year.
9210 }
9211 });
9213 //! moment.js locale configuration
9214 //! locale : norwegian bokmål (nb)
9215 //! authors : Espen Hovlandsdal : https://github.com/rexxars
9216 //! Sigurd Gartmann : https://github.com/sigurdga
9218 var nb = moment__default.defineLocale('nb', {
9219 months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
9220 monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
9221 monthsParseExact : true,
9222 weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
9223 weekdaysShort : 'sø._ma._ti._on._to._fr._lø.'.split('_'),
9224 weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
9225 weekdaysParseExact : true,
9226 longDateFormat : {
9227 LT : 'HH:mm',
9228 LTS : 'HH:mm:ss',
9229 L : 'DD.MM.YYYY',
9230 LL : 'D. MMMM YYYY',
9231 LLL : 'D. MMMM YYYY [kl.] HH:mm',
9232 LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
9233 },
9234 calendar : {
9235 sameDay: '[i dag kl.] LT',
9236 nextDay: '[i morgen kl.] LT',
9237 nextWeek: 'dddd [kl.] LT',
9238 lastDay: '[i går kl.] LT',
9239 lastWeek: '[forrige] dddd [kl.] LT',
9240 sameElse: 'L'
9241 },
9242 relativeTime : {
9243 future : 'om %s',
9244 past : '%s siden',
9245 s : 'noen sekunder',
9246 m : 'ett minutt',
9247 mm : '%d minutter',
9248 h : 'en time',
9249 hh : '%d timer',
9250 d : 'en dag',
9251 dd : '%d dager',
9252 M : 'en måned',
9253 MM : '%d måneder',
9254 y : 'ett år',
9255 yy : '%d år'
9256 },
9257 ordinalParse: /\d{1,2}\./,
9258 ordinal : '%d.',
9259 week : {
9260 dow : 1, // Monday is the first day of the week.
9261 doy : 4 // The week that contains Jan 4th is the first week of the year.
9262 }
9263 });
9265 //! moment.js locale configuration
9266 //! locale : nepali/nepalese
9267 //! author : suvash : https://github.com/suvash
9269 var ne__symbolMap = {
9270 '1': '१',
9271 '2': '२',
9272 '3': '३',
9273 '4': '४',
9274 '5': '५',
9275 '6': '६',
9276 '7': '७',
9277 '8': '८',
9278 '9': '९',
9279 '0': '०'
9280 },
9281 ne__numberMap = {
9282 '१': '1',
9283 '२': '2',
9284 '३': '3',
9285 '४': '4',
9286 '५': '5',
9287 '६': '6',
9288 '७': '7',
9289 '८': '8',
9290 '९': '9',
9291 '०': '0'
9292 };
9294 var ne = moment__default.defineLocale('ne', {
9295 months : 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split('_'),
9296 monthsShort : 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split('_'),
9297 monthsParseExact : true,
9298 weekdays : 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split('_'),
9299 weekdaysShort : 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
9300 weekdaysMin : 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
9301 weekdaysParseExact : true,
9302 longDateFormat : {
9303 LT : 'Aको h:mm बजे',
9304 LTS : 'Aको h:mm:ss बजे',
9305 L : 'DD/MM/YYYY',
9306 LL : 'D MMMM YYYY',
9307 LLL : 'D MMMM YYYY, Aको h:mm बजे',
9308 LLLL : 'dddd, D MMMM YYYY, Aको h:mm बजे'
9309 },
9310 preparse: function (string) {
9311 return string.replace(/[१२३४५६७८९०]/g, function (match) {
9312 return ne__numberMap[match];
9313 });
9314 },
9315 postformat: function (string) {
9316 return string.replace(/\d/g, function (match) {
9317 return ne__symbolMap[match];
9318 });
9319 },
9320 meridiemParse: /राति|बिहान|दिउँसो|साँझ/,
9321 meridiemHour : function (hour, meridiem) {
9322 if (hour === 12) {
9323 hour = 0;
9324 }
9325 if (meridiem === 'राति') {
9326 return hour < 4 ? hour : hour + 12;
9327 } else if (meridiem === 'बिहान') {
9328 return hour;
9329 } else if (meridiem === 'दिउँसो') {
9330 return hour >= 10 ? hour : hour + 12;
9331 } else if (meridiem === 'साँझ') {
9332 return hour + 12;
9333 }
9334 },
9335 meridiem : function (hour, minute, isLower) {
9336 if (hour < 3) {
9337 return 'राति';
9338 } else if (hour < 12) {
9339 return 'बिहान';
9340 } else if (hour < 16) {
9341 return 'दिउँसो';
9342 } else if (hour < 20) {
9343 return 'साँझ';
9344 } else {
9345 return 'राति';
9346 }
9347 },
9348 calendar : {
9349 sameDay : '[आज] LT',
9350 nextDay : '[भोलि] LT',
9351 nextWeek : '[आउँदो] dddd[,] LT',
9352 lastDay : '[हिजो] LT',
9353 lastWeek : '[गएको] dddd[,] LT',
9354 sameElse : 'L'
9355 },
9356 relativeTime : {
9357 future : '%sमा',
9358 past : '%s अगाडि',
9359 s : 'केही क्षण',
9360 m : 'एक मिनेट',
9361 mm : '%d मिनेट',
9362 h : 'एक घण्टा',
9363 hh : '%d घण्टा',
9364 d : 'एक दिन',
9365 dd : '%d दिन',
9366 M : 'एक महिना',
9367 MM : '%d महिना',
9368 y : 'एक बर्ष',
9369 yy : '%d बर्ष'
9370 },
9371 week : {
9372 dow : 0, // Sunday is the first day of the week.
9373 doy : 6 // The week that contains Jan 1st is the first week of the year.
9374 }
9375 });
9377 //! moment.js locale configuration
9378 //! locale : dutch (nl)
9379 //! author : Joris Röling : https://github.com/jjupiter
9381 var nl__monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
9382 nl__monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
9384 var nl = moment__default.defineLocale('nl', {
9385 months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
9386 monthsShort : function (m, format) {
9387 if (/-MMM-/.test(format)) {
9388 return nl__monthsShortWithoutDots[m.month()];
9389 } else {
9390 return nl__monthsShortWithDots[m.month()];
9391 }
9392 },
9393 monthsParseExact : true,
9394 weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
9395 weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
9396 weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
9397 weekdaysParseExact : true,
9398 longDateFormat : {
9399 LT : 'HH:mm',
9400 LTS : 'HH:mm:ss',
9401 L : 'DD-MM-YYYY',
9402 LL : 'D MMMM YYYY',
9403 LLL : 'D MMMM YYYY HH:mm',
9404 LLLL : 'dddd D MMMM YYYY HH:mm'
9405 },
9406 calendar : {
9407 sameDay: '[vandaag om] LT',
9408 nextDay: '[morgen om] LT',
9409 nextWeek: 'dddd [om] LT',
9410 lastDay: '[gisteren om] LT',
9411 lastWeek: '[afgelopen] dddd [om] LT',
9412 sameElse: 'L'
9413 },
9414 relativeTime : {
9415 future : 'over %s',
9416 past : '%s geleden',
9417 s : 'een paar seconden',
9418 m : 'één minuut',
9419 mm : '%d minuten',
9420 h : 'één uur',
9421 hh : '%d uur',
9422 d : 'één dag',
9423 dd : '%d dagen',
9424 M : 'één maand',
9425 MM : '%d maanden',
9426 y : 'één jaar',
9427 yy : '%d jaar'
9428 },
9429 ordinalParse: /\d{1,2}(ste|de)/,
9430 ordinal : function (number) {
9431 return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
9432 },
9433 week : {
9434 dow : 1, // Monday is the first day of the week.
9435 doy : 4 // The week that contains Jan 4th is the first week of the year.
9436 }
9437 });
9439 //! moment.js locale configuration
9440 //! locale : norwegian nynorsk (nn)
9441 //! author : https://github.com/mechuwind
9443 var nn = moment__default.defineLocale('nn', {
9444 months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
9445 monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
9446 weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
9447 weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
9448 weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),
9449 longDateFormat : {
9450 LT : 'HH:mm',
9451 LTS : 'HH:mm:ss',
9452 L : 'DD.MM.YYYY',
9453 LL : 'D. MMMM YYYY',
9454 LLL : 'D. MMMM YYYY [kl.] H:mm',
9455 LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
9456 },
9457 calendar : {
9458 sameDay: '[I dag klokka] LT',
9459 nextDay: '[I morgon klokka] LT',
9460 nextWeek: 'dddd [klokka] LT',
9461 lastDay: '[I går klokka] LT',
9462 lastWeek: '[Føregåande] dddd [klokka] LT',
9463 sameElse: 'L'
9464 },
9465 relativeTime : {
9466 future : 'om %s',
9467 past : '%s sidan',
9468 s : 'nokre sekund',
9469 m : 'eit minutt',
9470 mm : '%d minutt',
9471 h : 'ein time',
9472 hh : '%d timar',
9473 d : 'ein dag',
9474 dd : '%d dagar',
9475 M : 'ein månad',
9476 MM : '%d månader',
9477 y : 'eit år',
9478 yy : '%d år'
9479 },
9480 ordinalParse: /\d{1,2}\./,
9481 ordinal : '%d.',
9482 week : {
9483 dow : 1, // Monday is the first day of the week.
9484 doy : 4 // The week that contains Jan 4th is the first week of the year.
9485 }
9486 });
9488 //! moment.js locale configuration
9489 //! locale : punjabi india (pa-in)
9490 //! author : Harpreet Singh : https://github.com/harpreetkhalsagtbit
9492 var pa_in__symbolMap = {
9493 '1': '੧',
9494 '2': '੨',
9495 '3': '੩',
9496 '4': '੪',
9497 '5': '੫',
9498 '6': '੬',
9499 '7': '੭',
9500 '8': '੮',
9501 '9': '੯',
9502 '0': '੦'
9503 },
9504 pa_in__numberMap = {
9505 '੧': '1',
9506 '੨': '2',
9507 '੩': '3',
9508 '੪': '4',
9509 '੫': '5',
9510 '੬': '6',
9511 '੭': '7',
9512 '੮': '8',
9513 '੯': '9',
9514 '੦': '0'
9515 };
9517 var pa_in = moment__default.defineLocale('pa-in', {
9518 // There are months name as per Nanakshahi Calender but they are not used as rigidly in modern Punjabi.
9519 months : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
9520 monthsShort : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
9521 weekdays : 'ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ'.split('_'),
9522 weekdaysShort : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
9523 weekdaysMin : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
9524 longDateFormat : {
9525 LT : 'A h:mm ਵਜੇ',
9526 LTS : 'A h:mm:ss ਵਜੇ',
9527 L : 'DD/MM/YYYY',
9528 LL : 'D MMMM YYYY',
9529 LLL : 'D MMMM YYYY, A h:mm ਵਜੇ',
9530 LLLL : 'dddd, D MMMM YYYY, A h:mm ਵਜੇ'
9531 },
9532 calendar : {
9533 sameDay : '[ਅਜ] LT',
9534 nextDay : '[ਕਲ] LT',
9535 nextWeek : 'dddd, LT',
9536 lastDay : '[ਕਲ] LT',
9537 lastWeek : '[ਪਿਛਲੇ] dddd, LT',
9538 sameElse : 'L'
9539 },
9540 relativeTime : {
9541 future : '%s ਵਿੱਚ',
9542 past : '%s ਪਿਛਲੇ',
9543 s : 'ਕੁਝ ਸਕਿੰਟ',
9544 m : 'ਇਕ ਮਿੰਟ',
9545 mm : '%d ਮਿੰਟ',
9546 h : 'ਇੱਕ ਘੰਟਾ',
9547 hh : '%d ਘੰਟੇ',
9548 d : 'ਇੱਕ ਦਿਨ',
9549 dd : '%d ਦਿਨ',
9550 M : 'ਇੱਕ ਮਹੀਨਾ',
9551 MM : '%d ਮਹੀਨੇ',
9552 y : 'ਇੱਕ ਸਾਲ',
9553 yy : '%d ਸਾਲ'
9554 },
9555 preparse: function (string) {
9556 return string.replace(/[੧੨੩੪੫੬੭੮੯੦]/g, function (match) {
9557 return pa_in__numberMap[match];
9558 });
9559 },
9560 postformat: function (string) {
9561 return string.replace(/\d/g, function (match) {
9562 return pa_in__symbolMap[match];
9563 });
9564 },
9565 // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
9566 // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
9567 meridiemParse: /ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,
9568 meridiemHour : function (hour, meridiem) {
9569 if (hour === 12) {
9570 hour = 0;
9571 }
9572 if (meridiem === 'ਰਾਤ') {
9573 return hour < 4 ? hour : hour + 12;
9574 } else if (meridiem === 'ਸਵੇਰ') {
9575 return hour;
9576 } else if (meridiem === 'ਦੁਪਹਿਰ') {
9577 return hour >= 10 ? hour : hour + 12;
9578 } else if (meridiem === 'ਸ਼ਾਮ') {
9579 return hour + 12;
9580 }
9581 },
9582 meridiem : function (hour, minute, isLower) {
9583 if (hour < 4) {
9584 return 'ਰਾਤ';
9585 } else if (hour < 10) {
9586 return 'ਸਵੇਰ';
9587 } else if (hour < 17) {
9588 return 'ਦੁਪਹਿਰ';
9589 } else if (hour < 20) {
9590 return 'ਸ਼ਾਮ';
9591 } else {
9592 return 'ਰਾਤ';
9593 }
9594 },
9595 week : {
9596 dow : 0, // Sunday is the first day of the week.
9597 doy : 6 // The week that contains Jan 1st is the first week of the year.
9598 }
9599 });
9601 //! moment.js locale configuration
9602 //! locale : polish (pl)
9603 //! author : Rafal Hirsz : https://github.com/evoL
9605 var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'),
9606 monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');
9607 function pl__plural(n) {
9608 return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);
9609 }
9610 function pl__translate(number, withoutSuffix, key) {
9611 var result = number + ' ';
9612 switch (key) {
9613 case 'm':
9614 return withoutSuffix ? 'minuta' : 'minutę';
9615 case 'mm':
9616 return result + (pl__plural(number) ? 'minuty' : 'minut');
9617 case 'h':
9618 return withoutSuffix ? 'godzina' : 'godzinę';
9619 case 'hh':
9620 return result + (pl__plural(number) ? 'godziny' : 'godzin');
9621 case 'MM':
9622 return result + (pl__plural(number) ? 'miesiące' : 'miesięcy');
9623 case 'yy':
9624 return result + (pl__plural(number) ? 'lata' : 'lat');
9625 }
9626 }
9628 var pl = moment__default.defineLocale('pl', {
9629 months : function (momentToFormat, format) {
9630 if (format === '') {
9631 // Hack: if format empty we know this is used to generate
9632 // RegExp by moment. Give then back both valid forms of months
9633 // in RegExp ready format.
9634 return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')';
9635 } else if (/D MMMM/.test(format)) {
9636 return monthsSubjective[momentToFormat.month()];
9637 } else {
9638 return monthsNominative[momentToFormat.month()];
9639 }
9640 },
9641 monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
9642 weekdays : 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
9643 weekdaysShort : 'nie_pon_wt_śr_czw_pt_sb'.split('_'),
9644 weekdaysMin : 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
9645 longDateFormat : {
9646 LT : 'HH:mm',
9647 LTS : 'HH:mm:ss',
9648 L : 'DD.MM.YYYY',
9649 LL : 'D MMMM YYYY',
9650 LLL : 'D MMMM YYYY HH:mm',
9651 LLLL : 'dddd, D MMMM YYYY HH:mm'
9652 },
9653 calendar : {
9654 sameDay: '[Dziś o] LT',
9655 nextDay: '[Jutro o] LT',
9656 nextWeek: '[W] dddd [o] LT',
9657 lastDay: '[Wczoraj o] LT',
9658 lastWeek: function () {
9659 switch (this.day()) {
9660 case 0:
9661 return '[W zeszłą niedzielę o] LT';
9662 case 3:
9663 return '[W zeszłą środę o] LT';
9664 case 6:
9665 return '[W zeszłą sobotę o] LT';
9666 default:
9667 return '[W zeszły] dddd [o] LT';
9668 }
9669 },
9670 sameElse: 'L'
9671 },
9672 relativeTime : {
9673 future : 'za %s',
9674 past : '%s temu',
9675 s : 'kilka sekund',
9676 m : pl__translate,
9677 mm : pl__translate,
9678 h : pl__translate,
9679 hh : pl__translate,
9680 d : '1 dzień',
9681 dd : '%d dni',
9682 M : 'miesiąc',
9683 MM : pl__translate,
9684 y : 'rok',
9685 yy : pl__translate
9686 },
9687 ordinalParse: /\d{1,2}\./,
9688 ordinal : '%d.',
9689 week : {
9690 dow : 1, // Monday is the first day of the week.
9691 doy : 4 // The week that contains Jan 4th is the first week of the year.
9692 }
9693 });
9695 //! moment.js locale configuration
9696 //! locale : brazilian portuguese (pt-br)
9697 //! author : Caio Ribeiro Pereira : https://github.com/caio-ribeiro-pereira
9699 var pt_br = moment__default.defineLocale('pt-br', {
9700 months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
9701 monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
9702 weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
9703 weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
9704 weekdaysMin : 'Dom_2ª_3ª_4ª_5ª_6ª_Sáb'.split('_'),
9705 weekdaysParseExact : true,
9706 longDateFormat : {
9707 LT : 'HH:mm',
9708 LTS : 'HH:mm:ss',
9709 L : 'DD/MM/YYYY',
9710 LL : 'D [de] MMMM [de] YYYY',
9711 LLL : 'D [de] MMMM [de] YYYY [às] HH:mm',
9712 LLLL : 'dddd, D [de] MMMM [de] YYYY [às] HH:mm'
9713 },
9714 calendar : {
9715 sameDay: '[Hoje às] LT',
9716 nextDay: '[Amanhã às] LT',
9717 nextWeek: 'dddd [às] LT',
9718 lastDay: '[Ontem às] LT',
9719 lastWeek: function () {
9720 return (this.day() === 0 || this.day() === 6) ?
9721 '[Último] dddd [às] LT' : // Saturday + Sunday
9722 '[Última] dddd [às] LT'; // Monday - Friday
9723 },
9724 sameElse: 'L'
9725 },
9726 relativeTime : {
9727 future : 'em %s',
9728 past : '%s atrás',
9729 s : 'poucos segundos',
9730 m : 'um minuto',
9731 mm : '%d minutos',
9732 h : 'uma hora',
9733 hh : '%d horas',
9734 d : 'um dia',
9735 dd : '%d dias',
9736 M : 'um mês',
9737 MM : '%d meses',
9738 y : 'um ano',
9739 yy : '%d anos'
9740 },
9741 ordinalParse: /\d{1,2}º/,
9742 ordinal : '%dº'
9743 });
9745 //! moment.js locale configuration
9746 //! locale : portuguese (pt)
9747 //! author : Jefferson : https://github.com/jalex79
9749 var pt = moment__default.defineLocale('pt', {
9750 months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
9751 monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
9752 weekdays : 'Domingo_Segunda-Feira_Terça-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_Sábado'.split('_'),
9753 weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
9754 weekdaysMin : 'Dom_2ª_3ª_4ª_5ª_6ª_Sáb'.split('_'),
9755 weekdaysParseExact : true,
9756 longDateFormat : {
9757 LT : 'HH:mm',
9758 LTS : 'HH:mm:ss',
9759 L : 'DD/MM/YYYY',
9760 LL : 'D [de] MMMM [de] YYYY',
9761 LLL : 'D [de] MMMM [de] YYYY HH:mm',
9762 LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm'
9763 },
9764 calendar : {
9765 sameDay: '[Hoje às] LT',
9766 nextDay: '[Amanhã às] LT',
9767 nextWeek: 'dddd [às] LT',
9768 lastDay: '[Ontem às] LT',
9769 lastWeek: function () {
9770 return (this.day() === 0 || this.day() === 6) ?
9771 '[Último] dddd [às] LT' : // Saturday + Sunday
9772 '[Última] dddd [às] LT'; // Monday - Friday
9773 },
9774 sameElse: 'L'
9775 },
9776 relativeTime : {
9777 future : 'em %s',
9778 past : 'há %s',
9779 s : 'segundos',
9780 m : 'um minuto',
9781 mm : '%d minutos',
9782 h : 'uma hora',
9783 hh : '%d horas',
9784 d : 'um dia',
9785 dd : '%d dias',
9786 M : 'um mês',
9787 MM : '%d meses',
9788 y : 'um ano',
9789 yy : '%d anos'
9790 },
9791 ordinalParse: /\d{1,2}º/,
9792 ordinal : '%dº',
9793 week : {
9794 dow : 1, // Monday is the first day of the week.
9795 doy : 4 // The week that contains Jan 4th is the first week of the year.
9796 }
9797 });
9799 //! moment.js locale configuration
9800 //! locale : romanian (ro)
9801 //! author : Vlad Gurdiga : https://github.com/gurdiga
9802 //! author : Valentin Agachi : https://github.com/avaly
9804 function ro__relativeTimeWithPlural(number, withoutSuffix, key) {
9805 var format = {
9806 'mm': 'minute',
9807 'hh': 'ore',
9808 'dd': 'zile',
9809 'MM': 'luni',
9810 'yy': 'ani'
9811 },
9812 separator = ' ';
9813 if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
9814 separator = ' de ';
9815 }
9816 return number + separator + format[key];
9817 }
9819 var ro = moment__default.defineLocale('ro', {
9820 months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
9821 monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
9822 monthsParseExact: true,
9823 weekdays : 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
9824 weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
9825 weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
9826 longDateFormat : {
9827 LT : 'H:mm',
9828 LTS : 'H:mm:ss',
9829 L : 'DD.MM.YYYY',
9830 LL : 'D MMMM YYYY',
9831 LLL : 'D MMMM YYYY H:mm',
9832 LLLL : 'dddd, D MMMM YYYY H:mm'
9833 },
9834 calendar : {
9835 sameDay: '[azi la] LT',
9836 nextDay: '[mâine la] LT',
9837 nextWeek: 'dddd [la] LT',
9838 lastDay: '[ieri la] LT',
9839 lastWeek: '[fosta] dddd [la] LT',
9840 sameElse: 'L'
9841 },
9842 relativeTime : {
9843 future : 'peste %s',
9844 past : '%s în urmă',
9845 s : 'câteva secunde',
9846 m : 'un minut',
9847 mm : ro__relativeTimeWithPlural,
9848 h : 'o oră',
9849 hh : ro__relativeTimeWithPlural,
9850 d : 'o zi',
9851 dd : ro__relativeTimeWithPlural,
9852 M : 'o lună',
9853 MM : ro__relativeTimeWithPlural,
9854 y : 'un an',
9855 yy : ro__relativeTimeWithPlural
9856 },
9857 week : {
9858 dow : 1, // Monday is the first day of the week.
9859 doy : 7 // The week that contains Jan 1st is the first week of the year.
9860 }
9861 });
9863 //! moment.js locale configuration
9864 //! locale : russian (ru)
9865 //! author : Viktorminator : https://github.com/Viktorminator
9866 //! Author : Menelion Elensúle : https://github.com/Oire
9867 //! author : Коренберг Марк : https://github.com/socketpair
9869 function ru__plural(word, num) {
9870 var forms = word.split('_');
9871 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]);
9872 }
9873 function ru__relativeTimeWithPlural(number, withoutSuffix, key) {
9874 var format = {
9875 'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
9876 'hh': 'час_часа_часов',
9877 'dd': 'день_дня_дней',
9878 'MM': 'месяц_месяца_месяцев',
9879 'yy': 'год_года_лет'
9880 };
9881 if (key === 'm') {
9882 return withoutSuffix ? 'минута' : 'минуту';
9883 }
9884 else {
9885 return number + ' ' + ru__plural(format[key], +number);
9886 }
9887 }
9888 var monthsParse = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[йя]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];
9890 // http://new.gramota.ru/spravka/rules/139-prop : § 103
9891 // Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637
9892 // CLDR data: http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
9893 var ru = moment__default.defineLocale('ru', {
9894 months : {
9895 format: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_'),
9896 standalone: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_')
9897 },
9898 monthsShort : {
9899 // по CLDR именно "июл." и "июн.", но какой смысл менять букву на точку ?
9900 format: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split('_'),
9901 standalone: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split('_')
9902 },
9903 weekdays : {
9904 standalone: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),
9905 format: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_'),
9906 isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
9907 },
9908 weekdaysShort : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
9909 weekdaysMin : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
9910 monthsParse : monthsParse,
9911 longMonthsParse : monthsParse,
9912 shortMonthsParse : monthsParse,
9913 monthsRegex: /^(сентябр[яь]|октябр[яь]|декабр[яь]|феврал[яь]|январ[яь]|апрел[яь]|августа?|ноябр[яь]|сент\.|февр\.|нояб\.|июнь|янв.|июль|дек.|авг.|апр.|марта|мар[.т]|окт.|июн[яь]|июл[яь]|ма[яй])/i,
9914 monthsShortRegex: /^(сентябр[яь]|октябр[яь]|декабр[яь]|феврал[яь]|январ[яь]|апрел[яь]|августа?|ноябр[яь]|сент\.|февр\.|нояб\.|июнь|янв.|июль|дек.|авг.|апр.|марта|мар[.т]|окт.|июн[яь]|июл[яь]|ма[яй])/i,
9915 monthsStrictRegex: /^(сентябр[яь]|октябр[яь]|декабр[яь]|феврал[яь]|январ[яь]|апрел[яь]|августа?|ноябр[яь]|марта?|июн[яь]|июл[яь]|ма[яй])/i,
9916 monthsShortStrictRegex: /^(нояб\.|февр\.|сент\.|июль|янв\.|июн[яь]|мар[.т]|авг\.|апр\.|окт\.|дек\.|ма[яй])/i,
9917 longDateFormat : {
9918 LT : 'HH:mm',
9919 LTS : 'HH:mm:ss',
9920 L : 'DD.MM.YYYY',
9921 LL : 'D MMMM YYYY г.',
9922 LLL : 'D MMMM YYYY г., HH:mm',
9923 LLLL : 'dddd, D MMMM YYYY г., HH:mm'
9924 },
9925 calendar : {
9926 sameDay: '[Сегодня в] LT',
9927 nextDay: '[Завтра в] LT',
9928 lastDay: '[Вчера в] LT',
9929 nextWeek: function (now) {
9930 if (now.week() !== this.week()) {
9931 switch (this.day()) {
9932 case 0:
9933 return '[В следующее] dddd [в] LT';
9934 case 1:
9935 case 2:
9936 case 4:
9937 return '[В следующий] dddd [в] LT';
9938 case 3:
9939 case 5:
9940 case 6:
9941 return '[В следующую] dddd [в] LT';
9942 }
9943 } else {
9944 if (this.day() === 2) {
9945 return '[Во] dddd [в] LT';
9946 } else {
9947 return '[В] dddd [в] LT';
9948 }
9949 }
9950 },
9951 lastWeek: function (now) {
9952 if (now.week() !== this.week()) {
9953 switch (this.day()) {
9954 case 0:
9955 return '[В прошлое] dddd [в] LT';
9956 case 1:
9957 case 2:
9958 case 4:
9959 return '[В прошлый] dddd [в] LT';
9960 case 3:
9961 case 5:
9962 case 6:
9963 return '[В прошлую] dddd [в] LT';
9964 }
9965 } else {
9966 if (this.day() === 2) {
9967 return '[Во] dddd [в] LT';
9968 } else {
9969 return '[В] dddd [в] LT';
9970 }
9971 }
9972 },
9973 sameElse: 'L'
9974 },
9975 relativeTime : {
9976 future : 'через %s',
9977 past : '%s назад',
9978 s : 'несколько секунд',
9979 m : ru__relativeTimeWithPlural,
9980 mm : ru__relativeTimeWithPlural,
9981 h : 'час',
9982 hh : ru__relativeTimeWithPlural,
9983 d : 'день',
9984 dd : ru__relativeTimeWithPlural,
9985 M : 'месяц',
9986 MM : ru__relativeTimeWithPlural,
9987 y : 'год',
9988 yy : ru__relativeTimeWithPlural
9989 },
9990 meridiemParse: /ночи|утра|дня|вечера/i,
9991 isPM : function (input) {
9992 return /^(дня|вечера)$/.test(input);
9993 },
9994 meridiem : function (hour, minute, isLower) {
9995 if (hour < 4) {
9996 return 'ночи';
9997 } else if (hour < 12) {
9998 return 'утра';
9999 } else if (hour < 17) {
10000 return 'дня';
10001 } else {
10002 return 'вечера';
10003 }
10004 },
10005 ordinalParse: /\d{1,2}-(й|го|я)/,
10006 ordinal: function (number, period) {
10007 switch (period) {
10008 case 'M':
10009 case 'd':
10010 case 'DDD':
10011 return number + '-й';
10012 case 'D':
10013 return number + '-го';
10014 case 'w':
10015 case 'W':
10016 return number + '-я';
10017 default:
10018 return number;
10019 }
10020 },
10021 week : {
10022 dow : 1, // Monday is the first day of the week.
10023 doy : 7 // The week that contains Jan 1st is the first week of the year.
10024 }
10025 });
10027 //! moment.js locale configuration
10028 //! locale : Northern Sami (se)
10029 //! authors : Bård Rolstad Henriksen : https://github.com/karamell
10032 var se = moment__default.defineLocale('se', {
10033 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('_'),
10034 monthsShort : 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split('_'),
10035 weekdays : 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),
10036 weekdaysShort : 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
10037 weekdaysMin : 's_v_m_g_d_b_L'.split('_'),
10038 longDateFormat : {
10039 LT : 'HH:mm',
10040 LTS : 'HH:mm:ss',
10041 L : 'DD.MM.YYYY',
10042 LL : 'MMMM D. [b.] YYYY',
10043 LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',
10044 LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
10045 },
10046 calendar : {
10047 sameDay: '[otne ti] LT',
10048 nextDay: '[ihttin ti] LT',
10049 nextWeek: 'dddd [ti] LT',
10050 lastDay: '[ikte ti] LT',
10051 lastWeek: '[ovddit] dddd [ti] LT',
10052 sameElse: 'L'
10053 },
10054 relativeTime : {
10055 future : '%s geažes',
10056 past : 'maŋit %s',
10057 s : 'moadde sekunddat',
10058 m : 'okta minuhta',
10059 mm : '%d minuhtat',
10060 h : 'okta diimmu',
10061 hh : '%d diimmut',
10062 d : 'okta beaivi',
10063 dd : '%d beaivvit',
10064 M : 'okta mánnu',
10065 MM : '%d mánut',
10066 y : 'okta jahki',
10067 yy : '%d jagit'
10068 },
10069 ordinalParse: /\d{1,2}\./,
10070 ordinal : '%d.',
10071 week : {
10072 dow : 1, // Monday is the first day of the week.
10073 doy : 4 // The week that contains Jan 4th is the first week of the year.
10074 }
10075 });
10077 //! moment.js locale configuration
10078 //! locale : Sinhalese (si)
10079 //! author : Sampath Sitinamaluwa : https://github.com/sampathsris
10081 /*jshint -W100*/
10082 var si = moment__default.defineLocale('si', {
10083 months : 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split('_'),
10084 monthsShort : 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split('_'),
10085 weekdays : 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split('_'),
10086 weekdaysShort : 'ඉරි_සඳු_අඟ_බදා_බ්රහ_සිකු_සෙන'.split('_'),
10087 weekdaysMin : 'ඉ_ස_අ_බ_බ්ර_සි_සෙ'.split('_'),
10088 weekdaysParseExact : true,
10089 longDateFormat : {
10090 LT : 'a h:mm',
10091 LTS : 'a h:mm:ss',
10092 L : 'YYYY/MM/DD',
10093 LL : 'YYYY MMMM D',
10094 LLL : 'YYYY MMMM D, a h:mm',
10095 LLLL : 'YYYY MMMM D [වැනි] dddd, a h:mm:ss'
10096 },
10097 calendar : {
10098 sameDay : '[අද] LT[ට]',
10099 nextDay : '[හෙට] LT[ට]',
10100 nextWeek : 'dddd LT[ට]',
10101 lastDay : '[ඊයේ] LT[ට]',
10102 lastWeek : '[පසුගිය] dddd LT[ට]',
10103 sameElse : 'L'
10104 },
10105 relativeTime : {
10106 future : '%sකින්',
10107 past : '%sකට පෙර',
10108 s : 'තත්පර කිහිපය',
10109 m : 'මිනිත්තුව',
10110 mm : 'මිනිත්තු %d',
10111 h : 'පැය',
10112 hh : 'පැය %d',
10113 d : 'දිනය',
10114 dd : 'දින %d',
10115 M : 'මාසය',
10116 MM : 'මාස %d',
10117 y : 'වසර',
10118 yy : 'වසර %d'
10119 },
10120 ordinalParse: /\d{1,2} වැනි/,
10121 ordinal : function (number) {
10122 return number + ' වැනි';
10123 },
10124 meridiemParse : /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
10125 isPM : function (input) {
10126 return input === 'ප.ව.' || input === 'පස් වරු';
10127 },
10128 meridiem : function (hours, minutes, isLower) {
10129 if (hours > 11) {
10130 return isLower ? 'ප.ව.' : 'පස් වරු';
10131 } else {
10132 return isLower ? 'පෙ.ව.' : 'පෙර වරු';
10133 }
10134 }
10135 });
10137 //! moment.js locale configuration
10138 //! locale : slovak (sk)
10139 //! author : Martin Minka : https://github.com/k2s
10140 //! based on work of petrbela : https://github.com/petrbela
10142 var sk__months = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_'),
10143 sk__monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
10144 function sk__plural(n) {
10145 return (n > 1) && (n < 5);
10146 }
10147 function sk__translate(number, withoutSuffix, key, isFuture) {
10148 var result = number + ' ';
10149 switch (key) {
10150 case 's': // a few seconds / in a few seconds / a few seconds ago
10151 return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
10152 case 'm': // a minute / in a minute / a minute ago
10153 return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou');
10154 case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
10155 if (withoutSuffix || isFuture) {
10156 return result + (sk__plural(number) ? 'minúty' : 'minút');
10157 } else {
10158 return result + 'minútami';
10159 }
10160 break;
10161 case 'h': // an hour / in an hour / an hour ago
10162 return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
10163 case 'hh': // 9 hours / in 9 hours / 9 hours ago
10164 if (withoutSuffix || isFuture) {
10165 return result + (sk__plural(number) ? 'hodiny' : 'hodín');
10166 } else {
10167 return result + 'hodinami';
10168 }
10169 break;
10170 case 'd': // a day / in a day / a day ago
10171 return (withoutSuffix || isFuture) ? 'deň' : 'dňom';
10172 case 'dd': // 9 days / in 9 days / 9 days ago
10173 if (withoutSuffix || isFuture) {
10174 return result + (sk__plural(number) ? 'dni' : 'dní');
10175 } else {
10176 return result + 'dňami';
10177 }
10178 break;
10179 case 'M': // a month / in a month / a month ago
10180 return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
10181 case 'MM': // 9 months / in 9 months / 9 months ago
10182 if (withoutSuffix || isFuture) {
10183 return result + (sk__plural(number) ? 'mesiace' : 'mesiacov');
10184 } else {
10185 return result + 'mesiacmi';
10186 }
10187 break;
10188 case 'y': // a year / in a year / a year ago
10189 return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
10190 case 'yy': // 9 years / in 9 years / 9 years ago
10191 if (withoutSuffix || isFuture) {
10192 return result + (sk__plural(number) ? 'roky' : 'rokov');
10193 } else {
10194 return result + 'rokmi';
10195 }
10196 break;
10197 }
10198 }
10200 var sk = moment__default.defineLocale('sk', {
10201 months : sk__months,
10202 monthsShort : sk__monthsShort,
10203 weekdays : 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
10204 weekdaysShort : 'ne_po_ut_st_št_pi_so'.split('_'),
10205 weekdaysMin : 'ne_po_ut_st_št_pi_so'.split('_'),
10206 longDateFormat : {
10207 LT: 'H:mm',
10208 LTS : 'H:mm:ss',
10209 L : 'DD.MM.YYYY',
10210 LL : 'D. MMMM YYYY',
10211 LLL : 'D. MMMM YYYY H:mm',
10212 LLLL : 'dddd D. MMMM YYYY H:mm'
10213 },
10214 calendar : {
10215 sameDay: '[dnes o] LT',
10216 nextDay: '[zajtra o] LT',
10217 nextWeek: function () {
10218 switch (this.day()) {
10219 case 0:
10220 return '[v nedeľu o] LT';
10221 case 1:
10222 case 2:
10223 return '[v] dddd [o] LT';
10224 case 3:
10225 return '[v stredu o] LT';
10226 case 4:
10227 return '[vo štvrtok o] LT';
10228 case 5:
10229 return '[v piatok o] LT';
10230 case 6:
10231 return '[v sobotu o] LT';
10232 }
10233 },
10234 lastDay: '[včera o] LT',
10235 lastWeek: function () {
10236 switch (this.day()) {
10237 case 0:
10238 return '[minulú nedeľu o] LT';
10239 case 1:
10240 case 2:
10241 return '[minulý] dddd [o] LT';
10242 case 3:
10243 return '[minulú stredu o] LT';
10244 case 4:
10245 case 5:
10246 return '[minulý] dddd [o] LT';
10247 case 6:
10248 return '[minulú sobotu o] LT';
10249 }
10250 },
10251 sameElse: 'L'
10252 },
10253 relativeTime : {
10254 future : 'za %s',
10255 past : 'pred %s',
10256 s : sk__translate,
10257 m : sk__translate,
10258 mm : sk__translate,
10259 h : sk__translate,
10260 hh : sk__translate,
10261 d : sk__translate,
10262 dd : sk__translate,
10263 M : sk__translate,
10264 MM : sk__translate,
10265 y : sk__translate,
10266 yy : sk__translate
10267 },
10268 ordinalParse: /\d{1,2}\./,
10269 ordinal : '%d.',
10270 week : {
10271 dow : 1, // Monday is the first day of the week.
10272 doy : 4 // The week that contains Jan 4th is the first week of the year.
10273 }
10274 });
10276 //! moment.js locale configuration
10277 //! locale : slovenian (sl)
10278 //! author : Robert Sedovšek : https://github.com/sedovsek
10280 function sl__processRelativeTime(number, withoutSuffix, key, isFuture) {
10281 var result = number + ' ';
10282 switch (key) {
10283 case 's':
10284 return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami';
10285 case 'm':
10286 return withoutSuffix ? 'ena minuta' : 'eno minuto';
10287 case 'mm':
10288 if (number === 1) {
10289 result += withoutSuffix ? 'minuta' : 'minuto';
10290 } else if (number === 2) {
10291 result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
10292 } else if (number < 5) {
10293 result += withoutSuffix || isFuture ? 'minute' : 'minutami';
10294 } else {
10295 result += withoutSuffix || isFuture ? 'minut' : 'minutami';
10296 }
10297 return result;
10298 case 'h':
10299 return withoutSuffix ? 'ena ura' : 'eno uro';
10300 case 'hh':
10301 if (number === 1) {
10302 result += withoutSuffix ? 'ura' : 'uro';
10303 } else if (number === 2) {
10304 result += withoutSuffix || isFuture ? 'uri' : 'urama';
10305 } else if (number < 5) {
10306 result += withoutSuffix || isFuture ? 'ure' : 'urami';
10307 } else {
10308 result += withoutSuffix || isFuture ? 'ur' : 'urami';
10309 }
10310 return result;
10311 case 'd':
10312 return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
10313 case 'dd':
10314 if (number === 1) {
10315 result += withoutSuffix || isFuture ? 'dan' : 'dnem';
10316 } else if (number === 2) {
10317 result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
10318 } else {
10319 result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
10320 }
10321 return result;
10322 case 'M':
10323 return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
10324 case 'MM':
10325 if (number === 1) {
10326 result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
10327 } else if (number === 2) {
10328 result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
10329 } else if (number < 5) {
10330 result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
10331 } else {
10332 result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
10333 }
10334 return result;
10335 case 'y':
10336 return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
10337 case 'yy':
10338 if (number === 1) {
10339 result += withoutSuffix || isFuture ? 'leto' : 'letom';
10340 } else if (number === 2) {
10341 result += withoutSuffix || isFuture ? 'leti' : 'letoma';
10342 } else if (number < 5) {
10343 result += withoutSuffix || isFuture ? 'leta' : 'leti';
10344 } else {
10345 result += withoutSuffix || isFuture ? 'let' : 'leti';
10346 }
10347 return result;
10348 }
10349 }
10351 var sl = moment__default.defineLocale('sl', {
10352 months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
10353 monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
10354 monthsParseExact: true,
10355 weekdays : 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
10356 weekdaysShort : 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
10357 weekdaysMin : 'ne_po_to_sr_če_pe_so'.split('_'),
10358 weekdaysParseExact : true,
10359 longDateFormat : {
10360 LT : 'H:mm',
10361 LTS : 'H:mm:ss',
10362 L : 'DD. MM. YYYY',
10363 LL : 'D. MMMM YYYY',
10364 LLL : 'D. MMMM YYYY H:mm',
10365 LLLL : 'dddd, D. MMMM YYYY H:mm'
10366 },
10367 calendar : {
10368 sameDay : '[danes ob] LT',
10369 nextDay : '[jutri ob] LT',
10371 nextWeek : function () {
10372 switch (this.day()) {
10373 case 0:
10374 return '[v] [nedeljo] [ob] LT';
10375 case 3:
10376 return '[v] [sredo] [ob] LT';
10377 case 6:
10378 return '[v] [soboto] [ob] LT';
10379 case 1:
10380 case 2:
10381 case 4:
10382 case 5:
10383 return '[v] dddd [ob] LT';
10384 }
10385 },
10386 lastDay : '[včeraj ob] LT',
10387 lastWeek : function () {
10388 switch (this.day()) {
10389 case 0:
10390 return '[prejšnjo] [nedeljo] [ob] LT';
10391 case 3:
10392 return '[prejšnjo] [sredo] [ob] LT';
10393 case 6:
10394 return '[prejšnjo] [soboto] [ob] LT';
10395 case 1:
10396 case 2:
10397 case 4:
10398 case 5:
10399 return '[prejšnji] dddd [ob] LT';
10400 }
10401 },
10402 sameElse : 'L'
10403 },
10404 relativeTime : {
10405 future : 'čez %s',
10406 past : 'pred %s',
10407 s : sl__processRelativeTime,
10408 m : sl__processRelativeTime,
10409 mm : sl__processRelativeTime,
10410 h : sl__processRelativeTime,
10411 hh : sl__processRelativeTime,
10412 d : sl__processRelativeTime,
10413 dd : sl__processRelativeTime,
10414 M : sl__processRelativeTime,
10415 MM : sl__processRelativeTime,
10416 y : sl__processRelativeTime,
10417 yy : sl__processRelativeTime
10418 },
10419 ordinalParse: /\d{1,2}\./,
10420 ordinal : '%d.',
10421 week : {
10422 dow : 1, // Monday is the first day of the week.
10423 doy : 7 // The week that contains Jan 1st is the first week of the year.
10424 }
10425 });
10427 //! moment.js locale configuration
10428 //! locale : Albanian (sq)
10429 //! author : Flakërim Ismani : https://github.com/flakerimi
10430 //! author: Menelion Elensúle: https://github.com/Oire (tests)
10431 //! author : Oerd Cukalla : https://github.com/oerd (fixes)
10433 var sq = moment__default.defineLocale('sq', {
10434 months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
10435 monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
10436 weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
10437 weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
10438 weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'),
10439 weekdaysParseExact : true,
10440 meridiemParse: /PD|MD/,
10441 isPM: function (input) {
10442 return input.charAt(0) === 'M';
10443 },
10444 meridiem : function (hours, minutes, isLower) {
10445 return hours < 12 ? 'PD' : 'MD';
10446 },
10447 longDateFormat : {
10448 LT : 'HH:mm',
10449 LTS : 'HH:mm:ss',
10450 L : 'DD/MM/YYYY',
10451 LL : 'D MMMM YYYY',
10452 LLL : 'D MMMM YYYY HH:mm',
10453 LLLL : 'dddd, D MMMM YYYY HH:mm'
10454 },
10455 calendar : {
10456 sameDay : '[Sot në] LT',
10457 nextDay : '[Nesër në] LT',
10458 nextWeek : 'dddd [në] LT',
10459 lastDay : '[Dje në] LT',
10460 lastWeek : 'dddd [e kaluar në] LT',
10461 sameElse : 'L'
10462 },
10463 relativeTime : {
10464 future : 'në %s',
10465 past : '%s më parë',
10466 s : 'disa sekonda',
10467 m : 'një minutë',
10468 mm : '%d minuta',
10469 h : 'një orë',
10470 hh : '%d orë',
10471 d : 'një ditë',
10472 dd : '%d ditë',
10473 M : 'një muaj',
10474 MM : '%d muaj',
10475 y : 'një vit',
10476 yy : '%d vite'
10477 },
10478 ordinalParse: /\d{1,2}\./,
10479 ordinal : '%d.',
10480 week : {
10481 dow : 1, // Monday is the first day of the week.
10482 doy : 4 // The week that contains Jan 4th is the first week of the year.
10483 }
10484 });
10486 //! moment.js locale configuration
10487 //! locale : Serbian-cyrillic (sr-cyrl)
10488 //! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
10490 var sr_cyrl__translator = {
10491 words: { //Different grammatical cases
10492 m: ['један минут', 'једне минуте'],
10493 mm: ['минут', 'минуте', 'минута'],
10494 h: ['један сат', 'једног сата'],
10495 hh: ['сат', 'сата', 'сати'],
10496 dd: ['дан', 'дана', 'дана'],
10497 MM: ['месец', 'месеца', 'месеци'],
10498 yy: ['година', 'године', 'година']
10499 },
10500 correctGrammaticalCase: function (number, wordKey) {
10501 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
10502 },
10503 translate: function (number, withoutSuffix, key) {
10504 var wordKey = sr_cyrl__translator.words[key];
10505 if (key.length === 1) {
10506 return withoutSuffix ? wordKey[0] : wordKey[1];
10507 } else {
10508 return number + ' ' + sr_cyrl__translator.correctGrammaticalCase(number, wordKey);
10509 }
10510 }
10511 };
10513 var sr_cyrl = moment__default.defineLocale('sr-cyrl', {
10514 months: 'јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар'.split('_'),
10515 monthsShort: 'јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.'.split('_'),
10516 monthsParseExact: true,
10517 weekdays: 'недеља_понедељак_уторак_среда_четвртак_петак_субота'.split('_'),
10518 weekdaysShort: 'нед._пон._уто._сре._чет._пет._суб.'.split('_'),
10519 weekdaysMin: 'не_по_ут_ср_че_пе_су'.split('_'),
10520 weekdaysParseExact : true,
10521 longDateFormat: {
10522 LT: 'H:mm',
10523 LTS : 'H:mm:ss',
10524 L: 'DD. MM. YYYY',
10525 LL: 'D. MMMM YYYY',
10526 LLL: 'D. MMMM YYYY H:mm',
10527 LLLL: 'dddd, D. MMMM YYYY H:mm'
10528 },
10529 calendar: {
10530 sameDay: '[данас у] LT',
10531 nextDay: '[сутра у] LT',
10532 nextWeek: function () {
10533 switch (this.day()) {
10534 case 0:
10535 return '[у] [недељу] [у] LT';
10536 case 3:
10537 return '[у] [среду] [у] LT';
10538 case 6:
10539 return '[у] [суботу] [у] LT';
10540 case 1:
10541 case 2:
10542 case 4:
10543 case 5:
10544 return '[у] dddd [у] LT';
10545 }
10546 },
10547 lastDay : '[јуче у] LT',
10548 lastWeek : function () {
10549 var lastWeekDays = [
10550 '[прошле] [недеље] [у] LT',
10551 '[прошлог] [понедељка] [у] LT',
10552 '[прошлог] [уторка] [у] LT',
10553 '[прошле] [среде] [у] LT',
10554 '[прошлог] [четвртка] [у] LT',
10555 '[прошлог] [петка] [у] LT',
10556 '[прошле] [суботе] [у] LT'
10557 ];
10558 return lastWeekDays[this.day()];
10559 },
10560 sameElse : 'L'
10561 },
10562 relativeTime : {
10563 future : 'за %s',
10564 past : 'пре %s',
10565 s : 'неколико секунди',
10566 m : sr_cyrl__translator.translate,
10567 mm : sr_cyrl__translator.translate,
10568 h : sr_cyrl__translator.translate,
10569 hh : sr_cyrl__translator.translate,
10570 d : 'дан',
10571 dd : sr_cyrl__translator.translate,
10572 M : 'месец',
10573 MM : sr_cyrl__translator.translate,
10574 y : 'годину',
10575 yy : sr_cyrl__translator.translate
10576 },
10577 ordinalParse: /\d{1,2}\./,
10578 ordinal : '%d.',
10579 week : {
10580 dow : 1, // Monday is the first day of the week.
10581 doy : 7 // The week that contains Jan 1st is the first week of the year.
10582 }
10583 });
10585 //! moment.js locale configuration
10586 //! locale : Serbian-latin (sr)
10587 //! author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j
10589 var sr__translator = {
10590 words: { //Different grammatical cases
10591 m: ['jedan minut', 'jedne minute'],
10592 mm: ['minut', 'minute', 'minuta'],
10593 h: ['jedan sat', 'jednog sata'],
10594 hh: ['sat', 'sata', 'sati'],
10595 dd: ['dan', 'dana', 'dana'],
10596 MM: ['mesec', 'meseca', 'meseci'],
10597 yy: ['godina', 'godine', 'godina']
10598 },
10599 correctGrammaticalCase: function (number, wordKey) {
10600 return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
10601 },
10602 translate: function (number, withoutSuffix, key) {
10603 var wordKey = sr__translator.words[key];
10604 if (key.length === 1) {
10605 return withoutSuffix ? wordKey[0] : wordKey[1];
10606 } else {
10607 return number + ' ' + sr__translator.correctGrammaticalCase(number, wordKey);
10608 }
10609 }
10610 };
10612 var sr = moment__default.defineLocale('sr', {
10613 months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
10614 monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
10615 monthsParseExact: true,
10616 weekdays: 'nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota'.split('_'),
10617 weekdaysShort: 'ned._pon._uto._sre._čet._pet._sub.'.split('_'),
10618 weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
10619 weekdaysParseExact : true,
10620 longDateFormat: {
10621 LT: 'H:mm',
10622 LTS : 'H:mm:ss',
10623 L: 'DD. MM. YYYY',
10624 LL: 'D. MMMM YYYY',
10625 LLL: 'D. MMMM YYYY H:mm',
10626 LLLL: 'dddd, D. MMMM YYYY H:mm'
10627 },
10628 calendar: {
10629 sameDay: '[danas u] LT',
10630 nextDay: '[sutra u] LT',
10631 nextWeek: function () {
10632 switch (this.day()) {
10633 case 0:
10634 return '[u] [nedelju] [u] LT';
10635 case 3:
10636 return '[u] [sredu] [u] LT';
10637 case 6:
10638 return '[u] [subotu] [u] LT';
10639 case 1:
10640 case 2:
10641 case 4:
10642 case 5:
10643 return '[u] dddd [u] LT';
10644 }
10645 },
10646 lastDay : '[juče u] LT',
10647 lastWeek : function () {
10648 var lastWeekDays = [
10649 '[prošle] [nedelje] [u] LT',
10650 '[prošlog] [ponedeljka] [u] LT',
10651 '[prošlog] [utorka] [u] LT',
10652 '[prošle] [srede] [u] LT',
10653 '[prošlog] [četvrtka] [u] LT',
10654 '[prošlog] [petka] [u] LT',
10655 '[prošle] [subote] [u] LT'
10656 ];
10657 return lastWeekDays[this.day()];
10658 },
10659 sameElse : 'L'
10660 },
10661 relativeTime : {
10662 future : 'za %s',
10663 past : 'pre %s',
10664 s : 'nekoliko sekundi',
10665 m : sr__translator.translate,
10666 mm : sr__translator.translate,
10667 h : sr__translator.translate,
10668 hh : sr__translator.translate,
10669 d : 'dan',
10670 dd : sr__translator.translate,
10671 M : 'mesec',
10672 MM : sr__translator.translate,
10673 y : 'godinu',
10674 yy : sr__translator.translate
10675 },
10676 ordinalParse: /\d{1,2}\./,
10677 ordinal : '%d.',
10678 week : {
10679 dow : 1, // Monday is the first day of the week.
10680 doy : 7 // The week that contains Jan 1st is the first week of the year.
10681 }
10682 });
10684 //! moment.js locale configuration
10685 //! locale : siSwati (ss)
10686 //! author : Nicolai Davies<mail@nicolai.io> : https://github.com/nicolaidavies
10689 var ss = moment__default.defineLocale('ss', {
10690 months : "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'),
10691 monthsShort : 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
10692 weekdays : 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'),
10693 weekdaysShort : 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
10694 weekdaysMin : 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
10695 weekdaysParseExact : true,
10696 longDateFormat : {
10697 LT : 'h:mm A',
10698 LTS : 'h:mm:ss A',
10699 L : 'DD/MM/YYYY',
10700 LL : 'D MMMM YYYY',
10701 LLL : 'D MMMM YYYY h:mm A',
10702 LLLL : 'dddd, D MMMM YYYY h:mm A'
10703 },
10704 calendar : {
10705 sameDay : '[Namuhla nga] LT',
10706 nextDay : '[Kusasa nga] LT',
10707 nextWeek : 'dddd [nga] LT',
10708 lastDay : '[Itolo nga] LT',
10709 lastWeek : 'dddd [leliphelile] [nga] LT',
10710 sameElse : 'L'
10711 },
10712 relativeTime : {
10713 future : 'nga %s',
10714 past : 'wenteka nga %s',
10715 s : 'emizuzwana lomcane',
10716 m : 'umzuzu',
10717 mm : '%d emizuzu',
10718 h : 'lihora',
10719 hh : '%d emahora',
10720 d : 'lilanga',
10721 dd : '%d emalanga',
10722 M : 'inyanga',
10723 MM : '%d tinyanga',
10724 y : 'umnyaka',
10725 yy : '%d iminyaka'
10726 },
10727 meridiemParse: /ekuseni|emini|entsambama|ebusuku/,
10728 meridiem : function (hours, minutes, isLower) {
10729 if (hours < 11) {
10730 return 'ekuseni';
10731 } else if (hours < 15) {
10732 return 'emini';
10733 } else if (hours < 19) {
10734 return 'entsambama';
10735 } else {
10736 return 'ebusuku';
10737 }
10738 },
10739 meridiemHour : function (hour, meridiem) {
10740 if (hour === 12) {
10741 hour = 0;
10742 }
10743 if (meridiem === 'ekuseni') {
10744 return hour;
10745 } else if (meridiem === 'emini') {
10746 return hour >= 11 ? hour : hour + 12;
10747 } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') {
10748 if (hour === 0) {
10749 return 0;
10750 }
10751 return hour + 12;
10752 }
10753 },
10754 ordinalParse: /\d{1,2}/,
10755 ordinal : '%d',
10756 week : {
10757 dow : 1, // Monday is the first day of the week.
10758 doy : 4 // The week that contains Jan 4th is the first week of the year.
10759 }
10760 });
10762 //! moment.js locale configuration
10763 //! locale : swedish (sv)
10764 //! author : Jens Alm : https://github.com/ulmus
10766 var sv = moment__default.defineLocale('sv', {
10767 months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
10768 monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
10769 weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
10770 weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
10771 weekdaysMin : 'sö_må_ti_on_to_fr_lö'.split('_'),
10772 longDateFormat : {
10773 LT : 'HH:mm',
10774 LTS : 'HH:mm:ss',
10775 L : 'YYYY-MM-DD',
10776 LL : 'D MMMM YYYY',
10777 LLL : 'D MMMM YYYY [kl.] HH:mm',
10778 LLLL : 'dddd D MMMM YYYY [kl.] HH:mm',
10779 lll : 'D MMM YYYY HH:mm',
10780 llll : 'ddd D MMM YYYY HH:mm'
10781 },
10782 calendar : {
10783 sameDay: '[Idag] LT',
10784 nextDay: '[Imorgon] LT',
10785 lastDay: '[Igår] LT',
10786 nextWeek: '[På] dddd LT',
10787 lastWeek: '[I] dddd[s] LT',
10788 sameElse: 'L'
10789 },
10790 relativeTime : {
10791 future : 'om %s',
10792 past : 'för %s sedan',
10793 s : 'några sekunder',
10794 m : 'en minut',
10795 mm : '%d minuter',
10796 h : 'en timme',
10797 hh : '%d timmar',
10798 d : 'en dag',
10799 dd : '%d dagar',
10800 M : 'en månad',
10801 MM : '%d månader',
10802 y : 'ett år',
10803 yy : '%d år'
10804 },
10805 ordinalParse: /\d{1,2}(e|a)/,
10806 ordinal : function (number) {
10807 var b = number % 10,
10808 output = (~~(number % 100 / 10) === 1) ? 'e' :
10809 (b === 1) ? 'a' :
10810 (b === 2) ? 'a' :
10811 (b === 3) ? 'e' : 'e';
10812 return number + output;
10813 },
10814 week : {
10815 dow : 1, // Monday is the first day of the week.
10816 doy : 4 // The week that contains Jan 4th is the first week of the year.
10817 }
10818 });
10820 //! moment.js locale configuration
10821 //! locale : swahili (sw)
10822 //! author : Fahad Kassim : https://github.com/fadsel
10824 var sw = moment__default.defineLocale('sw', {
10825 months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
10826 monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
10827 weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
10828 weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
10829 weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
10830 weekdaysParseExact : true,
10831 longDateFormat : {
10832 LT : 'HH:mm',
10833 LTS : 'HH:mm:ss',
10834 L : 'DD.MM.YYYY',
10835 LL : 'D MMMM YYYY',
10836 LLL : 'D MMMM YYYY HH:mm',
10837 LLLL : 'dddd, D MMMM YYYY HH:mm'
10838 },
10839 calendar : {
10840 sameDay : '[leo saa] LT',
10841 nextDay : '[kesho saa] LT',
10842 nextWeek : '[wiki ijayo] dddd [saat] LT',
10843 lastDay : '[jana] LT',
10844 lastWeek : '[wiki iliyopita] dddd [saat] LT',
10845 sameElse : 'L'
10846 },
10847 relativeTime : {
10848 future : '%s baadaye',
10849 past : 'tokea %s',
10850 s : 'hivi punde',
10851 m : 'dakika moja',
10852 mm : 'dakika %d',
10853 h : 'saa limoja',
10854 hh : 'masaa %d',
10855 d : 'siku moja',
10856 dd : 'masiku %d',
10857 M : 'mwezi mmoja',
10858 MM : 'miezi %d',
10859 y : 'mwaka mmoja',
10860 yy : 'miaka %d'
10861 },
10862 week : {
10863 dow : 1, // Monday is the first day of the week.
10864 doy : 7 // The week that contains Jan 1st is the first week of the year.
10865 }
10866 });
10868 //! moment.js locale configuration
10869 //! locale : tamil (ta)
10870 //! author : Arjunkumar Krishnamoorthy : https://github.com/tk120404
10872 var ta__symbolMap = {
10873 '1': '௧',
10874 '2': '௨',
10875 '3': '௩',
10876 '4': '௪',
10877 '5': '௫',
10878 '6': '௬',
10879 '7': '௭',
10880 '8': '௮',
10881 '9': '௯',
10882 '0': '௦'
10883 }, ta__numberMap = {
10884 '௧': '1',
10885 '௨': '2',
10886 '௩': '3',
10887 '௪': '4',
10888 '௫': '5',
10889 '௬': '6',
10890 '௭': '7',
10891 '௮': '8',
10892 '௯': '9',
10893 '௦': '0'
10894 };
10896 var ta = moment__default.defineLocale('ta', {
10897 months : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
10898 monthsShort : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
10899 weekdays : 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split('_'),
10900 weekdaysShort : 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split('_'),
10901 weekdaysMin : 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
10902 longDateFormat : {
10903 LT : 'HH:mm',
10904 LTS : 'HH:mm:ss',
10905 L : 'DD/MM/YYYY',
10906 LL : 'D MMMM YYYY',
10907 LLL : 'D MMMM YYYY, HH:mm',
10908 LLLL : 'dddd, D MMMM YYYY, HH:mm'
10909 },
10910 calendar : {
10911 sameDay : '[இன்று] LT',
10912 nextDay : '[நாளை] LT',
10913 nextWeek : 'dddd, LT',
10914 lastDay : '[நேற்று] LT',
10915 lastWeek : '[கடந்த வாரம்] dddd, LT',
10916 sameElse : 'L'
10917 },
10918 relativeTime : {
10919 future : '%s இல்',
10920 past : '%s முன்',
10921 s : 'ஒரு சில விநாடிகள்',
10922 m : 'ஒரு நிமிடம்',
10923 mm : '%d நிமிடங்கள்',
10924 h : 'ஒரு மணி நேரம்',
10925 hh : '%d மணி நேரம்',
10926 d : 'ஒரு நாள்',
10927 dd : '%d நாட்கள்',
10928 M : 'ஒரு மாதம்',
10929 MM : '%d மாதங்கள்',
10930 y : 'ஒரு வருடம்',
10931 yy : '%d ஆண்டுகள்'
10932 },
10933 ordinalParse: /\d{1,2}வது/,
10934 ordinal : function (number) {
10935 return number + 'வது';
10936 },
10937 preparse: function (string) {
10938 return string.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match) {
10939 return ta__numberMap[match];
10940 });
10941 },
10942 postformat: function (string) {
10943 return string.replace(/\d/g, function (match) {
10944 return ta__symbolMap[match];
10945 });
10946 },
10947 // refer http://ta.wikipedia.org/s/1er1
10948 meridiemParse: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
10949 meridiem : function (hour, minute, isLower) {
10950 if (hour < 2) {
10951 return ' யாமம்';
10952 } else if (hour < 6) {
10953 return ' வைகறை'; // வைகறை
10954 } else if (hour < 10) {
10955 return ' காலை'; // காலை
10956 } else if (hour < 14) {
10957 return ' நண்பகல்'; // நண்பகல்
10958 } else if (hour < 18) {
10959 return ' எற்பாடு'; // எற்பாடு
10960 } else if (hour < 22) {
10961 return ' மாலை'; // மாலை
10962 } else {
10963 return ' யாமம்';
10964 }
10965 },
10966 meridiemHour : function (hour, meridiem) {
10967 if (hour === 12) {
10968 hour = 0;
10969 }
10970 if (meridiem === 'யாமம்') {
10971 return hour < 2 ? hour : hour + 12;
10972 } else if (meridiem === 'வைகறை' || meridiem === 'காலை') {
10973 return hour;
10974 } else if (meridiem === 'நண்பகல்') {
10975 return hour >= 10 ? hour : hour + 12;
10976 } else {
10977 return hour + 12;
10978 }
10979 },
10980 week : {
10981 dow : 0, // Sunday is the first day of the week.
10982 doy : 6 // The week that contains Jan 1st is the first week of the year.
10983 }
10984 });
10986 //! moment.js locale configuration
10987 //! locale : telugu (te)
10988 //! author : Krishna Chaitanya Thota : https://github.com/kcthota
10990 var te = moment__default.defineLocale('te', {
10991 months : 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జూలై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split('_'),
10992 monthsShort : 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జూలై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split('_'),
10993 monthsParseExact : true,
10994 weekdays : 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split('_'),
10995 weekdaysShort : 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
10996 weekdaysMin : 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
10997 longDateFormat : {
10998 LT : 'A h:mm',
10999 LTS : 'A h:mm:ss',
11000 L : 'DD/MM/YYYY',
11001 LL : 'D MMMM YYYY',
11002 LLL : 'D MMMM YYYY, A h:mm',
11003 LLLL : 'dddd, D MMMM YYYY, A h:mm'
11004 },
11005 calendar : {
11006 sameDay : '[నేడు] LT',
11007 nextDay : '[రేపు] LT',
11008 nextWeek : 'dddd, LT',
11009 lastDay : '[నిన్న] LT',
11010 lastWeek : '[గత] dddd, LT',
11011 sameElse : 'L'
11012 },
11013 relativeTime : {
11014 future : '%s లో',
11015 past : '%s క్రితం',
11016 s : 'కొన్ని క్షణాలు',
11017 m : 'ఒక నిమిషం',
11018 mm : '%d నిమిషాలు',
11019 h : 'ఒక గంట',
11020 hh : '%d గంటలు',
11021 d : 'ఒక రోజు',
11022 dd : '%d రోజులు',
11023 M : 'ఒక నెల',
11024 MM : '%d నెలలు',
11025 y : 'ఒక సంవత్సరం',
11026 yy : '%d సంవత్సరాలు'
11027 },
11028 ordinalParse : /\d{1,2}వ/,
11029 ordinal : '%dవ',
11030 meridiemParse: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
11031 meridiemHour : function (hour, meridiem) {
11032 if (hour === 12) {
11033 hour = 0;
11034 }
11035 if (meridiem === 'రాత్రి') {
11036 return hour < 4 ? hour : hour + 12;
11037 } else if (meridiem === 'ఉదయం') {
11038 return hour;
11039 } else if (meridiem === 'మధ్యాహ్నం') {
11040 return hour >= 10 ? hour : hour + 12;
11041 } else if (meridiem === 'సాయంత్రం') {
11042 return hour + 12;
11043 }
11044 },
11045 meridiem : function (hour, minute, isLower) {
11046 if (hour < 4) {
11047 return 'రాత్రి';
11048 } else if (hour < 10) {
11049 return 'ఉదయం';
11050 } else if (hour < 17) {
11051 return 'మధ్యాహ్నం';
11052 } else if (hour < 20) {
11053 return 'సాయంత్రం';
11054 } else {
11055 return 'రాత్రి';
11056 }
11057 },
11058 week : {
11059 dow : 0, // Sunday is the first day of the week.
11060 doy : 6 // The week that contains Jan 1st is the first week of the year.
11061 }
11062 });
11064 //! moment.js locale configuration
11065 //! locale : thai (th)
11066 //! author : Kridsada Thanabulpong : https://github.com/sirn
11068 var th = moment__default.defineLocale('th', {
11069 months : 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
11070 monthsShort : 'มกรา_กุมภา_มีนา_เมษา_พฤษภา_มิถุนา_กรกฎา_สิงหา_กันยา_ตุลา_พฤศจิกา_ธันวา'.split('_'),
11071 monthsParseExact: true,
11072 weekdays : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
11073 weekdaysShort : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
11074 weekdaysMin : 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
11075 weekdaysParseExact : true,
11076 longDateFormat : {
11077 LT : 'H นาฬิกา m นาที',
11078 LTS : 'H นาฬิกา m นาที s วินาที',
11079 L : 'YYYY/MM/DD',
11080 LL : 'D MMMM YYYY',
11081 LLL : 'D MMMM YYYY เวลา H นาฬิกา m นาที',
11082 LLLL : 'วันddddที่ D MMMM YYYY เวลา H นาฬิกา m นาที'
11083 },
11084 meridiemParse: /ก่อนเที่ยง|หลังเที่ยง/,
11085 isPM: function (input) {
11086 return input === 'หลังเที่ยง';
11087 },
11088 meridiem : function (hour, minute, isLower) {
11089 if (hour < 12) {
11090 return 'ก่อนเที่ยง';
11091 } else {
11092 return 'หลังเที่ยง';
11093 }
11094 },
11095 calendar : {
11096 sameDay : '[วันนี้ เวลา] LT',
11097 nextDay : '[พรุ่งนี้ เวลา] LT',
11098 nextWeek : 'dddd[หน้า เวลา] LT',
11099 lastDay : '[เมื่อวานนี้ เวลา] LT',
11100 lastWeek : '[วัน]dddd[ที่แล้ว เวลา] LT',
11101 sameElse : 'L'
11102 },
11103 relativeTime : {
11104 future : 'อีก %s',
11105 past : '%sที่แล้ว',
11106 s : 'ไม่กี่วินาที',
11107 m : '1 นาที',
11108 mm : '%d นาที',
11109 h : '1 ชั่วโมง',
11110 hh : '%d ชั่วโมง',
11111 d : '1 วัน',
11112 dd : '%d วัน',
11113 M : '1 เดือน',
11114 MM : '%d เดือน',
11115 y : '1 ปี',
11116 yy : '%d ปี'
11117 }
11118 });
11120 //! moment.js locale configuration
11121 //! locale : Tagalog/Filipino (tl-ph)
11122 //! author : Dan Hagman
11124 var tl_ph = moment__default.defineLocale('tl-ph', {
11125 months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
11126 monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
11127 weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
11128 weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
11129 weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
11130 longDateFormat : {
11131 LT : 'HH:mm',
11132 LTS : 'HH:mm:ss',
11133 L : 'MM/D/YYYY',
11134 LL : 'MMMM D, YYYY',
11135 LLL : 'MMMM D, YYYY HH:mm',
11136 LLLL : 'dddd, MMMM DD, YYYY HH:mm'
11137 },
11138 calendar : {
11139 sameDay: '[Ngayon sa] LT',
11140 nextDay: '[Bukas sa] LT',
11141 nextWeek: 'dddd [sa] LT',
11142 lastDay: '[Kahapon sa] LT',
11143 lastWeek: 'dddd [huling linggo] LT',
11144 sameElse: 'L'
11145 },
11146 relativeTime : {
11147 future : 'sa loob ng %s',
11148 past : '%s ang nakalipas',
11149 s : 'ilang segundo',
11150 m : 'isang minuto',
11151 mm : '%d minuto',
11152 h : 'isang oras',
11153 hh : '%d oras',
11154 d : 'isang araw',
11155 dd : '%d araw',
11156 M : 'isang buwan',
11157 MM : '%d buwan',
11158 y : 'isang taon',
11159 yy : '%d taon'
11160 },
11161 ordinalParse: /\d{1,2}/,
11162 ordinal : function (number) {
11163 return number;
11164 },
11165 week : {
11166 dow : 1, // Monday is the first day of the week.
11167 doy : 4 // The week that contains Jan 4th is the first week of the year.
11168 }
11169 });
11171 //! moment.js locale configuration
11172 //! locale : Klingon (tlh)
11173 //! author : Dominika Kruk : https://github.com/amaranthrose
11175 var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
11177 function translateFuture(output) {
11178 var time = output;
11179 time = (output.indexOf('jaj') !== -1) ?
11180 time.slice(0, -3) + 'leS' :
11181 (output.indexOf('jar') !== -1) ?
11182 time.slice(0, -3) + 'waQ' :
11183 (output.indexOf('DIS') !== -1) ?
11184 time.slice(0, -3) + 'nem' :
11185 time + ' pIq';
11186 return time;
11187 }
11189 function translatePast(output) {
11190 var time = output;
11191 time = (output.indexOf('jaj') !== -1) ?
11192 time.slice(0, -3) + 'Hu’' :
11193 (output.indexOf('jar') !== -1) ?
11194 time.slice(0, -3) + 'wen' :
11195 (output.indexOf('DIS') !== -1) ?
11196 time.slice(0, -3) + 'ben' :
11197 time + ' ret';
11198 return time;
11199 }
11201 function tlh__translate(number, withoutSuffix, string, isFuture) {
11202 var numberNoun = numberAsNoun(number);
11203 switch (string) {
11204 case 'mm':
11205 return numberNoun + ' tup';
11206 case 'hh':
11207 return numberNoun + ' rep';
11208 case 'dd':
11209 return numberNoun + ' jaj';
11210 case 'MM':
11211 return numberNoun + ' jar';
11212 case 'yy':
11213 return numberNoun + ' DIS';
11214 }
11215 }
11217 function numberAsNoun(number) {
11218 var hundred = Math.floor((number % 1000) / 100),
11219 ten = Math.floor((number % 100) / 10),
11220 one = number % 10,
11221 word = '';
11222 if (hundred > 0) {
11223 word += numbersNouns[hundred] + 'vatlh';
11224 }
11225 if (ten > 0) {
11226 word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH';
11227 }
11228 if (one > 0) {
11229 word += ((word !== '') ? ' ' : '') + numbersNouns[one];
11230 }
11231 return (word === '') ? 'pagh' : word;
11232 }
11234 var tlh = moment__default.defineLocale('tlh', {
11235 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('_'),
11236 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('_'),
11237 monthsParseExact : true,
11238 weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
11239 weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
11240 weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
11241 longDateFormat : {
11242 LT : 'HH:mm',
11243 LTS : 'HH:mm:ss',
11244 L : 'DD.MM.YYYY',
11245 LL : 'D MMMM YYYY',
11246 LLL : 'D MMMM YYYY HH:mm',
11247 LLLL : 'dddd, D MMMM YYYY HH:mm'
11248 },
11249 calendar : {
11250 sameDay: '[DaHjaj] LT',
11251 nextDay: '[wa’leS] LT',
11252 nextWeek: 'LLL',
11253 lastDay: '[wa’Hu’] LT',
11254 lastWeek: 'LLL',
11255 sameElse: 'L'
11256 },
11257 relativeTime : {
11258 future : translateFuture,
11259 past : translatePast,
11260 s : 'puS lup',
11261 m : 'wa’ tup',
11262 mm : tlh__translate,
11263 h : 'wa’ rep',
11264 hh : tlh__translate,
11265 d : 'wa’ jaj',
11266 dd : tlh__translate,
11267 M : 'wa’ jar',
11268 MM : tlh__translate,
11269 y : 'wa’ DIS',
11270 yy : tlh__translate
11271 },
11272 ordinalParse: /\d{1,2}\./,
11273 ordinal : '%d.',
11274 week : {
11275 dow : 1, // Monday is the first day of the week.
11276 doy : 4 // The week that contains Jan 4th is the first week of the year.
11277 }
11278 });
11280 //! moment.js locale configuration
11281 //! locale : turkish (tr)
11282 //! authors : Erhan Gundogan : https://github.com/erhangundogan,
11283 //! Burak Yiğit Kaya: https://github.com/BYK
11285 var tr__suffixes = {
11286 1: '\'inci',
11287 5: '\'inci',
11288 8: '\'inci',
11289 70: '\'inci',
11290 80: '\'inci',
11291 2: '\'nci',
11292 7: '\'nci',
11293 20: '\'nci',
11294 50: '\'nci',
11295 3: '\'üncü',
11296 4: '\'üncü',
11297 100: '\'üncü',
11298 6: '\'ncı',
11299 9: '\'uncu',
11300 10: '\'uncu',
11301 30: '\'uncu',
11302 60: '\'ıncı',
11303 90: '\'ıncı'
11304 };
11306 var tr = moment__default.defineLocale('tr', {
11307 months : 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
11308 monthsShort : 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
11309 weekdays : 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
11310 weekdaysShort : 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
11311 weekdaysMin : 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
11312 longDateFormat : {
11313 LT : 'HH:mm',
11314 LTS : 'HH:mm:ss',
11315 L : 'DD.MM.YYYY',
11316 LL : 'D MMMM YYYY',
11317 LLL : 'D MMMM YYYY HH:mm',
11318 LLLL : 'dddd, D MMMM YYYY HH:mm'
11319 },
11320 calendar : {
11321 sameDay : '[bugün saat] LT',
11322 nextDay : '[yarın saat] LT',
11323 nextWeek : '[haftaya] dddd [saat] LT',
11324 lastDay : '[dün] LT',
11325 lastWeek : '[geçen hafta] dddd [saat] LT',
11326 sameElse : 'L'
11327 },
11328 relativeTime : {
11329 future : '%s sonra',
11330 past : '%s önce',
11331 s : 'birkaç saniye',
11332 m : 'bir dakika',
11333 mm : '%d dakika',
11334 h : 'bir saat',
11335 hh : '%d saat',
11336 d : 'bir gün',
11337 dd : '%d gün',
11338 M : 'bir ay',
11339 MM : '%d ay',
11340 y : 'bir yıl',
11341 yy : '%d yıl'
11342 },
11343 ordinalParse: /\d{1,2}'(inci|nci|üncü|ncı|uncu|ıncı)/,
11344 ordinal : function (number) {
11345 if (number === 0) { // special case for zero
11346 return number + '\'ıncı';
11347 }
11348 var a = number % 10,
11349 b = number % 100 - a,
11350 c = number >= 100 ? 100 : null;
11351 return number + (tr__suffixes[a] || tr__suffixes[b] || tr__suffixes[c]);
11352 },
11353 week : {
11354 dow : 1, // Monday is the first day of the week.
11355 doy : 7 // The week that contains Jan 1st is the first week of the year.
11356 }
11357 });
11359 //! moment.js locale configuration
11360 //! locale : talossan (tzl)
11361 //! author : Robin van der Vliet : https://github.com/robin0van0der0v with the help of Iustì Canun
11364 // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
11365 // This is currently too difficult (maybe even impossible) to add.
11366 var tzl = moment__default.defineLocale('tzl', {
11367 months : 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'),
11368 monthsShort : 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
11369 weekdays : 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
11370 weekdaysShort : 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
11371 weekdaysMin : 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
11372 longDateFormat : {
11373 LT : 'HH.mm',
11374 LTS : 'HH.mm.ss',
11375 L : 'DD.MM.YYYY',
11376 LL : 'D. MMMM [dallas] YYYY',
11377 LLL : 'D. MMMM [dallas] YYYY HH.mm',
11378 LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
11379 },
11380 meridiemParse: /d\'o|d\'a/i,
11381 isPM : function (input) {
11382 return 'd\'o' === input.toLowerCase();
11383 },
11384 meridiem : function (hours, minutes, isLower) {
11385 if (hours > 11) {
11386 return isLower ? 'd\'o' : 'D\'O';
11387 } else {
11388 return isLower ? 'd\'a' : 'D\'A';
11389 }
11390 },
11391 calendar : {
11392 sameDay : '[oxhi à] LT',
11393 nextDay : '[demà à] LT',
11394 nextWeek : 'dddd [à] LT',
11395 lastDay : '[ieiri à] LT',
11396 lastWeek : '[sür el] dddd [lasteu à] LT',
11397 sameElse : 'L'
11398 },
11399 relativeTime : {
11400 future : 'osprei %s',
11401 past : 'ja%s',
11402 s : tzl__processRelativeTime,
11403 m : tzl__processRelativeTime,
11404 mm : tzl__processRelativeTime,
11405 h : tzl__processRelativeTime,
11406 hh : tzl__processRelativeTime,
11407 d : tzl__processRelativeTime,
11408 dd : tzl__processRelativeTime,
11409 M : tzl__processRelativeTime,
11410 MM : tzl__processRelativeTime,
11411 y : tzl__processRelativeTime,
11412 yy : tzl__processRelativeTime
11413 },
11414 ordinalParse: /\d{1,2}\./,
11415 ordinal : '%d.',
11416 week : {
11417 dow : 1, // Monday is the first day of the week.
11418 doy : 4 // The week that contains Jan 4th is the first week of the year.
11419 }
11420 });
11422 function tzl__processRelativeTime(number, withoutSuffix, key, isFuture) {
11423 var format = {
11424 's': ['viensas secunds', '\'iensas secunds'],
11425 'm': ['\'n míut', '\'iens míut'],
11426 'mm': [number + ' míuts', '' + number + ' míuts'],
11427 'h': ['\'n þora', '\'iensa þora'],
11428 'hh': [number + ' þoras', '' + number + ' þoras'],
11429 'd': ['\'n ziua', '\'iensa ziua'],
11430 'dd': [number + ' ziuas', '' + number + ' ziuas'],
11431 'M': ['\'n mes', '\'iens mes'],
11432 'MM': [number + ' mesen', '' + number + ' mesen'],
11433 'y': ['\'n ar', '\'iens ar'],
11434 'yy': [number + ' ars', '' + number + ' ars']
11435 };
11436 return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]);
11437 }
11439 //! moment.js locale configuration
11440 //! locale : Morocco Central Atlas Tamaziɣt in Latin (tzm-latn)
11441 //! author : Abdel Said : https://github.com/abdelsaid
11443 var tzm_latn = moment__default.defineLocale('tzm-latn', {
11444 months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
11445 monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
11446 weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
11447 weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
11448 weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
11449 longDateFormat : {
11450 LT : 'HH:mm',
11451 LTS : 'HH:mm:ss',
11452 L : 'DD/MM/YYYY',
11453 LL : 'D MMMM YYYY',
11454 LLL : 'D MMMM YYYY HH:mm',
11455 LLLL : 'dddd D MMMM YYYY HH:mm'
11456 },
11457 calendar : {
11458 sameDay: '[asdkh g] LT',
11459 nextDay: '[aska g] LT',
11460 nextWeek: 'dddd [g] LT',
11461 lastDay: '[assant g] LT',
11462 lastWeek: 'dddd [g] LT',
11463 sameElse: 'L'
11464 },
11465 relativeTime : {
11466 future : 'dadkh s yan %s',
11467 past : 'yan %s',
11468 s : 'imik',
11469 m : 'minuḍ',
11470 mm : '%d minuḍ',
11471 h : 'saɛa',
11472 hh : '%d tassaɛin',
11473 d : 'ass',
11474 dd : '%d ossan',
11475 M : 'ayowr',
11476 MM : '%d iyyirn',
11477 y : 'asgas',
11478 yy : '%d isgasn'
11479 },
11480 week : {
11481 dow : 6, // Saturday is the first day of the week.
11482 doy : 12 // The week that contains Jan 1st is the first week of the year.
11483 }
11484 });
11486 //! moment.js locale configuration
11487 //! locale : Morocco Central Atlas Tamaziɣt (tzm)
11488 //! author : Abdel Said : https://github.com/abdelsaid
11490 var tzm = moment__default.defineLocale('tzm', {
11491 months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
11492 monthsShort : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
11493 weekdays : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
11494 weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
11495 weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
11496 longDateFormat : {
11497 LT : 'HH:mm',
11498 LTS: 'HH:mm:ss',
11499 L : 'DD/MM/YYYY',
11500 LL : 'D MMMM YYYY',
11501 LLL : 'D MMMM YYYY HH:mm',
11502 LLLL : 'dddd D MMMM YYYY HH:mm'
11503 },
11504 calendar : {
11505 sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
11506 nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
11507 nextWeek: 'dddd [ⴴ] LT',
11508 lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
11509 lastWeek: 'dddd [ⴴ] LT',
11510 sameElse: 'L'
11511 },
11512 relativeTime : {
11513 future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
11514 past : 'ⵢⴰⵏ %s',
11515 s : 'ⵉⵎⵉⴽ',
11516 m : 'ⵎⵉⵏⵓⴺ',
11517 mm : '%d ⵎⵉⵏⵓⴺ',
11518 h : 'ⵙⴰⵄⴰ',
11519 hh : '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
11520 d : 'ⴰⵙⵙ',
11521 dd : '%d oⵙⵙⴰⵏ',
11522 M : 'ⴰⵢoⵓⵔ',
11523 MM : '%d ⵉⵢⵢⵉⵔⵏ',
11524 y : 'ⴰⵙⴳⴰⵙ',
11525 yy : '%d ⵉⵙⴳⴰⵙⵏ'
11526 },
11527 week : {
11528 dow : 6, // Saturday is the first day of the week.
11529 doy : 12 // The week that contains Jan 1st is the first week of the year.
11530 }
11531 });
11533 //! moment.js locale configuration
11534 //! locale : ukrainian (uk)
11535 //! author : zemlanin : https://github.com/zemlanin
11536 //! Author : Menelion Elensúle : https://github.com/Oire
11538 function uk__plural(word, num) {
11539 var forms = word.split('_');
11540 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]);
11541 }
11542 function uk__relativeTimeWithPlural(number, withoutSuffix, key) {
11543 var format = {
11544 'mm': withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
11545 'hh': withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
11546 'dd': 'день_дні_днів',
11547 'MM': 'місяць_місяці_місяців',
11548 'yy': 'рік_роки_років'
11549 };
11550 if (key === 'm') {
11551 return withoutSuffix ? 'хвилина' : 'хвилину';
11552 }
11553 else if (key === 'h') {
11554 return withoutSuffix ? 'година' : 'годину';
11555 }
11556 else {
11557 return number + ' ' + uk__plural(format[key], +number);
11558 }
11559 }
11560 function weekdaysCaseReplace(m, format) {
11561 var weekdays = {
11562 'nominative': 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
11563 'accusative': 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split('_'),
11564 'genitive': 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split('_')
11565 },
11566 nounCase = (/(\[[ВвУу]\]) ?dddd/).test(format) ?
11567 'accusative' :
11568 ((/\[?(?:минулої|наступної)? ?\] ?dddd/).test(format) ?
11569 'genitive' :
11570 'nominative');
11571 return weekdays[nounCase][m.day()];
11572 }
11573 function processHoursFunction(str) {
11574 return function () {
11575 return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
11576 };
11577 }
11579 var uk = moment__default.defineLocale('uk', {
11580 months : {
11581 'format': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_'),
11582 'standalone': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_')
11583 },
11584 monthsShort : 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
11585 weekdays : weekdaysCaseReplace,
11586 weekdaysShort : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
11587 weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
11588 longDateFormat : {
11589 LT : 'HH:mm',
11590 LTS : 'HH:mm:ss',
11591 L : 'DD.MM.YYYY',
11592 LL : 'D MMMM YYYY р.',
11593 LLL : 'D MMMM YYYY р., HH:mm',
11594 LLLL : 'dddd, D MMMM YYYY р., HH:mm'
11595 },
11596 calendar : {
11597 sameDay: processHoursFunction('[Сьогодні '),
11598 nextDay: processHoursFunction('[Завтра '),
11599 lastDay: processHoursFunction('[Вчора '),
11600 nextWeek: processHoursFunction('[У] dddd ['),
11601 lastWeek: function () {
11602 switch (this.day()) {
11603 case 0:
11604 case 3:
11605 case 5:
11606 case 6:
11607 return processHoursFunction('[Минулої] dddd [').call(this);
11608 case 1:
11609 case 2:
11610 case 4:
11611 return processHoursFunction('[Минулого] dddd [').call(this);
11612 }
11613 },
11614 sameElse: 'L'
11615 },
11616 relativeTime : {
11617 future : 'за %s',
11618 past : '%s тому',
11619 s : 'декілька секунд',
11620 m : uk__relativeTimeWithPlural,
11621 mm : uk__relativeTimeWithPlural,
11622 h : 'годину',
11623 hh : uk__relativeTimeWithPlural,
11624 d : 'день',
11625 dd : uk__relativeTimeWithPlural,
11626 M : 'місяць',
11627 MM : uk__relativeTimeWithPlural,
11628 y : 'рік',
11629 yy : uk__relativeTimeWithPlural
11630 },
11631 // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
11632 meridiemParse: /ночі|ранку|дня|вечора/,
11633 isPM: function (input) {
11634 return /^(дня|вечора)$/.test(input);
11635 },
11636 meridiem : function (hour, minute, isLower) {
11637 if (hour < 4) {
11638 return 'ночі';
11639 } else if (hour < 12) {
11640 return 'ранку';
11641 } else if (hour < 17) {
11642 return 'дня';
11643 } else {
11644 return 'вечора';
11645 }
11646 },
11647 ordinalParse: /\d{1,2}-(й|го)/,
11648 ordinal: function (number, period) {
11649 switch (period) {
11650 case 'M':
11651 case 'd':
11652 case 'DDD':
11653 case 'w':
11654 case 'W':
11655 return number + '-й';
11656 case 'D':
11657 return number + '-го';
11658 default:
11659 return number;
11660 }
11661 },
11662 week : {
11663 dow : 1, // Monday is the first day of the week.
11664 doy : 7 // The week that contains Jan 1st is the first week of the year.
11665 }
11666 });
11668 //! moment.js locale configuration
11669 //! locale : uzbek (uz)
11670 //! author : Sardor Muminov : https://github.com/muminoff
11672 var uz = moment__default.defineLocale('uz', {
11673 months : 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
11674 monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
11675 weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
11676 weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
11677 weekdaysMin : 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
11678 longDateFormat : {
11679 LT : 'HH:mm',
11680 LTS : 'HH:mm:ss',
11681 L : 'DD/MM/YYYY',
11682 LL : 'D MMMM YYYY',
11683 LLL : 'D MMMM YYYY HH:mm',
11684 LLLL : 'D MMMM YYYY, dddd HH:mm'
11685 },
11686 calendar : {
11687 sameDay : '[Бугун соат] LT [да]',
11688 nextDay : '[Эртага] LT [да]',
11689 nextWeek : 'dddd [куни соат] LT [да]',
11690 lastDay : '[Кеча соат] LT [да]',
11691 lastWeek : '[Утган] dddd [куни соат] LT [да]',
11692 sameElse : 'L'
11693 },
11694 relativeTime : {
11695 future : 'Якин %s ичида',
11696 past : 'Бир неча %s олдин',
11697 s : 'фурсат',
11698 m : 'бир дакика',
11699 mm : '%d дакика',
11700 h : 'бир соат',
11701 hh : '%d соат',
11702 d : 'бир кун',
11703 dd : '%d кун',
11704 M : 'бир ой',
11705 MM : '%d ой',
11706 y : 'бир йил',
11707 yy : '%d йил'
11708 },
11709 week : {
11710 dow : 1, // Monday is the first day of the week.
11711 doy : 7 // The week that contains Jan 4th is the first week of the year.
11712 }
11713 });
11715 //! moment.js locale configuration
11716 //! locale : vietnamese (vi)
11717 //! author : Bang Nguyen : https://github.com/bangnk
11719 var vi = moment__default.defineLocale('vi', {
11720 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('_'),
11721 monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
11722 monthsParseExact : true,
11723 weekdays : 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
11724 weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
11725 weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
11726 weekdaysParseExact : true,
11727 meridiemParse: /sa|ch/i,
11728 isPM : function (input) {
11729 return /^ch$/i.test(input);
11730 },
11731 meridiem : function (hours, minutes, isLower) {
11732 if (hours < 12) {
11733 return isLower ? 'sa' : 'SA';
11734 } else {
11735 return isLower ? 'ch' : 'CH';
11736 }
11737 },
11738 longDateFormat : {
11739 LT : 'HH:mm',
11740 LTS : 'HH:mm:ss',
11741 L : 'DD/MM/YYYY',
11742 LL : 'D MMMM [năm] YYYY',
11743 LLL : 'D MMMM [năm] YYYY HH:mm',
11744 LLLL : 'dddd, D MMMM [năm] YYYY HH:mm',
11745 l : 'DD/M/YYYY',
11746 ll : 'D MMM YYYY',
11747 lll : 'D MMM YYYY HH:mm',
11748 llll : 'ddd, D MMM YYYY HH:mm'
11749 },
11750 calendar : {
11751 sameDay: '[Hôm nay lúc] LT',
11752 nextDay: '[Ngày mai lúc] LT',
11753 nextWeek: 'dddd [tuần tới lúc] LT',
11754 lastDay: '[Hôm qua lúc] LT',
11755 lastWeek: 'dddd [tuần rồi lúc] LT',
11756 sameElse: 'L'
11757 },
11758 relativeTime : {
11759 future : '%s tới',
11760 past : '%s trước',
11761 s : 'vài giây',
11762 m : 'một phút',
11763 mm : '%d phút',
11764 h : 'một giờ',
11765 hh : '%d giờ',
11766 d : 'một ngày',
11767 dd : '%d ngày',
11768 M : 'một tháng',
11769 MM : '%d tháng',
11770 y : 'một năm',
11771 yy : '%d năm'
11772 },
11773 ordinalParse: /\d{1,2}/,
11774 ordinal : function (number) {
11775 return number;
11776 },
11777 week : {
11778 dow : 1, // Monday is the first day of the week.
11779 doy : 4 // The week that contains Jan 4th is the first week of the year.
11780 }
11781 });
11783 //! moment.js locale configuration
11784 //! locale : pseudo (x-pseudo)
11785 //! author : Andrew Hood : https://github.com/andrewhood125
11787 var x_pseudo = moment__default.defineLocale('x-pseudo', {
11788 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('_'),
11789 monthsShort : 'J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc'.split('_'),
11790 monthsParseExact : true,
11791 weekdays : 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý'.split('_'),
11792 weekdaysShort : 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát'.split('_'),
11793 weekdaysMin : 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
11794 weekdaysParseExact : true,
11795 longDateFormat : {
11796 LT : 'HH:mm',
11797 L : 'DD/MM/YYYY',
11798 LL : 'D MMMM YYYY',
11799 LLL : 'D MMMM YYYY HH:mm',
11800 LLLL : 'dddd, D MMMM YYYY HH:mm'
11801 },
11802 calendar : {
11803 sameDay : '[T~ódá~ý át] LT',
11804 nextDay : '[T~ómó~rró~w át] LT',
11805 nextWeek : 'dddd [át] LT',
11806 lastDay : '[Ý~ést~érdá~ý át] LT',
11807 lastWeek : '[L~ást] dddd [át] LT',
11808 sameElse : 'L'
11809 },
11810 relativeTime : {
11811 future : 'í~ñ %s',
11812 past : '%s á~gó',
11813 s : 'á ~féw ~sécó~ñds',
11814 m : 'á ~míñ~úté',
11815 mm : '%d m~íñú~tés',
11816 h : 'á~ñ hó~úr',
11817 hh : '%d h~óúrs',
11818 d : 'á ~dáý',
11819 dd : '%d d~áýs',
11820 M : 'á ~móñ~th',
11821 MM : '%d m~óñt~hs',
11822 y : 'á ~ýéár',
11823 yy : '%d ý~éárs'
11824 },
11825 ordinalParse: /\d{1,2}(th|st|nd|rd)/,
11826 ordinal : function (number) {
11827 var b = number % 10,
11828 output = (~~(number % 100 / 10) === 1) ? 'th' :
11829 (b === 1) ? 'st' :
11830 (b === 2) ? 'nd' :
11831 (b === 3) ? 'rd' : 'th';
11832 return number + output;
11833 },
11834 week : {
11835 dow : 1, // Monday is the first day of the week.
11836 doy : 4 // The week that contains Jan 4th is the first week of the year.
11837 }
11838 });
11840 //! moment.js locale configuration
11841 //! locale : chinese (zh-cn)
11842 //! author : suupic : https://github.com/suupic
11843 //! author : Zeno Zeng : https://github.com/zenozeng
11845 var zh_cn = moment__default.defineLocale('zh-cn', {
11846 months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
11847 monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
11848 weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
11849 weekdaysShort : '周日_周一_周二_周三_周四_周五_周六'.split('_'),
11850 weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
11851 longDateFormat : {
11852 LT : 'Ah点mm分',
11853 LTS : 'Ah点m分s秒',
11854 L : 'YYYY-MM-DD',
11855 LL : 'YYYY年MMMD日',
11856 LLL : 'YYYY年MMMD日Ah点mm分',
11857 LLLL : 'YYYY年MMMD日ddddAh点mm分',
11858 l : 'YYYY-MM-DD',
11859 ll : 'YYYY年MMMD日',
11860 lll : 'YYYY年MMMD日Ah点mm分',
11861 llll : 'YYYY年MMMD日ddddAh点mm分'
11862 },
11863 meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
11864 meridiemHour: function (hour, meridiem) {
11865 if (hour === 12) {
11866 hour = 0;
11867 }
11868 if (meridiem === '凌晨' || meridiem === '早上' ||
11869 meridiem === '上午') {
11870 return hour;
11871 } else if (meridiem === '下午' || meridiem === '晚上') {
11872 return hour + 12;
11873 } else {
11874 // '中午'
11875 return hour >= 11 ? hour : hour + 12;
11876 }
11877 },
11878 meridiem : function (hour, minute, isLower) {
11879 var hm = hour * 100 + minute;
11880 if (hm < 600) {
11881 return '凌晨';
11882 } else if (hm < 900) {
11883 return '早上';
11884 } else if (hm < 1130) {
11885 return '上午';
11886 } else if (hm < 1230) {
11887 return '中午';
11888 } else if (hm < 1800) {
11889 return '下午';
11890 } else {
11891 return '晚上';
11892 }
11893 },
11894 calendar : {
11895 sameDay : function () {
11896 return this.minutes() === 0 ? '[今天]Ah[点整]' : '[今天]LT';
11897 },
11898 nextDay : function () {
11899 return this.minutes() === 0 ? '[明天]Ah[点整]' : '[明天]LT';
11900 },
11901 lastDay : function () {
11902 return this.minutes() === 0 ? '[昨天]Ah[点整]' : '[昨天]LT';
11903 },
11904 nextWeek : function () {
11905 var startOfWeek, prefix;
11906 startOfWeek = moment__default().startOf('week');
11907 prefix = this.diff(startOfWeek, 'days') >= 7 ? '[下]' : '[本]';
11908 return this.minutes() === 0 ? prefix + 'dddAh点整' : prefix + 'dddAh点mm';
11909 },
11910 lastWeek : function () {
11911 var startOfWeek, prefix;
11912 startOfWeek = moment__default().startOf('week');
11913 prefix = this.unix() < startOfWeek.unix() ? '[上]' : '[本]';
11914 return this.minutes() === 0 ? prefix + 'dddAh点整' : prefix + 'dddAh点mm';
11915 },
11916 sameElse : 'LL'
11917 },
11918 ordinalParse: /\d{1,2}(日|月|周)/,
11919 ordinal : function (number, period) {
11920 switch (period) {
11921 case 'd':
11922 case 'D':
11923 case 'DDD':
11924 return number + '日';
11925 case 'M':
11926 return number + '月';
11927 case 'w':
11928 case 'W':
11929 return number + '周';
11930 default:
11931 return number;
11932 }
11933 },
11934 relativeTime : {
11935 future : '%s内',
11936 past : '%s前',
11937 s : '几秒',
11938 m : '1 分钟',
11939 mm : '%d 分钟',
11940 h : '1 小时',
11941 hh : '%d 小时',
11942 d : '1 天',
11943 dd : '%d 天',
11944 M : '1 个月',
11945 MM : '%d 个月',
11946 y : '1 年',
11947 yy : '%d 年'
11948 },
11949 week : {
11950 // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
11951 dow : 1, // Monday is the first day of the week.
11952 doy : 4 // The week that contains Jan 4th is the first week of the year.
11953 }
11954 });
11956 //! moment.js locale configuration
11957 //! locale : traditional chinese (zh-tw)
11958 //! author : Ben : https://github.com/ben-lin
11960 var zh_tw = moment__default.defineLocale('zh-tw', {
11961 months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
11962 monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
11963 weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
11964 weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
11965 weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
11966 longDateFormat : {
11967 LT : 'Ah點mm分',
11968 LTS : 'Ah點m分s秒',
11969 L : 'YYYY年MMMD日',
11970 LL : 'YYYY年MMMD日',
11971 LLL : 'YYYY年MMMD日Ah點mm分',
11972 LLLL : 'YYYY年MMMD日ddddAh點mm分',
11973 l : 'YYYY年MMMD日',
11974 ll : 'YYYY年MMMD日',
11975 lll : 'YYYY年MMMD日Ah點mm分',
11976 llll : 'YYYY年MMMD日ddddAh點mm分'
11977 },
11978 meridiemParse: /早上|上午|中午|下午|晚上/,
11979 meridiemHour : function (hour, meridiem) {
11980 if (hour === 12) {
11981 hour = 0;
11982 }
11983 if (meridiem === '早上' || meridiem === '上午') {
11984 return hour;
11985 } else if (meridiem === '中午') {
11986 return hour >= 11 ? hour : hour + 12;
11987 } else if (meridiem === '下午' || meridiem === '晚上') {
11988 return hour + 12;
11989 }
11990 },
11991 meridiem : function (hour, minute, isLower) {
11992 var hm = hour * 100 + minute;
11993 if (hm < 900) {
11994 return '早上';
11995 } else if (hm < 1130) {
11996 return '上午';
11997 } else if (hm < 1230) {
11998 return '中午';
11999 } else if (hm < 1800) {
12000 return '下午';
12001 } else {
12002 return '晚上';
12003 }
12004 },
12005 calendar : {
12006 sameDay : '[今天]LT',
12007 nextDay : '[明天]LT',
12008 nextWeek : '[下]ddddLT',
12009 lastDay : '[昨天]LT',
12010 lastWeek : '[上]ddddLT',
12011 sameElse : 'L'
12012 },
12013 ordinalParse: /\d{1,2}(日|月|週)/,
12014 ordinal : function (number, period) {
12015 switch (period) {
12016 case 'd' :
12017 case 'D' :
12018 case 'DDD' :
12019 return number + '日';
12020 case 'M' :
12021 return number + '月';
12022 case 'w' :
12023 case 'W' :
12024 return number + '週';
12025 default :
12026 return number;
12027 }
12028 },
12029 relativeTime : {
12030 future : '%s內',
12031 past : '%s前',
12032 s : '幾秒',
12033 m : '1分鐘',
12034 mm : '%d分鐘',
12035 h : '1小時',
12036 hh : '%d小時',
12037 d : '1天',
12038 dd : '%d天',
12039 M : '1個月',
12040 MM : '%d個月',
12041 y : '1年',
12042 yy : '%d年'
12043 }
12044 });
12046 var moment_with_locales = moment__default;
12047 moment_with_locales.locale('en');
12049 return moment_with_locales;
12051 }));