moment-with-locales.js

js uv.mx collected 2026-09-24 08:35:18 UTC 425,984 bytes, 12,910 lines download raw bytes

vendor: 5,449 bytes, lines 1-225

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';
6
7var hookCallback;
8
9function hooks () {
10    return hookCallback.apply(null, arguments);
11}
12
13// This is done to register the method called with moment()
14// without creating circular dependencies.
15function setHookCallback (callback) {
16    hookCallback = callback;
17}
18
19function isArray(input) {
20    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
21}
22
23function isObject(input) {
24    // IE8 will treat undefined and null as object if it wasn't for
25    // input != null
26    return input != null && Object.prototype.toString.call(input) === '[object Object]';
27}
28
29function isObjectEmpty(obj) {
30    var k;
31    for (k in obj) {
32        // even if its not own property I'd still call it non-empty
33        return false;
34    }
35    return true;
36}
37
38function isNumber(input) {
39    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
40}
41
42function isDate(input) {
43    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
44}
45
46function map(arr, fn) {
47    var res = [], i;
48    for (i = 0; i < arr.length; ++i) {
49        res.push(fn(arr[i], i));
50    }
51    return res;
52}
53
54function hasOwnProp(a, b) {
55    return Object.prototype.hasOwnProperty.call(a, b);
56}
57
58function extend(a, b) {
59    for (var i in b) {
60        if (hasOwnProp(b, i)) {
61            a[i] = b[i];
62        }
63    }
64
65    if (hasOwnProp(b, 'toString')) {
66        a.toString = b.toString;
67    }
68
69    if (hasOwnProp(b, 'valueOf')) {
70        a.valueOf = b.valueOf;
71    }
72
73    return a;
74}
75
76function createUTC (input, format, locale, strict) {
77    return createLocalOrUTC(input, format, locale, strict, true).utc();
78}
79
80function defaultParsingFlags() {
81    // We need to deep clone this object.
82    return {
83        empty           : false,
84        unusedTokens    : [],
85        unusedInput     : [],
86        overflow        : -2,
87        charsLeftOver   : 0,
88        nullInput       : false,
89        invalidMonth    : null,
90        invalidFormat   : false,
91        userInvalidated : false,
92        iso             : false,
93        parsedDateParts : [],
94        meridiem        : null
95    };
96}
97
98function getParsingFlags(m) {
99    if (m._pf == null) {
100        m._pf = defaultParsingFlags();
101    }
102    return m._pf;
103}
104
105var some;
106if (Array.prototype.some) {
107    some = Array.prototype.some;
108} else {
109    some = function (fun) {
110        var t = Object(this);
111        var len = t.length >>> 0;
112
113        for (var i = 0; i < len; i++) {
114            if (i in t && fun.call(this, t[i], i, t)) {
115                return true;
116            }
117        }
118
119        return false;
120    };
121}
122
123var some$1 = some;
124
125function isValid(m) {
126    if (m._isValid == null) {
127        var flags = getParsingFlags(m);
128        var parsedParts = some$1.call(flags.parsedDateParts, function (i) {
129            return i != null;
130        });
131        var isNowValid = !isNaN(m._d.getTime()) &&
132            flags.overflow < 0 &&
133            !flags.empty &&
134            !flags.invalidMonth &&
135            !flags.invalidWeekday &&
136            !flags.nullInput &&
137            !flags.invalidFormat &&
138            !flags.userInvalidated &&
139            (!flags.meridiem || (flags.meridiem && parsedParts));
140
141        if (m._strict) {
142            isNowValid = isNowValid &&
143                flags.charsLeftOver === 0 &&
144                flags.unusedTokens.length === 0 &&
145                flags.bigHour === undefined;
146        }
147
148        if (Object.isFrozen == null || !Object.isFrozen(m)) {
149            m._isValid = isNowValid;
150        }
151        else {
152            return isNowValid;
153        }
154    }
155    return m._isValid;
156}
157
158function createInvalid (flags) {
159    var m = createUTC(NaN);
160    if (flags != null) {
161        extend(getParsingFlags(m), flags);
162    }
163    else {
164        getParsingFlags(m).userInvalidated = true;
165    }
166
167    return m;
168}
169
170function isUndefined(input) {
171    return input === void 0;
172}
173
174// Plugins that add properties should also add the key here (null value),
175// so we can properly clone ourselves.
176var momentProperties = hooks.momentProperties = [];
177
178function copyConfig(to, from) {
179    var i, prop, val;
180
181    if (!isUndefined(from._isAMomentObject)) {
182        to._isAMomentObject = from._isAMomentObject;
183    }
184    if (!isUndefined(from._i)) {
185        to._i = from._i;
186    }
187    if (!isUndefined(from._f)) {
188        to._f = from._f;
189    }
190    if (!isUndefined(from._l)) {
191        to._l = from._l;
192    }
193    if (!isUndefined(from._strict)) {
194        to._strict = from._strict;
195    }
196    if (!isUndefined(from._tzm)) {
197        to._tzm = from._tzm;
198    }
199    if (!isUndefined(from._isUTC)) {
200        to._isUTC = from._isUTC;
201    }
202    if (!isUndefined(from._offset)) {
203        to._offset = from._offset;
204    }
205    if (!isUndefined(from._pf)) {
206        to._pf = getParsingFlags(from);
207    }
208    if (!isUndefined(from._locale)) {
209        to._locale = from._locale;
210    }
211
212    if (momentProperties.length > 0) {
213        for (i in momentProperties) {
214            prop = momentProperties[i];
215            val = from[prop];
216            if (!isUndefined(val)) {
217                to[prop] = val;
218            }
219        }
220    }
221
222    return to;
223}
224
225var updateInProgress = false;

vendor: 81,870 bytes, lines 226-2989

226
227// Moment prototype object
228function Moment(config) {
229    copyConfig(this, config);
230    this._d = new Date(config._d != null ? config._d.getTime() : NaN);
231    if (!this.isValid()) {
232        this._d = new Date(NaN);
233    }
234    // Prevent infinite loop in case updateOffset creates new moment
235    // objects.
236    if (updateInProgress === false) {
237        updateInProgress = true;
238        hooks.updateOffset(this);
239        updateInProgress = false;
240    }
241}
242
243function isMoment (obj) {
244    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
245}
246
247function absFloor (number) {
248    if (number < 0) {
249        // -0 -> 0
250        return Math.ceil(number) || 0;
251    } else {
252        return Math.floor(number);
253    }
254}
255
256function toInt(argumentForCoercion) {
257    var coercedNumber = +argumentForCoercion,
258        value = 0;
259
260    if (coercedNumber !== 0 && isFinite(coercedNumber)) {
261        value = absFloor(coercedNumber);
262    }
263
264    return value;
265}
266
267// compare two arrays, return the number of differences
268function compareArrays(array1, array2, dontConvert) {
269    var len = Math.min(array1.length, array2.length),
270        lengthDiff = Math.abs(array1.length - array2.length),
271        diffs = 0,
272        i;
273    for (i = 0; i < len; i++) {
274        if ((dontConvert && array1[i] !== array2[i]) ||
275            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
276            diffs++;
277        }
278    }
279    return diffs + lengthDiff;
280}
281
282function warn(msg) {
283    if (hooks.suppressDeprecationWarnings === false &&
284            (typeof console !==  'undefined') && console.warn) {
285        console.warn('Deprecation warning: ' + msg);
286    }
287}
288
289function deprecate(msg, fn) {
290    var firstTime = true;
291
292    return extend(function () {
293        if (hooks.deprecationHandler != null) {
294            hooks.deprecationHandler(null, msg);
295        }
296        if (firstTime) {
297            var args = [];
298            var arg;
299            for (var i = 0; i < arguments.length; i++) {
300                arg = '';
301                if (typeof arguments[i] === 'object') {
302                    arg += '\n[' + i + '] ';
303                    for (var key in arguments[0]) {
304                        arg += key + ': ' + arguments[0][key] + ', ';
305                    }
306                    arg = arg.slice(0, -2); // Remove trailing comma and space
307                } else {
308                    arg = arguments[i];
309                }
310                args.push(arg);
311            }
312            warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
313            firstTime = false;
314        }
315        return fn.apply(this, arguments);
316    }, fn);
317}
318
319var deprecations = {};
320
321function deprecateSimple(name, msg) {
322    if (hooks.deprecationHandler != null) {
323        hooks.deprecationHandler(name, msg);
324    }
325    if (!deprecations[name]) {
326        warn(msg);
327        deprecations[name] = true;
328    }
329}
330
331hooks.suppressDeprecationWarnings = false;
332hooks.deprecationHandler = null;
333
334function isFunction(input) {
335    return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
336}
337
338function set (config) {
339    var prop, i;
340    for (i in config) {
341        prop = config[i];
342        if (isFunction(prop)) {
343            this[i] = prop;
344        } else {
345            this['_' + i] = prop;
346        }
347    }
348    this._config = config;
349    // Lenient ordinal parsing accepts just a number in addition to
350    // number + (possibly) stuff coming from _ordinalParseLenient.
351    this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
352}
353
354function mergeConfigs(parentConfig, childConfig) {
355    var res = extend({}, parentConfig), prop;
356    for (prop in childConfig) {
357        if (hasOwnProp(childConfig, prop)) {
358            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
359                res[prop] = {};
360                extend(res[prop], parentConfig[prop]);
361                extend(res[prop], childConfig[prop]);
362            } else if (childConfig[prop] != null) {
363                res[prop] = childConfig[prop];
364            } else {
365                delete res[prop];
366            }
367        }
368    }
369    for (prop in parentConfig) {
370        if (hasOwnProp(parentConfig, prop) &&
371                !hasOwnProp(childConfig, prop) &&
372                isObject(parentConfig[prop])) {
373            // make sure changes to properties don't modify parent config
374            res[prop] = extend({}, res[prop]);
375        }
376    }
377    return res;
378}
379
380function Locale(config) {
381    if (config != null) {
382        this.set(config);
383    }
384}
385
386var keys;
387
388if (Object.keys) {
389    keys = Object.keys;
390} else {
391    keys = function (obj) {
392        var i, res = [];
393        for (i in obj) {
394            if (hasOwnProp(obj, i)) {
395                res.push(i);
396            }
397        }
398        return res;
399    };
400}
401
402var keys$1 = keys;
403
404var defaultCalendar = {
405    sameDay : '[Today at] LT',
406    nextDay : '[Tomorrow at] LT',
407    nextWeek : 'dddd [at] LT',
408    lastDay : '[Yesterday at] LT',
409    lastWeek : '[Last] dddd [at] LT',
410    sameElse : 'L'
411};
412
413function calendar (key, mom, now) {
414    var output = this._calendar[key] || this._calendar['sameElse'];
415    return isFunction(output) ? output.call(mom, now) : output;
416}
417
418var defaultLongDateFormat = {
419    LTS  : 'h:mm:ss A',
420    LT   : 'h:mm A',
421    L    : 'MM/DD/YYYY',
422    LL   : 'MMMM D, YYYY',
423    LLL  : 'MMMM D, YYYY h:mm A',
424    LLLL : 'dddd, MMMM D, YYYY h:mm A'
425};
426
427function longDateFormat (key) {
428    var format = this._longDateFormat[key],
429        formatUpper = this._longDateFormat[key.toUpperCase()];
430
431    if (format || !formatUpper) {
432        return format;
433    }
434
435    this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
436        return val.slice(1);
437    });
438
439    return this._longDateFormat[key];
440}
441
442var defaultInvalidDate = 'Invalid date';
443
444function invalidDate () {
445    return this._invalidDate;
446}
447
448var defaultOrdinal = '%d';
449var defaultOrdinalParse = /\d{1,2}/;
450
451function ordinal (number) {
452    return this._ordinal.replace('%d', number);
453}
454
455var defaultRelativeTime = {
456    future : 'in %s',
457    past   : '%s ago',
458    s  : 'a few seconds',
459    m  : 'a minute',
460    mm : '%d minutes',
461    h  : 'an hour',
462    hh : '%d hours',
463    d  : 'a day',
464    dd : '%d days',
465    M  : 'a month',
466    MM : '%d months',
467    y  : 'a year',
468    yy : '%d years'
469};
470
471function relativeTime (number, withoutSuffix, string, isFuture) {
472    var output = this._relativeTime[string];
473    return (isFunction(output)) ?
474        output(number, withoutSuffix, string, isFuture) :
475        output.replace(/%d/i, number);
476}
477
478function pastFuture (diff, output) {
479    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
480    return isFunction(format) ? format(output) : format.replace(/%s/i, output);
481}
482
483var aliases = {};
484
485function addUnitAlias (unit, shorthand) {
486    var lowerCase = unit.toLowerCase();
487    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
488}
489
490function normalizeUnits(units) {
491    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
492}
493
494function normalizeObjectUnits(inputObject) {
495    var normalizedInput = {},
496        normalizedProp,
497        prop;
498
499    for (prop in inputObject) {
500        if (hasOwnProp(inputObject, prop)) {
501            normalizedProp = normalizeUnits(prop);
502            if (normalizedProp) {
503                normalizedInput[normalizedProp] = inputObject[prop];
504            }
505        }
506    }
507
508    return normalizedInput;
509}
510
511var priorities = {};
512
513function addUnitPriority(unit, priority) {
514    priorities[unit] = priority;
515}
516
517function getPrioritizedUnits(unitsObj) {
518    var units = [];
519    for (var u in unitsObj) {
520        units.push({unit: u, priority: priorities[u]});
521    }
522    units.sort(function (a, b) {
523        return a.priority - b.priority;
524    });
525    return units;
526}
527
528function makeGetSet (unit, keepTime) {
529    return function (value) {
530        if (value != null) {
531            set$1(this, unit, value);
532            hooks.updateOffset(this, keepTime);
533            return this;
534        } else {
535            return get(this, unit);
536        }
537    };
538}
539
540function get (mom, unit) {
541    return mom.isValid() ?
542        mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
543}
544
545function set$1 (mom, unit, value) {
546    if (mom.isValid()) {
547        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
548    }
549}
550
551// MOMENTS
552
553function stringGet (units) {
554    units = normalizeUnits(units);
555    if (isFunction(this[units])) {
556        return this[units]();
557    }
558    return this;
559}
560
561
562function stringSet (units, value) {
563    if (typeof units === 'object') {
564        units = normalizeObjectUnits(units);
565        var prioritized = getPrioritizedUnits(units);
566        for (var i = 0; i < prioritized.length; i++) {
567            this[prioritized[i].unit](units[prioritized[i].unit]);
568        }
569    } else {
570        units = normalizeUnits(units);
571        if (isFunction(this[units])) {
572            return this[units](value);
573        }
574    }
575    return this;
576}
577
578function zeroFill(number, targetLength, forceSign) {
579    var absNumber = '' + Math.abs(number),
580        zerosToFill = targetLength - absNumber.length,
581        sign = number >= 0;
582    return (sign ? (forceSign ? '+' : '') : '-') +
583        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
584}
585
586var 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;
587
588var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
589
590var formatFunctions = {};
591
592var formatTokenFunctions = {};
593
594// token:    'M'
595// padded:   ['MM', 2]
596// ordinal:  'Mo'
597// callback: function () { this.month() + 1 }
598function addFormatToken (token, padded, ordinal, callback) {
599    var func = callback;
600    if (typeof callback === 'string') {
601        func = function () {
602            return this[callback]();
603        };
604    }
605    if (token) {
606        formatTokenFunctions[token] = func;
607    }
608    if (padded) {
609        formatTokenFunctions[padded[0]] = function () {
610            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
611        };
612    }
613    if (ordinal) {
614        formatTokenFunctions[ordinal] = function () {
615            return this.localeData().ordinal(func.apply(this, arguments), token);
616        };
617    }
618}
619
620function removeFormattingTokens(input) {
621    if (input.match(/\[[\s\S]/)) {
622        return input.replace(/^\[|\]$/g, '');
623    }
624    return input.replace(/\\/g, '');
625}
626
627function makeFormatFunction(format) {
628    var array = format.match(formattingTokens), i, length;
629
630    for (i = 0, length = array.length; i < length; i++) {
631        if (formatTokenFunctions[array[i]]) {
632            array[i] = formatTokenFunctions[array[i]];
633        } else {
634            array[i] = removeFormattingTokens(array[i]);
635        }
636    }
637
638    return function (mom) {
639        var output = '', i;
640        for (i = 0; i < length; i++) {
641            output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
642        }
643        return output;
644    };
645}
646
647// format date using native date object
648function formatMoment(m, format) {
649    if (!m.isValid()) {
650        return m.localeData().invalidDate();
651    }
652
653    format = expandFormat(format, m.localeData());
654    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
655
656    return formatFunctions[format](m);
657}
658
659function expandFormat(format, locale) {
660    var i = 5;
661
662    function replaceLongDateFormatTokens(input) {
663        return locale.longDateFormat(input) || input;
664    }
665
666    localFormattingTokens.lastIndex = 0;
667    while (i >= 0 && localFormattingTokens.test(format)) {
668        format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
669        localFormattingTokens.lastIndex = 0;
670        i -= 1;
671    }
672
673    return format;
674}
675
676var match1         = /\d/;            //       0 - 9
677var match2         = /\d\d/;          //      00 - 99
678var match3         = /\d{3}/;         //     000 - 999
679var match4         = /\d{4}/;         //    0000 - 9999
680var match6         = /[+-]?\d{6}/;    // -999999 - 999999
681var match1to2      = /\d\d?/;         //       0 - 99
682var match3to4      = /\d\d\d\d?/;     //     999 - 9999
683var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
684var match1to3      = /\d{1,3}/;       //       0 - 999
685var match1to4      = /\d{1,4}/;       //       0 - 9999
686var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
687
688var matchUnsigned  = /\d+/;           //       0 - inf
689var matchSigned    = /[+-]?\d+/;      //    -inf - inf
690
691var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
692var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
693
694var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
695
696// any word (or two) characters or numbers including two/three word month in arabic.
697// includes scottish gaelic two word and hyphenated months
698var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
699
700
701var regexes = {};
702
703function addRegexToken (token, regex, strictRegex) {
704    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
705        return (isStrict && strictRegex) ? strictRegex : regex;
706    };
707}
708
709function getParseRegexForToken (token, config) {
710    if (!hasOwnProp(regexes, token)) {
711        return new RegExp(unescapeFormat(token));
712    }
713
714    return regexes[token](config._strict, config._locale);
715}
716
717// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
718function unescapeFormat(s) {
719    return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
720        return p1 || p2 || p3 || p4;
721    }));
722}
723
724function regexEscape(s) {
725    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
726}
727
728var tokens = {};
729
730function addParseToken (token, callback) {
731    var i, func = callback;
732    if (typeof token === 'string') {
733        token = [token];
734    }
735    if (isNumber(callback)) {
736        func = function (input, array) {
737            array[callback] = toInt(input);
738        };
739    }
740    for (i = 0; i < token.length; i++) {
741        tokens[token[i]] = func;
742    }
743}
744
745function addWeekParseToken (token, callback) {
746    addParseToken(token, function (input, array, config, token) {
747        config._w = config._w || {};
748        callback(input, config._w, config, token);
749    });
750}
751
752function addTimeToArrayFromToken(token, input, config) {
753    if (input != null && hasOwnProp(tokens, token)) {
754        tokens[token](input, config._a, config, token);
755    }
756}
757
758var YEAR = 0;
759var MONTH = 1;
760var DATE = 2;
761var HOUR = 3;
762var MINUTE = 4;
763var SECOND = 5;
764var MILLISECOND = 6;
765var WEEK = 7;
766var WEEKDAY = 8;
767
768var indexOf;
769
770if (Array.prototype.indexOf) {
771    indexOf = Array.prototype.indexOf;
772} else {
773    indexOf = function (o) {
774        // I know
775        var i;
776        for (i = 0; i < this.length; ++i) {
777            if (this[i] === o) {
778                return i;
779            }
780        }
781        return -1;
782    };
783}
784
785var indexOf$1 = indexOf;
786
787function daysInMonth(year, month) {
788    return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
789}
790
791// FORMATTING
792
793addFormatToken('M', ['MM', 2], 'Mo', function () {
794    return this.month() + 1;
795});
796
797addFormatToken('MMM', 0, 0, function (format) {
798    return this.localeData().monthsShort(this, format);
799});
800
801addFormatToken('MMMM', 0, 0, function (format) {
802    return this.localeData().months(this, format);
803});
804
805// ALIASES
806
807addUnitAlias('month', 'M');
808
809// PRIORITY
810
811addUnitPriority('month', 8);
812
813// PARSING
814
815addRegexToken('M',    match1to2);
816addRegexToken('MM',   match1to2, match2);
817addRegexToken('MMM',  function (isStrict, locale) {
818    return locale.monthsShortRegex(isStrict);
819});
820addRegexToken('MMMM', function (isStrict, locale) {
821    return locale.monthsRegex(isStrict);
822});
823
824addParseToken(['M', 'MM'], function (input, array) {
825    array[MONTH] = toInt(input) - 1;
826});
827
828addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
829    var month = config._locale.monthsParse(input, token, config._strict);
830    // if we didn't find a month name, mark the date as invalid.
831    if (month != null) {
832        array[MONTH] = month;
833    } else {
834        getParsingFlags(config).invalidMonth = input;
835    }
836});
837
838// LOCALES
839
840var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
841var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
842function localeMonths (m, format) {
843    if (!m) {
844        return this._months;
845    }
846    return isArray(this._months) ? this._months[m.month()] :
847        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
848}
849
850var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
851function localeMonthsShort (m, format) {
852    if (!m) {
853        return this._monthsShort;
854    }
855    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
856        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
857}
858
859function handleStrictParse(monthName, format, strict) {
860    var i, ii, mom, llc = monthName.toLocaleLowerCase();
861    if (!this._monthsParse) {
862        // this is not used
863        this._monthsParse = [];
864        this._longMonthsParse = [];
865        this._shortMonthsParse = [];
866        for (i = 0; i < 12; ++i) {
867            mom = createUTC([2000, i]);
868            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
869            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
870        }
871    }
872
873    if (strict) {
874        if (format === 'MMM') {
875            ii = indexOf$1.call(this._shortMonthsParse, llc);
876            return ii !== -1 ? ii : null;
877        } else {
878            ii = indexOf$1.call(this._longMonthsParse, llc);
879            return ii !== -1 ? ii : null;
880        }
881    } else {
882        if (format === 'MMM') {
883            ii = indexOf$1.call(this._shortMonthsParse, llc);
884            if (ii !== -1) {
885                return ii;
886            }
887            ii = indexOf$1.call(this._longMonthsParse, llc);
888            return ii !== -1 ? ii : null;
889        } else {
890            ii = indexOf$1.call(this._longMonthsParse, llc);
891            if (ii !== -1) {
892                return ii;
893            }
894            ii = indexOf$1.call(this._shortMonthsParse, llc);
895            return ii !== -1 ? ii : null;
896        }
897    }
898}
899
900function localeMonthsParse (monthName, format, strict) {
901    var i, mom, regex;
902
903    if (this._monthsParseExact) {
904        return handleStrictParse.call(this, monthName, format, strict);
905    }
906
907    if (!this._monthsParse) {
908        this._monthsParse = [];
909        this._longMonthsParse = [];
910        this._shortMonthsParse = [];
911    }
912
913    // TODO: add sorting
914    // Sorting makes sure if one month (or abbr) is a prefix of another
915    // see sorting in computeMonthsParse
916    for (i = 0; i < 12; i++) {
917        // make the regex if we don't have it already
918        mom = createUTC([2000, i]);
919        if (strict && !this._longMonthsParse[i]) {
920            this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
921            this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
922        }
923        if (!strict && !this._monthsParse[i]) {
924            regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
925            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
926        }
927        // test the regex
928        if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
929            return i;
930        } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
931            return i;
932        } else if (!strict && this._monthsParse[i].test(monthName)) {
933            return i;
934        }
935    }
936}
937
938// MOMENTS
939
940function setMonth (mom, value) {
941    var dayOfMonth;
942
943    if (!mom.isValid()) {
944        // No op
945        return mom;
946    }
947
948    if (typeof value === 'string') {
949        if (/^\d+$/.test(value)) {
950            value = toInt(value);
951        } else {
952            value = mom.localeData().monthsParse(value);
953            // TODO: Another silent failure?
954            if (!isNumber(value)) {
955                return mom;
956            }
957        }
958    }
959
960    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
961    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
962    return mom;
963}
964
965function getSetMonth (value) {
966    if (value != null) {
967        setMonth(this, value);
968        hooks.updateOffset(this, true);
969        return this;
970    } else {
971        return get(this, 'Month');
972    }
973}
974
975function getDaysInMonth () {
976    return daysInMonth(this.year(), this.month());
977}
978
979var defaultMonthsShortRegex = matchWord;
980function monthsShortRegex (isStrict) {
981    if (this._monthsParseExact) {
982        if (!hasOwnProp(this, '_monthsRegex')) {
983            computeMonthsParse.call(this);
984        }
985        if (isStrict) {
986            return this._monthsShortStrictRegex;
987        } else {
988            return this._monthsShortRegex;
989        }
990    } else {
991        if (!hasOwnProp(this, '_monthsShortRegex')) {
992            this._monthsShortRegex = defaultMonthsShortRegex;
993        }
994        return this._monthsShortStrictRegex && isStrict ?
995            this._monthsShortStrictRegex : this._monthsShortRegex;
996    }
997}
998
999var defaultMonthsRegex = matchWord;
1000function monthsRegex (isStrict) {
1001    if (this._monthsParseExact) {
1002        if (!hasOwnProp(this, '_monthsRegex')) {
1003            computeMonthsParse.call(this);
1004        }
1005        if (isStrict) {
1006            return this._monthsStrictRegex;
1007        } else {
1008            return this._monthsRegex;
1009        }
1010    } else {
1011        if (!hasOwnProp(this, '_monthsRegex')) {
1012            this._monthsRegex = defaultMonthsRegex;
1013        }
1014        return this._monthsStrictRegex && isStrict ?
1015            this._monthsStrictRegex : this._monthsRegex;
1016    }
1017}
1018
1019function computeMonthsParse () {
1020    function cmpLenRev(a, b) {
1021        return b.length - a.length;
1022    }
1023
1024    var shortPieces = [], longPieces = [], mixedPieces = [],
1025        i, mom;
1026    for (i = 0; i < 12; i++) {
1027        // make the regex if we don't have it already
1028        mom = createUTC([2000, i]);
1029        shortPieces.push(this.monthsShort(mom, ''));
1030        longPieces.push(this.months(mom, ''));
1031        mixedPieces.push(this.months(mom, ''));
1032        mixedPieces.push(this.monthsShort(mom, ''));
1033    }
1034    // Sorting makes sure if one month (or abbr) is a prefix of another it
1035    // will match the longer piece.
1036    shortPieces.sort(cmpLenRev);
1037    longPieces.sort(cmpLenRev);
1038    mixedPieces.sort(cmpLenRev);
1039    for (i = 0; i < 12; i++) {
1040        shortPieces[i] = regexEscape(shortPieces[i]);
1041        longPieces[i] = regexEscape(longPieces[i]);
1042    }
1043    for (i = 0; i < 24; i++) {
1044        mixedPieces[i] = regexEscape(mixedPieces[i]);
1045    }
1046
1047    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1048    this._monthsShortRegex = this._monthsRegex;
1049    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1050    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1051}
1052
1053// FORMATTING
1054
1055addFormatToken('Y', 0, 0, function () {
1056    var y = this.year();
1057    return y <= 9999 ? '' + y : '+' + y;
1058});
1059
1060addFormatToken(0, ['YY', 2], 0, function () {
1061    return this.year() % 100;
1062});
1063
1064addFormatToken(0, ['YYYY',   4],       0, 'year');
1065addFormatToken(0, ['YYYYY',  5],       0, 'year');
1066addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
1067
1068// ALIASES
1069
1070addUnitAlias('year', 'y');
1071
1072// PRIORITIES
1073
1074addUnitPriority('year', 1);
1075
1076// PARSING
1077
1078addRegexToken('Y',      matchSigned);
1079addRegexToken('YY',     match1to2, match2);
1080addRegexToken('YYYY',   match1to4, match4);
1081addRegexToken('YYYYY',  match1to6, match6);
1082addRegexToken('YYYYYY', match1to6, match6);
1083
1084addParseToken(['YYYYY', 'YYYYYY'], YEAR);
1085addParseToken('YYYY', function (input, array) {
1086    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
1087});
1088addParseToken('YY', function (input, array) {
1089    array[YEAR] = hooks.parseTwoDigitYear(input);
1090});
1091addParseToken('Y', function (input, array) {
1092    array[YEAR] = parseInt(input, 10);
1093});
1094
1095// HELPERS
1096
1097function daysInYear(year) {
1098    return isLeapYear(year) ? 366 : 365;
1099}
1100
1101function isLeapYear(year) {
1102    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
1103}
1104
1105// HOOKS
1106
1107hooks.parseTwoDigitYear = function (input) {
1108    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
1109};
1110
1111// MOMENTS
1112
1113var getSetYear = makeGetSet('FullYear', true);
1114
1115function getIsLeapYear () {
1116    return isLeapYear(this.year());
1117}
1118
1119function createDate (y, m, d, h, M, s, ms) {
1120    //can't just apply() to create a date:
1121    //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
1122    var date = new Date(y, m, d, h, M, s, ms);
1123
1124    //the date constructor remaps years 0-99 to 1900-1999
1125    if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
1126        date.setFullYear(y);
1127    }
1128    return date;
1129}
1130
1131function createUTCDate (y) {
1132    var date = new Date(Date.UTC.apply(null, arguments));
1133
1134    //the Date.UTC function remaps years 0-99 to 1900-1999
1135    if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
1136        date.setUTCFullYear(y);
1137    }
1138    return date;
1139}
1140
1141// start-of-first-week - start-of-year
1142function firstWeekOffset(year, dow, doy) {
1143    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1144        fwd = 7 + dow - doy,
1145        // first-week day local weekday -- which local weekday is fwd
1146        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1147
1148    return -fwdlw + fwd - 1;
1149}
1150
1151//http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1152function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1153    var localWeekday = (7 + weekday - dow) % 7,
1154        weekOffset = firstWeekOffset(year, dow, doy),
1155        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1156        resYear, resDayOfYear;
1157
1158    if (dayOfYear <= 0) {
1159        resYear = year - 1;
1160        resDayOfYear = daysInYear(resYear) + dayOfYear;
1161    } else if (dayOfYear > daysInYear(year)) {
1162        resYear = year + 1;
1163        resDayOfYear = dayOfYear - daysInYear(year);
1164    } else {
1165        resYear = year;
1166        resDayOfYear = dayOfYear;
1167    }
1168
1169    return {
1170        year: resYear,
1171        dayOfYear: resDayOfYear
1172    };
1173}
1174
1175function weekOfYear(mom, dow, doy) {
1176    var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1177        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1178        resWeek, resYear;
1179
1180    if (week < 1) {
1181        resYear = mom.year() - 1;
1182        resWeek = week + weeksInYear(resYear, dow, doy);
1183    } else if (week > weeksInYear(mom.year(), dow, doy)) {
1184        resWeek = week - weeksInYear(mom.year(), dow, doy);
1185        resYear = mom.year() + 1;
1186    } else {
1187        resYear = mom.year();
1188        resWeek = week;
1189    }
1190
1191    return {
1192        week: resWeek,
1193        year: resYear
1194    };
1195}
1196
1197function weeksInYear(year, dow, doy) {
1198    var weekOffset = firstWeekOffset(year, dow, doy),
1199        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1200    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1201}
1202
1203// FORMATTING
1204
1205addFormatToken('w', ['ww', 2], 'wo', 'week');
1206addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1207
1208// ALIASES
1209
1210addUnitAlias('week', 'w');
1211addUnitAlias('isoWeek', 'W');
1212
1213// PRIORITIES
1214
1215addUnitPriority('week', 5);
1216addUnitPriority('isoWeek', 5);
1217
1218// PARSING
1219
1220addRegexToken('w',  match1to2);
1221addRegexToken('ww', match1to2, match2);
1222addRegexToken('W',  match1to2);
1223addRegexToken('WW', match1to2, match2);
1224
1225addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
1226    week[token.substr(0, 1)] = toInt(input);
1227});
1228
1229// HELPERS
1230
1231// LOCALES
1232
1233function localeWeek (mom) {
1234    return weekOfYear(mom, this._week.dow, this._week.doy).week;
1235}
1236
1237var defaultLocaleWeek = {
1238    dow : 0, // Sunday is the first day of the week.
1239    doy : 6  // The week that contains Jan 1st is the first week of the year.
1240};
1241
1242function localeFirstDayOfWeek () {
1243    return this._week.dow;
1244}
1245
1246function localeFirstDayOfYear () {
1247    return this._week.doy;
1248}
1249
1250// MOMENTS
1251
1252function getSetWeek (input) {
1253    var week = this.localeData().week(this);
1254    return input == null ? week : this.add((input - week) * 7, 'd');
1255}
1256
1257function getSetISOWeek (input) {
1258    var week = weekOfYear(this, 1, 4).week;
1259    return input == null ? week : this.add((input - week) * 7, 'd');
1260}
1261
1262// FORMATTING
1263
1264addFormatToken('d', 0, 'do', 'day');
1265
1266addFormatToken('dd', 0, 0, function (format) {
1267    return this.localeData().weekdaysMin(this, format);
1268});
1269
1270addFormatToken('ddd', 0, 0, function (format) {
1271    return this.localeData().weekdaysShort(this, format);
1272});
1273
1274addFormatToken('dddd', 0, 0, function (format) {
1275    return this.localeData().weekdays(this, format);
1276});
1277
1278addFormatToken('e', 0, 0, 'weekday');
1279addFormatToken('E', 0, 0, 'isoWeekday');
1280
1281// ALIASES
1282
1283addUnitAlias('day', 'd');
1284addUnitAlias('weekday', 'e');
1285addUnitAlias('isoWeekday', 'E');
1286
1287// PRIORITY
1288addUnitPriority('day', 11);
1289addUnitPriority('weekday', 11);
1290addUnitPriority('isoWeekday', 11);
1291
1292// PARSING
1293
1294addRegexToken('d',    match1to2);
1295addRegexToken('e',    match1to2);
1296addRegexToken('E',    match1to2);
1297addRegexToken('dd',   function (isStrict, locale) {
1298    return locale.weekdaysMinRegex(isStrict);
1299});
1300addRegexToken('ddd',   function (isStrict, locale) {
1301    return locale.weekdaysShortRegex(isStrict);
1302});
1303addRegexToken('dddd',   function (isStrict, locale) {
1304    return locale.weekdaysRegex(isStrict);
1305});
1306
1307addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1308    var weekday = config._locale.weekdaysParse(input, token, config._strict);
1309    // if we didn't get a weekday name, mark the date as invalid
1310    if (weekday != null) {
1311        week.d = weekday;
1312    } else {
1313        getParsingFlags(config).invalidWeekday = input;
1314    }
1315});
1316
1317addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1318    week[token] = toInt(input);
1319});
1320
1321// HELPERS
1322
1323function parseWeekday(input, locale) {
1324    if (typeof input !== 'string') {
1325        return input;
1326    }
1327
1328    if (!isNaN(input)) {
1329        return parseInt(input, 10);
1330    }
1331
1332    input = locale.weekdaysParse(input);
1333    if (typeof input === 'number') {
1334        return input;
1335    }
1336
1337    return null;
1338}
1339
1340function parseIsoWeekday(input, locale) {
1341    if (typeof input === 'string') {
1342        return locale.weekdaysParse(input) % 7 || 7;
1343    }
1344    return isNaN(input) ? null : input;
1345}
1346
1347// LOCALES
1348
1349var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
1350function localeWeekdays (m, format) {
1351    if (!m) {
1352        return this._weekdays;
1353    }
1354    return isArray(this._weekdays) ? this._weekdays[m.day()] :
1355        this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
1356}
1357
1358var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
1359function localeWeekdaysShort (m) {
1360    return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
1361}
1362
1363var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
1364function localeWeekdaysMin (m) {
1365    return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
1366}
1367
1368function handleStrictParse$1(weekdayName, format, strict) {
1369    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
1370    if (!this._weekdaysParse) {
1371        this._weekdaysParse = [];
1372        this._shortWeekdaysParse = [];
1373        this._minWeekdaysParse = [];
1374
1375        for (i = 0; i < 7; ++i) {
1376            mom = createUTC([2000, 1]).day(i);
1377            this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
1378            this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
1379            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1380        }
1381    }
1382
1383    if (strict) {
1384        if (format === 'dddd') {
1385            ii = indexOf$1.call(this._weekdaysParse, llc);
1386            return ii !== -1 ? ii : null;
1387        } else if (format === 'ddd') {
1388            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
1389            return ii !== -1 ? ii : null;
1390        } else {
1391            ii = indexOf$1.call(this._minWeekdaysParse, llc);
1392            return ii !== -1 ? ii : null;
1393        }
1394    } else {
1395        if (format === 'dddd') {
1396            ii = indexOf$1.call(this._weekdaysParse, llc);
1397            if (ii !== -1) {
1398                return ii;
1399            }
1400            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
1401            if (ii !== -1) {
1402                return ii;
1403            }
1404            ii = indexOf$1.call(this._minWeekdaysParse, llc);
1405            return ii !== -1 ? ii : null;
1406        } else if (format === 'ddd') {
1407            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
1408            if (ii !== -1) {
1409                return ii;
1410            }
1411            ii = indexOf$1.call(this._weekdaysParse, llc);
1412            if (ii !== -1) {
1413                return ii;
1414            }
1415            ii = indexOf$1.call(this._minWeekdaysParse, llc);
1416            return ii !== -1 ? ii : null;
1417        } else {
1418            ii = indexOf$1.call(this._minWeekdaysParse, llc);
1419            if (ii !== -1) {
1420                return ii;
1421            }
1422            ii = indexOf$1.call(this._weekdaysParse, llc);
1423            if (ii !== -1) {
1424                return ii;
1425            }
1426            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
1427            return ii !== -1 ? ii : null;
1428        }
1429    }
1430}
1431
1432function localeWeekdaysParse (weekdayName, format, strict) {
1433    var i, mom, regex;
1434
1435    if (this._weekdaysParseExact) {
1436        return handleStrictParse$1.call(this, weekdayName, format, strict);
1437    }
1438
1439    if (!this._weekdaysParse) {
1440        this._weekdaysParse = [];
1441        this._minWeekdaysParse = [];
1442        this._shortWeekdaysParse = [];
1443        this._fullWeekdaysParse = [];
1444    }
1445
1446    for (i = 0; i < 7; i++) {
1447        // make the regex if we don't have it already
1448
1449        mom = createUTC([2000, 1]).day(i);
1450        if (strict && !this._fullWeekdaysParse[i]) {
1451            this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
1452            this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
1453            this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
1454        }
1455        if (!this._weekdaysParse[i]) {
1456            regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
1457            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
1458        }
1459        // test the regex
1460        if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
1461            return i;
1462        } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
1463            return i;
1464        } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
1465            return i;
1466        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
1467            return i;
1468        }
1469    }
1470}
1471
1472// MOMENTS
1473
1474function getSetDayOfWeek (input) {
1475    if (!this.isValid()) {
1476        return input != null ? this : NaN;
1477    }
1478    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1479    if (input != null) {
1480        input = parseWeekday(input, this.localeData());
1481        return this.add(input - day, 'd');
1482    } else {
1483        return day;
1484    }
1485}
1486
1487function getSetLocaleDayOfWeek (input) {
1488    if (!this.isValid()) {
1489        return input != null ? this : NaN;
1490    }
1491    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1492    return input == null ? weekday : this.add(input - weekday, 'd');
1493}
1494
1495function getSetISODayOfWeek (input) {
1496    if (!this.isValid()) {
1497        return input != null ? this : NaN;
1498    }
1499
1500    // behaves the same as moment#day except
1501    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1502    // as a setter, sunday should belong to the previous week.
1503
1504    if (input != null) {
1505        var weekday = parseIsoWeekday(input, this.localeData());
1506        return this.day(this.day() % 7 ? weekday : weekday - 7);
1507    } else {
1508        return this.day() || 7;
1509    }
1510}
1511
1512var defaultWeekdaysRegex = matchWord;
1513function weekdaysRegex (isStrict) {
1514    if (this._weekdaysParseExact) {
1515        if (!hasOwnProp(this, '_weekdaysRegex')) {
1516            computeWeekdaysParse.call(this);
1517        }
1518        if (isStrict) {
1519            return this._weekdaysStrictRegex;
1520        } else {
1521            return this._weekdaysRegex;
1522        }
1523    } else {
1524        if (!hasOwnProp(this, '_weekdaysRegex')) {
1525            this._weekdaysRegex = defaultWeekdaysRegex;
1526        }
1527        return this._weekdaysStrictRegex && isStrict ?
1528            this._weekdaysStrictRegex : this._weekdaysRegex;
1529    }
1530}
1531
1532var defaultWeekdaysShortRegex = matchWord;
1533function weekdaysShortRegex (isStrict) {
1534    if (this._weekdaysParseExact) {
1535        if (!hasOwnProp(this, '_weekdaysRegex')) {
1536            computeWeekdaysParse.call(this);
1537        }
1538        if (isStrict) {
1539            return this._weekdaysShortStrictRegex;
1540        } else {
1541            return this._weekdaysShortRegex;
1542        }
1543    } else {
1544        if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1545            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
1546        }
1547        return this._weekdaysShortStrictRegex && isStrict ?
1548            this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
1549    }
1550}
1551
1552var defaultWeekdaysMinRegex = matchWord;
1553function weekdaysMinRegex (isStrict) {
1554    if (this._weekdaysParseExact) {
1555        if (!hasOwnProp(this, '_weekdaysRegex')) {
1556            computeWeekdaysParse.call(this);
1557        }
1558        if (isStrict) {
1559            return this._weekdaysMinStrictRegex;
1560        } else {
1561            return this._weekdaysMinRegex;
1562        }
1563    } else {
1564        if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1565            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
1566        }
1567        return this._weekdaysMinStrictRegex && isStrict ?
1568            this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
1569    }
1570}
1571
1572
1573function computeWeekdaysParse () {
1574    function cmpLenRev(a, b) {
1575        return b.length - a.length;
1576    }
1577
1578    var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
1579        i, mom, minp, shortp, longp;
1580    for (i = 0; i < 7; i++) {
1581        // make the regex if we don't have it already
1582        mom = createUTC([2000, 1]).day(i);
1583        minp = this.weekdaysMin(mom, '');
1584        shortp = this.weekdaysShort(mom, '');
1585        longp = this.weekdays(mom, '');
1586        minPieces.push(minp);
1587        shortPieces.push(shortp);
1588        longPieces.push(longp);
1589        mixedPieces.push(minp);
1590        mixedPieces.push(shortp);
1591        mixedPieces.push(longp);
1592    }
1593    // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1594    // will match the longer piece.
1595    minPieces.sort(cmpLenRev);
1596    shortPieces.sort(cmpLenRev);
1597    longPieces.sort(cmpLenRev);
1598    mixedPieces.sort(cmpLenRev);
1599    for (i = 0; i < 7; i++) {
1600        shortPieces[i] = regexEscape(shortPieces[i]);
1601        longPieces[i] = regexEscape(longPieces[i]);
1602        mixedPieces[i] = regexEscape(mixedPieces[i]);
1603    }
1604
1605    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1606    this._weekdaysShortRegex = this._weekdaysRegex;
1607    this._weekdaysMinRegex = this._weekdaysRegex;
1608
1609    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1610    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1611    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
1612}
1613
1614// FORMATTING
1615
1616function hFormat() {
1617    return this.hours() % 12 || 12;
1618}
1619
1620function kFormat() {
1621    return this.hours() || 24;
1622}
1623
1624addFormatToken('H', ['HH', 2], 0, 'hour');
1625addFormatToken('h', ['hh', 2], 0, hFormat);
1626addFormatToken('k', ['kk', 2], 0, kFormat);
1627
1628addFormatToken('hmm', 0, 0, function () {
1629    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
1630});
1631
1632addFormatToken('hmmss', 0, 0, function () {
1633    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
1634        zeroFill(this.seconds(), 2);
1635});
1636
1637addFormatToken('Hmm', 0, 0, function () {
1638    return '' + this.hours() + zeroFill(this.minutes(), 2);
1639});
1640
1641addFormatToken('Hmmss', 0, 0, function () {
1642    return '' + this.hours() + zeroFill(this.minutes(), 2) +
1643        zeroFill(this.seconds(), 2);
1644});
1645
1646function meridiem (token, lowercase) {
1647    addFormatToken(token, 0, 0, function () {
1648        return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
1649    });
1650}
1651
1652meridiem('a', true);
1653meridiem('A', false);
1654
1655// ALIASES
1656
1657addUnitAlias('hour', 'h');
1658
1659// PRIORITY
1660addUnitPriority('hour', 13);
1661
1662// PARSING
1663
1664function matchMeridiem (isStrict, locale) {
1665    return locale._meridiemParse;
1666}
1667
1668addRegexToken('a',  matchMeridiem);
1669addRegexToken('A',  matchMeridiem);
1670addRegexToken('H',  match1to2);
1671addRegexToken('h',  match1to2);
1672addRegexToken('HH', match1to2, match2);
1673addRegexToken('hh', match1to2, match2);
1674
1675addRegexToken('hmm', match3to4);
1676addRegexToken('hmmss', match5to6);
1677addRegexToken('Hmm', match3to4);
1678addRegexToken('Hmmss', match5to6);
1679
1680addParseToken(['H', 'HH'], HOUR);
1681addParseToken(['a', 'A'], function (input, array, config) {
1682    config._isPm = config._locale.isPM(input);
1683    config._meridiem = input;
1684});
1685addParseToken(['h', 'hh'], function (input, array, config) {
1686    array[HOUR] = toInt(input);
1687    getParsingFlags(config).bigHour = true;
1688});
1689addParseToken('hmm', function (input, array, config) {
1690    var pos = input.length - 2;
1691    array[HOUR] = toInt(input.substr(0, pos));
1692    array[MINUTE] = toInt(input.substr(pos));
1693    getParsingFlags(config).bigHour = true;
1694});
1695addParseToken('hmmss', function (input, array, config) {
1696    var pos1 = input.length - 4;
1697    var pos2 = input.length - 2;
1698    array[HOUR] = toInt(input.substr(0, pos1));
1699    array[MINUTE] = toInt(input.substr(pos1, 2));
1700    array[SECOND] = toInt(input.substr(pos2));
1701    getParsingFlags(config).bigHour = true;
1702});
1703addParseToken('Hmm', function (input, array, config) {
1704    var pos = input.length - 2;
1705    array[HOUR] = toInt(input.substr(0, pos));
1706    array[MINUTE] = toInt(input.substr(pos));
1707});
1708addParseToken('Hmmss', function (input, array, config) {
1709    var pos1 = input.length - 4;
1710    var pos2 = input.length - 2;
1711    array[HOUR] = toInt(input.substr(0, pos1));
1712    array[MINUTE] = toInt(input.substr(pos1, 2));
1713    array[SECOND] = toInt(input.substr(pos2));
1714});
1715
1716// LOCALES
1717
1718function localeIsPM (input) {
1719    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1720    // Using charAt should be more compatible.
1721    return ((input + '').toLowerCase().charAt(0) === 'p');
1722}
1723
1724var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
1725function localeMeridiem (hours, minutes, isLower) {
1726    if (hours > 11) {
1727        return isLower ? 'pm' : 'PM';
1728    } else {
1729        return isLower ? 'am' : 'AM';
1730    }
1731}
1732
1733
1734// MOMENTS
1735
1736// Setting the hour should keep the time, because the user explicitly
1737// specified which hour he wants. So trying to maintain the same hour (in
1738// a new timezone) makes sense. Adding/subtracting hours does not follow
1739// this rule.
1740var getSetHour = makeGetSet('Hours', true);
1741
1742// months
1743// week
1744// weekdays
1745// meridiem
1746var baseConfig = {
1747    calendar: defaultCalendar,
1748    longDateFormat: defaultLongDateFormat,
1749    invalidDate: defaultInvalidDate,
1750    ordinal: defaultOrdinal,
1751    ordinalParse: defaultOrdinalParse,
1752    relativeTime: defaultRelativeTime,
1753
1754    months: defaultLocaleMonths,
1755    monthsShort: defaultLocaleMonthsShort,
1756
1757    week: defaultLocaleWeek,
1758
1759    weekdays: defaultLocaleWeekdays,
1760    weekdaysMin: defaultLocaleWeekdaysMin,
1761    weekdaysShort: defaultLocaleWeekdaysShort,
1762
1763    meridiemParse: defaultLocaleMeridiemParse
1764};
1765
1766// internal storage for locale config files
1767var locales = {};
1768var localeFamilies = {};
1769var globalLocale;
1770
1771function normalizeLocale(key) {
1772    return key ? key.toLowerCase().replace('_', '-') : key;
1773}
1774
1775// pick the locale from the array
1776// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
1777// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
1778function chooseLocale(names) {
1779    var i = 0, j, next, locale, split;
1780
1781    while (i < names.length) {
1782        split = normalizeLocale(names[i]).split('-');
1783        j = split.length;
1784        next = normalizeLocale(names[i + 1]);
1785        next = next ? next.split('-') : null;
1786        while (j > 0) {
1787            locale = loadLocale(split.slice(0, j).join('-'));
1788            if (locale) {
1789                return locale;
1790            }
1791            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
1792                //the next array item is better than a shallower substring of this one
1793                break;
1794            }
1795            j--;
1796        }
1797        i++;
1798    }
1799    return null;
1800}
1801
1802function loadLocale(name) {
1803    var oldLocale = null;
1804    // TODO: Find a better way to register and load all the locales in Node
1805    if (!locales[name] && (typeof module !== 'undefined') &&
1806            module && module.exports) {
1807        try {
1808            oldLocale = globalLocale._abbr;
1809            require('./locale/' + name);
1810            // because defineLocale currently also sets the global locale, we
1811            // want to undo that for lazy loaded locales
1812            getSetGlobalLocale(oldLocale);
1813        } catch (e) { }
1814    }
1815    return locales[name];
1816}
1817
1818// This function will load locale and then set the global locale.  If
1819// no arguments are passed in, it will simply return the current global
1820// locale key.
1821function getSetGlobalLocale (key, values) {
1822    var data;
1823    if (key) {
1824        if (isUndefined(values)) {
1825            data = getLocale(key);
1826        }
1827        else {
1828            data = defineLocale(key, values);
1829        }
1830
1831        if (data) {
1832            // moment.duration._locale = moment._locale = data;
1833            globalLocale = data;
1834        }
1835    }
1836
1837    return globalLocale._abbr;
1838}
1839
1840function defineLocale (name, config) {
1841    if (config !== null) {
1842        var parentConfig = baseConfig;
1843        config.abbr = name;
1844        if (locales[name] != null) {
1845            deprecateSimple('defineLocaleOverride',
1846                    'use moment.updateLocale(localeName, config) to change ' +
1847                    'an existing locale. moment.defineLocale(localeName, ' +
1848                    'config) should only be used for creating a new locale ' +
1849                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
1850            parentConfig = locales[name]._config;
1851        } else if (config.parentLocale != null) {
1852            if (locales[config.parentLocale] != null) {
1853                parentConfig = locales[config.parentLocale]._config;
1854            } else {
1855                if (!localeFamilies[config.parentLocale]) {
1856                    localeFamilies[config.parentLocale] = [];
1857                }
1858                localeFamilies[config.parentLocale].push({
1859                    name: name,
1860                    config: config
1861                });
1862                return null;
1863            }
1864        }
1865        locales[name] = new Locale(mergeConfigs(parentConfig, config));
1866
1867        if (localeFamilies[name]) {
1868            localeFamilies[name].forEach(function (x) {
1869                defineLocale(x.name, x.config);
1870            });
1871        }
1872
1873        // backwards compat for now: also set the locale
1874        // make sure we set the locale AFTER all child locales have been
1875        // created, so we won't end up with the child locale set.
1876        getSetGlobalLocale(name);
1877
1878
1879        return locales[name];
1880    } else {
1881        // useful for testing
1882        delete locales[name];
1883        return null;
1884    }
1885}
1886
1887function updateLocale(name, config) {
1888    if (config != null) {
1889        var locale, parentConfig = baseConfig;
1890        // MERGE
1891        if (locales[name] != null) {
1892            parentConfig = locales[name]._config;
1893        }
1894        config = mergeConfigs(parentConfig, config);
1895        locale = new Locale(config);
1896        locale.parentLocale = locales[name];
1897        locales[name] = locale;
1898
1899        // backwards compat for now: also set the locale
1900        getSetGlobalLocale(name);
1901    } else {
1902        // pass null for config to unupdate, useful for tests
1903        if (locales[name] != null) {
1904            if (locales[name].parentLocale != null) {
1905                locales[name] = locales[name].parentLocale;
1906            } else if (locales[name] != null) {
1907                delete locales[name];
1908            }
1909        }
1910    }
1911    return locales[name];
1912}
1913
1914// returns locale data
1915function getLocale (key) {
1916    var locale;
1917
1918    if (key && key._locale && key._locale._abbr) {
1919        key = key._locale._abbr;
1920    }
1921
1922    if (!key) {
1923        return globalLocale;
1924    }
1925
1926    if (!isArray(key)) {
1927        //short-circuit everything else
1928        locale = loadLocale(key);
1929        if (locale) {
1930            return locale;
1931        }
1932        key = [key];
1933    }
1934
1935    return chooseLocale(key);
1936}
1937
1938function listLocales() {
1939    return keys$1(locales);
1940}
1941
1942function checkOverflow (m) {
1943    var overflow;
1944    var a = m._a;
1945
1946    if (a && getParsingFlags(m).overflow === -2) {
1947        overflow =
1948            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
1949            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
1950            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
1951            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
1952            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
1953            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
1954            -1;
1955
1956        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
1957            overflow = DATE;
1958        }
1959        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
1960            overflow = WEEK;
1961        }
1962        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
1963            overflow = WEEKDAY;
1964        }
1965
1966        getParsingFlags(m).overflow = overflow;
1967    }
1968
1969    return m;
1970}
1971
1972// iso 8601 regex
1973// 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)
1974var 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)?)?$/;
1975var 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)?)?$/;
1976
1977var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
1978
1979var isoDates = [
1980    ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
1981    ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
1982    ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
1983    ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
1984    ['YYYY-DDD', /\d{4}-\d{3}/],
1985    ['YYYY-MM', /\d{4}-\d\d/, false],
1986    ['YYYYYYMMDD', /[+-]\d{10}/],
1987    ['YYYYMMDD', /\d{8}/],
1988    // YYYYMM is NOT allowed by the standard
1989    ['GGGG[W]WWE', /\d{4}W\d{3}/],
1990    ['GGGG[W]WW', /\d{4}W\d{2}/, false],
1991    ['YYYYDDD', /\d{7}/]
1992];
1993
1994// iso time formats and regexes
1995var isoTimes = [
1996    ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
1997    ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
1998    ['HH:mm:ss', /\d\d:\d\d:\d\d/],
1999    ['HH:mm', /\d\d:\d\d/],
2000    ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2001    ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2002    ['HHmmss', /\d\d\d\d\d\d/],
2003    ['HHmm', /\d\d\d\d/],
2004    ['HH', /\d\d/]
2005];
2006
2007var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
2008
2009// date from iso format
2010function configFromISO(config) {
2011    var i, l,
2012        string = config._i,
2013        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2014        allowTime, dateFormat, timeFormat, tzFormat;
2015
2016    if (match) {
2017        getParsingFlags(config).iso = true;
2018
2019        for (i = 0, l = isoDates.length; i < l; i++) {
2020            if (isoDates[i][1].exec(match[1])) {
2021                dateFormat = isoDates[i][0];
2022                allowTime = isoDates[i][2] !== false;
2023                break;
2024            }
2025        }
2026        if (dateFormat == null) {
2027            config._isValid = false;
2028            return;
2029        }
2030        if (match[3]) {
2031            for (i = 0, l = isoTimes.length; i < l; i++) {
2032                if (isoTimes[i][1].exec(match[3])) {
2033                    // match[2] should be 'T' or space
2034                    timeFormat = (match[2] || ' ') + isoTimes[i][0];
2035                    break;
2036                }
2037            }
2038            if (timeFormat == null) {
2039                config._isValid = false;
2040                return;
2041            }
2042        }
2043        if (!allowTime && timeFormat != null) {
2044            config._isValid = false;
2045            return;
2046        }
2047        if (match[4]) {
2048            if (tzRegex.exec(match[4])) {
2049                tzFormat = 'Z';
2050            } else {
2051                config._isValid = false;
2052                return;
2053            }
2054        }
2055        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2056        configFromStringAndFormat(config);
2057    } else {
2058        config._isValid = false;
2059    }
2060}
2061
2062// date from iso format or fallback
2063function configFromString(config) {
2064    var matched = aspNetJsonRegex.exec(config._i);
2065
2066    if (matched !== null) {
2067        config._d = new Date(+matched[1]);
2068        return;
2069    }
2070
2071    configFromISO(config);
2072    if (config._isValid === false) {
2073        delete config._isValid;
2074        hooks.createFromInputFallback(config);
2075    }
2076}
2077
2078hooks.createFromInputFallback = deprecate(
2079    'value provided is not in a recognized ISO format. moment construction falls back to js Date(), ' +
2080    'which is not reliable across all browsers and versions. Non ISO date formats are ' +
2081    'discouraged and will be removed in an upcoming major release. Please refer to ' +
2082    'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2083    function (config) {
2084        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2085    }
2086);
2087
2088// Pick the first defined of two or three arguments.
2089function defaults(a, b, c) {
2090    if (a != null) {
2091        return a;
2092    }
2093    if (b != null) {
2094        return b;
2095    }
2096    return c;
2097}
2098
2099function currentDateArray(config) {
2100    // hooks is actually the exported moment object
2101    var nowValue = new Date(hooks.now());
2102    if (config._useUTC) {
2103        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
2104    }
2105    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2106}
2107
2108// convert an array to a date.
2109// the array should mirror the parameters below
2110// note: all values past the year are optional and will default to the lowest possible value.
2111// [year, month, day , hour, minute, second, millisecond]
2112function configFromArray (config) {
2113    var i, date, input = [], currentDate, yearToUse;
2114
2115    if (config._d) {
2116        return;
2117    }
2118
2119    currentDate = currentDateArray(config);
2120
2121    //compute day of the year from weeks and weekdays
2122    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2123        dayOfYearFromWeekInfo(config);
2124    }
2125
2126    //if the day of the year is set, figure out what it is
2127    if (config._dayOfYear) {
2128        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2129
2130        if (config._dayOfYear > daysInYear(yearToUse)) {
2131            getParsingFlags(config)._overflowDayOfYear = true;
2132        }
2133
2134        date = createUTCDate(yearToUse, 0, config._dayOfYear);
2135        config._a[MONTH] = date.getUTCMonth();
2136        config._a[DATE] = date.getUTCDate();
2137    }
2138
2139    // Default to current date.
2140    // * if no year, month, day of month are given, default to today
2141    // * if day of month is given, default month and year
2142    // * if month is given, default only year
2143    // * if year is given, don't default anything
2144    for (i = 0; i < 3 && config._a[i] == null; ++i) {
2145        config._a[i] = input[i] = currentDate[i];
2146    }
2147
2148    // Zero out whatever was not defaulted, including time
2149    for (; i < 7; i++) {
2150        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
2151    }
2152
2153    // Check for 24:00:00.000
2154    if (config._a[HOUR] === 24 &&
2155            config._a[MINUTE] === 0 &&
2156            config._a[SECOND] === 0 &&
2157            config._a[MILLISECOND] === 0) {
2158        config._nextDay = true;
2159        config._a[HOUR] = 0;
2160    }
2161
2162    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
2163    // Apply timezone offset from input. The actual utcOffset can be changed
2164    // with parseZone.
2165    if (config._tzm != null) {
2166        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2167    }
2168
2169    if (config._nextDay) {
2170        config._a[HOUR] = 24;
2171    }
2172}
2173
2174function dayOfYearFromWeekInfo(config) {
2175    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
2176
2177    w = config._w;
2178    if (w.GG != null || w.W != null || w.E != null) {
2179        dow = 1;
2180        doy = 4;
2181
2182        // TODO: We need to take the current isoWeekYear, but that depends on
2183        // how we interpret now (local, utc, fixed offset). So create
2184        // a now version of current config (take local/utc/offset flags, and
2185        // create now).
2186        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
2187        week = defaults(w.W, 1);
2188        weekday = defaults(w.E, 1);
2189        if (weekday < 1 || weekday > 7) {
2190            weekdayOverflow = true;
2191        }
2192    } else {
2193        dow = config._locale._week.dow;
2194        doy = config._locale._week.doy;
2195
2196        var curWeek = weekOfYear(createLocal(), dow, doy);
2197
2198        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
2199
2200        // Default to current week.
2201        week = defaults(w.w, curWeek.week);
2202
2203        if (w.d != null) {
2204            // weekday -- low day numbers are considered next week
2205            weekday = w.d;
2206            if (weekday < 0 || weekday > 6) {
2207                weekdayOverflow = true;
2208            }
2209        } else if (w.e != null) {
2210            // local weekday -- counting starts from begining of week
2211            weekday = w.e + dow;
2212            if (w.e < 0 || w.e > 6) {
2213                weekdayOverflow = true;
2214            }
2215        } else {
2216            // default to begining of week
2217            weekday = dow;
2218        }
2219    }
2220    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2221        getParsingFlags(config)._overflowWeeks = true;
2222    } else if (weekdayOverflow != null) {
2223        getParsingFlags(config)._overflowWeekday = true;
2224    } else {
2225        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2226        config._a[YEAR] = temp.year;
2227        config._dayOfYear = temp.dayOfYear;
2228    }
2229}
2230
2231// constant that refers to the ISO standard
2232hooks.ISO_8601 = function () {};
2233
2234// date from string and format string
2235function configFromStringAndFormat(config) {
2236    // TODO: Move this to another part of the creation flow to prevent circular deps
2237    if (config._f === hooks.ISO_8601) {
2238        configFromISO(config);
2239        return;
2240    }
2241
2242    config._a = [];
2243    getParsingFlags(config).empty = true;
2244
2245    // This array is used to make a Date, either with `new Date` or `Date.UTC`
2246    var string = '' + config._i,
2247        i, parsedInput, tokens, token, skipped,
2248        stringLength = string.length,
2249        totalParsedInputLength = 0;
2250
2251    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
2252
2253    for (i = 0; i < tokens.length; i++) {
2254        token = tokens[i];
2255        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
2256        // console.log('token', token, 'parsedInput', parsedInput,
2257        //         'regex', getParseRegexForToken(token, config));
2258        if (parsedInput) {
2259            skipped = string.substr(0, string.indexOf(parsedInput));
2260            if (skipped.length > 0) {
2261                getParsingFlags(config).unusedInput.push(skipped);
2262            }
2263            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
2264            totalParsedInputLength += parsedInput.length;
2265        }
2266        // don't parse if it's not a known token
2267        if (formatTokenFunctions[token]) {
2268            if (parsedInput) {
2269                getParsingFlags(config).empty = false;
2270            }
2271            else {
2272                getParsingFlags(config).unusedTokens.push(token);
2273            }
2274            addTimeToArrayFromToken(token, parsedInput, config);
2275        }
2276        else if (config._strict && !parsedInput) {
2277            getParsingFlags(config).unusedTokens.push(token);
2278        }
2279    }
2280
2281    // add remaining unparsed input length to the string
2282    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
2283    if (string.length > 0) {
2284        getParsingFlags(config).unusedInput.push(string);
2285    }
2286
2287    // clear _12h flag if hour is <= 12
2288    if (config._a[HOUR] <= 12 &&
2289        getParsingFlags(config).bigHour === true &&
2290        config._a[HOUR] > 0) {
2291        getParsingFlags(config).bigHour = undefined;
2292    }
2293
2294    getParsingFlags(config).parsedDateParts = config._a.slice(0);
2295    getParsingFlags(config).meridiem = config._meridiem;
2296    // handle meridiem
2297    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
2298
2299    configFromArray(config);
2300    checkOverflow(config);
2301}
2302
2303
2304function meridiemFixWrap (locale, hour, meridiem) {
2305    var isPm;
2306
2307    if (meridiem == null) {
2308        // nothing to do
2309        return hour;
2310    }
2311    if (locale.meridiemHour != null) {
2312        return locale.meridiemHour(hour, meridiem);
2313    } else if (locale.isPM != null) {
2314        // Fallback
2315        isPm = locale.isPM(meridiem);
2316        if (isPm && hour < 12) {
2317            hour += 12;
2318        }
2319        if (!isPm && hour === 12) {
2320            hour = 0;
2321        }
2322        return hour;
2323    } else {
2324        // this is not supposed to happen
2325        return hour;
2326    }
2327}
2328
2329// date from string and array of format strings
2330function configFromStringAndArray(config) {
2331    var tempConfig,
2332        bestMoment,
2333
2334        scoreToBeat,
2335        i,
2336        currentScore;
2337
2338    if (config._f.length === 0) {
2339        getParsingFlags(config).invalidFormat = true;
2340        config._d = new Date(NaN);
2341        return;
2342    }
2343
2344    for (i = 0; i < config._f.length; i++) {
2345        currentScore = 0;
2346        tempConfig = copyConfig({}, config);
2347        if (config._useUTC != null) {
2348            tempConfig._useUTC = config._useUTC;
2349        }
2350        tempConfig._f = config._f[i];
2351        configFromStringAndFormat(tempConfig);
2352
2353        if (!isValid(tempConfig)) {
2354            continue;
2355        }
2356
2357        // if there is any input that was not parsed add a penalty for that format
2358        currentScore += getParsingFlags(tempConfig).charsLeftOver;
2359
2360        //or tokens
2361        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2362
2363        getParsingFlags(tempConfig).score = currentScore;
2364
2365        if (scoreToBeat == null || currentScore < scoreToBeat) {
2366            scoreToBeat = currentScore;
2367            bestMoment = tempConfig;
2368        }
2369    }
2370
2371    extend(config, bestMoment || tempConfig);
2372}
2373
2374function configFromObject(config) {
2375    if (config._d) {
2376        return;
2377    }
2378
2379    var i = normalizeObjectUnits(config._i);
2380    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
2381        return obj && parseInt(obj, 10);
2382    });
2383
2384    configFromArray(config);
2385}
2386
2387function createFromConfig (config) {
2388    var res = new Moment(checkOverflow(prepareConfig(config)));
2389    if (res._nextDay) {
2390        // Adding is smart enough around DST
2391        res.add(1, 'd');
2392        res._nextDay = undefined;
2393    }
2394
2395    return res;
2396}
2397
2398function prepareConfig (config) {
2399    var input = config._i,
2400        format = config._f;
2401
2402    config._locale = config._locale || getLocale(config._l);
2403
2404    if (input === null || (format === undefined && input === '')) {
2405        return createInvalid({nullInput: true});
2406    }
2407
2408    if (typeof input === 'string') {
2409        config._i = input = config._locale.preparse(input);
2410    }
2411
2412    if (isMoment(input)) {
2413        return new Moment(checkOverflow(input));
2414    } else if (isDate(input)) {
2415        config._d = input;
2416    } else if (isArray(format)) {
2417        configFromStringAndArray(config);
2418    } else if (format) {
2419        configFromStringAndFormat(config);
2420    }  else {
2421        configFromInput(config);
2422    }
2423
2424    if (!isValid(config)) {
2425        config._d = null;
2426    }
2427
2428    return config;
2429}
2430
2431function configFromInput(config) {
2432    var input = config._i;
2433    if (input === undefined) {
2434        config._d = new Date(hooks.now());
2435    } else if (isDate(input)) {
2436        config._d = new Date(input.valueOf());
2437    } else if (typeof input === 'string') {
2438        configFromString(config);
2439    } else if (isArray(input)) {
2440        config._a = map(input.slice(0), function (obj) {
2441            return parseInt(obj, 10);
2442        });
2443        configFromArray(config);
2444    } else if (typeof(input) === 'object') {
2445        configFromObject(config);
2446    } else if (isNumber(input)) {
2447        // from milliseconds
2448        config._d = new Date(input);
2449    } else {
2450        hooks.createFromInputFallback(config);
2451    }
2452}
2453
2454function createLocalOrUTC (input, format, locale, strict, isUTC) {
2455    var c = {};
2456
2457    if (locale === true || locale === false) {
2458        strict = locale;
2459        locale = undefined;
2460    }
2461
2462    if ((isObject(input) && isObjectEmpty(input)) ||
2463            (isArray(input) && input.length === 0)) {
2464        input = undefined;
2465    }
2466    // object construction must be done this way.
2467    // https://github.com/moment/moment/issues/1423
2468    c._isAMomentObject = true;
2469    c._useUTC = c._isUTC = isUTC;
2470    c._l = locale;
2471    c._i = input;
2472    c._f = format;
2473    c._strict = strict;
2474
2475    return createFromConfig(c);
2476}
2477
2478function createLocal (input, format, locale, strict) {
2479    return createLocalOrUTC(input, format, locale, strict, false);
2480}
2481
2482var prototypeMin = deprecate(
2483    'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
2484    function () {
2485        var other = createLocal.apply(null, arguments);
2486        if (this.isValid() && other.isValid()) {
2487            return other < this ? this : other;
2488        } else {
2489            return createInvalid();
2490        }
2491    }
2492);
2493
2494var prototypeMax = deprecate(
2495    'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
2496    function () {
2497        var other = createLocal.apply(null, arguments);
2498        if (this.isValid() && other.isValid()) {
2499            return other > this ? this : other;
2500        } else {
2501            return createInvalid();
2502        }
2503    }
2504);
2505
2506// Pick a moment m from moments so that m[fn](other) is true for all
2507// other. This relies on the function fn to be transitive.
2508//
2509// moments should either be an array of moment objects or an array, whose
2510// first element is an array of moment objects.
2511function pickBy(fn, moments) {
2512    var res, i;
2513    if (moments.length === 1 && isArray(moments[0])) {
2514        moments = moments[0];
2515    }
2516    if (!moments.length) {
2517        return createLocal();
2518    }
2519    res = moments[0];
2520    for (i = 1; i < moments.length; ++i) {
2521        if (!moments[i].isValid() || moments[i][fn](res)) {
2522            res = moments[i];
2523        }
2524    }
2525    return res;
2526}
2527
2528// TODO: Use [].sort instead?
2529function min () {
2530    var args = [].slice.call(arguments, 0);
2531
2532    return pickBy('isBefore', args);
2533}
2534
2535function max () {
2536    var args = [].slice.call(arguments, 0);
2537
2538    return pickBy('isAfter', args);
2539}
2540
2541var now = function () {
2542    return Date.now ? Date.now() : +(new Date());
2543};
2544
2545function Duration (duration) {
2546    var normalizedInput = normalizeObjectUnits(duration),
2547        years = normalizedInput.year || 0,
2548        quarters = normalizedInput.quarter || 0,
2549        months = normalizedInput.month || 0,
2550        weeks = normalizedInput.week || 0,
2551        days = normalizedInput.day || 0,
2552        hours = normalizedInput.hour || 0,
2553        minutes = normalizedInput.minute || 0,
2554        seconds = normalizedInput.second || 0,
2555        milliseconds = normalizedInput.millisecond || 0;
2556
2557    // representation for dateAddRemove
2558    this._milliseconds = +milliseconds +
2559        seconds * 1e3 + // 1000
2560        minutes * 6e4 + // 1000 * 60
2561        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
2562    // Because of dateAddRemove treats 24 hours as different from a
2563    // day when working around DST, we need to store them separately
2564    this._days = +days +
2565        weeks * 7;
2566    // It is impossible translate months into days without knowing
2567    // which months you are are talking about, so we have to store
2568    // it separately.
2569    this._months = +months +
2570        quarters * 3 +
2571        years * 12;
2572
2573    this._data = {};
2574
2575    this._locale = getLocale();
2576
2577    this._bubble();
2578}
2579
2580function isDuration (obj) {
2581    return obj instanceof Duration;
2582}
2583
2584function absRound (number) {
2585    if (number < 0) {
2586        return Math.round(-1 * number) * -1;
2587    } else {
2588        return Math.round(number);
2589    }
2590}
2591
2592// FORMATTING
2593
2594function offset (token, separator) {
2595    addFormatToken(token, 0, 0, function () {
2596        var offset = this.utcOffset();
2597        var sign = '+';
2598        if (offset < 0) {
2599            offset = -offset;
2600            sign = '-';
2601        }
2602        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
2603    });
2604}
2605
2606offset('Z', ':');
2607offset('ZZ', '');
2608
2609// PARSING
2610
2611addRegexToken('Z',  matchShortOffset);
2612addRegexToken('ZZ', matchShortOffset);
2613addParseToken(['Z', 'ZZ'], function (input, array, config) {
2614    config._useUTC = true;
2615    config._tzm = offsetFromString(matchShortOffset, input);
2616});
2617
2618// HELPERS
2619
2620// timezone chunker
2621// '+10:00' > ['10',  '00']
2622// '-1530'  > ['-15', '30']
2623var chunkOffset = /([\+\-]|\d\d)/gi;
2624
2625function offsetFromString(matcher, string) {
2626    var matches = (string || '').match(matcher);
2627
2628    if (matches === null) {
2629        return null;
2630    }
2631
2632    var chunk   = matches[matches.length - 1] || [];
2633    var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
2634    var minutes = +(parts[1] * 60) + toInt(parts[2]);
2635
2636    return minutes === 0 ?
2637      0 :
2638      parts[0] === '+' ? minutes : -minutes;
2639}
2640
2641// Return a moment from input, that is local/utc/zone equivalent to model.
2642function cloneWithOffset(input, model) {
2643    var res, diff;
2644    if (model._isUTC) {
2645        res = model.clone();
2646        diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
2647        // Use low-level api, because this fn is low-level api.
2648        res._d.setTime(res._d.valueOf() + diff);
2649        hooks.updateOffset(res, false);
2650        return res;
2651    } else {
2652        return createLocal(input).local();
2653    }
2654}
2655
2656function getDateOffset (m) {
2657    // On Firefox.24 Date#getTimezoneOffset returns a floating point.
2658    // https://github.com/moment/moment/pull/1871
2659    return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
2660}
2661
2662// HOOKS
2663
2664// This function will be called whenever a moment is mutated.
2665// It is intended to keep the offset in sync with the timezone.
2666hooks.updateOffset = function () {};
2667
2668// MOMENTS
2669
2670// keepLocalTime = true means only change the timezone, without
2671// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
2672// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
2673// +0200, so we adjust the time as needed, to be valid.
2674//
2675// Keeping the time actually adds/subtracts (one hour)
2676// from the actual represented time. That is why we call updateOffset
2677// a second time. In case it wants us to change the offset again
2678// _changeInProgress == true case, then we have to adjust, because
2679// there is no such time in the given timezone.
2680function getSetOffset (input, keepLocalTime) {
2681    var offset = this._offset || 0,
2682        localAdjust;
2683    if (!this.isValid()) {
2684        return input != null ? this : NaN;
2685    }
2686    if (input != null) {
2687        if (typeof input === 'string') {
2688            input = offsetFromString(matchShortOffset, input);
2689            if (input === null) {
2690                return this;
2691            }
2692        } else if (Math.abs(input) < 16) {
2693            input = input * 60;
2694        }
2695        if (!this._isUTC && keepLocalTime) {
2696            localAdjust = getDateOffset(this);
2697        }
2698        this._offset = input;
2699        this._isUTC = true;
2700        if (localAdjust != null) {
2701            this.add(localAdjust, 'm');
2702        }
2703        if (offset !== input) {
2704            if (!keepLocalTime || this._changeInProgress) {
2705                addSubtract(this, createDuration(input - offset, 'm'), 1, false);
2706            } else if (!this._changeInProgress) {
2707                this._changeInProgress = true;
2708                hooks.updateOffset(this, true);
2709                this._changeInProgress = null;
2710            }
2711        }
2712        return this;
2713    } else {
2714        return this._isUTC ? offset : getDateOffset(this);
2715    }
2716}
2717
2718function getSetZone (input, keepLocalTime) {
2719    if (input != null) {
2720        if (typeof input !== 'string') {
2721            input = -input;
2722        }
2723
2724        this.utcOffset(input, keepLocalTime);
2725
2726        return this;
2727    } else {
2728        return -this.utcOffset();
2729    }
2730}
2731
2732function setOffsetToUTC (keepLocalTime) {
2733    return this.utcOffset(0, keepLocalTime);
2734}
2735
2736function setOffsetToLocal (keepLocalTime) {
2737    if (this._isUTC) {
2738        this.utcOffset(0, keepLocalTime);
2739        this._isUTC = false;
2740
2741        if (keepLocalTime) {
2742            this.subtract(getDateOffset(this), 'm');
2743        }
2744    }
2745    return this;
2746}
2747
2748function setOffsetToParsedOffset () {
2749    if (this._tzm != null) {
2750        this.utcOffset(this._tzm);
2751    } else if (typeof this._i === 'string') {
2752        var tZone = offsetFromString(matchOffset, this._i);
2753        if (tZone != null) {
2754            this.utcOffset(tZone);
2755        }
2756        else {
2757            this.utcOffset(0, true);
2758        }
2759    }
2760    return this;
2761}
2762
2763function hasAlignedHourOffset (input) {
2764    if (!this.isValid()) {
2765        return false;
2766    }
2767    input = input ? createLocal(input).utcOffset() : 0;
2768
2769    return (this.utcOffset() - input) % 60 === 0;
2770}
2771
2772function isDaylightSavingTime () {
2773    return (
2774        this.utcOffset() > this.clone().month(0).utcOffset() ||
2775        this.utcOffset() > this.clone().month(5).utcOffset()
2776    );
2777}
2778
2779function isDaylightSavingTimeShifted () {
2780    if (!isUndefined(this._isDSTShifted)) {
2781        return this._isDSTShifted;
2782    }
2783
2784    var c = {};
2785
2786    copyConfig(c, this);
2787    c = prepareConfig(c);
2788
2789    if (c._a) {
2790        var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
2791        this._isDSTShifted = this.isValid() &&
2792            compareArrays(c._a, other.toArray()) > 0;
2793    } else {
2794        this._isDSTShifted = false;
2795    }
2796
2797    return this._isDSTShifted;
2798}
2799
2800function isLocal () {
2801    return this.isValid() ? !this._isUTC : false;
2802}
2803
2804function isUtcOffset () {
2805    return this.isValid() ? this._isUTC : false;
2806}
2807
2808function isUtc () {
2809    return this.isValid() ? this._isUTC && this._offset === 0 : false;
2810}
2811
2812// ASP.NET json date format regex
2813var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
2814
2815// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
2816// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
2817// and further modified to allow for strings containing both week and day
2818var isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
2819
2820function createDuration (input, key) {
2821    var duration = input,
2822        // matching against regexp is expensive, do it on demand
2823        match = null,
2824        sign,
2825        ret,
2826        diffRes;
2827
2828    if (isDuration(input)) {
2829        duration = {
2830            ms : input._milliseconds,
2831            d  : input._days,
2832            M  : input._months
2833        };
2834    } else if (isNumber(input)) {
2835        duration = {};
2836        if (key) {
2837            duration[key] = input;
2838        } else {
2839            duration.milliseconds = input;
2840        }
2841    } else if (!!(match = aspNetRegex.exec(input))) {
2842        sign = (match[1] === '-') ? -1 : 1;
2843        duration = {
2844            y  : 0,
2845            d  : toInt(match[DATE])                         * sign,
2846            h  : toInt(match[HOUR])                         * sign,
2847            m  : toInt(match[MINUTE])                       * sign,
2848            s  : toInt(match[SECOND])                       * sign,
2849            ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
2850        };
2851    } else if (!!(match = isoRegex.exec(input))) {
2852        sign = (match[1] === '-') ? -1 : 1;
2853        duration = {
2854            y : parseIso(match[2], sign),
2855            M : parseIso(match[3], sign),
2856            w : parseIso(match[4], sign),
2857            d : parseIso(match[5], sign),
2858            h : parseIso(match[6], sign),
2859            m : parseIso(match[7], sign),
2860            s : parseIso(match[8], sign)
2861        };
2862    } else if (duration == null) {// checks for null or undefined
2863        duration = {};
2864    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
2865        diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
2866
2867        duration = {};
2868        duration.ms = diffRes.milliseconds;
2869        duration.M = diffRes.months;
2870    }
2871
2872    ret = new Duration(duration);
2873
2874    if (isDuration(input) && hasOwnProp(input, '_locale')) {
2875        ret._locale = input._locale;
2876    }
2877
2878    return ret;
2879}
2880
2881createDuration.fn = Duration.prototype;
2882
2883function parseIso (inp, sign) {
2884    // We'd normally use ~~inp for this, but unfortunately it also
2885    // converts floats to ints.
2886    // inp may be undefined, so careful calling replace on it.
2887    var res = inp && parseFloat(inp.replace(',', '.'));
2888    // apply sign while we're at it
2889    return (isNaN(res) ? 0 : res) * sign;
2890}
2891
2892function positiveMomentsDifference(base, other) {
2893    var res = {milliseconds: 0, months: 0};
2894
2895    res.months = other.month() - base.month() +
2896        (other.year() - base.year()) * 12;
2897    if (base.clone().add(res.months, 'M').isAfter(other)) {
2898        --res.months;
2899    }
2900
2901    res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
2902
2903    return res;
2904}
2905
2906function momentsDifference(base, other) {
2907    var res;
2908    if (!(base.isValid() && other.isValid())) {
2909        return {milliseconds: 0, months: 0};
2910    }
2911
2912    other = cloneWithOffset(other, base);
2913    if (base.isBefore(other)) {
2914        res = positiveMomentsDifference(base, other);
2915    } else {
2916        res = positiveMomentsDifference(other, base);
2917        res.milliseconds = -res.milliseconds;
2918        res.months = -res.months;
2919    }
2920
2921    return res;
2922}
2923
2924// TODO: remove 'name' arg after deprecation is removed
2925function createAdder(direction, name) {
2926    return function (val, period) {
2927        var dur, tmp;
2928        //invert the arguments, but complain about it
2929        if (period !== null && !isNaN(+period)) {
2930            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
2931            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
2932            tmp = val; val = period; period = tmp;
2933        }
2934
2935        val = typeof val === 'string' ? +val : val;
2936        dur = createDuration(val, period);
2937        addSubtract(this, dur, direction);
2938        return this;
2939    };
2940}
2941
2942function addSubtract (mom, duration, isAdding, updateOffset) {
2943    var milliseconds = duration._milliseconds,
2944        days = absRound(duration._days),
2945        months = absRound(duration._months);
2946
2947    if (!mom.isValid()) {
2948        // No op
2949        return;
2950    }
2951
2952    updateOffset = updateOffset == null ? true : updateOffset;
2953
2954    if (milliseconds) {
2955        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
2956    }
2957    if (days) {
2958        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
2959    }
2960    if (months) {
2961        setMonth(mom, get(mom, 'Month') + months * isAdding);
2962    }
2963    if (updateOffset) {
2964        hooks.updateOffset(mom, days || months);
2965    }
2966}
2967
2968var add      = createAdder(1, 'add');
2969var subtract = createAdder(-1, 'subtract');
2970
2971function getCalendarFormat(myMoment, now) {
2972    var diff = myMoment.diff(now, 'days', true);
2973    return diff < -6 ? 'sameElse' :
2974            diff < -1 ? 'lastWeek' :
2975            diff < 0 ? 'lastDay' :
2976            diff < 1 ? 'sameDay' :
2977            diff < 2 ? 'nextDay' :
2978            diff < 7 ? 'nextWeek' : 'sameElse';
2979}
2980
2981function calendar$1 (time, formats) {
2982    // We want to compare the start of today, vs this.
2983    // Getting start-of-today depends on whether we're local/utc/offset or not.
2984    var now = time || createLocal(),
2985        sod = cloneWithOffset(now, this).startOf('day'),
2986        format = hooks.calendarFormat(this, sod) || 'sameElse';
2987
2988    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
2989

2990    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
2991}
2992
2993function clone () {
2994    return new Moment(this);
2995}
2996
2997function isAfter (input, units) {
2998    var localInput = isMoment(input) ? input : createLocal(input);
2999    if (!(this.isValid() && localInput.isValid())) {
3000        return false;
3001    }
3002    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
3003    if (units === 'millisecond') {
3004        return this.valueOf() > localInput.valueOf();
3005    } else {
3006        return localInput.valueOf() < this.clone().startOf(units).valueOf();
3007    }
3008}
3009
3010function isBefore (input, units) {
3011    var localInput = isMoment(input) ? input : createLocal(input);
3012    if (!(this.isValid() && localInput.isValid())) {
3013        return false;
3014    }
3015    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
3016    if (units === 'millisecond') {
3017        return this.valueOf() < localInput.valueOf();
3018    } else {
3019        return this.clone().endOf(units).valueOf() < localInput.valueOf();
3020    }
3021}
3022
3023function isBetween (from, to, units, inclusivity) {
3024    inclusivity = inclusivity || '()';
3025    return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
3026        (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
3027}
3028
3029function isSame (input, units) {
3030    var localInput = isMoment(input) ? input : createLocal(input),
3031        inputMs;
3032    if (!(this.isValid() && localInput.isValid())) {
3033        return false;
3034    }
3035    units = normalizeUnits(units || 'millisecond');
3036    if (units === 'millisecond') {
3037        return this.valueOf() === localInput.valueOf();
3038    } else {
3039        inputMs = localInput.valueOf();
3040        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
3041    }
3042}
3043
3044function isSameOrAfter (input, units) {
3045    return this.isSame(input, units) || this.isAfter(input,units);
3046}
3047
3048function isSameOrBefore (input, units) {
3049    return this.isSame(input, units) || this.isBefore(input,units);
3050}
3051
3052function diff (input, units, asFloat) {
3053    var that,
3054        zoneDelta,
3055        delta, output;
3056
3057    if (!this.isValid()) {
3058        return NaN;
3059    }
3060
3061    that = cloneWithOffset(input, this);
3062
3063    if (!that.isValid()) {
3064        return NaN;
3065    }
3066
3067    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
3068
3069    units = normalizeUnits(units);
3070
3071    if (units === 'year' || units === 'month' || units === 'quarter') {
3072        output = monthDiff(this, that);
3073        if (units === 'quarter') {
3074            output = output / 3;
3075        } else if (units === 'year') {
3076            output = output / 12;
3077        }
3078    } else {
3079        delta = this - that;
3080        output = units === 'second' ? delta / 1e3 : // 1000
3081            units === 'minute' ? delta / 6e4 : // 1000 * 60
3082            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
3083            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
3084            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
3085            delta;
3086    }
3087    return asFloat ? output : absFloor(output);
3088}
3089
3090function monthDiff (a, b) {
3091    // difference in months
3092    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
3093        // b is in (anchor - 1 month, anchor + 1 month)
3094        anchor = a.clone().add(wholeMonthDiff, 'months'),
3095        anchor2, adjust;
3096
3097    if (b - anchor < 0) {
3098        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
3099        // linear across the month
3100        adjust = (b - anchor) / (anchor - anchor2);
3101    } else {
3102        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
3103        // linear across the month
3104        adjust = (b - anchor) / (anchor2 - anchor);
3105    }
3106
3107    //check for negative zero, return zero if negative zero
3108    return -(wholeMonthDiff + adjust) || 0;
3109}
3110
3111hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
3112hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
3113
3114function toString () {
3115    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
3116}
3117
3118function toISOString () {
3119    var m = this.clone().utc();
3120    if (0 < m.year() && m.year() <= 9999) {
3121        if (isFunction(Date.prototype.toISOString)) {
3122            // native implementation is ~50x faster, use it when we can
3123            return this.toDate().toISOString();
3124        } else {
3125            return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
3126        }
3127    } else {
3128        return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
3129    }
3130}
3131
3132/**
3133 * Return a human readable representation of a moment that can
3134 * also be evaluated to get a new moment which is the same
3135 *
3136 * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
3137 */
3138function inspect () {
3139    if (!this.isValid()) {

vendor: 29,676 bytes, lines 3140-4250

3140        return 'moment.invalid(/* ' + this._i + ' */)';
3141    }
3142    var func = 'moment';
3143    var zone = '';
3144    if (!this.isLocal()) {
3145        func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
3146        zone = 'Z';
3147    }
3148    var prefix = '[' + func + '("]';
3149    var year = (0 < this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
3150    var datetime = '-MM-DD[T]HH:mm:ss.SSS';
3151    var suffix = zone + '[")]';
3152
3153    return this.format(prefix + year + datetime + suffix);
3154}
3155
3156function format (inputString) {
3157    if (!inputString) {
3158        inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
3159    }
3160    var output = formatMoment(this, inputString);
3161    return this.localeData().postformat(output);
3162}
3163
3164function from (time, withoutSuffix) {
3165    if (this.isValid() &&
3166            ((isMoment(time) && time.isValid()) ||
3167             createLocal(time).isValid())) {
3168        return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
3169    } else {
3170        return this.localeData().invalidDate();
3171    }
3172}
3173
3174function fromNow (withoutSuffix) {
3175    return this.from(createLocal(), withoutSuffix);
3176}
3177
3178function to (time, withoutSuffix) {
3179    if (this.isValid() &&
3180            ((isMoment(time) && time.isValid()) ||
3181             createLocal(time).isValid())) {
3182        return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
3183    } else {
3184        return this.localeData().invalidDate();
3185    }
3186}
3187
3188function toNow (withoutSuffix) {
3189    return this.to(createLocal(), withoutSuffix);
3190}
3191
3192// If passed a locale key, it will set the locale for this
3193// instance.  Otherwise, it will return the locale configuration
3194// variables for this instance.
3195function locale (key) {
3196    var newLocaleData;
3197
3198    if (key === undefined) {
3199        return this._locale._abbr;
3200    } else {
3201        newLocaleData = getLocale(key);
3202        if (newLocaleData != null) {
3203            this._locale = newLocaleData;
3204        }
3205        return this;
3206    }
3207}
3208
3209var lang = deprecate(
3210    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
3211    function (key) {
3212        if (key === undefined) {
3213            return this.localeData();
3214        } else {
3215            return this.locale(key);
3216        }
3217    }
3218);
3219
3220function localeData () {
3221    return this._locale;
3222}
3223
3224function startOf (units) {
3225    units = normalizeUnits(units);
3226    // the following switch intentionally omits break keywords
3227    // to utilize falling through the cases.
3228    switch (units) {
3229        case 'year':
3230            this.month(0);
3231            /* falls through */
3232        case 'quarter':
3233        case 'month':
3234            this.date(1);
3235            /* falls through */
3236        case 'week':
3237        case 'isoWeek':
3238        case 'day':
3239        case 'date':
3240            this.hours(0);
3241            /* falls through */
3242        case 'hour':
3243            this.minutes(0);
3244            /* falls through */
3245        case 'minute':
3246            this.seconds(0);
3247            /* falls through */
3248        case 'second':
3249            this.milliseconds(0);
3250    }
3251
3252    // weeks are a special case
3253    if (units === 'week') {
3254        this.weekday(0);
3255    }
3256    if (units === 'isoWeek') {
3257        this.isoWeekday(1);
3258    }
3259
3260    // quarters are also special
3261    if (units === 'quarter') {
3262        this.month(Math.floor(this.month() / 3) * 3);
3263    }
3264
3265    return this;
3266}
3267
3268function endOf (units) {
3269    units = normalizeUnits(units);
3270    if (units === undefined || units === 'millisecond') {
3271        return this;
3272    }
3273
3274    // 'date' is an alias for 'day', so it should be considered as such.
3275    if (units === 'date') {
3276        units = 'day';
3277    }
3278
3279    return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
3280}
3281
3282function valueOf () {
3283    return this._d.valueOf() - ((this._offset || 0) * 60000);
3284}
3285
3286function unix () {
3287    return Math.floor(this.valueOf() / 1000);
3288}
3289
3290function toDate () {
3291    return new Date(this.valueOf());
3292}
3293
3294function toArray () {
3295    var m = this;
3296    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
3297}
3298
3299function toObject () {
3300    var m = this;
3301    return {
3302        years: m.year(),
3303        months: m.month(),
3304        date: m.date(),
3305        hours: m.hours(),
3306        minutes: m.minutes(),
3307        seconds: m.seconds(),
3308        milliseconds: m.milliseconds()
3309    };
3310}
3311
3312function toJSON () {
3313    // new Date(NaN).toJSON() === null
3314    return this.isValid() ? this.toISOString() : null;
3315}
3316
3317function isValid$1 () {
3318    return isValid(this);
3319}
3320
3321function parsingFlags () {
3322    return extend({}, getParsingFlags(this));
3323}
3324
3325function invalidAt () {
3326    return getParsingFlags(this).overflow;
3327}
3328
3329function creationData() {
3330    return {
3331        input: this._i,
3332        format: this._f,
3333        locale: this._locale,
3334        isUTC: this._isUTC,
3335        strict: this._strict
3336    };
3337}
3338
3339// FORMATTING
3340
3341addFormatToken(0, ['gg', 2], 0, function () {
3342    return this.weekYear() % 100;
3343});
3344
3345addFormatToken(0, ['GG', 2], 0, function () {
3346    return this.isoWeekYear() % 100;
3347});
3348
3349function addWeekYearFormatToken (token, getter) {
3350    addFormatToken(0, [token, token.length], 0, getter);
3351}
3352
3353addWeekYearFormatToken('gggg',     'weekYear');
3354addWeekYearFormatToken('ggggg',    'weekYear');
3355addWeekYearFormatToken('GGGG',  'isoWeekYear');
3356addWeekYearFormatToken('GGGGG', 'isoWeekYear');
3357
3358// ALIASES
3359
3360addUnitAlias('weekYear', 'gg');
3361addUnitAlias('isoWeekYear', 'GG');
3362
3363// PRIORITY
3364
3365addUnitPriority('weekYear', 1);
3366addUnitPriority('isoWeekYear', 1);
3367
3368
3369// PARSING
3370
3371addRegexToken('G',      matchSigned);
3372addRegexToken('g',      matchSigned);
3373addRegexToken('GG',     match1to2, match2);
3374addRegexToken('gg',     match1to2, match2);
3375addRegexToken('GGGG',   match1to4, match4);
3376addRegexToken('gggg',   match1to4, match4);
3377addRegexToken('GGGGG',  match1to6, match6);
3378addRegexToken('ggggg',  match1to6, match6);
3379
3380addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
3381    week[token.substr(0, 2)] = toInt(input);
3382});
3383
3384addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
3385    week[token] = hooks.parseTwoDigitYear(input);
3386});
3387
3388// MOMENTS
3389
3390function getSetWeekYear (input) {
3391    return getSetWeekYearHelper.call(this,
3392            input,
3393            this.week(),
3394            this.weekday(),
3395            this.localeData()._week.dow,
3396            this.localeData()._week.doy);
3397}
3398
3399function getSetISOWeekYear (input) {
3400    return getSetWeekYearHelper.call(this,
3401            input, this.isoWeek(), this.isoWeekday(), 1, 4);
3402}
3403
3404function getISOWeeksInYear () {
3405    return weeksInYear(this.year(), 1, 4);
3406}
3407
3408function getWeeksInYear () {
3409    var weekInfo = this.localeData()._week;
3410    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
3411}
3412
3413function getSetWeekYearHelper(input, week, weekday, dow, doy) {
3414    var weeksTarget;
3415    if (input == null) {
3416        return weekOfYear(this, dow, doy).year;
3417    } else {
3418        weeksTarget = weeksInYear(input, dow, doy);
3419        if (week > weeksTarget) {
3420            week = weeksTarget;
3421        }
3422        return setWeekAll.call(this, input, week, weekday, dow, doy);
3423    }
3424}
3425
3426function setWeekAll(weekYear, week, weekday, dow, doy) {
3427    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
3428        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
3429
3430    this.year(date.getUTCFullYear());
3431    this.month(date.getUTCMonth());
3432    this.date(date.getUTCDate());
3433    return this;
3434}
3435
3436// FORMATTING
3437
3438addFormatToken('Q', 0, 'Qo', 'quarter');
3439
3440// ALIASES
3441
3442addUnitAlias('quarter', 'Q');
3443
3444// PRIORITY
3445
3446addUnitPriority('quarter', 7);
3447
3448// PARSING
3449
3450addRegexToken('Q', match1);
3451addParseToken('Q', function (input, array) {
3452    array[MONTH] = (toInt(input) - 1) * 3;
3453});
3454
3455// MOMENTS
3456
3457function getSetQuarter (input) {
3458    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
3459}
3460
3461// FORMATTING
3462
3463addFormatToken('D', ['DD', 2], 'Do', 'date');
3464
3465// ALIASES
3466
3467addUnitAlias('date', 'D');
3468
3469// PRIOROITY
3470addUnitPriority('date', 9);
3471
3472// PARSING
3473
3474addRegexToken('D',  match1to2);
3475addRegexToken('DD', match1to2, match2);
3476addRegexToken('Do', function (isStrict, locale) {
3477    return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
3478});
3479
3480addParseToken(['D', 'DD'], DATE);
3481addParseToken('Do', function (input, array) {
3482    array[DATE] = toInt(input.match(match1to2)[0], 10);
3483});
3484
3485// MOMENTS
3486
3487var getSetDayOfMonth = makeGetSet('Date', true);
3488
3489// FORMATTING
3490
3491addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
3492
3493// ALIASES
3494
3495addUnitAlias('dayOfYear', 'DDD');
3496
3497// PRIORITY
3498addUnitPriority('dayOfYear', 4);
3499
3500// PARSING
3501
3502addRegexToken('DDD',  match1to3);
3503addRegexToken('DDDD', match3);
3504addParseToken(['DDD', 'DDDD'], function (input, array, config) {
3505    config._dayOfYear = toInt(input);
3506});
3507
3508// HELPERS
3509
3510// MOMENTS
3511
3512function getSetDayOfYear (input) {
3513    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
3514    return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
3515}
3516
3517// FORMATTING
3518
3519addFormatToken('m', ['mm', 2], 0, 'minute');
3520
3521// ALIASES
3522
3523addUnitAlias('minute', 'm');
3524
3525// PRIORITY
3526
3527addUnitPriority('minute', 14);
3528
3529// PARSING
3530
3531addRegexToken('m',  match1to2);
3532addRegexToken('mm', match1to2, match2);
3533addParseToken(['m', 'mm'], MINUTE);
3534
3535// MOMENTS
3536
3537var getSetMinute = makeGetSet('Minutes', false);
3538
3539// FORMATTING
3540
3541addFormatToken('s', ['ss', 2], 0, 'second');
3542
3543// ALIASES
3544
3545addUnitAlias('second', 's');
3546
3547// PRIORITY
3548
3549addUnitPriority('second', 15);
3550
3551// PARSING
3552
3553addRegexToken('s',  match1to2);
3554addRegexToken('ss', match1to2, match2);
3555addParseToken(['s', 'ss'], SECOND);
3556
3557// MOMENTS
3558
3559var getSetSecond = makeGetSet('Seconds', false);
3560
3561// FORMATTING
3562
3563addFormatToken('S', 0, 0, function () {
3564    return ~~(this.millisecond() / 100);
3565});
3566
3567addFormatToken(0, ['SS', 2], 0, function () {
3568    return ~~(this.millisecond() / 10);
3569});
3570
3571addFormatToken(0, ['SSS', 3], 0, 'millisecond');
3572addFormatToken(0, ['SSSS', 4], 0, function () {
3573    return this.millisecond() * 10;
3574});
3575addFormatToken(0, ['SSSSS', 5], 0, function () {
3576    return this.millisecond() * 100;
3577});
3578addFormatToken(0, ['SSSSSS', 6], 0, function () {
3579    return this.millisecond() * 1000;
3580});
3581addFormatToken(0, ['SSSSSSS', 7], 0, function () {
3582    return this.millisecond() * 10000;
3583});
3584addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
3585    return this.millisecond() * 100000;
3586});
3587addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
3588    return this.millisecond() * 1000000;
3589});
3590
3591
3592// ALIASES
3593
3594addUnitAlias('millisecond', 'ms');
3595
3596// PRIORITY
3597
3598addUnitPriority('millisecond', 16);
3599
3600// PARSING
3601
3602addRegexToken('S',    match1to3, match1);
3603addRegexToken('SS',   match1to3, match2);
3604addRegexToken('SSS',  match1to3, match3);
3605
3606var token;
3607for (token = 'SSSS'; token.length <= 9; token += 'S') {
3608    addRegexToken(token, matchUnsigned);
3609}
3610
3611function parseMs(input, array) {
3612    array[MILLISECOND] = toInt(('0.' + input) * 1000);
3613}
3614
3615for (token = 'S'; token.length <= 9; token += 'S') {
3616    addParseToken(token, parseMs);
3617}
3618// MOMENTS
3619
3620var getSetMillisecond = makeGetSet('Milliseconds', false);
3621
3622// FORMATTING
3623
3624addFormatToken('z',  0, 0, 'zoneAbbr');
3625addFormatToken('zz', 0, 0, 'zoneName');
3626
3627// MOMENTS
3628
3629function getZoneAbbr () {
3630    return this._isUTC ? 'UTC' : '';
3631}
3632
3633function getZoneName () {
3634    return this._isUTC ? 'Coordinated Universal Time' : '';
3635}
3636
3637var proto = Moment.prototype;
3638
3639proto.add               = add;
3640proto.calendar          = calendar$1;
3641proto.clone             = clone;
3642proto.diff              = diff;
3643proto.endOf             = endOf;
3644proto.format            = format;
3645proto.from              = from;
3646proto.fromNow           = fromNow;
3647proto.to                = to;
3648proto.toNow             = toNow;
3649proto.get               = stringGet;
3650proto.invalidAt         = invalidAt;
3651proto.isAfter           = isAfter;
3652proto.isBefore          = isBefore;
3653proto.isBetween         = isBetween;
3654proto.isSame            = isSame;
3655proto.isSameOrAfter     = isSameOrAfter;
3656proto.isSameOrBefore    = isSameOrBefore;
3657proto.isValid           = isValid$1;
3658proto.lang              = lang;
3659proto.locale            = locale;
3660proto.localeData        = localeData;
3661proto.max               = prototypeMax;
3662proto.min               = prototypeMin;
3663proto.parsingFlags      = parsingFlags;
3664proto.set               = stringSet;
3665proto.startOf           = startOf;
3666proto.subtract          = subtract;
3667proto.toArray           = toArray;
3668proto.toObject          = toObject;
3669proto.toDate            = toDate;
3670proto.toISOString       = toISOString;
3671proto.inspect           = inspect;
3672proto.toJSON            = toJSON;
3673proto.toString          = toString;
3674proto.unix              = unix;
3675proto.valueOf           = valueOf;
3676proto.creationData      = creationData;
3677
3678// Year
3679proto.year       = getSetYear;
3680proto.isLeapYear = getIsLeapYear;
3681
3682// Week Year
3683proto.weekYear    = getSetWeekYear;
3684proto.isoWeekYear = getSetISOWeekYear;
3685
3686// Quarter
3687proto.quarter = proto.quarters = getSetQuarter;
3688
3689// Month
3690proto.month       = getSetMonth;
3691proto.daysInMonth = getDaysInMonth;
3692
3693// Week
3694proto.week           = proto.weeks        = getSetWeek;
3695proto.isoWeek        = proto.isoWeeks     = getSetISOWeek;
3696proto.weeksInYear    = getWeeksInYear;
3697proto.isoWeeksInYear = getISOWeeksInYear;
3698
3699// Day
3700proto.date       = getSetDayOfMonth;
3701proto.day        = proto.days             = getSetDayOfWeek;
3702proto.weekday    = getSetLocaleDayOfWeek;
3703proto.isoWeekday = getSetISODayOfWeek;
3704proto.dayOfYear  = getSetDayOfYear;
3705
3706// Hour
3707proto.hour = proto.hours = getSetHour;
3708
3709// Minute
3710proto.minute = proto.minutes = getSetMinute;
3711
3712// Second
3713proto.second = proto.seconds = getSetSecond;
3714
3715// Millisecond
3716proto.millisecond = proto.milliseconds = getSetMillisecond;
3717
3718// Offset
3719proto.utcOffset            = getSetOffset;
3720proto.utc                  = setOffsetToUTC;
3721proto.local                = setOffsetToLocal;
3722proto.parseZone            = setOffsetToParsedOffset;
3723proto.hasAlignedHourOffset = hasAlignedHourOffset;
3724proto.isDST                = isDaylightSavingTime;
3725proto.isLocal              = isLocal;
3726proto.isUtcOffset          = isUtcOffset;
3727proto.isUtc                = isUtc;
3728proto.isUTC                = isUtc;
3729
3730// Timezone
3731proto.zoneAbbr = getZoneAbbr;
3732proto.zoneName = getZoneName;
3733
3734// Deprecations
3735proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
3736proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
3737proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
3738proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
3739proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
3740
3741function createUnix (input) {
3742    return createLocal(input * 1000);
3743}
3744
3745function createInZone () {
3746    return createLocal.apply(null, arguments).parseZone();
3747}
3748
3749function preParsePostFormat (string) {
3750    return string;
3751}
3752
3753var proto$1 = Locale.prototype;
3754
3755proto$1.calendar        = calendar;
3756proto$1.longDateFormat  = longDateFormat;
3757proto$1.invalidDate     = invalidDate;
3758proto$1.ordinal         = ordinal;
3759proto$1.preparse        = preParsePostFormat;
3760proto$1.postformat      = preParsePostFormat;
3761proto$1.relativeTime    = relativeTime;
3762proto$1.pastFuture      = pastFuture;
3763proto$1.set             = set;
3764
3765// Month
3766proto$1.months            =        localeMonths;
3767proto$1.monthsShort       =        localeMonthsShort;
3768proto$1.monthsParse       =        localeMonthsParse;
3769proto$1.monthsRegex       = monthsRegex;
3770proto$1.monthsShortRegex  = monthsShortRegex;
3771
3772// Week
3773proto$1.week = localeWeek;
3774proto$1.firstDayOfYear = localeFirstDayOfYear;
3775proto$1.firstDayOfWeek = localeFirstDayOfWeek;
3776
3777// Day of Week
3778proto$1.weekdays       =        localeWeekdays;
3779proto$1.weekdaysMin    =        localeWeekdaysMin;
3780proto$1.weekdaysShort  =        localeWeekdaysShort;
3781proto$1.weekdaysParse  =        localeWeekdaysParse;
3782
3783proto$1.weekdaysRegex       =        weekdaysRegex;
3784proto$1.weekdaysShortRegex  =        weekdaysShortRegex;
3785proto$1.weekdaysMinRegex    =        weekdaysMinRegex;
3786
3787// Hours
3788proto$1.isPM = localeIsPM;
3789proto$1.meridiem = localeMeridiem;
3790
3791function get$1 (format, index, field, setter) {
3792    var locale = getLocale();
3793    var utc = createUTC().set(setter, index);
3794    return locale[field](utc, format);
3795}
3796
3797function listMonthsImpl (format, index, field) {
3798    if (isNumber(format)) {
3799        index = format;
3800        format = undefined;
3801    }
3802
3803    format = format || '';
3804
3805    if (index != null) {
3806        return get$1(format, index, field, 'month');
3807    }
3808
3809    var i;
3810    var out = [];
3811    for (i = 0; i < 12; i++) {
3812        out[i] = get$1(format, i, field, 'month');
3813    }
3814    return out;
3815}
3816
3817// ()
3818// (5)
3819// (fmt, 5)
3820// (fmt)
3821// (true)
3822// (true, 5)
3823// (true, fmt, 5)
3824// (true, fmt)
3825function listWeekdaysImpl (localeSorted, format, index, field) {
3826    if (typeof localeSorted === 'boolean') {
3827        if (isNumber(format)) {
3828            index = format;
3829            format = undefined;
3830        }
3831
3832        format = format || '';
3833    } else {
3834        format = localeSorted;
3835        index = format;
3836        localeSorted = false;
3837
3838        if (isNumber(format)) {
3839            index = format;
3840            format = undefined;
3841        }
3842
3843        format = format || '';
3844    }
3845
3846    var locale = getLocale(),
3847        shift = localeSorted ? locale._week.dow : 0;
3848
3849    if (index != null) {
3850        return get$1(format, (index + shift) % 7, field, 'day');
3851    }
3852
3853    var i;
3854    var out = [];
3855    for (i = 0; i < 7; i++) {
3856        out[i] = get$1(format, (i + shift) % 7, field, 'day');
3857    }
3858    return out;
3859}
3860
3861function listMonths (format, index) {
3862    return listMonthsImpl(format, index, 'months');
3863}
3864
3865function listMonthsShort (format, index) {
3866    return listMonthsImpl(format, index, 'monthsShort');
3867}
3868
3869function listWeekdays (localeSorted, format, index) {
3870    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
3871}
3872
3873function listWeekdaysShort (localeSorted, format, index) {
3874    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
3875}
3876
3877function listWeekdaysMin (localeSorted, format, index) {
3878    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
3879}
3880
3881getSetGlobalLocale('en', {
3882    ordinalParse: /\d{1,2}(th|st|nd|rd)/,
3883    ordinal : function (number) {
3884        var b = number % 10,
3885            output = (toInt(number % 100 / 10) === 1) ? 'th' :
3886            (b === 1) ? 'st' :
3887            (b === 2) ? 'nd' :
3888            (b === 3) ? 'rd' : 'th';
3889        return number + output;
3890    }
3891});
3892
3893// Side effect imports
3894hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
3895hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
3896
3897var mathAbs = Math.abs;
3898
3899function abs () {
3900    var data           = this._data;
3901
3902    this._milliseconds = mathAbs(this._milliseconds);
3903    this._days         = mathAbs(this._days);
3904    this._months       = mathAbs(this._months);
3905
3906    data.milliseconds  = mathAbs(data.milliseconds);
3907    data.seconds       = mathAbs(data.seconds);
3908    data.minutes       = mathAbs(data.minutes);
3909    data.hours         = mathAbs(data.hours);
3910    data.months        = mathAbs(data.months);
3911    data.years         = mathAbs(data.years);
3912
3913    return this;
3914}
3915
3916function addSubtract$1 (duration, input, value, direction) {
3917    var other = createDuration(input, value);
3918
3919    duration._milliseconds += direction * other._milliseconds;
3920    duration._days         += direction * other._days;
3921    duration._months       += direction * other._months;
3922
3923    return duration._bubble();
3924}
3925
3926// supports only 2.0-style add(1, 's') or add(duration)
3927function add$1 (input, value) {
3928    return addSubtract$1(this, input, value, 1);
3929}
3930
3931// supports only 2.0-style subtract(1, 's') or subtract(duration)
3932function subtract$1 (input, value) {
3933    return addSubtract$1(this, input, value, -1);
3934}
3935
3936function absCeil (number) {
3937    if (number < 0) {
3938        return Math.floor(number);
3939    } else {
3940        return Math.ceil(number);
3941    }
3942}
3943
3944function bubble () {
3945    var milliseconds = this._milliseconds;
3946    var days         = this._days;
3947    var months       = this._months;
3948    var data         = this._data;
3949    var seconds, minutes, hours, years, monthsFromDays;
3950
3951    // if we have a mix of positive and negative values, bubble down first
3952    // check: https://github.com/moment/moment/issues/2166
3953    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
3954            (milliseconds <= 0 && days <= 0 && months <= 0))) {
3955        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
3956        days = 0;
3957        months = 0;
3958    }
3959
3960    // The following code bubbles up values, see the tests for
3961    // examples of what that means.
3962    data.milliseconds = milliseconds % 1000;
3963
3964    seconds           = absFloor(milliseconds / 1000);
3965    data.seconds      = seconds % 60;
3966
3967    minutes           = absFloor(seconds / 60);
3968    data.minutes      = minutes % 60;
3969
3970    hours             = absFloor(minutes / 60);
3971    data.hours        = hours % 24;
3972
3973    days += absFloor(hours / 24);
3974
3975    // convert days to months
3976    monthsFromDays = absFloor(daysToMonths(days));
3977    months += monthsFromDays;
3978    days -= absCeil(monthsToDays(monthsFromDays));
3979
3980    // 12 months -> 1 year
3981    years = absFloor(months / 12);
3982    months %= 12;
3983
3984    data.days   = days;
3985    data.months = months;
3986    data.years  = years;
3987
3988    return this;
3989}
3990
3991function daysToMonths (days) {
3992    // 400 years have 146097 days (taking into account leap year rules)
3993    // 400 years have 12 months === 4800
3994    return days * 4800 / 146097;
3995}
3996
3997function monthsToDays (months) {
3998    // the reverse of daysToMonths
3999    return months * 146097 / 4800;
4000}
4001
4002function as (units) {
4003    var days;
4004    var months;
4005    var milliseconds = this._milliseconds;
4006
4007    units = normalizeUnits(units);
4008
4009    if (units === 'month' || units === 'year') {
4010        days   = this._days   + milliseconds / 864e5;
4011        months = this._months + daysToMonths(days);
4012        return units === 'month' ? months : months / 12;
4013    } else {
4014        // handle milliseconds separately because of floating point math errors (issue #1867)
4015        days = this._days + Math.round(monthsToDays(this._months));
4016        switch (units) {
4017            case 'week'   : return days / 7     + milliseconds / 6048e5;
4018            case 'day'    : return days         + milliseconds / 864e5;
4019            case 'hour'   : return days * 24    + milliseconds / 36e5;
4020            case 'minute' : return days * 1440  + milliseconds / 6e4;
4021            case 'second' : return days * 86400 + milliseconds / 1000;
4022            // Math.floor prevents floating point math errors here
4023            case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
4024            default: throw new Error('Unknown unit ' + units);
4025        }
4026    }
4027}
4028
4029// TODO: Use this.as('ms')?
4030function valueOf$1 () {
4031    return (
4032        this._milliseconds +
4033        this._days * 864e5 +
4034        (this._months % 12) * 2592e6 +
4035        toInt(this._months / 12) * 31536e6
4036    );
4037}
4038
4039function makeAs (alias) {
4040    return function () {
4041        return this.as(alias);
4042    };
4043}
4044
4045var asMilliseconds = makeAs('ms');
4046var asSeconds      = makeAs('s');
4047var asMinutes      = makeAs('m');
4048var asHours        = makeAs('h');
4049var asDays         = makeAs('d');
4050var asWeeks        = makeAs('w');
4051var asMonths       = makeAs('M');
4052var asYears        = makeAs('y');
4053
4054function get$2 (units) {
4055    units = normalizeUnits(units);
4056    return this[units + 's']();
4057}
4058
4059function makeGetter(name) {
4060    return function () {
4061        return this._data[name];
4062    };
4063}
4064
4065var milliseconds = makeGetter('milliseconds');
4066var seconds      = makeGetter('seconds');
4067var minutes      = makeGetter('minutes');
4068var hours        = makeGetter('hours');
4069var days         = makeGetter('days');
4070var months       = makeGetter('months');
4071var years        = makeGetter('years');
4072
4073function weeks () {
4074    return absFloor(this.days() / 7);
4075}
4076
4077var round = Math.round;
4078var thresholds = {
4079    s: 45,  // seconds to minute
4080    m: 45,  // minutes to hour
4081    h: 22,  // hours to day
4082    d: 26,  // days to month
4083    M: 11   // months to year
4084};
4085
4086// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
4087function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
4088    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
4089}
4090
4091function relativeTime$1 (posNegDuration, withoutSuffix, locale) {
4092    var duration = createDuration(posNegDuration).abs();
4093    var seconds  = round(duration.as('s'));
4094    var minutes  = round(duration.as('m'));
4095    var hours    = round(duration.as('h'));
4096    var days     = round(duration.as('d'));
4097    var months   = round(duration.as('M'));
4098    var years    = round(duration.as('y'));
4099
4100    var a = seconds < thresholds.s && ['s', seconds]  ||
4101            minutes <= 1           && ['m']           ||
4102            minutes < thresholds.m && ['mm', minutes] ||
4103            hours   <= 1           && ['h']           ||
4104            hours   < thresholds.h && ['hh', hours]   ||
4105            days    <= 1           && ['d']           ||
4106            days    < thresholds.d && ['dd', days]    ||
4107            months  <= 1           && ['M']           ||
4108            months  < thresholds.M && ['MM', months]  ||
4109            years   <= 1           && ['y']           || ['yy', years];
4110
4111    a[2] = withoutSuffix;
4112    a[3] = +posNegDuration > 0;
4113    a[4] = locale;
4114    return substituteTimeAgo.apply(null, a);
4115}
4116
4117// This function allows you to set the rounding function for relative time strings
4118function getSetRelativeTimeRounding (roundingFunction) {
4119    if (roundingFunction === undefined) {
4120        return round;
4121    }
4122    if (typeof(roundingFunction) === 'function') {
4123        round = roundingFunction;
4124        return true;
4125    }
4126    return false;
4127}
4128
4129// This function allows you to set a threshold for relative time strings
4130function getSetRelativeTimeThreshold (threshold, limit) {
4131    if (thresholds[threshold] === undefined) {
4132        return false;
4133    }
4134    if (limit === undefined) {
4135        return thresholds[threshold];
4136    }
4137    thresholds[threshold] = limit;
4138    return true;
4139}
4140
4141function humanize (withSuffix) {
4142    var locale = this.localeData();
4143    var output = relativeTime$1(this, !withSuffix, locale);
4144
4145    if (withSuffix) {
4146        output = locale.pastFuture(+this, output);
4147    }
4148
4149    return locale.postformat(output);
4150}
4151
4152var abs$1 = Math.abs;
4153
4154function toISOString$1() {
4155    // for ISO strings we do not use the normal bubbling rules:
4156    //  * milliseconds bubble up until they become hours
4157    //  * days do not bubble at all
4158    //  * months bubble up until they become years
4159    // This is because there is no context-free conversion between hours and days
4160    // (think of clock changes)
4161    // and also not between days and months (28-31 days per month)
4162    var seconds = abs$1(this._milliseconds) / 1000;
4163    var days         = abs$1(this._days);
4164    var months       = abs$1(this._months);
4165    var minutes, hours, years;
4166
4167    // 3600 seconds -> 60 minutes -> 1 hour
4168    minutes           = absFloor(seconds / 60);
4169    hours             = absFloor(minutes / 60);
4170    seconds %= 60;
4171    minutes %= 60;
4172
4173    // 12 months -> 1 year
4174    years  = absFloor(months / 12);
4175    months %= 12;
4176
4177
4178    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
4179    var Y = years;
4180    var M = months;
4181    var D = days;
4182    var h = hours;
4183    var m = minutes;
4184    var s = seconds;
4185    var total = this.asSeconds();
4186
4187    if (!total) {
4188        // this is the same as C#'s (Noda) and python (isodate)...
4189        // but not other JS (goog.date)
4190        return 'P0D';
4191    }
4192
4193    return (total < 0 ? '-' : '') +
4194        'P' +
4195        (Y ? Y + 'Y' : '') +
4196        (M ? M + 'M' : '') +
4197        (D ? D + 'D' : '') +
4198        ((h || m || s) ? 'T' : '') +
4199        (h ? h + 'H' : '') +
4200        (m ? m + 'M' : '') +
4201        (s ? s + 'S' : '');
4202}
4203
4204var proto$2 = Duration.prototype;
4205
4206proto$2.abs            = abs;
4207proto$2.add            = add$1;
4208proto$2.subtract       = subtract$1;
4209proto$2.as             = as;
4210proto$2.asMilliseconds = asMilliseconds;
4211proto$2.asSeconds      = asSeconds;
4212proto$2.asMinutes      = asMinutes;
4213proto$2.asHours        = asHours;
4214proto$2.asDays         = asDays;
4215proto$2.asWeeks        = asWeeks;
4216proto$2.asMonths       = asMonths;
4217proto$2.asYears        = asYears;
4218proto$2.valueOf        = valueOf$1;
4219proto$2._bubble        = bubble;
4220proto$2.get            = get$2;
4221proto$2.milliseconds   = milliseconds;
4222proto$2.seconds        = seconds;
4223proto$2.minutes        = minutes;
4224proto$2.hours          = hours;
4225proto$2.days           = days;
4226proto$2.weeks          = weeks;
4227proto$2.months         = months;
4228proto$2.years          = years;
4229proto$2.humanize       = humanize;
4230proto$2.toISOString    = toISOString$1;
4231proto$2.toString       = toISOString$1;
4232proto$2.toJSON         = toISOString$1;
4233proto$2.locale         = locale;
4234proto$2.localeData     = localeData;
4235
4236// Deprecations
4237proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
4238proto$2.lang = lang;
4239
4240// Side effect imports
4241
4242// FORMATTING
4243
4244addFormatToken('X', 0, 0, 'unix');
4245addFormatToken('x', 0, 0, 'valueOf');
4246
4247// PARSING
4248
4249addRegexToken('x', matchSigned);
4250addRegexToken('X', matchTimestamp);

4251addParseToken('X', function (input, array, config) {
4252    config._d = new Date(parseFloat(input, 10) * 1000);
4253});
4254addParseToken('x', function (input, array, config) {
4255    config._d = new Date(toInt(input));
4256});
4257
4258// Side effect imports
4259
4260//! moment.js
4261//! version : 2.17.1
4262//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
4263//! license : MIT
4264//! momentjs.com
4265
4266hooks.version = '2.17.1';
4267
4268setHookCallback(createLocal);
4269
4270hooks.fn                    = proto;
4271hooks.min                   = min;
4272hooks.max                   = max;
4273hooks.now                   = now;
4274hooks.utc                   = createUTC;
4275hooks.unix                  = createUnix;
4276hooks.months                = listMonths;
4277hooks.isDate                = isDate;
4278hooks.locale                = getSetGlobalLocale;
4279hooks.invalid               = createInvalid;
4280hooks.duration              = createDuration;
4281hooks.isMoment              = isMoment;
4282hooks.weekdays              = listWeekdays;
4283hooks.parseZone             = createInZone;
4284hooks.localeData            = getLocale;
4285hooks.isDuration            = isDuration;
4286hooks.monthsShort           = listMonthsShort;
4287hooks.weekdaysMin           = listWeekdaysMin;
4288hooks.defineLocale          = defineLocale;
4289hooks.updateLocale          = updateLocale;
4290hooks.locales               = listLocales;
4291hooks.weekdaysShort         = listWeekdaysShort;
4292hooks.normalizeUnits        = normalizeUnits;
4293hooks.relativeTimeRounding = getSetRelativeTimeRounding;
4294hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
4295hooks.calendarFormat        = getCalendarFormat;
4296hooks.prototype             = proto;
4297
4298//! moment.js locale configuration
4299//! locale : Afrikaans [af]
4300//! author : Werner Mollentze : https://github.com/wernerm
4301
4302hooks.defineLocale('af', {
4303    months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
4304    monthsShort : 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
4305    weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
4306    weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
4307    weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
4308    meridiemParse: /vm|nm/i,
4309    isPM : function (input) {
4310        return /^nm$/i.test(input);
4311    },
4312    meridiem : function (hours, minutes, isLower) {
4313        if (hours < 12) {
4314            return isLower ? 'vm' : 'VM';
4315        } else {
4316            return isLower ? 'nm' : 'NM';
4317        }
4318    },
4319    longDateFormat : {
4320        LT : 'HH:mm',
4321        LTS : 'HH:mm:ss',
4322        L : 'DD/MM/YYYY',
4323        LL : 'D MMMM YYYY',
4324        LLL : 'D MMMM YYYY HH:mm',
4325        LLLL : 'dddd, D MMMM YYYY HH:mm'
4326    },
4327    calendar : {
4328        sameDay : '[Vandag om] LT',
4329        nextDay : '[MÃ´re om] LT',
4330        nextWeek : 'dddd [om] LT',
4331        lastDay : '[Gister om] LT',
4332        lastWeek : '[Laas] dddd [om] LT',
4333        sameElse : 'L'
4334    },
4335    relativeTime : {
4336        future : 'oor %s',
4337        past : '%s gelede',
4338        s : '\'n paar sekondes',
4339        m : '\'n minuut',
4340        mm : '%d minute',
4341        h : '\'n uur',
4342        hh : '%d ure',
4343        d : '\'n dag',
4344        dd : '%d dae',
4345        M : '\'n maand',
4346        MM : '%d maande',
4347        y : '\'n jaar',
4348        yy : '%d jaar'
4349    },
4350    ordinalParse: /\d{1,2}(ste|de)/,
4351    ordinal : function (number) {
4352        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris RÃ¶ling : https://github.com/jjupiter
4353    },
4354    week : {
4355        dow : 1, // Maandag is die eerste dag van die week.
4356        doy : 4  // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
4357    }
4358});
4359
4360//! moment.js locale configuration
4361//! locale : Arabic (Algeria) [ar-dz]
4362//! author : Noureddine LOUAHEDJ : https://github.com/noureddineme
4363
4364hooks.defineLocale('ar-dz', {
4365    months : 'Ø¬Ø§ÙÙÙ_ÙÙÙØ±Ù_ÙØ§Ø±Ø³_Ø£ÙØ±ÙÙ_ÙØ§Ù_Ø¬ÙØ§Ù_Ø¬ÙÙÙÙØ©_Ø£ÙØª_Ø³Ø¨ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙÙØ¨Ø±_Ø¯ÙØ³ÙØ¨Ø±'.split('_'),
4366    monthsShort : 'Ø¬Ø§ÙÙÙ_ÙÙÙØ±Ù_ÙØ§Ø±Ø³_Ø£ÙØ±ÙÙ_ÙØ§Ù_Ø¬ÙØ§Ù_Ø¬ÙÙÙÙØ©_Ø£ÙØª_Ø³Ø¨ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙÙØ¨Ø±_Ø¯ÙØ³ÙØ¨Ø±'.split('_'),
4367    weekdays : 'Ø§ÙØ£ØØ¯_Ø§ÙØ¥Ø«ÙÙÙ_Ø§ÙØ«ÙØ§Ø«Ø§Ø¡_Ø§ÙØ£Ø±Ø¨Ø¹Ø§Ø¡_Ø§ÙØ®ÙÙØ³_Ø§ÙØ¬ÙØ¹Ø©_Ø§ÙØ³Ø¨Øª'.split('_'),
4368    weekdaysShort : 'Ø§ØØ¯_Ø§Ø«ÙÙÙ_Ø«ÙØ§Ø«Ø§Ø¡_Ø§Ø±Ø¨Ø¹Ø§Ø¡_Ø®ÙÙØ³_Ø¬ÙØ¹Ø©_Ø³Ø¨Øª'.split('_'),
4369    weekdaysMin : 'Ø£Ø_Ø¥Ø«_Ø«ÙØ§_Ø£Ø±_Ø®Ù_Ø¬Ù_Ø³Ø¨'.split('_'),
4370    weekdaysParseExact : true,
4371    longDateFormat : {
4372        LT : 'HH:mm',
4373        LTS : 'HH:mm:ss',
4374        L : 'DD/MM/YYYY',
4375        LL : 'D MMMM YYYY',
4376        LLL : 'D MMMM YYYY HH:mm',
4377        LLLL : 'dddd D MMMM YYYY HH:mm'
4378    },
4379    calendar : {
4380        sameDay: '[Ø§ÙÙÙÙ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4381        nextDay: '[ØºØ¯Ø§ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4382        nextWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4383        lastDay: '[Ø£ÙØ³ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4384        lastWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4385        sameElse: 'L'
4386    },
4387    relativeTime : {
4388        future : 'ÙÙ %s',
4389        past : 'ÙÙØ° %s',
4390        s : 'Ø«ÙØ§Ù',
4391        m : 'Ø¯ÙÙÙØ©',
4392        mm : '%d Ø¯ÙØ§Ø¦Ù',
4393        h : 'Ø³Ø§Ø¹Ø©',
4394        hh : '%d Ø³Ø§Ø¹Ø§Øª',
4395        d : 'ÙÙÙ',
4396        dd : '%d Ø£ÙØ§Ù',
4397        M : 'Ø´ÙØ±',
4398        MM : '%d Ø£Ø´ÙØ±',
4399        y : 'Ø³ÙØ©',
4400        yy : '%d Ø³ÙÙØ§Øª'
4401    },
4402    week : {
4403        dow : 0, // Sunday is the first day of the week.
4404        doy : 4  // The week that contains Jan 1st is the first week of the year.
4405    }
4406});
4407
4408//! moment.js locale configuration
4409//! locale : Arabic (Lybia) [ar-ly]
4410//! author : Ali Hmer: https://github.com/kikoanis
4411
4412var symbolMap = {
4413    '1': '1',
4414    '2': '2',
4415    '3': '3',
4416    '4': '4',
4417    '5': '5',
4418    '6': '6',
4419    '7': '7',
4420    '8': '8',
4421    '9': '9',
4422    '0': '0'
4423};
4424var pluralForm = function (n) {
4425    return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
4426};
4427var plurals = {
4428    s : ['Ø£ÙÙ ÙÙ Ø«Ø§ÙÙØ©', 'Ø«Ø§ÙÙØ© ÙØ§ØØ¯Ø©', ['Ø«Ø§ÙÙØªØ§Ù', 'Ø«Ø§ÙÙØªÙÙ'], '%d Ø«ÙØ§Ù', '%d Ø«Ø§ÙÙØ©', '%d Ø«Ø§ÙÙØ©'],
4429    m : ['Ø£ÙÙ ÙÙ Ø¯ÙÙÙØ©', 'Ø¯ÙÙÙØ© ÙØ§ØØ¯Ø©', ['Ø¯ÙÙÙØªØ§Ù', 'Ø¯ÙÙÙØªÙÙ'], '%d Ø¯ÙØ§Ø¦Ù', '%d Ø¯ÙÙÙØ©', '%d Ø¯ÙÙÙØ©'],

4430    h : ['Ø£ÙÙ ÙÙ Ø³Ø§Ø¹Ø©', 'Ø³Ø§Ø¹Ø© ÙØ§ØØ¯Ø©', ['Ø³Ø§Ø¹ØªØ§Ù', 'Ø³Ø§Ø¹ØªÙÙ'], '%d Ø³Ø§Ø¹Ø§Øª', '%d Ø³Ø§Ø¹Ø©', '%d Ø³Ø§Ø¹Ø©'],
4431    d : ['Ø£ÙÙ ÙÙ ÙÙÙ', 'ÙÙÙ ÙØ§ØØ¯', ['ÙÙÙØ§Ù', 'ÙÙÙÙÙ'], '%d Ø£ÙØ§Ù', '%d ÙÙÙÙØ§', '%d ÙÙÙ'],
4432    M : ['Ø£ÙÙ ÙÙ Ø´ÙØ±', 'Ø´ÙØ± ÙØ§ØØ¯', ['Ø´ÙØ±Ø§Ù', 'Ø´ÙØ±ÙÙ'], '%d Ø£Ø´ÙØ±', '%d Ø´ÙØ±Ø§', '%d Ø´ÙØ±'],
4433    y : ['Ø£ÙÙ ÙÙ Ø¹Ø§Ù', 'Ø¹Ø§Ù ÙØ§ØØ¯', ['Ø¹Ø§ÙØ§Ù', 'Ø¹Ø§ÙÙÙ'], '%d Ø£Ø¹ÙØ§Ù', '%d Ø¹Ø§ÙÙØ§', '%d Ø¹Ø§Ù']
4434};
4435var pluralize = function (u) {
4436    return function (number, withoutSuffix, string, isFuture) {
4437        var f = pluralForm(number),
4438            str = plurals[u][pluralForm(number)];
4439        if (f === 2) {
4440            str = str[withoutSuffix ? 0 : 1];
4441        }
4442        return str.replace(/%d/i, number);
4443    };
4444};
4445var months$1 = [
4446    'ÙÙØ§ÙØ±',
4447    'ÙØ¨Ø±Ø§ÙØ±',
4448    'ÙØ§Ø±Ø³',
4449    'Ø£Ø¨Ø±ÙÙ',
4450    'ÙØ§ÙÙ',
4451    'ÙÙÙÙÙ',
4452    'ÙÙÙÙÙ',
4453    'Ø£ØºØ³Ø·Ø³',
4454    'Ø³Ø¨ØªÙØ¨Ø±',
4455    'Ø£ÙØªÙØ¨Ø±',
4456    'ÙÙÙÙØ¨Ø±',
4457    'Ø¯ÙØ³ÙØ¨Ø±'
4458];
4459
4460hooks.defineLocale('ar-ly', {
4461    months : months$1,
4462    monthsShort : months$1,
4463    weekdays : 'Ø§ÙØ£ØØ¯_Ø§ÙØ¥Ø«ÙÙÙ_Ø§ÙØ«ÙØ§Ø«Ø§Ø¡_Ø§ÙØ£Ø±Ø¨Ø¹Ø§Ø¡_Ø§ÙØ®ÙÙØ³_Ø§ÙØ¬ÙØ¹Ø©_Ø§ÙØ³Ø¨Øª'.split('_'),
4464    weekdaysShort : 'Ø£ØØ¯_Ø¥Ø«ÙÙÙ_Ø«ÙØ§Ø«Ø§Ø¡_Ø£Ø±Ø¨Ø¹Ø§Ø¡_Ø®ÙÙØ³_Ø¬ÙØ¹Ø©_Ø³Ø¨Øª'.split('_'),
4465    weekdaysMin : 'Ø_Ù_Ø«_Ø±_Ø®_Ø¬_Ø³'.split('_'),
4466    weekdaysParseExact : true,
4467    longDateFormat : {
4468        LT : 'HH:mm',
4469        LTS : 'HH:mm:ss',
4470        L : 'D/\u200FM/\u200FYYYY',
4471        LL : 'D MMMM YYYY',
4472        LLL : 'D MMMM YYYY HH:mm',
4473        LLLL : 'dddd D MMMM YYYY HH:mm'
4474    },
4475    meridiemParse: /Øµ|Ù/,
4476    isPM : function (input) {
4477        return 'Ù' === input;
4478    },
4479    meridiem : function (hour, minute, isLower) {
4480        if (hour < 12) {
4481            return 'Øµ';
4482        } else {
4483            return 'Ù';
4484        }
4485    },
4486    calendar : {
4487        sameDay: '[Ø§ÙÙÙÙ Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4488        nextDay: '[ØºØ¯ÙØ§ Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4489        nextWeek: 'dddd [Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4490        lastDay: '[Ø£ÙØ³ Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4491        lastWeek: 'dddd [Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4492        sameElse: 'L'
4493    },
4494    relativeTime : {
4495        future : 'Ø¨Ø¹Ø¯ %s',
4496        past : 'ÙÙØ° %s',
4497        s : pluralize('s'),
4498        m : pluralize('m'),
4499        mm : pluralize('m'),
4500        h : pluralize('h'),
4501        hh : pluralize('h'),
4502        d : pluralize('d'),
4503        dd : pluralize('d'),
4504        M : pluralize('M'),
4505        MM : pluralize('M'),
4506        y : pluralize('y'),
4507        yy : pluralize('y')
4508    },
4509    preparse: function (string) {
4510        return string.replace(/\u200f/g, '').replace(/Ø/g, ',');
4511    },
4512    postformat: function (string) {
4513        return string.replace(/\d/g, function (match) {
4514            return symbolMap[match];
4515        }).replace(/,/g, 'Ø');
4516    },
4517    week : {
4518        dow : 6, // Saturday is the first day of the week.
4519        doy : 12  // The week that contains Jan 1st is the first week of the year.
4520    }
4521});
4522
4523//! moment.js locale configuration
4524//! locale : Arabic (Morocco) [ar-ma]
4525//! author : ElFadili Yassine : https://github.com/ElFadiliY
4526//! author : Abdel Said : https://github.com/abdelsaid
4527
4528hooks.defineLocale('ar-ma', {
4529    months : 'ÙÙØ§ÙØ±_ÙØ¨Ø±Ø§ÙØ±_ÙØ§Ø±Ø³_Ø£Ø¨Ø±ÙÙ_ÙØ§Ù_ÙÙÙÙÙ_ÙÙÙÙÙØ²_ØºØ´Øª_Ø´ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙØ¨Ø±_Ø¯Ø¬ÙØ¨Ø±'.split('_'),
4530    monthsShort : 'ÙÙØ§ÙØ±_ÙØ¨Ø±Ø§ÙØ±_ÙØ§Ø±Ø³_Ø£Ø¨Ø±ÙÙ_ÙØ§Ù_ÙÙÙÙÙ_ÙÙÙÙÙØ²_ØºØ´Øª_Ø´ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙØ¨Ø±_Ø¯Ø¬ÙØ¨Ø±'.split('_'),
4531    weekdays : 'Ø§ÙØ£ØØ¯_Ø§ÙØ¥ØªÙÙÙ_Ø§ÙØ«ÙØ§Ø«Ø§Ø¡_Ø§ÙØ£Ø±Ø¨Ø¹Ø§Ø¡_Ø§ÙØ®ÙÙØ³_Ø§ÙØ¬ÙØ¹Ø©_Ø§ÙØ³Ø¨Øª'.split('_'),
4532    weekdaysShort : 'Ø§ØØ¯_Ø§ØªÙÙÙ_Ø«ÙØ§Ø«Ø§Ø¡_Ø§Ø±Ø¨Ø¹Ø§Ø¡_Ø®ÙÙØ³_Ø¬ÙØ¹Ø©_Ø³Ø¨Øª'.split('_'),
4533    weekdaysMin : 'Ø_Ù_Ø«_Ø±_Ø®_Ø¬_Ø³'.split('_'),
4534    weekdaysParseExact : true,
4535    longDateFormat : {
4536        LT : 'HH:mm',
4537        LTS : 'HH:mm:ss',
4538        L : 'DD/MM/YYYY',
4539        LL : 'D MMMM YYYY',
4540        LLL : 'D MMMM YYYY HH:mm',
4541        LLLL : 'dddd D MMMM YYYY HH:mm'
4542    },
4543    calendar : {
4544        sameDay: '[Ø§ÙÙÙÙ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4545        nextDay: '[ØºØ¯Ø§ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4546        nextWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4547        lastDay: '[Ø£ÙØ³ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4548        lastWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4549        sameElse: 'L'
4550    },
4551    relativeTime : {
4552        future : 'ÙÙ %s',
4553        past : 'ÙÙØ° %s',
4554        s : 'Ø«ÙØ§Ù',
4555        m : 'Ø¯ÙÙÙØ©',
4556        mm : '%d Ø¯ÙØ§Ø¦Ù',
4557        h : 'Ø³Ø§Ø¹Ø©',
4558        hh : '%d Ø³Ø§Ø¹Ø§Øª',
4559        d : 'ÙÙÙ',
4560        dd : '%d Ø£ÙØ§Ù',
4561        M : 'Ø´ÙØ±',
4562        MM : '%d Ø£Ø´ÙØ±',
4563        y : 'Ø³ÙØ©',
4564        yy : '%d Ø³ÙÙØ§Øª'
4565    },
4566    week : {
4567        dow : 6, // Saturday is the first day of the week.
4568        doy : 12  // The week that contains Jan 1st is the first week of the year.
4569    }
4570});
4571
4572//! moment.js locale configuration
4573//! locale : Arabic (Saudi Arabia) [ar-sa]
4574//! author : Suhail Alkowaileet : https://github.com/xsoh
4575
4576var symbolMap$1 = {
4577    '1': 'Ù¡',
4578    '2': 'Ù¢',
4579    '3': 'Ù£',
4580    '4': 'Ù¤',
4581    '5': 'Ù¥',
4582    '6': 'Ù¦',
4583    '7': 'Ù§',
4584    '8': 'Ù¨',
4585    '9': 'Ù©',
4586    '0': 'Ù '
4587};
4588var numberMap = {
4589    'Ù¡': '1',
4590    'Ù¢': '2',
4591    'Ù£': '3',
4592    'Ù¤': '4',
4593    'Ù¥': '5',
4594    'Ù¦': '6',
4595    'Ù§': '7',
4596    'Ù¨': '8',
4597    'Ù©': '9',
4598    'Ù ': '0'
4599};
4600
4601hooks.defineLocale('ar-sa', {
4602    months : 'ÙÙØ§ÙØ±_ÙØ¨Ø±Ø§ÙØ±_ÙØ§Ø±Ø³_Ø£Ø¨Ø±ÙÙ_ÙØ§ÙÙ_ÙÙÙÙÙ_ÙÙÙÙÙ_Ø£ØºØ³Ø·Ø³_Ø³Ø¨ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙÙØ¨Ø±_Ø¯ÙØ³ÙØ¨Ø±'.split('_'),
4603    monthsShort : 'ÙÙØ§ÙØ±_ÙØ¨Ø±Ø§ÙØ±_ÙØ§Ø±Ø³_Ø£Ø¨Ø±ÙÙ_ÙØ§ÙÙ_ÙÙÙÙÙ_ÙÙÙÙÙ_Ø£ØºØ³Ø·Ø³_Ø³Ø¨ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙÙØ¨Ø±_Ø¯ÙØ³ÙØ¨Ø±'.split('_'),
4604    weekdays : 'Ø§ÙØ£ØØ¯_Ø§ÙØ¥Ø«ÙÙÙ_Ø§ÙØ«ÙØ§Ø«Ø§Ø¡_Ø§ÙØ£Ø±Ø¨Ø¹Ø§Ø¡_Ø§ÙØ®ÙÙØ³_Ø§ÙØ¬ÙØ¹Ø©_Ø§ÙØ³Ø¨Øª'.split('_'),
4605    weekdaysShort : 'Ø£ØØ¯_Ø¥Ø«ÙÙÙ_Ø«ÙØ§Ø«Ø§Ø¡_Ø£Ø±Ø¨Ø¹Ø§Ø¡_Ø®ÙÙØ³_Ø¬ÙØ¹Ø©_Ø³Ø¨Øª'.split('_'),
4606    weekdaysMin : 'Ø_Ù_Ø«_Ø±_Ø®_Ø¬_Ø³'.split('_'),
4607    weekdaysParseExact : true,
4608    longDateFormat : {
4609        LT : 'HH:mm',
4610        LTS : 'HH:mm:ss',
4611        L : 'DD/MM/YYYY',
4612        LL : 'D MMMM YYYY',
4613        LLL : 'D MMMM YYYY HH:mm',
4614        LLLL : 'dddd D MMMM YYYY HH:mm'
4615    },
4616    meridiemParse: /Øµ|Ù/,
4617    isPM : function (input) {
4618        return 'Ù' === input;
4619    },
4620    meridiem : function (hour, minute, isLower) {
4621        if (hour < 12) {
4622            return 'Øµ';
4623        } else {
4624            return 'Ù';
4625        }
4626    },
4627    calendar : {
4628        sameDay: '[Ø§ÙÙÙÙ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4629        nextDay: '[ØºØ¯Ø§ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4630        nextWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4631        lastDay: '[Ø£ÙØ³ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4632        lastWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4633        sameElse: 'L'
4634    },
4635    relativeTime : {
4636        future : 'ÙÙ %s',
4637        past : 'ÙÙØ° %s',
4638        s : 'Ø«ÙØ§Ù',
4639        m : 'Ø¯ÙÙÙØ©',
4640        mm : '%d Ø¯ÙØ§Ø¦Ù',
4641        h : 'Ø³Ø§Ø¹Ø©',
4642        hh : '%d Ø³Ø§Ø¹Ø§Øª',
4643        d : 'ÙÙÙ',
4644        dd : '%d Ø£ÙØ§Ù',
4645        M : 'Ø´ÙØ±',
4646        MM : '%d Ø£Ø´ÙØ±',
4647        y : 'Ø³ÙØ©',
4648        yy : '%d Ø³ÙÙØ§Øª'
4649    },
4650    preparse: function (string) {
4651        return string.replace(/[Ù¡Ù¢Ù£Ù¤Ù¥Ù¦Ù§Ù¨Ù©Ù ]/g, function (match) {
4652            return numberMap[match];
4653        }).replace(/Ø/g, ',');
4654    },
4655    postformat: function (string) {
4656        return string.replace(/\d/g, function (match) {
4657            return symbolMap$1[match];
4658        }).replace(/,/g, 'Ø');
4659    },
4660    week : {
4661        dow : 0, // Sunday is the first day of the week.
4662        doy : 6  // The week that contains Jan 1st is the first week of the year.
4663    }
4664});
4665
4666//! moment.js locale configuration
4667//! locale  :  Arabic (Tunisia) [ar-tn]
4668//! author : Nader Toukabri : https://github.com/naderio
4669
4670hooks.defineLocale('ar-tn', {
4671    months: 'Ø¬Ø§ÙÙÙ_ÙÙÙØ±Ù_ÙØ§Ø±Ø³_Ø£ÙØ±ÙÙ_ÙØ§Ù_Ø¬ÙØ§Ù_Ø¬ÙÙÙÙØ©_Ø£ÙØª_Ø³Ø¨ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙÙØ¨Ø±_Ø¯ÙØ³ÙØ¨Ø±'.split('_'),
4672    monthsShort: 'Ø¬Ø§ÙÙÙ_ÙÙÙØ±Ù_ÙØ§Ø±Ø³_Ø£ÙØ±ÙÙ_ÙØ§Ù_Ø¬ÙØ§Ù_Ø¬ÙÙÙÙØ©_Ø£ÙØª_Ø³Ø¨ØªÙØ¨Ø±_Ø£ÙØªÙØ¨Ø±_ÙÙÙÙØ¨Ø±_Ø¯ÙØ³ÙØ¨Ø±'.split('_'),
4673    weekdays: 'Ø§ÙØ£ØØ¯_Ø§ÙØ¥Ø«ÙÙÙ_Ø§ÙØ«ÙØ§Ø«Ø§Ø¡_Ø§ÙØ£Ø±Ø¨Ø¹Ø§Ø¡_Ø§ÙØ®ÙÙØ³_Ø§ÙØ¬ÙØ¹Ø©_Ø§ÙØ³Ø¨Øª'.split('_'),
4674    weekdaysShort: 'Ø£ØØ¯_Ø¥Ø«ÙÙÙ_Ø«ÙØ§Ø«Ø§Ø¡_Ø£Ø±Ø¨Ø¹Ø§Ø¡_Ø®ÙÙØ³_Ø¬ÙØ¹Ø©_Ø³Ø¨Øª'.split('_'),
4675    weekdaysMin: 'Ø_Ù_Ø«_Ø±_Ø®_Ø¬_Ø³'.split('_'),
4676    weekdaysParseExact : true,
4677    longDateFormat: {
4678        LT: 'HH:mm',
4679        LTS: 'HH:mm:ss',
4680        L: 'DD/MM/YYYY',
4681        LL: 'D MMMM YYYY',
4682        LLL: 'D MMMM YYYY HH:mm',
4683        LLLL: 'dddd D MMMM YYYY HH:mm'
4684    },
4685    calendar: {
4686        sameDay: '[Ø§ÙÙÙÙ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4687        nextDay: '[ØºØ¯Ø§ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4688        nextWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4689        lastDay: '[Ø£ÙØ³ Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4690        lastWeek: 'dddd [Ø¹ÙÙ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4691        sameElse: 'L'
4692    },
4693    relativeTime: {
4694        future: 'ÙÙ %s',
4695        past: 'ÙÙØ° %s',
4696        s: 'Ø«ÙØ§Ù',
4697        m: 'Ø¯ÙÙÙØ©',
4698        mm: '%d Ø¯ÙØ§Ø¦Ù',
4699        h: 'Ø³Ø§Ø¹Ø©',
4700        hh: '%d Ø³Ø§Ø¹Ø§Øª',
4701        d: 'ÙÙÙ',
4702        dd: '%d Ø£ÙØ§Ù',
4703        M: 'Ø´ÙØ±',
4704        MM: '%d Ø£Ø´ÙØ±',
4705        y: 'Ø³ÙØ©',
4706        yy: '%d Ø³ÙÙØ§Øª'
4707    },
4708    week: {
4709        dow: 1, // Monday is the first day of the week.
4710        doy: 4 // The week that contains Jan 4th is the first week of the year.
4711    }
4712});
4713
4714//! moment.js locale configuration
4715//! locale : Arabic [ar]
4716//! author : Abdel Said: https://github.com/abdelsaid
4717//! author : Ahmed Elkhatib
4718//! author : forabi https://github.com/forabi
4719
4720var symbolMap$2 = {
4721    '1': 'Ù¡',
4722    '2': 'Ù¢',
4723    '3': 'Ù£',
4724    '4': 'Ù¤',
4725    '5': 'Ù¥',
4726    '6': 'Ù¦',
4727    '7': 'Ù§',
4728    '8': 'Ù¨',
4729    '9': 'Ù©',
4730    '0': 'Ù '
4731};
4732var numberMap$1 = {
4733    'Ù¡': '1',
4734    'Ù¢': '2',
4735    'Ù£': '3',
4736    'Ù¤': '4',
4737    'Ù¥': '5',
4738    'Ù¦': '6',
4739    'Ù§': '7',
4740    'Ù¨': '8',
4741    'Ù©': '9',
4742    'Ù ': '0'
4743};
4744var pluralForm$1 = function (n) {
4745    return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
4746};
4747var plurals$1 = {
4748    s : ['Ø£ÙÙ ÙÙ Ø«Ø§ÙÙØ©', 'Ø«Ø§ÙÙØ© ÙØ§ØØ¯Ø©', ['Ø«Ø§ÙÙØªØ§Ù', 'Ø«Ø§ÙÙØªÙÙ'], '%d Ø«ÙØ§Ù', '%d Ø«Ø§ÙÙØ©', '%d Ø«Ø§ÙÙØ©'],
4749    m : ['Ø£ÙÙ ÙÙ Ø¯ÙÙÙØ©', 'Ø¯ÙÙÙØ© ÙØ§ØØ¯Ø©', ['Ø¯ÙÙÙØªØ§Ù', 'Ø¯ÙÙÙØªÙÙ'], '%d Ø¯ÙØ§Ø¦Ù', '%d Ø¯ÙÙÙØ©', '%d Ø¯ÙÙÙØ©'],

4750    h : ['Ø£ÙÙ ÙÙ Ø³Ø§Ø¹Ø©', 'Ø³Ø§Ø¹Ø© ÙØ§ØØ¯Ø©', ['Ø³Ø§Ø¹ØªØ§Ù', 'Ø³Ø§Ø¹ØªÙÙ'], '%d Ø³Ø§Ø¹Ø§Øª', '%d Ø³Ø§Ø¹Ø©', '%d Ø³Ø§Ø¹Ø©'],
4751    d : ['Ø£ÙÙ ÙÙ ÙÙÙ', 'ÙÙÙ ÙØ§ØØ¯', ['ÙÙÙØ§Ù', 'ÙÙÙÙÙ'], '%d Ø£ÙØ§Ù', '%d ÙÙÙÙØ§', '%d ÙÙÙ'],
4752    M : ['Ø£ÙÙ ÙÙ Ø´ÙØ±', 'Ø´ÙØ± ÙØ§ØØ¯', ['Ø´ÙØ±Ø§Ù', 'Ø´ÙØ±ÙÙ'], '%d Ø£Ø´ÙØ±', '%d Ø´ÙØ±Ø§', '%d Ø´ÙØ±'],
4753    y : ['Ø£ÙÙ ÙÙ Ø¹Ø§Ù', 'Ø¹Ø§Ù ÙØ§ØØ¯', ['Ø¹Ø§ÙØ§Ù', 'Ø¹Ø§ÙÙÙ'], '%d Ø£Ø¹ÙØ§Ù', '%d Ø¹Ø§ÙÙØ§', '%d Ø¹Ø§Ù']
4754};
4755var pluralize$1 = function (u) {
4756    return function (number, withoutSuffix, string, isFuture) {
4757        var f = pluralForm$1(number),
4758            str = plurals$1[u][pluralForm$1(number)];
4759        if (f === 2) {
4760            str = str[withoutSuffix ? 0 : 1];
4761        }
4762        return str.replace(/%d/i, number);
4763    };
4764};
4765var months$2 = [
4766    'ÙØ§ÙÙÙ Ø§ÙØ«Ø§ÙÙ ÙÙØ§ÙØ±',
4767    'Ø´Ø¨Ø§Ø· ÙØ¨Ø±Ø§ÙØ±',
4768    'Ø¢Ø°Ø§Ø± ÙØ§Ø±Ø³',
4769    'ÙÙØ³Ø§Ù Ø£Ø¨Ø±ÙÙ',
4770    'Ø£ÙØ§Ø± ÙØ§ÙÙ',
4771    'ØØ²ÙØ±Ø§Ù ÙÙÙÙÙ',
4772    'ØªÙÙØ² ÙÙÙÙÙ',
4773    'Ø¢Ø¨ Ø£ØºØ³Ø·Ø³',
4774    'Ø£ÙÙÙÙ Ø³Ø¨ØªÙØ¨Ø±',
4775    'ØªØ´Ø±ÙÙ Ø§ÙØ£ÙÙ Ø£ÙØªÙØ¨Ø±',
4776    'ØªØ´Ø±ÙÙ Ø§ÙØ«Ø§ÙÙ ÙÙÙÙØ¨Ø±',
4777    'ÙØ§ÙÙÙ Ø§ÙØ£ÙÙ Ø¯ÙØ³ÙØ¨Ø±'
4778];
4779
4780hooks.defineLocale('ar', {
4781    months : months$2,
4782    monthsShort : months$2,
4783    weekdays : 'Ø§ÙØ£ØØ¯_Ø§ÙØ¥Ø«ÙÙÙ_Ø§ÙØ«ÙØ§Ø«Ø§Ø¡_Ø§ÙØ£Ø±Ø¨Ø¹Ø§Ø¡_Ø§ÙØ®ÙÙØ³_Ø§ÙØ¬ÙØ¹Ø©_Ø§ÙØ³Ø¨Øª'.split('_'),
4784    weekdaysShort : 'Ø£ØØ¯_Ø¥Ø«ÙÙÙ_Ø«ÙØ§Ø«Ø§Ø¡_Ø£Ø±Ø¨Ø¹Ø§Ø¡_Ø®ÙÙØ³_Ø¬ÙØ¹Ø©_Ø³Ø¨Øª'.split('_'),
4785    weekdaysMin : 'Ø_Ù_Ø«_Ø±_Ø®_Ø¬_Ø³'.split('_'),
4786    weekdaysParseExact : true,
4787    longDateFormat : {
4788        LT : 'HH:mm',
4789        LTS : 'HH:mm:ss',
4790        L : 'D/\u200FM/\u200FYYYY',
4791        LL : 'D MMMM YYYY',
4792        LLL : 'D MMMM YYYY HH:mm',
4793        LLLL : 'dddd D MMMM YYYY HH:mm'
4794    },
4795    meridiemParse: /Øµ|Ù/,
4796    isPM : function (input) {
4797        return 'Ù' === input;
4798    },
4799    meridiem : function (hour, minute, isLower) {
4800        if (hour < 12) {
4801            return 'Øµ';
4802        } else {
4803            return 'Ù';
4804        }
4805    },
4806    calendar : {
4807        sameDay: '[Ø§ÙÙÙÙ Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4808        nextDay: '[ØºØ¯ÙØ§ Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4809        nextWeek: 'dddd [Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4810        lastDay: '[Ø£ÙØ³ Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4811        lastWeek: 'dddd [Ø¹ÙØ¯ Ø§ÙØ³Ø§Ø¹Ø©] LT',
4812        sameElse: 'L'
4813    },
4814    relativeTime : {
4815        future : 'Ø¨Ø¹Ø¯ %s',
4816        past : 'ÙÙØ° %s',
4817        s : pluralize$1('s'),
4818        m : pluralize$1('m'),
4819        mm : pluralize$1('m'),
4820        h : pluralize$1('h'),
4821        hh : pluralize$1('h'),
4822        d : pluralize$1('d'),
4823        dd : pluralize$1('d'),
4824        M : pluralize$1('M'),
4825        MM : pluralize$1('M'),
4826        y : pluralize$1('y'),
4827        yy : pluralize$1('y')
4828    },
4829    preparse: function (string) {
4830        return string.replace(/\u200f/g, '').replace(/[Ù¡Ù¢Ù£Ù¤Ù¥Ù¦Ù§Ù¨Ù©Ù ]/g, function (match) {
4831            return numberMap$1[match];
4832        }).replace(/Ø/g, ',');
4833    },
4834    postformat: function (string) {
4835        return string.replace(/\d/g, function (match) {
4836            return symbolMap$2[match];
4837        }).replace(/,/g, 'Ø');
4838    },
4839    week : {
4840        dow : 6, // Saturday is the first day of the week.
4841        doy : 12  // The week that contains Jan 1st is the first week of the year.
4842    }
4843});
4844
4845//! moment.js locale configuration
4846//! locale : Azerbaijani [az]
4847//! author : topchiyev : https://github.com/topchiyev
4848
4849var suffixes = {
4850    1: '-inci',
4851    5: '-inci',
4852    8: '-inci',
4853    70: '-inci',
4854    80: '-inci',
4855    2: '-nci',
4856    7: '-nci',
4857    20: '-nci',
4858    50: '-nci',
4859    3: '-Ã¼ncÃ¼',
4860    4: '-Ã¼ncÃ¼',
4861    100: '-Ã¼ncÃ¼',
4862    6: '-ncÄ±',
4863    9: '-uncu',
4864    10: '-uncu',
4865    30: '-uncu',
4866    60: '-Ä±ncÄ±',
4867    90: '-Ä±ncÄ±'
4868};
4869
4870hooks.defineLocale('az', {
4871    months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
4872    monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
4873    weekdays : 'Bazar_Bazar ertÉsi_ÃÉrÅÉnbÉ axÅamÄ±_ÃÉrÅÉnbÉ_CÃ¼mÉ axÅamÄ±_CÃ¼mÉ_ÅÉnbÉ'.split('_'),
4874    weekdaysShort : 'Baz_BzE_ÃAx_ÃÉr_CAx_CÃ¼m_ÅÉn'.split('_'),
4875    weekdaysMin : 'Bz_BE_ÃA_ÃÉ_CA_CÃ¼_ÅÉ'.split('_'),
4876    weekdaysParseExact : true,
4877    longDateFormat : {
4878        LT : 'HH:mm',
4879        LTS : 'HH:mm:ss',
4880        L : 'DD.MM.YYYY',
4881        LL : 'D MMMM YYYY',
4882        LLL : 'D MMMM YYYY HH:mm',
4883        LLLL : 'dddd, D MMMM YYYY HH:mm'
4884    },
4885    calendar : {
4886        sameDay : '[bugÃ¼n saat] LT',
4887        nextDay : '[sabah saat] LT',
4888        nextWeek : '[gÉlÉn hÉftÉ] dddd [saat] LT',
4889        lastDay : '[dÃ¼nÉn] LT',

4890        lastWeek : '[keÃ§Én hÉftÉ] dddd [saat] LT',
4891        sameElse : 'L'
4892    },
4893    relativeTime : {
4894        future : '%s sonra',
4895        past : '%s ÉvvÉl',
4896        s : 'birneÃ§É saniyyÉ',
4897        m : 'bir dÉqiqÉ',
4898        mm : '%d dÉqiqÉ',
4899        h : 'bir saat',
4900        hh : '%d saat',
4901        d : 'bir gÃ¼n',
4902        dd : '%d gÃ¼n',
4903        M : 'bir ay',
4904        MM : '%d ay',
4905        y : 'bir il',
4906        yy : '%d il'
4907    },
4908    meridiemParse: /gecÉ|sÉhÉr|gÃ¼ndÃ¼z|axÅam/,
4909    isPM : function (input) {
4910        return /^(gÃ¼ndÃ¼z|axÅam)$/.test(input);
4911    },
4912    meridiem : function (hour, minute, isLower) {
4913        if (hour < 4) {
4914            return 'gecÉ';
4915        } else if (hour < 12) {
4916            return 'sÉhÉr';
4917        } else if (hour < 17) {
4918            return 'gÃ¼ndÃ¼z';
4919        } else {
4920            return 'axÅam';
4921        }
4922    },
4923    ordinalParse: /\d{1,2}-(Ä±ncÄ±|inci|nci|Ã¼ncÃ¼|ncÄ±|uncu)/,
4924    ordinal : function (number) {
4925        if (number === 0) {  // special case for zero
4926            return number + '-Ä±ncÄ±';
4927        }
4928        var a = number % 10,
4929            b = number % 100 - a,
4930            c = number >= 100 ? 100 : null;
4931        return number + (suffixes[a] || suffixes[b] || suffixes[c]);
4932    },
4933    week : {
4934        dow : 1, // Monday is the first day of the week.
4935        doy : 7  // The week that contains Jan 1st is the first week of the year.
4936    }
4937});
4938
4939//! moment.js locale configuration
4940//! locale : Belarusian [be]
4941//! author : Dmitry Demidov : https://github.com/demidov91
4942//! author: Praleska: http://praleska.pro/
4943//! Author : Menelion ElensÃºle : https://github.com/Oire
4944
4945function plural(word, num) {
4946    var forms = word.split('_');
4947    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]);
4948}
4949function relativeTimeWithPlural(number, withoutSuffix, key) {
4950    var format = {
4951        'mm': withoutSuffix ? 'ÑÐ²ÑÐ»ÑÐ½Ð°_ÑÐ²ÑÐ»ÑÐ½Ñ_ÑÐ²ÑÐ»ÑÐ½' : 'ÑÐ²ÑÐ»ÑÐ½Ñ_ÑÐ²ÑÐ»ÑÐ½Ñ_ÑÐ²ÑÐ»ÑÐ½',
4952        'hh': withoutSuffix ? 'Ð³Ð°Ð´Ð·ÑÐ½Ð°_Ð³Ð°Ð´Ð·ÑÐ½Ñ_Ð³Ð°Ð´Ð·ÑÐ½' : 'Ð³Ð°Ð´Ð·ÑÐ½Ñ_Ð³Ð°Ð´Ð·ÑÐ½Ñ_Ð³Ð°Ð´Ð·ÑÐ½',
4953        'dd': 'Ð´Ð·ÐµÐ½Ñ_Ð´Ð½Ñ_Ð´Ð·ÑÐ½',
4954        'MM': 'Ð¼ÐµÑÑÑ_Ð¼ÐµÑÑÑÑ_Ð¼ÐµÑÑÑÐ°Ñ',
4955        'yy': 'Ð³Ð¾Ð´_Ð³Ð°Ð´Ñ_Ð³Ð°Ð´Ð¾Ñ'
4956    };
4957    if (key === 'm') {
4958        return withoutSuffix ? 'ÑÐ²ÑÐ»ÑÐ½Ð°' : 'ÑÐ²ÑÐ»ÑÐ½Ñ';
4959    }
4960    else if (key === 'h') {
4961        return withoutSuffix ? 'Ð³Ð°Ð´Ð·ÑÐ½Ð°' : 'Ð³Ð°Ð´Ð·ÑÐ½Ñ';
4962    }
4963    else {
4964        return number + ' ' + plural(format[key], +number);
4965    }
4966}
4967
4968hooks.defineLocale('be', {
4969    months : {
4970        format: 'ÑÑÑÐ´Ð·ÐµÐ½Ñ_Ð»ÑÑÐ°Ð³Ð°_ÑÐ°ÐºÐ°Ð²ÑÐºÐ°_ÐºÑÐ°ÑÐ°Ð²ÑÐºÐ°_ÑÑÐ°ÑÐ½Ñ_ÑÑÑÐ²ÐµÐ½Ñ_Ð»ÑÐ¿ÐµÐ½Ñ_Ð¶Ð½ÑÑÐ½Ñ_Ð²ÐµÑÐ°ÑÐ½Ñ_ÐºÐ°ÑÑÑÑÑÐ½ÑÐºÐ°_Ð»ÑÑÑÐ°Ð¿Ð°Ð´Ð°_ÑÐ½ÐµÐ¶Ð½Ñ'.split('_'),
4971        standalone: 'ÑÑÑÐ´Ð·ÐµÐ½Ñ_Ð»ÑÑÑ_ÑÐ°ÐºÐ°Ð²ÑÐº_ÐºÑÐ°ÑÐ°Ð²ÑÐº_ÑÑÐ°Ð²ÐµÐ½Ñ_ÑÑÑÐ²ÐµÐ½Ñ_Ð»ÑÐ¿ÐµÐ½Ñ_Ð¶Ð½ÑÐ²ÐµÐ½Ñ_Ð²ÐµÑÐ°ÑÐµÐ½Ñ_ÐºÐ°ÑÑÑÑÑÐ½ÑÐº_Ð»ÑÑÑÐ°Ð¿Ð°Ð´_ÑÐ½ÐµÐ¶Ð°Ð½Ñ'.split('_')
4972    },
4973    monthsShort : 'ÑÑÑÐ´_Ð»ÑÑ_ÑÐ°Ðº_ÐºÑÐ°Ñ_ÑÑÐ°Ð²_ÑÑÑÐ²_Ð»ÑÐ¿_Ð¶Ð½ÑÐ²_Ð²ÐµÑ_ÐºÐ°ÑÑ_Ð»ÑÑÑ_ÑÐ½ÐµÐ¶'.split('_'),
4974    weekdays : {
4975        format: 'Ð½ÑÐ´Ð·ÐµÐ»Ñ_Ð¿Ð°Ð½ÑÐ´Ð·ÐµÐ»Ð°Ðº_Ð°ÑÑÐ¾ÑÐ°Ðº_ÑÐµÑÐ°Ð´Ñ_ÑÐ°ÑÐ²ÐµÑ_Ð¿ÑÑÐ½ÑÑÑ_ÑÑÐ±Ð¾ÑÑ'.split('_'),
4976        standalone: 'Ð½ÑÐ´Ð·ÐµÐ»Ñ_Ð¿Ð°Ð½ÑÐ´Ð·ÐµÐ»Ð°Ðº_Ð°ÑÑÐ¾ÑÐ°Ðº_ÑÐµÑÐ°Ð´Ð°_ÑÐ°ÑÐ²ÐµÑ_Ð¿ÑÑÐ½ÑÑÐ°_ÑÑÐ±Ð¾ÑÐ°'.split('_'),
4977        isFormat: /\[ ?[ÐÐ²] ?(?:Ð¼ÑÐ½ÑÐ»ÑÑ|Ð½Ð°ÑÑÑÐ¿Ð½ÑÑ)? ?\] ?dddd/
4978    },
4979    weekdaysShort : 'Ð½Ð´_Ð¿Ð½_Ð°Ñ_ÑÑ_ÑÑ_Ð¿Ñ_ÑÐ±'.split('_'),
4980    weekdaysMin : 'Ð½Ð´_Ð¿Ð½_Ð°Ñ_ÑÑ_ÑÑ_Ð¿Ñ_ÑÐ±'.split('_'),
4981    longDateFormat : {
4982        LT : 'HH:mm',
4983        LTS : 'HH:mm:ss',
4984        L : 'DD.MM.YYYY',
4985        LL : 'D MMMM YYYY Ð³.',
4986        LLL : 'D MMMM YYYY Ð³., HH:mm',
4987        LLLL : 'dddd, D MMMM YYYY Ð³., HH:mm'
4988    },
4989    calendar : {
4990        sameDay: '[Ð¡ÑÐ½Ð½Ñ Ñ] LT',
4991        nextDay: '[ÐÐ°ÑÑÑÐ° Ñ] LT',
4992        lastDay: '[Ð£ÑÐ¾ÑÐ° Ñ] LT',
4993        nextWeek: function () {
4994            return '[Ð£] dddd [Ñ] LT';
4995        },
4996        lastWeek: function () {
4997            switch (this.day()) {
4998                case 0:
4999                case 3:
5000                case 5:
5001                case 6:
5002                    return '[Ð£ Ð¼ÑÐ½ÑÐ»ÑÑ] dddd [Ñ] LT';
5003                case 1:
5004                case 2:
5005                case 4:
5006                    return '[Ð£ Ð¼ÑÐ½ÑÐ»Ñ] dddd [Ñ] LT';
5007            }
5008        },
5009        sameElse: 'L'
5010    },
5011    relativeTime : {
5012        future : 'Ð¿ÑÐ°Ð· %s',
5013        past : '%s ÑÐ°Ð¼Ñ',
5014        s : 'Ð½ÐµÐºÐ°Ð»ÑÐºÑ ÑÐµÐºÑÐ½Ð´',
5015        m : relativeTimeWithPlural,
5016        mm : relativeTimeWithPlural,
5017        h : relativeTimeWithPlural,
5018        hh : relativeTimeWithPlural,
5019        d : 'Ð´Ð·ÐµÐ½Ñ',
5020        dd : relativeTimeWithPlural,
5021        M : 'Ð¼ÐµÑÑÑ',
5022        MM : relativeTimeWithPlural,
5023        y : 'Ð³Ð¾Ð´',
5024        yy : relativeTimeWithPlural
5025    },
5026    meridiemParse: /Ð½Ð¾ÑÑ|ÑÐ°Ð½ÑÑÑ|Ð´Ð½Ñ|Ð²ÐµÑÐ°ÑÐ°/,
5027    isPM : function (input) {
5028        return /^(Ð´Ð½Ñ|Ð²ÐµÑÐ°ÑÐ°)$/.test(input);
5029    },
5030    meridiem : function (hour, minute, isLower) {
5031        if (hour < 4) {
5032            return 'Ð½Ð¾ÑÑ';
5033        } else if (hour < 12) {
5034            return 'ÑÐ°Ð½ÑÑÑ';
5035        } else if (hour < 17) {
5036            return 'Ð´Ð½Ñ';
5037        } else {
5038            return 'Ð²ÐµÑÐ°ÑÐ°';
5039        }
5040    },
5041    ordinalParse: /\d{1,2}-(Ñ|Ñ|Ð³Ð°)/,
5042    ordinal: function (number, period) {
5043        switch (period) {
5044            case 'M':
5045            case 'd':
5046            case 'DDD':
5047            case 'w':
5048            case 'W':
5049                return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-Ñ' : number + '-Ñ';
5050            case 'D':
5051                return number + '-Ð³Ð°';
5052            default:
5053                return number;
5054        }
5055    },
5056    week : {
5057        dow : 1, // Monday is the first day of the week.
5058        doy : 7  // The week that contains Jan 1st is the first week of the year.
5059    }
5060});
5061
5062//! moment.js locale configuration
5063//! locale : Bulgarian [bg]
5064//! author : Krasen Borisov : https://github.com/kraz
5065
5066hooks.defineLocale('bg', {
5067    months : 'ÑÐ½ÑÐ°ÑÐ¸_ÑÐµÐ²ÑÑÐ°ÑÐ¸_Ð¼Ð°ÑÑ_Ð°Ð¿ÑÐ¸Ð»_Ð¼Ð°Ð¹_ÑÐ½Ð¸_ÑÐ»Ð¸_Ð°Ð²Ð³ÑÑÑ_ÑÐµÐ¿ÑÐµÐ¼Ð²ÑÐ¸_Ð¾ÐºÑÐ¾Ð¼Ð²ÑÐ¸_Ð½Ð¾ÐµÐ¼Ð²ÑÐ¸_Ð´ÐµÐºÐµÐ¼Ð²ÑÐ¸'.split('_'),
5068    monthsShort : 'ÑÐ½Ñ_ÑÐµÐ²_Ð¼Ð°Ñ_Ð°Ð¿Ñ_Ð¼Ð°Ð¹_ÑÐ½Ð¸_ÑÐ»Ð¸_Ð°Ð²Ð³_ÑÐµÐ¿_Ð¾ÐºÑ_Ð½Ð¾Ðµ_Ð´ÐµÐº'.split('_'),
5069    weekdays : 'Ð½ÐµÐ´ÐµÐ»Ñ_Ð¿Ð¾Ð½ÐµÐ´ÐµÐ»Ð½Ð¸Ðº_Ð²ÑÐ¾ÑÐ½Ð¸Ðº_ÑÑÑÐ´Ð°_ÑÐµÑÐ²ÑÑÑÑÐº_Ð¿ÐµÑÑÐº_ÑÑÐ±Ð¾ÑÐ°'.split('_'),
5070    weekdaysShort : 'Ð½ÐµÐ´_Ð¿Ð¾Ð½_Ð²ÑÐ¾_ÑÑÑ_ÑÐµÑ_Ð¿ÐµÑ_ÑÑÐ±'.split('_'),
5071    weekdaysMin : 'Ð½Ð´_Ð¿Ð½_Ð²Ñ_ÑÑ_ÑÑ_Ð¿Ñ_ÑÐ±'.split('_'),
5072    longDateFormat : {
5073        LT : 'H:mm',
5074        LTS : 'H:mm:ss',
5075        L : 'D.MM.YYYY',
5076        LL : 'D MMMM YYYY',
5077        LLL : 'D MMMM YYYY H:mm',
5078        LLLL : 'dddd, D MMMM YYYY H:mm'
5079    },
5080    calendar : {
5081        sameDay : '[ÐÐ½ÐµÑ Ð²] LT',
5082        nextDay : '[Ð£ÑÑÐµ Ð²] LT',
5083        nextWeek : 'dddd [Ð²] LT',
5084        lastDay : '[ÐÑÐµÑÐ° Ð²] LT',
5085        lastWeek : function () {
5086            switch (this.day()) {
5087                case 0:
5088                case 3:
5089                case 6:
5090                    return '[Ð Ð¸Ð·Ð¼Ð¸Ð½Ð°Ð»Ð°ÑÐ°] dddd [Ð²] LT';
5091                case 1:
5092                case 2:
5093                case 4:
5094                case 5:
5095                    return '[Ð Ð¸Ð·Ð¼Ð¸Ð½Ð°Ð»Ð¸Ñ] dddd [Ð²] LT';
5096            }
5097        },
5098        sameElse : 'L'
5099    },
5100    relativeTime : {
5101        future : 'ÑÐ»ÐµÐ´ %s',
5102        past : 'Ð¿ÑÐµÐ´Ð¸ %s',
5103        s : 'Ð½ÑÐºÐ¾Ð»ÐºÐ¾ ÑÐµÐºÑÐ½Ð´Ð¸',
5104        m : 'Ð¼Ð¸Ð½ÑÑÐ°',
5105        mm : '%d Ð¼Ð¸Ð½ÑÑÐ¸',
5106        h : 'ÑÐ°Ñ',
5107        hh : '%d ÑÐ°ÑÐ°',
5108        d : 'Ð´ÐµÐ½',
5109        dd : '%d Ð´Ð½Ð¸',
5110        M : 'Ð¼ÐµÑÐµÑ',
5111        MM : '%d Ð¼ÐµÑÐµÑÐ°',
5112        y : 'Ð³Ð¾Ð´Ð¸Ð½Ð°',
5113        yy : '%d Ð³Ð¾Ð´Ð¸Ð½Ð¸'
5114    },
5115    ordinalParse: /\d{1,2}-(ÐµÐ²|ÐµÐ½|ÑÐ¸|Ð²Ð¸|ÑÐ¸|Ð¼Ð¸)/,
5116    ordinal : function (number) {
5117        var lastDigit = number % 10,
5118            last2Digits = number % 100;
5119        if (number === 0) {
5120            return number + '-ÐµÐ²';
5121        } else if (last2Digits === 0) {
5122            return number + '-ÐµÐ½';
5123        } else if (last2Digits > 10 && last2Digits < 20) {
5124            return number + '-ÑÐ¸';
5125        } else if (lastDigit === 1) {
5126            return number + '-Ð²Ð¸';
5127        } else if (lastDigit === 2) {
5128            return number + '-ÑÐ¸';
5129        } else if (lastDigit === 7 || lastDigit === 8) {
5130            return number + '-Ð¼Ð¸';
5131        } else {
5132            return number + '-ÑÐ¸';
5133        }
5134    },
5135    week : {
5136        dow : 1, // Monday is the first day of the week.
5137        doy : 7  // The week that contains Jan 1st is the first week of the year.
5138    }
5139});
5140
5141//! moment.js locale configuration
5142//! locale : Bengali [bn]
5143//! author : Kaushik Gandhi : https://github.com/kaushikgandhi
5144
5145var symbolMap$3 = {
5146    '1': 'à§§',
5147    '2': 'à§¨',
5148    '3': 'à§©',
5149    '4': 'à§ª',
5150    '5': 'à§«',
5151    '6': 'à§¬',
5152    '7': 'à§',
5153    '8': 'à§®',
5154    '9': 'à§¯',
5155    '0': 'à§¦'
5156};
5157var numberMap$2 = {
5158    'à§§': '1',
5159    'à§¨': '2',
5160    'à§©': '3',
5161    'à§ª': '4',
5162    'à§«': '5',
5163    'à§¬': '6',
5164    'à§': '7',
5165    'à§®': '8',
5166    'à§¯': '9',
5167    'à§¦': '0'
5168};
5169
5170hooks.defineLocale('bn', {
5171    months : 'à¦à¦¾à¦¨à§à§à¦¾à¦°à§_à¦«à§à¦¬à§à¦°à§à§à¦¾à¦°à¦¿_à¦®à¦¾à¦°à§à¦_à¦à¦ªà§à¦°à¦¿à¦²_à¦®à§_à¦à§à¦¨_à¦à§à¦²à¦¾à¦_à¦à¦à¦¸à§à¦_à¦¸à§à¦ªà§à¦à§à¦®à§à¦¬à¦°_à¦à¦à§à¦à§à¦¬à¦°_à¦¨à¦à§à¦®à§à¦¬à¦°_à¦¡à¦¿à¦¸à§à¦®à§à¦¬à¦°'.split('_'),
5172    monthsShort : 'à¦à¦¾à¦¨à§_à¦«à§à¦¬_à¦®à¦¾à¦°à§à¦_à¦à¦ªà§à¦°_à¦®à§_à¦à§à¦¨_à¦à§à¦²_à¦à¦_à¦¸à§à¦ªà§à¦_à¦à¦à§à¦à§_à¦¨à¦à§_à¦¡à¦¿à¦¸à§'.split('_'),
5173    weekdays : 'à¦°à¦¬à¦¿à¦¬à¦¾à¦°_à¦¸à§à¦®à¦¬à¦¾à¦°_à¦®à¦à§à¦à¦²à¦¬à¦¾à¦°_à¦¬à§à¦§à¦¬à¦¾à¦°_à¦¬à§à¦¹à¦¸à§à¦ªà¦¤à¦¿à¦¬à¦¾à¦°_à¦¶à§à¦à§à¦°à¦¬à¦¾à¦°_à¦¶à¦¨à¦¿à¦¬à¦¾à¦°'.split('_'),
5174    weekdaysShort : 'à¦°à¦¬à¦¿_à¦¸à§à¦®_à¦®à¦à§à¦à¦²_à¦¬à§à¦§_à¦¬à§à¦¹à¦¸à§à¦ªà¦¤à¦¿_à¦¶à§à¦à§à¦°_à¦¶à¦¨à¦¿'.split('_'),
5175    weekdaysMin : 'à¦°à¦¬à¦¿_à¦¸à§à¦®_à¦®à¦à§à¦_à¦¬à§à¦§_à¦¬à§à¦¹à¦_à¦¶à§à¦à§à¦°_à¦¶à¦¨à¦¿'.split('_'),
5176    longDateFormat : {
5177        LT : 'A h:mm à¦¸à¦®à§',
5178        LTS : 'A h:mm:ss à¦¸à¦®à§',
5179        L : 'DD/MM/YYYY',
5180        LL : 'D MMMM YYYY',
5181        LLL : 'D MMMM YYYY, A h:mm à¦¸à¦®à§',
5182        LLLL : 'dddd, D MMMM YYYY, A h:mm à¦¸à¦®à§'
5183    },
5184    calendar : {
5185        sameDay : '[à¦à¦] LT',
5186        nextDay : '[à¦à¦à¦¾à¦®à§à¦à¦¾à¦²] LT',
5187        nextWeek : 'dddd, LT',
5188        lastDay : '[à¦à¦¤à¦à¦¾à¦²] LT',
5189        lastWeek : '[à¦à¦¤] dddd, LT',
5190        sameElse : 'L'
5191    },
5192    relativeTime : {
5193        future : '%s à¦ªà¦°à§',
5194        past : '%s à¦à¦à§',
5195        s : 'à¦à§à§à¦ à¦¸à§à¦à§à¦¨à§à¦¡',
5196        m : 'à¦à¦ à¦®à¦¿à¦¨à¦¿à¦',
5197        mm : '%d à¦®à¦¿à¦¨à¦¿à¦',
5198        h : 'à¦à¦ à¦à¦¨à§à¦à¦¾',
5199        hh : '%d à¦à¦¨à§à¦à¦¾',
5200        d : 'à¦à¦ à¦¦à¦¿à¦¨',
5201        dd : '%d à¦¦à¦¿à¦¨',
5202        M : 'à¦à¦ à¦®à¦¾à¦¸',
5203        MM : '%d à¦®à¦¾à¦¸',
5204        y : 'à¦à¦ à¦¬à¦à¦°',
5205        yy : '%d à¦¬à¦à¦°'
5206    },
5207    preparse: function (string) {
5208        return string.replace(/[à§§à§¨à§©à§ªà§«à§¬à§à§®à§¯à§¦]/g, function (match) {
5209            return numberMap$2[match];
5210        });
5211    },
5212    postformat: function (string) {
5213        return string.replace(/\d/g, function (match) {
5214            return symbolMap$3[match];
5215        });
5216    },
5217    meridiemParse: /à¦°à¦¾à¦¤|à¦¸à¦à¦¾à¦²|à¦¦à§à¦ªà§à¦°|à¦¬à¦¿à¦à¦¾à¦²|à¦°à¦¾à¦¤/,
5218    meridiemHour : function (hour, meridiem) {
5219        if (hour === 12) {
5220            hour = 0;
5221        }
5222        if ((meridiem === 'à¦°à¦¾à¦¤' && hour >= 4) ||
5223                (meridiem === 'à¦¦à§à¦ªà§à¦°' && hour < 5) ||
5224                meridiem === 'à¦¬à¦¿à¦à¦¾à¦²') {
5225            return hour + 12;
5226        } else {
5227            return hour;
5228        }
5229    },
5230    meridiem : function (hour, minute, isLower) {
5231        if (hour < 4) {
5232            return 'à¦°à¦¾à¦¤';
5233        } else if (hour < 10) {
5234            return 'à¦¸à¦à¦¾à¦²';
5235        } else if (hour < 17) {
5236            return 'à¦¦à§à¦ªà§à¦°';
5237        } else if (hour < 20) {
5238            return 'à¦¬à¦¿à¦à¦¾à¦²';
5239        } else {
5240            return 'à¦°à¦¾à¦¤';
5241        }
5242    },
5243    week : {
5244        dow : 0, // Sunday is the first day of the week.
5245        doy : 6  // The week that contains Jan 1st is the first week of the year.
5246    }
5247});
5248
5249//! moment.js locale configuration
5250//! locale : Tibetan [bo]
5251//! author : Thupten N. Chakrishar : https://github.com/vajradog
5252
5253var symbolMap$4 = {
5254    '1': 'à¼¡',
5255    '2': 'à¼¢',
5256    '3': 'à¼£',
5257    '4': 'à¼¤',
5258    '5': 'à¼¥',
5259    '6': 'à¼¦',
5260    '7': 'à¼§',
5261    '8': 'à¼¨',
5262    '9': 'à¼©',
5263    '0': 'à¼ '
5264};
5265var numberMap$3 = {
5266    'à¼¡': '1',
5267    'à¼¢': '2',
5268    'à¼£': '3',
5269    'à¼¤': '4',
5270    'à¼¥': '5',
5271    'à¼¦': '6',
5272    'à¼§': '7',
5273    'à¼¨': '8',
5274    'à¼©': '9',
5275    'à¼ ': '0'
5276};
5277
5278hooks.defineLocale('bo', {
5279    months : 'à½à¾³à¼à½à¼à½à½à¼à½à½¼_à½à¾³à¼à½à¼à½à½à½²à½¦à¼à½_à½à¾³à¼à½à¼à½à½¦à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½²à¼à½_à½à¾³à¼à½à¼à½£à¾à¼à½_à½à¾³à¼à½à¼à½à¾²à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à½à¼à½_à½à¾³à¼à½à¼à½à½¢à¾à¾±à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½à½à½²à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½à½à½²à½¦à¼à½'.split('_'),
5280    monthsShort : 'à½à¾³à¼à½à¼à½à½à¼à½à½¼_à½à¾³à¼à½à¼à½à½à½²à½¦à¼à½_à½à¾³à¼à½à¼à½à½¦à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½²à¼à½_à½à¾³à¼à½à¼à½£à¾à¼à½_à½à¾³à¼à½à¼à½à¾²à½´à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à½à¼à½_à½à¾³à¼à½à¼à½à½¢à¾à¾±à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½à½à½²à½à¼à½_à½à¾³à¼à½à¼à½à½à½´à¼à½à½à½²à½¦à¼à½'.split('_'),
5281    weekdays : 'à½à½à½ à¼à½à½²à¼à½à¼_à½à½à½ à¼à½à¾³à¼à½à¼_à½à½à½ à¼à½à½²à½à¼à½à½à½¢à¼_à½à½à½ à¼à½£à¾·à½à¼à½à¼_à½à½à½ à¼à½à½´à½¢à¼à½à½´_à½à½à½ à¼à½à¼à½¦à½à½¦à¼_à½à½à½ à¼à½¦à¾¤à½ºà½à¼à½à¼'.split('_'),
5282    weekdaysShort : 'à½à½²à¼à½à¼_à½à¾³à¼à½à¼_à½à½²à½à¼à½à½à½¢à¼_à½£à¾·à½à¼à½à¼_à½à½´à½¢à¼à½à½´_à½à¼à½¦à½à½¦à¼_à½¦à¾¤à½ºà½à¼à½à¼'.split('_'),
5283    weekdaysMin : 'à½à½²à¼à½à¼_à½à¾³à¼à½à¼_à½à½²à½à¼à½à½à½¢à¼_à½£à¾·à½à¼à½à¼_à½à½´à½¢à¼à½à½´_à½à¼à½¦à½à½¦à¼_à½¦à¾¤à½ºà½à¼à½à¼'.split('_'),
5284    longDateFormat : {
5285        LT : 'A h:mm',
5286        LTS : 'A h:mm:ss',
5287        L : 'DD/MM/YYYY',
5288        LL : 'D MMMM YYYY',
5289        LLL : 'D MMMM YYYY, A h:mm',
5290        LLLL : 'dddd, D MMMM YYYY, A h:mm'
5291    },
5292    calendar : {
5293        sameDay : '[à½à½²à¼à½¢à½²à½] LT',
5294        nextDay : '[à½¦à½à¼à½à½²à½] LT',
5295        nextWeek : '[à½à½à½´à½à¼à½à¾²à½à¼à½¢à¾à½ºà½¦à¼à½], LT',
5296        lastDay : '[à½à¼à½¦à½] LT',
5297        lastWeek : '[à½à½à½´à½à¼à½à¾²à½à¼à½à½à½ à¼à½] dddd, LT',
5298        sameElse : 'L'
5299    },
5300    relativeTime : {
5301        future : '%s à½£à¼',
5302        past : '%s à½¦à¾à½à¼à½£',
5303        s : 'à½£à½à¼à½¦à½',
5304        m : 'à½¦à¾à½¢à¼à½à¼à½à½à½²à½',
5305        mm : '%d à½¦à¾à½¢à¼à½',
5306        h : 'à½à½´à¼à½à½¼à½à¼à½à½à½²à½',
5307        hh : '%d à½à½´à¼à½à½¼à½',
5308        d : 'à½à½²à½à¼à½à½à½²à½',
5309        dd : '%d à½à½²à½à¼',
5310        M : 'à½à¾³à¼à½à¼à½à½à½²à½',
5311        MM : '%d à½à¾³à¼à½',
5312        y : 'à½£à½¼à¼à½à½à½²à½',
5313        yy : '%d à½£à½¼'
5314    },
5315    preparse: function (string) {
5316        return string.replace(/[à¼¡à¼¢à¼£à¼¤à¼¥à¼¦à¼§à¼¨à¼©à¼ ]/g, function (match) {
5317            return numberMap$3[match];
5318        });
5319    },
5320    postformat: function (string) {
5321        return string.replace(/\d/g, function (match) {
5322            return symbolMap$4[match];
5323        });
5324    },
5325    meridiemParse: /à½à½à½à¼à½à½¼|à½à½¼à½à½¦à¼à½à½¦|à½à½²à½à¼à½à½´à½|à½à½à½¼à½à¼à½à½|à½à½à½à¼à½à½¼/,
5326    meridiemHour : function (hour, meridiem) {
5327        if (hour === 12) {
5328            hour = 0;
5329        }
5330        if ((meridiem === 'à½à½à½à¼à½à½¼' && hour >= 4) ||
5331                (meridiem =

5331== 'à½à½²à½à¼à½à½´à½' && hour < 5) ||
5332                meridiem === 'à½à½à½¼à½à¼à½à½') {
5333            return hour + 12;
5334        } else {
5335            return hour;
5336        }
5337    },
5338    meridiem : function (hour, minute, isLower) {
5339        if (hour < 4) {
5340            return 'à½à½à½à¼à½à½¼';
5341        } else if (hour < 10) {
5342            return 'à½à½¼à½à½¦à¼à½à½¦';
5343        } else if (hour < 17) {
5344            return 'à½à½²à½à¼à½à½´à½';
5345        } else if (hour < 20) {
5346            return 'à½à½à½¼à½à¼à½à½';
5347        } else {
5348            return 'à½à½à½à¼à½à½¼';
5349        }
5350    },
5351    week : {
5352        dow : 0, // Sunday is the first day of the week.
5353        doy : 6  // The week that contains Jan 1st is the first week of the year.
5354    }
5355});
5356
5357//! moment.js locale configuration
5358//! locale : Breton [br]
5359//! author : Jean-Baptiste Le Duigou : https://github.com/jbleduigou
5360
5361function relativeTimeWithMutation(number, withoutSuffix, key) {
5362    var format = {
5363        'mm': 'munutenn',
5364        'MM': 'miz',
5365        'dd': 'devezh'
5366    };
5367    return number + ' ' + mutation(format[key], number);
5368}
5369function specialMutationForYears(number) {
5370    switch (lastNumber(number)) {
5371        case 1:
5372        case 3:
5373        case 4:
5374        case 5:
5375        case 9:
5376            return number + ' bloaz';
5377        default:
5378            return number + ' vloaz';
5379    }
5380}
5381function lastNumber(number) {
5382    if (number > 9) {
5383        return lastNumber(number % 10);
5384    }
5385    return number;
5386}
5387function mutation(text, number) {
5388    if (number === 2) {
5389        return softMutation(text);
5390    }
5391    return text;
5392}
5393function softMutation(text) {
5394    var mutationTable = {
5395        'm': 'v',
5396        'b': 'v',
5397        'd': 'z'
5398    };
5399    if (mutationTable[text.charAt(0)] === undefined) {
5400        return text;
5401    }
5402    return mutationTable[text.charAt(0)] + text.substring(1);
5403}
5404
5405hooks.defineLocale('br', {
5406    months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
5407    monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
5408    weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
5409    weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
5410    weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
5411    weekdaysParseExact : true,
5412    longDateFormat : {
5413        LT : 'h[e]mm A',
5414        LTS : 'h[e]mm:ss A',
5415        L : 'DD/MM/YYYY',
5416        LL : 'D [a viz] MMMM YYYY',
5417        LLL : 'D [a viz] MMMM YYYY h[e]mm A',
5418        LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A'
5419    },
5420    calendar : {
5421        sameDay : '[Hiziv da] LT',
5422        nextDay : '[Warc\'hoazh da] LT',
5423        nextWeek : 'dddd [da] LT',
5424        lastDay : '[Dec\'h da] LT',
5425        lastWeek : 'dddd [paset da] LT',
5426        sameElse : 'L'
5427    },
5428    relativeTime : {
5429        future : 'a-benn %s',
5430        past : '%s \'zo',
5431        s : 'un nebeud segondennoÃ¹',
5432        m : 'ur vunutenn',
5433        mm : relativeTimeWithMutation,
5434        h : 'un eur',
5435        hh : '%d eur',
5436        d : 'un devezh',
5437        dd : relativeTimeWithMutation,
5438        M : 'ur miz',
5439        MM : relativeTimeWithMutation,
5440        y : 'ur bloaz',
5441        yy : specialMutationForYears
5442    },
5443    ordinalParse: /\d{1,2}(aÃ±|vet)/,
5444    ordinal : function (number) {
5445        var output = (number === 1) ? 'aÃ±' : 'vet';
5446        return number + output;
5447    },
5448    week : {
5449        dow : 1, // Monday is the first day of the week.
5450        doy : 4  // The week that contains Jan 4th is the first week of the year.
5451    }
5452});
5453
5454//! moment.js locale configuration
5455//! locale : Bosnian [bs]
5456//! author : Nedim Cholich : https://github.com/frontyard
5457//! based on (hr) translation by Bojan MarkoviÄ
5458
5459function translate(number, withoutSuffix, key) {
5460    var result = number + ' ';
5461    switch (key) {
5462        case 'm':
5463            return withoutSuffix ? 'jedna minuta' : 'jedne minute';
5464        case 'mm':
5465            if (number === 1) {
5466                result += 'minuta';
5467            } else if (number === 2 || number === 3 || number === 4) {
5468                result += 'minute';
5469            } else {
5470                result += 'minuta';
5471            }
5472            return result;
5473        case 'h':
5474            return withoutSuffix ? 'jedan sat' : 'jednog sata';
5475        case 'hh':
5476            if (number === 1) {
5477                result += 'sat';
5478            } else if (number === 2 || number === 3 || number === 4) {
5479                result += 'sata';
5480            } else {
5481                result += 'sati';
5482            }
5483            return result;
5484        case 'dd':
5485            if (number === 1) {
5486                result += 'dan';
5487            } else {
5488                result += 'dana';
5489            }
5490            return result;
5491        case 'MM':
5492            if (number === 1) {
5493                result += 'mjesec';
5494            } else if (number === 2 || number === 3 || number === 4) {
5495                result += 'mjeseca';
5496            } else {
5497                result += 'mjeseci';
5498            }
5499            return result;
5500        case 'yy':
5501            if (number === 1) {
5502                result += 'godina';
5503            } else if (number === 2 || number === 3 || number === 4) {
5504                result += 'godine';
5505            } else {
5506                result += 'godina';
5507            }
5508            return result;
5509    }
5510}
5511
5512hooks.defineLocale('bs', {
5513    months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
5514    monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
5515    monthsParseExact: true,
5516    weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'),
5517    weekdaysShort : 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'),
5518    weekdaysMin : 'ne_po_ut_sr_Äe_pe_su'.split('_'),
5519    weekdaysParseExact : true,
5520    longDateFormat : {
5521        LT : 'H:mm',
5522        LTS : 'H:mm:ss',
5523        L : 'DD.MM.YYYY',
5524        LL : 'D. MMMM YYYY',
5525        LLL : 'D. MMMM YYYY H:mm',
5526        LLLL : 'dddd, D. MMMM YYYY H:mm'
5527    },
5528    calendar : {
5529        sameDay  : '[danas u] LT',
5530        nextDay  : '[sutra u] LT',
5531        nextWeek : function () {
5532            switch (this.day()) {
5533                case 0:
5534                    return '[u] [nedjelju] [u] LT';
5535                case 3:
5536                    return '[u] [srijedu] [u] LT';
5537                case 6:
5538                    return '[u] [subotu] [u] LT';
5539                case 1:
5540                case 2:
5541                case 4:
5542                case 5:
5543                    return '[u] dddd [u] LT';
5544            }
5545        },
5546        lastDay  : '[juÄer u] LT',
5547        lastWeek : function () {
5548            switch (this.day()) {
5549                case 0:
5550                case 3:
5551                    return '[proÅ¡lu] dddd [u] LT';
5552                case 6:
5553                    return '[proÅ¡le] [subote] [u] LT';
5554                case 1:
5555                case 2:
5556                case 4:
5557                case 5:
5558                    return '[proÅ¡li] dddd [u] LT';
5559            }
5560        },
5561        sameElse : 'L'
5562    },
5563    relativeTime : {
5564        future : 'za %s',
5565        past   : 'prije %s',
5566        s      : 'par sekundi',
5567        m      : translate,
5568        mm     : translate,
5569        h      : translate,
5570        hh     : translate,
5571        d      : 'dan',
5572        dd     : translate,
5573        M      : 'mjesec',
5574        MM     : translate,
5575        y      : 'godinu',
5576        yy     : translate
5577    },
5578    ordinalParse: /\d{1,2}\./,
5579    ordinal : '%d.',
5580    week : {
5581        dow : 1, // Monday is the first day of the week.
5582        doy : 7  // The week that contains Jan 1st is the first week of the year.
5583    }
5584});
5585
5586//! moment.js locale configuration
5587//! locale : Catalan [ca]
5588//! author : Juan G. Hurtado : https://github.com/juanghurtado
5589
5590hooks.defineLocale('ca', {
5591    months : 'gener_febrer_marÃ§_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
5592    monthsShort : 'gen._febr._mar._abr._mai._jun._jul._ag._set._oct._nov._des.'.split('_'),
5593    monthsParseExact : true,
5594    weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
5595    weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
5596    weekdaysMin : 'Dg_Dl_Dt_Dc_Dj_Dv_Ds'.split('_'),
5597    weekdaysParseExact : true,
5598    longDateFormat : {
5599        LT : 'H:mm',
5600        LTS : 'H:mm:ss',
5601        L : 'DD/MM/YYYY',
5602        LL : 'D MMMM YYYY',
5603        LLL : 'D MMMM YYYY H:mm',
5604        LLLL : 'dddd D MMMM YYYY H:mm'
5605    },
5606    calendar : {
5607        sameDay : function () {
5608            return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5609        },
5610        nextDay : function () {
5611            return '[demÃ  a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5612        },
5613        nextWeek : function () {
5614            return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5615        },
5616        lastDay : function () {
5617            return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5618        },
5619        lastWeek : function () {
5620            return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
5621        },
5622        sameElse : 'L'
5623    },
5624    relativeTime : {
5625        future : 'd\'aquÃ %s',
5626        past : 'fa %s',
5627        s : 'uns segons',
5628        m : 'un minut',
5629        mm : '%d minuts',
5630        h : 'una hora',
5631        hh : '%d hores',
5632        d : 'un dia',
5633        dd : '%d dies',
5634        M : 'un mes',
5635        MM : '%d mesos',
5636        y : 'un any',
5637        yy : '%d anys'
5638    },
5639    ordinalParse: /\d{1,2}(r|n|t|Ã¨|a)/,
5640    ordinal : function (number, period) {
5641        var output = (number === 1) ? 'r' :
5642            (number === 2) ? 'n' :
5643            (number === 3) ? 'r' :
5644            (number === 4) ? 't' : 'Ã¨';
5645        if (period === 'w' || period === 'W') {
5646            output = 'a';
5647        }
5648        return number + output;
5649    },
5650    week : {
5651        dow : 1, // Monday is the first day of the week.
5652        doy : 4  // The week that contains Jan 4th is the first week of the year.
5653    }
5654});
5655
5656//! moment.js locale configuration
5657//! locale : Czech [cs]
5658//! author : petrbela : https://github.com/petrbela
5659
5660var months$3 = 'leden_Ãºnor_bÅezen_duben_kvÄten_Äerven_Äervenec_srpen_zÃ¡ÅÃ_ÅÃjen_listopad_prosinec'.

5660split('_');
5661var monthsShort = 'led_Ãºno_bÅe_dub_kvÄ_Ävn_Ävc_srp_zÃ¡Å_ÅÃj_lis_pro'.split('_');
5662function plural$1(n) {
5663    return (n > 1) && (n < 5) && (~~(n / 10) !== 1);
5664}
5665function translate$1(number, withoutSuffix, key, isFuture) {
5666    var result = number + ' ';
5667    switch (key) {
5668        case 's':  // a few seconds / in a few seconds / a few seconds ago
5669            return (withoutSuffix || isFuture) ? 'pÃ¡r sekund' : 'pÃ¡r sekundami';
5670        case 'm':  // a minute / in a minute / a minute ago
5671            return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
5672        case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
5673            if (withoutSuffix || isFuture) {
5674                return result + (plural$1(number) ? 'minuty' : 'minut');
5675            } else {
5676                return result + 'minutami';
5677            }
5678            break;
5679        case 'h':  // an hour / in an hour / an hour ago
5680            return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
5681        case 'hh': // 9 hours / in 9 hours / 9 hours ago
5682            if (withoutSuffix || isFuture) {
5683                return result + (plural$1(number) ? 'hodiny' : 'hodin');
5684            } else {
5685                return result + 'hodinami';
5686            }
5687            break;
5688        case 'd':  // a day / in a day / a day ago
5689            return (withoutSuffix || isFuture) ? 'den' : 'dnem';
5690        case 'dd': // 9 days / in 9 days / 9 days ago
5691            if (withoutSuffix || isFuture) {
5692                return result + (plural$1(number) ? 'dny' : 'dnÃ');
5693            } else {
5694                return result + 'dny';
5695            }
5696            break;
5697        case 'M':  // a month / in a month / a month ago
5698            return (withoutSuffix || isFuture) ? 'mÄsÃc' : 'mÄsÃcem';
5699        case 'MM': // 9 months / in 9 months / 9 months ago
5700            if (withoutSuffix || isFuture) {
5701                return result + (plural$1(number) ? 'mÄsÃce' : 'mÄsÃcÅ¯');
5702            } else {
5703                return result + 'mÄsÃci';
5704            }
5705            break;
5706        case 'y':  // a year / in a year / a year ago
5707            return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
5708        case 'yy': // 9 years / in 9 years / 9 years ago
5709            if (withoutSuffix || isFuture) {
5710                return result + (plural$1(number) ? 'roky' : 'let');
5711            } else {
5712                return result + 'lety';
5713            }
5714            break;
5715    }
5716}
5717
5718hooks.defineLocale('cs', {
5719    months : months$3,
5720    monthsShort : monthsShort,
5721    monthsParse : (function (months, monthsShort) {
5722        var i, _monthsParse = [];
5723        for (i = 0; i < 12; i++) {
5724            // use custom parser to solve problem with July (Äervenec)
5725            _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
5726        }
5727        return _monthsParse;
5728    }(months$3, monthsShort)),
5729    shortMonthsParse : (function (monthsShort) {
5730        var i, _shortMonthsParse = [];
5731        for (i = 0; i < 12; i++) {
5732            _shortMonthsParse[i] = new RegExp('^' + monthsShort[i] + '$', 'i');
5733        }
5734        return _shortMonthsParse;
5735    }(monthsShort)),
5736    longMonthsParse : (function (months) {
5737        var i, _longMonthsParse = [];
5738        for (i = 0; i < 12; i++) {
5739            _longMonthsParse[i] = new RegExp('^' + months[i] + '$', 'i');
5740        }
5741        return _longMonthsParse;
5742    }(months$3)),
5743    weekdays : 'nedÄle_pondÄlÃ_ÃºterÃ½_stÅeda_Ätvrtek_pÃ¡tek_sobota'.split('_'),
5744    weekdaysShort : 'ne_po_Ãºt_st_Ät_pÃ¡_so'.split('_'),
5745    weekdaysMin : 'ne_po_Ãºt_st_Ät_pÃ¡_so'.split('_'),
5746    longDateFormat : {
5747        LT: 'H:mm',
5748        LTS : 'H:mm:ss',
5749        L : 'DD.MM.YYYY',
5750        LL : 'D. MMMM YYYY',
5751        LLL : 'D. MMMM YYYY H:mm',
5752        LLLL : 'dddd D. MMMM YYYY H:mm',
5753        l : 'D. M. YYYY'
5754    },
5755    calendar : {
5756        sameDay: '[dnes v] LT',
5757        nextDay: '[zÃtra v] LT',
5758        nextWeek: function () {
5759            switch (this.day()) {
5760                case 0:
5761                    return '[v nedÄli v] LT';
5762                case 1:
5763                case 2:
5764                    return '[v] dddd [v] LT';
5765                case 3:
5766                    return '[ve stÅedu v] LT';
5767                case 4:
5768                    return '[ve Ätvrtek v] LT';
5769                case 5:
5770                    return '[v pÃ¡tek v] LT';
5771                case 6:
5772                    return '[v sobotu v] LT';
5773            }
5774        },
5775        lastDay: '[vÄera v] LT',
5776        lastWeek: function () {
5777            switch (this.day()) {
5778                case 0:
5779                    return '[minulou nedÄli v] LT';
5780                case 1:
5781                case 2:
5782                    return '[minulÃ©] dddd [v] LT';
5783                case 3:
5784                    return '[minulou stÅedu v] LT';
5785                case 4:
5786                case 5:
5787                    return '[minulÃ½] dddd [v] LT';
5788                case 6:
5789                    return '[minulou sobotu v] LT';
5790            }
5791        },
5792        sameElse: 'L'
5793    },
5794    relativeTime : {
5795        future : 'za %s',
5796        past : 'pÅed %s',
5797        s : translate$1,
5798        m : translate$1,
5799        mm : translate$1,
5800        h : translate$1,
5801        hh : translate$1,
5802        d : translate$1,
5803        dd : translate$1,
5804        M : translate$1,
5805        MM : translate$1,
5806        y : translate$1,
5807        yy : translate$1
5808    },
5809    ordinalParse : /\d{1,2}\./,
5810    ordinal : '%d.',
5811    week : {
5812        dow : 1, // Monday is the first day of the week.
5813        doy : 4  // The week that contains Jan 4th is the first week of the year.
5814    }
5815});
5816
5817//! moment.js locale configuration
5818//! locale : Chuvash [cv]
5819//! author : Anatoly Mironov : https://github.com/mirontoli
5820
5821hooks.defineLocale('cv', {
5822    months : 'ÐºÓÑÐ»Ð°Ñ_Ð½Ð°ÑÓÑ_Ð¿ÑÑ_Ð°ÐºÐ°_Ð¼Ð°Ð¹_Ò«ÓÑÑÐ¼Ðµ_ÑÑÓ_Ò«ÑÑÐ»Ð°_Ð°Ð²ÓÐ½_ÑÐ¿Ð°_ÑÓ³Ðº_ÑÐ°ÑÑÐ°Ð²'.split('_'),
5823    monthsShort : 'ÐºÓÑ_Ð½Ð°Ñ_Ð¿ÑÑ_Ð°ÐºÐ°_Ð¼Ð°Ð¹_Ò«ÓÑ_ÑÑÓ_Ò«ÑÑ_Ð°Ð²Ð½_ÑÐ¿Ð°_ÑÓ³Ðº_ÑÐ°Ñ'.split('_'),
5824    weekdays : 'Ð²ÑÑÑÐ°ÑÐ½Ð¸ÐºÑÐ½_ÑÑÐ½ÑÐ¸ÐºÑÐ½_ÑÑÐ»Ð°ÑÐ¸ÐºÑÐ½_ÑÐ½ÐºÑÐ½_ÐºÓÒ«Ð½ÐµÑÐ½Ð¸ÐºÑÐ½_ÑÑÐ½ÐµÐºÑÐ½_ÑÓÐ¼Ð°ÑÐºÑÐ½'.split('_'),
5825    weekdaysShort : 'Ð²ÑÑ_ÑÑÐ½_ÑÑÐ»_ÑÐ½_ÐºÓÒ«_ÑÑÐ½_ÑÓÐ¼'.split('_'),
5826    weekdaysMin : 'Ð²Ñ_ÑÐ½_ÑÑ_ÑÐ½_ÐºÒ«_ÑÑ_ÑÐ¼'.split('_'),
5827    longDateFormat : {
5828        LT : 'HH:mm',
5829        LTS : 'HH:mm:ss',
5830        L : 'DD-MM-YYYY',
5831        LL : 'YYYY [Ò«ÑÐ»ÑÐ¸] MMMM [ÑÐ¹ÓÑÓÐ½] D[-Ð¼ÓÑÓ]',
5832        LLL : 'YYYY [Ò«ÑÐ»ÑÐ¸] MMMM [ÑÐ¹ÓÑÓÐ½] D[-Ð¼ÓÑÓ], HH:mm',
5833        LLLL : 'dddd, YYYY [Ò«ÑÐ»ÑÐ¸] MMMM [ÑÐ¹ÓÑÓÐ½] D[-Ð¼ÓÑÓ], HH:mm'
5834    },
5835    calendar : {
5836        sameDay: '[ÐÐ°ÑÐ½] LT [ÑÐµÑÐµÑÑÐµ]',
5837        nextDay: '[Ð«ÑÐ°Ð½] LT [ÑÐµÑÐµÑÑÐµ]',
5838        lastDay: '[ÓÐ½ÐµÑ] LT [ÑÐµÑÐµÑÑÐµ]',
5839        nextWeek: '[ÒªÐ¸ÑÐµÑ] dddd LT [ÑÐµÑÐµÑÑÐµ]',
5840        lastWeek: '[ÐÑÑÐ½Ó] dddd LT [ÑÐµÑÐµÑÑÐµ]',
5841        sameElse: 'L'
5842    },
5843    relativeTime : {
5844        future : function (output) {

5845            var affix = /ÑÐµÑÐµÑ$/i.exec(output) ? 'ÑÐµÐ½' : /Ò«ÑÐ»$/i.exec(output) ? 'ÑÐ°Ð½' : 'ÑÐ°Ð½';
5846            return output + affix;
5847        },
5848        past : '%s ÐºÐ°ÑÐ»Ð»Ð°',
5849        s : 'Ð¿ÓÑ-Ð¸Ðº Ò«ÐµÐºÐºÑÐ½Ñ',
5850        m : 'Ð¿ÓÑ Ð¼Ð¸Ð½ÑÑ',
5851        mm : '%d Ð¼Ð¸Ð½ÑÑ',
5852        h : 'Ð¿ÓÑ ÑÐµÑÐµÑ',
5853        hh : '%d ÑÐµÑÐµÑ',
5854        d : 'Ð¿ÓÑ ÐºÑÐ½',
5855        dd : '%d ÐºÑÐ½',
5856        M : 'Ð¿ÓÑ ÑÐ¹ÓÑ',
5857        MM : '%d ÑÐ¹ÓÑ',
5858        y : 'Ð¿ÓÑ Ò«ÑÐ»',
5859        yy : '%d Ò«ÑÐ»'
5860    },
5861    ordinalParse: /\d{1,2}-Ð¼ÓÑ/,
5862    ordinal : '%d-Ð¼ÓÑ',
5863    week : {
5864        dow : 1, // Monday is the first day of the week.
5865        doy : 7  // The week that contains Jan 1st is the first week of the year.
5866    }
5867});
5868
5869//! moment.js locale configuration
5870//! locale : Welsh [cy]
5871//! author : Robert Allen : https://github.com/robgallen
5872//! author : https://github.com/ryangreaves
5873
5874hooks.defineLocale('cy', {
5875    months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
5876    monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
5877    weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
5878    weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
5879    weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
5880    weekdaysParseExact : true,
5881    // time formats are the same as en-gb
5882    longDateFormat: {
5883        LT: 'HH:mm',
5884        LTS : 'HH:mm:ss',
5885        L: 'DD/MM/YYYY',
5886        LL: 'D MMMM YYYY',
5887        LLL: 'D MMMM YYYY HH:mm',
5888        LLLL: 'dddd, D MMMM YYYY HH:mm'
5889    },
5890    calendar: {
5891        sameDay: '[Heddiw am] LT',
5892        nextDay: '[Yfory am] LT',
5893        nextWeek: 'dddd [am] LT',
5894        lastDay: '[Ddoe am] LT',
5895        lastWeek: 'dddd [diwethaf am] LT',
5896        sameElse: 'L'
5897    },
5898    relativeTime: {
5899        future: 'mewn %s',
5900        past: '%s yn Ã´l',
5901        s: 'ychydig eiliadau',
5902        m: 'munud',
5903        mm: '%d munud',
5904        h: 'awr',
5905        hh: '%d awr',
5906        d: 'diwrnod',
5907        dd: '%d diwrnod',
5908        M: 'mis',
5909        MM: '%d mis',
5910        y: 'blwyddyn',
5911        yy: '%d flynedd'
5912    },
5913    ordinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
5914    // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
5915    ordinal: function (number) {
5916        var b = number,
5917            output = '',
5918            lookup = [

5919                '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
5920                'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
5921            ];
5922        if (b > 20) {
5923            if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
5924                output = 'fed'; // not 30ain, 70ain or 90ain
5925            } else {
5926                output = 'ain';
5927            }
5928        } else if (b > 0) {
5929            output = lookup[b];
5930        }
5931        return number + output;
5932    },
5933    week : {
5934        dow : 1, // Monday is the first day of the week.
5935        doy : 4  // The week that contains Jan 4th is the first week of the year.
5936    }
5937});
5938
5939//! moment.js locale configuration
5940//! locale : Danish [da]
5941//! author : Ulrik Nielsen : https://github.com/mrbase
5942
5943hooks.defineLocale('da', {
5944    months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
5945    monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
5946    weekdays : 'sÃ¸ndag_mandag_tirsdag_onsdag_torsdag_fredag_lÃ¸rdag'.split('_'),
5947    weekdaysShort : 'sÃ¸n_man_tir_ons_tor_fre_lÃ¸r'.split('_'),
5948    weekdaysMin : 'sÃ¸_ma_ti_on_to_fr_lÃ¸'.split('_'),
5949    longDateFormat : {
5950        LT : 'HH:mm',
5951        LTS : 'HH:mm:ss',
5952        L : 'DD/MM/YYYY',
5953        LL : 'D. MMMM YYYY',
5954        LLL : 'D. MMMM YYYY HH:mm',
5955        LLLL : 'dddd [d.] D. MMMM YYYY HH:mm'
5956    },
5957    calendar : {
5958        sameDay : '[I dag kl.] LT',
5959        nextDay : '[I morgen kl.] LT',
5960        nextWeek : 'dddd [kl.] LT',
5961        lastDay : '[I gÃ¥r kl.] LT',
5962        lastWeek : '[sidste] dddd [kl] LT',
5963        sameElse : 'L'
5964    },
5965    relativeTime : {
5966        future : 'om %s',
5967        past : '%s siden',
5968        s : 'fÃ¥ sekunder',
5969        m : 'et minut',
5970        mm : '%d minutter',
5971        h : 'en time',
5972        hh : '%d timer',
5973        d : 'en dag',
5974        dd : '%d dage',
5975        M : 'en mÃ¥ned',
5976        MM : '%d mÃ¥neder',
5977        y : 'et Ã¥r',
5978        yy : '%d Ã¥r'
5979    },
5980    ordinalParse: /\d{1,2}\./,
5981    ordinal : '%d.',
5982    week : {
5983        dow : 1, // Monday is the first day of the week.
5984        doy : 4  // The week that contains Jan 4th is the first week of the year.
5985    }
5986});
5987
5988//! moment.js locale configuration
5989//! locale : German (Austria) [de-at]
5990//! author : lluchs : https://github.com/lluchs
5991//! author: Menelion ElensÃºle: https://github.com/Oire
5992//! author : Martin Groller : https://github.com/MadMG
5993//! author : Mikolaj Dadela : https://github.com/mik01aj
5994
5995function processRelativeTime(number, withoutSuffix, key, isFuture) {
5996    var format = {
5997        'm': ['eine Minute', 'einer Minute'],
5998        'h': ['eine Stunde', 'einer Stunde'],
5999        'd': ['ein Tag', 'einem Tag'],
6000        'dd': [number + ' Tage', number + ' Tagen'],
6001        'M': ['ein Monat', 'einem Monat'],
6002        'MM': [number + ' Monate', number + ' Monaten'],
6003        'y': ['ein Jahr', 'einem Jahr'],
6004        'yy': [number + ' Jahre', number + ' Jahren']
6005    };
6006    return withoutSuffix ? format[key][0] : format[key][1];
6007}
6008
6009hooks.defineLocale('de-at', {
6010    months : 'JÃ¤nner_Februar_MÃ¤rz_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6011    monthsShort : 'JÃ¤n._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
6012    monthsParseExact : true,
6013    weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6014    weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6015    weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6016    weekdaysParseExact : true,
6017    longDateFormat : {
6018        LT: 'HH:mm',
6019        LTS: 'HH:mm:ss',
6020        L : 'DD.MM.YYYY',
6021        LL : 'D. MMMM YYYY',
6022        LLL : 'D. MMMM YYYY HH:mm',
6023        LLLL : 'dddd, D. MMMM YYYY HH:mm'
6024    },
6025    calendar : {
6026        sameDay: '[heute um] LT [Uhr]',
6027        sameElse: 'L',
6028        nextDay: '[morgen um] LT [Uhr]',
6029        nextWeek: 'dddd [um] LT [Uhr]',
6030        lastDay: '[gestern um] LT [Uhr]',
6031        lastWeek: '[letzten] dddd [um] LT [Uhr]'
6032    },
6033    relativeTime : {
6034        future : 'in %s',
6035        past : 'vor %s',
6036        s : 'ein paar Sekunden',
6037        m : processRelativeTime,
6038        mm : '%d Minuten',
6039        h : processRelativeTime,
6040        hh : '%d Stunden',
6041        d : processRelativeTime,
6042        dd : processRelativeTime,
6043        M : processRelativeTime,
6044        MM : processRelativeTime,
6045        y : processRelativeTime,
6046        yy : processRelativeTime
6047    },
6048    ordinalParse: /\d{1,2}\./,
6049    ordinal : '%d.',
6050    week : {
6051        dow : 1, // Monday is the first day of the week.
6052        doy : 4  // The week that contains Jan 4th is the first week of the year.
6053    }
6054});
6055
6056//! moment.js locale configuration
6057//! locale : German [de]
6058//! author : lluchs : https://github.com/lluchs
6059//! author: Menelion ElensÃºle: https://github.com/Oire
6060//! author : Mikolaj Dadela : https://github.com/mik01aj
6061
6062function processRelativeTime$1(number, withoutSuffix, key, isFuture) {
6063    var format = {
6064        'm': ['eine Minute', 'einer Minute'],
6065        'h': ['eine Stunde', 'einer Stunde'],
6066        'd': ['ein Tag', 'einem Tag'],
6067        'dd': [number + ' Tage', number + ' Tagen'],
6068        'M': ['ein Monat', 'einem Monat'],
6069        'MM': [number + ' Monate', number + ' Monaten'],
6070        'y': ['ein Jahr', 'einem Jahr'],

6071        'yy': [number + ' Jahre', number + ' Jahren']
6072    };
6073    return withoutSuffix ? format[key][0] : format[key][1];
6074}
6075
6076hooks.defineLocale('de', {
6077    months : 'Januar_Februar_MÃ¤rz_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6078    monthsShort : 'Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
6079    monthsParseExact : true,
6080    weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6081    weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6082    weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6083    weekdaysParseExact : true,
6084    longDateFormat : {
6085        LT: 'HH:mm',
6086        LTS: 'HH:mm:ss',
6087        L : 'DD.MM.YYYY',
6088        LL : 'D. MMMM YYYY',
6089        LLL : 'D. MMMM YYYY HH:mm',
6090        LLLL : 'dddd, D. MMMM YYYY HH:mm'
6091    },
6092    calendar : {
6093        sameDay: '[heute um] LT [Uhr]',
6094        sameElse: 'L',
6095        nextDay: '[morgen um] LT [Uhr]',
6096        nextWeek: 'dddd [um] LT [Uhr]',
6097        lastDay: '[gestern um] LT [Uhr]',
6098        lastWeek: '[letzten] dddd [um] LT [Uhr]'
6099    },
6100    relativeTime : {
6101        future : 'in %s',
6102        past : 'vor %s',
6103        s : 'ein paar Sekunden',
6104        m : processRelativeTime$1,
6105        mm : '%d Minuten',
6106        h : processRelativeTime$1,
6107        hh : '%d Stunden',
6108        d : processRelativeTime$1,
6109        dd : processRelativeTime$1,
6110        M : processRelativeTime$1,
6111        MM : processRelativeTime$1,
6112        y : processRelativeTime$1,
6113        yy : processRelativeTime$1
6114    },
6115    ordinalParse: /\d{1,2}\./,
6116    ordinal : '%d.',
6117    week : {
6118        dow : 1, // Monday is the first day of the week.
6119        doy : 4  // The week that contains Jan 4th is the first week of the year.
6120    }
6121});
6122
6123//! moment.js locale configuration
6124//! locale : Maldivian [dv]
6125//! author : Jawish Hameed : https://github.com/jawish
6126
6127var months$4 = [
6128    'ÞÞ¬ÞÞªÞÞ¦ÞÞ©',
6129    'ÞÞ¬ÞÞ°ÞÞªÞÞ¦ÞÞ©',
6130    'ÞÞ§ÞÞ¨ÞÞª',
6131    'ÞÞÞÞ°ÞÞ©ÞÞª',
6132    'ÞÞ',
6133    'ÞÞ«ÞÞ°',
6134    'ÞÞªÞÞ¦ÞÞ¨',
6135    'ÞÞ¯ÞÞ¦ÞÞ°ÞÞª',
6136    'ÞÞ¬ÞÞ°ÞÞ¬ÞÞ°ÞÞ¦ÞÞª',
6137    'ÞÞ®ÞÞ°ÞÞ¯ÞÞ¦ÞÞª',
6138    'ÞÞ®ÞÞ¬ÞÞ°ÞÞ¦ÞÞª',
6139    'ÞÞ¨ÞÞ¬ÞÞ°ÞÞ¦ÞÞª'
6140];
6141var weekdays = [
6142    'ÞÞ§ÞÞ¨ÞÞ°ÞÞ¦',
6143    'ÞÞ¯ÞÞ¦',
6144    'ÞÞ¦ÞÞ°ÞÞ§ÞÞ¦',
6145    'ÞÞªÞÞ¦',
6146    'ÞÞªÞÞ§ÞÞ°ÞÞ¦ÞÞ¨',
6147    'ÞÞªÞÞªÞÞª',
6148    'ÞÞ®ÞÞ¨ÞÞ¨ÞÞª'
6149];
6150
6151hooks.defineLocale('dv', {
6152    months : months$4,
6153    monthsShort : months$4,
6154    weekdays : weekdays,
6155    weekdaysShort : weekdays,
6156    weekdaysMin : 'ÞÞ§ÞÞ¨_ÞÞ¯ÞÞ¦_ÞÞ¦ÞÞ°_ÞÞªÞÞ¦_ÞÞªÞÞ§_ÞÞªÞÞª_ÞÞ®ÞÞ¨'.split('_'),
6157    longDateFormat : {
6158
6159        LT : 'HH:mm',
6160        LTS : 'HH:mm:ss',
6161        L : 'D/M/YYYY',
6162        LL : 'D MMMM YYYY',
6163        LLL : 'D MMMM YYYY HH:mm',
6164        LLLL : 'dddd D MMMM YYYY HH:mm'
6165    },
6166    meridiemParse: /ÞÞ|ÞÞ/,
6167    isPM : function (input) {
6168        return 'ÞÞ' === input;
6169    },
6170    meridiem : function (hour, minute, isLower) {
6171        if (hour < 12) {
6172            return 'ÞÞ';
6173        } else {
6174            return 'ÞÞ';
6175        }
6176    },
6177    calendar : {
6178        sameDay : '[ÞÞ¨ÞÞ¦ÞÞª] LT',
6179        nextDay : '[ÞÞ§ÞÞ¦ÞÞ§] LT',
6180        nextWeek : 'dddd LT',
6181        lastDay : '[ÞÞ¨ÞÞ°ÞÞ¬] LT',
6182        lastWeek : '[ÞÞ§ÞÞ¨ÞÞªÞÞ¨] dddd LT',
6183        sameElse : 'L'
6184    },
6185    relativeTime : {
6186        future : 'ÞÞ¬ÞÞÞÞ¦ÞÞ¨ %s',
6187        past : 'ÞÞªÞÞ¨ÞÞ° %s',
6188        s : 'ÞÞ¨ÞÞªÞÞ°ÞÞªÞÞ®ÞÞ¬ÞÞ°',
6189        m : 'ÞÞ¨ÞÞ¨ÞÞ¬ÞÞ°',
6190        mm : 'ÞÞ¨ÞÞ¨ÞÞª %d',
6191        h : 'ÞÞ¦ÞÞ¨ÞÞ¨ÞÞ¬ÞÞ°',
6192        hh : 'ÞÞ¦ÞÞ¨ÞÞ¨ÞÞª %d',
6193        d : 'ÞÞªÞÞ¦ÞÞ¬ÞÞ°',
6194        dd : 'ÞÞªÞÞ¦ÞÞ° %d',
6195        M : 'ÞÞ¦ÞÞ¬ÞÞ°',
6196        MM : 'ÞÞ¦ÞÞ° %d',
6197        y : 'ÞÞ¦ÞÞ¦ÞÞ¬ÞÞ°',
6198        yy : 'ÞÞ¦ÞÞ¦ÞÞª %d'
6199    },
6200    preparse: function (string) {
6201        return string.replace(/Ø/g, ',');
6202    },
6203    postformat: function (string) {
6204        return string.replace(/,/g, 'Ø');
6205    },
6206    week : {
6207        dow : 7,  // Sunday is the first day of the week.
6208        doy : 12  // The week that contains Jan 1st is the first week of the year.
6209    }
6210});
6211
6212//! moment.js locale configuration
6213//! locale : Greek [el]
6214//! author : Aggelos Karalias : https://github.com/mehiel
6215
6216hooks.defineLocale('el', {
6217    monthsNominativeEl : 'ÎÎ±Î½Î¿ÏÎ¬ÏÎ¹Î¿Ï_Î¦ÎµÎ²ÏÎ¿ÏÎ¬ÏÎ¹Î¿Ï_ÎÎ¬ÏÏÎ¹Î¿Ï_ÎÏÏÎ¯Î»Î¹Î¿Ï_ÎÎ¬Î¹Î¿Ï_ÎÎ¿ÏÎ½Î¹Î¿Ï_ÎÎ¿ÏÎ»Î¹Î¿Ï_ÎÏÎ³Î¿ÏÏÏÎ¿Ï_Î£ÎµÏÏÎÎ¼Î²ÏÎ¹Î¿Ï_ÎÎºÏÏÎ²ÏÎ¹Î¿Ï_ÎÎ¿ÎÎ¼Î²ÏÎ¹Î¿Ï_ÎÎµÎºÎÎ¼Î²ÏÎ¹Î¿Ï'.split('_'),
6218    monthsGenitiveEl : 'ÎÎ±Î½Î¿ÏÎ±ÏÎ¯Î¿Ï_Î¦ÎµÎ²ÏÎ¿ÏÎ±ÏÎ¯Î¿Ï_ÎÎ±ÏÏÎ¯Î¿Ï_ÎÏÏÎ¹Î»Î¯Î¿Ï_ÎÎ±ÎÎ¿Ï_ÎÎ¿ÏÎ½Î¯Î¿Ï_ÎÎ¿ÏÎ»Î¯Î¿Ï_ÎÏÎ³Î¿ÏÏÏÎ¿Ï_Î£ÎµÏÏÎµÎ¼Î²ÏÎ¯Î¿Ï_ÎÎºÏÏÎ²ÏÎ¯Î¿Ï_ÎÎ¿ÎµÎ¼Î²ÏÎ¯Î¿Ï_ÎÎµÎºÎµÎ¼Î²ÏÎ¯Î¿Ï'.split('_'),
6219    months : function (momentToFormat, format) {
6220        if (/D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
6221            return this._monthsGenitiveEl[momentToFormat.month()];
6222        } else {
6223            return this._monthsNominativeEl[momentToFormat.month()];
6224        }
6225    },
6226    monthsShort : 'ÎÎ±Î½_Î¦ÎµÎ²_ÎÎ±Ï_ÎÏÏ_ÎÎ±Ï_ÎÎ¿ÏÎ½_ÎÎ¿ÏÎ»_ÎÏÎ³_Î£ÎµÏ_ÎÎºÏ_ÎÎ¿Îµ_ÎÎµÎº'.split('_'),
6227    weekdays : 'ÎÏÏÎ¹Î±ÎºÎ®_ÎÎµÏÏÎÏÎ±_Î¤ÏÎ¯ÏÎ·_Î¤ÎµÏÎ¬ÏÏÎ·_Î ÎÎ¼ÏÏÎ·_Î Î±ÏÎ±ÏÎºÎµÏÎ®_Î£Î¬Î²Î²Î±ÏÎ¿'.split('_'),
6228    weekdaysShort : 'ÎÏÏ_ÎÎµÏ_Î¤ÏÎ¹_Î¤ÎµÏ_Î ÎµÎ¼_Î Î±Ï_Î£Î±Î²'.split('_'),
6229    weekdaysMin : 'ÎÏ_ÎÎµ_Î¤Ï_Î¤Îµ_Î Îµ_Î Î±_Î£Î±'.split('_'),
6230    meridiem : function (hours, minutes, isLower) {
6231        if (hours > 11) {
6232            return isLower ? 'Î¼Î¼' : 'ÎÎ';
6233        } else {
6234            return isLower ? 'ÏÎ¼' : 'Î Î';
6235        }
6236    },
6237    isPM : function (input) {
6238        return ((input + '').toLowerCase()[0] === 'Î¼');
6239    },
6240    meridiemParse : /[Î Î]\.?Î?\.?/i,
6241    longDateFormat : {
6242        LT : 'h:mm A',
6243        LTS : 'h:mm:ss A',
6244        L : 'DD/MM/YYYY',
6245        LL : 'D MMMM YYYY',
6246        LLL : 'D MMMM YYYY h:mm A',
6247        LLLL : 'dddd, D MMMM YYYY h:mm A'
6248    },
6249    calendarEl : {
6250        sameDay : '[Î£Î®Î¼ÎµÏÎ± {}] LT',
6251        nextDay : '[ÎÏÏÎ¹Î¿ {}] LT',
6252        nextWeek : 'dddd [{}] LT',
6253        lastDay : '[Î§Î¸ÎµÏ {}] LT',
6254        lastWeek : function () {
6255            switch (this.day()) {
6256                case 6:
6257                    return '[ÏÎ¿ ÏÏÎ¿Î·Î³Î¿ÏÎ¼ÎµÎ½Î¿] dddd [{}] LT';
6258                default:
6259                    return '[ÏÎ·Î½ ÏÏÎ¿Î·Î³Î¿ÏÎ¼ÎµÎ½Î·] dddd [{}] LT';
6260            }
6261        },
6262        sameElse : 'L'
6263    },
6264    calendar : function (key, mom) {
6265        var output = this._calendarEl[key],
6266            hours = mom && mom.hours();
6267        if (isFunction(output)) {
6268            output = output.apply(mom);
6269        }
6270        return output.replace('{}', (hours % 12 === 1 ? 'ÏÏÎ·' : 'ÏÏÎ¹Ï'));
6271    },
6272    relativeTime : {
6273        future : 'ÏÎµ %s',
6274        past : '%s ÏÏÎ¹Î½',
6275        s : 'Î»Î¯Î³Î± Î´ÎµÏÏÎµÏÏÎ»ÎµÏÏÎ±',
6276        m : 'ÎÎ½Î± Î»ÎµÏÏÏ',
6277        mm : '%d Î»ÎµÏÏÎ¬',
6278        h : 'Î¼Î¯Î± ÏÏÎ±',
6279        hh : '%d ÏÏÎµÏ',
6280        d : 'Î¼Î¯Î± Î¼ÎÏÎ±',
6281        dd : '%d Î¼ÎÏÎµÏ',

6282        M : 'ÎÎ½Î±Ï Î¼Î®Î½Î±Ï',
6283        MM : '%d Î¼Î®Î½ÎµÏ',
6284        y : 'ÎÎ½Î±Ï ÏÏÏÎ½Î¿Ï',
6285        yy : '%d ÏÏÏÎ½Î¹Î±'
6286    },
6287    ordinalParse: /\d{1,2}Î·/,
6288    ordinal: '%dÎ·',
6289    week : {
6290        dow : 1, // Monday is the first day of the week.
6291        doy : 4  // The week that contains Jan 4st is the first week of the year.
6292    }
6293});
6294
6295//! moment.js locale configuration
6296//! locale : English (Australia) [en-au]
6297//! author : Jared Morse : https://github.com/jarcoal
6298
6299hooks.defineLocale('en-au', {
6300    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6301    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6302    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6303    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6304    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6305    longDateFormat : {
6306        LT : 'h:mm A',
6307        LTS : 'h:mm:ss A',
6308        L : 'DD/MM/YYYY',
6309        LL : 'D MMMM YYYY',
6310        LLL : 'D MMMM YYYY h:mm A',
6311        LLLL : 'dddd, D MMMM YYYY h:mm A'
6312    },
6313    calendar : {
6314        sameDay : '[Today at] LT',
6315        nextDay : '[Tomorrow at] LT',
6316        nextWeek : 'dddd [at] LT',
6317        lastDay : '[Yesterday at] LT',
6318        lastWeek : '[Last] dddd [at] LT',
6319        sameElse : 'L'
6320    },
6321    relativeTime : {
6322        future : 'in %s',
6323        past : '%s ago',
6324        s : 'a few seconds',
6325        m : 'a minute',
6326        mm : '%d minutes',
6327        h : 'an hour',
6328        hh : '%d hours',
6329        d : 'a day',
6330        dd : '%d days',
6331        M : 'a month',
6332        MM : '%d months',
6333        y : 'a year',
6334        yy : '%d years'
6335    },
6336    ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6337    ordinal : function (number) {
6338        var b = number % 10,
6339            output = (~~(number % 100 / 10) === 1) ? 'th' :
6340            (b === 1) ? 'st' :
6341            (b === 2) ? 'nd' :
6342            (b === 3) ? 'rd' : 'th';
6343        return number + output;
6344    },
6345    week : {
6346        dow : 1, // Monday is the first day of the week.
6347        doy : 4  // The week that contains Jan 4th is the first week of the year.
6348    }
6349});
6350
6351//! moment.js locale configuration
6352//! locale : English (Canada) [en-ca]
6353//! author : Jonathan Abourbih : https://github.com/jonbca
6354
6355hooks.defineLocale('en-ca', {
6356    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6357    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6358    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6359    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6360    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6361    longDateFormat : {
6362        LT : 'h:mm A',
6363        LTS : 'h:mm:ss A',
6364        L : 'YYYY-MM-DD',
6365        LL : 'MMMM D, YYYY',
6366        LLL : 'MMMM D, YYYY h:mm A',
6367        LLLL : 'dddd, MMMM D, YYYY h:mm A'
6368    },
6369    calendar : {
6370        sameDay : '[Today at] LT',
6371        nextDay : '[Tomorrow at] LT',
6372        nextWeek : 'dddd [at] LT',
6373        lastDay : '[Yesterday at] LT',
6374        lastWeek : '[Last] dddd [at] LT',
6375        sameElse : 'L'
6376    },
6377    relativeTime : {
6378        future : 'in %s',
6379        past : '%s ago',
6380        s : 'a few seconds',
6381        m : 'a minute',
6382        mm : '%d minutes',
6383        h : 'an hour',
6384        hh : '%d hours',
6385        d : 'a day',
6386        dd : '%d days',
6387        M : 'a month',
6388        MM : '%d months',
6389        y : 'a year',
6390        yy : '%d years'
6391    },
6392    ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6393    ordinal : function (number) {
6394        var b = number % 10,
6395            output = (~~(number % 100 / 10) === 1) ? 'th' :
6396            (b === 1) ? 'st' :
6397            (b === 2) ? 'nd' :
6398            (b === 3) ? 'rd' : 'th';
6399        return number + output;
6400    }
6401});
6402
6403//! moment.js locale configuration
6404//! locale : English (United Kingdom) [en-gb]
6405//! author : Chris Gedrim : https://github.com/chrisgedrim
6406
6407hooks.defineLocale('en-gb', {
6408    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6409    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6410    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6411    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6412    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6413    longDateFormat : {
6414        LT : 'HH:mm',
6415        LTS : 'HH:mm:ss',
6416        L : 'DD/MM/YYYY',
6417        LL : 'D MMMM YYYY',
6418        LLL : 'D MMMM YYYY HH:mm',
6419        LLLL : 'dddd, D MMMM YYYY HH:mm'
6420    },
6421    calendar : {
6422        sameDay : '[Today at] LT',
6423        nextDay : '[Tomorrow at] LT',
6424        nextWeek : 'dddd [at] LT',
6425        lastDay : '[Yesterday at] LT',
6426        lastWeek : '[Last] dddd [at] LT',
6427        sameElse : 'L'
6428    },
6429    relativeTime : {
6430        future : 'in %s',
6431        past : '%s ago',
6432        s : 'a few seconds',
6433        m : 'a minute',
6434        mm : '%d minutes',
6435        h : 'an hour',
6436        hh : '%d hours',
6437        d : 'a day',
6438        dd : '%d days',
6439        M : 'a month',
6440        MM : '%d months',
6441        y : 'a year',
6442        yy : '%d years'
6443    },
6444    ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6445    ordinal : function (number) {
6446        var b = number % 10,
6447            output = (~~(number % 100 / 10) === 1) ? 'th' :
6448            (b === 1) ? 'st' :
6449            (b === 2) ? 'nd' :
6450            (b === 3) ? 'rd' : 'th';
6451        return number + output;
6452    },
6453    week : {
6454        dow : 1, // Monday is the first day of the week.
6455        doy : 4  // The week that contains Jan 4th is the first week of the year.
6456    }
6457});
6458
6459//! moment.js locale configuration
6460//! locale : English (Ireland) [en-ie]
6461//! author : Chris Cartlidge : https://github.com/chriscartlidge
6462
6463hooks.defineLocale('en-ie', {
6464    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6465    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6466    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6467    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6468    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6469    longDateFormat : {
6470        LT : 'HH:mm',
6471        LTS : 'HH:mm:ss',
6472        L : 'DD-MM-YYYY',
6473        LL : 'D MMMM YYYY',
6474        LLL : 'D MMMM YYYY HH:mm',
6475        LLLL : 'dddd D MMMM YYYY HH:mm'
6476    },
6477    calendar : {
6478        sameDay : '[Today at] LT',
6479        nextDay : '[Tomorrow at] LT',
6480        nextWeek : 'dddd [at] LT',
6481        lastDay : '[Yesterday at] LT',
6482        lastWeek : '[Last] dddd [at] LT',
6483        sameElse : 'L'
6484    },
6485    relativeTime : {
6486        future : 'in %s',
6487        past : '%s ago',
6488        s : 'a few seconds',
6489        m : 'a minute',
6490        mm : '%d minutes',
6491        h : 'an hour',
6492        hh : '%d hours',
6493        d : 'a day',
6494        dd : '%d days',
6495        M : 'a month',
6496        MM : '%d months',
6497        y : 'a year',
6498        yy : '%d years'
6499    },
6500    ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6501    ordinal : function (number) {
6502        var b = number % 10,
6503            output = (~~(number % 100 / 10) === 1) ? 'th' :
6504            (b === 1) ? 'st' :
6505            (b === 2) ? 'nd' :
6506            (b === 3) ? 'rd' : 'th';
6507        return number + output;
6508    },
6509    week : {
6510        dow : 1, // Monday is the first day of the week.
6511        doy : 4  // The week that contains Jan 4th is the first week of the year.
6512    }
6513});
6514
6515//! moment.js locale configuration
6516//! locale : English (New Zealand) [en-nz]
6517//! author : Luke McGregor : https://github.com/lukemcgregor
6518
6519hooks.defineLocale('en-nz', {
6520    months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6521    monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6522    weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6523    weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6524    weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6525    longDateFormat : {
6526        LT : 'h:mm A',
6527        LTS : 'h:mm:ss A',
6528        L : 'DD/MM/YYYY',
6529        LL : 'D MMMM YYYY',
6530        LLL : 'D MMMM YYYY h:mm A',
6531        LLLL : 'dddd, D MMMM YYYY h:mm A'
6532    },
6533    calendar : {
6534        sameDay : '[Today at] LT',
6535        nextDay : '[Tomorrow at] LT',
6536        nextWeek : 'dddd [at] LT',
6537        lastDay : '[Yesterday at] LT',
6538        lastWeek : '[Last] dddd [at] LT',
6539        sameElse : 'L'
6540    },
6541    relativeTime : {
6542        future : 'in %s',
6543        past : '%s ago',
6544        s : 'a few seconds',
6545        m : 'a minute',
6546        mm : '%d minutes',
6547        h : 'an hour',
6548        hh : '%d hours',
6549        d : 'a day',
6550        dd : '%d days',
6551        M : 'a month',
6552        MM : '%d months',
6553        y : 'a year',
6554        yy : '%d years'
6555    },
6556    ordinalParse: /\d{1,2}(st|nd|rd|th)/,
6557    ordinal : function (number) {
6558        var b = number % 10,
6559            output = (~~(number % 100 / 10) === 1) ? 'th' :
6560            (b === 1) ? 'st' :
6561            (b === 2) ? 'nd' :
6562            (b === 3) ? 'rd' : 'th';
6563        return number + output;
6564    },
6565    week : {
6566        dow : 1, // Monday is the first day of the week.
6567        doy : 4  // The week that contains Jan 4th is the first week of the year.
6568    }
6569});
6570
6571//! moment.js locale configuration
6572//! locale : Esperanto [eo]
6573//! author : Colin Dean : https://github.com/colindean
6574//! komento: Mi estas malcerta se mi korekte traktis akuzativojn en tiu traduko.
6575//!          Se ne, bonvolu korekti kaj avizi min por ke mi povas lerni!
6576
6577hooks.defineLocale('eo', {
6578    months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aÅgusto_septembro_oktobro_novembro_decembro'.split('_'),
6579    monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aÅg_sep_okt_nov_dec'.split('_'),
6580    weekdays : 'DimanÄo_Lundo_Mardo_Merkredo_Ä´aÅdo_Vendredo_Sabato'.split('_'),
6581    weekdaysShort : 'Dim_Lun_Mard_Merk_Ä´aÅ_Ven_Sab'.split('_'),
6582    weekdaysMin : 'Di_Lu_Ma_Me_Ä´a_Ve_Sa'.split('_'),
6583    longDateFormat : {
6584        LT : 'HH:mm',
6585        LTS : 'HH:mm:ss',
6586        L : 'YYYY-MM-DD',
6587        LL : 'D[-an de] MMMM, YYYY',
6588        LLL : 'D[-an de] MMMM, YYYY HH:mm',
6589        LLLL : 'dddd, [la] D[-an de] MMMM, YYYY HH:mm'
6590    },
6591    meridiemParse: /[ap]\.t\.m/i,
6592    isPM: function (input) {
6593        return input.charAt(0).toLowerCase() === 'p';
6594    },
6595    meridiem : function (hours, minutes, isLower) {
6596        if (hours > 11) {
6597            return isLower ? 'p.t.m.' : 'P.T.M.';
6598        } else {
6599            return isLower ? 'a.t.m.' : 'A.T.M.';
6600        }
6601    },
6602    calendar : {
6603        sameDay : '[HodiaÅ je] LT',
6604        nextDay : '[MorgaÅ je] LT',
6605        nextWeek : 'dddd [je] LT',
6606        lastDay : '[HieraÅ je] LT',
6607        lastWeek : '[pasinta] dddd [je] LT',
6608        sameElse : 'L'
6609    },
6610    relativeTime : {
6611        future : 'je %s',
6612        past : 'antaÅ %s',
6613        s : 'sekundoj',
6614        m : 'minuto',
6615        mm : '%d minutoj',
6616        h : 'horo',
6617        hh : '%d horoj',
6618        d : 'tago',//ne 'diurno', Äar estas uzita por proksimumo
6619        dd : '%d tagoj',
6620        M : 'monato',
6621        MM : '%d monatoj',
6622        y : 'jaro',
6623        yy : '%d jaroj'
6624    },
6625    ordinalParse: /\d{1,2}a/,
6626    ordinal : '%da',
6627    week : {
6628        dow : 1, // Monday is the first day of the week.
6629        doy : 7  // The week that contains Jan 1st is the first week of the year.
6630    }
6631});
6632
6633//! moment.js locale configuration
6634//! locale : Spanish (Dominican Republic) [es-do]
6635
6636var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_');
6637var monthsShort$1 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
6638
6639hooks.defineLocale('es-do', {
6640    months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
6641    monthsShort : function (m, format) {
6642        if (/-MMM-/.test(format)) {
6643            return monthsShort$1[m.month()];
6644        } else {
6645            return monthsShortDot[m.month()];
6646        }
6647    },
6648    monthsParseExact : true,
6649    weekdays : 'domingo_lunes_martes_miÃ©rcoles_jueves_viernes_sÃ¡bado'.split('_'),
6650    weekdaysShort : 'dom._lun._mar._miÃ©._jue._vie._sÃ¡b.'.split('_'),
6651    weekdaysMin : 'do_lu_ma_mi_ju_vi_sÃ¡'.split('_'),
6652    weekdaysParseExact : true,
6653    longDateFormat : {
6654        LT : 'h:mm A',
6655        LTS : 'h:mm:ss A',
6656        L : 'DD/MM/YYYY',
6657        LL : 'D [de] MMMM [de] YYYY',
6658        LLL : 'D [de] MMMM [de] YYYY h:mm A',
6659        LLLL : 'dddd, D [de] MMMM [de] YYYY h:mm A'
6660    },
6661    calendar : {
6662        sameDay : function () {
6663            return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6664        },
6665        nextDay : function () {
6666            return '[maÃ±ana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6667        },
6668        nextWeek : function () {
6669            return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6670        },
6671        lastDay : function () {
6672            return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6673        },
6674        lastWeek : function () {
6675            return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6676        },
6677        sameElse : 'L'
6678    },
6679    relativeTime : {
6680        future : 'en %s',
6681        past : 'hace %s',
6682        s : 'unos segundos',
6683        m : 'un minuto',
6684        mm : '%d minutos',
6685        h : 'una hora',
6686        hh : '%d horas',
6687        d : 'un dÃa',
6688        dd : '%d dÃas',
6689        M : 'un mes',
6690        MM : '%d meses',
6691        y : 'un aÃ±o',
6692        yy : '%d aÃ±os'
6693    },
6694    ordinalParse : /\d{1,2}Âº/,
6695    ordinal : '%dÂº',
6696    week : {
6697        dow : 1, // Monday is the first day of the week.
6698        doy : 4  // The week that contains Jan 4th is the first week of the year.
6699    }
6700});
6701
6702//! moment.js locale configuration
6703//! locale : Spanish [es]
6704//! author : Julio NapurÃ : https://github.com/julionc
6705
6706var monthsShortDot$1 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_');
6707var monthsShort$2 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
6708
6709hooks.defineLocale('es', {
6710    months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
6711    monthsShort : function (m, format) {
6712        if (/-MMM-/.test(format)) {
6713            return monthsShort$2[m.month()];
6714        } else {
6715            return monthsShortDot$1[m.month()];
6716        }
6717    },
6718    monthsParseExact : true,
6719    weekdays : 'domingo_lunes_martes_miÃ©rcoles_jueves_viernes_sÃ¡bado'.split('_'),
6720    weekdaysShort : 'dom._lun._mar._miÃ©._jue._vie._sÃ¡b.'.split('_'),
6721    weekdaysMin : 'do_lu_ma_mi_ju_vi_sÃ¡'.split('_'),
6722    weekdaysParseExact : true,
6723    longDateFormat : {
6724        LT : 'H:mm',
6725        LTS : 'H:mm:ss',
6726        L : 'DD/MM/YYYY',
6727        LL : 'D [de] MMMM [de] YYYY',
6728        LLL : 'D [de] MMMM [de] YYYY H:mm',
6729        LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
6730    },
6731    calendar : {
6732        sameDay : function () {
6733            return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6734        },
6735        nextDay : function () {
6736            return '[maÃ±ana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6737        },
6738        nextWeek : function () {
6739            return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6740        },
6741        lastDay : function () {
6742            return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6743        },
6744        lastWeek : function () {
6745            return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
6746        },
6747        sameElse : 'L'
6748    },
6749    relativeTime : {
6750        future : 'en %s',
6751        past : 'hace %s',
6752        s : 'unos segundos',
6753        m : 'un minuto',
6754        mm : '%d minutos',
6755        h : 'una hora',
6756        hh : '%d horas',
6757        d : 'un dÃa',
6758        dd : '%d dÃas',
6759        M : 'un mes',
6760        MM : '%d meses',
6761        y : 'un aÃ±o',
6762        yy : '%d aÃ±os'
6763    },
6764    ordinalParse : /\d{1,2}Âº/,
6765    ordinal : '%dÂº',
6766    week : {
6767        dow : 1, // Monday is the first day of the week.
6768        doy : 4  // The week that contains Jan 4th is the first week of the year.
6769    }
6770});
6771
6772//! moment.js locale configuration
6773//! locale : Estonian [et]

6774//! author : Henry Kehlmann : https://github.com/madhenry
6775//! improvements : Illimar Tambek : https://github.com/ragulka
6776
6777function processRelativeTime$2(number, withoutSuffix, key, isFuture) {
6778    var format = {
6779        's' : ['mÃµne sekundi', 'mÃµni sekund', 'paar sekundit'],
6780        'm' : ['Ã¼he minuti', 'Ã¼ks minut'],
6781        'mm': [number + ' minuti', number + ' minutit'],
6782        'h' : ['Ã¼he tunni', 'tund aega', 'Ã¼ks tund'],
6783        'hh': [number + ' tunni', number + ' tundi'],
6784        'd' : ['Ã¼he pÃ¤eva', 'Ã¼ks pÃ¤ev'],
6785        'M' : ['kuu aja', 'kuu aega', 'Ã¼ks kuu'],
6786        'MM': [number + ' kuu', number + ' kuud'],
6787        'y' : ['Ã¼he aasta', 'aasta', 'Ã¼ks aasta'],
6788        'yy': [number + ' aasta', number + ' aastat']
6789    };
6790    if (withoutSuffix) {
6791        return format[key][2] ? format[key][2] : format[key][1];
6792    }
6793    return isFuture ? format[key][0] : format[key][1];
6794}
6795
6796hooks.defineLocale('et', {
6797    months        : 'jaanuar_veebruar_mÃ¤rts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
6798    monthsShort   : 'jaan_veebr_mÃ¤rts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
6799    weekdays      : 'pÃ¼hapÃ¤ev_esmaspÃ¤ev_teisipÃ¤ev_kolmapÃ¤ev_neljapÃ¤ev_reede_laupÃ¤ev'.split('_'),
6800    weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
6801    weekdaysMin   : 'P_E_T_K_N_R_L'.split('_'),
6802    longDateFormat : {
6803        LT   : 'H:mm',
6804        LTS : 'H:mm:ss',
6805        L    : 'DD.MM.YYYY',
6806        LL   : 'D. MMMM YYYY',
6807        LLL  : 'D. MMMM YYYY H:mm',
6808        LLLL : 'dddd, D. MMMM YYYY H:mm'
6809    },
6810    calendar : {
6811        sameDay  : '[TÃ¤na,] LT',
6812        nextDay  : '[Homme,] LT',
6813        nextWeek : '[JÃ¤rgmine] dddd LT',
6814        lastDay  : '[Eile,] LT',
6815        lastWeek : '[Eelmine] dddd LT',
6816        sameElse : 'L'
6817    },
6818    relativeTime : {
6819        future : '%s pÃ¤rast',
6820        past   : '%s tagasi',
6821        s      : processRelativeTime$2,
6822        m      : processRelativeTime$2,
6823        mm     : processRelativeTime$2,
6824        h      : processRelativeTime$2,
6825        hh     : processRelativeTime$2,
6826        d      : processRelativeTime$2,
6827        dd     : '%d pÃ¤eva',
6828        M      : processRelativeTime$2,
6829        MM     : processRelativeTime$2,
6830        y      : processRelativeTime$2,
6831        yy     : processRelativeTime$2
6832    },
6833    ordinalParse: /\d{1,2}\./,
6834    ordinal : '%d.',
6835    week : {
6836        dow : 1, // Monday is the first day of the week.
6837        doy : 4  // The week that contains Jan 4th is the first week of the year.
6838    }
6839});
6840
6841//! moment.js locale configuration
6842//! locale : Basque [eu]
6843//! author : Eneko Illarramendi : https://github.com/eillarra
6844
6845hooks.defineLocale('eu', {
6846    months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
6847    monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
6848    monthsParseExact : true,
6849    weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
6850    weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
6851    weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
6852    weekdaysParseExact : true,
6853    longDateFormat : {
6854        LT : 'HH:mm',
6855        LTS : 'HH:mm:ss',
6856        L : 'YYYY-MM-DD',
6857        LL : 'YYYY[ko] MMMM[ren] D[a]',
6858        LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm',
6859        LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
6860        l : 'YYYY-M-D',
6861        ll : 'YYYY[ko] MMM D[a]',
6862        lll : 'YYYY[ko] MMM D[a] HH:mm',
6863        llll : 'ddd, YYYY[ko] MMM D[a] HH:mm'
6864    },
6865    calendar : {
6866        sameDay : '[gaur] LT[etan]',
6867        nextDay : '[bihar] LT[etan]',
6868        nextWeek : 'dddd LT[etan]',
6869        lastDay : '[atzo] LT[etan]',
6870        lastWeek : '[aurreko] dddd LT[etan]',
6871        sameElse : 'L'
6872    },
6873    relativeTime : {
6874        future : '%s barru',
6875        past : 'duela %s',
6876        s : 'segundo batzuk',
6877        m : 'minutu bat',
6878        mm : '%d minutu',
6879        h : 'ordu bat',
6880        hh : '%d ordu',
6881        d : 'egun bat',
6882        dd : '%d egun',
6883        M : 'hilabete bat',
6884        MM : '%d hilabete',
6885        y : 'urte bat',
6886        yy : '%d urte'
6887    },
6888    ordinalParse: /\d{1,2}\./,
6889    ordinal : '%d.',
6890    week : {
6891        dow : 1, // Monday is the first day of the week.
6892        doy : 7  // The week that contains Jan 1st is the first week of the year.
6893    }
6894});
6895
6896//! moment.js locale configuration
6897//! locale : Persian [fa]
6898//! author : Ebrahim Byagowi : https://github.com/ebraminio
6899
6900var symbolMap$5 = {
6901    '1': 'Û±',
6902    '2': 'Û²',
6903    '3': 'Û³',
6904    '4': 'Û´',
6905    '5': 'Ûµ',
6906    '6': 'Û¶',
6907    '7': 'Û·',
6908    '8': 'Û¸',
6909    '9': 'Û¹',
6910    '0': 'Û°'
6911};
6912var numberMap$4 = {
6913    'Û±': '1',
6914    'Û²': '2',
6915    'Û³': '3',
6916    'Û´': '4',
6917    'Ûµ': '5',
6918    'Û¶': '6',
6919    'Û·': '7',
6920    'Û¸': '8',
6921    'Û¹': '9',
6922    'Û°': '0'
6923};
6924
6925hooks.defineLocale('fa', {
6926    months : 'ÚØ§ÙÙÛÙ_ÙÙØ±ÛÙ_ÙØ§Ø±Ø³_Ø¢ÙØ±ÛÙ_ÙÙ_ÚÙØ¦Ù_ÚÙØ¦ÛÙ_Ø§ÙØª_Ø³Ù¾ØªØ§ÙØ¨Ø±_Ø§Ú©ØªØ¨Ø±_ÙÙØ§ÙØ¨Ø±_Ø¯Ø³Ø§ÙØ¨Ø±'.split('_'),
6927    monthsShort : 'ÚØ§ÙÙÛÙ_ÙÙØ±ÛÙ_ÙØ§Ø±Ø³_Ø¢ÙØ±ÛÙ_ÙÙ_ÚÙØ¦Ù_ÚÙØ¦ÛÙ_Ø§ÙØª_Ø³Ù¾ØªØ§ÙØ¨Ø±_Ø§Ú©ØªØ¨Ø±_ÙÙØ§ÙØ¨Ø±_Ø¯Ø³Ø§ÙØ¨Ø±'.split('_'),

6928    weekdays : 'ÛÚ©\u200cØ´ÙØ¨Ù_Ø¯ÙØ´ÙØ¨Ù_Ø³Ù\u200cØ´ÙØ¨Ù_ÚÙØ§Ø±Ø´ÙØ¨Ù_Ù¾ÙØ¬\u200cØ´ÙØ¨Ù_Ø¬ÙØ¹Ù_Ø´ÙØ¨Ù'.split('_'),
6929    weekdaysShort : 'ÛÚ©\u200cØ´ÙØ¨Ù_Ø¯ÙØ´ÙØ¨Ù_Ø³Ù\u200cØ´ÙØ¨Ù_ÚÙØ§Ø±Ø´ÙØ¨Ù_Ù¾ÙØ¬\u200cØ´ÙØ¨Ù_Ø¬ÙØ¹Ù_Ø´ÙØ¨Ù'.split('_'),
6930    weekdaysMin : 'Û_Ø¯_Ø³_Ú_Ù¾_Ø¬_Ø´'.split('_'),
6931    weekdaysParseExact : true,
6932    longDateFormat : {
6933        LT : 'HH:mm',
6934        LTS : 'HH:mm:ss',
6935        L : 'DD/MM/YYYY',
6936        LL : 'D MMMM YYYY',
6937        LLL : 'D MMMM YYYY HH:mm',
6938        LLLL : 'dddd, D MMMM YYYY HH:mm'
6939    },
6940    meridiemParse: /ÙØ¨Ù Ø§Ø² Ø¸ÙØ±|Ø¨Ø¹Ø¯ Ø§Ø² Ø¸ÙØ±/,
6941    isPM: function (input) {
6942        return /Ø¨Ø¹Ø¯ Ø§Ø² Ø¸ÙØ±/.test(input);
6943    },
6944    meridiem : function (hour, minute, isLower) {
6945        if (hour < 12) {
6946            return 'ÙØ¨Ù Ø§Ø² Ø¸ÙØ±';
6947        } else {
6948            return 'Ø¨Ø¹Ø¯ Ø§Ø² Ø¸ÙØ±';
6949        }
6950    },
6951    calendar : {
6952        sameDay : '[Ø§ÙØ±ÙØ² Ø³Ø§Ø¹Øª] LT',
6953        nextDay : '[ÙØ±Ø¯Ø§ Ø³Ø§Ø¹Øª] LT',
6954        nextWeek : 'dddd [Ø³Ø§Ø¹Øª] LT',
6955        lastDay : '[Ø¯ÛØ±ÙØ² Ø³Ø§Ø¹Øª] LT',
6956        lastWeek : 'dddd [Ù¾ÛØ´] [Ø³Ø§Ø¹Øª] LT',
6957        sameElse : 'L'
6958    },
6959    relativeTime : {
6960        future : 'Ø¯Ø± %s',
6961        past : '%s Ù¾ÛØ´',
6962        s : 'ÚÙØ¯ÛÙ Ø«Ø§ÙÛÙ',
6963        m : 'ÛÚ© Ø¯ÙÛÙÙ',
6964        mm : '%d Ø¯ÙÛÙÙ',
6965        h : 'ÛÚ© Ø³Ø§Ø¹Øª',
6966        hh : '%d Ø³Ø§Ø¹Øª',
6967        d : 'ÛÚ© Ø±ÙØ²',
6968        dd : '%d Ø±ÙØ²',
6969        M : 'ÛÚ© ÙØ§Ù',
6970        MM : '%d ÙØ§Ù',
6971        y : 'ÛÚ© Ø³Ø§Ù',
6972        yy : '%d Ø³Ø§Ù'
6973    },
6974    preparse: function (string) {
6975        return string.replace(/[Û°-Û¹]/g, function (match) {
6976            return numberMap$4[match];
6977        }).replace(/Ø/g, ',');
6978    },
6979    postformat: function (string) {
6980        return string.replace(/\d/g, function (match) {
6981            return symbolMap$5[match];
6982        }).replace(/,/g, 'Ø');
6983    },
6984    ordinalParse: /\d{1,2}Ù/,
6985    ordinal : '%dÙ',
6986    week : {
6987        dow : 6, // Saturday is the first day of the week.
6988        doy : 12 // The week that contains Jan 1st is the first week of the year.
6989    }
6990});
6991
6992//! moment.js locale configuration
6993//! locale : Finnish [fi]
6994//! author : Tarmo Aidantausta : https://github.com/bleadof
6995
6996var numbersPast = 'nolla yksi kaksi kolme neljÃ¤ viisi kuusi seitsemÃ¤n kahdeksan yhdeksÃ¤n'.split(' ');
6997var numbersFuture = [
6998        'nolla', 'yhden', 'kahden', 'kolmen', 'neljÃ¤n', 'viiden', 'kuuden',
6999        numbersPast[7], numbersPast[8], numbersPast[9]
7000    ];
7001function translate$2(number, withoutSuffix, key, isFuture) {
7002    var result = '';
7003    switch (key) {
7004        case 's':
7005            return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
7006        case 'm':
7007            return isFuture ? 'minuutin' : 'minuutti';
7008        case 'mm':
7009            result = isFuture ? 'minuutin' : 'minuuttia';
7010            break;
7011        case 'h':
7012            return isFuture ? 'tunnin' : 'tunti';
7013        case 'hh':
7014            result = isFuture ? 'tunnin' : 'tuntia';
7015            break;
7016        case 'd':
7017            return isFuture ? 'pÃ¤ivÃ¤n' : 'pÃ¤ivÃ¤';
7018        case 'dd':
7019            result = isFuture ? 'pÃ¤ivÃ¤n' : 'pÃ¤ivÃ¤Ã¤';
7020            break;
7021        case 'M':
7022            return isFuture ? 'kuukauden' : 'kuukausi';
7023        case 'MM':
7024            result = isFuture ? 'kuukauden' : 'kuukautta';
7025            break;
7026        case 'y':
7027            return isFuture ? 'vuoden' : 'vuosi';
7028        case 'yy':
7029            result = isFuture ? 'vuoden' : 'vuotta';
7030            break;
7031    }
7032    result = verbalNumber(number, isFuture) + ' ' + result;
7033    return result;
7034}
7035function verbalNumber(number, isFuture) {
7036    return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;
7037}
7038
7039hooks.defineLocale('fi', {
7040    months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesÃ¤kuu_heinÃ¤kuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
7041    monthsShort : 'tammi_helmi_maalis_huhti_touko_kesÃ¤_heinÃ¤_elo_syys_loka_marras_joulu'.split('_'),
7042    weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
7043    weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
7044    weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
7045    longDateFormat : {
7046        LT : 'HH.mm',
7047        LTS : 'HH.mm.ss',
7048        L : 'DD.MM.YYYY',
7049        LL : 'Do MMMM[ta] YYYY',
7050        LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm',
7051        LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
7052        l : 'D.M.YYYY',
7053        ll : 'Do MMM YYYY',
7054        lll : 'Do MMM YYYY, [klo] HH.mm',
7055        llll : 'ddd, Do MMM YYYY, [klo] HH.mm'
7056    },
7057    calendar : {
7058        sameDay : '[tÃ¤nÃ¤Ã¤n] [klo] LT',
7059        nextDay : '[huomenna] [klo] LT',
7060        nextWeek : 'dddd [klo] LT',
7061        lastDay : '[eilen] [klo] LT',
7062        lastWeek : '[viime] dddd[na] [klo] LT',
7063        sameElse : 'L'
7064    },
7065    relativeTime : {
7066        future : '%s pÃ¤Ã¤stÃ¤',
7067        past : '%s sitten',
7068        s : translate$2,
7069        m : translate$2,
7070        mm : translate$2,
7071        h : translate$2,
7072        hh : translate$2,
7073        d : translate$2,
7074        dd : translate$2,
7075        M : translate$2,
7076        MM : translate$2,
7077        y : translate$2,
7078        yy : translate$2
7079    },
7080    ordinalParse: /\d{1,2}\./,
7081    ordinal : '%d.',
7082    week : {
7083        dow : 1, // Monday is the first day of the week.
7084        doy : 4  // The week that contains Jan 4th is the first week of the year.
7085    }
7086});
7087
7088//! moment.js locale configuration
7089//! locale : Faroese [fo]
7090//! author : Ragnar Johannesen : https://github.com/ragnar123
7091
7092hooks.defineLocale('fo', {
7093    months : 'januar_februar_mars_aprÃl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
7094    monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
7095    weekdays : 'sunnudagur_mÃ¡nadagur_tÃ½sdagur_mikudagur_hÃ³sdagur_frÃggjadagur_leygardagur'.split('_'),
7096    weekdaysShort : 'sun_mÃ¡n_tÃ½s_mik_hÃ³s_frÃ_ley'.split('_'),
7097    weekdaysMin : 'su_mÃ¡_tÃ½_mi_hÃ³_fr_le'.split('_'),
7098    longDateFormat : {
7099        LT : 'HH:mm',
7100        LTS : 'HH:mm:ss',
7101        L : 'DD/MM/YYYY',
7102        LL : 'D MMMM YYYY',
7103        LLL : 'D MMMM YYYY HH:mm',
7104        LLLL : 'dddd D. MMMM, YYYY HH:mm'
7105    },
7106    calendar : {
7107        sameDay : '[Ã dag kl.] LT',
7108        nextDay : '[Ã morgin kl.] LT',
7109        nextWeek : 'dddd [kl.] LT',
7110        lastDay : '[Ã gjÃ¡r kl.] LT',
7111        lastWeek : '[sÃÃ°stu] dddd [kl] LT',
7112        sameElse : 'L'
7113    },
7114    relativeTime : {
7115        future : 'um %s',
7116        past : '%s sÃÃ°ani',
7117        s : 'fÃ¡ sekund',
7118        m : 'ein minutt',
7119        mm : '%d minuttir',
7120        h : 'ein tÃmi',
7121        hh : '%d tÃmar',
7122        d : 'ein dagur',
7123        dd : '%d dagar',
7124        M : 'ein mÃ¡naÃ°i',
7125        MM : '%d mÃ¡naÃ°ir',
7126        y : 'eitt Ã¡r',
7127        yy : '%d Ã¡r'
7128    },
7129    ordinalParse: /\d{1,2}\./,
7130    ordinal : '%d.',
7131    week : {
7132        dow : 1, // Monday is the first day of the week.
7133        doy : 4  // The week that contains Jan 4th is the first week of the year.
7134    }
7135});
7136
7137//! moment.js locale configuration

7138//! locale : French (Canada) [fr-ca]
7139//! author : Jonathan Abourbih : https://github.com/jonbca
7140
7141hooks.defineLocale('fr-ca', {
7142    months : 'janvier_fÃ©vrier_mars_avril_mai_juin_juillet_aoÃ»t_septembre_octobre_novembre_dÃ©cembre'.split('_'),
7143    monthsShort : 'janv._fÃ©vr._mars_avr._mai_juin_juil._aoÃ»t_sept._oct._nov._dÃ©c.'.split('_'),
7144    monthsParseExact : true,
7145    weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7146    weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7147    weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
7148    weekdaysParseExact : true,
7149    longDateFormat : {
7150        LT : 'HH:mm',
7151        LTS : 'HH:mm:ss',
7152        L : 'YYYY-MM-DD',
7153        LL : 'D MMMM YYYY',
7154        LLL : 'D MMMM YYYY HH:mm',
7155        LLLL : 'dddd D MMMM YYYY HH:mm'
7156    },
7157    calendar : {
7158        sameDay: '[Aujourd\'hui Ã ] LT',
7159        nextDay: '[Demain Ã ] LT',
7160        nextWeek: 'dddd [Ã ] LT',
7161        lastDay: '[Hier Ã ] LT',
7162        lastWeek: 'dddd [dernier Ã ] LT',
7163        sameElse: 'L'
7164    },
7165    relativeTime : {
7166        future : 'dans %s',
7167        past : 'il y a %s',
7168        s : 'quelques secondes',
7169        m : 'une minute',
7170        mm : '%d minutes',
7171        h : 'une heure',
7172        hh : '%d heures',
7173        d : 'un jour',
7174        dd : '%d jours',
7175        M : 'un mois',
7176        MM : '%d mois',
7177        y : 'un an',
7178        yy : '%d ans'
7179    },
7180    ordinalParse: /\d{1,2}(er|e)/,
7181    ordinal : function (number) {
7182        return number + (number === 1 ? 'er' : 'e');
7183    }
7184});
7185
7186//! moment.js locale configuration
7187//! locale : French (Switzerland) [fr-ch]
7188//! author : Gaspard Bucher : https://github.com/gaspard
7189
7190hooks.defineLocale('fr-ch', {
7191    months : 'janvier_fÃ©vrier_mars_avril_mai_juin_juillet_aoÃ»t_septembre_octobre_novembre_dÃ©cembre'.split('_'),
7192    monthsShort : 'janv._fÃ©vr._mars_avr._mai_juin_juil._aoÃ»t_sept._oct._nov._dÃ©c.'.split('_'),
7193    monthsParseExact : true,
7194    weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7195    weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7196    weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
7197    weekdaysParseExact : true,
7198    longDateFormat : {
7199        LT : 'HH:mm',
7200        LTS : 'HH:mm:ss',
7201        L : 'DD.MM.YYYY',
7202        LL : 'D MMMM YYYY',
7203        LLL : 'D MMMM YYYY HH:mm',
7204        LLLL : 'dddd D MMMM YYYY HH:mm'
7205    },
7206    calendar : {
7207        sameDay: '[Aujourd\'hui Ã ] LT',
7208        nextDay: '[Demain Ã ] LT',
7209        nextWeek: 'dddd [Ã ] LT',
7210        lastDay: '[Hier Ã ] LT',
7211        lastWeek: 'dddd [dernier Ã ] LT',
7212        sameElse: 'L'
7213    },
7214    relativeTime : {
7215        future : 'dans %s',
7216        past : 'il y a %s',
7217        s : 'quelques secondes',
7218        m : 'une minute',
7219        mm : '%d minutes',
7220        h : 'une heure',
7221        hh : '%d heures',
7222        d : 'un jour',
7223        dd : '%d jours',
7224        M : 'un mois',
7225        MM : '%d mois',
7226        y : 'un an',
7227        yy : '%d ans'
7228    },
7229    ordinalParse: /\d{1,2}(er|e)/,
7230    ordinal : function (number) {
7231        return number + (number === 1 ? 'er' : 'e');
7232    },
7233    week : {
7234        dow : 1, // Monday is the first day of the week.
7235        doy : 4  // The week that contains Jan 4th is the first week of the year.
7236    }
7237});
7238
7239//! moment.js locale configuration
7240//! locale : French [fr]
7241//! author : John Fischer : https://github.com/jfroffice
7242
7243hooks.defineLocale('fr', {
7244    months : 'janvier_fÃ©vrier_mars_avril_mai_juin_juillet_aoÃ»t_septembre_octobre_novembre_dÃ©cembre'.split('_'),
7245    monthsShort : 'janv._fÃ©vr._mars_avr._mai_juin_juil._aoÃ»t_sept._oct._nov._dÃ©c.'.split('_'),
7246    monthsParseExact : true,
7247    weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7248    weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7249    weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
7250    weekdaysParseExact : true,
7251    longDateFormat : {
7252        LT : 'HH:mm',
7253        LTS : 'HH:mm:ss',
7254        L : 'DD/MM/YYYY',
7255        LL : 'D MMMM YYYY',
7256        LLL : 'D MMMM YYYY HH:mm',
7257        LLLL : 'dddd D MMMM YYYY HH:mm'
7258    },
7259    calendar : {
7260        sameDay: '[Aujourd\'hui Ã ] LT',
7261        nextDay: '[Demain Ã ] LT',
7262        nextWeek: 'dddd [Ã ] LT',
7263        lastDay: '[Hier Ã ] LT',
7264        lastWeek: 'dddd [dernier Ã ] LT',
7265        sameElse: 'L'
7266    },
7267    relativeTime : {
7268        future : 'dans %s',
7269        past : 'il y a %s',
7270        s : 'quelques secondes',
7271        m : 'une minute',
7272        mm : '%d minutes',
7273        h : 'une heure',
7274        hh : '%d heures',
7275        d : 'un jour',
7276        dd : '%d jours',
7277        M : 'un mois',
7278        MM : '%d mois',
7279        y : 'un an',
7280        yy : '%d ans'
7281    },
7282    ordinalParse: /\d{1,2}(er|)/,
7283    ordinal : function (number) {
7284        return number + (number === 1 ? 'er' : '');
7285    },
7286    week : {
7287        dow : 1, // Monday is the first day of the week.
7288        doy : 4  // The week that contains Jan 4th is the first week of the year.
7289    }
7290});
7291
7292//! moment.js locale configuration
7293//! locale : Frisian [fy]
7294//! author : Robin van der Vliet : https://github.com/robin0van0der0v
7295
7296var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_');
7297var monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
7298
7299hooks.defineLocale('fy', {
7300    months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
7301    monthsShort : function (m, format) {
7302        if (/-MMM-/.test(format)) {
7303            return monthsShortWithoutDots[m.month()];
7304        } else {
7305            return monthsShortWithDots[m.month()];
7306        }
7307    },
7308    monthsParseExact : true,
7309    weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
7310    weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'),
7311    weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
7312    weekdaysParseExact : true,
7313    longDateFormat : {
7314        LT : 'HH:mm',
7315        LTS : 'HH:mm:ss',
7316        L : 'DD-MM-YYYY',
7317        LL : 'D MMMM YYYY',
7318        LLL : 'D MMMM YYYY HH:mm',
7319        LLLL : 'dddd D MMMM YYYY HH:mm'
7320    },
7321    calendar : {
7322        sameDay: '[hjoed om] LT',
7323        nextDay: '[moarn om] LT',
7324        nextWeek: 'dddd [om] LT',
7325        lastDay: '[juster om] LT',
7326        lastWeek: '[Ã´frÃ»ne] dddd [om] LT',
7327        sameElse: 'L'
7328    },
7329    relativeTime : {
7330        future : 'oer %s',
7331        past : '%s lyn',
7332        s : 'in pear sekonden',
7333        m : 'ien minÃºt',
7334        mm : '%d minuten',
7335        h : 'ien oere',
7336        hh : '%d oeren',
7337        d : 'ien dei',
7338        dd : '%d dagen',
7339        M : 'ien moanne',
7340        MM : '%d moannen',
7341        y : 'ien jier',
7342        yy : '%d jierren'
7343    },
7344    ordinalParse: /\d{1,2}(ste|de)/,
7345    ordinal : function (number) {
7346        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
7347    },
7348    week : {
7349        dow : 1, // Monday is the first day of the week.
7350        doy : 4  // The week that contains Jan 4th is the first week of the year.
7351    }
7352});
7353
7354//! moment.js locale configuration
7355//! locale : Scottish Gaelic [gd]

7356//! author : Jon Ashdown : https://github.com/jonashdown
7357
7358var months$5 = [
7359    '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'
7360];
7361
7362var monthsShort$3 = ['Faoi', 'Gear', 'MÃ rt', 'Gibl', 'CÃ¨it', 'Ãgmh', 'Iuch', 'LÃ¹n', 'Sult', 'DÃ mh', 'Samh', 'DÃ¹bh'];
7363
7364var weekdays$1 = ['DidÃ²mhnaich', 'Diluain', 'DimÃ irt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];
7365
7366var weekdaysShort = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];
7367
7368var weekdaysMin = ['DÃ²', 'Lu', 'MÃ ', 'Ci', 'Ar', 'Ha', 'Sa'];
7369
7370hooks.defineLocale('gd', {
7371    months : months$5,
7372    monthsShort : monthsShort$3,
7373    monthsParseExact : true,
7374    weekdays : weekdays$1,
7375    weekdaysShort : weekdaysShort,
7376    weekdaysMin : weekdaysMin,
7377    longDateFormat : {
7378        LT : 'HH:mm',
7379        LTS : 'HH:mm:ss',
7380        L : 'DD/MM/YYYY',
7381        LL : 'D MMMM YYYY',
7382        LLL : 'D MMMM YYYY HH:mm',
7383        LLLL : 'dddd, D MMMM YYYY HH:mm'
7384    },
7385    calendar : {
7386        sameDay : '[An-diugh aig] LT',
7387        nextDay : '[A-mÃ ireach aig] LT',
7388        nextWeek : 'dddd [aig] LT',
7389        lastDay : '[An-dÃ¨ aig] LT',
7390        lastWeek : 'dddd [seo chaidh] [aig] LT',
7391        sameElse : 'L'
7392    },
7393    relativeTime : {
7394        future : 'ann an %s',
7395        past : 'bho chionn %s',
7396        s : 'beagan diogan',
7397        m : 'mionaid',
7398        mm : '%d mionaidean',
7399        h : 'uair',
7400        hh : '%d uairean',
7401        d : 'latha',
7402        dd : '%d latha',
7403        M : 'mÃ¬os',
7404        MM : '%d mÃ¬osan',
7405        y : 'bliadhna',
7406        yy : '%d bliadhna'
7407    },
7408    ordinalParse : /\d{1,2}(d|na|mh)/,
7409    ordinal : function (number) {
7410        var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
7411        return number + output;
7412    },
7413    week : {
7414        dow : 1, // Monday is the first day of the week.
7415        doy : 4  // The week that contains Jan 4th is the first week of the year.
7416    }
7417});
7418
7419//! moment.js locale configuration
7420//! locale : Galician [gl]
7421//! author : Juan G. Hurtado : https://github.com/juanghurtado
7422
7423hooks.defineLocale('gl', {
7424    months : 'xaneiro_febreiro_marzo_abril_maio_xuÃ±o_xullo_agosto_setembro_outubro_novembro_decembro'.split('_'),
7425    monthsShort : 'xan._feb._mar._abr._mai._xuÃ±._xul._ago._set._out._nov._dec.'.split('_'),
7426    monthsParseExact: true,
7427    weekdays : 'domingo_luns_martes_mÃ©rcores_xoves_venres_sÃ¡bado'.split('_'),
7428    weekdaysShort : 'dom._lun._mar._mÃ©r._xov._ven._sÃ¡b.'.split('_'),
7429    weekdaysMin : 'do_lu_ma_mÃ©_xo_ve_sÃ¡'.split('_'),
7430    weekdaysParseExact : true,
7431    longDateFormat : {
7432        LT : 'H:mm',
7433        LTS : 'H:mm:ss',
7434        L : 'DD/MM/YYYY',
7435        LL : 'D [de] MMMM [de] YYYY',
7436        LLL : 'D [de] MMMM [de] YYYY H:mm',
7437        LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
7438    },
7439    calendar : {
7440        sameDay : function () {
7441            return '[hoxe ' + ((this.hours() !== 1) ? 'Ã¡s' : 'Ã¡') + '] LT';
7442        },
7443        nextDay : function () {
7444            return '[maÃ±Ã¡ ' + ((this.hours() !== 1) ? 'Ã¡s' : 'Ã¡') + '] LT';
7445        },
7446        nextWeek : function () {
7447            return 'dddd [' + ((this.hours() !== 1) ? 'Ã¡s' : 'a') + '] LT';
7448        },
7449        lastDay : function () {
7450            return '[onte ' + ((this.hours() !== 1) ? 'Ã¡' : 'a') + '] LT';
7451        },
7452        lastWeek : function () {
7453            return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'Ã¡s' : 'a') + '] LT';
7454        },
7455        sameElse : 'L'
7456    },
7457    relativeTime : {
7458        future : function (str) {
7459            if (str.indexOf('un') === 0) {
7460                return 'n' + str;
7461            }
7462            return 'en ' + str;
7463        },
7464        past : 'hai %s',
7465        s : 'uns segundos',
7466        m : 'un minuto',
7467        mm : '%d minutos',
7468        h : 'unha hora',
7469        hh : '%d horas',
7470        d : 'un dÃa',
7471        dd : '%d dÃas',
7472        M : 'un mes',
7473        MM : '%d meses',
7474        y : 'un ano',
7475        yy : '%d anos'
7476    },
7477    ordinalParse : /\d{1,2}Âº/,
7478    ordinal : '%dÂº',
7479    week : {
7480        dow : 1, // Monday is the first day of the week.
7481        doy : 4  // The week that contains Jan 4th is the first week of the year.
7482    }
7483});
7484
7485//! moment.js locale configuration
7486//! locale : Hebrew [he]
7487//! author : Tomer Cohen : https://github.com/tomer
7488//! author : Moshe Simantov : https://github.com/DevelopmentIL
7489//! author : Tal Ater : https://github.com/TalAter
7490
7491hooks.defineLocale('he', {
7492    months : '×× ×××¨_×¤××¨×××¨_××¨×¥_××¤×¨××_×××_××× ×_××××_×××××¡×_×¡×¤××××¨_×××§××××¨_× ×××××¨_××¦×××¨'.split('_'),
7493    monthsShort : '×× ××³_×¤××¨×³_××¨×¥_××¤×¨×³_×××_××× ×_××××_××××³_×¡×¤××³_×××§×³_× ×××³_××¦××³'.split('_'),
7494    weekdays : '×¨××©××_×©× ×_×©×××©×_×¨×××¢×_××××©×_×©××©×_×©××ª'.split('_'),
7495    weekdaysShort : '××³_××³_××³_××³_××³_××³_×©×³'.split('_'),
7496    weekdaysMin : '×_×_×_×_×_×_×©'.split('_'),
7497    longDateFormat : {
7498        LT : 'HH:mm',
7499        LTS : 'HH:mm:ss',
7500        L : 'DD/MM/YYYY',
7501        LL : 'D [×]MMMM YYYY',
7502        LLL : 'D [×]MMMM YYYY HH:mm',
7503        LLLL : 'dddd, D [×]MMMM YYYY HH:mm',
7504        l : 'D/M/YYYY',
7505        ll : 'D MMM YYYY',
7506        lll : 'D MMM YYYY HH:mm',
7507        llll : 'ddd, D MMM YYYY HH:mm'
7508    },
7509    calendar : {
7510        sameDay : '[×××× ×Ö¾]LT',
7511        nextDay : '[×××¨ ×Ö¾]LT',
7512        nextWeek : 'dddd [××©×¢×] LT',
7513        lastDay : '[××ª××× ×Ö¾]LT',
7514        lastWeek : '[××××] dddd [××××¨×× ××©×¢×] LT',
7515        sameElse : 'L'
7516    },
7517    relativeTime : {
7518        future : '××¢×× %s',
7519        past : '××¤× × %s',
7520        s : '××¡×¤×¨ ×©× ×××ª',
7521        m : '××§×',
7522        mm : '%d ××§××ª',
7523        h : '×©×¢×',
7524        hh : function (number) {
7525            if (number === 2) {
7526                return '×©×¢×ª×××';
7527            }
7528            return number + ' ×©×¢××ª';
7529        },
7530        d : '×××',
7531        dd : function (number) {
7532            if (number === 2) {
7533                return '××××××';
7534            }
7535            return number + ' ××××';
7536        },
7537        M : '××××©',
7538        MM : function (number) {
7539            if (number === 2) {
7540                return '××××©×××';
7541            }
7542            return number + ' ××××©××';
7543        },
7544        y : '×©× ×',
7545        yy : function (number) {
7546            if (number === 2) {
7547                return '×©× ×ª×××';
7548            } else if (number % 10 === 0 && number !== 10) {
7549                return number + ' ×©× ×';
7550            }
7551            return number + ' ×©× ××';
7552        }
7553    },
7554    meridiemParse: /×××"×¦|××¤× ×"×¦|×××¨× ××¦××¨×××|××¤× × ××¦××¨×××|××¤× ××ª ×××§×¨|××××§×¨|××¢×¨×/i,
7555    isPM : function (input) {
7556        return /^(×××"×¦|×××¨× ××¦××¨×××|××¢×¨×)$/.test(input);
7557    },
7558    meridiem : function (hour, minute, isLower) {
7559        if (hour < 5) {
7560            return '××¤× ××ª ×××§×¨';
7561        } else if (hour < 10) {
7562            return '××××§×¨';
7563        } else if (hour < 12) {
7564            return isLower ? '××¤× ×"×¦' : '××¤× × ××¦××¨×××';
7565        } else if (hour < 18) {
7566            return isLower ? '×××"×¦' : '×××¨× ××¦××¨×××';
7567        } else {
7568            return '××¢×¨×';
7569        }
7570    }
7571});
7572
7573//! moment.js locale configuration

7574//! locale : Hindi [hi]
7575//! author : Mayank Singhal : https://github.com/mayanksinghal
7576
7577var symbolMap$6 = {
7578    '1': 'à¥§',
7579    '2': 'à¥¨',
7580    '3': 'à¥©',
7581    '4': 'à¥ª',
7582    '5': 'à¥«',
7583    '6': 'à¥¬',
7584    '7': 'à¥',
7585    '8': 'à¥®',
7586    '9': 'à¥¯',
7587    '0': 'à¥¦'
7588};
7589var numberMap$5 = {
7590    'à¥§': '1',
7591    'à¥¨': '2',
7592    'à¥©': '3',
7593    'à¥ª': '4',
7594    'à¥«': '5',
7595    'à¥¬': '6',
7596    'à¥': '7',
7597    'à¥®': '8',
7598    'à¥¯': '9',
7599    'à¥¦': '0'
7600};
7601
7602hooks.defineLocale('hi', {
7603    months : 'à¤à¤¨à¤µà¤°à¥_à¤«à¤¼à¤°à¤µà¤°à¥_à¤®à¤¾à¤°à¥à¤_à¤à¤ªà¥à¤°à¥à¤²_à¤®à¤_à¤à¥à¤¨_à¤à¥à¤²à¤¾à¤_à¤à¤à¤¸à¥à¤¤_à¤¸à¤¿à¤¤à¤®à¥à¤¬à¤°_à¤à¤à¥à¤à¥à¤¬à¤°_à¤¨à¤µà¤®à¥à¤¬à¤°_à¤¦à¤¿à¤¸à¤®à¥à¤¬à¤°'.split('_'),
7604    monthsShort : 'à¤à¤¨._à¤«à¤¼à¤°._à¤®à¤¾à¤°à¥à¤_à¤à¤ªà¥à¤°à¥._à¤®à¤_à¤à¥à¤¨_à¤à¥à¤²._à¤à¤._à¤¸à¤¿à¤¤._à¤à¤à¥à¤à¥._à¤¨à¤µ._à¤¦à¤¿à¤¸.'.split('_'),
7605    monthsParseExact: true,
7606    weekdays : 'à¤°à¤µà¤¿à¤µà¤¾à¤°_à¤¸à¥à¤®à¤µà¤¾à¤°_à¤®à¤à¤à¤²à¤µà¤¾à¤°_à¤¬à¥à¤§à¤µà¤¾à¤°_à¤à¥à¤°à¥à¤µà¤¾à¤°_à¤¶à¥à¤à¥à¤°à¤µà¤¾à¤°_à¤¶à¤¨à¤¿à¤µà¤¾à¤°'.split('_'),
7607    weekdaysShort : 'à¤°à¤µà¤¿_à¤¸à¥à¤®_à¤®à¤à¤à¤²_à¤¬à¥à¤§_à¤à¥à¤°à¥_à¤¶à¥à¤à¥à¤°_à¤¶à¤¨à¤¿'.split('_'),
7608    weekdaysMin : 'à¤°_à¤¸à¥_à¤®à¤_à¤¬à¥_à¤à¥_à¤¶à¥_à¤¶'.split('_'),
7609    longDateFormat : {
7610        LT : 'A h:mm à¤¬à¤à¥',
7611        LTS : 'A h:mm:ss à¤¬à¤à¥',
7612        L : 'DD/MM/YYYY',
7613        LL : 'D MMMM YYYY',
7614        LLL : 'D MMMM YYYY, A h:mm à¤¬à¤à¥',
7615        LLLL : 'dddd, D MMMM YYYY, A h:mm à¤¬à¤à¥'
7616    },
7617    calendar : {
7618        sameDay : '[à¤à¤] LT',
7619        nextDay : '[à¤à¤²] LT',
7620        nextWeek : 'dddd, LT',
7621        lastDay : '[à¤à¤²] LT',
7622        lastWeek : '[à¤ªà¤¿à¤à¤²à¥] dddd, LT',
7623        sameElse : 'L'
7624    },
7625    relativeTime : {
7626        future : '%s à¤®à¥à¤',
7627        past : '%s à¤ªà¤¹à¤²à¥',
7628        s : 'à¤à¥à¤ à¤¹à¥ à¤à¥à¤·à¤£',
7629        m : 'à¤à¤ à¤®à¤¿à¤¨à¤',
7630        mm : '%d à¤®à¤¿à¤¨à¤',
7631        h : 'à¤à¤ à¤à¤à¤à¤¾',
7632        hh : '%d à¤à¤à¤à¥',
7633        d : 'à¤à¤ à¤¦à¤¿à¤¨',
7634        dd : '%d à¤¦à¤¿à¤¨',
7635        M : 'à¤à¤ à¤®à¤¹à¥à¤¨à¥',
7636        MM : '%d à¤®à¤¹à¥à¤¨à¥',
7637        y : 'à¤à¤ à¤µà¤°à¥à¤·',
7638        yy : '%d à¤µà¤°à¥à¤·'
7639    },
7640    preparse: function (string) {
7641        return string.replace(/[à¥§à¥¨à¥©à¥ªà¥«à¥¬à¥à¥®à¥¯à¥¦]/g, function (match) {
7642            return numberMap$5[match];
7643        });
7644    },
7645    postformat: function (string) {
7646        return string.replace(/\d/g, function (match) {
7647            return symbolMap$6[match];
7648        });
7649    },
7650    // Hindi notation for meridiems are quite fuzzy in practice. While there exists
7651    // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
7652    meridiemParse: /à¤°à¤¾à¤¤|à¤¸à¥à¤¬à¤¹|à¤¦à¥à¤ªà¤¹à¤°|à¤¶à¤¾à¤®/,
7653    meridiemHour : function (hour, meridiem) {
7654        if (hour === 12) {
7655            hour = 0;
7656        }
7657        if (meridiem === 'à¤°à¤¾à¤¤') {
7658            return hour < 4 ? hour : hour + 12;
7659        } else if (meridiem === 'à¤¸à¥à¤¬à¤¹') {
7660            return hour;
7661        } else if (meridiem === 'à¤¦à¥à¤ªà¤¹à¤°') {
7662            return hour >= 10 ? hour : hour + 12;
7663        } else if (meridiem === 'à¤¶à¤¾à¤®') {
7664            return hour + 12;
7665        }
7666    },
7667    meridiem : function (hour, minute, isLower) {
7668        if (hour < 4) {
7669            return 'à¤°à¤¾à¤¤';
7670        } else if (hour < 10) {
7671            return 'à¤¸à¥à¤¬à¤¹';
7672        } else if (hour < 17) {
7673            return 'à¤¦à¥à¤ªà¤¹à¤°';
7674        } else if (hour < 20) {
7675            return 'à¤¶à¤¾à¤®';
7676        } else {
7677            return 'à¤°à¤¾à¤¤';
7678        }
7679    },
7680    week : {
7681        dow : 0, // Sunday is the first day of the week.
7682        doy : 6  // The week that contains Jan 1st is the first week of the year.
7683    }
7684});
7685
7686//! moment.js locale configuration
7687//! locale : Croatian [hr]
7688//! author : Bojan MarkoviÄ : https://github.com/bmarkovic
7689
7690function translate$3(number, withoutSuffix, key) {
7691    var result = number + ' ';
7692    switch (key) {
7693        case 'm':
7694            return withoutSuffix ? 'jedna minuta' : 'jedne minute';
7695        case 'mm':
7696            if (number === 1) {
7697                result += 'minuta';
7698            } else if (number === 2 || number === 3 || number === 4) {
7699                result += 'minute';
7700            } else {
7701                result += 'minuta';
7702            }
7703            return result;
7704        case 'h':
7705            return withoutSuffix ? 'jedan sat' : 'jednog sata';
7706        case 'hh':
7707            if (number === 1) {
7708                result += 'sat';
7709            } else if (number === 2 || number === 3 || number === 4) {
7710                result += 'sata';
7711            } else {
7712                result += 'sati';
7713            }
7714            return result;
7715        case 'dd':
7716            if (number === 1) {
7717                result += 'dan';
7718            } else {
7719                result += 'dana';
7720            }
7721            return result;
7722        case 'MM':
7723            if (number === 1) {
7724                result += 'mjesec';
7725            } else if (number === 2 || number === 3 || number === 4) {
7726                result += 'mjeseca';
7727            } else {
7728                result += 'mjeseci';
7729            }
7730            return result;
7731        case 'yy':
7732            if (number === 1) {
7733                result += 'godina';
7734            } else if (number === 2 || number === 3 || number === 4) {
7735                result += 'godine';
7736            } else {
7737                result += 'godina';
7738            }
7739            return result;
7740    }
7741}
7742
7743hooks.defineLocale('hr', {
7744    months : {
7745        format: 'sijeÄnja_veljaÄe_oÅ¾ujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
7746        standalone: 'sijeÄanj_veljaÄa_oÅ¾ujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
7747    },
7748    monthsShort : 'sij._velj._oÅ¾u._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
7749    monthsParseExact: true,
7750    weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'),
7751    weekdaysShort : 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'),
7752    weekdaysMin : 'ne_po_ut_sr_Äe_pe_su'.split('_'),
7753    weekdaysParseExact : true,
7754    longDateFormat : {
7755        LT : 'H:mm',
7756        LTS : 'H:mm:ss',
7757        L : 'DD.MM.YYYY',
7758        LL : 'D. MMMM YYYY',
7759        LLL : 'D. MMMM YYYY H:mm',
7760        LLLL : 'dddd, D. MMMM YYYY H:mm'
7761    },
7762    calendar : {
7763        sameDay  : '[danas u] LT',
7764        nextDay  : '[sutra u] LT',
7765        nextWeek : function () {
7766            switch (this.day()) {
7767                case 0:
7768                    return '[u] [nedjelju] [u] LT';
7769                case 3:
7770                    return '[u] [srijedu] [u] LT';
7771                case 6:
7772                    return '[u] [subotu] [u] LT';
7773                case 1:
7774                case 2:
7775                case 4:
7776                case 5:
7777                    return '[u] dddd [u] LT';
7778            }
7779        },
7780        lastDay  : '[juÄer u] LT',
7781        lastWeek : function () {
7782            switch (this.day()) {
7783                case 0:
7784                case 3:
7785                    return '[proÅ¡lu] dddd [u] LT';
7786                case 6:
7787                    return '[proÅ¡le] [subote] [u] LT';
7788                case 1:
7789                case 2:
7790                case 4:
7791                case 5:
7792                    return '[proÅ¡li] dddd [u] LT';
7793            }
7794        },
7795        sameElse : 'L'
7796    },
7797    relativeTime : {
7798        future : 'za %s',
7799        past   : 'prije %s',
7800        s      : 'par sekundi',
7801        m      : translate$3,
7802        mm     : translate$3,
7803        h      : translate$3,
7804        hh     : translate$3,
7805        d      : 'dan',
7806        dd     : translate$3,
7807        M      : 'mjesec',
7808        MM     : translate$3,
7809        y      : 'godinu',
7810        yy     : translate$3
7811    },
7812    ordinalParse: /\d{1,2}\./,
7813    ordinal : '%d.',
7814    week : {
7815        dow : 1, // Monday is the first day of the week.
7816        doy : 7  // The week that contains Jan 1st is the first week of the year.
7817    }
7818});
7819
7820//! moment.js locale configuration
7821//! locale : Hungarian [hu]
7822//! author : Adam Brunner : https://github.com/adambrunner
7823
7824var weekEndings = 'vasÃ¡rnap hÃ©tfÅn kedden szerdÃ¡n csÃ¼tÃ¶rtÃ¶kÃ¶n pÃ©nteken szombaton'.split(' ');
7825function translate$4(number, withoutSuffix, key, isFuture) {
7826    var num = number,
7827        suffix;
7828    switch (key) {
7829        case 's':
7830            return (isFuture || withoutSuffix) ? 'nÃ©hÃ¡ny mÃ¡sodperc' : 'nÃ©hÃ¡ny mÃ¡sodperce';
7831        case 'm':
7832            return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
7833        case 'mm':
7834            return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
7835        case 'h':
7836            return 'egy' + (isFuture || withoutSuffix ? ' Ã³ra' : ' Ã³rÃ¡ja');
7837        case 'hh':
7838            return num + (isFuture || withoutSuffix ? ' Ã³ra' : ' Ã³rÃ¡ja');
7839        case 'd':
7840            return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
7841        case 'dd':
7842            return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
7843        case 'M':
7844            return 'egy' + (isFuture || withoutSuffix ? ' hÃ³nap' : ' hÃ³napja');
7845        case 'MM':
7846            return num + (isFuture || withoutSuffix ? ' hÃ³nap' : ' hÃ³napja');
7847        case 'y':
7848            return 'egy' + (isFuture || withoutSuffix ? ' Ã©v' : ' Ã©ve');
7849        case 'yy':
7850            return num + (isFuture || withoutSuffix ? ' Ã©v' : ' Ã©ve');
7851    }
7852    return '';
7853}
7854function week(isFuture) {
7855    return (isFuture ? '' : '[mÃºlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';
7856}
7857
7858hooks.defineLocale('hu', {
7859    months : 'januÃ¡r_februÃ¡r_mÃ¡rcius_Ã¡prilis_mÃ¡jus_jÃºnius_jÃºlius_augusztus_szeptember_oktÃ³ber_november_december'.split('_'),
7860    monthsShort : 'jan_feb_mÃ¡rc_Ã¡pr_mÃ¡j_jÃºn_jÃºl_aug_szept_okt_nov_dec'.split('_'),
7861    weekdays : 'vasÃ¡rnap_hÃ©tfÅ_kedd_szerda_csÃ¼tÃ¶rtÃ¶k_pÃ©ntek_szombat'.split('_'),
7862    weekdaysShort : 'vas_hÃ©t_kedd_sze_csÃ¼t_pÃ©n_szo'.split('_'),
7863    weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
7864    longDateFormat : {
7865        LT : 'H:mm',
7866        LTS : 'H:mm:ss',
7867        L : 'YYYY.MM.DD.',
7868        LL : 'YYYY. MMMM D.',
7869        LLL : 'YYYY. MMMM D. H:mm',
7870        LLLL : 'YYYY. MMMM D., dddd H:mm'
7871    },
7872    meridiemParse: /de|du/i,
7873    isPM: function (input) {
7874        return input.charAt(1).toLowerCase() === 'u';
7875    },
7876    meridiem : function (hours, minutes, isLower) {
7877        if (hours < 12) {
7878            return isLower === true ? 'de' : 'DE';
7879        } else {
7880            return isLower === true ? 'du' : 'DU';
7881        }
7882    },
7883    calendar : {
7884        sameDay : '[ma] LT[-kor]',
7885        nextDay : '[holnap] LT[-kor]',
7886        nextWeek : function () {
7887            return week.call(this, true);
7888        },
7889        lastDay : '[tegnap] LT[-kor]',
7890        lastWeek : function () {
7891            return week.call(this, false);
7892        },
7893        sameElse : 'L'
7894    },
7895    relativeTime : {
7896        future : '%s mÃºlva',
7897        past : '%s',
7898        s : translate$4,
7899        m : translate$4,
7900        mm : translate$4,
7901        h : translate$4,
7902        hh : translate$4,
7903        d : translate$4,
7904        dd : translate$4,
7905        M : translate$4,
7906        MM : translate$4,
7907        y : translate$4,
7908        yy : translate$4
7909    },
7910    ordinalParse: /\d{1,2}\./,
7911    ordinal : '%d.',
7912    week : {
7913        dow : 1, // Monday is the first day of the week.
7914        doy : 4  // The week that contains Jan 4th is the first week of the year.
7915    }
7916});
7917
7918//! moment.js locale configuration
7919//! locale : Armenian [hy-am]
7920//! author : Armendarabyan : https://github.com/armendarabyan
7921
7922hooks.defineLocale('hy-am', {
7923    months : {
7924        format: 'Õ°Õ¸ÖÕ¶Õ¾Õ¡ÖÕ«_ÖÕ¥Õ¿ÖÕ¾Õ¡ÖÕ«_Õ´Õ¡ÖÕ¿Õ«_Õ¡ÕºÖÕ«Õ¬Õ«_Õ´Õ¡ÕµÕ«Õ½Õ«_Õ°Õ¸ÖÕ¶Õ«Õ½Õ«_Õ°Õ¸ÖÕ¬Õ«Õ½Õ«_ÖÕ£Õ¸Õ½Õ¿Õ¸Õ½Õ«_Õ½Õ¥ÕºÕ¿Õ¥Õ´Õ¢Õ¥ÖÕ«_Õ°Õ¸Õ¯Õ¿Õ¥Õ´Õ¢Õ¥ÖÕ«_Õ¶Õ¸ÕµÕ¥Õ´Õ¢Õ¥ÖÕ«_Õ¤Õ¥Õ¯Õ¿Õ¥Õ´Õ¢Õ¥ÖÕ«'.split('_'),
7925        standalone: 'Õ°Õ¸ÖÕ¶Õ¾Õ¡Ö_ÖÕ¥Õ¿ÖÕ¾Õ¡Ö_Õ´Õ¡ÖÕ¿_Õ¡ÕºÖÕ«Õ¬_Õ´Õ¡ÕµÕ«Õ½_Õ°Õ¸ÖÕ¶Õ«Õ½_Õ°Õ¸ÖÕ¬Õ«Õ½_ÖÕ£Õ¸Õ½Õ¿Õ¸Õ½_Õ½Õ¥ÕºÕ¿Õ¥Õ´Õ¢Õ¥Ö_Õ°Õ¸Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö_Õ¶Õ¸ÕµÕ¥Õ´Õ¢Õ¥Ö_Õ¤Õ¥Õ¯Õ¿Õ¥Õ´Õ¢Õ¥Ö'.split('_')
7926    },
7927    monthsShort : 'Õ°Õ¶Õ¾_ÖÕ¿Ö_Õ´ÖÕ¿_Õ¡ÕºÖ_Õ´ÕµÕ½_Õ°Õ¶Õ½_Õ°Õ¬Õ½_ÖÕ£Õ½_Õ½ÕºÕ¿_Õ°Õ¯Õ¿_Õ¶Õ´Õ¢_Õ¤Õ¯Õ¿'.split('_'),
7928    weekdays : 'Õ¯Õ«ÖÕ¡Õ¯Õ«_Õ¥ÖÕ¯Õ¸ÖÕ·Õ¡Õ¢Õ©Õ«_Õ¥ÖÕ¥ÖÕ·Õ¡Õ¢Õ©Õ«_Õ¹Õ¸ÖÕ¥ÖÕ·Õ¡Õ¢Õ©Õ«_Õ°Õ«Õ¶Õ£Õ·Õ¡Õ¢Õ©Õ«_Õ¸ÖÖÕ¢Õ¡Õ©_Õ·Õ¡Õ¢Õ¡Õ©'.split('_'),
7929    weekdaysShort : 'Õ¯ÖÕ¯_Õ¥ÖÕ¯_Õ¥ÖÖ_Õ¹ÖÖ_Õ°Õ¶Õ£_Õ¸ÖÖÕ¢_Õ·Õ¢Õ©'.split('_'),
7930    weekdaysMin : 'Õ¯ÖÕ¯_Õ¥ÖÕ¯_Õ¥ÖÖ_Õ¹ÖÖ_Õ°Õ¶Õ£_Õ¸ÖÖÕ¢_Õ·Õ¢Õ©'.split('_'),
7931    longDateFormat : {
7932        LT : 'HH:mm',
7933        LTS : 'HH:mm:ss',
7934        L : 'DD.MM.YYYY',
7935        LL : 'D MMMM YYYY Õ©.',
7936        LLL : 'D MMMM YYYY Õ©., HH:mm',
7937        LLLL : 'dddd, D MMMM YYYY Õ©., HH:mm'
7938    },
7939    calendar : {
7940        sameDay: '[Õ¡ÕµÕ½ÖÖ] LT',
7941        nextDay: '[Õ¾Õ¡Õ²Õ¨] LT',
7942        lastDay: '[Õ¥ÖÕ¥Õ¯] LT',
7943        nextWeek: function () {
7944            return 'dddd [ÖÖÕ¨ ÕªÕ¡Õ´Õ¨] LT';
7945        },
7946        lastWeek: function () {
7947            return '[Õ¡Õ¶ÖÕ¡Õ®] dddd [ÖÖÕ¨ ÕªÕ¡Õ´Õ¨] LT';
7948        },
7949        sameElse: 'L'
7950    },
7951    relativeTime : {
7952        future : '%s Õ°Õ¥Õ¿Õ¸',
7953        past : '%s Õ¡Õ¼Õ¡Õ»',
7954        s : 'Õ´Õ« ÖÕ¡Õ¶Õ« Õ¾Õ¡ÕµÖÕ¯ÕµÕ¡Õ¶',
7955        m : 'ÖÕ¸ÕºÕ¥',
7956        mm : '%d ÖÕ¸ÕºÕ¥',
7957        h : 'ÕªÕ¡Õ´',
7958        hh : '%d ÕªÕ¡Õ´',
7959        d : 'ÖÖ',
7960        dd : '%d ÖÖ',
7961        M : 'Õ¡Õ´Õ«Õ½',
7962        MM : '%d Õ¡Õ´Õ«Õ½',
7963        y : 'Õ¿Õ¡ÖÕ«',
7964        yy : '%d Õ¿Õ¡ÖÕ«'
7965    },
7966    meridiemParse: /Õ£Õ«Õ·Õ¥ÖÕ¾Õ¡|Õ¡Õ¼Õ¡Õ¾Õ¸Õ¿Õ¾Õ¡|ÖÕ¥ÖÕ¥Õ¯Õ¾Õ¡|Õ¥ÖÕ¥Õ¯Õ¸ÕµÕ¡Õ¶/,
7967    isPM: function (input) {
7968        return /^(ÖÕ¥ÖÕ¥Õ¯Õ¾Õ¡|Õ¥ÖÕ¥Õ¯Õ¸ÕµÕ¡Õ¶)$/.test(input);
7969    },
7970    meridiem : function (hour) {
7971        if (hour < 4) {
7972            return 'Õ£Õ«Õ·Õ¥ÖÕ¾Õ¡';
7973        } else if (hour < 12) {
7974            return 'Õ¡Õ¼Õ¡Õ¾Õ¸Õ¿Õ¾Õ¡';
7975        } else if (hour < 17) {
7976            return 'ÖÕ¥ÖÕ¥Õ¯Õ¾Õ¡';
7977        } else {
7978            return 'Õ¥ÖÕ¥Õ¯Õ¸ÕµÕ¡Õ¶';
7979        }
7980    },
7981    ordinalParse: /\d{1,2}|\d{1,2}-(Õ«Õ¶|ÖÕ¤)/,
7982    ordinal: function (number, period) {
7983        switch (period) {
7984            case 'DDD':
7985            case 'w':
7986            case 'W':
7987            case 'DDDo':
7988                if (number === 1) {
7989                    return number + '-Õ«Õ¶';
7990                }
7991                return number + '-ÖÕ¤';
7992            default:
7993                return number;
7994        }
7995    },
7996    week : {
7997        dow : 1, // Monday is the first day of the week.
7998        doy : 7  // The week that contains Jan 1st is the first week of the year.
7999    }
8000});
8001
8002//! moment.js locale configuration
8003//! locale : Indonesian [id]
8004//! author : Mohammad Satrio Utomo : https://github.com/tyok
8005//! reference: http://id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan
8006
8007hooks.defineLocale('id', {
8008    months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
8009    monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des'.split('_'),
8010    weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
8011    weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
8012    weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
8013    longDateFormat : {
8014        LT : 'HH.mm',
8015        LTS : 'HH.mm.ss',
8016        L : 'DD/MM/YYYY',
8017        LL : 'D MMMM YYYY',
8018        LLL : 'D MMMM YYYY [pukul] HH.mm',
8019        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
8020    },
8021    meridiemParse: /pagi|siang|sore|malam/,
8022    meridiemHour : function (hour, meridiem) {
8023        if (hour === 12) {
8024            hour = 0;
8025        }
8026        if (meridiem === 'pagi') {
8027            return hour;
8028        } else if (meridiem === 'siang') {
8029            return hour >= 11 ? hour : hour + 12;
8030        } else if (meridiem === 'sore' || meridiem === 'malam') {
8031            return hour + 12;
8032        }
8033    },
8034    meridiem : function (hours, minutes, isLower) {
8035        if (hours < 11) {
8036            return 'pagi';
8037        } else if (hours < 15) {
8038            return 'siang';

vendor: 4,908 bytes, lines 8039-8191

8039        } else if (hours < 19) {
8040            return 'sore';
8041        } else {
8042            return 'malam';
8043        }
8044    },
8045    calendar : {
8046        sameDay : '[Hari ini pukul] LT',
8047        nextDay : '[Besok pukul] LT',
8048        nextWeek : 'dddd [pukul] LT',
8049        lastDay : '[Kemarin pukul] LT',
8050        lastWeek : 'dddd [lalu pukul] LT',
8051        sameElse : 'L'
8052    },
8053    relativeTime : {
8054        future : 'dalam %s',
8055        past : '%s yang lalu',
8056        s : 'beberapa detik',
8057        m : 'semenit',
8058        mm : '%d menit',
8059        h : 'sejam',
8060        hh : '%d jam',
8061        d : 'sehari',
8062        dd : '%d hari',
8063        M : 'sebulan',
8064        MM : '%d bulan',
8065        y : 'setahun',
8066        yy : '%d tahun'
8067    },
8068    week : {
8069        dow : 1, // Monday is the first day of the week.
8070        doy : 7  // The week that contains Jan 1st is the first week of the year.
8071    }
8072});
8073
8074//! moment.js locale configuration
8075//! locale : Icelandic [is]
8076//! author : Hinrik Ãrn SigurÃ°sson : https://github.com/hinrik
8077
8078function plural$2(n) {
8079    if (n % 100 === 11) {
8080        return true;
8081    } else if (n % 10 === 1) {
8082        return false;
8083    }
8084    return true;
8085}
8086function translate$5(number, withoutSuffix, key, isFuture) {
8087    var result = number + ' ';
8088    switch (key) {
8089        case 's':
8090            return withoutSuffix || isFuture ? 'nokkrar sekÃºndur' : 'nokkrum sekÃºndum';
8091        case 'm':
8092            return withoutSuffix ? 'mÃnÃºta' : 'mÃnÃºtu';
8093        case 'mm':
8094            if (plural$2(number)) {
8095                return result + (withoutSuffix || isFuture ? 'mÃnÃºtur' : 'mÃnÃºtum');
8096            } else if (withoutSuffix) {
8097                return result + 'mÃnÃºta';
8098            }
8099            return result + 'mÃnÃºtu';
8100        case 'hh':
8101            if (plural$2(number)) {
8102                return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
8103            }
8104            return result + 'klukkustund';
8105        case 'd':
8106            if (withoutSuffix) {
8107                return 'dagur';
8108            }
8109            return isFuture ? 'dag' : 'degi';
8110        case 'dd':
8111            if (plural$2(number)) {
8112                if (withoutSuffix) {
8113                    return result + 'dagar';
8114                }
8115                return result + (isFuture ? 'daga' : 'dÃ¶gum');
8116            } else if (withoutSuffix) {
8117                return result + 'dagur';
8118            }
8119            return result + (isFuture ? 'dag' : 'degi');
8120        case 'M':
8121            if (withoutSuffix) {
8122                return 'mÃ¡nuÃ°ur';
8123            }
8124            return isFuture ? 'mÃ¡nuÃ°' : 'mÃ¡nuÃ°i';
8125        case 'MM':
8126            if (plural$2(number)) {
8127                if (withoutSuffix) {
8128                    return result + 'mÃ¡nuÃ°ir';
8129                }
8130                return result + (isFuture ? 'mÃ¡nuÃ°i' : 'mÃ¡nuÃ°um');
8131            } else if (withoutSuffix) {
8132                return result + 'mÃ¡nuÃ°ur';
8133            }
8134            return result + (isFuture ? 'mÃ¡nuÃ°' : 'mÃ¡nuÃ°i');
8135        case 'y':
8136            return withoutSuffix || isFuture ? 'Ã¡r' : 'Ã¡ri';
8137        case 'yy':
8138            if (plural$2(number)) {
8139                return result + (withoutSuffix || isFuture ? 'Ã¡r' : 'Ã¡rum');
8140            }
8141            return result + (withoutSuffix || isFuture ? 'Ã¡r' : 'Ã¡ri');
8142    }
8143}
8144
8145hooks.defineLocale('is', {
8146    months : 'janÃºar_febrÃºar_mars_aprÃl_maÃ_jÃºnÃ_jÃºlÃ_Ã¡gÃºst_september_oktÃ³ber_nÃ³vember_desember'.split('_'),
8147    monthsShort : 'jan_feb_mar_apr_maÃ_jÃºn_jÃºl_Ã¡gÃº_sep_okt_nÃ³v_des'.split('_'),
8148    weekdays : 'sunnudagur_mÃ¡nudagur_Ã¾riÃ°judagur_miÃ°vikudagur_fimmtudagur_fÃ¶studagur_laugardagur'.split('_'),
8149    weekdaysShort : 'sun_mÃ¡n_Ã¾ri_miÃ°_fim_fÃ¶s_lau'.split('_'),
8150    weekdaysMin : 'Su_MÃ¡_Ãr_Mi_Fi_FÃ¶_La'.split('_'),
8151    longDateFormat : {
8152        LT : 'H:mm',
8153        LTS : 'H:mm:ss',
8154        L : 'DD.MM.YYYY',
8155        LL : 'D. MMMM YYYY',
8156        LLL : 'D. MMMM YYYY [kl.] H:mm',
8157        LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm'
8158    },
8159    calendar : {
8160        sameDay : '[Ã dag kl.] LT',
8161        nextDay : '[Ã¡ morgun kl.] LT',
8162        nextWeek : 'dddd [kl.] LT',
8163        lastDay : '[Ã gÃ¦r kl.] LT',
8164        lastWeek : '[sÃÃ°asta] dddd [kl.] LT',
8165        sameElse : 'L'
8166    },
8167    relativeTime : {
8168        future : 'eftir %s',
8169        past : 'fyrir %s sÃÃ°an',
8170        s : translate$5,
8171        m : translate$5,
8172        mm : translate$5,
8173        h : 'klukkustund',
8174        hh : translate$5,
8175        d : translate$5,
8176        dd : translate$5,
8177        M : translate$5,
8178        MM : translate$5,
8179        y : translate$5,
8180        yy : translate$5
8181    },
8182    ordinalParse: /\d{1,2}\./,
8183    ordinal : '%d.',
8184    week : {
8185        dow : 1, // Monday is the first day of the week.
8186        doy : 4  // The week that contains Jan 4th is the first week of the year.
8187    }
8188});
8189
8190//! moment.js locale configuration
8191//! locale : Italian [it]

8192//! author : Lorenzo : https://github.com/aliem
8193//! author: Mattia Larentis: https://github.com/nostalgiaz
8194
8195hooks.defineLocale('it', {
8196    months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
8197    monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
8198    weekdays : 'Domenica_LunedÃ¬_MartedÃ¬_MercoledÃ¬_GiovedÃ¬_VenerdÃ¬_Sabato'.split('_'),
8199    weekdaysShort : 'Dom_Lun_Mar_Mer_Gio_Ven_Sab'.split('_'),
8200    weekdaysMin : 'Do_Lu_Ma_Me_Gi_Ve_Sa'.split('_'),
8201    longDateFormat : {
8202        LT : 'HH:mm',
8203        LTS : 'HH:mm:ss',
8204        L : 'DD/MM/YYYY',
8205        LL : 'D MMMM YYYY',
8206        LLL : 'D MMMM YYYY HH:mm',
8207        LLLL : 'dddd, D MMMM YYYY HH:mm'
8208    },
8209    calendar : {
8210        sameDay: '[Oggi alle] LT',
8211        nextDay: '[Domani alle] LT',
8212        nextWeek: 'dddd [alle] LT',
8213        lastDay: '[Ieri alle] LT',
8214        lastWeek: function () {
8215            switch (this.day()) {
8216                case 0:
8217                    return '[la scorsa] dddd [alle] LT';
8218                default:
8219                    return '[lo scorso] dddd [alle] LT';
8220            }
8221        },
8222        sameElse: 'L'
8223    },
8224    relativeTime : {
8225        future : function (s) {
8226            return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
8227        },
8228        past : '%s fa',
8229        s : 'alcuni secondi',
8230        m : 'un minuto',
8231        mm : '%d minuti',
8232        h : 'un\'ora',
8233        hh : '%d ore',
8234        d : 'un giorno',
8235        dd : '%d giorni',
8236        M : 'un mese',
8237        MM : '%d mesi',
8238        y : 'un anno',
8239        yy : '%d anni'
8240    },
8241    ordinalParse : /\d{1,2}Âº/,
8242    ordinal: '%dÂº',
8243    week : {
8244        dow : 1, // Monday is the first day of the week.
8245        doy : 4  // The week that contains Jan 4th is the first week of the year.
8246    }
8247});
8248
8249//! moment.js locale configuration
8250//! locale : Japanese [ja]
8251//! author : LI Long : https://github.com/baryon
8252
8253hooks.defineLocale('ja', {
8254    months : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'),
8255    monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'),
8256    weekdays : 'æ¥ææ¥_æææ¥_ç«ææ¥_æ°´ææ¥_æ¨ææ¥_éææ¥_åææ¥'.split('_'),
8257    weekdaysShort : 'æ¥_æ_ç«_æ°´_æ¨_é_å'.split('_'),
8258    weekdaysMin : 'æ¥_æ_ç«_æ°´_æ¨_é_å'.split('_'),
8259    longDateFormat : {
8260        LT : 'Ahæmå',
8261        LTS : 'Ahæmåsç§',
8262        L : 'YYYY/MM/DD',
8263        LL : 'YYYYå¹´MæDæ¥',
8264        LLL : 'YYYYå¹´MæDæ¥Ahæmå',
8265        LLLL : 'YYYYå¹´MæDæ¥Ahæmå dddd'
8266    },
8267    meridiemParse: /åå|åå¾/i,
8268    isPM : function (input) {
8269        return input === 'åå¾';
8270    },
8271    meridiem : function (hour, minute, isLower) {
8272        if (hour < 12) {
8273            return 'åå';
8274        } else {
8275            return 'åå¾';
8276        }
8277    },
8278    calendar : {
8279        sameDay : '[ä»æ¥] LT',
8280        nextDay : '[ææ¥] LT',
8281        nextWeek : '[æ¥é±]dddd LT',
8282        lastDay : '[æ¨æ¥] LT',
8283        lastWeek : '[åé±]dddd LT',
8284        sameElse : 'L'
8285    },
8286    ordinalParse : /\d{1,2}æ¥/,
8287    ordinal : function (number, period) {
8288        switch (period) {
8289            case 'd':
8290            case 'D':
8291            case 'DDD':
8292                return number + 'æ¥';
8293            default:
8294                return number;
8295        }
8296    },
8297    relativeTime : {
8298        future : '%så¾',
8299        past : '%så',
8300        s : 'æ°ç§',
8301        m : '1å',
8302        mm : '%då',
8303        h : '1æé',
8304        hh : '%dæé',
8305        d : '1æ¥',
8306        dd : '%dæ¥',
8307        M : '1ã¶æ',
8308        MM : '%dã¶æ',
8309        y : '1å¹´',
8310        yy : '%då¹´'
8311    }
8312});
8313
8314//! moment.js locale configuration
8315//! locale : Javanese [jv]
8316//! author : Rony Lantip : https://github.com/lantip
8317//! reference: http://jv.wikipedia.org/wiki/Basa_Jawa
8318
8319hooks.defineLocale('jv', {
8320    months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
8321    monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
8322    weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
8323    weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
8324    weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
8325    longDateFormat : {
8326        LT : 'HH.mm',
8327        LTS : 'HH.mm.ss',
8328        L : 'DD/MM/YYYY',
8329        LL : 'D MMMM YYYY',
8330        LLL : 'D MMMM YYYY [pukul] HH.mm',
8331        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
8332    },
8333    meridiemParse: /enjing|siyang|sonten|ndalu/,
8334    meridiemHour : function (hour, meridiem) {
8335        if (hour === 12) {
8336            hour = 0;
8337        }
8338        if (meridiem === 'enjing') {
8339            return hour;
8340        } else if (meridiem === 'siyang') {
8341            return hour >= 11 ? hour : hour + 12;
8342        } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
8343            return hour + 12;
8344        }
8345    },
8346    meridiem : function (hours, minutes, isLower) {
8347        if (hours < 11) {
8348            return 'enjing';
8349        } else if (hours < 15) {
8350            return 'siyang';
8351        } else if (hours < 19) {
8352            return 'sonten';
8353        } else {
8354            return 'ndalu';
8355        }
8356    },
8357    calendar : {
8358        sameDay : '[Dinten puniko pukul] LT',
8359        nextDay : '[Mbenjang pukul] LT',
8360        nextWeek : 'dddd [pukul] LT',
8361        lastDay : '[Kala wingi pukul] LT',
8362        lastWeek : 'dddd [kepengker pukul] LT',
8363        sameElse : 'L'
8364    },
8365    relativeTime : {
8366        future : 'wonten ing %s',
8367        past : '%s ingkang kepengker',
8368        s : 'sawetawis detik',
8369        m : 'setunggal menit',
8370        mm : '%d menit',
8371        h : 'setunggal jam',
8372        hh : '%d jam',
8373        d : 'sedinten',
8374        dd : '%d dinten',
8375        M : 'sewulan',
8376        MM : '%d wulan',

8377        y : 'setaun',
8378        yy : '%d taun'
8379    },
8380    week : {
8381        dow : 1, // Monday is the first day of the week.
8382        doy : 7  // The week that contains Jan 1st is the first week of the year.
8383    }
8384});
8385
8386//! moment.js locale configuration
8387//! locale : Georgian [ka]
8388//! author : Irakli Janiashvili : https://github.com/irakli-janiashvili
8389
8390hooks.defineLocale('ka', {
8391    months : {
8392        standalone: 'áááááá á_ááááá áááá_ááá á¢á_ááá ááá_áááá¡á_ááááá¡á_ááááá¡á_ááááá¡á¢á_á¡áá¥á¢ááááá á_áá¥á¢ááááá á_ááááááá á_áááááááá á'.split('_'),
8393        format: 'áááááá á¡_ááááá áááá¡_ááá á¢á¡_ááá áááá¡_áááá¡á¡_ááááá¡á¡_ááááá¡á¡_ááááá¡á¢á¡_á¡áá¥á¢ááááá á¡_áá¥á¢ááááá á¡_ááááááá á¡_áááááááá á¡'.split('_')
8394    },
8395    monthsShort : 'ááá_ááá_ááá _ááá _ááá_ááá_ááá_ááá_á¡áá¥_áá¥á¢_ááá_ááá'.split('_'),
8396    weekdays : {
8397        standalone: 'áááá á_áá á¨ááááá_á¡ááá¨ááááá_ááá®á¨ááááá_á®á£áá¨ááááá_ááá áá¡áááá_á¨ááááá'.split('_'),
8398        format: 'áááá áá¡_áá á¨ááááá¡_á¡ááá¨ááááá¡_ááá®á¨ááááá¡_á®á£áá¨ááááá¡_ááá áá¡áááá¡_á¨ááááá¡'.split('_'),
8399        isFormat: /(á¬ááá|á¨ááááá)/
8400    },
8401    weekdaysShort : 'ááá_áá á¨_á¡áá_ááá®_á®á£á_ááá _á¨áá'.split('_'),
8402    weekdaysMin : 'áá_áá _á¡á_áá_á®á£_áá_á¨á'.split('_'),
8403    longDateFormat : {
8404        LT : 'h:mm A',
8405        LTS : 'h:mm:ss A',
8406        L : 'DD/MM/YYYY',
8407        LL : 'D MMMM YYYY',
8408        LLL : 'D MMMM YYYY h:mm A',
8409        LLLL : 'dddd, D MMMM YYYY h:mm A'
8410    },
8411    calendar : {
8412        sameDay : '[áá¦áá¡] LT[-áá]',
8413        nextDay : '[á®ááá] LT[-áá]',
8414        lastDay : '[áá£á¨áá] LT[-áá]',
8415        nextWeek : '[á¨ááááá] dddd LT[-áá]',
8416        lastWeek : '[á¬ááá] dddd LT-áá',
8417        sameElse : 'L'
8418    },
8419    relativeTime : {
8420        future : function (s) {
8421            return (/(á¬ááá|á¬á£áá|á¡áááá|á¬ááá)/).test(s) ?
8422                s.replace(/á$/, 'á¨á') :
8423                s + 'á¨á';
8424        },
8425        past : function (s) {
8426            if ((/(á¬ááá|á¬á£áá|á¡áááá|áá¦á|ááá)/).test(s)) {
8427                return s.replace(/(á|á)$/, 'áá¡ á¬áá');
8428            }
8429            if ((/á¬ááá/).test(s)) {
8430                return s.replace(/á¬ááá$/, 'á¬ááá¡ á¬áá');
8431            }
8432        },
8433        s : 'á áááááááá á¬ááá',
8434        m : 'á¬á£áá',
8435        mm : '%d á¬á£áá',
8436        h : 'á¡áááá',
8437        hh : '%d á¡áááá',
8438        d : 'áá¦á',
8439        dd : '%d áá¦á',
8440        M : 'ááá',
8441        MM : '%d ááá',
8442        y : 'á¬ááá',
8443        yy : '%d á¬ááá'
8444    },
8445    ordinalParse: /0|1-áá|áá-\d{1,2}|\d{1,2}-á/,
8446    ordinal : function (number) {
8447        if (number === 0) {
8448            return number;
8449        }
8450        if (number === 1) {
8451            return number + '-áá';
8452        }
8453        if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
8454            return 'áá-' + number;
8455        }
8456        return number + '-á';
8457    },
8458    week : {
8459        dow : 1,
8460        doy : 7
8461    }
8462});
8463
8464//! moment.js locale configuration
8465//! locale : Kazakh [kk]
8466//! authors : Nurlan Rakhimzhanov : https://github.com/nurlan
8467
8468var suffixes$1 = {
8469    0: '-ÑÑ',
8470    1: '-ÑÑ',
8471    2: '-ÑÑ',
8472    3: '-ÑÑ',
8473    4: '-ÑÑ',
8474    5: '-ÑÑ',
8475    6: '-ÑÑ',
8476    7: '-ÑÑ',
8477    8: '-ÑÑ',
8478    9: '-ÑÑ',
8479    10: '-ÑÑ',
8480    20: '-ÑÑ',
8481    30: '-ÑÑ',
8482    40: '-ÑÑ',
8483    50: '-ÑÑ',
8484    60: '-ÑÑ',
8485    70: '-ÑÑ',
8486    80: '-ÑÑ',
8487    90: '-ÑÑ',
8488    100: '-ÑÑ'
8489};
8490
8491hooks.defineLocale('kk', {
8492    months : 'ÒÐ°Ò£ÑÐ°Ñ_Ð°ÒÐ¿Ð°Ð½_Ð½Ð°ÑÑÑÐ·_ÑÓÑÑÑ_Ð¼Ð°Ð¼ÑÑ_Ð¼Ð°ÑÑÑÐ¼_ÑÑÐ»Ð´Ðµ_ÑÐ°Ð¼ÑÐ·_ÒÑÑÐºÒ¯Ð¹ÐµÐº_ÒÐ°Ð·Ð°Ð½_ÒÐ°ÑÐ°ÑÐ°_Ð¶ÐµÐ»ÑÐ¾ÒÑÐ°Ð½'.split('_'),
8493    monthsShort : 'ÒÐ°Ò£_Ð°ÒÐ¿_Ð½Ð°Ñ_ÑÓÑ_Ð¼Ð°Ð¼_Ð¼Ð°Ñ_ÑÑÐ»_ÑÐ°Ð¼_ÒÑÑ_ÒÐ°Ð·_ÒÐ°Ñ_Ð¶ÐµÐ»'.split('_'),
8494    weekdays : 'Ð¶ÐµÐºÑÐµÐ½Ð±Ñ_Ð´Ò¯Ð¹ÑÐµÐ½Ð±Ñ_ÑÐµÐ¹ÑÐµÐ½Ð±Ñ_ÑÓÑÑÐµÐ½Ð±Ñ_Ð±ÐµÐ¹ÑÐµÐ½Ð±Ñ_Ð¶Ò±Ð¼Ð°_ÑÐµÐ½Ð±Ñ'.split('_'),
8495    weekdaysShort : 'Ð¶ÐµÐº_Ð´Ò¯Ð¹_ÑÐµÐ¹_ÑÓÑ_Ð±ÐµÐ¹_Ð¶Ò±Ð¼_ÑÐµÐ½'.split('_'),
8496    weekdaysMin : 'Ð¶Ðº_Ð´Ð¹_ÑÐ¹_ÑÑ_Ð±Ð¹_Ð¶Ð¼_ÑÐ½'.split('_'),
8497    longDateFormat : {
8498        LT : 'HH:mm',
8499        LTS : 'HH:mm:ss',
8500        L : 'DD.MM.YYYY',
8501        LL : 'D MMMM YYYY',
8502        LLL : 'D MMMM YYYY HH:mm',
8503        LLLL : 'dddd, D MMMM YYYY HH:mm'
8504    },
8505    calendar : {
8506        sameDay : '[ÐÒ¯Ð³ÑÐ½ ÑÐ°ÒÐ°Ñ] LT',
8507        nextDay : '[ÐÑÑÐµÒ£ ÑÐ°ÒÐ°Ñ] LT',
8508        nextWeek : 'dddd [ÑÐ°ÒÐ°Ñ] LT',
8509        lastDay : '[ÐÐµÑÐµ ÑÐ°ÒÐ°Ñ] LT',
8510        lastWeek : '[Ó¨ÑÐºÐµÐ½ Ð°Ð¿ÑÐ°Ð½ÑÒ£] dddd [ÑÐ°ÒÐ°Ñ] LT',
8511        sameElse : 'L'
8512    },
8513    relativeTime : {
8514        future : '%s ÑÑÑÐ½Ð´Ðµ',
8515        past : '%s Ð±Ò±ÑÑÐ½',
8516        s : 'Ð±ÑÑÐ½ÐµÑÐµ ÑÐµÐºÑÐ½Ð´',
8517        m : 'Ð±ÑÑ Ð¼Ð¸Ð½ÑÑ',
8518        mm : '%d Ð¼Ð¸Ð½ÑÑ',
8519        h : 'Ð±ÑÑ ÑÐ°ÒÐ°Ñ',
8520        hh : '%d ÑÐ°ÒÐ°Ñ',
8521        d : 'Ð±ÑÑ ÐºÒ¯Ð½',
8522        dd : '%d ÐºÒ¯Ð½',
8523        M : 'Ð±ÑÑ Ð°Ð¹',
8524        MM : '%d Ð°Ð¹',
8525        y : 'Ð±ÑÑ Ð¶ÑÐ»',
8526        yy : '%d Ð¶ÑÐ»'
8527    },
8528    ordinalParse: /\d{1,2}-(ÑÑ|ÑÑ)/,
8529    ordinal : function (number) {
8530        var a = number % 10,
8531            b = number >= 100 ? 100 : null;
8532        return number + (suffixes$1[number] || suffixes$1[a] || suffixes$1[b]);
8533    },
8534    week : {
8535        dow : 1, // Monday is the first day of the week.
8536        doy : 7  // The week that contains Jan 1st is the first week of the year.
8537    }
8538});
8539
8540//! moment.js locale configuration
8541//! locale : Cambodian [km]
8542//! author : Kruy Vanna : https://github.com/kruyvanna
8543
8544hooks.defineLocale('km', {
8545    months: 'áááá¶_áá»áááá_áá¸áá¶_áááá¶_á§ááá¶_áá·áá»áá¶_áááááá¶_áá¸á á¶_ááááá¶_áá»áá¶_áá·áááá·áá¶_áááá¼'.split('_'),
8546    monthsShort: 'áááá¶_áá»áááá_áá¸áá¶_áááá¶_á§ááá¶_áá·áá»áá¶_áááááá¶_áá¸á á¶_ááááá¶_áá»áá¶_áá·áááá·áá¶_áááá¼'.split('_'),
8547    weekdays: 'á¢á¶áá·ááá_ááááá_á¢áááá¶á_áá»á_áááá ááááá·á_áá»ááá_áááá'.split('_'),
8548    weekdaysShort: 'á¢á¶áá·ááá_ááááá_á¢áááá¶á_áá»á_áááá ááááá·á_áá»ááá_áááá'.split('_'),
8549    weekdaysMin: 'á¢á¶áá·ááá_ááááá_á¢áááá¶á_áá»á_áááá ááááá·á_áá»ááá_áááá'.split('_'),
8550    longDateFormat: {
8551        LT: 'HH:mm',
8552        LTS : 'HH:mm:ss',
8553        L: 'DD/MM/YYYY',
8554        LL: 'D MMMM YYYY',
8555        LLL: 'D MMMM YYYY HH:mm',
8556        LLLL: 'dddd, D MMMM YYYY HH:mm'
8557    },
8558    calendar: {

8559        sameDay: '[ááááááá áááá] LT',
8560        nextDay: '[ááá¢áá áááá] LT',
8561        nextWeek: 'dddd [áááá] LT',
8562        lastDay: '[áááá·ááá·á áááá] LT',
8563        lastWeek: 'dddd [ááááá¶á ááá»á] [áááá] LT',
8564        sameElse: 'L'
8565    },
8566    relativeTime: {
8567        future: '%sááá',
8568        past: '%sáá»á',
8569        s: 'ááá»áááá¶ááá·áá¶áá¸',
8570        m: 'áá½ááá¶áá¸',
8571        mm: '%d áá¶áá¸',
8572        h: 'áá½ááááá',
8573        hh: '%d áááá',
8574        d: 'áá½ááááá',
8575        dd: '%d áááá',
8576        M: 'áá½ááá',
8577        MM: '%d áá',
8578        y: 'áá½ááááá¶á',
8579        yy: '%d áááá¶á'
8580    },
8581    week: {
8582        dow: 1, // Monday is the first day of the week.
8583        doy: 4 // The week that contains Jan 4th is the first week of the year.
8584    }
8585});
8586
8587//! moment.js locale configuration
8588//! locale : Korean [ko]
8589//! author : Kyungwook, Park : https://github.com/kyungw00k
8590//! author : Jeeeyul Lee <[email protected]>
8591
8592hooks.defineLocale('ko', {
8593    months : '1ì_2ì_3ì_4ì_5ì_6ì_7ì_8ì_9ì_10ì_11ì_12ì'.split('_'),
8594    monthsShort : '1ì_2ì_3ì_4ì_5ì_6ì_7ì_8ì_9ì_10ì_11ì_12ì'.split('_'),
8595    weekdays : 'ì¼ìì¼_ììì¼_íìì¼_ììì¼_ëª©ìì¼_ê¸ìì¼_í ìì¼'.split('_'),
8596    weekdaysShort : 'ì¼_ì_í_ì_ëª©_ê¸_í '.split('_'),
8597    weekdaysMin : 'ì¼_ì_í_ì_ëª©_ê¸_í '.split('_'),
8598    longDateFormat : {
8599        LT : 'A hì më¶',
8600        LTS : 'A hì më¶ sì´',
8601        L : 'YYYY.MM.DD',
8602        LL : 'YYYYë MMMM Dì¼',
8603        LLL : 'YYYYë MMMM Dì¼ A hì më¶',
8604        LLLL : 'YYYYë MMMM Dì¼ dddd A hì më¶'
8605    },
8606    calendar : {
8607        sameDay : 'ì¤ë LT',
8608        nextDay : 'ë´ì¼ LT',
8609        nextWeek : 'dddd LT',
8610        lastDay : 'ì´ì  LT',
8611        lastWeek : 'ì§ëì£¼ dddd LT',
8612        sameElse : 'L'
8613    },
8614    relativeTime : {
8615        future : '%s í',
8616        past : '%s ì ',
8617        s : 'ëª ì´',
8618        ss : '%dì´',
8619        m : 'ì¼ë¶',
8620        mm : '%dë¶',
8621        h : 'í ìê°',
8622        hh : '%dìê°',
8623        d : 'íë£¨',
8624        dd : '%dì¼',
8625        M : 'í ë¬',
8626        MM : '%dë¬',
8627        y : 'ì¼ ë',
8628        yy : '%dë'
8629    },
8630    ordinalParse : /\d{1,2}ì¼/,
8631    ordinal : '%dì¼',
8632    meridiemParse : /ì¤ì |ì¤í/,
8633    isPM : function (token) {
8634        return token === 'ì¤í';
8635    },
8636    meridiem : function (hour, minute, isUpper) {
8637        return hour < 12 ? 'ì¤ì ' : 'ì¤í';
8638    }
8639});
8640
8641//! moment.js locale configuration
8642//! locale : Kyrgyz [ky]
8643//! author : Chyngyz Arystan uulu : https://github.com/chyngyz
8644
8645
8646var suffixes$2 = {
8647    0: '-ÑÒ¯',
8648    1: '-ÑÐ¸',
8649    2: '-ÑÐ¸',
8650    3: '-ÑÒ¯',
8651    4: '-ÑÒ¯',
8652    5: '-ÑÐ¸',
8653    6: '-ÑÑ',
8654    7: '-ÑÐ¸',
8655    8: '-ÑÐ¸',
8656    9: '-ÑÑ',
8657    10: '-ÑÑ',
8658    20: '-ÑÑ',
8659    30: '-ÑÑ',
8660    40: '-ÑÑ',
8661    50: '-ÑÒ¯',
8662    60: '-ÑÑ',
8663    70: '-ÑÐ¸',
8664    80: '-ÑÐ¸',
8665    90: '-ÑÑ',
8666    100: '-ÑÒ¯'
8667};
8668
8669hooks.defineLocale('ky', {
8670    months : 'ÑÐ½Ð²Ð°ÑÑ_ÑÐµÐ²ÑÐ°Ð»Ñ_Ð¼Ð°ÑÑ_Ð°Ð¿ÑÐµÐ»Ñ_Ð¼Ð°Ð¹_Ð¸ÑÐ½Ñ_Ð¸ÑÐ»Ñ_Ð°Ð²Ð³ÑÑÑ_ÑÐµÐ½ÑÑÐ±ÑÑ_Ð¾ÐºÑÑÐ±ÑÑ_Ð½Ð¾ÑÐ±ÑÑ_Ð´ÐµÐºÐ°Ð±ÑÑ'.split('_'),
8671    monthsShort : 'ÑÐ½Ð²_ÑÐµÐ²_Ð¼Ð°ÑÑ_Ð°Ð¿Ñ_Ð¼Ð°Ð¹_Ð¸ÑÐ½Ñ_Ð¸ÑÐ»Ñ_Ð°Ð²Ð³_ÑÐµÐ½_Ð¾ÐºÑ_Ð½Ð¾Ñ_Ð´ÐµÐº'.split('_'),
8672    weekdays : 'ÐÐµÐºÑÐµÐ¼Ð±Ð¸_ÐÒ¯Ð¹ÑÓ©Ð¼Ð±Ò¯_Ð¨ÐµÐ¹ÑÐµÐ¼Ð±Ð¸_Ð¨Ð°ÑÑÐµÐ¼Ð±Ð¸_ÐÐµÐ¹ÑÐµÐ¼Ð±Ð¸_ÐÑÐ¼Ð°_ÐÑÐµÐ¼Ð±Ð¸'.split('_'),
8673    weekdaysShort : 'ÐÐµÐº_ÐÒ¯Ð¹_Ð¨ÐµÐ¹_Ð¨Ð°Ñ_ÐÐµÐ¹_ÐÑÐ¼_ÐÑÐµ'.split('_'),
8674    weekdaysMin : 'ÐÐº_ÐÐ¹_Ð¨Ð¹_Ð¨Ñ_ÐÐ¹_ÐÐ¼_ÐÑ'.split('_'),
8675    longDateFormat : {
8676        LT : 'HH:mm',
8677        LTS : 'HH:mm:ss',
8678        L : 'DD.MM.YYYY',
8679        LL : 'D MMMM YYYY',
8680        LLL : 'D MMMM YYYY HH:mm',
8681        LLLL : 'dddd, D MMMM YYYY HH:mm'
8682    },
8683    calendar : {
8684        sameDay : '[ÐÒ¯Ð³Ò¯Ð½ ÑÐ°Ð°Ñ] LT',
8685        nextDay : '[ÐÑÑÐµÒ£ ÑÐ°Ð°Ñ] LT',
8686        nextWeek : 'dddd [ÑÐ°Ð°Ñ] LT',
8687        lastDay : '[ÐÐµÑÐµ ÑÐ°Ð°Ñ] LT',
8688        lastWeek : '[Ó¨ÑÐºÐµÐ½ Ð°Ð¿ÑÐ°Ð½ÑÐ½] dddd [ÐºÒ¯Ð½Ò¯] [ÑÐ°Ð°Ñ] LT',
8689        sameElse : 'L'
8690    },
8691    relativeTime : {
8692        future : '%s Ð¸ÑÐ¸Ð½Ð´Ðµ',
8693        past : '%s Ð¼ÑÑÑÐ½',
8694        s : 'Ð±Ð¸ÑÐ½ÐµÑÐµ ÑÐµÐºÑÐ½Ð´',
8695        m : 'Ð±Ð¸Ñ Ð¼Ò¯Ð½Ó©Ñ',
8696        mm : '%d Ð¼Ò¯Ð½Ó©Ñ',
8697        h : 'Ð±Ð¸Ñ ÑÐ°Ð°Ñ',
8698        hh : '%d ÑÐ°Ð°Ñ',
8699        d : 'Ð±Ð¸Ñ ÐºÒ¯Ð½',
8700        dd : '%d ÐºÒ¯Ð½',
8701        M : 'Ð±Ð¸Ñ Ð°Ð¹',
8702        MM : '%d Ð°Ð¹',
8703        y : 'Ð±Ð¸Ñ Ð¶ÑÐ»',
8704        yy : '%d Ð¶ÑÐ»'
8705    },
8706    ordinalParse: /\d{1,2}-(ÑÐ¸|ÑÑ|ÑÒ¯|ÑÑ)/,
8707    ordinal : function (number) {
8708        var a = number % 10,
8709            b = number >= 100 ? 100 : null;
8710        return number + (suffixes$2[number] || suffixes$2[a] || suffixes$2[b]);
8711    },
8712    week : {
8713        dow : 1, // Monday is the first day of the week.
8714        doy : 7  // The week that contains Jan 1st is the first week of the year.
8715    }
8716});
8717
8718//! moment.js locale configuration
8719//! locale : Luxembourgish [lb]
8720//! author : mweimerskirch : https://github.com/mweimerskirch
8721//! author : David Raison : https://github.com/kwisatz
8722
8723function processRelativeTime$3(number, withoutSuffix, key, isFuture) {
8724    var format = {
8725        'm': ['eng Minutt', 'enger Minutt'],
8726        'h': ['eng Stonn', 'enger Stonn'],
8727        'd': ['een Dag', 'engem Dag'],
8728        'M': ['ee Mount', 'engem Mount'],
8729        'y': ['ee Joer', 'engem Joer']
8730    };
8731    return withoutSuffix ? format[key][0] : format[key][1];
8732}

8733function processFutureTime(string) {
8734    var number = string.substr(0, string.indexOf(' '));
8735    if (eifelerRegelAppliesToNumber(number)) {
8736        return 'a ' + string;
8737    }
8738    return 'an ' + string;
8739}
8740function processPastTime(string) {
8741    var number = string.substr(0, string.indexOf(' '));
8742    if (eifelerRegelAppliesToNumber(number)) {
8743        return 'viru ' + string;
8744    }
8745    return 'virun ' + string;
8746}
8747/**
8748 * Returns true if the word before the given number loses the '-n' ending.
8749 * e.g. 'an 10 Deeg' but 'a 5 Deeg'
8750 *
8751 * @param number {integer}
8752 * @returns {boolean}
8753 */
8754function eifelerRegelAppliesToNumber(number) {
8755    number = parseInt(number, 10);
8756    if (isNaN(number)) {
8757        return false;
8758    }
8759    if (number < 0) {
8760        // Negative Number --> always true
8761        return true;
8762    } else if (number < 10) {
8763        // Only 1 digit
8764        if (4 <= number && number <= 7) {
8765            return true;
8766        }
8767        return false;
8768    } else if (number < 100) {
8769        // 2 digits
8770        var lastDigit = number % 10, firstDigit = number / 10;
8771        if (lastDigit === 0) {
8772            return eifelerRegelAppliesToNumber(firstDigit);
8773        }
8774        return eifelerRegelAppliesToNumber(lastDigit);
8775    } else if (number < 10000) {
8776        // 3 or 4 digits --> recursively check first digit
8777        while (number >= 10) {
8778            number = number / 10;
8779        }
8780        return eifelerRegelAppliesToNumber(number);
8781    } else {
8782        // Anything larger than 4 digits: recursively check first n-3 digits
8783        number = number / 1000;
8784        return eifelerRegelAppliesToNumber(number);
8785    }
8786}
8787
8788hooks.defineLocale('lb', {
8789    months: 'Januar_Februar_MÃ¤erz_AbrÃ«ll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
8790    monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
8791    monthsParseExact : true,
8792    weekdays: 'Sonndeg_MÃ©indeg_DÃ«nschdeg_MÃ«ttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
8793    weekdaysShort: 'So._MÃ©._DÃ«._MÃ«._Do._Fr._Sa.'.split('_'),
8794    weekdaysMin: 'So_MÃ©_DÃ«_MÃ«_Do_Fr_Sa'.split('_'),
8795    weekdaysParseExact : true,
8796    longDateFormat: {
8797        LT: 'H:mm [Auer]',
8798        LTS: 'H:mm:ss [Auer]',
8799        L: 'DD.MM.YYYY',
8800        LL: 'D. MMMM YYYY',
8801        LLL: 'D. MMMM YYYY H:mm [Auer]',
8802        LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]'
8803    },
8804    calendar: {
8805        sameDay: '[Haut um] LT',
8806        sameElse: 'L',
8807        nextDay: '[Muer um] LT',
8808        nextWeek: 'dddd [um] LT',
8809        lastDay: '[GÃ«schter um] LT',
8810        lastWeek: function () {
8811            // Different date string for 'DÃ«nschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
8812            switch (this.day()) {
8813                case 2:
8814                case 4:
8815                    return '[Leschten] dddd [um] LT';
8816                default:
8817                    return '[Leschte] dddd [um] LT';
8818            }
8819        }
8820    },
8821    relativeTime : {
8822        future : processFutureTime,
8823        past : processPastTime,
8824        s : 'e puer Sekonnen',
8825        m : processRelativeTime$3,
8826        mm : '%d Minutten',
8827        h : processRelativeTime$3,
8828        hh : '%d Stonnen',
8829        d : processRelativeTime$3,
8830        dd : '%d Deeg',
8831        M : processRelativeTime$3,
8832        MM : '%d MÃ©int',
8833        y : processRelativeTime$3,
8834        yy : '%d Joer'
8835    },
8836    ordinalParse: /\d{1,2}\./,
8837    ordinal: '%d.',
8838    week: {
8839        dow: 1, // Monday is the first day of the week.
8840        doy: 4  // The week that contains Jan 4th is the first week of the year.
8841    }
8842});
8843
8844//! moment.js locale configuration
8845//! locale : Lao [lo]
8846//! author : Ryan Hart : https://github.com/ryanhart2
8847
8848hooks.defineLocale('lo', {
8849    months : 'àº¡àº±àºàºàºàº_àºàº¸àº¡àºàº²_àº¡àºµàºàº²_à»àº¡àºªàº²_àºàº¶àºàºªàº°àºàº²_àº¡àº´àºàº¸àºàº²_àºà»àº¥àº°àºàº»àº_àºªàº´àºàº«àº²_àºàº±àºàºàº²_àºàº¸àº¥àº²_àºàº°àºàº´àº_àºàº±àºàº§àº²'.split('_'),
8850    monthsShort : 'àº¡àº±àºàºàºàº_àºàº¸àº¡àºàº²_àº¡àºµàºàº²_à»àº¡àºªàº²_àºàº¶àºàºªàº°àºàº²_àº¡àº´àºàº¸àºàº²_àºà»àº¥àº°àºàº»àº_àºªàº´àºàº«àº²_àºàº±àºàºàº²_àºàº¸àº¥àº²_àºàº°àºàº´àº_àºàº±àºàº§àº²'.split('_'),
8851    weekdays : 'àºàº²àºàº´àº_àºàº±àº_àºàº±àºàºàº²àº_àºàº¸àº_àºàº°àº«àº±àº_àºªàº¸àº_à»àºªàº»àº²'.split('_'),
8852    weekdaysShort : 'àºàº´àº_àºàº±àº_àºàº±àºàºàº²àº_àºàº¸àº_àºàº°àº«àº±àº_àºªàº¸àº_à»àºªàº»àº²'.split('_'),
8853    weekdaysMin : 'àº_àº_àºàº_àº_àºàº«_àºªàº_àºª'.split('_'),
8854    weekdaysParseExact : true,
8855    longDateFormat : {
8856        LT : 'HH:mm',
8857        LTS : 'HH:mm:ss',
8858        L : 'DD/MM/YYYY',
8859        LL : 'D MMMM YYYY',
8860        LLL : 'D MMMM YYYY HH:mm',
8861        LLLL : 'àº§àº±àºdddd D MMMM YYYY HH:mm'
8862    },
8863    meridiemParse: /àºàºàºà»àºàº»à»àº²|àºàºàºà»àº¥àº/,
8864    isPM: function (input) {
8865        return input === 'àºàºàºà»àº¥àº';
8866    },
8867    meridiem : function (hour, minute, isLower) {
8868        if (hour < 12) {
8869            return 'àºàºàºà»àºàº»à»àº²';
8870        } else {
8871            return 'àºàºàºà»àº¥àº';
8872        }
8873    },
8874    calendar : {
8875        sameDay : '[àº¡àº·à»àºàºµà»à»àº§àº¥àº²] LT',
8876        nextDay : '[àº¡àº·à»àºàº·à»àºà»àº§àº¥àº²] LT',
8877        nextWeek : '[àº§àº±àº]dddd[à»à»àº²à»àº§àº¥àº²] LT',
8878        lastDay : '[àº¡àº·à»àº§àº²àºàºàºµà»à»àº§àº¥àº²] LT',
8879        lastWeek : '[àº§àº±àº]dddd[à»àº¥à»àº§àºàºµà»à»àº§àº¥àº²] LT',
8880        sameElse : 'L'
8881    },
8882    relativeTime : {
8883        future : 'àºàºµàº %s',
8884        past : '%sàºà»àº²àºàº¡àº²',
8885        s : 'àºà»à»à»àºàº»à»àº²à»àºàº§àº´àºàº²àºàºµ',
8886        m : '1 àºàº²àºàºµ',
8887        mm : '%d àºàº²àºàºµ',
8888        h : '1 àºàº»à»àº§à»àº¡àº',
8889        hh : '%d àºàº»à»àº§à»àº¡àº',
8890        d : '1 àº¡àº·à»',
8891        dd : '%d àº¡àº·à»',
8892        M : '1 à»àºàº·àºàº',
8893        MM : '%d à»àºàº·àºàº',
8894        y : '1 àºàºµ',
8895        yy : '%d àºàºµ'
8896    },
8897    ordinalParse: /(àºàºµà»)\d{1,2}/,
8898    ordinal : function (number) {
8899        return 'àºàºµà»' + number;
8900    }
8901});
8902
8903//! moment.js locale configuration
8904//! locale : Lithuanian [lt]
8905//! author : Mindaugas MozÅ«ras : https://github.com/mmozuras
8906
8907var units = {
8908    'm' : 'minutÄ_minutÄs_minutÄ',
8909    'mm': 'minutÄs_minuÄiÅ³_minutes',
8910    'h' : 'valanda_valandos_valandÄ',
8911    'hh': 'valandos_valandÅ³_valandas',

8912    'd' : 'diena_dienos_dienÄ',
8913    'dd': 'dienos_dienÅ³_dienas',
8914    'M' : 'mÄnuo_mÄnesio_mÄnesÄ¯',
8915    'MM': 'mÄnesiai_mÄnesiÅ³_mÄnesius',
8916    'y' : 'metai_metÅ³_metus',
8917    'yy': 'metai_metÅ³_metus'
8918};
8919function translateSeconds(number, withoutSuffix, key, isFuture) {
8920    if (withoutSuffix) {
8921        return 'kelios sekundÄs';
8922    } else {
8923        return isFuture ? 'keliÅ³ sekundÅ¾iÅ³' : 'kelias sekundes';
8924    }
8925}
8926function translateSingular(number, withoutSuffix, key, isFuture) {
8927    return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);
8928}
8929function special(number) {
8930    return number % 10 === 0 || (number > 10 && number < 20);
8931}
8932function forms(key) {
8933    return units[key].split('_');
8934}
8935function translate$6(number, withoutSuffix, key, isFuture) {
8936    var result = number + ' ';
8937    if (number === 1) {
8938        return result + translateSingular(number, withoutSuffix, key[0], isFuture);
8939    } else if (withoutSuffix) {
8940        return result + (special(number) ? forms(key)[1] : forms(key)[0]);
8941    } else {
8942        if (isFuture) {
8943            return result + forms(key)[1];
8944        } else {
8945            return result + (special(number) ? forms(key)[1] : forms(key)[2]);
8946        }
8947    }
8948}
8949hooks.defineLocale('lt', {
8950    months : {
8951        format: 'sausio_vasario_kovo_balandÅ¾io_geguÅ¾Äs_birÅ¾elio_liepos_rugpjÅ«Äio_rugsÄjo_spalio_lapkriÄio_gruodÅ¾io'.split('_'),
8952        standalone: 'sausis_vasaris_kovas_balandis_geguÅ¾Ä_birÅ¾elis_liepa_rugpjÅ«tis_rugsÄjis_spalis_lapkritis_gruodis'.split('_'),
8953        isFormat: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/
8954    },
8955    monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
8956    weekdays : {
8957        format: 'sekmadienÄ¯_pirmadienÄ¯_antradienÄ¯_treÄiadienÄ¯_ketvirtadienÄ¯_penktadienÄ¯_Å¡eÅ¡tadienÄ¯'.split('_'),
8958        standalone: 'sekmadienis_pirmadienis_antradienis_treÄiadienis_ketvirtadienis_penktadienis_Å¡eÅ¡tadienis'.split('_'),
8959        isFormat: /dddd HH:mm/
8960    },
8961    weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Å eÅ¡'.split('_'),
8962    weekdaysMin : 'S_P_A_T_K_Pn_Å '.split('_'),
8963    weekdaysParseExact : true,
8964    longDateFormat : {
8965        LT : 'HH:mm',
8966        LTS : 'HH:mm:ss',
8967        L : 'YYYY-MM-DD',
8968        LL : 'YYYY [m.] MMMM D [d.]',
8969        LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
8970        LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
8971        l : 'YYYY-MM-DD',
8972        ll : 'YYYY [m.] MMMM D [d.]',
8973        lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
8974        llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
8975    },
8976    calendar : {
8977        sameDay : '[Å iandien] LT',
8978        nextDay : '[Rytoj] LT',
8979        nextWeek : 'dddd LT',
8980        lastDay : '[Vakar] LT',
8981        lastWeek : '[PraÄjusÄ¯] dddd LT',
8982        sameElse : 'L'
8983    },
8984    relativeTime : {
8985        future : 'po %s',
8986        past : 'prieÅ¡ %s',
8987        s : translateSeconds,
8988        m : translateSingular,
8989        mm : translate$6,
8990        h : translateSingular,
8991        hh : translate$6,
8992        d : translateSingular,
8993        dd : translate$6,
8994        M : translateSingular,
8995        MM : translate$6,
8996        y : translateSingular,
8997        yy : translate$6
8998    },
8999    ordinalParse: /\d{1,2}-oji/,
9000    ordinal : function (number) {
9001        return number + '-oji';
9002    },
9003    week : {
9004        dow : 1, // Monday is the first day of the week.
9005        doy : 4  // The week that contains Jan 4th is the first week of the year.
9006    }
9007});
9008
9009//! moment.js locale configuration
9010//! locale : Latvian [lv]
9011//! author : Kristaps Karlsons : https://github.com/skakri
9012//! author : JÄnis Elmeris : https://github.com/JanisE
9013
9014var units$1 = {
9015    'm': 'minÅ«tes_minÅ«tÄm_minÅ«te_minÅ«tes'.split('_'),
9016    'mm': 'minÅ«tes_minÅ«tÄm_minÅ«te_minÅ«tes'.split('_'),
9017    'h': 'stundas_stundÄm_stunda_stundas'.split('_'),
9018    'hh': 'stundas_stundÄm_stunda_stundas'.split('_'),
9019    'd': 'dienas_dienÄm_diena_dienas'.split('_'),
9020    'dd': 'dienas_dienÄm_diena_dienas'.split('_'),
9021    'M': 'mÄneÅ¡a_mÄneÅ¡iem_mÄnesis_mÄneÅ¡i'.split('_'),
9022    'MM': 'mÄneÅ¡a_mÄneÅ¡iem_mÄnesis_mÄneÅ¡i'.split('_'),
9023    'y': 'gada_gadiem_gads_gadi'.split('_'),
9024    'yy': 'gada_gadiem_gads_gadi'.split('_')
9025};
9026/**
9027 * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
9028 */
9029function format$1(forms, number, withoutSuffix) {
9030    if (withoutSuffix) {
9031        // E.g. "21 minÅ«te", "3 minÅ«tes".
9032        return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3];
9033    } else {
9034        // E.g. "21 minÅ«tes" as in "pÄc 21 minÅ«tes".
9035        // E.g. "3 minÅ«tÄm" as in "pÄc 3 minÅ«tÄm".
9036        return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1];
9037    }
9038}
9039function relativeTimeWithPlural$1(number, withoutSuffix, key) {
9040    return number + ' ' + format$1(units$1[key], number, withoutSuffix);
9041}
9042function relativeTimeWithSingular(number, withoutSuffix, key) {
9043    return format$1(units$1[key], number, withoutSuffix);
9044}
9045function relativeSeconds(number, withoutSuffix) {
9046    return withoutSuffix ? 'daÅ¾as sekundes' : 'daÅ¾Äm sekundÄm';
9047}
9048
9049hooks.defineLocale('lv', {
9050    months : 'janvÄris_februÄris_marts_aprÄ«lis_maijs_jÅ«nijs_

9050jÅ«lijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
9051    monthsShort : 'jan_feb_mar_apr_mai_jÅ«n_jÅ«l_aug_sep_okt_nov_dec'.split('_'),
9052    weekdays : 'svÄtdiena_pirmdiena_otrdiena_treÅ¡diena_ceturtdiena_piektdiena_sestdiena'.split('_'),
9053    weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
9054    weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
9055    weekdaysParseExact : true,
9056    longDateFormat : {
9057        LT : 'HH:mm',
9058        LTS : 'HH:mm:ss',
9059        L : 'DD.MM.YYYY.',
9060        LL : 'YYYY. [gada] D. MMMM',
9061        LLL : 'YYYY. [gada] D. MMMM, HH:mm',
9062        LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
9063    },
9064    calendar : {
9065        sameDay : '[Å odien pulksten] LT',
9066        nextDay : '[RÄ«t pulksten] LT',
9067        nextWeek : 'dddd [pulksten] LT',
9068        lastDay : '[Vakar pulksten] LT',
9069        lastWeek : '[PagÄjuÅ¡Ä] dddd [pulksten] LT',
9070        sameElse : 'L'
9071    },
9072    relativeTime : {
9073        future : 'pÄc %s',
9074        past : 'pirms %s',
9075        s : relativeSeconds,
9076        m : relativeTimeWithSingular,
9077        mm : relativeTimeWithPlural$1,
9078        h : relativeTimeWithSingular,
9079        hh : relativeTimeWithPlural$1,
9080        d : relativeTimeWithSingular,
9081        dd : relativeTimeWithPlural$1,
9082        M : relativeTimeWithSingular,
9083        MM : relativeTimeWithPlural$1,
9084        y : relativeTimeWithSingular,
9085        yy : relativeTimeWithPlural$1
9086    },
9087    ordinalParse: /\d{1,2}\./,
9088    ordinal : '%d.',
9089    week : {
9090        dow : 1, // Monday is the first day of the week.
9091        doy : 4  // The week that contains Jan 4th is the first week of the year.
9092    }
9093});
9094
9095//! moment.js locale configuration
9096//! locale : Montenegrin [me]
9097//! author : Miodrag NikaÄ <[email protected]> : https://github.com/miodragnikac
9098
9099var translator = {
9100    words: { //Different grammatical cases
9101        m: ['jedan minut', 'jednog minuta'],
9102        mm: ['minut', 'minuta', 'minuta'],
9103        h: ['jedan sat', 'jednog sata'],
9104        hh: ['sat', 'sata', 'sati'],
9105        dd: ['dan', 'dana', 'dana'],
9106        MM: ['mjesec', 'mjeseca', 'mjeseci'],
9107        yy: ['godina', 'godine', 'godina']
9108    },
9109    correctGrammaticalCase: function (number, wordKey) {
9110        return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
9111    },
9112    translate: function (number, withoutSuffix, key) {
9113        var wordKey = translator.words[key];
9114        if (key.length === 1) {
9115            return withoutSuffix ? wordKey[0] : wordKey[1];
9116        } else {
9117            return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
9118        }
9119    }
9120};
9121
9122hooks.defineLocale('me', {
9123    months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
9124    monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
9125    monthsParseExact : true,
9126    weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_Äetvrtak_petak_subota'.split('_'),
9127    weekdaysShort: 'ned._pon._uto._sri._Äet._pet._sub.'.split('_'),
9128    weekdaysMin: 'ne_po_ut_sr_Äe_pe_su'.split('_'),
9129    weekdaysParseExact : true,
9130    longDateFormat: {
9131        LT: 'H:mm',
9132        LTS : 'H:mm:ss',
9133        L: 'DD.MM.YYYY',
9134        LL: 'D. MMMM YYYY',
9135        LLL: 'D. MMMM YYYY H:mm',
9136        LLLL: 'dddd, D. MMMM YYYY H:mm'
9137    },
9138    calendar: {
9139        sameDay: '[danas u] LT',
9140        nextDay: '[sjutra u] LT',
9141
9142        nextWeek: function () {
9143            switch (this.day()) {
9144                case 0:
9145                    return '[u] [nedjelju] [u] LT';
9146                case 3:
9147                    return '[u] [srijedu] [u] LT';
9148                case 6:
9149                    return '[u] [subotu] [u] LT';
9150                case 1:
9151                case 2:
9152                case 4:
9153                case 5:
9154                    return '[u] dddd [u] LT';
9155            }
9156        },
9157        lastDay  : '[juÄe u] LT',
9158        lastWeek : function () {
9159            var lastWeekDays = [
9160                '[proÅ¡le] [nedjelje] [u] LT',
9161                '[proÅ¡log] [ponedjeljka] [u] LT',
9162                '[proÅ¡log] [utorka] [u] LT',
9163                '[proÅ¡le] [srijede] [u] LT',
9164                '[proÅ¡log] [Äetvrtka] [u] LT',
9165                '[proÅ¡log] [petka] [u] LT',
9166                '[proÅ¡le] [subote] [u] LT'
9167            ];
9168            return lastWeekDays[this.day()];
9169        },
9170        sameElse : 'L'
9171    },
9172    relativeTime : {
9173        future : 'za %s',
9174        past   : 'prije %s',
9175        s      : 'nekoliko sekundi',
9176        m      : translator.translate,
9177        mm     : translator.translate,
9178        h      : translator.translate,
9179        hh     : translator.translate,
9180        d      : 'dan',
9181        dd     : translator.translate,
9182        M      : 'mjesec',
9183        MM     : translator.translate,
9184        y      : 'godinu',
9185        yy     : translator.translate
9186    },
9187    ordinalParse: /\d{1,2}\./,
9188    ordinal : '%d.',
9189    week : {
9190        dow : 1, // Monday is the first day of the week.
9191        doy : 7  // The week that contains Jan 1st is the first week of the year.
9192    }
9193});
9194
9195//! moment.js locale configuration
9196//! locale : Maori [mi]
9197//! author : John Corrigan <[email protected]> : https://github.com/johnideal
9198
9199hooks.defineLocale('mi', {
9200    months: 'Kohi-tÄte_Hui-tanguru_PoutÅ«-te-rangi_Paenga-whÄwhÄ_Haratua_Pipiri_HÅngoingoi_Here-turi-kÅkÄ_Mahuru_Whiringa-Ä-nuku_Whiringa-Ä-rangi_Hakihea'.split('_'),
9201    monthsShort: 'Kohi_Hui_Pou_Pae_Hara_Pipi_HÅngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split('_'),
9202    monthsRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
9203    monthsStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
9204    monthsShortRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
9205    monthsShortStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
9206    weekdays: 'RÄtapu_Mane_TÅ«rei_Wenerei_TÄite_Paraire_HÄtarei'.split('_'),
9207    weekdaysShort: 'Ta_Ma_TÅ«_We_TÄi_Pa_HÄ'.split('_'),
9208    weekdaysMin: 'Ta_Ma_TÅ«_We_TÄi_Pa_HÄ'.split('_'),
9209    longDateFormat: {
9210        LT: 'HH:mm',
9211        LTS: 'HH:mm:ss',
9212        L: 'DD/MM/YYYY',
9213        LL: 'D MMMM YYYY',
9214        LLL: 'D MMMM YYYY [i] HH:mm',
9215        LLLL: 'dddd, D MMMM YYYY [i] HH:mm'
9216    },
9217    calendar: {
9218        sameDay: '[i teie mahana, i] LT',
9219        nextDay: '[apopo i] LT',
9220        nextWeek: 'dddd [i] LT',
9221        lastDay: '[inanahi i] LT',
9222        lastWeek: 'dddd [whakamutunga i] LT',
9223        sameElse: 'L'
9224    },
9225    relativeTime: {
9226        future: 'i roto i %s',
9227        past: '%s i mua',
9228        s: 'te hÄkona ruarua',
9229        m: 'he meneti',
9230        mm: '%d meneti',
9231        h: 'te haora',
9232        hh: '%d haora',
9233        d: 'he ra',
9234        dd: '%d ra',
9235        M: 'he marama',
9236        MM: '%d marama',
9237        y: 'he tau',
9238        yy: '%d tau'
9239    },
9240    ordinalParse: /\d{1,2}Âº/,
9241    ordinal: '%dÂº',
9242    week : {
9243        dow : 1, // Monday is the first day of the week.
9244        doy : 4  // The week that contains Jan 4th is the first week of the year.
9245    }
9246});
9247
9248//! moment.js locale configuration
9249//! locale : Macedonian [mk]
9250//! author : Borislav Mickov : https://github.com/B0k0
9251
9252hooks.defineLocale('mk', {
9253    months : 'ÑÐ°Ð½ÑÐ°ÑÐ¸_ÑÐµÐ²ÑÑÐ°ÑÐ¸_Ð¼Ð°ÑÑ_Ð°Ð¿ÑÐ¸Ð»_Ð¼Ð°Ñ_ÑÑÐ½Ð¸_ÑÑÐ»Ð¸_Ð°Ð²Ð³ÑÑÑ_ÑÐµÐ¿ÑÐµÐ¼Ð²ÑÐ¸_Ð¾ÐºÑÐ¾Ð¼Ð²ÑÐ¸_Ð½Ð¾ÐµÐ¼Ð²ÑÐ¸_Ð´ÐµÐºÐµÐ¼Ð²ÑÐ¸'.split('_'),
9254    monthsShort : 'ÑÐ°Ð½_ÑÐµÐ²_Ð¼Ð°Ñ_Ð°Ð¿Ñ_Ð¼Ð°Ñ_ÑÑÐ½_ÑÑÐ»_Ð°Ð²Ð³_ÑÐµÐ¿_Ð¾ÐºÑ_Ð½Ð¾Ðµ_Ð´ÐµÐº'.split('_'),
9255    weekdays : 'Ð½ÐµÐ´ÐµÐ»Ð°_Ð¿Ð¾Ð½ÐµÐ´ÐµÐ»Ð½Ð¸Ðº_Ð²ÑÐ¾ÑÐ½Ð¸Ðº_ÑÑÐµÐ´Ð°_ÑÐµÑÐ²ÑÑÐ¾Ðº_Ð¿ÐµÑÐ¾Ðº_ÑÐ°Ð±Ð¾ÑÐ°'.split('_'),
9256    weekdaysShort : 'Ð½ÐµÐ´_Ð¿Ð¾Ð½_Ð²ÑÐ¾_ÑÑÐµ_ÑÐµÑ_Ð¿ÐµÑ_ÑÐ°Ð±'.split('_'),
9257    weekdaysMin : 'Ð½e_Ð¿o_Ð²Ñ_ÑÑ_ÑÐµ_Ð¿Ðµ_Ña'.split('_'),
9258    longDateFormat : {
9259        LT : 'H:mm',
9260        LTS : 'H:mm:ss',
9261        L : 'D.MM.YYYY',
9262        LL : 'D MMMM YYYY',
9263        LLL : 'D MMMM YYYY H:mm',
9264        LLLL : 'dddd, D MMMM YYYY H:mm'
9265    },
9266    calendar : {
9267        sameDay : '[ÐÐµÐ½ÐµÑ Ð²Ð¾] LT',
9268        nextDay : '[Ð£ÑÑÐµ Ð²Ð¾] LT',
9269        nextWeek : '[ÐÐ¾] dddd [Ð²Ð¾] LT',
9270        lastDay : '[ÐÑÐµÑÐ° Ð²Ð¾] LT',
9271        lastWeek : function () {
9272            switch (this.day()) {
9273                case 0:
9274                case 3:
9275                case 6:
9276                    return '[ÐÐ·Ð¼Ð¸Ð½Ð°ÑÐ°ÑÐ°] dddd [Ð²Ð¾] LT';
9277                case 1:
9278                case 2:
9279                case 4:
9280                case 5:
9281                    return '[ÐÐ·Ð¼Ð¸Ð½Ð°ÑÐ¸Ð¾Ñ] dddd [Ð²Ð¾] LT';
9282            }
9283        },
9284        sameElse : 'L'
9285    },
9286    relativeTime : {
9287        future : 'Ð¿Ð¾ÑÐ»Ðµ %s',
9288        past : 'Ð¿ÑÐµÐ´ %s',
9289        s : 'Ð½ÐµÐºÐ¾Ð»ÐºÑ ÑÐµÐºÑÐ½Ð´Ð¸',
9290        m : 'Ð¼Ð¸Ð½ÑÑÐ°',
9291        mm : '%d Ð¼Ð¸Ð½ÑÑÐ¸',
9292        h : 'ÑÐ°Ñ',
9293        hh : '%d ÑÐ°ÑÐ°',
9294        d : 'Ð´ÐµÐ½',
9295        dd : '%d Ð´ÐµÐ½Ð°',
9296        M : 'Ð¼ÐµÑÐµÑ',
9297        MM : '%d Ð¼ÐµÑÐµÑÐ¸',
9298        y : 'Ð³Ð¾Ð´Ð¸Ð½Ð°',
9299        yy : '%d Ð³Ð¾Ð´Ð¸Ð½Ð¸'
9300    },
9301    ordinalParse: /\d{1,2}-(ÐµÐ²|ÐµÐ½|ÑÐ¸|Ð²Ð¸|ÑÐ¸|Ð¼Ð¸)/,
9302    ordinal : function (number) {
9303        var lastDigit = number % 10,
9304            last2Digits = number % 100;
9305        if (number === 0) {
9306            return number + '-ÐµÐ²';
9307        } else if (last2Digits === 0) {
9308            return number + '-ÐµÐ½';
9309        } else if (last2Digits > 10 && last2Digits < 20) {
9310            return number + '-ÑÐ¸';
9311        } else if (lastDigit === 1) {
9312            return number + '-Ð²Ð¸';
9313        } else if (lastDigit === 2) {
9314            return number + '-ÑÐ¸';
9315        } else if (lastDigit === 7 || lastDigit === 8) {
9316            return number + '-Ð¼Ð¸';
9317        } else {
9318            return number + '-ÑÐ¸';
9319        }
9320    },
9321    week : {
9322        dow : 1, // Monday is the first day of the week.
9323        doy : 7  // The week that contains Jan 1st is the first week of the year.
9324    }
9325});
9326
9327//! moment.js locale configuration
9328//! locale : Malayalam [ml]
9329//! author : Floyd Pink : https://github.com/floydpink
9330
9331hooks.defineLocale('ml', {
9332    months : 'à´à´¨àµà´µà´°à´¿_à´«àµà´¬àµà´°àµà´µà´°à´¿_à´®à´¾àµ¼à´àµà´à

9332µ_à´à´ªàµà´°à´¿àµ½_à´®àµà´¯àµ_à´àµàµº_à´àµà´²àµ_à´à´à´¸àµà´±àµà´±àµ_à´¸àµà´ªàµà´±àµà´±à´à´¬àµ¼_à´à´àµà´àµà´¬àµ¼_à´¨à´µà´à´¬àµ¼_à´¡à´¿à´¸à´à´¬àµ¼'.split('_'),
9333    monthsShort : 'à´à´¨àµ._à´«àµà´¬àµà´°àµ._à´®à´¾àµ¼._à´à´ªàµà´°à´¿._à´®àµà´¯àµ_à´àµàµº_à´àµà´²àµ._à´à´._à´¸àµà´ªàµà´±àµà´±._à´à´àµà´àµ._à´¨à´µà´._à´¡à´¿à´¸à´.'.split('_'),
9334    monthsParseExact : true,
9335    weekdays : 'à´à´¾à´¯à´±à´¾à´´àµà´_à´¤à´¿à´àµà´à´³à´¾à´´àµà´_à´àµà´µàµà´µà´¾à´´àµà´_à´¬àµà´§à´¨à´¾à´´àµà´_à´µàµà´¯à´¾à´´à´¾à´´àµà´_à´µàµà´³àµà´³à´¿à´¯à´¾à´´àµà´_à´¶à´¨à´¿à´¯à´¾à´´àµà´'.split('_'),
9336    weekdaysShort : 'à´à´¾à´¯àµ¼_à´¤à´¿à´àµà´àµ¾_à´àµà´µàµà´µ_à´¬àµà´§àµ»_à´µàµà´¯à´¾à´´à´_à´µàµà´³àµà´³à´¿_à´¶à´¨à´¿'.split('_'),
9337    weekdaysMin : 'à´à´¾_à´¤à´¿_à´àµ_à´¬àµ_à´µàµà´¯à´¾_à´µàµ_à´¶'.split('_'),
9338    longDateFormat : {
9339        LT : 'A h:mm -à´¨àµ',
9340        LTS : 'A h:mm:ss -à´¨àµ',
9341        L : 'DD/MM/YYYY',
9342        LL : 'D MMMM YYYY',
9343        LLL : 'D MMMM YYYY, A h:mm -à´¨àµ',
9344        LLLL : 'dddd, D MMMM YYYY, A h:mm -à´¨àµ'
9345    },
9346    calendar : {
9347        sameDay : '[à´à´¨àµà´¨àµ] LT',
9348        nextDay : '[à´¨à´¾à´³àµ] LT',
9349        nextWeek : 'dddd, LT',
9350        lastDay : '[à´à´¨àµà´¨à´²àµ] LT',
9351        lastWeek : '[à´à´´à´¿à´àµà´] dddd, LT',
9352        sameElse : 'L'
9353    },
9354    relativeTime : {
9355        future : '%s à´à´´à´¿à´àµà´àµ',
9356        past : '%s à´®àµàµ»à´ªàµ',
9357        s : 'à´àµ½à´ª à´¨à´¿à´®à´¿à´·à´àµà´àµ¾',
9358        m : 'à´à´°àµ à´®à´¿à´¨à´¿à´±àµà´±àµ',
9359        mm : '%d à´®à´¿à´¨à´¿à´±àµà´±àµ',
9360        h : 'à´à´°àµ à´®à´£à´¿à´àµà´àµàµ¼',
9361        hh : '%d à´®à´£à´¿à´àµà´àµàµ¼',
9362        d : 'à´à´°àµ à´¦à´¿à´µà´¸à´',
9363        dd : '%d à´¦à´¿à´µà´¸à´',
9364        M : 'à´à´°àµ à´®à´¾à´¸à´',
9365        MM : '%d à´®à´¾à´¸à´',
9366        y : 'à´à´°àµ à´µàµ¼à´·à´',
9367        yy : '%d à´µàµ¼à´·à´'
9368    },
9369    meridiemParse: /à´°à´¾à´¤àµà´°à´¿|à´°à´¾à´µà´¿à´²àµ|à´à´àµà´ à´à´´à´¿à´àµà´àµ|à´µàµà´àµà´¨àµà´¨àµà´°à´|à´°à´¾à´¤àµà´°à´¿/i,
9370    meridiemHour : function (hour, meridiem) {
9371        if (hour === 12) {
9372            hour = 0;
9373        }
9374        if ((meridiem === 'à´°à´¾à´¤àµà´°à´¿' && hour >= 4) ||
9375                meridiem === 'à´à´àµà´ à´à´´à´¿à´àµà´àµ' ||
9376                meridiem === 'à´µàµà´àµà´¨àµà´¨àµà´°à´') {
9377            return hour + 12;
9378        } else {
9379            return hour;
9380        }
9381    },
9382    meridiem : function (hour, minute, isLower) {
9383        if (hour < 4) {
9384            return 'à´°à´¾à´¤àµà´°à´¿';
9385        } else if (hour < 12) {
9386            return 'à´°à´¾à´µà´¿à´²àµ';
9387        } else if (hour < 17) {
9388            return 'à´à´àµà´ à´à´´à´¿à´àµà´àµ';
9389        } else if (hour < 20) {
9390            return 'à´µàµà´àµà´¨àµà´¨àµà´°à´';
9391        } else {
9392            return 'à´°à´¾à´¤àµà´°à´¿';
9393        }
9394    }
9395});
9396
9397//! moment.js locale configuration
9398//! locale : Marathi [mr]
9399//! author : Harshad Kale : https://github.com/kalehv
9400//! author : Vivek Athalye : https://github.com/vnathalye
9401
9402var symbolMap$7 = {
9403    '1': 'à¥§',
9404    '2': 'à¥¨',
9405    '3': 'à¥©',
9406    '4': 'à¥ª',
9407    '5': 'à¥«',
9408    '6': 'à¥¬',
9409    '7': 'à¥',
9410    '8': 'à¥®',
9411    '9': 'à¥¯',
9412    '0': 'à¥¦'
9413};
9414var numberMap$6 = {
9415    'à¥§': '1',
9416    'à¥¨': '2',
9417    'à¥©': '3',
9418    'à¥ª': '4',
9419    'à¥«': '5',
9420    'à¥¬': '6',
9421    'à¥': '7',
9422    'à¥®': '8',
9423    'à¥¯': '9',
9424    'à¥¦': '0'
9425};
9426
9427function relativeTimeMr(number, withoutSuffix, string, isFuture)
9428{
9429    var output = '';
9430    if (withoutSuffix) {
9431        switch (string) {
9432            case 's': output = 'à¤à¤¾à¤¹à¥ à¤¸à¥à¤à¤à¤¦'; break;
9433            case 'm': output = 'à¤à¤ à¤®à¤¿à¤¨à¤¿à¤'; break;
9434            case 'mm': output = '%d à¤®à¤¿à¤¨à¤¿à¤à¥'; break;
9435            case 'h': output = 'à¤à¤ à¤¤à¤¾à¤¸'; break;
9436            case 'hh': output = '%d à¤¤à¤¾à¤¸'; break;
9437            case 'd': output = 'à¤à¤ à¤¦à¤¿à¤µà¤¸'; break;
9438            case 'dd': output = '%d à¤¦à¤¿à¤µà¤¸'; break;
9439            case 'M': output = 'à¤à¤ à¤®à¤¹à¤¿à¤¨à¤¾'; break;
9440            case 'MM': output = '%d à¤®à¤¹à¤¿à¤¨à¥'; break;
9441            case 'y': output = 'à¤à¤ à¤µà¤°à¥à¤·'; break;
9442            case 'yy': output = '%d à¤µà¤°à¥à¤·à¥'; break;
9443        }
9444    }
9445    else {
9446        switch (string) {
9447            case 's': output = 'à¤à¤¾à¤¹à¥ à¤¸à¥à¤à¤à¤¦à¤¾à

vendor: 6,118 bytes, lines 9447-9607

9447¤'; break;
9448            case 'm': output = 'à¤à¤à¤¾ à¤®à¤¿à¤¨à¤¿à¤à¤¾'; break;
9449            case 'mm': output = '%d à¤®à¤¿à¤¨à¤¿à¤à¤¾à¤'; break;
9450            case 'h': output = 'à¤à¤à¤¾ à¤¤à¤¾à¤¸à¤¾'; break;
9451            case 'hh': output = '%d à¤¤à¤¾à¤¸à¤¾à¤'; break;
9452            case 'd': output = 'à¤à¤à¤¾ à¤¦à¤¿à¤µà¤¸à¤¾'; break;
9453            case 'dd': output = '%d à¤¦à¤¿à¤µà¤¸à¤¾à¤'; break;
9454            case 'M': output = 'à¤à¤à¤¾ à¤®à¤¹à¤¿à¤¨à¥à¤¯à¤¾'; break;
9455            case 'MM': output = '%d à¤®à¤¹à¤¿à¤¨à¥à¤¯à¤¾à¤'; break;
9456            case 'y': output = 'à¤à¤à¤¾ à¤µà¤°à¥à¤·à¤¾'; break;
9457            case 'yy': output = '%d à¤µà¤°à¥à¤·à¤¾à¤'; break;
9458        }
9459    }
9460    return output.replace(/%d/i, number);
9461}
9462
9463hooks.defineLocale('mr', {
9464    months : 'à¤à¤¾à¤¨à¥à¤µà¤¾à¤°à¥_à¤«à¥à¤¬à¥à¤°à¥à¤µà¤¾à¤°à¥_à¤®à¤¾à¤°à¥à¤_à¤à¤ªà¥à¤°à¤¿à¤²_à¤®à¥_à¤à¥à¤¨_à¤à¥à¤²à¥_à¤à¤à¤¸à¥à¤_à¤¸à¤ªà¥à¤à¥à¤à¤¬à¤°_à¤à¤à¥à¤à¥à¤¬à¤°_à¤¨à¥à¤µà¥à¤¹à¥à¤à¤¬à¤°_à¤¡à¤¿à¤¸à¥à¤à¤¬à¤°'.split('_'),
9465    monthsShort: 'à¤à¤¾à¤¨à¥._à¤«à¥à¤¬à¥à¤°à¥._à¤®à¤¾à¤°à¥à¤._à¤à¤ªà¥à¤°à¤¿._à¤®à¥._à¤à¥à¤¨._à¤à¥à¤²à¥._à¤à¤._à¤¸à¤ªà¥à¤à¥à¤._à¤à¤à¥à¤à¥._à¤¨à¥à¤µà¥à¤¹à¥à¤._à¤¡à¤¿à¤¸à¥à¤.'.split('_'),
9466    monthsParseExact : true,
9467    weekdays : 'à¤°à¤µà¤¿à¤µà¤¾à¤°_à¤¸à¥à¤®à¤µà¤¾à¤°_à¤®à¤à¤à¤³à¤µà¤¾à¤°_à¤¬à¥à¤§à¤µà¤¾à¤°_à¤à¥à¤°à¥à¤µà¤¾à¤°_à¤¶à¥à¤à¥à¤°à¤µà¤¾à¤°_à¤¶à¤¨à¤¿à¤µà¤¾à¤°'.split('_'),
9468    weekdaysShort : 'à¤°à¤µà¤¿_à¤¸à¥à¤®_à¤®à¤à¤à¤³_à¤¬à¥à¤§_à¤à¥à¤°à¥_à¤¶à¥à¤à¥à¤°_à¤¶à¤¨à¤¿'.split('_'),
9469    weekdaysMin : 'à¤°_à¤¸à¥_à¤®à¤_à¤¬à¥_à¤à¥_à¤¶à¥_à¤¶'.split('_'),
9470    longDateFormat : {
9471        LT : 'A h:mm à¤µà¤¾à¤à¤¤à¤¾',
9472        LTS : 'A h:mm:ss à¤µà¤¾à¤à¤¤à¤¾',
9473        L : 'DD/MM/YYYY',
9474        LL : 'D MMMM YYYY',
9475        LLL : 'D MMMM YYYY, A h:mm à¤µà¤¾à¤à¤¤à¤¾',
9476        LLLL : 'dddd, D MMMM YYYY, A h:mm à¤µà¤¾à¤à¤¤à¤¾'
9477    },
9478    calendar : {
9479        sameDay : '[à¤à¤] LT',
9480        nextDay : '[à¤à¤¦à¥à¤¯à¤¾] LT',
9481        nextWeek : 'dddd, LT',
9482        lastDay : '[à¤à¤¾à¤²] LT',
9483        lastWeek: '[à¤®à¤¾à¤à¥à¤²] dddd, LT',
9484        sameElse : 'L'
9485    },
9486    relativeTime : {
9487        future: '%sà¤®à¤§à¥à¤¯à¥',
9488        past: '%sà¤ªà¥à¤°à¥à¤µà¥',
9489        s: relativeTimeMr,
9490        m: relativeTimeMr,
9491        mm: relativeTimeMr,
9492        h: relativeTimeMr,
9493        hh: relativeTimeMr,
9494        d: relativeTimeMr,
9495        dd: relativeTimeMr,
9496        M: relativeTimeMr,
9497        MM: relativeTimeMr,
9498        y: relativeTimeMr,
9499        yy: relativeTimeMr
9500    },
9501    preparse: function (string) {
9502        return string.replace(/[à¥§à¥¨à¥©à¥ªà¥«à¥¬à¥à¥®à¥¯à¥¦]/g, function (match) {
9503            return numberMap$6[match];
9504        });
9505    },
9506    postformat: function (string) {
9507        return string.replace(/\d/g, function (match) {
9508            return symbolMap$7[match];
9509        });
9510    },
9511    meridiemParse: /à¤°à¤¾à¤¤à¥à¤°à¥|à¤¸à¤à¤¾à¤³à¥|à¤¦à¥à¤ªà¤¾à¤°à¥|à¤¸à¤¾à¤¯à¤à¤à¤¾à¤³à¥/,
9512    meridiemHour : function (hour, meridiem) {
9513        if (hour === 12) {
9514            hour = 0;
9515        }
9516        if (meridiem === 'à¤°à¤¾à¤¤à¥à¤°à¥') {
9517            return hour < 4 ? hour : hour + 12;
9518        } else if (meridiem === 'à¤¸à¤à¤¾à¤³à¥') {
9519            return hour;
9520        } else if (meridiem === 'à¤¦à¥à¤ªà¤¾à¤°à¥') {
9521            return hour >= 10 ? hour : hour + 12;
9522        } else if (meridiem === 'à¤¸à¤¾à¤¯à¤à¤à¤¾à¤³à¥') {
9523            return hour + 12;
9524        }
9525    },
9526    meridiem: function (hour, minute, isLower) {
9527        if (hour < 4) {
9528            return 'à¤°à¤¾à¤¤à¥à¤°à¥';
9529        } else if (hour < 10) {
9530            return 'à¤¸à¤à¤¾à¤³à¥';
9531        } else if (hour < 17) {
9532            return 'à¤¦à¥à¤ªà¤¾à¤°à¥';
9533        } else if (hour < 20) {
9534            return 'à¤¸à¤¾à¤¯à¤à¤à¤¾à¤³à¥';
9535        } else {
9536            return 'à¤°à¤¾à¤¤à¥à¤°à¥';
9537        }
9538    },
9539    week : {
9540        dow : 0, // Sunday is the first day of the week.
9541        doy : 6  // The week that contains Jan 1st is the first week of the year.
9542    }
9543});
9544
9545//! moment.js locale configuration
9546//! locale : Malay [ms-my]
9547//! note : DEPRECATED, the correct one is [ms]
9548//! author : Weldan Jamili : https://github.com/weldan
9549
9550hooks.defineLocale('ms-my', {
9551    months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
9552    monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
9553    weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
9554    weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
9555    weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
9556    longDateFormat : {
9557        LT : 'HH.mm',
9558        LTS : 'HH.mm.ss',
9559        L : 'DD/MM/YYYY',
9560        LL : 'D MMMM YYYY',
9561        LLL : 'D MMMM YYYY [pukul] HH.mm',
9562        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
9563    },
9564    meridiemParse: /pagi|tengahari|petang|malam/,
9565    meridiemHour: function (hour, meridiem) {
9566        if (hour === 12) {
9567            hour = 0;
9568        }
9569        if (meridiem === 'pagi') {
9570            return hour;
9571        } else if (meridiem === 'tengahari') {
9572            return hour >= 11 ? hour : hour + 12;
9573        } else if (meridiem === 'petang' || meridiem === 'malam') {
9574            return hour + 12;
9575        }
9576    },
9577    meridiem : function (hours, minutes, isLower) {
9578        if (hours < 11) {
9579            return 'pagi';
9580        } else if (hours < 15) {
9581            return 'tengahari';
9582        } else if (hours < 19) {
9583            return 'petang';
9584        } else {
9585            return 'malam';
9586        }
9587    },
9588    calendar : {
9589        sameDay : '[Hari ini pukul] LT',
9590        nextDay : '[Esok pukul] LT',
9591        nextWeek : 'dddd [pukul] LT',
9592        lastDay : '[Kelmarin pukul] LT',
9593        lastWeek : 'dddd [lepas pukul] LT',
9594        sameElse : 'L'
9595    },
9596    relativeTime : {
9597        future : 'dalam %s',
9598        past : '%s yang lepas',
9599        s : 'beberapa saat',
9600        m : 'seminit',
9601        mm : '%d minit',
9602        h : 'sejam',
9603        hh : '%d jam',
9604        d : 'sehari',
9605        dd : '%d hari',
9606        M : 'sebulan',
9607        MM : '%d bulan',

9608        y : 'setahun',
9609        yy : '%d tahun'
9610    },
9611    week : {
9612        dow : 1, // Monday is the first day of the week.
9613        doy : 7  // The week that contains Jan 1st is the first week of the year.
9614    }
9615});
9616
9617//! moment.js locale configuration
9618//! locale : Malay [ms]
9619//! author : Weldan Jamili : https://github.com/weldan
9620
9621hooks.defineLocale('ms', {
9622    months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
9623    monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
9624    weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
9625    weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
9626    weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
9627    longDateFormat : {
9628        LT : 'HH.mm',
9629        LTS : 'HH.mm.ss',
9630        L : 'DD/MM/YYYY',
9631        LL : 'D MMMM YYYY',
9632        LLL : 'D MMMM YYYY [pukul] HH.mm',
9633        LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
9634    },
9635    meridiemParse: /pagi|tengahari|petang|malam/,
9636    meridiemHour: function (hour, meridiem) {
9637        if (hour === 12) {
9638            hour = 0;
9639        }
9640        if (meridiem === 'pagi') {
9641            return hour;
9642        } else if (meridiem === 'tengahari') {
9643            return hour >= 11 ? hour : hour + 12;
9644        } else if (meridiem === 'petang' || meridiem === 'malam') {
9645            return hour + 12;
9646        }
9647    },
9648    meridiem : function (hours, minutes, isLower) {
9649        if (hours < 11) {
9650            return 'pagi';
9651        } else if (hours < 15) {
9652            return 'tengahari';
9653        } else if (hours < 19) {
9654            return 'petang';
9655        } else {
9656            return 'malam';
9657        }
9658    },
9659    calendar : {
9660        sameDay : '[Hari ini pukul] LT',
9661        nextDay : '[Esok pukul] LT',
9662        nextWeek : 'dddd [pukul] LT',
9663        lastDay : '[Kelmarin pukul] LT',
9664        lastWeek : 'dddd [lepas pukul] LT',
9665        sameElse : 'L'
9666    },
9667    relativeTime : {
9668        future : 'dalam %s',
9669        past : '%s yang lepas',
9670        s : 'beberapa saat',
9671        m : 'seminit',
9672        mm : '%d minit',
9673        h : 'sejam',
9674        hh : '%d jam',
9675        d : 'sehari',
9676        dd : '%d hari',
9677        M : 'sebulan',
9678        MM : '%d bulan',
9679        y : 'setahun',
9680        yy : '%d tahun'
9681    },
9682    week : {
9683        dow : 1, // Monday is the first day of the week.
9684        doy : 7  // The week that contains Jan 1st is the first week of the year.
9685    }
9686});
9687
9688//! moment.js locale configuration
9689//! locale : Burmese [my]
9690//! author : Squar team, mysquar.com
9691//! author : David Rossellat : https://github.com/gholadr
9692//! author : Tin Aung Lin : https://github.com/thanyawzinmin
9693
9694var symbolMap$8 = {
9695    '1': 'á',
9696    '2': 'á',
9697    '3': 'á',
9698    '4': 'á',
9699    '5': 'á',
9700    '6': 'á',
9701    '7': 'á',
9702    '8': 'á',
9703    '9': 'á',
9704    '0': 'á'
9705};
9706var numberMap$7 = {
9707    'á': '1',
9708    'á': '2',
9709    'á': '3',
9710    'á': '4',
9711    'á': '5',
9712    'á': '6',
9713    'á': '7',
9714    'á': '8',
9715    'á': '9',
9716    'á': '0'
9717};
9718
9719hooks.defineLocale('my', {
9720    months: 'áááºááá«áá®_áá±áá±á¬áºáá«áá®_áááº_á§áá¼á®_áá±_áá½ááº_áá°ááá¯ááº_áá¼áá¯ááº_áááºáááºáá¬_á¡á±á¬ááºááá¯áá¬_ááá¯áááºáá¬_áá®áááºáá¬'.split('_'),
9721    monthsShort: 'áááº_áá±_áááº_áá¼á®_áá±_áá½ááº_ááá¯ááº_áá¼_áááº_á¡á±á¬ááº_ááá¯_áá®'.split('_'),
9722    weekdays: 'ááááºá¹ááá½á±_ááááºá¹áá¬_á¡ááºá¹áá«_áá¯áá¹ááá°á¸_áá¼á¬áááá±á¸_áá±á¬áá¼á¬_ááá±'.split('_'),
9723    weekdaysShort: 'áá½á±_áá¬_áá«_áá°á¸_áá¼á¬_áá±á¬_áá±'.split('_'),
9724    weekdaysMin: 'áá½á±_áá¬_áá«_áá°á¸_áá¼á¬_áá±á¬_áá±'.split('_'),
9725
9726    longDateFormat: {
9727        LT: 'HH:mm',
9728        LTS: 'HH:mm:ss',
9729        L: 'DD/MM/YYYY',
9730        LL: 'D MMMM YYYY',
9731        LLL: 'D MMMM YYYY HH:mm',
9732        LLLL: 'dddd D MMMM YYYY HH:mm'
9733    },
9734    calendar: {
9735        sameDay: '[ááá±.] LT [áá¾á¬]',
9736        nextDay: '[ááááºáá¼ááº] LT [áá¾á¬]',
9737        nextWeek: 'dddd LT [áá¾á¬]',
9738        lastDay: '[ááá±.á] LT [áá¾á¬]',
9739        lastWeek: '[áá¼á®á¸áá²á·áá±á¬] dddd LT [áá¾á¬]',
9740        sameElse: 'L'
9741    },
9742    relativeTime: {
9743        future: 'áá¬áááºá· %s áá¾á¬',
9744        past: 'áá½ááºáá²á·áá±á¬ %s á',

9745        s: 'ááá¹áááº.á¡áááºá¸áááº',
9746        m: 'áááºáááááº',
9747        mm: '%d áááááº',
9748        h: 'áááºáá¬áá®',
9749        hh: '%d áá¬áá®',
9750        d: 'áááºáááº',
9751        dd: '%d áááº',
9752        M: 'áááºá',
9753        MM: '%d á',
9754        y: 'áááºáá¾ááº',
9755        yy: '%d áá¾ááº'
9756    },
9757    preparse: function (string) {
9758        return string.replace(/[áááááááááá]/g, function (match) {
9759            return numberMap$7[match];
9760        });
9761    },
9762    postformat: function (string) {
9763        return string.replace(/\d/g, function (match) {
9764            return symbolMap$8[match];
9765        });
9766    },
9767    week: {
9768        dow: 1, // Monday is the first day of the week.
9769        doy: 4 // The week that contains Jan 1st is the first week of the year.
9770    }
9771});
9772
9773//! moment.js locale configuration
9774//! locale : Norwegian BokmÃ¥l [nb]
9775//! authors : Espen Hovlandsdal : https://github.com/rexxars
9776//!           Sigurd Gartmann : https://github.com/sigurdga
9777
9778hooks.defineLocale('nb', {
9779    months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
9780    monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
9781    monthsParseExact : true,
9782    weekdays : 'sÃ¸ndag_mandag_tirsdag_onsdag_torsdag_fredag_lÃ¸rdag'.split('_'),
9783    weekdaysShort : 'sÃ¸._ma._ti._on._to._fr._lÃ¸.'.split('_'),
9784    weekdaysMin : 'sÃ¸_ma_ti_on_to_fr_lÃ¸'.split('_'),
9785    weekdaysParseExact : true,
9786    longDateFormat : {
9787        LT : 'HH:mm',
9788        LTS : 'HH:mm:ss',
9789        L : 'DD.MM.YYYY',
9790        LL : 'D. MMMM YYYY',
9791        LLL : 'D. MMMM YYYY [kl.] HH:mm',
9792        LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
9793    },
9794    calendar : {
9795        sameDay: '[i dag kl.] LT',
9796        nextDay: '[i morgen kl.] LT',
9797        nextWeek: 'dddd [kl.] LT',
9798        lastDay: '[i gÃ¥r kl.] LT',
9799        lastWeek: '[forrige] dddd [kl.] LT',
9800        sameElse: 'L'
9801    },
9802    relativeTime : {
9803        future : 'om %s',
9804        past : '%s siden',
9805        s : 'noen sekunder',
9806        m : 'ett minutt',
9807        mm : '%d minutter',
9808        h : 'en time',
9809        hh : '%d timer',
9810        d : 'en dag',
9811        dd : '%d dager',
9812        M : 'en mÃ¥ned',
9813        MM : '%d mÃ¥neder',
9814        y : 'ett Ã¥r',
9815        yy : '%d Ã¥r'
9816    },
9817    ordinalParse: /\d{1,2}\./,
9818    ordinal : '%d.',
9819    week : {
9820        dow : 1, // Monday is the first day of the week.
9821        doy : 4  // The week that contains Jan 4th is the first week of the year.
9822    }
9823});
9824
9825//! moment.js locale configuration
9826//! locale : Nepalese [ne]
9827//! author : suvash : https://github.com/suvash
9828
9829var symbolMap$9 = {
9830    '1': 'à¥§',
9831    '2': 'à¥¨',
9832    '3': 'à¥©',
9833    '4': 'à¥ª',
9834    '5': 'à¥«',
9835    '6': 'à¥¬',
9836    '7': 'à¥',
9837    '8': 'à¥®',
9838    '9': 'à¥¯',
9839    '0': 'à¥¦'
9840};
9841var numberMap$8 = {
9842    'à¥§': '1',
9843    'à¥¨': '2',
9844    'à¥©': '3',
9845    'à¥ª': '4',
9846    'à¥«': '5',
9847    'à¥¬': '6',
9848    'à¥': '7',
9849    'à¥®': '8',
9850    'à¥¯': '9',
9851    'à¥¦': '0'
9852};
9853
9854hooks.defineLocale('ne', {
9855    months : 'à¤à¤¨à¤µà¤°à¥_à¤«à¥à¤¬à¥à¤°à¥à¤µà¤°à¥_à¤®à¤¾à¤°à¥à¤_à¤à¤ªà¥à¤°à¤¿à¤²_à¤®à¤_à¤à¥à¤¨_à¤à¥à¤²à¤¾à¤_à¤à¤à¤·à¥à¤_à¤¸à¥à¤ªà¥à¤à¥à¤®à¥à¤¬à¤°_à¤à¤à¥à¤à¥à¤¬à¤°_à¤¨à¥à¤à¥à¤®à¥à¤¬à¤°_à¤¡à¤¿à¤¸à¥à¤®à¥à¤¬à¤°'.split('_'),
9856    monthsShort : 'à¤à¤¨._à¤«à¥à¤¬à¥à¤°à¥._à¤®à¤¾à¤°à¥à¤_à¤à¤ªà¥à¤°à¤¿._à¤®à¤_à¤à¥à¤¨_à¤à¥à¤²à¤¾à¤._à¤à¤._à¤¸à¥à¤ªà¥à¤._à¤à¤à¥à¤à¥._à¤¨à¥à¤à¥._à¤¡à¤¿à¤¸à¥.'.split('_'),
9857    monthsParseExact : true,
9858    weekdays : 'à¤à¤à¤¤à¤¬à¤¾à¤°_à¤¸à¥à¤®à¤¬à¤¾à¤°_à¤®à¤à¥à¤à¤²à¤¬à¤¾à¤°_à¤¬à¥à¤§à¤¬à¤¾à¤°_à¤¬à¤¿à¤¹à¤¿à¤¬à¤¾à¤°_à¤¶à¥à¤à¥à¤°à¤¬à¤¾à¤°_à¤¶à¤¨à¤¿à¤¬à¤¾à¤°'.split('_'),
9859    weekdaysShort : 'à¤à¤à¤¤._à¤¸à¥à¤®._à¤®à¤à¥à¤à¤²._à¤¬à¥à¤§._à¤¬à¤¿à¤¹à¤¿._à¤¶à¥à¤à¥à¤°._à¤¶à¤¨à¤¿.'.split('_'),
9860    weekdaysMin : 'à¤._à¤¸à¥._à¤®à¤._à¤¬à¥._à¤¬à¤¿._à¤¶à¥._à¤¶.'.split('_'),
9861    weekdaysParseExact : true,
9862    longDateFormat : {
9863        LT : 'Aà¤à¥ h:mm à¤¬à¤à¥',
9864        LTS : 'Aà¤à¥ h:mm:ss à¤¬à¤à¥',
9865        L : 'DD/MM/YYYY',
9866        LL : 'D MMMM YYYY',
9867        LLL : 'D MMMM YYYY, Aà¤à¥ h:mm à¤¬à¤à¥',
9868        LLLL : 'dddd, D MMMM YYYY, Aà¤à¥ h:mm à¤¬à¤à¥'
9869    },
9870    preparse: function (string) {
9871        return string.replace(/[à¥§à¥¨à¥©à¥ªà¥«à¥¬à¥à¥®à¥¯à¥¦]/g, function (match) {
9872            return numberMap$8[match];
9873        });
9874    },
9875    postformat: function (string) {
9876        return string.replace(/\d/g, function (match) {
9877            return symbolMap$9[match];
9878        });
9879    },

9880    meridiemParse: /à¤°à¤¾à¤¤à¤¿|à¤¬à¤¿à¤¹à¤¾à¤¨|à¤¦à¤¿à¤à¤à¤¸à¥|à¤¸à¤¾à¤à¤/,
9881    meridiemHour : function (hour, meridiem) {
9882        if (hour === 12) {
9883            hour = 0;
9884        }
9885        if (meridiem === 'à¤°à¤¾à¤¤à¤¿') {
9886            return hour < 4 ? hour : hour + 12;
9887        } else if (meridiem === 'à¤¬à¤¿à¤¹à¤¾à¤¨') {
9888            return hour;
9889        } else if (meridiem === 'à¤¦à¤¿à¤à¤à¤¸à¥') {
9890            return hour >= 10 ? hour : hour + 12;
9891        } else if (meridiem === 'à¤¸à¤¾à¤à¤') {
9892            return hour + 12;
9893        }
9894    },
9895    meridiem : function (hour, minute, isLower) {
9896        if (hour < 3) {
9897            return 'à¤°à¤¾à¤¤à¤¿';
9898        } else if (hour < 12) {
9899            return 'à¤¬à¤¿à¤¹à¤¾à¤¨';
9900        } else if (hour < 16) {
9901            return 'à¤¦à¤¿à¤à¤à¤¸à¥';
9902        } else if (hour < 20) {
9903            return 'à¤¸à¤¾à¤à¤';
9904        } else {
9905            return 'à¤°à¤¾à¤¤à¤¿';
9906        }
9907    },
9908    calendar : {
9909        sameDay : '[à¤à¤] LT',
9910        nextDay : '[à¤à¥à¤²à¤¿] LT',
9911        nextWeek : '[à¤à¤à¤à¤¦à¥] dddd[,] LT',
9912        lastDay : '[à¤¹à¤¿à¤à¥] LT',
9913        lastWeek : '[à¤à¤à¤à¥] dddd[,] LT',
9914        sameElse : 'L'
9915    },
9916    relativeTime : {
9917        future : '%sà¤®à¤¾',
9918        past : '%s à¤à¤à¤¾à¤¡à¤¿',
9919        s : 'à¤à¥à¤¹à¥ à¤à¥à¤·à¤£',
9920        m : 'à¤à¤ à¤®à¤¿à¤¨à¥à¤',
9921        mm : '%d à¤®à¤¿à¤¨à¥à¤',
9922        h : 'à¤à¤ à¤à¤£à¥à¤à¤¾',
9923        hh : '%d à¤à¤£à¥à¤à¤¾',
9924        d : 'à¤à¤ à¤¦à¤¿à¤¨',
9925        dd : '%d à¤¦à¤¿à¤¨',
9926        M : 'à¤à¤ à¤®à¤¹à¤¿à¤¨à¤¾',
9927        MM : '%d à¤®à¤¹à¤¿à¤¨à¤¾',
9928        y : 'à¤à¤ à¤¬à¤°à¥à¤·',
9929        yy : '%d à¤¬à¤°à¥à¤·'
9930    },
9931    week : {
9932        dow : 0, // Sunday is the first day of the week.
9933        doy : 6  // The week that contains Jan 1st is the first week of the year.
9934    }
9935});
9936
9937//! moment.js locale configuration
9938//! locale : Dutch (Belgium) [nl-be]
9939//! author : Joris RÃ¶ling : https://github.com/jorisroling
9940//! author : Jacob Middag : https://github.com/middagj
9941
9942var monthsShortWithDots$1 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_');
9943var monthsShortWithoutDots$1 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
9944
9945var monthsParse = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
9946var monthsRegex$1 = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
9947
9948hooks.defineLocale('nl-be', {
9949    months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
9950    monthsShort : function (m, format) {
9951        if (/-MMM-/.test(format)) {
9952            return monthsShortWithoutDots$1[m.month()];
9953        } else {
9954            return monthsShortWithDots$1[m.month()];
9955        }
9956    },
9957
9958    monthsRegex: monthsRegex$1,
9959    monthsShortRegex: monthsRegex$1,
9960    monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
9961    monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
9962
9963    monthsParse : monthsParse,
9964    longMonthsParse : monthsParse,
9965    shortMonthsParse : monthsParse,
9966
9967    weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
9968    weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
9969    weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
9970    weekdaysParseExact : true,
9971    longDateFormat : {
9972        LT : 'HH:mm',
9973        LTS : 'HH:mm:ss',
9974        L : 'DD/MM/YYYY',
9975        LL : 'D MMMM YYYY',
9976        LLL : 'D MMMM YYYY HH:mm',
9977        LLLL : 'dddd D MMMM YYYY HH:mm'
9978    },
9979    calendar : {
9980        sameDay: '[vandaag om] LT',
9981        nextDay: '[morgen om] LT',
9982        nextWeek: 'dddd [om] LT',
9983        lastDay: '[gisteren om] LT',
9984        lastWeek: '[afgelopen] dddd [om] LT',
9985        sameElse: 'L'
9986    },
9987    relativeTime : {
9988        future : 'over %s',
9989        past : '%s geleden',
9990        s : 'een paar seconden',
9991        m : 'Ã©Ã©n minuut',
9992        mm : '%d minuten',
9993        h : 'Ã©Ã©n uur',
9994        hh : '%d uur',
9995        d : 'Ã©Ã©n dag',
9996        dd : '%d dagen',
9997        M : 'Ã©Ã©n maand',
9998        MM : '%d maanden',

9999        y : 'Ã©Ã©n jaar',
10000        yy : '%d jaar'
10001    },
10002    ordinalParse: /\d{1,2}(ste|de)/,
10003    ordinal : function (number) {
10004        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
10005    },
10006    week : {
10007        dow : 1, // Monday is the first day of the week.
10008        doy : 4  // The week that contains Jan 4th is the first week of the year.
10009    }
10010});
10011
10012//! moment.js locale configuration
10013//! locale : Dutch [nl]
10014//! author : Joris RÃ¶ling : https://github.com/jorisroling
10015//! author : Jacob Middag : https://github.com/middagj
10016
10017var monthsShortWithDots$2 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_');
10018var monthsShortWithoutDots$2 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
10019
10020var monthsParse$1 = [/^jan/i, /^feb/i, /^maart|mrt.?$/i, /^apr/i, /^mei$/i, /^jun[i.]?$/i, /^jul[i.]?$/i, /^aug/i, /^sep/i, /^okt/i, /^nov/i, /^dec/i];
10021var monthsRegex$2 = /^(januari|februari|maart|april|mei|april|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
10022
10023hooks.defineLocale('nl', {
10024    months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
10025    monthsShort : function (m, format) {
10026        if (/-MMM-/.test(format)) {
10027            return monthsShortWithoutDots$2[m.month()];
10028        } else {
10029            return monthsShortWithDots$2[m.month()];
10030        }
10031    },
10032
10033    monthsRegex: monthsRegex$2,
10034    monthsShortRegex: monthsRegex$2,
10035    monthsStrictRegex: /^(januari|februari|maart|mei|ju[nl]i|april|augustus|september|oktober|november|december)/i,
10036    monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
10037
10038    monthsParse : monthsParse$1,
10039    longMonthsParse : monthsParse$1,
10040    shortMonthsParse : monthsParse$1,
10041
10042    weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
10043    weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
10044    weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
10045    weekdaysParseExact : true,
10046    longDateFormat : {
10047        LT : 'HH:mm',
10048        LTS : 'HH:mm:ss',
10049        L : 'DD-MM-YYYY',
10050        LL : 'D MMMM YYYY',
10051        LLL : 'D MMMM YYYY HH:mm',
10052        LLLL : 'dddd D MMMM YYYY HH:mm'
10053    },
10054    calendar : {
10055        sameDay: '[vandaag om] LT',
10056        nextDay: '[morgen om] LT',
10057        nextWeek: 'dddd [om] LT',
10058        lastDay: '[gisteren om] LT',
10059        lastWeek: '[afgelopen] dddd [om] LT',
10060        sameElse: 'L'
10061    },
10062    relativeTime : {
10063        future : 'over %s',
10064        past : '%s geleden',
10065        s : 'een paar seconden',
10066        m : 'Ã©Ã©n minuut',
10067        mm : '%d minuten',
10068        h : 'Ã©Ã©n uur',
10069        hh : '%d uur',
10070        d : 'Ã©Ã©n dag',
10071        dd : '%d dagen',
10072        M : 'Ã©Ã©n maand',
10073        MM : '%d maanden',
10074        y : 'Ã©Ã©n jaar',
10075        yy : '%d jaar'
10076    },
10077    ordinalParse: /\d{1,2}(ste|de)/,
10078    ordinal : function (number) {
10079        return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
10080    },
10081    week : {
10082        dow : 1, // Monday is the first day of the week.
10083        doy : 4  // The week that contains Jan 4th is the first week of the year.
10084    }
10085});
10086
10087//! moment.js locale configuration
10088//! locale : Nynorsk [nn]
10089//! author : https://github.com/mechuwind
10090
10091hooks.defineLocale('nn', {
10092    months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
10093    monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
10094    weekdays : 'sundag_mÃ¥ndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
10095    weekdaysShort : 'sun_mÃ¥n_tys_ons_tor_fre_lau'.split('_'),
10096    weekdaysMin : 'su_mÃ¥_ty_on_to_fr_lÃ¸'.split('_'),
10097    longDateFormat : {
10098        LT : 'HH:mm',
10099        LTS : 'HH:mm:ss',
10100        L : 'DD.MM.YYYY',
10101        LL : 'D. MMMM YYYY',
10102        LLL : 'D. MMMM YYYY [kl.] H:mm',
10103        LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
10104    },
10105    calendar : {
10106        sameDay: '[I dag klokka] LT',
10107        nextDay: '[I morgon klokka] LT',
10108        nextWeek: 'dddd [klokka] LT',
10109        lastDay: '[I gÃ¥r klokka] LT',
10110        lastWeek: '[FÃ¸regÃ¥ande] dddd [klokka] LT',
10111        sameElse: 'L'
10112    },
10113    relativeTime : {
10114        future : 'om %s',
10115        past : '%s sidan',
10116        s : 'nokre sekund',
10117        m : 'eit minutt',
10118        mm : '%d minutt',
10119        h : 'ein time',
10120        hh : '%d timar',
10121        d : 'ein dag',
10122        dd : '%d dagar',
10123        M : 'ein mÃ¥nad',
10124        MM : '%d mÃ¥nader',
10125        y : 'eit Ã¥r',
10126        yy : '%d Ã¥r'
10127    },
10128    ordinalParse: /\d{1,2}\./,
10129    ordinal : '%d.',
10130    week : {
10131        dow : 1, // Monday is the first day of the week.
10132        doy : 4  // The week that contains Jan 4th is the first week of the year.
10133    }
10134});
10135
10136//! moment.js locale configuration
10137//! locale : Punjabi (India) [pa-in]
10138//! author : Harpreet Singh : https://github.com/harpreetkhalsagtbit
10139

10140var symbolMap$10 = {
10141    '1': 'à©§',
10142    '2': 'à©¨',
10143    '3': 'à©©',
10144    '4': 'à©ª',
10145    '5': 'à©«',
10146    '6': 'à©¬',
10147    '7': 'à©',
10148    '8': 'à©®',
10149    '9': 'à©¯',
10150    '0': 'à©¦'
10151};
10152var numberMap$9 = {
10153    'à©§': '1',
10154    'à©¨': '2',
10155    'à©©': '3',
10156    'à©ª': '4',
10157    'à©«': '5',
10158    'à©¬': '6',
10159    'à©': '7',
10160    'à©®': '8',
10161    'à©¯': '9',
10162    'à©¦': '0'
10163};
10164
10165hooks.defineLocale('pa-in', {
10166    // There are months name as per Nanakshahi Calender but they are not used as rigidly in modern Punjabi.
10167    months : 'à¨à¨¨à¨µà¨°à©_à¨«à¨¼à¨°à¨µà¨°à©_à¨®à¨¾à¨°à¨_à¨à¨ªà©à¨°à©à¨²_à¨®à¨_à¨à©à¨¨_à¨à©à¨²à¨¾à¨_à¨à¨à¨¸à¨¤_à¨¸à¨¤à©°à¨¬à¨°_à¨à¨à¨¤à©à¨¬à¨°_à¨¨à¨µà©°à¨¬à¨°_à¨¦à¨¸à©°à¨¬à¨°'.split('_'),
10168    monthsShort : 'à¨à¨¨à¨µà¨°à©_à¨«à¨¼à¨°à¨µà¨°à©_à¨®à¨¾à¨°à¨_à¨à¨ªà©à¨°à©à¨²_à¨®à¨_à¨à©à¨¨_à¨à©à¨²à¨¾à¨_à¨à¨à¨¸à¨¤_à¨¸à¨¤à©°à¨¬à¨°_à¨à¨à¨¤à©à¨¬à¨°_à¨¨à¨µà©°à¨¬à¨°_à¨¦à¨¸à©°à¨¬à¨°'.split('_'),
10169    weekdays : 'à¨à¨¤à¨µà¨¾à¨°_à¨¸à©à¨®à¨µà¨¾à¨°_à¨®à©°à¨à¨²à¨µà¨¾à¨°_à¨¬à©à¨§à¨µà¨¾à¨°_à¨µà©à¨°à¨µà¨¾à¨°_à¨¸à¨¼à©à©±à¨à¨°à¨µà¨¾à¨°_à¨¸à¨¼à¨¨à©à¨à¨°à¨µà¨¾à¨°'.split('_'),
10170    weekdaysShort : 'à¨à¨¤_à¨¸à©à¨®_à¨®à©°à¨à¨²_à¨¬à©à¨§_à¨µà©à¨°_à¨¸à¨¼à©à¨à¨°_à¨¸à¨¼à¨¨à©'.split('_'),
10171    weekdaysMin : 'à¨à¨¤_à¨¸à©à¨®_à¨®à©°à¨à¨²_à¨¬à©à¨§_à¨µà©à¨°_à¨¸à¨¼à©à¨à¨°_à¨¸à¨¼à¨¨à©'.split('_'),
10172    longDateFormat : {
10173        LT : 'A h:mm à¨µà¨à©',
10174        LTS : 'A h:mm:ss à¨µà¨à©',
10175        L : 'DD/MM/YYYY',
10176        LL : 'D MMMM YYYY',
10177        LLL : 'D MMMM YYYY, A h:mm à¨µà¨à©',
10178        LLLL : 'dddd, D MMMM YYYY, A h:mm à¨µà¨à©'
10179    },
10180    calendar : {
10181        sameDay : '[à¨à¨] LT',
10182        nextDay : '[à¨à¨²] LT',
10183        nextWeek : 'dddd, LT',
10184        lastDay : '[à¨à¨²] LT',
10185        lastWeek : '[à¨ªà¨¿à¨à¨²à©] dddd, LT',
10186        sameElse : 'L'
10187    },
10188    relativeTime : {
10189        future : '%s à¨µà¨¿à©±à¨',
10190        past : '%s à¨ªà¨¿à¨à¨²à©',
10191        s : 'à¨à©à¨ à¨¸à¨à¨¿à©°à¨',
10192        m : 'à¨à¨ à¨®à¨¿à©°à¨',
10193        mm : '%d à¨®à¨¿à©°à¨',
10194        h : 'à¨à©±à¨ à¨à©°à¨à¨¾',
10195        hh : '%d à¨à©°à¨à©',
10196        d : 'à¨à©±à¨ à¨¦à¨¿à¨¨',
10197        dd : '%d à¨¦à¨¿à¨¨',
10198        M : 'à¨à©±à¨ à¨®à¨¹à©à¨¨à¨¾',
10199        MM : '%d à¨®à¨¹à©à¨¨à©',
10200        y : 'à¨à©±à¨ à¨¸à¨¾à¨²',
10201        yy : '%d à¨¸à¨¾à¨²'
10202    },
10203    preparse: function (string) {
10204        return string.replace(/[à©§à©¨à©©à©ªà©«à©¬à©à©®à©¯à©¦]/g, function (match) {
10205            return numberMap$9[match];
10206        });
10207    },
10208    postformat: function (string) {
10209        return string.replace(/\d/g, function (match) {
10210            return symbolMap$10[match];
10211        });
10212    },
10213    // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
10214    // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
10215    meridiemParse: /à¨°à¨¾à¨¤|à¨¸à¨µà©à¨°|à¨¦à©à¨ªà¨¹à¨¿à¨°|à¨¸à¨¼à¨¾à¨®/,
10216    meridiemHour : function (hour, meridiem) {
10217        if (hour === 12) {
10218            hour = 0;
10219        }
10220        if (meridiem === 'à¨°à¨¾à¨¤') {
10221            return hour < 4 ? hour : hour + 12;
10222        } else if (meridiem === 'à¨¸à¨µà©à¨°') {
10223            return hour;
10224        } else if (meridiem === 'à¨¦à©à¨ªà¨¹à¨¿à¨°') {
10225            return hour >= 10 ? hour : hour + 12;
10226        } else if (meridiem === 'à¨¸à¨¼à¨¾à¨®') {
10227            return hour + 12;
10228        }
10229    },
10230    meridiem : function (hour, minute, isLower) {
10231        if (hour < 4) {
10232            return 'à¨°à¨¾à¨¤';
10233        } else if (hour < 10) {
10234            return 'à¨¸à¨µà©à¨°';
10235        } else if (hour < 17) {
10236            return 'à¨¦à©à¨ªà¨¹à¨¿à¨°';
10237        } else if (hour < 20) {
10238            return 'à¨¸à¨¼à¨¾à¨®';
10239        } else {
10240            return 'à¨°à¨¾à¨¤';
10241        }
10242    },
10243    week : {
10244        dow : 0, // Sunday is the first day of the week.
10245        doy : 6  // The week that contains Jan 1st is the first week of the year.
10246    }
10247});
10248
10249//! moment.js locale configuration
10250//! locale : Polish [pl]
10251//! author : Rafal Hirsz : https://github.com/evoL
10252
10253var monthsNominative = 'styczeÅ_luty_marzec_kwiecieÅ_maj_czerwiec_lipiec_sierpieÅ_wrzesieÅ_paÅºdziernik_listopad_grudzieÅ'.split('_');
10254var monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_wrzeÅnia_paÅºdziernika_listopada_grudnia'.split('_');
10255function plural$3(n) {
10256    return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);
10257}
10258function translate$7(number, withoutSuffix, key) {
10259    var result = number + ' ';
10260    switch (key) {
10261        case 'm':
10262            return withoutSuffix ? 'minuta' : 'minutÄ';
10263        case 'mm':
10264            return result + (plural$3(number) ? 'minuty' : 'minut');
10265        case 'h':
10266            return withoutSuffix  ? 'godzina'  : 'godzinÄ';
10267        case 'hh':
10268            return result + (plural$3(number) ? 'godziny' : 'godzin');
10269        case 'MM':
10270            return result + (plural$3(number) ? 'miesiÄce' : 'miesiÄcy');
10271        case 'yy':
10272            return result + (plural$3(number) ? 'lata' : 'lat');
10273    }
10274}
10275
10276hooks.defineLocale('pl', {
10277    months : function (momentToFormat, format) {
10278        if (format === '') {
10279            // Hack: if format empty we know this is used to generate
10280            // RegExp by moment. Give then back both valid forms of months
10281            // in RegExp ready format.
10282            return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')';
10283        } else if (/D MMMM/.test(format)) {
10284            return monthsSubjective[momentToFormat.month()];
10285        } else {
10286            return monthsNominative[momentToFormat.month()];
10287        }
10288    },
10289    monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paÅº_lis_gru'.split('_'),
10290    weekdays : 'niedziela_poniedziaÅek_wtorek_Åroda_czwartek_piÄtek_sobota'.split('_'),
10291    weekdaysShort : 'ndz_pon_wt_År_czw_pt_sob'.split('_'),
10292    weekdaysMin : 'Nd_Pn_Wt_År_Cz_Pt_So'.split('_'),
10293    longDateFormat : {
10294        LT : 'HH:mm',
10295        LTS : 'HH:mm:ss',
10296        L : 'DD.MM.YYYY',
10297        LL : 'D MMMM YYYY',
10298        LLL : 'D MMMM YYYY HH:mm',
10299        LLLL : 'dddd, D MMMM YYYY HH:mm'
10300    },
10301    calendar : {
10302        sameDay: '[DziÅ o] LT',
10303        nextDay: '[Jutro o] LT',
10304        nextWeek: '[W] dddd [o] LT',
10305        lastDay: '[Wczoraj o] LT',
10306        lastWeek: function () {
10307            switch (this.day()) {
10308                case 0:
10309                    return '[W zeszÅÄ niedzielÄ o] LT';
10310                case 3:
10311                    return '[W zeszÅÄ ÅrodÄ o] LT';
10312                case 6:
10313                    return '[W zeszÅÄ sobotÄ o] LT';
10314                default:
10315                    return '[W zeszÅy] dddd [o] LT';
10316            }
10317        },
10318        sameElse: 'L'
10319    },
10320    relativeTime : {
10321        future : 'za %s',
10322        past : '%s temu',
10323        s : 'kilka sekund',
10324        m : translate$7,
10325        mm : translate$7,
10326        h : translate$7,
10327        hh : translate$7,
10328        d : '1 dzieÅ',
10329        dd : '%d dni',
10330        M : 'miesiÄc',
10331        MM : translate$7,
10332        y : 'rok',
10333        yy : translate$7
10334    },
10335    ordinalParse: /\d{1,2}\./,
10336    ordinal : '%d.',
10337    week : {
10338        dow : 1, // Monday is the first day of the week.
10339        doy : 4  // The week that contains Jan 4th is the first week of the year.
10340    }
10341});
10342
10343//! moment.js locale configuration
10344//! locale : Portuguese (Brazil) [pt-br]
10345//! author : Caio Ribeiro Pereira : https://github.com/caio-ribeiro-pereira
10346
10347hooks.defineLocale('pt-br', {
10348    months : 'Janeiro_Fevereiro_MarÃ§o_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
10349    monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
10350    weekdays : 'Domingo_Segunda-feira_TerÃ§a-feira_Quarta-feira_Quinta-feira_Sexta-feira_SÃ¡bado'.split('_'),
10351    weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_SÃ¡b'.split('_'),
10352    weekdaysMin : 'Dom_2Âª_3Âª_4Âª_5Âª_6Âª_SÃ¡b'.split('_'),
10353    weekdaysParseExact : true,
10354    longDateFormat : {
10355        LT : 'HH:mm',
10356        LTS : 'HH:mm:ss',
10357        L : 'DD/MM/YYYY',
10358        LL : 'D [de] MMMM [de] YYYY',
10359        LLL : 'D [de] MMMM [de] YYYY [Ã s] HH:mm',
10360        LLLL : 'dddd, D [de] MMMM [de] YYYY [Ã s] HH:mm'
10361    },
10362    calendar : {
10363        sameDay: '[Hoje Ã s] LT',
10364        nextDay: '[AmanhÃ£ Ã s] LT',
10365        nextWeek: 'dddd [Ã s] LT',
10366        lastDay: '[Ontem Ã s] LT',
10367        lastWeek: function () {
10368            return (this.day() === 0 || this.day() === 6) ?
10369                '[Ãltimo] dddd [Ã s] LT' : // Saturday + Sunday
10370                '[Ãltima] dddd [Ã s] LT'; // Monday - Friday
10371        },
10372        sameElse: 'L'
10373    },
10374    relativeTime : {
10375        future : 'em %s',
10376        past : '%s atrÃ¡s',
10377        s : 'poucos segundos',
10378        m : 'um minuto',
10379        mm : '%d minutos',
10380        h : 'uma hora',
10381        hh : '%d horas',
10382        d : 'um dia',
10383        dd : '%d dias',
10384        M : 'um mÃªs',
10385        MM : '%d meses',
10386        y : 'um ano',
10387        yy : '%d anos'
10388    },
10389    ordinalParse: /\d{1,2}Âº/,
10390    ordinal : '%dÂº'
10391});
10392
10393//! moment.js locale configuration
10394//! locale : Portuguese [pt]
10395//! author : Jefferson : https://github.com/jalex79
10396
10397hooks.defineLocale('pt', {
10398    months : 'Janeiro_Fevereiro_MarÃ§o_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
10399    monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
10400    weekdays : 'Domingo_Segunda-Feira_TerÃ§a-Feira_Quarta-Feira_Quinta-Feira_Sexta-Feira_SÃ¡bado'.split('_'),
10401    weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_SÃ¡b'.split('_'),
10402    weekdaysMin : 'Dom_2Âª_3Âª_4Âª_5Âª_6Âª_SÃ¡b'.split('_'),
10403    weekdaysParseExact : true,
10404    longDateFormat : {
10405        LT : 'HH:mm',
10406        LTS : 'HH:mm:ss',
10407        L : 'DD/MM/YYYY',
10408        LL : 'D [de] MMMM [de] YYYY',
10409        LLL : 'D [de] MMMM [de] YYYY HH:mm',
10410        LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm'
10411    },
10412    calendar : {
10413        sameDay: '[Hoje Ã s] LT',
10414        nextDay: '[AmanhÃ£ Ã s] LT',
10415        nextWeek: 'dddd [Ã s] LT',
10416        lastDay: '[Ontem Ã s] LT',
10417        lastWeek: function () {
10418            return (this.day() === 0 || this.day() === 6) ?
10419                '[Ãltimo] dddd [Ã s] LT' : // Saturday + Sunday
10420                '[Ãltima] dddd [Ã s] LT'; // Monday - Friday
10421        },
10422        sameElse: 'L'
10423    },
10424    relativeTime : {
10425        future : 'em %s',
10426        past : 'hÃ¡ %s',
10427        s : 'segundos',
10428        m : 'um minuto',
10429        mm : '%d minutos',
10430        h : 'uma hora',
10431        hh : '%d horas',
10432        d : 'um dia',
10433        dd : '%d dias',
10434        M : 'um mÃªs',
10435        MM : '%d meses',
10436        y : 'um ano',
10437        yy : '%d anos'
10438    },
10439    ordinalParse: /\d{1,2}Âº/,
10440    ordinal : '%dÂº',
10441    week : {
10442        dow : 1, // Monday is the first day of the week.
10443        doy : 4  // The week that contains Jan 4th is the first week of the year.
10444    }
10445});
10446
10447//! moment.js locale configuration
10448//! locale : Romanian [ro]
10449//! author : Vlad Gurdiga : https://github.com/gurdiga
10450//! author : Valentin Agachi : https://github.com/avaly
10451
10452function relativeTimeWithPlural$2(number, withoutSuffix, key) {
10453    var format = {
10454            'mm': 'minute',
10455            'hh': 'ore',
10456            'dd': 'zile',
10457            'MM': 'luni',
10458            'yy': 'ani'
10459        },
10460        separator = ' ';
10461    if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
10462        separator = ' de ';
10463    }
10464    return number + separator + format[key];
10465}
10466
10467hooks.defineLocale('ro', {
10468    months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
10469    monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
10470    monthsParseExact: true,
10471    weekdays : 'duminicÄ_luni_marÈi_miercuri_joi_vineri_sÃ¢mbÄtÄ'.split('_'),
10472    weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_SÃ¢m'.split('_'),
10473    weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_SÃ¢'.split('_'),
10474    longDateFormat : {
10475        LT : 'H:mm',
10476        LTS : 'H:mm:ss',
10477        L : 'DD.MM.YYYY',
10478        LL : 'D MMMM YYYY',
10479        LLL : 'D MMMM YYYY H:mm',
10480        LLLL : 'dddd, D MMMM YYYY H:mm'
10481    },
10482    calendar : {
10483        sameDay: '[azi la] LT',
10484        nextDay: '[mÃ¢ine la] LT',
10485        nextWeek: 'dddd [la] LT',
10486        lastDay: '[ieri la] LT',
10487        lastWeek: '[fosta] dddd [la] LT',
10488        sameElse: 'L'
10489    },
10490    relativeTime : {
10491        future : 'peste %s',
10492        past : '%s Ã®n urmÄ',
10493        s : 'cÃ¢teva secunde',
10494        m : 'un minut',
10495        mm : relativeTimeWithPlural$2,
10496        h : 'o orÄ',
10497        hh : relativeTimeWithPlural$2,
10498        d : 'o zi',
10499        dd : relativeTimeWithPlural$2,
10500        M : 'o lunÄ',
10501        MM : relativeTimeWithPlural$2,
10502        y : 'un an',
10503        yy : relativeTimeWithPlural$2
10504    },
10505    week : {
10506        dow : 1, // Monday is the first day of the week.
10507        doy : 7  // The week that contains Jan 1st is the first week of the year.
10508    }
10509});
10510
10511//! moment.js locale configuration
10512//! locale : Russian [ru]
10513//! author : Viktorminator : https://github.com/Viktorminator
10514//! Author : Menelion ElensÃºle : https://github.com/Oire
10515//! author : ÐÐ¾ÑÐµÐ½Ð±ÐµÑÐ³ ÐÐ°ÑÐº : https://github.com/socketpair
10516
10517function plural$4(word, num) {
10518    var forms = word.split('_');
10519    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]);
10520}
10521function relativeTimeWithPlural$3(number, withoutSuffix, key) {
10522    var format = {
10523        'mm': withoutSuffix ? 'Ð¼Ð¸Ð½ÑÑÐ°_Ð¼Ð¸Ð½ÑÑÑ_Ð¼Ð¸Ð½ÑÑ' : 'Ð¼Ð¸Ð½ÑÑÑ_Ð¼Ð¸Ð½ÑÑÑ_Ð¼Ð¸Ð½ÑÑ',
10524        'hh': 'ÑÐ°Ñ_ÑÐ°ÑÐ°_ÑÐ°ÑÐ¾Ð²',
10525        'dd': 'Ð´ÐµÐ½Ñ_Ð´Ð½Ñ_Ð´Ð½ÐµÐ¹',
10526        'MM': 'Ð¼ÐµÑÑÑ_Ð¼ÐµÑÑÑÐ°_Ð¼ÐµÑÑÑÐµÐ²',
10527        'yy': 'Ð³Ð¾Ð´_Ð³Ð¾Ð´Ð°_Ð»ÐµÑ'
10528    };
10529    if (key === 'm') {
10530        return withoutSuffix ? 'Ð¼Ð¸Ð½ÑÑÐ°' : 'Ð¼Ð¸Ð½ÑÑÑ';
10531    }
10532    else {

vendor: 8,748 bytes, lines 10533-10736

10533        return number + ' ' + plural$4(format[key], +number);
10534    }
10535}
10536var monthsParse$2 = [/^ÑÐ½Ð²/i, /^ÑÐµÐ²/i, /^Ð¼Ð°Ñ/i, /^Ð°Ð¿Ñ/i, /^Ð¼Ð°[Ð¹Ñ]/i, /^Ð¸ÑÐ½/i, /^Ð¸ÑÐ»/i, /^Ð°Ð²Ð³/i, /^ÑÐµÐ½/i, /^Ð¾ÐºÑ/i, /^Ð½Ð¾Ñ/i, /^Ð´ÐµÐº/i];
10537
10538// http://new.gramota.ru/spravka/rules/139-prop : Â§ 103
10539// Ð¡Ð¾ÐºÑÐ°ÑÐµÐ½Ð¸Ñ Ð¼ÐµÑÑÑÐµÐ²: http://new.gramota.ru/spravka/buro/search-answer?s=242637
10540// CLDR data:          http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
10541hooks.defineLocale('ru', {
10542    months : {
10543        format: 'ÑÐ½Ð²Ð°ÑÑ_ÑÐµÐ²ÑÐ°Ð»Ñ_Ð¼Ð°ÑÑÐ°_Ð°Ð¿ÑÐµÐ»Ñ_Ð¼Ð°Ñ_Ð¸ÑÐ½Ñ_Ð¸ÑÐ»Ñ_Ð°Ð²Ð³ÑÑÑÐ°_ÑÐµÐ½ÑÑÐ±ÑÑ_Ð¾ÐºÑÑÐ±ÑÑ_Ð½Ð¾ÑÐ±ÑÑ_Ð´ÐµÐºÐ°Ð±ÑÑ'.split('_'),
10544        standalone: 'ÑÐ½Ð²Ð°ÑÑ_ÑÐµÐ²ÑÐ°Ð»Ñ_Ð¼Ð°ÑÑ_Ð°Ð¿ÑÐµÐ»Ñ_Ð¼Ð°Ð¹_Ð¸ÑÐ½Ñ_Ð¸ÑÐ»Ñ_Ð°Ð²Ð³ÑÑÑ_ÑÐµÐ½ÑÑÐ±ÑÑ_Ð¾ÐºÑÑÐ±ÑÑ_Ð½Ð¾ÑÐ±ÑÑ_Ð´ÐµÐºÐ°Ð±ÑÑ'.split('_')
10545    },
10546    monthsShort : {
10547        // Ð¿Ð¾ CLDR Ð¸Ð¼ÐµÐ½Ð½Ð¾ "Ð¸ÑÐ»." Ð¸ "Ð¸ÑÐ½.", Ð½Ð¾ ÐºÐ°ÐºÐ¾Ð¹ ÑÐ¼ÑÑÐ» Ð¼ÐµÐ½ÑÑÑ Ð±ÑÐºÐ²Ñ Ð½Ð° ÑÐ¾ÑÐºÑ ?
10548        format: 'ÑÐ½Ð²._ÑÐµÐ²Ñ._Ð¼Ð°Ñ._Ð°Ð¿Ñ._Ð¼Ð°Ñ_Ð¸ÑÐ½Ñ_Ð¸ÑÐ»Ñ_Ð°Ð²Ð³._ÑÐµÐ½Ñ._Ð¾ÐºÑ._Ð½Ð¾ÑÐ±._Ð´ÐµÐº.'.split('_'),
10549        standalone: 'ÑÐ½Ð²._ÑÐµÐ²Ñ._Ð¼Ð°ÑÑ_Ð°Ð¿Ñ._Ð¼Ð°Ð¹_Ð¸ÑÐ½Ñ_Ð¸ÑÐ»Ñ_Ð°Ð²Ð³._ÑÐµÐ½Ñ._Ð¾ÐºÑ._Ð½Ð¾ÑÐ±._Ð´ÐµÐº.'.split('_')
10550    },
10551    weekdays : {
10552        standalone: 'Ð²Ð¾ÑÐºÑÐµÑÐµÐ½ÑÐµ_Ð¿Ð¾Ð½ÐµÐ´ÐµÐ»ÑÐ½Ð¸Ðº_Ð²ÑÐ¾ÑÐ½Ð¸Ðº_ÑÑÐµÐ´Ð°_ÑÐµÑÐ²ÐµÑÐ³_Ð¿ÑÑÐ½Ð¸ÑÐ°_ÑÑÐ±Ð±Ð¾ÑÐ°'.split('_'),
10553        format: 'Ð²Ð¾ÑÐºÑÐµÑÐµÐ½ÑÐµ_Ð¿Ð¾Ð½ÐµÐ´ÐµÐ»ÑÐ½Ð¸Ðº_Ð²ÑÐ¾ÑÐ½Ð¸Ðº_ÑÑÐµÐ´Ñ_ÑÐµÑÐ²ÐµÑÐ³_Ð¿ÑÑÐ½Ð¸ÑÑ_ÑÑÐ±Ð±Ð¾ÑÑ'.split('_'),
10554        isFormat: /\[ ?[ÐÐ²] ?(?:Ð¿ÑÐ¾ÑÐ»ÑÑ|ÑÐ»ÐµÐ´ÑÑÑÑÑ|ÑÑÑ)? ?\] ?dddd/
10555    },
10556    weekdaysShort : 'Ð²Ñ_Ð¿Ð½_Ð²Ñ_ÑÑ_ÑÑ_Ð¿Ñ_ÑÐ±'.split('_'),
10557    weekdaysMin : 'Ð²Ñ_Ð¿Ð½_Ð²Ñ_ÑÑ_ÑÑ_Ð¿Ñ_ÑÐ±'.split('_'),
10558    monthsParse : monthsParse$2,
10559    longMonthsParse : monthsParse$2,
10560    shortMonthsParse : monthsParse$2,
10561
10562    // Ð¿Ð¾Ð»Ð½ÑÐµ Ð½Ð°Ð·Ð²Ð°Ð½Ð¸Ñ Ñ Ð¿Ð°Ð´ÐµÐ¶Ð°Ð¼Ð¸, Ð¿Ð¾ ÑÑÐ¸ Ð±ÑÐºÐ²Ñ, Ð´Ð»Ñ Ð½ÐµÐºÐ¾ÑÐ¾ÑÑÑ, Ð¿Ð¾ 4 Ð±ÑÐºÐ²Ñ, ÑÐ¾ÐºÑÐ°ÑÐµÐ½Ð¸Ñ Ñ ÑÐ¾ÑÐºÐ¾Ð¹ Ð¸ Ð±ÐµÐ· ÑÐ¾ÑÐºÐ¸
10563    monthsRegex: /^(ÑÐ½Ð²Ð°Ñ[ÑÑ]|ÑÐ½Ð²\.?|ÑÐµÐ²ÑÐ°Ð»[ÑÑ]|ÑÐµÐ²Ñ?\.?|Ð¼Ð°ÑÑÐ°?|Ð¼Ð°Ñ\.?|Ð°Ð¿ÑÐµÐ»[ÑÑ]|Ð°Ð¿Ñ\.?|Ð¼Ð°[Ð¹Ñ]|Ð¸ÑÐ½[ÑÑ]|Ð¸ÑÐ½\.?|Ð¸ÑÐ»[ÑÑ]|Ð¸ÑÐ»\.?|Ð°Ð²Ð³ÑÑÑÐ°?|Ð°Ð²Ð³\.?|ÑÐµÐ½ÑÑÐ±Ñ[ÑÑ]|ÑÐµÐ½Ñ?\.?|Ð¾ÐºÑÑÐ±Ñ[ÑÑ]|Ð¾ÐºÑ\.?|Ð½Ð¾ÑÐ±Ñ[ÑÑ]|Ð½Ð¾ÑÐ±?\.?|Ð´ÐµÐºÐ°Ð±Ñ[ÑÑ]|Ð´ÐµÐº\.?)/i,
10564
10565    // ÐºÐ¾Ð¿Ð¸Ñ Ð¿ÑÐµÐ´ÑÐ´ÑÑÐµÐ³Ð¾
10566    monthsShortRegex: /^(ÑÐ½Ð²Ð°Ñ[ÑÑ]|ÑÐ½Ð²\.?|ÑÐµÐ²ÑÐ°Ð»[ÑÑ]|ÑÐµÐ²Ñ?\.?|Ð¼Ð°ÑÑÐ°?|Ð¼Ð°Ñ\.?|Ð°Ð¿ÑÐµÐ»[ÑÑ]|Ð°Ð¿Ñ\.?|Ð¼Ð°[Ð¹Ñ]|Ð¸ÑÐ½[ÑÑ]|Ð¸ÑÐ½\.?|Ð¸ÑÐ»[ÑÑ]|Ð¸ÑÐ»\.?|Ð°Ð²Ð³ÑÑÑÐ°?|Ð°Ð²Ð³\.?|ÑÐµÐ½ÑÑÐ±Ñ[ÑÑ]|ÑÐµÐ½Ñ?\.?|Ð¾ÐºÑÑÐ±Ñ[ÑÑ]|Ð¾ÐºÑ\.?|Ð½Ð¾ÑÐ±Ñ[ÑÑ]|Ð½Ð¾ÑÐ±?\.?|Ð´ÐµÐºÐ°Ð±Ñ[ÑÑ]|Ð´ÐµÐº\.?)/i,
10567
10568    // Ð¿Ð¾Ð»Ð½ÑÐµ Ð½Ð°Ð·Ð²Ð°Ð½Ð¸Ñ Ñ Ð¿Ð°Ð´ÐµÐ¶Ð°Ð¼Ð¸
10569    monthsStrictRegex: /^(ÑÐ½Ð²Ð°Ñ[ÑÑ]|ÑÐµÐ²ÑÐ°Ð»[ÑÑ]|Ð¼Ð°ÑÑÐ°?|Ð°Ð¿ÑÐµÐ»[ÑÑ]|Ð¼Ð°[ÑÐ¹]|Ð¸ÑÐ½[ÑÑ]|Ð¸ÑÐ»[ÑÑ]|Ð°Ð²Ð³ÑÑÑÐ°?|ÑÐµÐ½ÑÑÐ±Ñ[ÑÑ]|Ð¾ÐºÑÑÐ±Ñ[ÑÑ]|Ð½Ð¾ÑÐ±Ñ[ÑÑ]|Ð´ÐµÐºÐ°Ð±Ñ[ÑÑ])/i,
10570
10571    // ÐÑÑÐ°Ð¶ÐµÐ½Ð¸Ðµ, ÐºÐ¾ÑÐ¾ÑÐ¾Ðµ ÑÐ¾Ð¾ÑÐ²ÐµÑÑÐ²ÑÐµÑ ÑÐ¾Ð»ÑÐºÐ¾ ÑÐ¾ÐºÑÐ°ÑÑÐ½Ð½ÑÐ¼ ÑÐ¾ÑÐ¼Ð°Ð¼
10572    monthsShortStrictRegex: /^(ÑÐ½Ð²\.|ÑÐµÐ²Ñ?\.|Ð¼Ð°Ñ[Ñ.]|Ð°Ð¿Ñ\.|Ð¼Ð°[ÑÐ¹]|Ð¸ÑÐ½[ÑÑ.]|Ð¸ÑÐ»[ÑÑ.]|Ð°Ð²Ð³\.|ÑÐµÐ½Ñ?\.|Ð¾ÐºÑ\.|Ð½Ð¾ÑÐ±?\.|Ð´ÐµÐº\.)/i,
10573    longDateFormat : {
10574        LT : 'HH:mm',
10575        LTS : 'HH:mm:ss',
10576        L : 'DD.MM.YYYY',
10577        LL : 'D MMMM YYYY Ð³.',
10578        LLL : 'D MMMM YYYY Ð³., HH:mm',
10579        LLLL : 'dddd, D MMMM YYYY Ð³., HH:mm'
10580    },
10581    calendar : {
10582        sameDay: '[Ð¡ÐµÐ³Ð¾Ð´Ð½Ñ Ð²] LT',
10583        nextDay: '[ÐÐ°Ð²ÑÑÐ° Ð²] LT',
10584        lastDay: '[ÐÑÐµÑÐ° Ð²] LT',
10585        nextWeek: function (now) {
10586            if (now.week() !== this.week()) {
10587                switch (this.day()) {
10588                    case 0:
10589                        return '[Ð ÑÐ»ÐµÐ´ÑÑÑÐµÐµ] dddd [Ð²] LT';
10590                    case 1:
10591                    case 2:
10592                    case 4:
10593                        return '[Ð ÑÐ»ÐµÐ´ÑÑÑÐ¸Ð¹] dddd [Ð²] LT';
10594                    case 3:
10595                    case 5:
10596                    case 6:
10597                        return '[Ð ÑÐ»ÐµÐ´ÑÑÑÑÑ] dddd [Ð²] LT';
10598                }
10599            } else {
10600                if (this.day() === 2) {
10601                    return '[ÐÐ¾] dddd [Ð²] LT';
10602                } else {
10603                    return '[Ð] dddd [Ð²] LT';
10604                }
10605            }
10606        },
10607        lastWeek: function (now) {
10608            if (now.week() !== this.week()) {
10609                switch (this.day()) {
10610                    case 0:
10611                        return '[Ð Ð¿ÑÐ¾ÑÐ»Ð¾Ðµ] dddd [Ð²] LT';
10612                    case 1:
10613                    case 2:
10614                    case 4:
10615                        return '[Ð Ð¿ÑÐ¾ÑÐ»ÑÐ¹] dddd [Ð²] LT';
10616                    case 3:
10617                    case 5:
10618                    case 6:
10619                        return '[Ð Ð¿ÑÐ¾ÑÐ»ÑÑ] dddd [Ð²] LT';
10620                }
10621            } else {
10622                if (this.day() === 2) {
10623                    return '[ÐÐ¾] dddd [Ð²] LT';
10624                } else {
10625                    return '[Ð] dddd [Ð²] LT';
10626                }
10627            }
10628        },
10629        sameElse: 'L'
10630    },
10631    relativeTime : {
10632        future : 'ÑÐµÑÐµÐ· %s',
10633        past : '%s Ð½Ð°Ð·Ð°Ð´',
10634        s : 'Ð½ÐµÑÐºÐ¾Ð»ÑÐºÐ¾ ÑÐµÐºÑÐ½Ð´',
10635        m : relativeTimeWithPlural$3,
10636        mm : relativeTimeWithPlural$3,
10637        h : 'ÑÐ°Ñ',
10638        hh : relativeTimeWithPlural$3,
10639        d : 'Ð´ÐµÐ½Ñ',
10640        dd : relativeTimeWithPlural$3,
10641        M : 'Ð¼ÐµÑÑÑ',
10642        MM : relativeTimeWithPlural$3,
10643        y : 'Ð³Ð¾Ð´',
10644        yy : relativeTimeWithPlural$3
10645    },
10646    meridiemParse: /Ð½Ð¾ÑÐ¸|ÑÑÑÐ°|Ð´Ð½Ñ|Ð²ÐµÑÐµÑÐ°/i,
10647    isPM : function (input) {
10648        return /^(Ð´Ð½Ñ|Ð²ÐµÑÐµÑÐ°)$/.test(input);
10649    },
10650    meridiem : function (hour, minute, isLower) {
10651        if (hour < 4) {
10652            return 'Ð½Ð¾ÑÐ¸';
10653        } else if (hour < 12) {
10654            return 'ÑÑÑÐ°';
10655        } else if (hour < 17) {
10656            return 'Ð´Ð½Ñ';
10657        } else {
10658            return 'Ð²ÐµÑÐµÑÐ°';
10659        }
10660    },
10661    ordinalParse: /\d{1,2}-(Ð¹|Ð³Ð¾|Ñ)/,
10662    ordinal: function (number, period) {
10663        switch (period) {
10664            case 'M':
10665            case 'd':
10666            case 'DDD':
10667                return number + '-Ð¹';
10668            case 'D':
10669                return number + '-Ð³Ð¾';
10670            case 'w':
10671            case 'W':
10672                return number + '-Ñ';
10673            default:
10674                return number;
10675        }
10676    },
10677    week : {
10678        dow : 1, // Monday is the first day of the week.
10679        doy : 7  // The week that contains Jan 1st is the first week of the year.
10680    }
10681});
10682
10683//! moment.js locale configuration
10684//! locale : Northern Sami [se]
10685//! authors : BÃ¥rd Rolstad Henriksen : https://github.com/karamell
10686
10687
10688hooks.defineLocale('se', {
10689    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('_'),
10690    monthsShort : 'oÄÄj_guov_njuk_cuo_mies_geas_suoi_borg_ÄakÄ_golg_skÃ¡b_juov'.split('_'),
10691    weekdays : 'sotnabeaivi_vuossÃ¡rga_maÅÅebÃ¡rga_gaskavahkku_duorastat_bearjadat_lÃ¡vvardat'.split('_'),
10692    weekdaysShort : 'sotn_vuos_maÅ_gask_duor_bear_lÃ¡v'.split('_'),
10693    weekdaysMin : 's_v_m_g_d_b_L'.split('_'),
10694    longDateFormat : {
10695        LT : 'HH:mm',
10696        LTS : 'HH:mm:ss',
10697        L : 'DD.MM.YYYY',
10698        LL : 'MMMM D. [b.] YYYY',
10699        LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',
10700        LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
10701    },
10702    calendar : {
10703        sameDay: '[otne ti] LT',
10704        nextDay: '[ihttin ti] LT',
10705        nextWeek: 'dddd [ti] LT',
10706        lastDay: '[ikte ti] LT',
10707        lastWeek: '[ovddit] dddd [ti] LT',
10708        sameElse: 'L'
10709    },
10710    relativeTime : {
10711        future : '%s geaÅ¾es',
10712        past : 'maÅit %s',
10713        s : 'moadde sekunddat',
10714        m : 'okta minuhta',
10715        mm : '%d minuhtat',
10716        h : 'okta diimmu',
10717        hh : '%d diimmut',
10718        d : 'okta beaivi',
10719        dd : '%d beaivvit',
10720        M : 'okta mÃ¡nnu',
10721        MM : '%d mÃ¡nut',
10722        y : 'okta jahki',
10723        yy : '%d jagit'
10724    },
10725    ordinalParse: /\d{1,2}\./,
10726    ordinal : '%d.',
10727    week : {
10728        dow : 1, // Monday is the first day of the week.
10729        doy : 4  // The week that contains Jan 4th is the first week of the year.
10730    }
10731});
10732
10733//! moment.js locale configuration
10734//! locale : Sinhalese [si]
10735//! author : Sampath Sitinamaluwa : https://github.com/sampathsris
10736

10737/*jshint -W100*/
10738hooks.defineLocale('si', {
10739    months : 'à¶¢à¶±à·à·à¶»à·_à¶´à·à¶¶à¶»à·à·à¶»à·_à¶¸à·à¶»à·à¶à·_à¶à¶´à·âà¶»à·à¶½à·_à¶¸à·à¶ºà·_à¶¢à·à¶±à·_à¶¢à·à¶½à·_à¶à¶à·à·à·à¶à·_à·à·à¶´à·à¶à·à¶¸à·à¶¶à¶»à·_à¶à¶à·à¶à·à¶¶à¶»à·_à¶±à·à·à·à¶¸à·à¶¶à¶»à·_à¶¯à·à·à·à¶¸à·à¶¶à¶»à·'.split('_'),
10740    monthsShort : 'à¶¢à¶±_à¶´à·à¶¶_à¶¸à·à¶»à·_à¶à¶´à·_à¶¸à·à¶ºà·_à¶¢à·à¶±à·_à¶¢à·à¶½à·_à¶à¶à·_à·à·à¶´à·_à¶à¶à·_à¶±à·à·à·_à¶¯à·à·à·'.split('_'),
10741    weekdays : 'à¶à¶»à·à¶¯à·_à·à¶³à·à¶¯à·_à¶à¶à·à¶»à·à·à·à¶¯à·_à¶¶à¶¯à·à¶¯à·_à¶¶à·âà¶»à·à·à·à¶´à¶à·à¶±à·à¶¯à·_à·à·à¶à·à¶»à·à¶¯à·_à·à·à¶±à·à·à¶»à·à¶¯à·'.split('_'),
10742    weekdaysShort : 'à¶à¶»à·_à·à¶³à·_à¶à¶_à¶¶à¶¯à·_à¶¶à·âà¶»à·_à·à·à¶à·_à·à·à¶±'.split('_'),
10743    weekdaysMin : 'à¶_à·_à¶_à¶¶_à¶¶à·âà¶»_à·à·_à·à·'.split('_'),
10744    weekdaysParseExact : true,
10745    longDateFormat : {
10746        LT : 'a h:mm',
10747        LTS : 'a h:mm:ss',
10748        L : 'YYYY/MM/DD',
10749        LL : 'YYYY MMMM D',
10750        LLL : 'YYYY MMMM D, a h:mm',
10751        LLLL : 'YYYY MMMM D [à·à·à¶±à·] dddd, a h:mm:ss'
10752    },
10753    calendar : {
10754        sameDay : '[à¶à¶¯] LT[à¶§]',
10755        nextDay : '[à·à·à¶§] LT[à¶§]',
10756        nextWeek : 'dddd LT[à¶§]',
10757        lastDay : '[à¶à¶ºà·] LT[à¶§]',
10758        lastWeek : '[à¶´à·à·à¶à·à¶º] dddd LT[à¶§]',
10759        sameElse : 'L'
10760    },
10761    relativeTime : {
10762        future : '%sà¶à·à¶±à·',
10763        past : '%sà¶à¶§ à¶´à·à¶»',
10764        s : 'à¶à¶à·à¶´à¶» à¶à·à·à·à¶´à¶º',
10765        m : 'à¶¸à·à¶±à·à¶à·à¶à·à·',
10766        mm : 'à¶¸à·à¶±à·à¶à·à¶à· %d',
10767        h : 'à¶´à·à¶º',
10768        hh : 'à¶´à·à¶º %d',
10769        d : 'à¶¯à·à¶±à¶º',
10770        dd : 'à¶¯à·à¶± %d',
10771        M : 'à¶¸à·à·à¶º',
10772        MM : 'à¶¸à·à· %d',
10773        y : 'à·à·à¶»',
10774        yy : 'à·à·à¶» %d'
10775    },
10776    ordinalParse: /\d{1,2} à·à·à¶±à·/,
10777    ordinal : function (number) {
10778        return number + ' à·à·à¶±à·';
10779    },
10780    meridiemParse : /à¶´à·à¶» à·à¶»à·|à¶´à·à· à·à¶»à·|à¶´à·.à·|à¶´.à·./,
10781    isPM : function (input) {
10782        return input === 'à¶´.à·.' || input === 'à¶´à·à· à·à¶»à·';
10783    },
10784    meridiem : function (hours, minutes, isLower) {
10785        if (hours > 11) {
10786            return isLower ? 'à¶´.à·.' : 'à¶´à·à· à·à¶»à·';
10787        } else {
10788            return isLower ? 'à¶´à·.à·.' : 'à¶´à·à¶» à·à¶»à·';
10789        }
10790    }
10791});
10792
10793//! moment.js locale configuration
10794//! locale : Slovak [sk]
10795//! author : Martin Minka : https://github.com/k2s
10796//! based on work of petrbela : https://github.com/petrbela
10797
10798var months$6 = 'januÃ¡r_februÃ¡r_marec_aprÃl_mÃ¡j_jÃºn_jÃºl_august_september_oktÃ³ber_november_december'.split('_');
10799var monthsShort$4 = 'jan_feb_mar_apr_mÃ¡j_jÃºn_jÃºl_aug_sep_okt_nov_dec'.split('_');
10800function plural$5(n) {
10801    return (n > 1) && (n < 5);
10802}
10803function translate$8(number, withoutSuffix, key, isFuture) {
10804    var result = number + ' ';
10805    switch (key) {
10806        case 's':  // a few seconds / in a few seconds / a few seconds ago
10807            return (withoutSuffix || isFuture) ? 'pÃ¡r sekÃºnd' : 'pÃ¡r sekundami';
10808        case 'm':  // a minute / in a minute / a minute ago
10809            return withoutSuffix ? 'minÃºta' : (isFuture ? 'minÃºtu' : 'minÃºtou');
10810        case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
10811            if (withoutSuffix || isFuture) {
10812                return result + (plural$5(number) ? 'minÃºty' : 'minÃºt');
10813            } else {
10814                return result + 'minÃºtami';
10815            }
10816            break;
10817        case 'h':  // an hour / in an hour / an hour ago
10818            return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
10819        case 'hh': // 9 hours / in 9 hours / 9 hours ago
10820            if (withoutSuffix || isFuture) {
10821                return result + (plural$5(number) ? 'hodiny' : 'hodÃn');
10822            } else {
10823                return result + 'hodinami';
10824            }
10825            break;
10826        case 'd':  // a day / in a day / a day ago
10827            return (withoutSuffix || isFuture) ? 'deÅ' : 'dÅom';
10828        case 'dd': // 9 days / in 9 days / 9 days ago
10829            if (withoutSuffix || isFuture) {
10830                return result + (plural$5(number) ? 'dni' : 'dnÃ');
10831            } else {
10832                return result + 'dÅami';
10833            }
10834            break;
10835        case 'M':  // a month / in a month / a month ago
10836            return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
10837        case 'MM': // 9 months / in 9 months / 9 months ago
10838            if (withoutSuffix || isFuture) {
10839                return result + (plural$5(number) ? 'mesiace' : 'mesiacov');
10840            } else {
10841                return result + 'mesiacmi';
10842            }
10843            break;
10844        case 'y':  // a year / in a year / a year ago
10845            return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
10846        case 'yy': // 9 years / in 9 years / 9 years ago
10847            if (withoutSuffix || isFuture) {
10848                return result + (plural$5(number) ? 'roky' : 'rokov');
10849            } else {
10850                return result + 'rokmi';
10851            }
10852            break;
10853    }
10854}
10855
10856hooks.defineLocale('sk', {
10857    months : months$6,
10858    monthsShort : monthsShort$4,
10859    weekdays : 'nedeÄ¾a_pondelok_utorok_streda_Å¡tvrtok_piatok_sobota'.split('_'),
10860    weekdaysShort : 'ne_po_ut_st_Å¡t_pi_so'.split('_'),
10861    weekdaysMin : 'ne_po_ut_st_Å¡t_pi_so'.split('_'),
10862    longDateFormat : {
10863        LT: 'H:mm',
10864        LTS : 'H:mm:ss',
10865        L : 'DD.MM.YYYY',
10866        LL : 'D. MMMM YYYY',
10867        LLL : 'D. MMMM YYYY H:mm',
10868        LLLL : 'dddd D. MMMM YYYY H:mm'
10869    },
10870    calendar : {
10871        sameDay: '[dnes o] LT',
10872        nextDay: '[zajtra o] LT',
10873        nextWeek: function () {
10874            switch (this.day()) {
10875                case 0:
10876                    return '[v nedeÄ¾u o] LT';
10877                case 1:
10878                case 2:
10879                    return '[v] dddd [o] LT';
10880                case 3:
10881                    return '[v stredu o] LT';
10882                case 4:
10883                    return '[vo Å¡tvrtok o] LT';
10884                case 5:
10885                    return '[v piatok o] LT';
10886                case 6:
10887                    return '[v sobotu o] LT';
10888            }
10889        },
10890        lastDay: '[vÄera o] LT',
10891        lastWeek: function () {
10892            switch (this.day()) {
10893                case 0:
10894                    return '[minulÃº nedeÄ¾u o] LT';
10895                case 1:
10896                case 2:
10897                    return '[minulÃ½] dddd [o] LT';
10898                case 3:
10899                    return '[minulÃº stredu o] LT';
10900                case 4:
10901                case 5:
10902                    return '[minulÃ½] dddd [o] LT';
10903                case 6:
10904                    return '[minulÃº sobotu o] LT';
10905            }
10906        },
10907        sameElse: 'L'
10908    },
10909    relativeTime : {
10910        future : 'za %s',
10911        past : 'pred %s',
10912        s : translate$8,
10913        m : translate$8,
10914        mm : translate$8,
10915        h : translate$8,
10916        hh : translate$8,
10917        d : translate$8,
10918        dd : translate$8,
10919        M : translate$8,
10920        MM : translate$8,
10921        y : translate$8,
10922        yy : translate$8
10923    },
10924    ordinalParse: /\d{1,2}\./,
10925    ordinal : '%d.',
10926    week : {
10927        dow : 1, // Monday is the first day of the week.
10928        doy : 4  // The week that contains Jan 4th is the first week of the year.
10929    }
10930});
10931
10932//! moment.js locale configuration
10933//! locale : Slovenian [sl]
10934//! author : Robert SedovÅ¡ek : https://github.com/sedovsek
10935
10936function processRelativeTime$4(number, withoutSuffix, key, isFuture) {
10937    var result = number + ' ';
10938    switch (key) {
10939        case 's':
10940            return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami';
10941        case 'm':
10942            return withoutSuffix ? 'ena minuta' : 'eno minuto';
10943        case 'mm':
10944            if (number === 1) {
10945                result += withoutSuffix ? 'minuta' : 'minuto';
10946            } else if (number === 2) {
10947                result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
10948            } else if (number < 5) {
10949                result += withoutSuffix || isFuture ? 'minute' : 'minutami';
10950            } else {
10951                result += withoutSuffix || isFuture ? 'minut' : 'minutami';
10952            }
10953            return result;
10954        case 'h':
10955            return withoutSuffix ? 'ena ura' : 'eno uro';
10956        case 'hh':
10957            if (number === 1) {
10958                result += withoutSuffix ? 'ura' : 'uro';
10959            } else if (number === 2) {
10960                result += withoutSuffix || isFuture ? 'uri' : 'urama';
10961            } else if (number < 5) {
10962                result += withoutSuffix || isFuture ? 'ure' : 'urami';
10963            } else {
10964                result += withoutSuffix || isFuture ? 'ur' : 'urami';
10965            }
10966            return result;
10967        case 'd':
10968            return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
10969        case 'dd':
10970            if (number === 1) {
10971                result += withoutSuffix || isFuture ? 'dan' : 'dnem';
10972            } else if (number === 2) {
10973                result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
10974            } else {
10975                result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
10976            }
10977            return result;
10978        case 'M':
10979            return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
10980        case 'MM':
10981            if (number === 1) {
10982                result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
10983            } else if (number === 2) {
10984                result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
10985            } else if (number < 5) {
10986                result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
10987            } else {
10988                result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
10989            }
10990            return result;
10991        case 'y':
10992            return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
10993        case 'yy':
10994            if (number === 1) {
10995                result += withoutSuffix || isFuture ? 'leto' : 'letom';
10996            } else if (number === 2) {
10997                result += withoutSuffix || isFuture ? 'leti' : 'letoma';
10998            } else if (number < 5) {
10999                result += withoutSuffix || isFuture ? 'leta' : 'leti';
11000            } else {
11001                result += withoutSuffix || isFuture ? 'let' : 'leti';
11002            }
11003            return result;
11004    }
11005}
11006
11007hooks.defineLocale('sl', {
11008    months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
11009    monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
11010    monthsParseExact: true,
11011    weekdays : 'nedelja_ponedeljek_torek_sreda_Äetrtek_petek_sobota'.split('_'),
11012    weekdaysShort : 'ned._pon._tor._sre._Äet._pet._sob.'.split('_'),
11013    weekdaysMin : 'ne_po_to_sr_Äe_pe_so'.split('_'),
11014    weekdaysParseExact : true,
11015    longDateFormat : {
11016        LT : 'H:mm',
11017        LTS : 'H:mm:ss',
11018        L : 'DD.MM.YYYY',
11019        LL : 'D. MMMM YYYY',
11020        LLL : 'D. MMMM YYYY H:mm',
11021        LLLL : 'dddd, D. MMMM YYYY H:mm'
11022    },
11023    calendar : {
11024        sameDay  : '[danes ob] LT',
11025        nextDay  : '[jutri ob] LT',
11026
11027        nextWeek : function () {
11028            switch (this.day()) {
11029                case 0:
11030                    return '[v] [nedeljo] [ob] LT';
11031                case 3:
11032                    return '[v] [sredo] [ob] LT';
11033                case 6:
11034                    return '[v] [soboto] [ob] LT';
11035                case 1:
11036                case 2:
11037                case 4:
11038                case 5:
11039                    return '[v] dddd [ob] LT';
11040            }
11041        },
11042        lastDay  : '[vÄeraj ob] LT',
11043        lastWeek : function () {
11044            switch (this.day()) {
11045                case 0:
11046                    return '[prejÅ¡njo] [nedeljo] [ob] LT';
11047                case 3:
11048                    return '[prejÅ¡njo] [sredo] [ob] LT';
11049                case 6:
11050                    return '[prejÅ¡njo] [soboto] [ob] LT';
11051                case 1:
11052                case 2:
11053                case 4:
11054                case 5:
11055                    return '[prejÅ¡nji] dddd [ob] LT';
11056            }
11057        },
11058        sameElse : 'L'
11059    },
11060    relativeTime : {
11061        future : 'Äez %s',
11062        past   : 'pred %s',
11063        s      : processRelativeTime$4,
11064        m      : processRelativeTime$4,
11065        mm     : processRelativeTime$4,
11066        h      : processRelativeTime$4,
11067        hh     : processRelativeTime$4,
11068        d      : processRelativeTime$4,
11069        dd     : processRelativeTime$4,
11070        M      : processRelativeTime$4,
11071        MM     : processRelativeTime$4,
11072        y      : processRelativeTime$4,
11073        yy     : processRelativeTime$4
11074    },
11075    ordinalParse: /\d{1,2}\./,
11076    ordinal : '%d.',
11077    week : {
11078        dow : 1, // Monday is the first day of the week.
11079        doy : 7  // The week that contains Jan 1st is the first week of the year.
11080    }
11081});
11082
11083//! moment.js locale configuration
11084//! locale : Albanian [sq]
11085//! author : FlakÃ«rim Ismani : https://github.com/flakerimi
11086//! author : Menelion ElensÃºle : https://github.com/Oire
11087//! author : Oerd Cukalla : https://github.com/oerd
11088
11089hooks.defineLocale('sq', {
11090    months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_NÃ«ntor_Dhjetor'.split('_'),
11091    monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_NÃ«n_Dhj'.split('_'),
11092    weekdays : 'E Diel_E HÃ«nÃ«_E MartÃ«_E MÃ«rkurÃ«_E Enjte_E Premte_E ShtunÃ«'.split('_'),
11093    weekdaysShort : 'Die_HÃ«n_Mar_MÃ«r_Enj_Pre_Sht'.split('_'),
11094    weekdaysMin : 'D_H_Ma_MÃ«_E_P_Sh'.split('_'),
11095    weekdaysParseExact : true,
11096    meridiemParse: /PD|MD/,
11097    isPM: function (input) {
11098        return input.charAt(0) === 'M';
11099    },
11100    meridiem : function (hours, minutes, isLower) {
11101        return hours < 12 ? 'PD' : 'MD';
11102    },
11103    longDateFormat : {
11104        LT : 'HH:mm',
11105        LTS : 'HH:mm:ss',
11106        L : 'DD/MM/YYYY',
11107        LL : 'D MMMM YYYY',
11108        LLL : 'D MMMM YYYY HH:mm',
11109        LLLL : 'dddd, D MMMM YYYY HH:mm'
11110    },
11111    calendar : {

11112        sameDay : '[Sot nÃ«] LT',
11113        nextDay : '[NesÃ«r nÃ«] LT',
11114        nextWeek : 'dddd [nÃ«] LT',
11115        lastDay : '[Dje nÃ«] LT',
11116        lastWeek : 'dddd [e kaluar nÃ«] LT',
11117        sameElse : 'L'
11118    },
11119    relativeTime : {
11120        future : 'nÃ« %s',
11121        past : '%s mÃ« parÃ«',
11122        s : 'disa sekonda',
11123        m : 'njÃ« minutÃ«',
11124        mm : '%d minuta',
11125        h : 'njÃ« orÃ«',
11126        hh : '%d orÃ«',
11127        d : 'njÃ« ditÃ«',
11128        dd : '%d ditÃ«',
11129        M : 'njÃ« muaj',
11130        MM : '%d muaj',
11131        y : 'njÃ« vit',
11132        yy : '%d vite'
11133    },
11134    ordinalParse: /\d{1,2}\./,
11135    ordinal : '%d.',
11136    week : {
11137        dow : 1, // Monday is the first day of the week.
11138        doy : 4  // The week that contains Jan 4th is the first week of the year.
11139    }
11140});
11141
11142//! moment.js locale configuration
11143//! locale : Serbian Cyrillic [sr-cyrl]
11144//! author : Milan JanaÄkoviÄ<[email protected]> : https://github.com/milan-j
11145
11146var translator$1 = {
11147    words: { //Different grammatical cases
11148        m: ['ÑÐµÐ´Ð°Ð½ Ð¼Ð¸Ð½ÑÑ', 'ÑÐµÐ´Ð½Ðµ Ð¼Ð¸Ð½ÑÑÐµ'],
11149        mm: ['Ð¼Ð¸Ð½ÑÑ', 'Ð¼Ð¸Ð½ÑÑÐµ', 'Ð¼Ð¸Ð½ÑÑÐ°'],
11150        h: ['ÑÐµÐ´Ð°Ð½ ÑÐ°Ñ', 'ÑÐµÐ´Ð½Ð¾Ð³ ÑÐ°ÑÐ°'],
11151        hh: ['ÑÐ°Ñ', 'ÑÐ°ÑÐ°', 'ÑÐ°ÑÐ¸'],
11152        dd: ['Ð´Ð°Ð½', 'Ð´Ð°Ð½Ð°', 'Ð´Ð°Ð½Ð°'],
11153        MM: ['Ð¼ÐµÑÐµÑ', 'Ð¼ÐµÑÐµÑÐ°', 'Ð¼ÐµÑÐµÑÐ¸'],
11154        yy: ['Ð³Ð¾Ð´Ð¸Ð½Ð°', 'Ð³Ð¾Ð´Ð¸Ð½Ðµ', 'Ð³Ð¾Ð´Ð¸Ð½Ð°']
11155    },
11156    correctGrammaticalCase: function (number, wordKey) {
11157        return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
11158    },
11159    translate: function (number, withoutSuffix, key) {
11160        var wordKey = translator$1.words[key];
11161        if (key.length === 1) {
11162            return withoutSuffix ? wordKey[0] : wordKey[1];
11163        } else {
11164            return number + ' ' + translator$1.correctGrammaticalCase(number, wordKey);
11165        }
11166    }
11167};
11168
11169hooks.defineLocale('sr-cyrl', {
11170    months: 'ÑÐ°Ð½ÑÐ°Ñ_ÑÐµÐ±ÑÑÐ°Ñ_Ð¼Ð°ÑÑ_Ð°Ð¿ÑÐ¸Ð»_Ð¼Ð°Ñ_ÑÑÐ½_ÑÑÐ»_Ð°Ð²Ð³ÑÑÑ_ÑÐµÐ¿ÑÐµÐ¼Ð±Ð°Ñ_Ð¾ÐºÑÐ¾Ð±Ð°Ñ_Ð½Ð¾Ð²ÐµÐ¼Ð±Ð°Ñ_Ð´ÐµÑÐµÐ¼Ð±Ð°Ñ'.split('_'),
11171    monthsShort: 'ÑÐ°Ð½._ÑÐµÐ±._Ð¼Ð°Ñ._Ð°Ð¿Ñ._Ð¼Ð°Ñ_ÑÑÐ½_ÑÑÐ»_Ð°Ð²Ð³._ÑÐµÐ¿._Ð¾ÐºÑ._Ð½Ð¾Ð²._Ð´ÐµÑ.'.split('_'),
11172    monthsParseExact: true,
11173    weekdays: 'Ð½ÐµÐ´ÐµÑÐ°_Ð¿Ð¾Ð½ÐµÐ´ÐµÑÐ°Ðº_ÑÑÐ¾ÑÐ°Ðº_ÑÑÐµÐ´Ð°_ÑÐµÑÐ²ÑÑÐ°Ðº_Ð¿ÐµÑÐ°Ðº_ÑÑÐ±Ð¾ÑÐ°'.split('_'),
11174    weekdaysShort: 'Ð½ÐµÐ´._Ð¿Ð¾Ð½._ÑÑÐ¾._ÑÑÐµ._ÑÐµÑ._Ð¿ÐµÑ._ÑÑÐ±.'.split('_'),
11175    weekdaysMin: 'Ð½Ðµ_Ð¿Ð¾_ÑÑ_ÑÑ_ÑÐµ_Ð¿Ðµ_ÑÑ'.split('_'),
11176    weekdaysParseExact : true,
11177    longDateFormat: {
11178        LT: 'H:mm',
11179        LTS : 'H:mm:ss',
11180        L: 'DD.MM.YYYY',
11181        LL: 'D. MMMM YYYY',
11182        LLL: 'D. MMMM YYYY H:mm',
11183        LLLL: 'dddd, D. MMMM YYYY H:mm'
11184    },
11185    calendar: {
11186        sameDay: '[Ð´Ð°Ð½Ð°Ñ Ñ] LT',
11187        nextDay: '[ÑÑÑÑÐ° Ñ] LT',
11188        nextWeek: function () {
11189            switch (this.day()) {
11190                case 0:
11191                    return '[Ñ] [Ð½ÐµÐ´ÐµÑÑ] [Ñ] LT';
11192                case 3:
11193                    return '[Ñ] [ÑÑÐµÐ´Ñ] [Ñ] LT';
11194                case 6:
11195                    return '[Ñ] [ÑÑÐ±Ð¾ÑÑ] [Ñ] LT';
11196                case 1:
11197                case 2:
11198                case 4:
11199                case 5:
11200                    return '[Ñ] dddd [Ñ] LT';
11201            }
11202        },
11203        lastDay  : '[ÑÑÑÐµ Ñ] LT',
11204        lastWeek : function () {
11205            var lastWeekDays = [
11206                '[Ð¿ÑÐ¾ÑÐ»Ðµ] [Ð½ÐµÐ´ÐµÑÐµ] [Ñ] LT',
11207                '[Ð¿ÑÐ¾ÑÐ»Ð¾Ð³] [Ð¿Ð¾Ð½ÐµÐ´ÐµÑÐºÐ°] [Ñ] LT',
11208                '[Ð¿ÑÐ¾ÑÐ»Ð¾Ð³] [ÑÑÐ¾ÑÐºÐ°] [Ñ] LT',
11209                '[Ð¿ÑÐ¾ÑÐ»Ðµ] [ÑÑÐµÐ´Ðµ] [Ñ] LT',
11210                '[Ð¿ÑÐ¾ÑÐ»Ð¾Ð³] [ÑÐµÑÐ²ÑÑÐºÐ°] [Ñ] LT',
11211                '[Ð¿ÑÐ¾ÑÐ»Ð¾Ð³] [Ð¿ÐµÑÐºÐ°] [Ñ] LT',
11212                '[Ð¿ÑÐ¾ÑÐ»Ðµ] [ÑÑÐ±Ð¾ÑÐµ] [Ñ] LT'
11213            ];
11214            return lastWeekDays[this.day()];
11215        },
11216        sameElse : 'L'
11217    },
11218    relativeTime : {
11219        future : 'Ð·Ð° %s',
11220        past   : 'Ð¿ÑÐµ %s',
11221        s      : 'Ð½ÐµÐºÐ¾Ð»Ð¸ÐºÐ¾ ÑÐµÐºÑÐ½Ð´Ð¸',
11222        m      : translator$1.translate,
11223        mm     : translator$1.translate,
11224        h      : translator$1.translate,
11225        hh     : translator$1.translate,
11226        d      : 'Ð´Ð°Ð½',
11227        dd     : translator$1.translate,
11228        M      : 'Ð¼ÐµÑÐµÑ',
11229        MM     : translator$1.translate,
11230        y      : 'Ð³Ð¾Ð´Ð¸Ð½Ñ',
11231        yy     : translator$1.translate
11232    },
11233    ordinalParse: /\d{1,2}\./,
11234    ordinal : '%d.',
11235    week : {
11236        dow : 1, // Monday is the first day of the week.
11237        doy : 7  // The week that contains Jan 1st is the first week of the year.
11238    }
11239});
11240
11241//! moment.js locale configuration
11242//! locale : Serbian [sr]
11243//! author : Milan JanaÄkoviÄ<[email protected]> : https://github.com/milan-j
11244
11245var translator$2 = {
11246    words: { //Different grammatical cases
11247        m: ['jedan minut', 'jedne minute'],
11248        mm: ['minut', 'minute', 'minuta'],
11249        h: ['jedan sat', 'jednog sata'],
11250        hh: ['sat', 'sata', 'sati'],
11251        dd: ['dan', 'dana', 'dana'],
11252        MM: ['mesec', 'meseca', 'meseci'],
11253        yy: ['godina', 'godine', 'godina']
11254    },
11255    correctGrammaticalCase: function (number, wordKey) {
11256        return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
11257    },
11258    translate: function (number, withoutSuffix, key) {
11259        var wordKey = translator$2.words[key];
11260        if (key.length === 1) {
11261            return withoutSuffix ? wordKey[0] : wordKey[1];
11262        } else {
11263            return number + ' ' + translator$2.correctGrammaticalCase(number, wordKey);
11264        }
11265    }
11266};
11267
11268hooks.defineLocale('sr', {
11269    months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
11270    monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
11271    monthsParseExact: true,
11272    weekdays: 'nedelja_ponedeljak_utorak_sreda_Äetvrtak_petak_subota'.split('_'),
11273    weekdaysShort: 'ned._pon._uto._sre._Äet._pet._sub.'.split('_'),
11274    weekdaysMin: 'ne_po_ut_sr_Äe_pe_su'.split('_'),
11275    weekdaysParseExact : true,
11276    longDateFormat: {
11277        LT: 'H:mm',
11278        LTS : 'H:mm:ss',
11279        L: 'DD.MM.YYYY',
11280        LL: 'D. MMMM YYYY',
11281        LLL: 'D. MMMM YYYY H:mm',
11282        LLLL: 'dddd, D. MMMM YYYY H:mm'
11283    },
11284    calendar: {
11285        sameDay: '[danas u] LT',
11286        nextDay: '[sutra u] LT',
11287        nextWeek: function () {
11288            switch (this.day()) {
11289                case 0:
11290                    return '[u] [nedelju] [u] LT';
11291                case 3:
11292                    return '[u] [sredu] [u] LT';
11293                case 6:
11294                    return '[u] [subotu] [u] LT';
11295                case 1:
11296                case 2:
11297                case 4:
11298                case 5:
11299                    return '[u] dddd [u] LT';
11300            }
11301        },
11302        lastDay  : '[juÄe u] LT',
11303        lastWeek : function () {
11304            var lastWeekDays = [
11305                '[proÅ¡le] [nedelje] [u] LT',
11306                '[proÅ¡log] [ponedeljka] [u] LT',
11307                '[proÅ¡log] [utorka] [u] LT',
11308                '[proÅ¡le] [srede] [u] LT',
11309                '[proÅ¡log] [Äetvrtka] [u] LT',
11310                '[proÅ¡log] [petka] [u] LT',
11311                '[proÅ¡le] [subote] [u] LT'
11312            ];
11313            return lastWeekDays[this.day()];
11314        },
11315        sameElse : 'L'
11316    },
11317    relativeTime : {
11318        future : 'za %s',
11319        past   : 'pre %s',
11320        s      : 'nekoliko sekundi',
11321        m      : translator$2.translate,
11322        mm     : translator$2.translate,
11323        h      : translator$2.translate,
11324        hh     : translator$2.translate,
11325        d      : 'dan',
11326        dd     : translator$2.translate,
11327        M      : 'mesec',
11328        MM     : translator$2.translate,
11329        y      : 'godinu',
11330        yy     : translator$2.translate
11331    },
11332    ordinalParse: /\d{1,2}\./,
11333    ordinal : '%d.',
11334    week : {
11335        dow : 1, // Monday is the first day of the week.
11336        doy : 7  // The week that contains Jan 1st is the first week of the year.
11337    }
11338});
11339
11340//! moment.js locale configuration
11341//! locale : siSwati [ss]
11342//! author : Nicolai Davies<[email protected]> : https://github.com/nicolaidavies
11343
11344
11345hooks.defineLocale('ss', {

11346    months : "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'),
11347    monthsShort : 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
11348    weekdays : 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'),
11349    weekdaysShort : 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
11350    weekdaysMin : 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
11351    weekdaysParseExact : true,
11352    longDateFormat : {
11353        LT : 'h:mm A',
11354        LTS : 'h:mm:ss A',
11355        L : 'DD/MM/YYYY',
11356        LL : 'D MMMM YYYY',
11357        LLL : 'D MMMM YYYY h:mm A',
11358        LLLL : 'dddd, D MMMM YYYY h:mm A'
11359    },
11360    calendar : {
11361        sameDay : '[Namuhla nga] LT',
11362        nextDay : '[Kusasa nga] LT',
11363        nextWeek : 'dddd [nga] LT',
11364        lastDay : '[Itolo nga] LT',
11365        lastWeek : 'dddd [leliphelile] [nga] LT',
11366        sameElse : 'L'
11367    },
11368    relativeTime : {
11369        future : 'nga %s',
11370        past : 'wenteka nga %s',
11371        s : 'emizuzwana lomcane',
11372        m : 'umzuzu',
11373        mm : '%d emizuzu',
11374        h : 'lihora',
11375        hh : '%d emahora',
11376        d : 'lilanga',
11377        dd : '%d emalanga',
11378        M : 'inyanga',
11379        MM : '%d tinyanga',
11380        y : 'umnyaka',
11381        yy : '%d iminyaka'
11382    },
11383    meridiemParse: /ekuseni|emini|entsambama|ebusuku/,
11384    meridiem : function (hours, minutes, isLower) {
11385        if (hours < 11) {
11386            return 'ekuseni';
11387        } else if (hours < 15) {
11388            return 'emini';
11389        } else if (hours < 19) {
11390            return 'entsambama';
11391        } else {
11392            return 'ebusuku';
11393        }
11394    },
11395    meridiemHour : function (hour, meridiem) {
11396        if (hour === 12) {
11397            hour = 0;
11398        }
11399        if (meridiem === 'ekuseni') {
11400            return hour;
11401        } else if (meridiem === 'emini') {
11402            return hour >= 11 ? hour : hour + 12;
11403        } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') {
11404            if (hour === 0) {
11405                return 0;
11406            }
11407            return hour + 12;
11408        }
11409    },
11410    ordinalParse: /\d{1,2}/,
11411    ordinal : '%d',
11412    week : {
11413        dow : 1, // Monday is the first day of the week.
11414        doy : 4  // The week that contains Jan 4th is the first week of the year.
11415    }
11416});
11417
11418//! moment.js locale configuration
11419//! locale : Swedish [sv]
11420//! author : Jens Alm : https://github.com/ulmus
11421
11422hooks.defineLocale('sv', {
11423    months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
11424    monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
11425    weekdays : 'sÃ¶ndag_mÃ¥ndag_tisdag_onsdag_torsdag_fredag_lÃ¶rdag'.split('_'),
11426    weekdaysShort : 'sÃ¶n_mÃ¥n_tis_ons_tor_fre_lÃ¶r'.split('_'),
11427    weekdaysMin : 'sÃ¶_mÃ¥_ti_on_to_fr_lÃ¶'.split('_'),
11428    longDateFormat : {
11429        LT : 'HH:mm',
11430        LTS : 'HH:mm:ss',
11431        L : 'YYYY-MM-DD',
11432        LL : 'D MMMM YYYY',
11433        LLL : 'D MMMM YYYY [kl.] HH:mm',
11434        LLLL : 'dddd D MMMM YYYY [kl.] HH:mm',
11435        lll : 'D MMM YYYY HH:mm',
11436        llll : 'ddd D MMM YYYY HH:mm'
11437    },
11438    calendar : {
11439        sameDay: '[Idag] LT',
11440        nextDay: '[Imorgon] LT',
11441        lastDay: '[IgÃ¥r] LT',
11442        nextWeek: '[PÃ¥] dddd LT',
11443        lastWeek: '[I] dddd[s] LT',
11444        sameElse: 'L'
11445    },
11446    relativeTime : {
11447        future : 'om %s',
11448        past : 'fÃ¶r %s sedan',
11449        s : 'nÃ¥gra sekunder',
11450        m : 'en minut',
11451        mm : '%d minuter',
11452        h : 'en timme',
11453        hh : '%d timmar',
11454        d : 'en dag',
11455        dd : '%d dagar',
11456        M : 'en mÃ¥nad',
11457        MM : '%d mÃ¥nader',
11458        y : 'ett Ã¥r',
11459        yy : '%d Ã¥r'
11460    },
11461    ordinalParse: /\d{1,2}(e|a)/,
11462    ordinal : function (number) {
11463        var b = number % 10,
11464            output = (~~(number % 100 / 10) === 1) ? 'e' :
11465            (b === 1) ? 'a' :
11466            (b === 2) ? 'a' :
11467            (b === 3) ? 'e' : 'e';
11468        return number + output;
11469    },
11470    week : {
11471        dow : 1, // Monday is the first day of the week.
11472        doy : 4  // The week that contains Jan 4th is the first week of the year.
11473    }
11474});
11475
11476//! moment.js locale configuration
11477//! locale : Swahili [sw]
11478//! author : Fahad Kassim : https://github.com/fadsel
11479
11480hooks.defineLocale('sw', {
11481    months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
11482    monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
11483    weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
11484    weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
11485    weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
11486    weekdaysParseExact : true,
11487    longDateFormat : {
11488        LT : 'HH:mm',
11489        LTS : 'HH:mm:ss',
11490        L : 'DD.MM.YYYY',
11491        LL : 'D MMMM YYYY',
11492        LLL : 'D MMMM YYYY HH:mm',
11493        LLLL : 'dddd, D MMMM YYYY HH:mm'
11494    },
11495    calendar : {
11496        sameDay : '[leo saa] LT',
11497        nextDay : '[kesho saa] LT',
11498        nextWeek : '[wiki ijayo] dddd [saat] LT',
11499        lastDay : '[jana] LT',
11500        lastWeek : '[wiki iliyopita] dddd [saat] LT',
11501        sameElse : 'L'
11502    },
11503    relativeTime : {
11504        future : '%s baadaye',
11505        past : 'tokea %s',
11506        s : 'hivi punde',
11507        m : 'dakika moja',
11508        mm : 'dakika %d',
11509        h : 'saa limoja',
11510        hh : 'masaa %d',
11511        d : 'siku moja',
11512        dd : 'masiku %d',
11513        M : 'mwezi mmoja',
11514        MM : 'miezi %d',
11515        y : 'mwaka mmoja',
11516        yy : 'miaka %d'
11517    },
11518    week : {
11519        dow : 1, // Monday is the first day of the week.
11520        doy : 7  // The week that contains Jan 1st is the first week of the year.
11521    }
11522});
11523
11524//! moment.js locale configuration
11525//! locale : Tamil [ta]
11526//! author : Arjunkumar Krishnamoorthy : https://github.com/tk120404
11527
11528var symbolMap$11 = {
11529    '1': 'à¯§',
11530    '2': 'à¯¨',
11531    '3': 'à¯©',
11532    '4': 'à¯ª',
11533    '5': 'à¯«',
11534    '6': 'à¯¬',
11535    '7': 'à¯',
11536    '8': 'à¯®',
11537    '9': 'à¯¯',
11538    '0': 'à¯¦'
11539};

vendor: 6,188 bytes, lines 11540-11681

11540var numberMap$10 = {
11541    'à¯§': '1',
11542    'à¯¨': '2',
11543    'à¯©': '3',
11544    'à¯ª': '4',
11545    'à¯«': '5',
11546    'à¯¬': '6',
11547    'à¯': '7',
11548    'à¯®': '8',
11549    'à¯¯': '9',
11550    'à¯¦': '0'
11551};
11552
11553hooks.defineLocale('ta', {
11554    months : 'à®à®©à®µà®°à®¿_à®ªà®¿à®ªà¯à®°à®µà®°à®¿_à®®à®¾à®°à¯à®à¯_à®à®ªà¯à®°à®²à¯_à®®à¯_à®à¯à®©à¯_à®à¯à®²à¯_à®à®à®¸à¯à®à¯_à®à¯à®ªà¯à®à¯à®®à¯à®ªà®°à¯_à®à®à¯à®à¯à®¾à®ªà®°à¯_à®¨à®µà®®à¯à®ªà®°à¯_à®à®¿à®à®®à¯à®ªà®°à¯'.split('_'),
11555    monthsShort : 'à®à®©à®µà®°à®¿_à®ªà®¿à®ªà¯à®°à®µà®°à®¿_à®®à®¾à®°à¯à®à¯_à®à®ªà¯à®°à®²à¯_à®®à¯_à®à¯à®©à¯_à®à¯à®²à¯_à®à®à®¸à¯à®à¯_à®à¯à®ªà¯à®à¯à®®à¯à®ªà®°à¯_à®à®à¯à®à¯à®¾à®ªà®°à¯_à®¨à®µà®®à¯à®ªà®°à¯_à®à®¿à®à®®à¯à®ªà®°à¯'.split('_'),
11556    weekdays : 'à®à®¾à®¯à®¿à®±à¯à®±à¯à®à¯à®à®¿à®´à®®à¯_à®¤à®¿à®à¯à®à®à¯à®à®¿à®´à®®à¯_à®à¯à®µà¯à®µà®¾à®¯à¯à®à®¿à®´à®®à¯_à®ªà¯à®¤à®©à¯à®à®¿à®´à®®à¯_à®µà®¿à®¯à®¾à®´à®à¯à®à®¿à®´à®®à¯_à®µà¯à®³à¯à®³à®¿à®à¯à®à®¿à®´à®®à¯_à®à®©à®¿à®à¯à®à®¿à®´à®®à¯'.split('_'),
11557    weekdaysShort : 'à®à®¾à®¯à®¿à®±à¯_à®¤à®¿à®à¯à®à®³à¯_à®à¯à®µà¯à®µà®¾à®¯à¯_à®ªà¯à®¤à®©à¯_à®µà®¿à®¯à®¾à®´à®©à¯_à®µà¯à®³à¯à®³à®¿_à®à®©à®¿'.split('_'),
11558    weekdaysMin : 'à®à®¾_à®¤à®¿_à®à¯_à®ªà¯_à®µà®¿_à®µà¯_à®'.split('_'),
11559    longDateFormat : {
11560        LT : 'HH:mm',
11561        LTS : 'HH:mm:ss',
11562        L : 'DD/MM/YYYY',
11563        LL : 'D MMMM YYYY',
11564        LLL : 'D MMMM YYYY, HH:mm',
11565        LLLL : 'dddd, D MMMM YYYY, HH:mm'
11566    },
11567    calendar : {
11568        sameDay : '[à®à®©à¯à®±à¯] LT',
11569        nextDay : '[à®¨à®¾à®³à¯] LT',
11570        nextWeek : 'dddd, LT',
11571        lastDay : '[à®¨à¯à®±à¯à®±à¯] LT',
11572        lastWeek : '[à®à®à®¨à¯à®¤ à®µà®¾à®°à®®à¯] dddd, LT',
11573        sameElse : 'L'
11574    },
11575    relativeTime : {
11576        future : '%s à®à®²à¯',
11577        past : '%s à®®à¯à®©à¯',
11578        s : 'à®à®°à¯ à®à®¿à®² à®µà®¿à®¨à®¾à®à®¿à®à®³à¯',
11579        m : 'à®à®°à¯ à®¨à®¿à®®à®¿à®à®®à¯',
11580        mm : '%d à®¨à®¿à®®à®¿à®à®à¯à®à®³à¯',
11581        h : 'à®à®°à¯ à®®à®£à®¿ à®¨à¯à®°à®®à¯',
11582        hh : '%d à®®à®£à®¿ à®¨à¯à®°à®®à¯',
11583        d : 'à®à®°à¯ à®¨à®¾à®³à¯',
11584        dd : '%d à®¨à®¾à®à¯à®à®³à¯',
11585        M : 'à®à®°à¯ à®®à®¾à®¤à®®à¯',
11586        MM : '%d à®®à®¾à®¤à®à¯à®à®³à¯',
11587        y : 'à®à®°à¯ à®µà®°à¯à®à®®à¯',
11588        yy : '%d à®à®£à¯à®à¯à®à®³à¯'
11589    },
11590    ordinalParse: /\d{1,2}à®µà®¤à¯/,
11591    ordinal : function (number) {
11592        return number + 'à®µà®¤à¯';
11593    },
11594    preparse: function (string) {
11595        return string.replace(/[à¯§à¯¨à¯©à¯ªà¯«à¯¬à¯à¯®à¯¯à¯¦]/g, function (match) {
11596            return numberMap$10[match];
11597        });
11598    },
11599    postformat: function (string) {
11600        return string.replace(/\d/g, function (match) {
11601            return symbolMap$11[match];
11602        });
11603    },
11604    // refer http://ta.wikipedia.org/s/1er1
11605    meridiemParse: /à®¯à®¾à®®à®®à¯|à®µà¯à®à®±à¯|à®à®¾à®²à¯|à®¨à®£à¯à®ªà®à®²à¯|à®à®±à¯à®ªà®¾à®à¯|à®®à®¾à®²à¯/,
11606    meridiem : function (hour, minute, isLower) {
11607        if (hour < 2) {
11608            return ' à®¯à®¾à®®à®®à¯';
11609        } else if (hour < 6) {
11610            return ' à®µà¯à®à®±à¯';  // à®µà¯à®à®±à¯
11611        } else if (hour < 10) {
11612            return ' à®à®¾à®²à¯'; // à®à®¾à®²à¯
11613        } else if (hour < 14) {
11614            return ' à®¨à®£à¯à®ªà®à®²à¯'; // à®¨à®£à¯à®ªà®à®²à¯
11615        } else if (hour < 18) {
11616            return ' à®à®±à¯à®ªà®¾à®à¯'; // à®à®±à¯à®ªà®¾à®à¯
11617        } else if (hour < 22) {
11618            return ' à®®à®¾à®²à¯'; // à®®à®¾à®²à¯
11619        } else {
11620            return ' à®¯à®¾à®®à®®à¯';
11621        }
11622    },
11623    meridiemHour : function (hour, meridiem) {
11624        if (hour === 12) {
11625            hour = 0;
11626        }
11627        if (meridiem === 'à®¯à®¾à®®à®®à¯') {
11628            return hour < 2 ? hour : hour + 12;
11629        } else if (meridiem === 'à®µà¯à®à®±à¯' || meridiem === 'à®à®¾à®²à¯') {
11630            return hour;
11631        } else if (meridiem === 'à®¨à®£à¯à®ªà®à®²à¯') {
11632            return hour >= 10 ? hour : hour + 12;
11633        } else {
11634            return hour + 12;
11635        }
11636    },
11637    week : {
11638        dow : 0, // Sunday is the first day of the week.
11639        doy : 6  // The week that contains Jan 1st is the first week of the year.
11640    }
11641});
11642
11643//! moment.js locale configuration
11644//! locale : Telugu [te]
11645//! author : Krishna Chaitanya Thota : https://github.com/kcthota
11646
11647hooks.defineLocale('te', {
11648    months : 'à°à°¨à°µà°°à°¿_à°«à°¿à°¬à±à°°à°µà°°à°¿_à°®à°¾à°°à±à°à°¿_à°à°ªà±à°°à°¿à°²à±_à°®à±_à°à±à°¨à±_à°à±à°²à±à±_à°à°à°¸à±à°à±_à°¸à±à°ªà±à°à±à°à°¬à°°à±_à°à°à±à°à±à°¬à°°à±_à°¨à°µà°à°¬à°°à±_à°¡à°¿à°¸à±à°à°¬à°°à±'.split('_'),
11649    monthsShort : 'à°à°¨._à°«à°¿à°¬à±à°°._à°®à°¾à°°à±à°à°¿_à°à°ªà±à°°à°¿._à°®à±_à°à±à°¨à±_à°à±à°²à±à±_à°à°._à°¸à±à°ªà±._à°à°à±à°à±._à°¨à°µ._à°¡à°¿à°¸à±.'.split('_'),
11650    monthsParseExact : true,
11651    weekdays : 'à°à°¦à°¿à°µà°¾à°°à°_à°¸à±à°®à°µà°¾à°°à°_à°®à°à°à°³à°µà°¾à°°à°_à°¬à±à°§à°µà°¾à°°à°_à°à±à°°à±à°µà°¾à°°à°_à°¶à±à°à±à°°à°µà°¾à°°à°_à°¶à°¨à°¿à°µà°¾à°°à°'.split('_'),
11652    weekdaysShort : 'à°à°¦à°¿_à°¸à±à°®_à°®à°à°à°³_à°¬à±à°§_à°à±à°°à±_à°¶à±à°à±à°°_à°¶à°¨à°¿'.split('_'),
11653    weekdaysMin : 'à°_à°¸à±_à°®à°_à°¬à±_à°à±_à°¶à±_à°¶'.split('_'),
11654    longDateFormat : {
11655        LT : 'A h:mm',
11656        LTS : 'A h:mm:ss',
11657        L : 'DD/MM/YYYY',
11658        LL : 'D MMMM YYYY',
11659        LLL : 'D MMMM YYYY, A h:mm',
11660        LLLL : 'dddd, D MMMM YYYY, A h:mm'
11661    },
11662    calendar : {
11663        sameDay : '[à°¨à±à°¡à±] LT',
11664        nextDay : '[à°°à±à°ªà±] LT',
11665        nextWeek : 'dddd, LT',
11666        lastDay : '[à°¨à°¿à°¨à±à°¨] LT',
11667        lastWeek : '[à°à°¤] dddd, LT',
11668        sameElse : 'L'
11669    },
11670    relativeTime : {
11671        future : '%s à°²à±',
11672        past : '%s à°à±à°°à°¿à°¤à°',
11673        s : 'à°à±à°¨à±à°¨à°¿ à°à±à°·à°£à°¾à°²à±',
11674        m : 'à°à° à°¨à°¿à°®à°¿à°·à°',
11675        mm : '%d à°¨à°¿à°®à°¿à°·à°¾à°²à±',
11676        h : 'à°à° à°à°à°',
11677        hh : '%d à°à°à°à°²à±',
11678        d : 'à°à° à°°à±à°à±',
11679        dd : '%d à°°à±à°à±à°²à±',
11680        M : 'à°à° à°¨à±à°²',
11681        MM : '%d à°¨à±à°²à°²à±',

vendor: 1,028 bytes, lines 11682-11708

11682        y : 'à°à° à°¸à°à°µà°¤à±à°¸à°°à°',
11683        yy : '%d à°¸à°à°µà°¤à±à°¸à°°à°¾à°²à±'
11684    },
11685    ordinalParse : /\d{1,2}à°µ/,
11686    ordinal : '%dà°µ',
11687    meridiemParse: /à°°à°¾à°¤à±à°°à°¿|à°à°¦à°¯à°|à°®à°§à±à°¯à°¾à°¹à±à°¨à°|à°¸à°¾à°¯à°à°¤à±à°°à°/,
11688    meridiemHour : function (hour, meridiem) {
11689        if (hour === 12) {
11690            hour = 0;
11691        }
11692        if (meridiem === 'à°°à°¾à°¤à±à°°à°¿') {
11693            return hour < 4 ? hour : hour + 12;
11694        } else if (meridiem === 'à°à°¦à°¯à°') {
11695            return hour;
11696        } else if (meridiem === 'à°®à°§à±à°¯à°¾à°¹à±à°¨à°') {
11697            return hour >= 10 ? hour : hour + 12;
11698        } else if (meridiem === 'à°¸à°¾à°¯à°à°¤à±à°°à°') {
11699            return hour + 12;
11700        }
11701    },
11702    meridiem : function (hour, minute, isLower) {
11703        if (hour < 4) {
11704            return 'à°°à°¾à°¤à±à°°à°¿';
11705        } else if (hour < 10) {
11706            return 'à°à°¦à°¯à°';
11707        } else if (hour < 17) {
11708            return 'à°®à°§à±à°¯à°¾à°¹à±à°¨à°

11708';
11709        } else if (hour < 20) {
11710            return 'à°¸à°¾à°¯à°à°¤à±à°°à°';
11711        } else {
11712            return 'à°°à°¾à°¤à±à°°à°¿';
11713        }
11714    },
11715    week : {
11716        dow : 0, // Sunday is the first day of the week.
11717        doy : 6  // The week that contains Jan 1st is the first week of the year.
11718    }
11719});
11720
11721//! moment.js locale configuration
11722//! locale : Tetun Dili (East Timor) [tet]
11723//! author : Joshua Brooks : https://github.com/joshbrooks
11724//! author : Onorio De J. Afonso : https://github.com/marobo
11725
11726hooks.defineLocale('tet', {
11727    months : 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juniu_Juliu_Augustu_Setembru_Outubru_Novembru_Dezembru'.split('_'),
11728    monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Aug_Set_Out_Nov_Dez'.split('_'),
11729    weekdays : 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sexta_Sabadu'.split('_'),
11730    weekdaysShort : 'Dom_Seg_Ters_Kua_Kint_Sext_Sab'.split('_'),
11731    weekdaysMin : 'Do_Seg_Te_Ku_Ki_Sex_Sa'.split('_'),
11732    longDateFormat : {
11733        LT : 'HH:mm',
11734        LTS : 'HH:mm:ss',
11735        L : 'DD/MM/YYYY',
11736        LL : 'D MMMM YYYY',
11737        LLL : 'D MMMM YYYY HH:mm',
11738        LLLL : 'dddd, D MMMM YYYY HH:mm'
11739    },
11740    calendar : {
11741        sameDay: '[Ohin iha] LT',
11742        nextDay: '[Aban iha] LT',
11743        nextWeek: 'dddd [iha] LT',
11744        lastDay: '[Horiseik iha] LT',
11745        lastWeek: 'dddd [semana kotuk] [iha] LT',
11746        sameElse: 'L'
11747    },
11748    relativeTime : {
11749        future : 'iha %s',
11750        past : '%s liuba',
11751        s : 'minutu balun',
11752        m : 'minutu ida',
11753        mm : 'minutus %d',
11754        h : 'horas ida',
11755        hh : 'horas %d',
11756        d : 'loron ida',
11757        dd : 'loron %d',
11758        M : 'fulan ida',
11759        MM : 'fulan %d',
11760        y : 'tinan ida',
11761        yy : 'tinan %d'
11762    },
11763    ordinalParse: /\d{1,2}(st|nd|rd|th)/,
11764    ordinal : function (number) {
11765        var b = number % 10,
11766            output = (~~(number % 100 / 10) === 1) ? 'th' :
11767            (b === 1) ? 'st' :
11768            (b === 2) ? 'nd' :
11769            (b === 3) ? 'rd' : 'th';
11770        return number + output;
11771    },
11772    week : {
11773        dow : 1, // Monday is the first day of the week.
11774        doy : 4  // The week that contains Jan 4th is the first week of the year.
11775    }
11776});
11777
11778//! moment.js locale configuration
11779//! locale : Thai [th]
11780//! author : Kridsada Thanabulpong : https://github.com/sirn
11781
11782hooks.defineLocale('th', {
11783    months : 'à¸¡à¸à¸£à¸²à¸à¸¡_à¸à¸¸à¸¡à¸ à¸²à¸à¸±à¸à¸à¹_à¸¡à¸µà¸à¸²à¸à¸¡_à¹à¸¡à¸©à¸²à¸¢à¸_à¸à¸¤à¸©à¸ à¸²à¸à¸¡_à¸¡à¸´à¸à¸¸à¸à¸²à¸¢à¸_à¸à¸£à¸à¸à¸²à¸à¸¡_à¸ªà¸´à¸à¸«à¸²à¸à¸¡_à¸à¸±à¸à¸¢à¸²à¸¢à¸_à¸à¸¸à¸¥à¸²à¸à¸¡_à¸à¸¤à¸¨à¸à¸´à¸à¸²à¸¢à¸_à¸à¸±à¸à¸§à¸²à¸à¸¡'.split('_'),
11784    monthsShort : 'à¸¡.à¸._à¸.à¸._à¸¡à¸µ.à¸._à¹à¸¡.à¸¢._à¸.à¸._à¸¡à¸´.à¸¢._à¸.à¸._à¸ª.à¸._à¸.à¸¢._à¸.à¸._à¸.à¸¢._à¸.à¸.'.split('_'),
11785    monthsParseExact: true,
11786    weekdays : 'à¸à¸²à¸à¸´à¸à¸¢à¹_à¸à¸±à¸à¸à¸£à¹_à¸à¸±à¸à¸à¸²à¸£_à¸à¸¸à¸_à¸à¸¤à¸«à¸±à¸ªà¸à¸à¸µ_à¸¨à¸¸à¸à¸£à¹_à¹à¸ªà¸²à¸£à¹'.split('_'),
11787    weekdaysShort : 'à¸à¸²à¸à¸´à¸à¸¢à¹_à¸à¸±à¸à¸à¸£à¹_à¸à¸±à¸à¸à¸²à¸£_à¸à¸¸à¸_à¸à¸¤à¸«à¸±à¸ª_à¸¨à¸¸à¸à¸£à¹_à¹à¸ªà¸²à¸£à¹'.split('_'), // yes, three characters difference
11788    weekdaysMin : 'à¸à¸²._à¸._à¸._à¸._à¸à¸¤._à¸¨._à¸ª.'.split('_'),
11789    weekdaysParseExact : true,
11790    longDateFormat : {
11791        LT : 'H:mm',
11792        LTS : 'H:mm:ss',
11793        L : 'YYYY/MM/DD',
11794        LL : 'D MMMM YYYY',
11795        LLL : 'D MMMM YYYY à¹à¸§à¸¥à¸² H:mm',
11796        LLLL : 'à¸§à¸±à¸ddddà¸à¸µà¹ D MMMM YYYY à¹à¸§à¸¥à¸² H:mm'
11797    },
11798    meridiemParse: /à¸à¹à¸à¸à¹à¸à¸µà¹à¸¢à¸|à¸«à¸¥à¸±à¸à¹à¸à¸µà¹à¸¢à¸/,
11799    isPM: function (input) {
11800        return input === 'à¸«à¸¥à¸±à¸à¹à¸à¸µà¹à¸¢à¸';
11801    },
11802    meridiem : function (hour, minute, isLower) {
11803        if (hour < 12) {
11804            return 'à¸à¹à¸à¸à¹à¸à¸µà¹à¸¢à¸';
11805        } else {
11806            return 'à¸«à¸¥à¸±à¸à¹à¸à¸µà¹à¸¢à¸';
11807        }
11808    },
11809    calendar : {
11810        sameDay : '[à¸§à¸±à¸à¸à¸µà¹ à¹à¸§à¸¥à¸²] LT',
11811        nextDay : '[à¸à¸£à¸¸à¹à¸à¸à¸µà¹ à¹à¸§à¸¥à¸²] LT',
11812        nextWeek : 'dddd[à¸«à¸à¹à¸² à¹à¸§à¸¥à¸²] LT',
11813        lastDay : '[à¹à¸¡à¸·à¹à¸à¸§à¸²à¸à¸à¸µà¹ à¹à¸§à¸¥à¸²] LT',
11814        lastWeek : '[à¸§à¸±à¸]dddd[à¸à¸µà¹à¹à¸¥à¹à¸§ à¹à¸§à¸¥à¸²] LT',
11815        sameElse : 'L'
11816    },
11817    relativeTime : {
11818        future : 'à¸à¸µà¸ %s',
11819        past : '%sà¸à¸µà¹à¹à¸¥à¹à¸§',
11820        s : 'à¹à¸¡à¹à¸à¸µà¹à¸§à¸´à¸à¸²à¸à¸µ',
11821        m : '1 à¸à¸²à¸à¸µ',
11822        mm : '%d à¸à¸²à¸à¸µ',
11823        h : '1 à¸à¸±à¹à¸§à¹à¸¡à¸',
11824        hh : '%d à¸à¸±à¹à¸§à¹à¸¡à¸',
11825        d : '1 à¸§à¸±à¸',
11826        dd : '%d à¸§à¸±à¸',
11827        M : '1 à¹à¸à¸·à¸à¸',
11828        MM : '%d à¹à¸à¸·à¸à¸',
11829        y : '1 à¸à¸µ',
11830        yy : '%d à¸à¸µ'
11831    }
11832});
11833
11834//! moment.js locale configuration
11835//! locale : Tagalog (Philippines) [tl-ph]
11836//! author : Dan Hagman : https://github.com/hagmandan
11837
11838hooks.defineLocale('tl-ph', {
11839    months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
11840    monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
11841    weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
11842    weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
11843    weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
11844    longDateFormat : {
11845        LT : 'HH:mm',
11846        LTS : 'HH:mm:ss',
11847        L : 'MM/D/YYYY',
11848        LL : 'MMMM D, YYYY',
11849        LLL : 'MMMM D, YYYY HH:mm',
11850        LLLL : 'dddd, MMMM DD, YYYY HH:mm'
11851    },
11852    calendar : {
11853        sameDay: 'LT [ngayong araw]',
11854        nextDay: '[Bukas ng] LT',
11855        nextWeek: 'LT [sa susunod na] dddd',
11856        lastDay: 'LT [kahapon]',
11857        lastWeek: 'LT [noong nakaraang] dddd',
11858        sameElse: 'L'
11859    },
11860    relativeTime : {
11861        future : 'sa loob ng %s',
11862        past : '%s ang nakalipas',
11863        s : 'ilang segundo',
11864        m : 'isang minuto',
11865        mm : '%d minuto',
11866        h : 'isang oras',
11867        hh : '%d oras',
11868        d : 'isang araw',
11869        dd : '%d araw',
11870        M : 'isang buwan',
11871        MM : '%d buwan',
11872        y : 'isang taon',
11873        yy : '%d taon'
11874    },
11875    ordinalParse: /\d{1,2}/,
11876    ordinal : function (number) {
11877        return number;
11878    },
11879    week : {
11880        dow : 1, // Monday is the first day of the week.
11881        doy : 4  // The week that contains Jan 4th is the first week of the year.
11882    }
11883});
11884
11885//! moment.js locale configuration
11886//! locale : Klingon [tlh]
11887//! author : Dominika Kruk : https://github.com/amaranthrose
11888
11889var numbersNouns = 'pagh_waâ_chaâ_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
11890
11891function translateFuture(output) {
11892    var time = output;
11893    time = (output.indexOf('jaj') !== -1) ?
11894    time.slice(0, -3) + 'leS' :
11895    (output.indexOf('jar') !== -1) ?
11896    time.slice(0, -3) + 'waQ' :
11897    (output.indexOf('DIS') !== -1) ?
11898    time.slice(0, -3) + 'nem' :
11899    time + ' pIq';
11900    return time;
11901}
11902
11903function translatePast(output) {
11904    var time = output;
11905    time = (output.indexOf('jaj') !== -1) ?
11906    time.slice(0, -3) + 'Huâ' :
11907    (output.indexOf('jar') !== -1) ?
11908    time.slice(0, -3) + 'wen' :
11909    (output.indexOf('DIS') !== -1) ?
11910    time.slice(0, -3) + 'ben' :
11911    time + ' ret';
11912    return time;
11913}
11914
11915function translate$9(number, withoutSuffix, string, isFuture) {
11916    var numberNoun = numberAsNoun(number);
11917    switch (string) {
11918        case 'mm':
11919            return numberNoun + ' tup';
11920        case 'hh':
11921            return numberNoun + ' rep';
11922        case 'dd':
11923            return numberNoun + ' jaj';
11924        case 'MM':
11925            return numberNoun + ' jar';
11926        case 'yy':
11927            return numberNoun + ' DIS';
11928    }
11929}
11930
11931function numberAsNoun(number) {
11932    var hundred = Math.floor((number % 1000) / 100),
11933    ten = Math.floor((number % 100) / 10),
11934    one = number % 10,
11935    word = '';
11936    if (hundred > 0) {
11937        word += numbersNouns[hundred] + 'vatlh';
11938    }
11939    if (ten > 0) {
11940        word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH';
11941    }
11942    if (one > 0) {
11943        word += ((word !== '') ? ' ' : '') + numbersNouns[one];
11944    }
11945    return (word === '') ? 'pagh' : word;
11946}
11947
11948hooks.defineLocale('tlh', {
11949    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('_'),
11950    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('_'),
11951    monthsParseExact : true,
11952    weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
11953    weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
11954    weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
11955    longDateFormat : {
11956        LT : 'HH:mm',
11957        LTS : 'HH:mm:ss',
11958        L : 'DD.MM.YYYY',
11959        LL : 'D MMMM YYYY',
11960        LLL : 'D MMMM YYYY HH:mm',
11961        LLLL : 'dddd, D MMMM YYYY HH:mm'
11962    },
11963    calendar : {
11964        sameDay: '[DaHjaj] LT',
11965        nextDay: '[waâleS] LT',
11966        nextWeek: 'LLL',
11967        lastDay: '[waâHuâ] LT',
11968        lastWeek: 'LLL',
11969        sameElse: 'L'
11970    },
11971    relativeTime : {
11972        future : translateFuture,
11973        past : translatePast,
11974        s : 'puS lup',
11975        m : 'waâ tup',
11976        mm : translate$9,
11977        h : 'waâ rep',
11978        hh : translate$9,
11979        d : 'waâ jaj',
11980        dd : translate$9,
11981        M : 'waâ jar',
11982        MM : translate$9,
11983        y : 'waâ DIS',
11984        yy : translate$9
11985    },
11986    ordinalParse: /\d{1,2}\./,
11987    ordinal : '%d.',
11988    week : {
11989        dow : 1, // Monday is the first day of the week.
11990        doy : 4  // The week that contains Jan 4th is the first week of the year.
11991    }
11992});
11993
11994//! moment.js locale configuration
11995//! locale : Turkish [tr]
11996//! authors : Erhan Gundogan : https://github.com/erhangundogan,
11997//!           Burak YiÄit Kaya: https://github.com/BYK
11998
11999var suffixes$3 = {
12000    1: '\'inci',
12001    5: '\'inci',
12002    8: '\'inci',
12003    70: '\'inci',
12004    80: '\'inci',
12005    2: '\'nci',
12006    7: '\'nci',
12007    20: '\'nci',
12008    50: '\'nci',
12009    3: '\'Ã¼ncÃ¼',
12010    4: '\'Ã¼ncÃ¼',
12011    100: '\'Ã¼ncÃ¼',

12012    6: '\'ncÄ±',
12013    9: '\'uncu',
12014    10: '\'uncu',
12015    30: '\'uncu',
12016    60: '\'Ä±ncÄ±',
12017    90: '\'Ä±ncÄ±'
12018};
12019
12020hooks.defineLocale('tr', {
12021    months : 'Ocak_Åubat_Mart_Nisan_MayÄ±s_Haziran_Temmuz_AÄustos_EylÃ¼l_Ekim_KasÄ±m_AralÄ±k'.split('_'),
12022    monthsShort : 'Oca_Åub_Mar_Nis_May_Haz_Tem_AÄu_Eyl_Eki_Kas_Ara'.split('_'),
12023    weekdays : 'Pazar_Pazartesi_SalÄ±_ÃarÅamba_PerÅembe_Cuma_Cumartesi'.split('_'),
12024    weekdaysShort : 'Paz_Pts_Sal_Ãar_Per_Cum_Cts'.split('_'),
12025    weekdaysMin : 'Pz_Pt_Sa_Ãa_Pe_Cu_Ct'.split('_'),
12026    longDateFormat : {
12027        LT : 'HH:mm',
12028        LTS : 'HH:mm:ss',
12029        L : 'DD.MM.YYYY',
12030        LL : 'D MMMM YYYY',
12031        LLL : 'D MMMM YYYY HH:mm',
12032        LLLL : 'dddd, D MMMM YYYY HH:mm'
12033    },
12034    calendar : {
12035        sameDay : '[bugÃ¼n saat] LT',
12036        nextDay : '[yarÄ±n saat] LT',
12037        nextWeek : '[haftaya] dddd [saat] LT',
12038        lastDay : '[dÃ¼n] LT',
12039        lastWeek : '[geÃ§en hafta] dddd [saat] LT',
12040        sameElse : 'L'
12041    },
12042    relativeTime : {
12043        future : '%s sonra',
12044        past : '%s Ã¶nce',
12045        s : 'birkaÃ§ saniye',
12046        m : 'bir dakika',
12047        mm : '%d dakika',
12048        h : 'bir saat',
12049        hh : '%d saat',
12050        d : 'bir gÃ¼n',
12051        dd : '%d gÃ¼n',
12052        M : 'bir ay',
12053        MM : '%d ay',
12054        y : 'bir yÄ±l',
12055        yy : '%d yÄ±l'
12056    },
12057    ordinalParse: /\d{1,2}'(inci|nci|Ã¼ncÃ¼|ncÄ±|uncu|Ä±ncÄ±)/,
12058    ordinal : function (number) {
12059        if (number === 0) {  // special case for zero
12060            return number + '\'Ä±ncÄ±';
12061        }
12062        var a = number % 10,
12063            b = number % 100 - a,
12064            c = number >= 100 ? 100 : null;
12065        return number + (suffixes$3[a] || suffixes$3[b] || suffixes$3[c]);
12066    },
12067    week : {
12068        dow : 1, // Monday is the first day of the week.
12069        doy : 7  // The week that contains Jan 1st is the first week of the year.
12070    }
12071});
12072
12073//! moment.js locale configuration
12074//! locale : Talossan [tzl]
12075//! author : Robin van der Vliet : https://github.com/robin0van0der0v
12076//! author : IustÃ¬ Canun
12077
12078// After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
12079// This is currently too difficult (maybe even impossible) to add.
12080hooks.defineLocale('tzl', {
12081    months : 'Januar_Fevraglh_MarÃ§_AvrÃ¯u_Mai_GÃ¼n_Julia_Guscht_Setemvar_ListopÃ¤ts_Noemvar_Zecemvar'.split('_'),
12082    monthsShort : 'Jan_Fev_Mar_Avr_Mai_GÃ¼n_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
12083    weekdays : 'SÃºladi_LÃºneÃ§i_Maitzi_MÃ¡rcuri_XhÃºadi_ViÃ©nerÃ§i_SÃ¡turi'.split('_'),
12084    weekdaysShort : 'SÃºl_LÃºn_Mai_MÃ¡r_XhÃº_ViÃ©_SÃ¡t'.split('_'),
12085    weekdaysMin : 'SÃº_LÃº_Ma_MÃ¡_Xh_Vi_SÃ¡'.split('_'),
12086    longDateFormat : {
12087        LT : 'HH.mm',
12088        LTS : 'HH.mm.ss',
12089        L : 'DD.MM.YYYY',
12090        LL : 'D. MMMM [dallas] YYYY',
12091        LLL : 'D. MMMM [dallas] YYYY HH.mm',
12092        LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
12093    },
12094    meridiemParse: /d\'o|d\'a/i,
12095    isPM : function (input) {
12096        return 'd\'o' === input.toLowerCase();
12097    },
12098    meridiem : function (hours, minutes, isLower) {
12099        if (hours > 11) {
12100            return isLower ? 'd\'o' : 'D\'O';
12101        } else {
12102            return isLower ? 'd\'a' : 'D\'A';
12103        }
12104    },
12105    calendar : {
12106        sameDay : '[oxhi Ã ] LT',
12107        nextDay : '[demÃ  Ã ] LT',
12108        nextWeek : 'dddd [Ã ] LT',
12109        lastDay : '[ieiri Ã ] LT',
12110        lastWeek : '[sÃ¼r el] dddd [lasteu Ã ] LT',
12111        sameElse : 'L'
12112    },
12113    relativeTime : {
12114        future : 'osprei %s',
12115        past : 'ja%s',
12116        s : processRelativeTime$5,
12117        m : processRelativeTime$5,
12118        mm : processRelativeTime$5,
12119        h : processRelativeTime$5,
12120        hh : processRelativeTime$5,
12121        d : processRelativeTime$5,
12122        dd : processRelativeTime$5,
12123        M : processRelativeTime$5,
12124        MM : processRelativeTime$5,
12125        y : processRelativeTime$5,
12126        yy : processRelativeTime$5
12127    },
12128    ordinalParse: /\d{1,2}\./,
12129    ordinal : '%d.',
12130    week : {
12131        dow : 1, // Monday is the first day of the week.
12132        doy : 4  // The week that contains Jan 4th is the first week of the year.
12133    }
12134});
12135
12136function processRelativeTime$5(number, withoutSuffix, key, isFuture) {
12137    var format = {
12138        's': ['viensas secunds', '\'iensas secunds'],
12139        'm': ['\'n mÃut', '\'iens mÃut'],
12140        'mm': [number + ' mÃuts', '' + number + ' mÃuts'],
12141        'h': ['\'n Ã¾ora', '\'iensa Ã¾ora'],
12142        'hh': [number + ' Ã¾oras', '' + number + ' Ã¾oras'],
12143        'd': ['\'n ziua', '\'iensa ziua'],
12144        'dd': [number + ' ziuas', '' + number + ' ziuas'],
12145        'M': ['\'n mes', '\'iens mes'],
12146        'MM': [number + ' mesen', '' + number + ' mesen'],
12147        'y': ['\'n ar', '\'iens ar'],
12148        'yy': [number + ' ars', '' + number + ' ars']
12149    };
12150    return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]);
12151}
12152
12153//! moment.js locale configuration
12154//! locale : Central Atlas Tamazight Latin [tzm-latn]
12155//! author : Abdel Said : https://github.com/abdelsaid
12156
12157hooks.defineLocale('tzm-latn', {

12158    months : 'innayr_brË¤ayrË¤_marË¤sË¤_ibrir_mayyw_ywnyw_ywlywz_É£wÅ¡t_Å¡wtanbir_ktË¤wbrË¤_nwwanbir_dwjnbir'.split('_'),
12159    monthsShort : 'innayr_brË¤ayrË¤_marË¤sË¤_ibrir_mayyw_ywnyw_ywlywz_É£wÅ¡t_Å¡wtanbir_ktË¤wbrË¤_nwwanbir_dwjnbir'.split('_'),
12160    weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'),
12161    weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'),
12162    weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiá¸yas'.split('_'),
12163    longDateFormat : {
12164        LT : 'HH:mm',
12165        LTS : 'HH:mm:ss',
12166        L : 'DD/MM/YYYY',
12167        LL : 'D MMMM YYYY',
12168        LLL : 'D MMMM YYYY HH:mm',
12169        LLLL : 'dddd D MMMM YYYY HH:mm'
12170    },
12171    calendar : {
12172        sameDay: '[asdkh g] LT',
12173        nextDay: '[aska g] LT',
12174        nextWeek: 'dddd [g] LT',
12175        lastDay: '[assant g] LT',
12176        lastWeek: 'dddd [g] LT',
12177        sameElse: 'L'
12178    },
12179    relativeTime : {
12180        future : 'dadkh s yan %s',
12181        past : 'yan %s',
12182        s : 'imik',
12183        m : 'minuá¸',
12184        mm : '%d minuá¸',
12185        h : 'saÉa',
12186        hh : '%d tassaÉin',
12187        d : 'ass',
12188        dd : '%d ossan',
12189        M : 'ayowr',
12190        MM : '%d iyyirn',
12191        y : 'asgas',
12192        yy : '%d isgasn'
12193    },
12194    week : {
12195        dow : 6, // Saturday is the first day of the week.
12196        doy : 12  // The week that contains Jan 1st is the first week of the year.
12197    }
12198});
12199
12200//! moment.js locale configuration
12201//! locale : Central Atlas Tamazight [tzm]
12202//! author : Abdel Said : https://github.com/abdelsaid
12203
12204hooks.defineLocale('tzm', {
12205    months : 'âµâµâµâ´°âµ¢âµ_â´±âµâ´°âµ¢âµ_âµâ´°âµâµ_âµâ´±âµâµâµ_âµâ´°âµ¢âµ¢âµ_âµ¢âµâµâµ¢âµ_âµ¢âµâµâµ¢âµâµ£_âµâµâµâµ_âµâµâµâ´°âµâ´±âµâµ_â´½âµâµâ´±âµ_âµâµâµ¡â´°âµâ´±âµâµ_â´·âµâµâµâ´±âµâµ'.split('_'),
12206    monthsShort : 'âµâµâµâ´°âµ¢âµ_â´±âµâ´°âµ¢âµ_âµâ´°âµâµ_âµâ´±âµâµâµ_âµâ´°âµ¢âµ¢âµ_âµ¢âµâµâµ¢âµ_âµ¢âµâµâµ¢âµâµ£_âµâµâµâµ_âµâµâµâ´°âµâ´±âµâµ_â´½âµâµâ´±âµ_âµâµâµ¡â´°âµâ´±âµâµ_â´·âµâµâµâ´±âµâµ'.split('_'),
12207    weekdays : 'â´°âµâ´°âµâ´°âµ_â´°âµ¢âµâ´°âµ_â´°âµâµâµâ´°âµ_â´°â´½âµâ´°âµ_â´°â´½âµ¡â´°âµ_â´°âµâµâµâµ¡â´°âµ_â´°âµâµâ´¹âµ¢â´°âµ'.split('_'),
12208    weekdaysShort : 'â´°âµâ´°âµâ´°âµ_â´°âµ¢âµâ´°âµ_â´°âµâµâµâ´°âµ_â´°â´½âµâ´°âµ_â´°â´½âµ¡â´°âµ_â´°âµâµâµâµ¡â´°âµ_â´°âµâµâ´¹âµ¢â´°âµ'.split('_'),
12209    weekdaysMin : 'â´°âµâ´°âµâ´°âµ_â´°âµ¢âµâ´°âµ_â´°âµâµâµâ´°âµ_â´°â´½âµâ´°âµ_â´°â´½âµ¡â´°âµ_â´°âµâµâµâµ¡â´°âµ_â´°âµâµâ´¹âµ¢â´°âµ'.split('_'),
12210    longDateFormat : {
12211        LT : 'HH:mm',
12212        LTS: 'HH:mm:ss',
12213        L : 'DD/MM/YYYY',
12214        LL : 'D MMMM YYYY',
12215        LLL : 'D MMMM YYYY HH:mm',
12216        LLLL : 'dddd D MMMM YYYY HH:mm'
12217    },
12218    calendar : {
12219        sameDay: '[â´°âµâ´·âµ â´´] LT',
12220        nextDay: '[â´°âµâ´½â´° â´´] LT',
12221        nextWeek: 'dddd [â´´] LT',
12222        lastDay: '[â´°âµâ´°âµâµ â´´] LT',
12223        lastWeek: 'dddd [â´´] LT',
12224        sameElse: 'L'
12225    },
12226    relativeTime : {
12227        future : 'â´·â´°â´·âµ âµ âµ¢â´°âµ %s',
12228        past : 'âµ¢â´°âµ %s',
12229        s : 'âµâµâµâ´½',
12230        m : 'âµâµâµâµâ´º',
12231        mm : '%d âµâµâµâµâ´º',
12232        h : 'âµâ´°âµâ´°',
12233        hh : '%d âµâ´°âµâµâ´°âµâµâµ',
12234        d : 'â´°âµâµ',
12235        dd : '%d oâµâµâ´°âµ',
12236        M : 'â´°âµ¢oâµâµ',
12237        MM : '%d âµâµ¢âµ¢âµâµâµ',
12238        y : 'â´°âµâ´³â´°âµ',
12239        yy : '%d âµâµâ´³â´°âµâµ'
12240    },
12241    week : {
12242        dow : 6, // Saturday is the first day of the week.
12243        doy : 12  // The week that contains Jan 1st is the first week of the year.
12244    }
12245});
12246
12247//! moment.js locale configuration
12248//! locale : Ukrainian [uk]
12249//! author : zemlanin : https://github.com/zemlanin
12250//! Author : Menelion ElensÃºle : https://github.com/Oire
12251
12252function plural$6(word, num) {
12253    var forms = word.split('_');
12254    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]);
12255}
12256function relativeTimeWithPlural$4(number, withoutSuffix, key) {
12257    var format = {
12258        'mm': withoutSuffix ? 'ÑÐ²Ð¸Ð»Ð¸Ð½Ð°_ÑÐ²Ð¸Ð»Ð¸Ð½Ð¸_ÑÐ²Ð¸Ð»Ð¸Ð½' : 'ÑÐ²Ð¸Ð»Ð¸Ð½Ñ_ÑÐ²Ð¸Ð»Ð¸Ð½Ð¸_ÑÐ²Ð¸Ð»Ð¸Ð½',
12259        'hh': withoutSuffix ? 'Ð³Ð¾Ð´Ð¸Ð½Ð°_Ð³Ð¾Ð´Ð¸Ð½Ð¸_Ð³Ð¾Ð´Ð¸Ð½' : 'Ð³Ð¾Ð´Ð¸Ð½Ñ_Ð³Ð¾Ð´Ð¸Ð½Ð¸_Ð³Ð¾Ð´Ð¸Ð½',
12260        'dd': 'Ð´ÐµÐ½Ñ_Ð´Ð½Ñ_Ð´Ð½ÑÐ²',
12261        'MM': 'Ð¼ÑÑÑÑÑ_Ð¼ÑÑÑÑÑ_Ð¼ÑÑÑÑÑÐ²',
12262        'yy': 'ÑÑÐº_ÑÐ¾ÐºÐ¸_ÑÐ¾ÐºÑÐ²'
12263    };
12264    if (key === 'm') {
12265        return withoutSuffix ? 'ÑÐ²Ð¸Ð»Ð¸Ð½Ð°' : 'ÑÐ²Ð¸Ð»Ð¸Ð½Ñ';
12266    }
12267    else if (key === 'h') {
12268        return withoutSuffix ? 'Ð³Ð¾Ð´Ð¸Ð½Ð°' : 'Ð³Ð¾Ð´Ð¸Ð½Ñ';
12269    }
12270    else {

12271        return number + ' ' + plural$6(format[key], +number);
12272    }
12273}
12274function weekdaysCaseReplace(m, format) {
12275    var weekdays = {
12276        'nominative': 'Ð½ÐµÐ´ÑÐ»Ñ_Ð¿Ð¾Ð½ÐµÐ´ÑÐ»Ð¾Ðº_Ð²ÑÐ²ÑÐ¾ÑÐ¾Ðº_ÑÐµÑÐµÐ´Ð°_ÑÐµÑÐ²ÐµÑ_Ð¿âÑÑÐ½Ð¸ÑÑ_ÑÑÐ±Ð¾ÑÐ°'.split('_'),
12277        'accusative': 'Ð½ÐµÐ´ÑÐ»Ñ_Ð¿Ð¾Ð½ÐµÐ´ÑÐ»Ð¾Ðº_Ð²ÑÐ²ÑÐ¾ÑÐ¾Ðº_ÑÐµÑÐµÐ´Ñ_ÑÐµÑÐ²ÐµÑ_Ð¿âÑÑÐ½Ð¸ÑÑ_ÑÑÐ±Ð¾ÑÑ'.split('_'),
12278        'genitive': 'Ð½ÐµÐ´ÑÐ»Ñ_Ð¿Ð¾Ð½ÐµÐ´ÑÐ»ÐºÐ°_Ð²ÑÐ²ÑÐ¾ÑÐºÐ°_ÑÐµÑÐµÐ´Ð¸_ÑÐµÑÐ²ÐµÑÐ³Ð°_Ð¿âÑÑÐ½Ð¸ÑÑ_ÑÑÐ±Ð¾ÑÐ¸'.split('_')
12279    },
12280    nounCase = (/(\[[ÐÐ²Ð£Ñ]\]) ?dddd/).test(format) ?
12281        'accusative' :
12282        ((/\[?(?:Ð¼Ð¸Ð½ÑÐ»Ð¾Ñ|Ð½Ð°ÑÑÑÐ¿Ð½Ð¾Ñ)? ?\] ?dddd/).test(format) ?
12283            'genitive' :
12284            'nominative');
12285    return weekdays[nounCase][m.day()];
12286}
12287function processHoursFunction(str) {
12288    return function () {
12289        return str + 'Ð¾' + (this.hours() === 11 ? 'Ð±' : '') + '] LT';
12290    };
12291}
12292
12293hooks.defineLocale('uk', {
12294    months : {
12295        'format': 'ÑÑÑÐ½Ñ_Ð»ÑÑÐ¾Ð³Ð¾_Ð±ÐµÑÐµÐ·Ð½Ñ_ÐºÐ²ÑÑÐ½Ñ_ÑÑÐ°Ð²Ð½Ñ_ÑÐµÑÐ²Ð½Ñ_Ð»Ð¸Ð¿Ð½Ñ_ÑÐµÑÐ¿Ð½Ñ_Ð²ÐµÑÐµÑÐ½Ñ_Ð¶Ð¾Ð²ÑÐ½Ñ_Ð»Ð¸ÑÑÐ¾Ð¿Ð°Ð´Ð°_Ð³ÑÑÐ´Ð½Ñ'.split('_'),
12296        'standalone': 'ÑÑÑÐµÐ½Ñ_Ð»ÑÑÐ¸Ð¹_Ð±ÐµÑÐµÐ·ÐµÐ½Ñ_ÐºÐ²ÑÑÐµÐ½Ñ_ÑÑÐ°Ð²ÐµÐ½Ñ_ÑÐµÑÐ²ÐµÐ½Ñ_Ð»Ð¸Ð¿ÐµÐ½Ñ_ÑÐµÑÐ¿ÐµÐ½Ñ_Ð²ÐµÑÐµÑÐµÐ½Ñ_Ð¶Ð¾Ð²ÑÐµÐ½Ñ_Ð»Ð¸ÑÑÐ¾Ð¿Ð°Ð´_Ð³ÑÑÐ´ÐµÐ½Ñ'.split('_')
12297    },
12298    monthsShort : 'ÑÑÑ_Ð»ÑÑ_Ð±ÐµÑ_ÐºÐ²ÑÑ_ÑÑÐ°Ð²_ÑÐµÑÐ²_Ð»Ð¸Ð¿_ÑÐµÑÐ¿_Ð²ÐµÑ_Ð¶Ð¾Ð²Ñ_Ð»Ð¸ÑÑ_Ð³ÑÑÐ´'.split('_'),
12299    weekdays : weekdaysCaseReplace,
12300    weekdaysShort : 'Ð½Ð´_Ð¿Ð½_Ð²Ñ_ÑÑ_ÑÑ_Ð¿Ñ_ÑÐ±'.split('_'),
12301    weekdaysMin : 'Ð½Ð´_Ð¿Ð½_Ð²Ñ_ÑÑ_ÑÑ_Ð¿Ñ_ÑÐ±'.split('_'),
12302    longDateFormat : {
12303        LT : 'HH:mm',
12304        LTS : 'HH:mm:ss',
12305        L : 'DD.MM.YYYY',
12306        LL : 'D MMMM YYYY Ñ.',
12307        LLL : 'D MMMM YYYY Ñ., HH:mm',
12308        LLLL : 'dddd, D MMMM YYYY Ñ., HH:mm'
12309    },
12310    calendar : {
12311        sameDay: processHoursFunction('[Ð¡ÑÐ¾Ð³Ð¾Ð´Ð½Ñ '),
12312        nextDay: processHoursFunction('[ÐÐ°Ð²ÑÑÐ° '),
12313        lastDay: processHoursFunction('[ÐÑÐ¾ÑÐ° '),
12314        nextWeek: processHoursFunction('[Ð£] dddd ['),
12315        lastWeek: function () {
12316            switch (this.day()) {
12317                case 0:
12318                case 3:
12319                case 5:
12320                case 6:
12321                    return processHoursFunction('[ÐÐ¸Ð½ÑÐ»Ð¾Ñ] dddd [').call(this);
12322                case 1:
12323                case 2:
12324                case 4:
12325                    return processHoursFunction('[ÐÐ¸Ð½ÑÐ»Ð¾Ð³Ð¾] dddd [').call(this);
12326            }
12327        },
12328        sameElse: 'L'
12329    },
12330    relativeTime : {
12331        future : 'Ð·Ð° %s',
12332        past : '%s ÑÐ¾Ð¼Ñ',
12333        s : 'Ð´ÐµÐºÑÐ»ÑÐºÐ° ÑÐµÐºÑÐ½Ð´',
12334        m : relativeTimeWithPlural$4,
12335        mm : relativeTimeWithPlural$4,
12336        h : 'Ð³Ð¾Ð´Ð¸Ð½Ñ',
12337        hh : relativeTimeWithPlural$4,
12338        d : 'Ð´ÐµÐ½Ñ',
12339        dd : relativeTimeWithPlural$4,
12340        M : 'Ð¼ÑÑÑÑÑ',
12341        MM : relativeTimeWithPlural$4,
12342        y : 'ÑÑÐº',
12343        yy : relativeTimeWithPlural$4
12344    },
12345    // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
12346    meridiemParse: /Ð½Ð¾ÑÑ|ÑÐ°Ð½ÐºÑ|Ð´Ð½Ñ|Ð²ÐµÑÐ¾ÑÐ°/,
12347    isPM: function (input) {
12348        return /^(Ð´Ð½Ñ|Ð²ÐµÑÐ¾ÑÐ°)$/.test(input);
12349    },
12350    meridiem : function (hour, minute, isLower) {
12351        if (hour < 4) {
12352            return 'Ð½Ð¾ÑÑ';
12353        } else if (hour < 12) {
12354            return 'ÑÐ°Ð½ÐºÑ';
12355        } else if (hour < 17) {
12356            return 'Ð´Ð½Ñ';
12357        } else {
12358            return 'Ð²ÐµÑÐ¾ÑÐ°';
12359        }
12360    },
12361    ordinalParse: /\d{1,2}-(Ð¹|Ð³Ð¾)/,
12362    ordinal: function (number, period) {
12363        switch (period) {
12364            case 'M':
12365            case 'd':
12366            case 'DDD':
12367            case 'w':
12368            case 'W':
12369                return number + '-Ð¹';
12370            case 'D':
12371                return number + '-Ð³Ð¾';
12372            default:
12373                return number;
12374        }
12375    },
12376    week : {
12377        dow : 1, // Monday is the first day of the week.
12378        doy : 7  // The week that contains Jan 1st is the first week of the year.
12379    }
12380});
12381
12382//! moment.js locale configuration
12383//! locale : Uzbek [uz]
12384//! author : Sardor Muminov : https://github.com/muminoff
12385
12386hooks.defineLocale('uz', {
12387    months : 'ÑÐ½Ð²Ð°Ñ_ÑÐµÐ²ÑÐ°Ð»_Ð¼Ð°ÑÑ_Ð°Ð¿ÑÐµÐ»_Ð¼Ð°Ð¹_Ð¸ÑÐ½_Ð¸ÑÐ»_Ð°Ð²Ð³ÑÑÑ_ÑÐµÐ½ÑÑÐ±Ñ_Ð¾ÐºÑÑÐ±Ñ_Ð½Ð¾ÑÐ±Ñ_Ð´ÐµÐºÐ°Ð±Ñ'.split('_'),
12388    monthsShort : 'ÑÐ½Ð²_ÑÐµÐ²_Ð¼Ð°Ñ_Ð°Ð¿Ñ_Ð¼Ð°Ð¹_Ð¸ÑÐ½_Ð¸ÑÐ»_Ð°Ð²Ð³_ÑÐµÐ½_Ð¾ÐºÑ_Ð½Ð¾Ñ_Ð´ÐµÐº'.split('_'),
12389    weekdays : 'Ð¯ÐºÑÐ°Ð½Ð±Ð°_ÐÑÑÐ°Ð½Ð±Ð°_Ð¡ÐµÑÐ°Ð½Ð±Ð°_Ð§Ð¾ÑÑÐ°Ð½Ð±Ð°_ÐÐ°Ð¹ÑÐ°Ð½Ð±Ð°_ÐÑÐ¼Ð°_Ð¨Ð°Ð½Ð±Ð°'.split('_'),
12390    weekdaysShort : 'Ð¯ÐºÑ_ÐÑÑ_Ð¡ÐµÑ_Ð§Ð¾Ñ_ÐÐ°Ð¹_ÐÑÐ¼_Ð¨Ð°Ð½'.split('_'),
12391    weekdaysMin : 'Ð¯Ðº_ÐÑ_Ð¡Ðµ_Ð§Ð¾_ÐÐ°_ÐÑ_Ð¨Ð°'.split('_'),
12392    longDateFormat : {
12393        LT : 'HH:mm',
12394        LTS : 'HH:mm:ss',
12395        L : 'DD/MM/YYYY',
12396        LL : 'D MMMM YYYY',
12397        LLL : 'D MMMM YYYY HH:mm',
12398        LLLL : 'D MMMM YYYY, dddd HH:mm'
12399    },
12400    calendar : {
12401        sameDay : '[ÐÑÐ³ÑÐ½ ÑÐ¾Ð°Ñ] LT [Ð´Ð°]',
12402        nextDay : '[ÐÑÑÐ°Ð³Ð°] LT [Ð´Ð°]',
12403        nextWeek : 'dddd [ÐºÑÐ½Ð¸ ÑÐ¾Ð°Ñ] LT [Ð´Ð°]',
12404        lastDay : '[ÐÐµÑÐ° ÑÐ¾Ð°Ñ] LT [Ð´Ð°]',
12405        lastWeek : '[Ð£ÑÐ³Ð°Ð½] dddd [ÐºÑÐ½Ð¸ ÑÐ¾Ð°Ñ] LT [Ð´Ð°]',
12406        sameElse : 'L'
12407    },
12408    relativeTime : {
12409        future : 'Ð¯ÐºÐ¸Ð½ %s Ð¸ÑÐ¸Ð´Ð°',
12410        past : 'ÐÐ¸Ñ Ð½ÐµÑÐ° %s Ð¾Ð»Ð´Ð¸Ð½',
12411        s : 'ÑÑÑÑÐ°Ñ',
12412        m : 'Ð±Ð¸Ñ Ð´Ð°ÐºÐ¸ÐºÐ°',
12413        mm : '%d Ð´Ð°ÐºÐ¸ÐºÐ°',
12414        h : 'Ð±Ð¸Ñ ÑÐ¾Ð°Ñ',
12415        hh : '%d ÑÐ¾Ð°Ñ',
12416        d : 'Ð±Ð¸Ñ ÐºÑÐ½',
12417        dd : '%d ÐºÑÐ½',
12418        M : 'Ð±Ð¸Ñ Ð¾Ð¹',
12419        MM : '%d Ð¾Ð¹',
12420        y : 'Ð±Ð¸Ñ Ð¹Ð¸Ð»',
12421        yy : '%d Ð¹Ð¸Ð»'
12422    },
12423    week : {
12424        dow : 1, // Monday is the first day of the week.
12425        doy : 7  // The week that contains Jan 4th is the first week of the year.
12426    }
12427});
12428
12429//! moment.js locale configuration
12430//! locale : Vietnamese [vi]
12431//! author : Bang Nguyen : https://github.com/bangnk
12432
12433hooks.defineLocale('vi', {
12434    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('_'),
12435    monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
12436    monthsParseExact : true,
12437    weekdays : 'chá»§ nháºt_thá»© hai_thá»© ba_thá»© tÆ°_thá»© nÄm_thá»© sÃ¡u_thá»© báº£y'.split('_'),
12438    weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
12439    weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
12440    weekdaysParseExact : true,
12441    meridiemParse: /sa|ch/i,
12442    isPM : function (input) {
12443        return /^ch$/i.test(input);
12444    },
12445    meridiem : function (hours, minutes, isLower) {
12446        if (hours < 12) {
12447            return isLower ? 'sa' : 'SA';
12448        } else {
12449            return isLower ? 'ch' : 'CH';
12450        }
12451    },
12452    longDateFormat : {
12453        LT : 'HH:mm',
12454        LTS : 'HH:mm:ss',
12455        L : 'DD/MM/YYYY',
12456        LL : 'D MMMM [nÄm] YYYY',
12457        LLL : 'D MMMM [nÄm] YYYY HH:mm',
12458        LLLL : 'dddd, D MMMM [nÄm] YYYY HH:mm',
12459        l : 'DD/M/YYYY',
12460        ll : 'D MMM YYYY',
12461        lll : 'D MMM YYYY HH:mm',
12462        llll : 'ddd, D MMM YYYY HH:mm'
12463    },
12464    calendar : {
12465        sameDay: '[HÃ´m nay lÃºc] LT',
12466        nextDay: '[NgÃ y mai lÃºc] LT',
12467        nextWeek: 'dddd [tuáº§n tá»i lÃºc] LT',
12468        lastDay: '[HÃ´m qua lÃºc] LT',
12469        lastWeek: 'dddd [tuáº§n rá»i lÃºc] LT',
12470        sameElse: 'L'
12471    },
12472    relativeTime : {
12473        future : '%s tá»i',
12474        past : '%s trÆ°á»c',
12475        s : 'vÃ i giÃ¢y',
12476        m : 'má»t phÃºt',
12477        mm : '%d phÃºt',
12478        h : 'má»t giá»',
12479        hh : '%d giá»',
12480        d : 'má»t ngÃ y',
12481        dd : '%d ngÃ y',
12482        M : 'má»t thÃ¡ng',
12483        MM : '%d thÃ¡ng',
12484        y : 'má»t nÄm',
12485        yy : '%d nÄm'
12486    },
12487    ordinalParse: /\d{1,2}/,
12488    ordinal : function (number) {
12489        return number;
12490    },
12491    week : {
12492        dow : 1, // Monday is the first day of the week.
12493        doy : 4  // The week that contains Jan 4th is the first week of the year.
12494    }
12495});
12496
12497//! moment.js locale configuration
12498//! locale : Pseudo [x-pseudo]
12499//! author : Andrew Hood : https://github.com/andrewhood125
12500
12501hooks.defineLocale('x-pseudo', {
12502    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('_'),
12503    monthsShort : 'J~Ã¡Ã±_~FÃ©b_~MÃ¡r_~Ãpr_~MÃ¡Ã½_~JÃºÃ±_~JÃºl_~ÃÃºg_~SÃ©p_~Ãct_~ÃÃ³v_~DÃ©c'.

12503split('_'),
12504    monthsParseExact : true,
12505    weekdays : 'S~ÃºÃ±dÃ¡~Ã½_MÃ³~Ã±dÃ¡Ã½~_TÃºÃ©~sdÃ¡Ã½~_WÃ©d~Ã±Ã©sd~Ã¡Ã½_T~hÃºrs~dÃ¡Ã½_~FrÃd~Ã¡Ã½_S~Ã¡tÃºr~dÃ¡Ã½'.split('_'),
12506    weekdaysShort : 'S~ÃºÃ±_~MÃ³Ã±_~TÃºÃ©_~WÃ©d_~ThÃº_~FrÃ_~SÃ¡t'.split('_'),
12507    weekdaysMin : 'S~Ãº_MÃ³~_TÃº_~WÃ©_T~h_Fr~_SÃ¡'.split('_'),
12508    weekdaysParseExact : true,
12509    longDateFormat : {
12510        LT : 'HH:mm',
12511        L : 'DD/MM/YYYY',
12512        LL : 'D MMMM YYYY',
12513        LLL : 'D MMMM YYYY HH:mm',
12514        LLLL : 'dddd, D MMMM YYYY HH:mm'
12515    },
12516    calendar : {
12517        sameDay : '[T~Ã³dÃ¡~Ã½ Ã¡t] LT',
12518        nextDay : '[T~Ã³mÃ³~rrÃ³~w Ã¡t] LT',
12519        nextWeek : 'dddd [Ã¡t] LT',
12520        lastDay : '[Ã~Ã©st~Ã©rdÃ¡~Ã½ Ã¡t] LT',
12521        lastWeek : '[L~Ã¡st] dddd [Ã¡t] LT',
12522        sameElse : 'L'
12523    },
12524    relativeTime : {
12525        future : 'Ã~Ã± %s',
12526        past : '%s Ã¡~gÃ³',
12527        s : 'Ã¡ ~fÃ©w ~sÃ©cÃ³~Ã±ds',
12528        m : 'Ã¡ ~mÃÃ±~ÃºtÃ©',
12529        mm : '%d m~ÃÃ±Ãº~tÃ©s',
12530        h : 'Ã¡~Ã± hÃ³~Ãºr',
12531        hh : '%d h~Ã³Ãºrs',
12532        d : 'Ã¡ ~dÃ¡Ã½',
12533        dd : '%d d~Ã¡Ã½s',
12534        M : 'Ã¡ ~mÃ³Ã±~th',
12535        MM : '%d m~Ã³Ã±t~hs',
12536        y : 'Ã¡ ~Ã½Ã©Ã¡r',
12537        yy : '%d Ã½~Ã©Ã¡rs'
12538    },
12539    ordinalParse: /\d{1,2}(th|st|nd|rd)/,
12540    ordinal : function (number) {
12541        var b = number % 10,
12542            output = (~~(number % 100 / 10) === 1) ? 'th' :
12543            (b === 1) ? 'st' :
12544            (b === 2) ? 'nd' :
12545            (b === 3) ? 'rd' : 'th';
12546        return number + output;
12547    },
12548    week : {
12549        dow : 1, // Monday is the first day of the week.
12550        doy : 4  // The week that contains Jan 4th is the first week of the year.
12551    }
12552});
12553
12554//! moment.js locale configuration
12555//! locale : Yoruba Nigeria [yo]
12556//! author : Atolagbe Abisoye : https://github.com/andela-batolagbe
12557
12558hooks.defineLocale('yo', {
12559    months : 'Sáº¹Ìráº¹Ì_EÌreÌleÌ_áº¸ráº¹ÌnaÌ_IÌgbeÌ_EÌbibi_OÌkuÌdu_Agáº¹mo_OÌguÌn_Owewe_á»ÌwaÌraÌ_BeÌluÌ_á»Ìpáº¹ÌÌ'.split('_'),
12560    monthsShort : 'Sáº¹Ìr_EÌrl_áº¸rn_IÌgb_EÌbi_OÌkuÌ_Agáº¹_OÌguÌ_Owe_á»ÌwaÌ_BeÌl_á»Ìpáº¹ÌÌ'.split('_'),
12561    weekdays : 'AÌiÌkuÌ_AjeÌ_IÌsáº¹Ìgun_á»já»ÌruÌ_á»já»Ìbá»_áº¸tiÌ_AÌbaÌmáº¹Ìta'.split('_'),
12562    weekdaysShort : 'AÌiÌk_AjeÌ_IÌsáº¹Ì_á»jr_á»jb_áº¸tiÌ_AÌbaÌ'.split('_'),
12563    weekdaysMin : 'AÌiÌ_Aj_IÌs_á»r_á»b_áº¸t_AÌb'.split('_'),
12564    longDateFormat : {
12565        LT : 'h:mm A',
12566        LTS : 'h:mm:ss A',
12567        L : 'DD/MM/YYYY',
12568        LL : 'D MMMM YYYY',
12569        LLL : 'D MMMM YYYY h:mm A',
12570        LLLL : 'dddd, D MMMM YYYY h:mm A'
12571    },
12572    calendar : {
12573        sameDay : '[OÌniÌ ni] LT',
12574        nextDay : '[á»Ìla ni] LT',
12575        nextWeek : 'dddd [á»sáº¹Ì toÌn\'bá»] [ni] LT',
12576        lastDay : '[AÌna ni] LT',
12577        lastWeek : 'dddd [á»sáº¹Ì toÌlá»Ì] [ni] LT',
12578        sameElse : 'L'
12579    },
12580    relativeTime : {
12581        future : 'niÌ %s',
12582        past : '%s ká»jaÌ',
12583        s : 'iÌsáº¹juÌ aayaÌ die',
12584        m : 'iÌsáº¹juÌ kan',
12585        mm : 'iÌsáº¹juÌ %d',
12586        h : 'waÌkati kan',
12587        hh : 'waÌkati %d',
12588        d : 'á»já»Ì kan',
12589        dd : 'á»já»Ì %d',
12590        M : 'osuÌ kan',
12591        MM : 'osuÌ %d',
12592        y : 'á»duÌn kan',
12593        yy : 'á»duÌn %d'
12594    },
12595    ordinalParse : /á»já»Ì\s\d{1,2}/,
12596    ordinal : 'á»já»Ì %d',
12597    week : {
12598        dow : 1, // Monday is the first day of the week.
12599        doy : 4 // The week that contains Jan 4th is the first week of the year.
12600    }
12601});
12602
12603//! moment.js locale configuration
12604//! locale : Chinese (China) [zh-cn]
12605//! author : suupic : https://github.com/suupic
12606//! author : Zeno Zeng : https://github.com/zenozeng
12607
12608hooks.defineLocale('zh-cn', {
12609    months : 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_åæ_ä¸æ_å«æ_ä¹æ_åæ_åä¸æ_åäºæ'.split('_'),
12610    monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'),
12611    weekdays : 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå'.split('_'),
12612    weekdaysShort : 'å¨æ¥_å¨ä¸_å¨äº_å¨ä¸_å¨å_å¨äº_å¨å'.split('_'),
12613    weekdaysMin : 'æ¥_ä¸_äº_ä¸_å_äº_å'.split('_'),
12614    longDateFormat : {
12615        LT : 'Ahç¹mmå',
12616        LTS : 'Ahç¹måsç§',
12617        L : 'YYYY-MM-DD',
12618        LL : 'YYYYå¹´MMMDæ¥',
12619        LLL : 'YYYYå¹´MMMDæ¥Ahç¹mmå',
12620        LLLL : 'YYYYå¹´MMMDæ¥ddddAhç¹mmå',
12621        l : 'YYYY-MM-DD',
12622        ll : 'YYYYå¹´MMMDæ¥',
12623        lll : 'YYYYå¹´MMMDæ¥Ahç¹mmå',
12624        llll : 'YYYYå¹´MMMDæ¥ddddAhç¹mmå'
12625    },
12626    meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/,
12627    meridiemHour: function (hour, meridiem) {
12628        if (hour === 12) {
12629            hour = 0;
12630        }
12631        if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' ||
12632                meridiem === 'ä¸å') {
12633            return hour;
12634        } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') {
12635            return hour + 12;
12636        } else {
12637            // 'ä¸å'
12638            return hour >= 11 ? hour : hour + 12;
12639        }
12640    },
12641    meridiem : function (hour, minute, isLower) {
12642        var hm = hour * 100 + minute;
12643        if (hm < 600) {
12644            return 'åæ¨';
12645        } else if (hm < 900) {
12646            return 'æ©ä¸';
12647        } else if (hm < 1130) {
12648            return 'ä¸å';
12649        } else if (hm < 1230) {
12650            return 'ä¸å';
12651        } else if (hm < 1800) {
12652            return 'ä¸å';
12653        } else {
12654            return 'æä¸';
12655        }
12656    },
12657    calendar : {
12658        sameDay : function () {
12659            return this.minutes() === 0 ? '[ä»å¤©]Ah[ç¹æ´]' : '[ä»å¤©]LT';
12660        },
12661        nextDay : function () {
12662            return this.minutes() === 0 ? '[æå¤©]Ah[ç¹æ´]' : '[æå¤©]LT';
12663        },
12664        lastDay : function () {
12665            return this.minutes() === 0 ? '[æ¨å¤©]Ah[ç¹æ´]' : '[æ¨å¤©]LT';
12666        },
12667        nextWeek : function () {
12668            var startOfWeek, prefix;
12669            startOfWeek = hooks().startOf('week');
12670            prefix = this.diff(startOfWeek, 'days') >= 7 ? '[ä¸]' : '[æ¬]';
12671            return this.minutes() === 0 ? prefix + 'dddAhç¹æ´' : prefix + 'dddAhç¹mm';
12672        },
12673        lastWeek : function () {
12674            var startOfWeek, prefix;
12675            startOfWeek = hooks().startOf('week');
12676            prefix = this.unix() < startOfWeek.unix()  ? '[ä¸]' : '[æ¬]';
12677            return this.minutes() === 0 ? prefix + 'dddAhç¹æ´' : prefix + 'dddAhç¹mm';
12678        },
12679        sameElse : 'LL'
12680    },
12681    ordinalParse: /\d{1,2}(æ¥|æ|å¨)/,
12682    ordinal : function (number, period) {
12683        switch (period) {
12684            case 'd':
12685            case 'D':
12686            case 'DDD':
12687                return number + 'æ¥';
12688            case 'M':
12689                return number + 'æ';
12690            case 'w':
12691            case 'W':
12692                return number + 'å¨';
12693            default:
12694                return number;
12695        }
12696    },
12697    relativeTime : {
12698        future : '%så',
12699        past : '%så',
12700        s : 'å ç§',
12701        m : '1 åé',
12702        mm : '%d åé',
12703        h : '1 å°æ¶',
12704        hh : '%d å°æ¶',
12705        d : '1 å¤©',
12706        dd : '%d å¤©',
12707        M : '1 ä¸ªæ',
12708        MM : '%d ä¸ªæ',
12709        y : '1 å¹´',
12710        yy : '%d å¹´'
12711    },
12712    week : {
12713        // GB/T 7408-1994ãæ°æ®ååäº¤æ¢æ ¼å¼Â·ä¿¡æ¯äº¤æ¢Â·æ¥æåæ¶é´è¡¨ç¤ºæ³ãä¸ISO 8601:1988çæ
12714        dow : 1, // Monday is the first day of the week.
12715        doy : 4  // The week that contains Jan 4th is the first week of the year.
12716    }
12717});
12718
12719//! moment.js locale configuration
12720//! locale : Chinese (Hong Kong) [zh-hk]
12721//! author : Ben : https://github.com/ben-lin
12722//! author : Chris Lam : https://github.com/hehachris
12723//! author : Konstantin : https://github.com/skfd
12724
12725hooks.defineLocale('zh-hk', {
12726    months : 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_åæ_ä¸æ_å«æ_ä¹æ_åæ_åä¸æ_åäºæ'.split('_'),
12727    monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'),
12728    weekdays : 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå'.split('_'),
12729    weekdaysShort : 'é±æ¥_é±ä¸_é±äº_é±ä¸_é±å_é±äº_é±å'.split('_'),
12730    weekdaysMin : 'æ¥_ä¸_äº_ä¸_å_äº_å'.split('_'),
12731    longDateFormat : {
12732        LT : 'Ahé»mmå',
12733        LTS : 'Ahé»måsç§',
12734        L : 'YYYYå¹´MMMDæ¥',
12735        LL : 'YYYYå¹´MMMDæ¥',
12736        LLL : 'YYYYå¹´MMMDæ¥Ahé»mmå',
12737        LLLL : 'YYYYå¹´MMMDæ¥ddddAhé»mmå',
12738        l : 'YYYYå¹´MMMDæ¥',
12739        ll : 'YYYYå¹´MMMDæ¥',
12740        lll : 'YYYYå¹´MMMDæ¥Ahé»mmå',
12741        llll : 'YYYYå¹´MMMDæ¥ddddAhé»mmå'
12742    },
12743    meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/,
12744    meridiemHour : function (hour, meridiem) {
12745        if (hour === 12) {
12746            hour = 0;
12747        }
12748        if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' || meridiem === 'ä¸å') {
12749            return hour;
12750        } else if (meridiem === 'ä¸å') {
12751            return hour >= 11 ? hour : hour + 12;
12752        } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') {
12753            return hour + 12;
12754        }
12755    },
12756    meridiem : function (hour, minute, isLower) {
12757        var hm = hour * 100 + minute;
12758        if (hm < 600) {
12759            return 'åæ¨';
12760        } else if (hm < 900) {
12761            return 'æ©ä¸';
12762        } else if (hm < 1130) {
12763            return 'ä¸å';
12764        } else if (hm < 1230) {
12765            return 'ä¸å';
12766        } else if (hm < 1800) {
12767            return 'ä¸å';
12768        } else {
12769            return 'æä¸';
12770        }
12771    },
12772    calendar : {
12773        sameDay : '[ä»å¤©]LT',
12774        nextDay : '[æå¤©]LT',
12775        nextWeek : '[ä¸]ddddLT',
12776        lastDay : '[æ¨å¤©]LT',
12777        lastWeek : '[ä¸]ddddLT',
12778        sameElse : 'L'
12779    },
12780    ordinalParse: /\d{1,2}(æ¥|æ|é±)/,
12781    ordinal : function (number, period) {
12782        switch (period) {
12783            case 'd' :
12784            case 'D' :
12785            case 'DDD' :
12786                return number + 'æ¥';
12787            case 'M' :
12788                return number + 'æ';
12789            case 'w' :
12790            case 'W' :
12791                return number + 'é±';
12792            default :
12793                return number;
12794        }
12795    },
12796    relativeTime : {
12797        future : '%så§',
12798        past : '%så',
12799        s : 'å¹¾ç§',
12800        m : '1 åé',
12801        mm : '%d åé',
12802        h : '1 å°æ',
12803        hh : '%d å°æ',
12804        d : '1 å¤©',
12805        dd : '%d å¤©',
12806        M : '1 åæ',
12807        MM : '%d åæ',
12808        y : '1 å¹´',
12809        yy : '%d å¹´'
12810    }
12811});
12812
12813//! moment.js locale configuration
12814//! locale : Chinese (Taiwan) [zh-tw]
12815//! author : Ben : https://github.com/ben-lin
12816//! author : Chris Lam : https://github.com/hehachris
12817
12818hooks.defineLocale('zh-tw', {
12819    months : 'ä¸æ_äºæ_ä¸æ_åæ_äºæ_åæ_ä¸æ_å«æ_ä¹æ_åæ_åä¸æ_åäºæ'.split('_'),
12820    monthsShort : '1æ_2æ_3æ_4æ_5æ_6æ_7æ_8æ_9æ_10æ_11æ_12æ'.split('_'),
12821    weekdays : 'æææ¥_ææä¸_ææäº_ææä¸_ææå_ææäº_ææå'.split('_'),
12822    weekdaysShort : 'é±æ¥_é±ä¸_é±äº_é±ä¸_é±å_é±äº_é±å'.split('_'),
12823    weekdaysMin : 'æ¥_ä¸_äº_ä¸_å_äº_å'.split('_'),
12824    longDateFormat : {
12825        LT : 'Ahé»mmå',
12826        LTS : 'Ahé»måsç§',
12827        L : 'YYYYå¹´MMMDæ¥',
12828        LL : 'YYYYå¹´MMMDæ¥',
12829        LLL : 'YYYYå¹´MMMDæ¥Ahé»mmå',
12830        LLLL : 'YYYYå¹´MMMDæ¥ddddAhé»mmå',
12831        l : 'YYYYå¹´MMMDæ¥',
12832        ll : 'YYYYå¹´MMMDæ¥',
12833        lll : 'YYYYå¹´MMMDæ¥Ahé»mmå',
12834        llll : 'YYYYå¹´MMMDæ¥ddddAhé»mmå'
12835    },
12836    meridiemParse: /åæ¨|æ©ä¸|ä¸å|ä¸å|ä¸å|æä¸/,
12837    meridiemHour : function (hour, meridiem) {
12838        if (hour === 12) {
12839            hour = 0;
12840        }
12841        if (meridiem === 'åæ¨' || meridiem === 'æ©ä¸' || meridiem === 'ä¸å') {
12842            return hour;
12843        } else if (meridiem === 'ä¸å') {
12844            return hour >= 11 ? hour : hour + 12;
12845        } else if (meridiem === 'ä¸å' || meridiem === 'æä¸') {
12846            return hour + 12;
12847        }
12848    },
12849    meridiem : function (hour, minute, isLower) {
12850        var hm = hour * 100 + minute;
12851        if (hm < 600) {
12852            return 'åæ¨';
12853        } else if (hm < 900) {
12854            return 'æ©ä¸';
12855        } else if (hm < 1130) {
12856            return 'ä¸å';
12857        } else if (hm < 1230) {
12858            return 'ä¸å';
12859        } else if (hm < 1800) {
12860            return 'ä¸å';
12861        } else {
12862            return 'æä¸';
12863        }
12864    },
12865    calendar : {
12866        sameDay : '[ä»å¤©]LT',
12867        nextDay : '[æå¤©]LT',
12868        nextWeek : '[ä¸]ddddLT',
12869        lastDay : '[æ¨å¤©]LT',
12870        lastWeek : '[ä¸]ddddLT',
12871        sameElse : 'L'
12872    },
12873    ordinalParse: /\d{1,2}(æ¥|æ|é±)/,
12874    ordinal : function (number, period) {
12875        switch (period) {
12876            case 'd' :
12877            case 'D' :
12878            case 'DDD' :
12879                return number + 'æ¥';
12880            case 'M' :
12881                return number + 'æ';
12882            case 'w' :
12883            case 'W' :
12884                return number + 'é±';
12885            default :
12886                return number;
12887        }
12888    },
12889    relativeTime : {
12890        future : '%så§',
12891        past : '%så',
12892        s : 'å¹¾ç§',
12893        m : '1 åé',
12894        mm : '%d åé',
12895        h : '1 å°æ',
12896        hh : '%d å°æ',
12897        d : '1 å¤©',
12898        dd : '%d å¤©',
12899        M : '1 åæ',
12900        MM : '%d åæ',
12901        y : '1 å¹´',
12902        yy : '%d å¹´'
12903    }
12904});
12905
12906hooks.locale('en');
12907
12908return hooks;
12909
12910})));

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.