Browse code

Created repository.

DoubleBastionAdmin authored on 26/01/2022 20:32:42
Showing 1 changed files
js/moment-with-locales-2.24.0.js
History View file @ 06fbd76
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,14780 @@
1 
+/**
2 
+ *  Copyright (C) 2021  Double Bastion LLC
3 
+ *
4 
+ *  This file is part of Roundpin, which is licensed under the
5 
+ *  GNU Affero General Public License Version 3.0. The license terms
6 
+ *  are detailed in the "LICENSE.txt" file located in the root directory.
7 
+ *
8 
+ *  The file content from below is identical with that of the
9 
+ *  original file "moment-with-locales.js" released under the
10 
+ *  MIT License: https://github.com/moment/moment/blob/develop/LICENSE .
11 
+ *  The copyright notice for the original content follows:
12 
+ *
13 
+ *  Copyright (c) JS Foundation and other contributors
14 
+ */
15 
+
16 
+;(function (global, factory) {
17 
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
18 
+    typeof define === 'function' && define.amd ? define(factory) :
19 
+    global.moment = factory()
20 
+}(this, (function () { 'use strict';
21 
+
22 
+    var hookCallback;
23 
+
24 
+    function hooks () {
25 
+        return hookCallback.apply(null, arguments);
26 
+    }
27 
+
28 
+    // This is done to register the method called with moment()
29 
+    // without creating circular dependencies.
30 
+    function setHookCallback (callback) {
31 
+        hookCallback = callback;
32 
+    }
33 
+
34 
+    function isArray(input) {
35 
+        return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
36 
+    }
37 
+
38 
+    function isObject(input) {
39 
+        // IE8 will treat undefined and null as object if it wasn't for
40 
+        // input != null
41 
+        return input != null && Object.prototype.toString.call(input) === '[object Object]';
42 
+    }
43 
+
44 
+    function isObjectEmpty(obj) {
45 
+        if (Object.getOwnPropertyNames) {
46 
+            return (Object.getOwnPropertyNames(obj).length === 0);
47 
+        } else {
48 
+            var k;
49 
+            for (k in obj) {
50 
+                if (obj.hasOwnProperty(k)) {
51 
+                    return false;
52 
+                }
53 
+            }
54 
+            return true;
55 
+        }
56 
+    }
57 
+
58 
+    function isUndefined(input) {
59 
+        return input === void 0;
60 
+    }
61 
+
62 
+    function isNumber(input) {
63 
+        return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
64 
+    }
65 
+
66 
+    function isDate(input) {
67 
+        return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
68 
+    }
69 
+
70 
+    function map(arr, fn) {
71 
+        var res = [], i;
72 
+        for (i = 0; i < arr.length; ++i) {
73 
+            res.push(fn(arr[i], i));
74 
+        }
75 
+        return res;
76 
+    }
77 
+
78 
+    function hasOwnProp(a, b) {
79 
+        return Object.prototype.hasOwnProperty.call(a, b);
80 
+    }
81 
+
82 
+    function extend(a, b) {
83 
+        for (var i in b) {
84 
+            if (hasOwnProp(b, i)) {
85 
+                a[i] = b[i];
86 
+            }
87 
+        }
88 
+
89 
+        if (hasOwnProp(b, 'toString')) {
90 
+            a.toString = b.toString;
91 
+        }
92 
+
93 
+        if (hasOwnProp(b, 'valueOf')) {
94 
+            a.valueOf = b.valueOf;
95 
+        }
96 
+
97 
+        return a;
98 
+    }
99 
+
100 
+    function createUTC (input, format, locale, strict) {
101 
+        return createLocalOrUTC(input, format, locale, strict, true).utc();
102 
+    }
103 
+
104 
+    function defaultParsingFlags() {
105 
+        // We need to deep clone this object.
106 
+        return {
107 
+            empty           : false,
108 
+            unusedTokens    : [],
109 
+            unusedInput     : [],
110 
+            overflow        : -2,
111 
+            charsLeftOver   : 0,
112 
+            nullInput       : false,
113 
+            invalidMonth    : null,
114 
+            invalidFormat   : false,
115 
+            userInvalidated : false,
116 
+            iso             : false,
117 
+            parsedDateParts : [],
118 
+            meridiem        : null,
119 
+            rfc2822         : false,
120 
+            weekdayMismatch : false
121 
+        };
122 
+    }
123 
+
124 
+    function getParsingFlags(m) {
125 
+        if (m._pf == null) {
126 
+            m._pf = defaultParsingFlags();
127 
+        }
128 
+        return m._pf;
129 
+    }
130 
+
131 
+    var some;
132 
+    if (Array.prototype.some) {
133 
+        some = Array.prototype.some;
134 
+    } else {
135 
+        some = function (fun) {
136 
+            var t = Object(this);
137 
+            var len = t.length >>> 0;
138 
+
139 
+            for (var i = 0; i < len; i++) {
140 
+                if (i in t && fun.call(this, t[i], i, t)) {
141 
+                    return true;
142 
+                }
143 
+            }
144 
+
145 
+            return false;
146 
+        };
147 
+    }
148 
+
149 
+    function isValid(m) {
150 
+        if (m._isValid == null) {
151 
+            var flags = getParsingFlags(m);
152 
+            var parsedParts = some.call(flags.parsedDateParts, function (i) {
153 
+                return i != null;
154 
+            });
155 
+            var isNowValid = !isNaN(m._d.getTime()) &&
156 
+                flags.overflow < 0 &&
157 
+                !flags.empty &&
158 
+                !flags.invalidMonth &&
159 
+                !flags.invalidWeekday &&
160 
+                !flags.weekdayMismatch &&
161 
+                !flags.nullInput &&
162 
+                !flags.invalidFormat &&
163 
+                !flags.userInvalidated &&
164 
+                (!flags.meridiem || (flags.meridiem && parsedParts));
165 
+
166 
+            if (m._strict) {
167 
+                isNowValid = isNowValid &&
168 
+                    flags.charsLeftOver === 0 &&
169 
+                    flags.unusedTokens.length === 0 &&
170 
+                    flags.bigHour === undefined;
171 
+            }
172 
+
173 
+            if (Object.isFrozen == null || !Object.isFrozen(m)) {
174 
+                m._isValid = isNowValid;
175 
+            }
176 
+            else {
177 
+                return isNowValid;
178 
+            }
179 
+        }
180 
+        return m._isValid;
181 
+    }
182 
+
183 
+    function createInvalid (flags) {
184 
+        var m = createUTC(NaN);
185 
+        if (flags != null) {
186 
+            extend(getParsingFlags(m), flags);
187 
+        }
188 
+        else {
189 
+            getParsingFlags(m).userInvalidated = true;
190 
+        }
191 
+
192 
+        return m;
193 
+    }
194 
+
195 
+    // Plugins that add properties should also add the key here (null value),
196 
+    // so we can properly clone ourselves.
197 
+    var momentProperties = hooks.momentProperties = [];
198 
+
199 
+    function copyConfig(to, from) {
200 
+        var i, prop, val;
201 
+
202 
+        if (!isUndefined(from._isAMomentObject)) {
203 
+            to._isAMomentObject = from._isAMomentObject;
204 
+        }
205 
+        if (!isUndefined(from._i)) {
206 
+            to._i = from._i;
207 
+        }
208 
+        if (!isUndefined(from._f)) {
209 
+            to._f = from._f;
210 
+        }
211 
+        if (!isUndefined(from._l)) {
212 
+            to._l = from._l;
213 
+        }
214 
+        if (!isUndefined(from._strict)) {
215 
+            to._strict = from._strict;
216 
+        }
217 
+        if (!isUndefined(from._tzm)) {
218 
+            to._tzm = from._tzm;
219 
+        }
220 
+        if (!isUndefined(from._isUTC)) {
221 
+            to._isUTC = from._isUTC;
222 
+        }
223 
+        if (!isUndefined(from._offset)) {
224 
+            to._offset = from._offset;
225 
+        }
226 
+        if (!isUndefined(from._pf)) {
227 
+            to._pf = getParsingFlags(from);
228 
+        }
229 
+        if (!isUndefined(from._locale)) {
230 
+            to._locale = from._locale;
231 
+        }
232 
+
233 
+        if (momentProperties.length > 0) {
234 
+            for (i = 0; i < momentProperties.length; i++) {
235 
+                prop = momentProperties[i];
236 
+                val = from[prop];
237 
+                if (!isUndefined(val)) {
238 
+                    to[prop] = val;
239 
+                }
240 
+            }
241 
+        }
242 
+
243 
+        return to;
244 
+    }
245 
+
246 
+    var updateInProgress = false;
247 
+
248 
+    // Moment prototype object
249 
+    function Moment(config) {
250 
+        copyConfig(this, config);
251 
+        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
252 
+        if (!this.isValid()) {
253 
+            this._d = new Date(NaN);
254 
+        }
255 
+        // Prevent infinite loop in case updateOffset creates new moment
256 
+        // objects.
257 
+        if (updateInProgress === false) {
258 
+            updateInProgress = true;
259 
+            hooks.updateOffset(this);
260 
+            updateInProgress = false;
261 
+        }
262 
+    }
263 
+
264 
+    function isMoment (obj) {
265 
+        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
266 
+    }
267 
+
268 
+    function absFloor (number) {
269 
+        if (number < 0) {
270 
+            // -0 -> 0
271 
+            return Math.ceil(number) || 0;
272 
+        } else {
273 
+            return Math.floor(number);
274 
+        }
275 
+    }
276 
+
277 
+    function toInt(argumentForCoercion) {
278 
+        var coercedNumber = +argumentForCoercion,
279 
+            value = 0;
280 
+
281 
+        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
282 
+            value = absFloor(coercedNumber);
283 
+        }
284 
+
285 
+        return value;
286 
+    }
287 
+
288 
+    // compare two arrays, return the number of differences
289 
+    function compareArrays(array1, array2, dontConvert) {
290 
+        var len = Math.min(array1.length, array2.length),
291 
+            lengthDiff = Math.abs(array1.length - array2.length),
292 
+            diffs = 0,
293 
+            i;
294 
+        for (i = 0; i < len; i++) {
295 
+            if ((dontConvert && array1[i] !== array2[i]) ||
296 
+                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
297 
+                diffs++;
298 
+            }
299 
+        }
300 
+        return diffs + lengthDiff;
301 
+    }
302 
+
303 
+    function warn(msg) {
304 
+        if (hooks.suppressDeprecationWarnings === false &&
305 
+                (typeof console !==  'undefined') && console.warn) {
306 
+            console.warn('Deprecation warning: ' + msg);
307 
+        }
308 
+    }
309 
+
310 
+    function deprecate(msg, fn) {
311 
+        var firstTime = true;
312 
+
313 
+        return extend(function () {
314 
+            if (hooks.deprecationHandler != null) {
315 
+                hooks.deprecationHandler(null, msg);
316 
+            }
317 
+            if (firstTime) {
318 
+                var args = [];
319 
+                var arg;
320 
+                for (var i = 0; i < arguments.length; i++) {
321 
+                    arg = '';
322 
+                    if (typeof arguments[i] === 'object') {
323 
+                        arg += '\n[' + i + '] ';
324 
+                        for (var key in arguments[0]) {
325 
+                            arg += key + ': ' + arguments[0][key] + ', ';
326 
+                        }
327 
+                        arg = arg.slice(0, -2); // Remove trailing comma and space
328 
+                    } else {
329 
+                        arg = arguments[i];
330 
+                    }
331 
+                    args.push(arg);
332 
+                }
333 
+                warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
334 
+                firstTime = false;
335 
+            }
336 
+            return fn.apply(this, arguments);
337 
+        }, fn);
338 
+    }
339 
+
340 
+    var deprecations = {};
341 
+
342 
+    function deprecateSimple(name, msg) {
343 
+        if (hooks.deprecationHandler != null) {
344 
+            hooks.deprecationHandler(name, msg);
345 
+        }
346 
+        if (!deprecations[name]) {
347 
+            warn(msg);
348 
+            deprecations[name] = true;
349 
+        }
350 
+    }
351 
+
352 
+    hooks.suppressDeprecationWarnings = false;
353 
+    hooks.deprecationHandler = null;
354 
+
355 
+    function isFunction(input) {
356 
+        return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
357 
+    }
358 
+
359 
+    function set (config) {
360 
+        var prop, i;
361 
+        for (i in config) {
362 
+            prop = config[i];
363 
+            if (isFunction(prop)) {
364 
+                this[i] = prop;
365 
+            } else {
366 
+                this['_' + i] = prop;
367 
+            }
368 
+        }
369 
+        this._config = config;
370 
+        // Lenient ordinal parsing accepts just a number in addition to
371 
+        // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
372 
+        // TODO: Remove "ordinalParse" fallback in next major release.
373 
+        this._dayOfMonthOrdinalParseLenient = new RegExp(
374 
+            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
375 
+                '|' + (/\d{1,2}/).source);
376 
+    }
377 
+
378 
+    function mergeConfigs(parentConfig, childConfig) {
379 
+        var res = extend({}, parentConfig), prop;
380 
+        for (prop in childConfig) {
381 
+            if (hasOwnProp(childConfig, prop)) {
382 
+                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
383 
+                    res[prop] = {};
384 
+                    extend(res[prop], parentConfig[prop]);
385 
+                    extend(res[prop], childConfig[prop]);
386 
+                } else if (childConfig[prop] != null) {
387 
+                    res[prop] = childConfig[prop];
388 
+                } else {
389 
+                    delete res[prop];
390 
+                }
391 
+            }
392 
+        }
393 
+        for (prop in parentConfig) {
394 
+            if (hasOwnProp(parentConfig, prop) &&
395 
+                    !hasOwnProp(childConfig, prop) &&
396 
+                    isObject(parentConfig[prop])) {
397 
+                // make sure changes to properties don't modify parent config
398 
+                res[prop] = extend({}, res[prop]);
399 
+            }
400 
+        }
401 
+        return res;
402 
+    }
403 
+
404 
+    function Locale(config) {
405 
+        if (config != null) {
406 
+            this.set(config);
407 
+        }
408 
+    }
409 
+
410 
+    var keys;
411 
+
412 
+    if (Object.keys) {
413 
+        keys = Object.keys;
414 
+    } else {
415 
+        keys = function (obj) {
416 
+            var i, res = [];
417 
+            for (i in obj) {
418 
+                if (hasOwnProp(obj, i)) {
419 
+                    res.push(i);
420 
+                }
421 
+            }
422 
+            return res;
423 
+        };
424 
+    }
425 
+
426 
+    var defaultCalendar = {
427 
+        sameDay : '[Today at] LT',
428 
+        nextDay : '[Tomorrow at] LT',
429 
+        nextWeek : 'dddd [at] LT',
430 
+        lastDay : '[Yesterday at] LT',
431 
+        lastWeek : '[Last] dddd [at] LT',
432 
+        sameElse : 'L'
433 
+    };
434 
+
435 
+    function calendar (key, mom, now) {
436 
+        var output = this._calendar[key] || this._calendar['sameElse'];
437 
+        return isFunction(output) ? output.call(mom, now) : output;
438 
+    }
439 
+
440 
+    var defaultLongDateFormat = {
441 
+        LTS  : 'h:mm:ss A',
442 
+        LT   : 'h:mm A',
443 
+        L    : 'MM/DD/YYYY',
444 
+        LL   : 'MMMM D, YYYY',
445 
+        LLL  : 'MMMM D, YYYY h:mm A',
446 
+        LLLL : 'dddd, MMMM D, YYYY h:mm A'
447 
+    };
448 
+
449 
+    function longDateFormat (key) {
450 
+        var format = this._longDateFormat[key],
451 
+            formatUpper = this._longDateFormat[key.toUpperCase()];
452 
+
453 
+        if (format || !formatUpper) {
454 
+            return format;
455 
+        }
456 
+
457 
+        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
458 
+            return val.slice(1);
459 
+        });
460 
+
461 
+        return this._longDateFormat[key];
462 
+    }
463 
+
464 
+    var defaultInvalidDate = 'Invalid date';
465 
+
466 
+    function invalidDate () {
467 
+        return this._invalidDate;
468 
+    }
469 
+
470 
+    var defaultOrdinal = '%d';
471 
+    var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
472 
+
473 
+    function ordinal (number) {
474 
+        return this._ordinal.replace('%d', number);
475 
+    }
476 
+
477 
+    var defaultRelativeTime = {
478 
+        future : 'in %s',
479 
+        past   : '%s ago',
480 
+        s  : 'a few seconds',
481 
+        ss : '%d seconds',
482 
+        m  : 'a minute',
483 
+        mm : '%d minutes',
484 
+        h  : 'an hour',
485 
+        hh : '%d hours',
486 
+        d  : 'a day',
487 
+        dd : '%d days',
488 
+        M  : 'a month',
489 
+        MM : '%d months',
490 
+        y  : 'a year',
491 
+        yy : '%d years'
492 
+    };
493 
+
494 
+    function relativeTime (number, withoutSuffix, string, isFuture) {
495 
+        var output = this._relativeTime[string];
496 
+        return (isFunction(output)) ?
497 
+            output(number, withoutSuffix, string, isFuture) :
498 
+            output.replace(/%d/i, number);
499 
+    }
500 
+
501 
+    function pastFuture (diff, output) {
502 
+        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
503 
+        return isFunction(format) ? format(output) : format.replace(/%s/i, output);
504 
+    }
505 
+
506 
+    var aliases = {};
507 
+
508 
+    function addUnitAlias (unit, shorthand) {
509 
+        var lowerCase = unit.toLowerCase();
510 
+        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
511 
+    }
512 
+
513 
+    function normalizeUnits(units) {
514 
+        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
515 
+    }
516 
+
517 
+    function normalizeObjectUnits(inputObject) {
518 
+        var normalizedInput = {},
519 
+            normalizedProp,
520 
+            prop;
521 
+
522 
+        for (prop in inputObject) {
523 
+            if (hasOwnProp(inputObject, prop)) {
524 
+                normalizedProp = normalizeUnits(prop);
525 
+                if (normalizedProp) {
526 
+                    normalizedInput[normalizedProp] = inputObject[prop];
527 
+                }
528 
+            }
529 
+        }
530 
+
531 
+        return normalizedInput;
532 
+    }
533 
+
534 
+    var priorities = {};
535 
+
536 
+    function addUnitPriority(unit, priority) {
537 
+        priorities[unit] = priority;
538 
+    }
539 
+
540 
+    function getPrioritizedUnits(unitsObj) {
541 
+        var units = [];
542 
+        for (var u in unitsObj) {
543 
+            units.push({unit: u, priority: priorities[u]});
544 
+        }
545 
+        units.sort(function (a, b) {
546 
+            return a.priority - b.priority;
547 
+        });
548 
+        return units;
549 
+    }
550 
+
551 
+    function zeroFill(number, targetLength, forceSign) {
552 
+        var absNumber = '' + Math.abs(number),
553 
+            zerosToFill = targetLength - absNumber.length,
554 
+            sign = number >= 0;
555 
+        return (sign ? (forceSign ? '+' : '') : '-') +
556 
+            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
557 
+    }
558 
+
559 
+    var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
560 
+
561 
+    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
562 
+
563 
+    var formatFunctions = {};
564 
+
565 
+    var formatTokenFunctions = {};
566 
+
567 
+    // token:    'M'
568 
+    // padded:   ['MM', 2]
569 
+    // ordinal:  'Mo'
570 
+    // callback: function () { this.month() + 1 }
571 
+    function addFormatToken (token, padded, ordinal, callback) {
572 
+        var func = callback;
573 
+        if (typeof callback === 'string') {
574 
+            func = function () {
575 
+                return this[callback]();
576 
+            };
577 
+        }
578 
+        if (token) {
579 
+            formatTokenFunctions[token] = func;
580 
+        }
581 
+        if (padded) {
582 
+            formatTokenFunctions[padded[0]] = function () {
583 
+                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
584 
+            };
585 
+        }
586 
+        if (ordinal) {
587 
+            formatTokenFunctions[ordinal] = function () {
588 
+                return this.localeData().ordinal(func.apply(this, arguments), token);
589 
+            };
590 
+        }
591 
+    }
592 
+
593 
+    function removeFormattingTokens(input) {
594 
+        if (input.match(/\[[\s\S]/)) {
595 
+            return input.replace(/^\[|\]$/g, '');
596 
+        }
597 
+        return input.replace(/\\/g, '');
598 
+    }
599 
+
600 
+    function makeFormatFunction(format) {
601 
+        var array = format.match(formattingTokens), i, length;
602 
+
603 
+        for (i = 0, length = array.length; i < length; i++) {
604 
+            if (formatTokenFunctions[array[i]]) {
605 
+                array[i] = formatTokenFunctions[array[i]];
606 
+            } else {
607 
+                array[i] = removeFormattingTokens(array[i]);
608 
+            }
609 
+        }
610 
+
611 
+        return function (mom) {
612 
+            var output = '', i;
613 
+            for (i = 0; i < length; i++) {
614 
+                output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
615 
+            }
616 
+            return output;
617 
+        };
618 
+    }
619 
+
620 
+    // format date using native date object
621 
+    function formatMoment(m, format) {
622 
+        if (!m.isValid()) {
623 
+            return m.localeData().invalidDate();
624 
+        }
625 
+
626 
+        format = expandFormat(format, m.localeData());
627 
+        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
628 
+
629 
+        return formatFunctions[format](m);
630 
+    }
631 
+
632 
+    function expandFormat(format, locale) {
633 
+        var i = 5;
634 
+
635 
+        function replaceLongDateFormatTokens(input) {
636 
+            return locale.longDateFormat(input) || input;
637 
+        }
638 
+
639 
+        localFormattingTokens.lastIndex = 0;
640 
+        while (i >= 0 && localFormattingTokens.test(format)) {
641 
+            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
642 
+            localFormattingTokens.lastIndex = 0;
643 
+            i -= 1;
644 
+        }
645 
+
646 
+        return format;
647 
+    }
648 
+
649 
+    var match1         = /\d/;            //       0 - 9
650 
+    var match2         = /\d\d/;          //      00 - 99
651 
+    var match3         = /\d{3}/;         //     000 - 999
652 
+    var match4         = /\d{4}/;         //    0000 - 9999
653 
+    var match6         = /[+-]?\d{6}/;    // -999999 - 999999
654 
+    var match1to2      = /\d\d?/;         //       0 - 99
655 
+    var match3to4      = /\d\d\d\d?/;     //     999 - 9999
656 
+    var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
657 
+    var match1to3      = /\d{1,3}/;       //       0 - 999
658 
+    var match1to4      = /\d{1,4}/;       //       0 - 9999
659 
+    var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
660 
+
661 
+    var matchUnsigned  = /\d+/;           //       0 - inf
662 
+    var matchSigned    = /[+-]?\d+/;      //    -inf - inf
663 
+
664 
+    var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
665 
+    var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
666 
+
667 
+    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
668 
+
669 
+    // any word (or two) characters or numbers including two/three word month in arabic.
670 
+    // includes scottish gaelic two word and hyphenated months
671 
+    var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;
672 
+
673 
+    var regexes = {};
674 
+
675 
+    function addRegexToken (token, regex, strictRegex) {
676 
+        regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
677 
+            return (isStrict && strictRegex) ? strictRegex : regex;
678 
+        };
679 
+    }
680 
+
681 
+    function getParseRegexForToken (token, config) {
682 
+        if (!hasOwnProp(regexes, token)) {
683 
+            return new RegExp(unescapeFormat(token));
684 
+        }
685 
+
686 
+        return regexes[token](config._strict, config._locale);
687 
+    }
688 
+
689 
+    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
690 
+    function unescapeFormat(s) {
691 
+        return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
692 
+            return p1 || p2 || p3 || p4;
693 
+        }));
694 
+    }
695 
+
696 
+    function regexEscape(s) {
697 
+        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
698 
+    }
699 
+
700 
+    var tokens = {};
701 
+
702 
+    function addParseToken (token, callback) {
703 
+        var i, func = callback;
704 
+        if (typeof token === 'string') {
705 
+            token = [token];
706 
+        }
707 
+        if (isNumber(callback)) {
708 
+            func = function (input, array) {
709 
+                array[callback] = toInt(input);
710 
+            };
711 
+        }
712 
+        for (i = 0; i < token.length; i++) {
713 
+            tokens[token[i]] = func;
714 
+        }
715 
+    }
716 
+
717 
+    function addWeekParseToken (token, callback) {
718 
+        addParseToken(token, function (input, array, config, token) {
719 
+            config._w = config._w || {};
720 
+            callback(input, config._w, config, token);
721 
+        });
722 
+    }
723 
+
724 
+    function addTimeToArrayFromToken(token, input, config) {
725 
+        if (input != null && hasOwnProp(tokens, token)) {
726 
+            tokens[token](input, config._a, config, token);
727 
+        }
728 
+    }
729 
+
730 
+    var YEAR = 0;
731 
+    var MONTH = 1;
732 
+    var DATE = 2;
733 
+    var HOUR = 3;
734 
+    var MINUTE = 4;
735 
+    var SECOND = 5;
736 
+    var MILLISECOND = 6;
737 
+    var WEEK = 7;
738 
+    var WEEKDAY = 8;
739 
+
740 
+    // FORMATTING
741 
+
742 
+    addFormatToken('Y', 0, 0, function () {
743 
+        var y = this.year();
744 
+        return y <= 9999 ? '' + y : '+' + y;
745 
+    });
746 
+
747 
+    addFormatToken(0, ['YY', 2], 0, function () {
748 
+        return this.year() % 100;
749 
+    });
750 
+
751 
+    addFormatToken(0, ['YYYY',   4],       0, 'year');
752 
+    addFormatToken(0, ['YYYYY',  5],       0, 'year');
753 
+    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
754 
+
755 
+    // ALIASES
756 
+
757 
+    addUnitAlias('year', 'y');
758 
+
759 
+    // PRIORITIES
760 
+
761 
+    addUnitPriority('year', 1);
762 
+
763 
+    // PARSING
764 
+
765 
+    addRegexToken('Y',      matchSigned);
766 
+    addRegexToken('YY',     match1to2, match2);
767 
+    addRegexToken('YYYY',   match1to4, match4);
768 
+    addRegexToken('YYYYY',  match1to6, match6);
769 
+    addRegexToken('YYYYYY', match1to6, match6);
770 
+
771 
+    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
772 
+    addParseToken('YYYY', function (input, array) {
773 
+        array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
774 
+    });
775 
+    addParseToken('YY', function (input, array) {
776 
+        array[YEAR] = hooks.parseTwoDigitYear(input);
777 
+    });
778 
+    addParseToken('Y', function (input, array) {
779 
+        array[YEAR] = parseInt(input, 10);
780 
+    });
781 
+
782 
+    // HELPERS
783 
+
784 
+    function daysInYear(year) {
785 
+        return isLeapYear(year) ? 366 : 365;
786 
+    }
787 
+
788 
+    function isLeapYear(year) {
789 
+        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
790 
+    }
791 
+
792 
+    // HOOKS
793 
+
794 
+    hooks.parseTwoDigitYear = function (input) {
795 
+        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
796 
+    };
797 
+
798 
+    // MOMENTS
799 
+
800 
+    var getSetYear = makeGetSet('FullYear', true);
801 
+
802 
+    function getIsLeapYear () {
803 
+        return isLeapYear(this.year());
804 
+    }
805 
+
806 
+    function makeGetSet (unit, keepTime) {
807 
+        return function (value) {
808 
+            if (value != null) {
809 
+                set$1(this, unit, value);
810 
+                hooks.updateOffset(this, keepTime);
811 
+                return this;
812 
+            } else {
813 
+                return get(this, unit);
814 
+            }
815 
+        };
816 
+    }
817 
+
818 
+    function get (mom, unit) {
819 
+        return mom.isValid() ?
820 
+            mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
821 
+    }
822 
+
823 
+    function set$1 (mom, unit, value) {
824 
+        if (mom.isValid() && !isNaN(value)) {
825 
+            if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
826 
+                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));
827 
+            }
828 
+            else {
829 
+                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
830 
+            }
831 
+        }
832 
+    }
833 
+
834 
+    // MOMENTS
835 
+
836 
+    function stringGet (units) {
837 
+        units = normalizeUnits(units);
838 
+        if (isFunction(this[units])) {
839 
+            return this[units]();
840 
+        }
841 
+        return this;
842 
+    }
843 
+
844 
+
845 
+    function stringSet (units, value) {
846 
+        if (typeof units === 'object') {
847 
+            units = normalizeObjectUnits(units);
848 
+            var prioritized = getPrioritizedUnits(units);
849 
+            for (var i = 0; i < prioritized.length; i++) {
850 
+                this[prioritized[i].unit](units[prioritized[i].unit]);
851 
+            }
852 
+        } else {
853 
+            units = normalizeUnits(units);
854 
+            if (isFunction(this[units])) {
855 
+                return this[units](value);
856 
+            }
857 
+        }
858 
+        return this;
859 
+    }
860 
+
861 
+    function mod(n, x) {
862 
+        return ((n % x) + x) % x;
863 
+    }
864 
+
865 
+    var indexOf;
866 
+
867 
+    if (Array.prototype.indexOf) {
868 
+        indexOf = Array.prototype.indexOf;
869 
+    } else {
870 
+        indexOf = function (o) {
871 
+            // I know
872 
+            var i;
873 
+            for (i = 0; i < this.length; ++i) {
874 
+                if (this[i] === o) {
875 
+                    return i;
876 
+                }
877 
+            }
878 
+            return -1;
879 
+        };
880 
+    }
881 
+
882 
+    function daysInMonth(year, month) {
883 
+        if (isNaN(year) || isNaN(month)) {
884 
+            return NaN;
885 
+        }
886 
+        var modMonth = mod(month, 12);
887 
+        year += (month - modMonth) / 12;
888 
+        return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
889 
+    }
890 
+
891 
+    // FORMATTING
892 
+
893 
+    addFormatToken('M', ['MM', 2], 'Mo', function () {
894 
+        return this.month() + 1;
895 
+    });
896 
+
897 
+    addFormatToken('MMM', 0, 0, function (format) {
898 
+        return this.localeData().monthsShort(this, format);
899 
+    });
900 
+
901 
+    addFormatToken('MMMM', 0, 0, function (format) {
902 
+        return this.localeData().months(this, format);
903 
+    });
904 
+
905 
+    // ALIASES
906 
+
907 
+    addUnitAlias('month', 'M');
908 
+
909 
+    // PRIORITY
910 
+
911 
+    addUnitPriority('month', 8);
912 
+
913 
+    // PARSING
914 
+
915 
+    addRegexToken('M',    match1to2);
916 
+    addRegexToken('MM',   match1to2, match2);
917 
+    addRegexToken('MMM',  function (isStrict, locale) {
918 
+        return locale.monthsShortRegex(isStrict);
919 
+    });
920 
+    addRegexToken('MMMM', function (isStrict, locale) {
921 
+        return locale.monthsRegex(isStrict);
922 
+    });
923 
+
924 
+    addParseToken(['M', 'MM'], function (input, array) {
925 
+        array[MONTH] = toInt(input) - 1;
926 
+    });
927 
+
928 
+    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
929 
+        var month = config._locale.monthsParse(input, token, config._strict);
930 
+        // if we didn't find a month name, mark the date as invalid.
931 
+        if (month != null) {
932 
+            array[MONTH] = month;
933 
+        } else {
934 
+            getParsingFlags(config).invalidMonth = input;
935 
+        }
936 
+    });
937 
+
938 
+    // LOCALES
939 
+
940 
+    var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
941 
+    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
942 
+    function localeMonths (m, format) {
943 
+        if (!m) {
944 
+            return isArray(this._months) ? this._months :
945 
+                this._months['standalone'];
946 
+        }
947 
+        return isArray(this._months) ? this._months[m.month()] :
948 
+            this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
949 
+    }
950 
+
951 
+    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
952 
+    function localeMonthsShort (m, format) {
953 
+        if (!m) {
954 
+            return isArray(this._monthsShort) ? this._monthsShort :
955 
+                this._monthsShort['standalone'];
956 
+        }
957 
+        return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
958 
+            this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
959 
+    }
960 
+
961 
+    function handleStrictParse(monthName, format, strict) {
962 
+        var i, ii, mom, llc = monthName.toLocaleLowerCase();
963 
+        if (!this._monthsParse) {
964 
+            // this is not used
965 
+            this._monthsParse = [];
966 
+            this._longMonthsParse = [];
967 
+            this._shortMonthsParse = [];
968 
+            for (i = 0; i < 12; ++i) {
969 
+                mom = createUTC([2000, i]);
970 
+                this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
971 
+                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
972 
+            }
973 
+        }
974 
+
975 
+        if (strict) {
976 
+            if (format === 'MMM') {
977 
+                ii = indexOf.call(this._shortMonthsParse, llc);
978 
+                return ii !== -1 ? ii : null;
979 
+            } else {
980 
+                ii = indexOf.call(this._longMonthsParse, llc);
981 
+                return ii !== -1 ? ii : null;
982 
+            }
983 
+        } else {
984 
+            if (format === 'MMM') {
985 
+                ii = indexOf.call(this._shortMonthsParse, llc);
986 
+                if (ii !== -1) {
987 
+                    return ii;
988 
+                }
989 
+                ii = indexOf.call(this._longMonthsParse, llc);
990 
+                return ii !== -1 ? ii : null;
991 
+            } else {
992 
+                ii = indexOf.call(this._longMonthsParse, llc);
993 
+                if (ii !== -1) {
994 
+                    return ii;
995 
+                }
996 
+                ii = indexOf.call(this._shortMonthsParse, llc);
997 
+                return ii !== -1 ? ii : null;
998 
+            }
999 
+        }
1000 
+    }
1001 
+
1002 
+    function localeMonthsParse (monthName, format, strict) {
1003 
+        var i, mom, regex;
1004 
+
1005 
+        if (this._monthsParseExact) {
1006 
+            return handleStrictParse.call(this, monthName, format, strict);
1007 
+        }
1008 
+
1009 
+        if (!this._monthsParse) {
1010 
+            this._monthsParse = [];
1011 
+            this._longMonthsParse = [];
1012 
+            this._shortMonthsParse = [];
1013 
+        }
1014 
+
1015 
+        // TODO: add sorting
1016 
+        // Sorting makes sure if one month (or abbr) is a prefix of another
1017 
+        // see sorting in computeMonthsParse
1018 
+        for (i = 0; i < 12; i++) {
1019 
+            // make the regex if we don't have it already
1020 
+            mom = createUTC([2000, i]);
1021 
+            if (strict && !this._longMonthsParse[i]) {
1022 
+                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
1023 
+                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
1024 
+            }
1025 
+            if (!strict && !this._monthsParse[i]) {
1026 
+                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
1027 
+                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
1028 
+            }
1029 
+            // test the regex
1030 
+            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
1031 
+                return i;
1032 
+            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
1033 
+                return i;
1034 
+            } else if (!strict && this._monthsParse[i].test(monthName)) {
1035 
+                return i;
1036 
+            }
1037 
+        }
1038 
+    }
1039 
+
1040 
+    // MOMENTS
1041 
+
1042 
+    function setMonth (mom, value) {
1043 
+        var dayOfMonth;
1044 
+
1045 
+        if (!mom.isValid()) {
1046 
+            // No op
1047 
+            return mom;
1048 
+        }
1049 
+
1050 
+        if (typeof value === 'string') {
1051 
+            if (/^\d+$/.test(value)) {
1052 
+                value = toInt(value);
1053 
+            } else {
1054 
+                value = mom.localeData().monthsParse(value);
1055 
+                // TODO: Another silent failure?
1056 
+                if (!isNumber(value)) {
1057 
+                    return mom;
1058 
+                }
1059 
+            }
1060 
+        }
1061 
+
1062 
+        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
1063 
+        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
1064 
+        return mom;
1065 
+    }
1066 
+
1067 
+    function getSetMonth (value) {
1068 
+        if (value != null) {
1069 
+            setMonth(this, value);
1070 
+            hooks.updateOffset(this, true);
1071 
+            return this;
1072 
+        } else {
1073 
+            return get(this, 'Month');
1074 
+        }
1075 
+    }
1076 
+
1077 
+    function getDaysInMonth () {
1078 
+        return daysInMonth(this.year(), this.month());
1079 
+    }
1080 
+
1081 
+    var defaultMonthsShortRegex = matchWord;
1082 
+    function monthsShortRegex (isStrict) {
1083 
+        if (this._monthsParseExact) {
1084 
+            if (!hasOwnProp(this, '_monthsRegex')) {
1085 
+                computeMonthsParse.call(this);
1086 
+            }
1087 
+            if (isStrict) {
1088 
+                return this._monthsShortStrictRegex;
1089 
+            } else {
1090 
+                return this._monthsShortRegex;
1091 
+            }
1092 
+        } else {
1093 
+            if (!hasOwnProp(this, '_monthsShortRegex')) {
1094 
+                this._monthsShortRegex = defaultMonthsShortRegex;
1095 
+            }
1096 
+            return this._monthsShortStrictRegex && isStrict ?
1097 
+                this._monthsShortStrictRegex : this._monthsShortRegex;
1098 
+        }
1099 
+    }
1100 
+
1101 
+    var defaultMonthsRegex = matchWord;
1102 
+    function monthsRegex (isStrict) {
1103 
+        if (this._monthsParseExact) {
1104 
+            if (!hasOwnProp(this, '_monthsRegex')) {
1105 
+                computeMonthsParse.call(this);
1106 
+            }
1107 
+            if (isStrict) {
1108 
+                return this._monthsStrictRegex;
1109 
+            } else {
1110 
+                return this._monthsRegex;
1111 
+            }
1112 
+        } else {
1113 
+            if (!hasOwnProp(this, '_monthsRegex')) {
1114 
+                this._monthsRegex = defaultMonthsRegex;
1115 
+            }
1116 
+            return this._monthsStrictRegex && isStrict ?
1117 
+                this._monthsStrictRegex : this._monthsRegex;
1118 
+        }
1119 
+    }
1120 
+
1121 
+    function computeMonthsParse () {
1122 
+        function cmpLenRev(a, b) {
1123 
+            return b.length - a.length;
1124 
+        }
1125 
+
1126 
+        var shortPieces = [], longPieces = [], mixedPieces = [],
1127 
+            i, mom;
1128 
+        for (i = 0; i < 12; i++) {
1129 
+            // make the regex if we don't have it already
1130 
+            mom = createUTC([2000, i]);
1131 
+            shortPieces.push(this.monthsShort(mom, ''));
1132 
+            longPieces.push(this.months(mom, ''));
1133 
+            mixedPieces.push(this.months(mom, ''));
1134 
+            mixedPieces.push(this.monthsShort(mom, ''));
1135 
+        }
1136 
+        // Sorting makes sure if one month (or abbr) is a prefix of another it
1137 
+        // will match the longer piece.
1138 
+        shortPieces.sort(cmpLenRev);
1139 
+        longPieces.sort(cmpLenRev);
1140 
+        mixedPieces.sort(cmpLenRev);
1141 
+        for (i = 0; i < 12; i++) {
1142 
+            shortPieces[i] = regexEscape(shortPieces[i]);
1143 
+            longPieces[i] = regexEscape(longPieces[i]);
1144 
+        }
1145 
+        for (i = 0; i < 24; i++) {
1146 
+            mixedPieces[i] = regexEscape(mixedPieces[i]);
1147 
+        }
1148 
+
1149 
+        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1150 
+        this._monthsShortRegex = this._monthsRegex;
1151 
+        this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1152 
+        this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1153 
+    }
1154 
+
1155 
+    function createDate (y, m, d, h, M, s, ms) {
1156 
+        // can't just apply() to create a date:
1157 
+        // https://stackoverflow.com/q/181348
1158 
+        var date;
1159 
+        // the date constructor remaps years 0-99 to 1900-1999
1160 
+        if (y < 100 && y >= 0) {
1161 
+            // preserve leap years using a full 400 year cycle, then reset
1162 
+            date = new Date(y + 400, m, d, h, M, s, ms);
1163 
+            if (isFinite(date.getFullYear())) {
1164 
+                date.setFullYear(y);
1165 
+            }
1166 
+        } else {
1167 
+            date = new Date(y, m, d, h, M, s, ms);
1168 
+        }
1169 
+
1170 
+        return date;
1171 
+    }
1172 
+
1173 
+    function createUTCDate (y) {
1174 
+        var date;
1175 
+        // the Date.UTC function remaps years 0-99 to 1900-1999
1176 
+        if (y < 100 && y >= 0) {
1177 
+            var args = Array.prototype.slice.call(arguments);
1178 
+            // preserve leap years using a full 400 year cycle, then reset
1179 
+            args[0] = y + 400;
1180 
+            date = new Date(Date.UTC.apply(null, args));
1181 
+            if (isFinite(date.getUTCFullYear())) {
1182 
+                date.setUTCFullYear(y);
1183 
+            }
1184 
+        } else {
1185 
+            date = new Date(Date.UTC.apply(null, arguments));
1186 
+        }
1187 
+
1188 
+        return date;
1189 
+    }
1190 
+
1191 
+    // start-of-first-week - start-of-year
1192 
+    function firstWeekOffset(year, dow, doy) {
1193 
+        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
1194 
+            fwd = 7 + dow - doy,
1195 
+            // first-week day local weekday -- which local weekday is fwd
1196 
+            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
1197 
+
1198 
+        return -fwdlw + fwd - 1;
1199 
+    }
1200 
+
1201 
+    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
1202 
+    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
1203 
+        var localWeekday = (7 + weekday - dow) % 7,
1204 
+            weekOffset = firstWeekOffset(year, dow, doy),
1205 
+            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
1206 
+            resYear, resDayOfYear;
1207 
+
1208 
+        if (dayOfYear <= 0) {
1209 
+            resYear = year - 1;
1210 
+            resDayOfYear = daysInYear(resYear) + dayOfYear;
1211 
+        } else if (dayOfYear > daysInYear(year)) {
1212 
+            resYear = year + 1;
1213 
+            resDayOfYear = dayOfYear - daysInYear(year);
1214 
+        } else {
1215 
+            resYear = year;
1216 
+            resDayOfYear = dayOfYear;
1217 
+        }
1218 
+
1219 
+        return {
1220 
+            year: resYear,
1221 
+            dayOfYear: resDayOfYear
1222 
+        };
1223 
+    }
1224 
+
1225 
+    function weekOfYear(mom, dow, doy) {
1226 
+        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
1227 
+            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
1228 
+            resWeek, resYear;
1229 
+
1230 
+        if (week < 1) {
1231 
+            resYear = mom.year() - 1;
1232 
+            resWeek = week + weeksInYear(resYear, dow, doy);
1233 
+        } else if (week > weeksInYear(mom.year(), dow, doy)) {
1234 
+            resWeek = week - weeksInYear(mom.year(), dow, doy);
1235 
+            resYear = mom.year() + 1;
1236 
+        } else {
1237 
+            resYear = mom.year();
1238 
+            resWeek = week;
1239 
+        }
1240 
+
1241 
+        return {
1242 
+            week: resWeek,
1243 
+            year: resYear
1244 
+        };
1245 
+    }
1246 
+
1247 
+    function weeksInYear(year, dow, doy) {
1248 
+        var weekOffset = firstWeekOffset(year, dow, doy),
1249 
+            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
1250 
+        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
1251 
+    }
1252 
+
1253 
+    // FORMATTING
1254 
+
1255 
+    addFormatToken('w', ['ww', 2], 'wo', 'week');
1256 
+    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
1257 
+
1258 
+    // ALIASES
1259 
+
1260 
+    addUnitAlias('week', 'w');
1261 
+    addUnitAlias('isoWeek', 'W');
1262 
+
1263 
+    // PRIORITIES
1264 
+
1265 
+    addUnitPriority('week', 5);
1266 
+    addUnitPriority('isoWeek', 5);
1267 
+
1268 
+    // PARSING
1269 
+
1270 
+    addRegexToken('w',  match1to2);
1271 
+    addRegexToken('ww', match1to2, match2);
1272 
+    addRegexToken('W',  match1to2);
1273 
+    addRegexToken('WW', match1to2, match2);
1274 
+
1275 
+    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
1276 
+        week[token.substr(0, 1)] = toInt(input);
1277 
+    });
1278 
+
1279 
+    // HELPERS
1280 
+
1281 
+    // LOCALES
1282 
+
1283 
+    function localeWeek (mom) {
1284 
+        return weekOfYear(mom, this._week.dow, this._week.doy).week;
1285 
+    }
1286 
+
1287 
+    var defaultLocaleWeek = {
1288 
+        dow : 0, // Sunday is the first day of the week.
1289 
+        doy : 6  // The week that contains Jan 6th is the first week of the year.
1290 
+    };
1291 
+
1292 
+    function localeFirstDayOfWeek () {
1293 
+        return this._week.dow;
1294 
+    }
1295 
+
1296 
+    function localeFirstDayOfYear () {
1297 
+        return this._week.doy;
1298 
+    }
1299 
+
1300 
+    // MOMENTS
1301 
+
1302 
+    function getSetWeek (input) {
1303 
+        var week = this.localeData().week(this);
1304 
+        return input == null ? week : this.add((input - week) * 7, 'd');
1305 
+    }
1306 
+
1307 
+    function getSetISOWeek (input) {
1308 
+        var week = weekOfYear(this, 1, 4).week;
1309 
+        return input == null ? week : this.add((input - week) * 7, 'd');
1310 
+    }
1311 
+
1312 
+    // FORMATTING
1313 
+
1314 
+    addFormatToken('d', 0, 'do', 'day');
1315 
+
1316 
+    addFormatToken('dd', 0, 0, function (format) {
1317 
+        return this.localeData().weekdaysMin(this, format);
1318 
+    });
1319 
+
1320 
+    addFormatToken('ddd', 0, 0, function (format) {
1321 
+        return this.localeData().weekdaysShort(this, format);
1322 
+    });
1323 
+
1324 
+    addFormatToken('dddd', 0, 0, function (format) {
1325 
+        return this.localeData().weekdays(this, format);
1326 
+    });
1327 
+
1328 
+    addFormatToken('e', 0, 0, 'weekday');
1329 
+    addFormatToken('E', 0, 0, 'isoWeekday');
1330 
+
1331 
+    // ALIASES
1332 
+
1333 
+    addUnitAlias('day', 'd');
1334 
+    addUnitAlias('weekday', 'e');
1335 
+    addUnitAlias('isoWeekday', 'E');
1336 
+
1337 
+    // PRIORITY
1338 
+    addUnitPriority('day', 11);
1339 
+    addUnitPriority('weekday', 11);
1340 
+    addUnitPriority('isoWeekday', 11);
1341 
+
1342 
+    // PARSING
1343 
+
1344 
+    addRegexToken('d',    match1to2);
1345 
+    addRegexToken('e',    match1to2);
1346 
+    addRegexToken('E',    match1to2);
1347 
+    addRegexToken('dd',   function (isStrict, locale) {
1348 
+        return locale.weekdaysMinRegex(isStrict);
1349 
+    });
1350 
+    addRegexToken('ddd',   function (isStrict, locale) {
1351 
+        return locale.weekdaysShortRegex(isStrict);
1352 
+    });
1353 
+    addRegexToken('dddd',   function (isStrict, locale) {
1354 
+        return locale.weekdaysRegex(isStrict);
1355 
+    });
1356 
+
1357 
+    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
1358 
+        var weekday = config._locale.weekdaysParse(input, token, config._strict);
1359 
+        // if we didn't get a weekday name, mark the date as invalid
1360 
+        if (weekday != null) {
1361 
+            week.d = weekday;
1362 
+        } else {
1363 
+            getParsingFlags(config).invalidWeekday = input;
1364 
+        }
1365 
+    });
1366 
+
1367 
+    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
1368 
+        week[token] = toInt(input);
1369 
+    });
1370 
+
1371 
+    // HELPERS
1372 
+
1373 
+    function parseWeekday(input, locale) {
1374 
+        if (typeof input !== 'string') {
1375 
+            return input;
1376 
+        }
1377 
+
1378 
+        if (!isNaN(input)) {
1379 
+            return parseInt(input, 10);
1380 
+        }
1381 
+
1382 
+        input = locale.weekdaysParse(input);
1383 
+        if (typeof input === 'number') {
1384 
+            return input;
1385 
+        }
1386 
+
1387 
+        return null;
1388 
+    }
1389 
+
1390 
+    function parseIsoWeekday(input, locale) {
1391 
+        if (typeof input === 'string') {
1392 
+            return locale.weekdaysParse(input) % 7 || 7;
1393 
+        }
1394 
+        return isNaN(input) ? null : input;
1395 
+    }
1396 
+
1397 
+    // LOCALES
1398 
+    function shiftWeekdays (ws, n) {
1399 
+        return ws.slice(n, 7).concat(ws.slice(0, n));
1400 
+    }
1401 
+
1402 
+    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
1403 
+    function localeWeekdays (m, format) {
1404 
+        var weekdays = isArray(this._weekdays) ? this._weekdays :
1405 
+            this._weekdays[(m && m !== true && this._weekdays.isFormat.test(format)) ? 'format' : 'standalone'];
1406 
+        return (m === true) ? shiftWeekdays(weekdays, this._week.dow)
1407 
+            : (m) ? weekdays[m.day()] : weekdays;
1408 
+    }
1409 
+
1410 
+    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
1411 
+    function localeWeekdaysShort (m) {
1412 
+        return (m === true) ? shiftWeekdays(this._weekdaysShort, this._week.dow)
1413 
+            : (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
1414 
+    }
1415 
+
1416 
+    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
1417 
+    function localeWeekdaysMin (m) {
1418 
+        return (m === true) ? shiftWeekdays(this._weekdaysMin, this._week.dow)
1419 
+            : (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
1420 
+    }
1421 
+
1422 
+    function handleStrictParse$1(weekdayName, format, strict) {
1423 
+        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
1424 
+        if (!this._weekdaysParse) {
1425 
+            this._weekdaysParse = [];
1426 
+            this._shortWeekdaysParse = [];
1427 
+            this._minWeekdaysParse = [];
1428 
+
1429 
+            for (i = 0; i < 7; ++i) {
1430 
+                mom = createUTC([2000, 1]).day(i);
1431 
+                this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
1432 
+                this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
1433 
+                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
1434 
+            }
1435 
+        }
1436 
+
1437 
+        if (strict) {
1438 
+            if (format === 'dddd') {
1439 
+                ii = indexOf.call(this._weekdaysParse, llc);
1440 
+                return ii !== -1 ? ii : null;
1441 
+            } else if (format === 'ddd') {
1442 
+                ii = indexOf.call(this._shortWeekdaysParse, llc);
1443 
+                return ii !== -1 ? ii : null;
1444 
+            } else {
1445 
+                ii = indexOf.call(this._minWeekdaysParse, llc);
1446 
+                return ii !== -1 ? ii : null;
1447 
+            }
1448 
+        } else {
1449 
+            if (format === 'dddd') {
1450 
+                ii = indexOf.call(this._weekdaysParse, llc);
1451 
+                if (ii !== -1) {
1452 
+                    return ii;
1453 
+                }
1454 
+                ii = indexOf.call(this._shortWeekdaysParse, llc);
1455 
+                if (ii !== -1) {
1456 
+                    return ii;
1457 
+                }
1458 
+                ii = indexOf.call(this._minWeekdaysParse, llc);
1459 
+                return ii !== -1 ? ii : null;
1460 
+            } else if (format === 'ddd') {
1461 
+                ii = indexOf.call(this._shortWeekdaysParse, llc);
1462 
+                if (ii !== -1) {
1463 
+                    return ii;
1464 
+                }
1465 
+                ii = indexOf.call(this._weekdaysParse, llc);
1466 
+                if (ii !== -1) {
1467 
+                    return ii;
1468 
+                }
1469 
+                ii = indexOf.call(this._minWeekdaysParse, llc);
1470 
+                return ii !== -1 ? ii : null;
1471 
+            } else {
1472 
+                ii = indexOf.call(this._minWeekdaysParse, llc);
1473 
+                if (ii !== -1) {
1474 
+                    return ii;
1475 
+                }
1476 
+                ii = indexOf.call(this._weekdaysParse, llc);
1477 
+                if (ii !== -1) {
1478 
+                    return ii;
1479 
+                }
1480 
+                ii = indexOf.call(this._shortWeekdaysParse, llc);
1481 
+                return ii !== -1 ? ii : null;
1482 
+            }
1483 
+        }
1484 
+    }
1485 
+
1486 
+    function localeWeekdaysParse (weekdayName, format, strict) {
1487 
+        var i, mom, regex;
1488 
+
1489 
+        if (this._weekdaysParseExact) {
1490 
+            return handleStrictParse$1.call(this, weekdayName, format, strict);
1491 
+        }
1492 
+
1493 
+        if (!this._weekdaysParse) {
1494 
+            this._weekdaysParse = [];
1495 
+            this._minWeekdaysParse = [];
1496 
+            this._shortWeekdaysParse = [];
1497 
+            this._fullWeekdaysParse = [];
1498 
+        }
1499 
+
1500 
+        for (i = 0; i < 7; i++) {
1501 
+            // make the regex if we don't have it already
1502 
+
1503 
+            mom = createUTC([2000, 1]).day(i);
1504 
+            if (strict && !this._fullWeekdaysParse[i]) {
1505 
+                this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');
1506 
+                this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');
1507 
+                this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');
1508 
+            }
1509 
+            if (!this._weekdaysParse[i]) {
1510 
+                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
1511 
+                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
1512 
+            }
1513 
+            // test the regex
1514 
+            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
1515 
+                return i;
1516 
+            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
1517 
+                return i;
1518 
+            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
1519 
+                return i;
1520 
+            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
1521 
+                return i;
1522 
+            }
1523 
+        }
1524 
+    }
1525 
+
1526 
+    // MOMENTS
1527 
+
1528 
+    function getSetDayOfWeek (input) {
1529 
+        if (!this.isValid()) {
1530 
+            return input != null ? this : NaN;
1531 
+        }
1532 
+        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
1533 
+        if (input != null) {
1534 
+            input = parseWeekday(input, this.localeData());
1535 
+            return this.add(input - day, 'd');
1536 
+        } else {
1537 
+            return day;
1538 
+        }
1539 
+    }
1540 
+
1541 
+    function getSetLocaleDayOfWeek (input) {
1542 
+        if (!this.isValid()) {
1543 
+            return input != null ? this : NaN;
1544 
+        }
1545 
+        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
1546 
+        return input == null ? weekday : this.add(input - weekday, 'd');
1547 
+    }
1548 
+
1549 
+    function getSetISODayOfWeek (input) {
1550 
+        if (!this.isValid()) {
1551 
+            return input != null ? this : NaN;
1552 
+        }
1553 
+
1554 
+        // behaves the same as moment#day except
1555 
+        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
1556 
+        // as a setter, sunday should belong to the previous week.
1557 
+
1558 
+        if (input != null) {
1559 
+            var weekday = parseIsoWeekday(input, this.localeData());
1560 
+            return this.day(this.day() % 7 ? weekday : weekday - 7);
1561 
+        } else {
1562 
+            return this.day() || 7;
1563 
+        }
1564 
+    }
1565 
+
1566 
+    var defaultWeekdaysRegex = matchWord;
1567 
+    function weekdaysRegex (isStrict) {
1568 
+        if (this._weekdaysParseExact) {
1569 
+            if (!hasOwnProp(this, '_weekdaysRegex')) {
1570 
+                computeWeekdaysParse.call(this);
1571 
+            }
1572 
+            if (isStrict) {
1573 
+                return this._weekdaysStrictRegex;
1574 
+            } else {
1575 
+                return this._weekdaysRegex;
1576 
+            }
1577 
+        } else {
1578 
+            if (!hasOwnProp(this, '_weekdaysRegex')) {
1579 
+                this._weekdaysRegex = defaultWeekdaysRegex;
1580 
+            }
1581 
+            return this._weekdaysStrictRegex && isStrict ?
1582 
+                this._weekdaysStrictRegex : this._weekdaysRegex;
1583 
+        }
1584 
+    }
1585 
+
1586 
+    var defaultWeekdaysShortRegex = matchWord;
1587 
+    function weekdaysShortRegex (isStrict) {
1588 
+        if (this._weekdaysParseExact) {
1589 
+            if (!hasOwnProp(this, '_weekdaysRegex')) {
1590 
+                computeWeekdaysParse.call(this);
1591 
+            }
1592 
+            if (isStrict) {
1593 
+                return this._weekdaysShortStrictRegex;
1594 
+            } else {
1595 
+                return this._weekdaysShortRegex;
1596 
+            }
1597 
+        } else {
1598 
+            if (!hasOwnProp(this, '_weekdaysShortRegex')) {
1599 
+                this._weekdaysShortRegex = defaultWeekdaysShortRegex;
1600 
+            }
1601 
+            return this._weekdaysShortStrictRegex && isStrict ?
1602 
+                this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
1603 
+        }
1604 
+    }
1605 
+
1606 
+    var defaultWeekdaysMinRegex = matchWord;
1607 
+    function weekdaysMinRegex (isStrict) {
1608 
+        if (this._weekdaysParseExact) {
1609 
+            if (!hasOwnProp(this, '_weekdaysRegex')) {
1610 
+                computeWeekdaysParse.call(this);
1611 
+            }
1612 
+            if (isStrict) {
1613 
+                return this._weekdaysMinStrictRegex;
1614 
+            } else {
1615 
+                return this._weekdaysMinRegex;
1616 
+            }
1617 
+        } else {
1618 
+            if (!hasOwnProp(this, '_weekdaysMinRegex')) {
1619 
+                this._weekdaysMinRegex = defaultWeekdaysMinRegex;
1620 
+            }
1621 
+            return this._weekdaysMinStrictRegex && isStrict ?
1622 
+                this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
1623 
+        }
1624 
+    }
1625 
+
1626 
+
1627 
+    function computeWeekdaysParse () {
1628 
+        function cmpLenRev(a, b) {
1629 
+            return b.length - a.length;
1630 
+        }
1631 
+
1632 
+        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
1633 
+            i, mom, minp, shortp, longp;
1634 
+        for (i = 0; i < 7; i++) {
1635 
+            // make the regex if we don't have it already
1636 
+            mom = createUTC([2000, 1]).day(i);
1637 
+            minp = this.weekdaysMin(mom, '');
1638 
+            shortp = this.weekdaysShort(mom, '');
1639 
+            longp = this.weekdays(mom, '');
1640 
+            minPieces.push(minp);
1641 
+            shortPieces.push(shortp);
1642 
+            longPieces.push(longp);
1643 
+            mixedPieces.push(minp);
1644 
+            mixedPieces.push(shortp);
1645 
+            mixedPieces.push(longp);
1646 
+        }
1647 
+        // Sorting makes sure if one weekday (or abbr) is a prefix of another it
1648 
+        // will match the longer piece.
1649 
+        minPieces.sort(cmpLenRev);
1650 
+        shortPieces.sort(cmpLenRev);
1651 
+        longPieces.sort(cmpLenRev);
1652 
+        mixedPieces.sort(cmpLenRev);
1653 
+        for (i = 0; i < 7; i++) {
1654 
+            shortPieces[i] = regexEscape(shortPieces[i]);
1655 
+            longPieces[i] = regexEscape(longPieces[i]);
1656 
+            mixedPieces[i] = regexEscape(mixedPieces[i]);
1657 
+        }
1658 
+
1659 
+        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
1660 
+        this._weekdaysShortRegex = this._weekdaysRegex;
1661 
+        this._weekdaysMinRegex = this._weekdaysRegex;
1662 
+
1663 
+        this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
1664 
+        this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
1665 
+        this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
1666 
+    }
1667 
+
1668 
+    // FORMATTING
1669 
+
1670 
+    function hFormat() {
1671 
+        return this.hours() % 12 || 12;
1672 
+    }
1673 
+
1674 
+    function kFormat() {
1675 
+        return this.hours() || 24;
1676 
+    }
1677 
+
1678 
+    addFormatToken('H', ['HH', 2], 0, 'hour');
1679 
+    addFormatToken('h', ['hh', 2], 0, hFormat);
1680 
+    addFormatToken('k', ['kk', 2], 0, kFormat);
1681 
+
1682 
+    addFormatToken('hmm', 0, 0, function () {
1683 
+        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
1684 
+    });
1685 
+
1686 
+    addFormatToken('hmmss', 0, 0, function () {
1687 
+        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
1688 
+            zeroFill(this.seconds(), 2);
1689 
+    });
1690 
+
1691 
+    addFormatToken('Hmm', 0, 0, function () {
1692 
+        return '' + this.hours() + zeroFill(this.minutes(), 2);
1693 
+    });
1694 
+
1695 
+    addFormatToken('Hmmss', 0, 0, function () {
1696 
+        return '' + this.hours() + zeroFill(this.minutes(), 2) +
1697 
+            zeroFill(this.seconds(), 2);
1698 
+    });
1699 
+
1700 
+    function meridiem (token, lowercase) {
1701 
+        addFormatToken(token, 0, 0, function () {
1702 
+            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
1703 
+        });
1704 
+    }
1705 
+
1706 
+    meridiem('a', true);
1707 
+    meridiem('A', false);
1708 
+
1709 
+    // ALIASES
1710 
+
1711 
+    addUnitAlias('hour', 'h');
1712 
+
1713 
+    // PRIORITY
1714 
+    addUnitPriority('hour', 13);
1715 
+
1716 
+    // PARSING
1717 
+
1718 
+    function matchMeridiem (isStrict, locale) {
1719 
+        return locale._meridiemParse;
1720 
+    }
1721 
+
1722 
+    addRegexToken('a',  matchMeridiem);
1723 
+    addRegexToken('A',  matchMeridiem);
1724 
+    addRegexToken('H',  match1to2);
1725 
+    addRegexToken('h',  match1to2);
1726 
+    addRegexToken('k',  match1to2);
1727 
+    addRegexToken('HH', match1to2, match2);
1728 
+    addRegexToken('hh', match1to2, match2);
1729 
+    addRegexToken('kk', match1to2, match2);
1730 
+
1731 
+    addRegexToken('hmm', match3to4);
1732 
+    addRegexToken('hmmss', match5to6);
1733 
+    addRegexToken('Hmm', match3to4);
1734 
+    addRegexToken('Hmmss', match5to6);
1735 
+
1736 
+    addParseToken(['H', 'HH'], HOUR);
1737 
+    addParseToken(['k', 'kk'], function (input, array, config) {
1738 
+        var kInput = toInt(input);
1739 
+        array[HOUR] = kInput === 24 ? 0 : kInput;
1740 
+    });
1741 
+    addParseToken(['a', 'A'], function (input, array, config) {
1742 
+        config._isPm = config._locale.isPM(input);
1743 
+        config._meridiem = input;
1744 
+    });
1745 
+    addParseToken(['h', 'hh'], function (input, array, config) {
1746 
+        array[HOUR] = toInt(input);
1747 
+        getParsingFlags(config).bigHour = true;
1748 
+    });
1749 
+    addParseToken('hmm', function (input, array, config) {
1750 
+        var pos = input.length - 2;
1751 
+        array[HOUR] = toInt(input.substr(0, pos));
1752 
+        array[MINUTE] = toInt(input.substr(pos));
1753 
+        getParsingFlags(config).bigHour = true;
1754 
+    });
1755 
+    addParseToken('hmmss', function (input, array, config) {
1756 
+        var pos1 = input.length - 4;
1757 
+        var pos2 = input.length - 2;
1758 
+        array[HOUR] = toInt(input.substr(0, pos1));
1759 
+        array[MINUTE] = toInt(input.substr(pos1, 2));
1760 
+        array[SECOND] = toInt(input.substr(pos2));
1761 
+        getParsingFlags(config).bigHour = true;
1762 
+    });
1763 
+    addParseToken('Hmm', function (input, array, config) {
1764 
+        var pos = input.length - 2;
1765 
+        array[HOUR] = toInt(input.substr(0, pos));
1766 
+        array[MINUTE] = toInt(input.substr(pos));
1767 
+    });
1768 
+    addParseToken('Hmmss', function (input, array, config) {
1769 
+        var pos1 = input.length - 4;
1770 
+        var pos2 = input.length - 2;
1771 
+        array[HOUR] = toInt(input.substr(0, pos1));
1772 
+        array[MINUTE] = toInt(input.substr(pos1, 2));
1773 
+        array[SECOND] = toInt(input.substr(pos2));
1774 
+    });
1775 
+
1776 
+    // LOCALES
1777 
+
1778 
+    function localeIsPM (input) {
1779 
+        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
1780 
+        // Using charAt should be more compatible.
1781 
+        return ((input + '').toLowerCase().charAt(0) === 'p');
1782 
+    }
1783 
+
1784 
+    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
1785 
+    function localeMeridiem (hours, minutes, isLower) {
1786 
+        if (hours > 11) {
1787 
+            return isLower ? 'pm' : 'PM';
1788 
+        } else {
1789 
+            return isLower ? 'am' : 'AM';
1790 
+        }
1791 
+    }
1792 
+
1793 
+
1794 
+    // MOMENTS
1795 
+
1796 
+    // Setting the hour should keep the time, because the user explicitly
1797 
+    // specified which hour they want. So trying to maintain the same hour (in
1798 
+    // a new timezone) makes sense. Adding/subtracting hours does not follow
1799 
+    // this rule.
1800 
+    var getSetHour = makeGetSet('Hours', true);
1801 
+
1802 
+    var baseConfig = {
1803 
+        calendar: defaultCalendar,
1804 
+        longDateFormat: defaultLongDateFormat,
1805 
+        invalidDate: defaultInvalidDate,
1806 
+        ordinal: defaultOrdinal,
1807 
+        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
1808 
+        relativeTime: defaultRelativeTime,
1809 
+
1810 
+        months: defaultLocaleMonths,
1811 
+        monthsShort: defaultLocaleMonthsShort,
1812 
+
1813 
+        week: defaultLocaleWeek,
1814 
+
1815 
+        weekdays: defaultLocaleWeekdays,
1816 
+        weekdaysMin: defaultLocaleWeekdaysMin,
1817 
+        weekdaysShort: defaultLocaleWeekdaysShort,
1818 
+
1819 
+        meridiemParse: defaultLocaleMeridiemParse
1820 
+    };
1821 
+
1822 
+    // internal storage for locale config files
1823 
+    var locales = {};
1824 
+    var localeFamilies = {};
1825 
+    var globalLocale;
1826 
+
1827 
+    function normalizeLocale(key) {
1828 
+        return key ? key.toLowerCase().replace('_', '-') : key;
1829 
+    }
1830 
+
1831 
+    // pick the locale from the array
1832 
+    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
1833 
+    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
1834 
+    function chooseLocale(names) {
1835 
+        var i = 0, j, next, locale, split;
1836 
+
1837 
+        while (i < names.length) {
1838 
+            split = normalizeLocale(names[i]).split('-');
1839 
+            j = split.length;
1840 
+            next = normalizeLocale(names[i + 1]);
1841 
+            next = next ? next.split('-') : null;
1842 
+            while (j > 0) {
1843 
+                locale = loadLocale(split.slice(0, j).join('-'));
1844 
+                if (locale) {
1845 
+                    return locale;
1846 
+                }
1847 
+                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
1848 
+                    //the next array item is better than a shallower substring of this one
1849 
+                    break;
1850 
+                }
1851 
+                j--;
1852 
+            }
1853 
+            i++;
1854 
+        }
1855 
+        return globalLocale;
1856 
+    }
1857 
+
1858 
+    function loadLocale(name) {
1859 
+        var oldLocale = null;
1860 
+        // TODO: Find a better way to register and load all the locales in Node
1861 
+        if (!locales[name] && (typeof module !== 'undefined') &&
1862 
+                module && module.exports) {
1863 
+            try {
1864 
+                oldLocale = globalLocale._abbr;
1865 
+                var aliasedRequire = require;
1866 
+                aliasedRequire('./locale/' + name);
1867 
+                getSetGlobalLocale(oldLocale);
1868 
+            } catch (e) {}
1869 
+        }
1870 
+        return locales[name];
1871 
+    }
1872 
+
1873 
+    // This function will load locale and then set the global locale.  If
1874 
+    // no arguments are passed in, it will simply return the current global
1875 
+    // locale key.
1876 
+    function getSetGlobalLocale (key, values) {
1877 
+        var data;
1878 
+        if (key) {
1879 
+            if (isUndefined(values)) {
1880 
+                data = getLocale(key);
1881 
+            }
1882 
+            else {
1883 
+                data = defineLocale(key, values);
1884 
+            }
1885 
+
1886 
+            if (data) {
1887 
+                // moment.duration._locale = moment._locale = data;
1888 
+                globalLocale = data;
1889 
+            }
1890 
+            else {
1891 
+                if ((typeof console !==  'undefined') && console.warn) {
1892 
+                    //warn user if arguments are passed but the locale could not be set
1893 
+                    console.warn('Locale ' + key +  ' not found. Did you forget to load it?');
1894 
+                }
1895 
+            }
1896 
+        }
1897 
+
1898 
+        return globalLocale._abbr;
1899 
+    }
1900 
+
1901 
+    function defineLocale (name, config) {
1902 
+        if (config !== null) {
1903 
+            var locale, parentConfig = baseConfig;
1904 
+            config.abbr = name;
1905 
+            if (locales[name] != null) {
1906 
+                deprecateSimple('defineLocaleOverride',
1907 
+                        'use moment.updateLocale(localeName, config) to change ' +
1908 
+                        'an existing locale. moment.defineLocale(localeName, ' +
1909 
+                        'config) should only be used for creating a new locale ' +
1910 
+                        'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
1911 
+                parentConfig = locales[name]._config;
1912 
+            } else if (config.parentLocale != null) {
1913 
+                if (locales[config.parentLocale] != null) {
1914 
+                    parentConfig = locales[config.parentLocale]._config;
1915 
+                } else {
1916 
+                    locale = loadLocale(config.parentLocale);
1917 
+                    if (locale != null) {
1918 
+                        parentConfig = locale._config;
1919 
+                    } else {
1920 
+                        if (!localeFamilies[config.parentLocale]) {
1921 
+                            localeFamilies[config.parentLocale] = [];
1922 
+                        }
1923 
+                        localeFamilies[config.parentLocale].push({
1924 
+                            name: name,
1925 
+                            config: config
1926 
+                        });
1927 
+                        return null;
1928 
+                    }
1929 
+                }
1930 
+            }
1931 
+            locales[name] = new Locale(mergeConfigs(parentConfig, config));
1932 
+
1933 
+            if (localeFamilies[name]) {
1934 
+                localeFamilies[name].forEach(function (x) {
1935 
+                    defineLocale(x.name, x.config);
1936 
+                });
1937 
+            }
1938 
+
1939 
+            // backwards compat for now: also set the locale
1940 
+            // make sure we set the locale AFTER all child locales have been
1941 
+            // created, so we won't end up with the child locale set.
1942 
+            getSetGlobalLocale(name);
1943 
+
1944 
+
1945 
+            return locales[name];
1946 
+        } else {
1947 
+            // useful for testing
1948 
+            delete locales[name];
1949 
+            return null;
1950 
+        }
1951 
+    }
1952 
+
1953 
+    function updateLocale(name, config) {
1954 
+        if (config != null) {
1955 
+            var locale, tmpLocale, parentConfig = baseConfig;
1956 
+            // MERGE
1957 
+            tmpLocale = loadLocale(name);
1958 
+            if (tmpLocale != null) {
1959 
+                parentConfig = tmpLocale._config;
1960 
+            }
1961 
+            config = mergeConfigs(parentConfig, config);
1962 
+            locale = new Locale(config);
1963 
+            locale.parentLocale = locales[name];
1964 
+            locales[name] = locale;
1965 
+
1966 
+            // backwards compat for now: also set the locale
1967 
+            getSetGlobalLocale(name);
1968 
+        } else {
1969 
+            // pass null for config to unupdate, useful for tests
1970 
+            if (locales[name] != null) {
1971 
+                if (locales[name].parentLocale != null) {
1972 
+                    locales[name] = locales[name].parentLocale;
1973 
+                } else if (locales[name] != null) {
1974 
+                    delete locales[name];
1975 
+                }
1976 
+            }
1977 
+        }
1978 
+        return locales[name];
1979 
+    }
1980 
+
1981 
+    // returns locale data
1982 
+    function getLocale (key) {
1983 
+        var locale;
1984 
+
1985 
+        if (key && key._locale && key._locale._abbr) {
1986 
+            key = key._locale._abbr;
1987 
+        }
1988 
+
1989 
+        if (!key) {
1990 
+            return globalLocale;
1991 
+        }
1992 
+
1993 
+        if (!isArray(key)) {
1994 
+            //short-circuit everything else
1995 
+            locale = loadLocale(key);
1996 
+            if (locale) {
1997 
+                return locale;
1998 
+            }
1999 
+            key = [key];
2000 
+        }
2001 
+
2002 
+        return chooseLocale(key);
2003 
+    }
2004 
+
2005 
+    function listLocales() {
2006 
+        return keys(locales);
2007 
+    }
2008 
+
2009 
+    function checkOverflow (m) {
2010 
+        var overflow;
2011 
+        var a = m._a;
2012 
+
2013 
+        if (a && getParsingFlags(m).overflow === -2) {
2014 
+            overflow =
2015 
+                a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
2016 
+                a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
2017 
+                a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
2018 
+                a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
2019 
+                a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
2020 
+                a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
2021 
+                -1;
2022 
+
2023 
+            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
2024 
+                overflow = DATE;
2025 
+            }
2026 
+            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
2027 
+                overflow = WEEK;
2028 
+            }
2029 
+            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
2030 
+                overflow = WEEKDAY;
2031 
+            }
2032 
+
2033 
+            getParsingFlags(m).overflow = overflow;
2034 
+        }
2035 
+
2036 
+        return m;
2037 
+    }
2038 
+
2039 
+    // Pick the first defined of two or three arguments.
2040 
+    function defaults(a, b, c) {
2041 
+        if (a != null) {
2042 
+            return a;
2043 
+        }
2044 
+        if (b != null) {
2045 
+            return b;
2046 
+        }
2047 
+        return c;
2048 
+    }
2049 
+
2050 
+    function currentDateArray(config) {
2051 
+        // hooks is actually the exported moment object
2052 
+        var nowValue = new Date(hooks.now());
2053 
+        if (config._useUTC) {
2054 
+            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
2055 
+        }
2056 
+        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
2057 
+    }
2058 
+
2059 
+    // convert an array to a date.
2060 
+    // the array should mirror the parameters below
2061 
+    // note: all values past the year are optional and will default to the lowest possible value.
2062 
+    // [year, month, day , hour, minute, second, millisecond]
2063 
+    function configFromArray (config) {
2064 
+        var i, date, input = [], currentDate, expectedWeekday, yearToUse;
2065 
+
2066 
+        if (config._d) {
2067 
+            return;
2068 
+        }
2069 
+
2070 
+        currentDate = currentDateArray(config);
2071 
+
2072 
+        //compute day of the year from weeks and weekdays
2073 
+        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
2074 
+            dayOfYearFromWeekInfo(config);
2075 
+        }
2076 
+
2077 
+        //if the day of the year is set, figure out what it is
2078 
+        if (config._dayOfYear != null) {
2079 
+            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
2080 
+
2081 
+            if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
2082 
+                getParsingFlags(config)._overflowDayOfYear = true;
2083 
+            }
2084 
+
2085 
+            date = createUTCDate(yearToUse, 0, config._dayOfYear);
2086 
+            config._a[MONTH] = date.getUTCMonth();
2087 
+            config._a[DATE] = date.getUTCDate();
2088 
+        }
2089 
+
2090 
+        // Default to current date.
2091 
+        // * if no year, month, day of month are given, default to today
2092 
+        // * if day of month is given, default month and year
2093 
+        // * if month is given, default only year
2094 
+        // * if year is given, don't default anything
2095 
+        for (i = 0; i < 3 && config._a[i] == null; ++i) {
2096 
+            config._a[i] = input[i] = currentDate[i];
2097 
+        }
2098 
+
2099 
+        // Zero out whatever was not defaulted, including time
2100 
+        for (; i < 7; i++) {
2101 
+            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
2102 
+        }
2103 
+
2104 
+        // Check for 24:00:00.000
2105 
+        if (config._a[HOUR] === 24 &&
2106 
+                config._a[MINUTE] === 0 &&
2107 
+                config._a[SECOND] === 0 &&
2108 
+                config._a[MILLISECOND] === 0) {
2109 
+            config._nextDay = true;
2110 
+            config._a[HOUR] = 0;
2111 
+        }
2112 
+
2113 
+        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
2114 
+        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
2115 
+
2116 
+        // Apply timezone offset from input. The actual utcOffset can be changed
2117 
+        // with parseZone.
2118 
+        if (config._tzm != null) {
2119 
+            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2120 
+        }
2121 
+
2122 
+        if (config._nextDay) {
2123 
+            config._a[HOUR] = 24;
2124 
+        }
2125 
+
2126 
+        // check for mismatching day of week
2127 
+        if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
2128 
+            getParsingFlags(config).weekdayMismatch = true;
2129 
+        }
2130 
+    }
2131 
+
2132 
+    function dayOfYearFromWeekInfo(config) {
2133 
+        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
2134 
+
2135 
+        w = config._w;
2136 
+        if (w.GG != null || w.W != null || w.E != null) {
2137 
+            dow = 1;
2138 
+            doy = 4;
2139 
+
2140 
+            // TODO: We need to take the current isoWeekYear, but that depends on
2141 
+            // how we interpret now (local, utc, fixed offset). So create
2142 
+            // a now version of current config (take local/utc/offset flags, and
2143 
+            // create now).
2144 
+            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
2145 
+            week = defaults(w.W, 1);
2146 
+            weekday = defaults(w.E, 1);
2147 
+            if (weekday < 1 || weekday > 7) {
2148 
+                weekdayOverflow = true;
2149 
+            }
2150 
+        } else {
2151 
+            dow = config._locale._week.dow;
2152 
+            doy = config._locale._week.doy;
2153 
+
2154 
+            var curWeek = weekOfYear(createLocal(), dow, doy);
2155 
+
2156 
+            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
2157 
+
2158 
+            // Default to current week.
2159 
+            week = defaults(w.w, curWeek.week);
2160 
+
2161 
+            if (w.d != null) {
2162 
+                // weekday -- low day numbers are considered next week
2163 
+                weekday = w.d;
2164 
+                if (weekday < 0 || weekday > 6) {
2165 
+                    weekdayOverflow = true;
2166 
+                }
2167 
+            } else if (w.e != null) {
2168 
+                // local weekday -- counting starts from beginning of week
2169 
+                weekday = w.e + dow;
2170 
+                if (w.e < 0 || w.e > 6) {
2171 
+                    weekdayOverflow = true;
2172 
+                }
2173 
+            } else {
2174 
+                // default to beginning of week
2175 
+                weekday = dow;
2176 
+            }
2177 
+        }
2178 
+        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
2179 
+            getParsingFlags(config)._overflowWeeks = true;
2180 
+        } else if (weekdayOverflow != null) {
2181 
+            getParsingFlags(config)._overflowWeekday = true;
2182 
+        } else {
2183 
+            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
2184 
+            config._a[YEAR] = temp.year;
2185 
+            config._dayOfYear = temp.dayOfYear;
2186 
+        }
2187 
+    }
2188 
+
2189 
+    // iso 8601 regex
2190 
+    // 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)
2191 
+    var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
2192 
+    var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
2193 
+
2194 
+    var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
2195 
+
2196 
+    var isoDates = [
2197 
+        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
2198 
+        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
2199 
+        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
2200 
+        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
2201 
+        ['YYYY-DDD', /\d{4}-\d{3}/],
2202 
+        ['YYYY-MM', /\d{4}-\d\d/, false],
2203 
+        ['YYYYYYMMDD', /[+-]\d{10}/],
2204 
+        ['YYYYMMDD', /\d{8}/],
2205 
+        // YYYYMM is NOT allowed by the standard
2206 
+        ['GGGG[W]WWE', /\d{4}W\d{3}/],
2207 
+        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
2208 
+        ['YYYYDDD', /\d{7}/]
2209 
+    ];
2210 
+
2211 
+    // iso time formats and regexes
2212 
+    var isoTimes = [
2213 
+        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
2214 
+        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
2215 
+        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
2216 
+        ['HH:mm', /\d\d:\d\d/],
2217 
+        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
2218 
+        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
2219 
+        ['HHmmss', /\d\d\d\d\d\d/],
2220 
+        ['HHmm', /\d\d\d\d/],
2221 
+        ['HH', /\d\d/]
2222 
+    ];
2223 
+
2224 
+    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
2225 
+
2226 
+    // date from iso format
2227 
+    function configFromISO(config) {
2228 
+        var i, l,
2229 
+            string = config._i,
2230 
+            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
2231 
+            allowTime, dateFormat, timeFormat, tzFormat;
2232 
+
2233 
+        if (match) {
2234 
+            getParsingFlags(config).iso = true;
2235 
+
2236 
+            for (i = 0, l = isoDates.length; i < l; i++) {
2237 
+                if (isoDates[i][1].exec(match[1])) {
2238 
+                    dateFormat = isoDates[i][0];
2239 
+                    allowTime = isoDates[i][2] !== false;
2240 
+                    break;
2241 
+                }
2242 
+            }
2243 
+            if (dateFormat == null) {
2244 
+                config._isValid = false;
2245 
+                return;
2246 
+            }
2247 
+            if (match[3]) {
2248 
+                for (i = 0, l = isoTimes.length; i < l; i++) {
2249 
+                    if (isoTimes[i][1].exec(match[3])) {
2250 
+                        // match[2] should be 'T' or space
2251 
+                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
2252 
+                        break;
2253 
+                    }
2254 
+                }
2255 
+                if (timeFormat == null) {
2256 
+                    config._isValid = false;
2257 
+                    return;
2258 
+                }
2259 
+            }
2260 
+            if (!allowTime && timeFormat != null) {
2261 
+                config._isValid = false;
2262 
+                return;
2263 
+            }
2264 
+            if (match[4]) {
2265 
+                if (tzRegex.exec(match[4])) {
2266 
+                    tzFormat = 'Z';
2267 
+                } else {
2268 
+                    config._isValid = false;
2269 
+                    return;
2270 
+                }
2271 
+            }
2272 
+            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
2273 
+            configFromStringAndFormat(config);
2274 
+        } else {
2275 
+            config._isValid = false;
2276 
+        }
2277 
+    }
2278 
+
2279 
+    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
2280 
+    var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;
2281 
+
2282 
+    function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
2283 
+        var result = [
2284 
+            untruncateYear(yearStr),
2285 
+            defaultLocaleMonthsShort.indexOf(monthStr),
2286 
+            parseInt(dayStr, 10),
2287 
+            parseInt(hourStr, 10),
2288 
+            parseInt(minuteStr, 10)
2289 
+        ];
2290 
+
2291 
+        if (secondStr) {
2292 
+            result.push(parseInt(secondStr, 10));
2293 
+        }
2294 
+
2295 
+        return result;
2296 
+    }
2297 
+
2298 
+    function untruncateYear(yearStr) {
2299 
+        var year = parseInt(yearStr, 10);
2300 
+        if (year <= 49) {
2301 
+            return 2000 + year;
2302 
+        } else if (year <= 999) {
2303 
+            return 1900 + year;
2304 
+        }
2305 
+        return year;
2306 
+    }
2307 
+
2308 
+    function preprocessRFC2822(s) {
2309 
+        // Remove comments and folding whitespace and replace multiple-spaces with a single space
2310 
+        return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, '');
2311 
+    }
2312 
+
2313 
+    function checkWeekday(weekdayStr, parsedInput, config) {
2314 
+        if (weekdayStr) {
2315 
+            // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
2316 
+            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
2317 
+                weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
2318 
+            if (weekdayProvided !== weekdayActual) {
2319 
+                getParsingFlags(config).weekdayMismatch = true;
2320 
+                config._isValid = false;
2321 
+                return false;
2322 
+            }
2323 
+        }
2324 
+        return true;
2325 
+    }
2326 
+
2327 
+    var obsOffsets = {
2328 
+        UT: 0,
2329 
+        GMT: 0,
2330 
+        EDT: -4 * 60,
2331 
+        EST: -5 * 60,
2332 
+        CDT: -5 * 60,
2333 
+        CST: -6 * 60,
2334 
+        MDT: -6 * 60,
2335 
+        MST: -7 * 60,
2336 
+        PDT: -7 * 60,
2337 
+        PST: -8 * 60
2338 
+    };
2339 
+
2340 
+    function calculateOffset(obsOffset, militaryOffset, numOffset) {
2341 
+        if (obsOffset) {
2342 
+            return obsOffsets[obsOffset];
2343 
+        } else if (militaryOffset) {
2344 
+            // the only allowed military tz is Z
2345 
+            return 0;
2346 
+        } else {
2347 
+            var hm = parseInt(numOffset, 10);
2348 
+            var m = hm % 100, h = (hm - m) / 100;
2349 
+            return h * 60 + m;
2350 
+        }
2351 
+    }
2352 
+
2353 
+    // date and time from ref 2822 format
2354 
+    function configFromRFC2822(config) {
2355 
+        var match = rfc2822.exec(preprocessRFC2822(config._i));
2356 
+        if (match) {
2357 
+            var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
2358 
+            if (!checkWeekday(match[1], parsedArray, config)) {
2359 
+                return;
2360 
+            }
2361 
+
2362 
+            config._a = parsedArray;
2363 
+            config._tzm = calculateOffset(match[8], match[9], match[10]);
2364 
+
2365 
+            config._d = createUTCDate.apply(null, config._a);
2366 
+            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
2367 
+
2368 
+            getParsingFlags(config).rfc2822 = true;
2369 
+        } else {
2370 
+            config._isValid = false;
2371 
+        }
2372 
+    }
2373 
+
2374 
+    // date from iso format or fallback
2375 
+    function configFromString(config) {
2376 
+        var matched = aspNetJsonRegex.exec(config._i);
2377 
+
2378 
+        if (matched !== null) {
2379 
+            config._d = new Date(+matched[1]);
2380 
+            return;
2381 
+        }
2382 
+
2383 
+        configFromISO(config);
2384 
+        if (config._isValid === false) {
2385 
+            delete config._isValid;
2386 
+        } else {
2387 
+            return;
2388 
+        }
2389 
+
2390 
+        configFromRFC2822(config);
2391 
+        if (config._isValid === false) {
2392 
+            delete config._isValid;
2393 
+        } else {
2394 
+            return;
2395 
+        }
2396 
+
2397 
+        // Final attempt, use Input Fallback
2398 
+        hooks.createFromInputFallback(config);
2399 
+    }
2400 
+
2401 
+    hooks.createFromInputFallback = deprecate(
2402 
+        'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
2403 
+        'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
2404 
+        'discouraged and will be removed in an upcoming major release. Please refer to ' +
2405 
+        'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
2406 
+        function (config) {
2407 
+            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
2408 
+        }
2409 
+    );
2410 
+
2411 
+    // constant that refers to the ISO standard
2412 
+    hooks.ISO_8601 = function () {};
2413 
+
2414 
+    // constant that refers to the RFC 2822 form
2415 
+    hooks.RFC_2822 = function () {};
2416 
+
2417 
+    // date from string and format string
2418 
+    function configFromStringAndFormat(config) {
2419 
+        // TODO: Move this to another part of the creation flow to prevent circular deps
2420 
+        if (config._f === hooks.ISO_8601) {
2421 
+            configFromISO(config);
2422 
+            return;
2423 
+        }
2424 
+        if (config._f === hooks.RFC_2822) {
2425 
+            configFromRFC2822(config);
2426 
+            return;
2427 
+        }
2428 
+        config._a = [];
2429 
+        getParsingFlags(config).empty = true;
2430 
+
2431 
+        // This array is used to make a Date, either with `new Date` or `Date.UTC`
2432 
+        var string = '' + config._i,
2433 
+            i, parsedInput, tokens, token, skipped,
2434 
+            stringLength = string.length,
2435 
+            totalParsedInputLength = 0;
2436 
+
2437 
+        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
2438 
+
2439 
+        for (i = 0; i < tokens.length; i++) {
2440 
+            token = tokens[i];
2441 
+            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
2442 
+            // console.log('token', token, 'parsedInput', parsedInput,
2443 
+            //         'regex', getParseRegexForToken(token, config));
2444 
+            if (parsedInput) {
2445 
+                skipped = string.substr(0, string.indexOf(parsedInput));
2446 
+                if (skipped.length > 0) {
2447 
+                    getParsingFlags(config).unusedInput.push(skipped);
2448 
+                }
2449 
+                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
2450 
+                totalParsedInputLength += parsedInput.length;
2451 
+            }
2452 
+            // don't parse if it's not a known token
2453 
+            if (formatTokenFunctions[token]) {
2454 
+                if (parsedInput) {
2455 
+                    getParsingFlags(config).empty = false;
2456 
+                }
2457 
+                else {
2458 
+                    getParsingFlags(config).unusedTokens.push(token);
2459 
+                }
2460 
+                addTimeToArrayFromToken(token, parsedInput, config);
2461 
+            }
2462 
+            else if (config._strict && !parsedInput) {
2463 
+                getParsingFlags(config).unusedTokens.push(token);
2464 
+            }
2465 
+        }
2466 
+
2467 
+        // add remaining unparsed input length to the string
2468 
+        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
2469 
+        if (string.length > 0) {
2470 
+            getParsingFlags(config).unusedInput.push(string);
2471 
+        }
2472 
+
2473 
+        // clear _12h flag if hour is <= 12
2474 
+        if (config._a[HOUR] <= 12 &&
2475 
+            getParsingFlags(config).bigHour === true &&
2476 
+            config._a[HOUR] > 0) {
2477 
+            getParsingFlags(config).bigHour = undefined;
2478 
+        }
2479 
+
2480 
+        getParsingFlags(config).parsedDateParts = config._a.slice(0);
2481 
+        getParsingFlags(config).meridiem = config._meridiem;
2482 
+        // handle meridiem
2483 
+        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
2484 
+
2485 
+        configFromArray(config);
2486 
+        checkOverflow(config);
2487 
+    }
2488 
+
2489 
+
2490 
+    function meridiemFixWrap (locale, hour, meridiem) {
2491 
+        var isPm;
2492 
+
2493 
+        if (meridiem == null) {
2494 
+            // nothing to do
2495 
+            return hour;
2496 
+        }
2497 
+        if (locale.meridiemHour != null) {
2498 
+            return locale.meridiemHour(hour, meridiem);
2499 
+        } else if (locale.isPM != null) {
2500 
+            // Fallback
2501 
+            isPm = locale.isPM(meridiem);
2502 
+            if (isPm && hour < 12) {
2503 
+                hour += 12;
2504 
+            }
2505 
+            if (!isPm && hour === 12) {
2506 
+                hour = 0;
2507 
+            }
2508 
+            return hour;
2509 
+        } else {
2510 
+            // this is not supposed to happen
2511 
+            return hour;
2512 
+        }
2513 
+    }
2514 
+
2515 
+    // date from string and array of format strings
2516 
+    function configFromStringAndArray(config) {
2517 
+        var tempConfig,
2518 
+            bestMoment,
2519 
+
2520 
+            scoreToBeat,
2521 
+            i,
2522 
+            currentScore;
2523 
+
2524 
+        if (config._f.length === 0) {
2525 
+            getParsingFlags(config).invalidFormat = true;
2526 
+            config._d = new Date(NaN);
2527 
+            return;
2528 
+        }
2529 
+
2530 
+        for (i = 0; i < config._f.length; i++) {
2531 
+            currentScore = 0;
2532 
+            tempConfig = copyConfig({}, config);
2533 
+            if (config._useUTC != null) {
2534 
+                tempConfig._useUTC = config._useUTC;
2535 
+            }
2536 
+            tempConfig._f = config._f[i];
2537 
+            configFromStringAndFormat(tempConfig);
2538 
+
2539 
+            if (!isValid(tempConfig)) {
2540 
+                continue;
2541 
+            }
2542 
+
2543 
+            // if there is any input that was not parsed add a penalty for that format
2544 
+            currentScore += getParsingFlags(tempConfig).charsLeftOver;
2545 
+
2546 
+            //or tokens
2547 
+            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
2548 
+
2549 
+            getParsingFlags(tempConfig).score = currentScore;
2550 
+
2551 
+            if (scoreToBeat == null || currentScore < scoreToBeat) {
2552 
+                scoreToBeat = currentScore;
2553 
+                bestMoment = tempConfig;
2554 
+            }
2555 
+        }
2556 
+
2557 
+        extend(config, bestMoment || tempConfig);
2558 
+    }
2559 
+
2560 
+    function configFromObject(config) {
2561 
+        if (config._d) {
2562 
+            return;
2563 
+        }
2564 
+
2565 
+        var i = normalizeObjectUnits(config._i);
2566 
+        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
2567 
+            return obj && parseInt(obj, 10);
2568 
+        });
2569 
+
2570 
+        configFromArray(config);
2571 
+    }
2572 
+
2573 
+    function createFromConfig (config) {
2574 
+        var res = new Moment(checkOverflow(prepareConfig(config)));
2575 
+        if (res._nextDay) {
2576 
+            // Adding is smart enough around DST
2577 
+            res.add(1, 'd');
2578 
+            res._nextDay = undefined;
2579 
+        }
2580 
+
2581 
+        return res;
2582 
+    }
2583 
+
2584 
+    function prepareConfig (config) {
2585 
+        var input = config._i,
2586 
+            format = config._f;
2587 
+
2588 
+        config._locale = config._locale || getLocale(config._l);
2589 
+
2590 
+        if (input === null || (format === undefined && input === '')) {
2591 
+            return createInvalid({nullInput: true});
2592 
+        }
2593 
+
2594 
+        if (typeof input === 'string') {
2595 
+            config._i = input = config._locale.preparse(input);
2596 
+        }
2597 
+
2598 
+        if (isMoment(input)) {
2599 
+            return new Moment(checkOverflow(input));
2600 
+        } else if (isDate(input)) {
2601 
+            config._d = input;
2602 
+        } else if (isArray(format)) {
2603 
+            configFromStringAndArray(config);
2604 
+        } else if (format) {
2605 
+            configFromStringAndFormat(config);
2606 
+        }  else {
2607 
+            configFromInput(config);
2608 
+        }
2609 
+
2610 
+        if (!isValid(config)) {
2611 
+            config._d = null;
2612 
+        }
2613 
+
2614 
+        return config;
2615 
+    }
2616 
+
2617 
+    function configFromInput(config) {
2618 
+        var input = config._i;
2619 
+        if (isUndefined(input)) {
2620 
+            config._d = new Date(hooks.now());
2621 
+        } else if (isDate(input)) {
2622 
+            config._d = new Date(input.valueOf());
2623 
+        } else if (typeof input === 'string') {
2624 
+            configFromString(config);
2625 
+        } else if (isArray(input)) {
2626 
+            config._a = map(input.slice(0), function (obj) {
2627 
+                return parseInt(obj, 10);
2628 
+            });
2629 
+            configFromArray(config);
2630 
+        } else if (isObject(input)) {
2631 
+            configFromObject(config);
2632 
+        } else if (isNumber(input)) {
2633 
+            // from milliseconds
2634 
+            config._d = new Date(input);
2635 
+        } else {
2636 
+            hooks.createFromInputFallback(config);
2637 
+        }
2638 
+    }
2639 
+
2640 
+    function createLocalOrUTC (input, format, locale, strict, isUTC) {
2641 
+        var c = {};
2642 
+
2643 
+        if (locale === true || locale === false) {
2644 
+            strict = locale;
2645 
+            locale = undefined;
2646 
+        }
2647 
+
2648 
+        if ((isObject(input) && isObjectEmpty(input)) ||
2649 
+                (isArray(input) && input.length === 0)) {
2650 
+            input = undefined;
2651 
+        }
2652 
+        // object construction must be done this way.
2653 
+        // https://github.com/moment/moment/issues/1423
2654 
+        c._isAMomentObject = true;
2655 
+        c._useUTC = c._isUTC = isUTC;
2656 
+        c._l = locale;
2657 
+        c._i = input;
2658 
+        c._f = format;
2659 
+        c._strict = strict;
2660 
+
2661 
+        return createFromConfig(c);
2662 
+    }
2663 
+
2664 
+    function createLocal (input, format, locale, strict) {
2665 
+        return createLocalOrUTC(input, format, locale, strict, false);
2666 
+    }
2667 
+
2668 
+    var prototypeMin = deprecate(
2669 
+        'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
2670 
+        function () {
2671 
+            var other = createLocal.apply(null, arguments);
2672 
+            if (this.isValid() && other.isValid()) {
2673 
+                return other < this ? this : other;
2674 
+            } else {
2675 
+                return createInvalid();
2676 
+            }
2677 
+        }
2678 
+    );
2679 
+
2680 
+    var prototypeMax = deprecate(
2681 
+        'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
2682 
+        function () {
2683 
+            var other = createLocal.apply(null, arguments);
2684 
+            if (this.isValid() && other.isValid()) {
2685 
+                return other > this ? this : other;
2686 
+            } else {
2687 
+                return createInvalid();
2688 
+            }
2689 
+        }
2690 
+    );
2691 
+
2692 
+    // Pick a moment m from moments so that m[fn](other) is true for all
2693 
+    // other. This relies on the function fn to be transitive.
2694 
+    //
2695 
+    // moments should either be an array of moment objects or an array, whose
2696 
+    // first element is an array of moment objects.
2697 
+    function pickBy(fn, moments) {
2698 
+        var res, i;
2699 
+        if (moments.length === 1 && isArray(moments[0])) {
2700 
+            moments = moments[0];
2701 
+        }
2702 
+        if (!moments.length) {
2703 
+            return createLocal();
2704 
+        }
2705 
+        res = moments[0];
2706 
+        for (i = 1; i < moments.length; ++i) {
2707 
+            if (!moments[i].isValid() || moments[i][fn](res)) {
2708 
+                res = moments[i];
2709 
+            }
2710 
+        }
2711 
+        return res;
2712 
+    }
2713 
+
2714 
+    // TODO: Use [].sort instead?
2715 
+    function min () {
2716 
+        var args = [].slice.call(arguments, 0);
2717 
+
2718 
+        return pickBy('isBefore', args);
2719 
+    }
2720 
+
2721 
+    function max () {
2722 
+        var args = [].slice.call(arguments, 0);
2723 
+
2724 
+        return pickBy('isAfter', args);
2725 
+    }
2726 
+
2727 
+    var now = function () {
2728 
+        return Date.now ? Date.now() : +(new Date());
2729 
+    };
2730 
+
2731 
+    var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
2732 
+
2733 
+    function isDurationValid(m) {
2734 
+        for (var key in m) {
2735 
+            if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
2736 
+                return false;
2737 
+            }
2738 
+        }
2739 
+
2740 
+        var unitHasDecimal = false;
2741 
+        for (var i = 0; i < ordering.length; ++i) {
2742 
+            if (m[ordering[i]]) {
2743 
+                if (unitHasDecimal) {
2744 
+                    return false; // only allow non-integers for smallest unit
2745 
+                }
2746 
+                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
2747 
+                    unitHasDecimal = true;
2748 
+                }
2749 
+            }
2750 
+        }
2751 
+
2752 
+        return true;
2753 
+    }
2754 
+
2755 
+    function isValid$1() {
2756 
+        return this._isValid;
2757 
+    }
2758 
+
2759 
+    function createInvalid$1() {
2760 
+        return createDuration(NaN);
2761 
+    }
2762 
+
2763 
+    function Duration (duration) {
2764 
+        var normalizedInput = normalizeObjectUnits(duration),
2765 
+            years = normalizedInput.year || 0,
2766 
+            quarters = normalizedInput.quarter || 0,
2767 
+            months = normalizedInput.month || 0,
2768 
+            weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
2769 
+            days = normalizedInput.day || 0,
2770 
+            hours = normalizedInput.hour || 0,
2771 
+            minutes = normalizedInput.minute || 0,
2772 
+            seconds = normalizedInput.second || 0,
2773 
+            milliseconds = normalizedInput.millisecond || 0;
2774 
+
2775 
+        this._isValid = isDurationValid(normalizedInput);
2776 
+
2777 
+        // representation for dateAddRemove
2778 
+        this._milliseconds = +milliseconds +
2779 
+            seconds * 1e3 + // 1000
2780 
+            minutes * 6e4 + // 1000 * 60
2781 
+            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
2782 
+        // Because of dateAddRemove treats 24 hours as different from a
2783 
+        // day when working around DST, we need to store them separately
2784 
+        this._days = +days +
2785 
+            weeks * 7;
2786 
+        // It is impossible to translate months into days without knowing
2787 
+        // which months you are are talking about, so we have to store
2788 
+        // it separately.
2789 
+        this._months = +months +
2790 
+            quarters * 3 +
2791 
+            years * 12;
2792 
+
2793 
+        this._data = {};
2794 
+
2795 
+        this._locale = getLocale();
2796 
+
2797 
+        this._bubble();
2798 
+    }
2799 
+
2800 
+    function isDuration (obj) {
2801 
+        return obj instanceof Duration;
2802 
+    }
2803 
+
2804 
+    function absRound (number) {
2805 
+        if (number < 0) {
2806 
+            return Math.round(-1 * number) * -1;
2807 
+        } else {
2808 
+            return Math.round(number);
2809 
+        }
2810 
+    }
2811 
+
2812 
+    // FORMATTING
2813 
+
2814 
+    function offset (token, separator) {
2815 
+        addFormatToken(token, 0, 0, function () {
2816 
+            var offset = this.utcOffset();
2817 
+            var sign = '+';
2818 
+            if (offset < 0) {
2819 
+                offset = -offset;
2820 
+                sign = '-';
2821 
+            }
2822 
+            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
2823 
+        });
2824 
+    }
2825 
+
2826 
+    offset('Z', ':');
2827 
+    offset('ZZ', '');
2828 
+
2829 
+    // PARSING
2830 
+
2831 
+    addRegexToken('Z',  matchShortOffset);
2832 
+    addRegexToken('ZZ', matchShortOffset);
2833 
+    addParseToken(['Z', 'ZZ'], function (input, array, config) {
2834 
+        config._useUTC = true;
2835 
+        config._tzm = offsetFromString(matchShortOffset, input);
2836 
+    });
2837 
+
2838 
+    // HELPERS
2839 
+
2840 
+    // timezone chunker
2841 
+    // '+10:00' > ['10',  '00']
2842 
+    // '-1530'  > ['-15', '30']
2843 
+    var chunkOffset = /([\+\-]|\d\d)/gi;
2844 
+
2845 
+    function offsetFromString(matcher, string) {
2846 
+        var matches = (string || '').match(matcher);
2847 
+
2848 
+        if (matches === null) {
2849 
+            return null;
2850 
+        }
2851 
+
2852 
+        var chunk   = matches[matches.length - 1] || [];
2853 
+        var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
2854 
+        var minutes = +(parts[1] * 60) + toInt(parts[2]);
2855 
+
2856 
+        return minutes === 0 ?
2857 
+          0 :
2858 
+          parts[0] === '+' ? minutes : -minutes;
2859 
+    }
2860 
+
2861 
+    // Return a moment from input, that is local/utc/zone equivalent to model.
2862 
+    function cloneWithOffset(input, model) {
2863 
+        var res, diff;
2864 
+        if (model._isUTC) {
2865 
+            res = model.clone();
2866 
+            diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
2867 
+            // Use low-level api, because this fn is low-level api.
2868 
+            res._d.setTime(res._d.valueOf() + diff);
2869 
+            hooks.updateOffset(res, false);
2870 
+            return res;
2871 
+        } else {
2872 
+            return createLocal(input).local();
2873 
+        }
2874 
+    }
2875 
+
2876 
+    function getDateOffset (m) {
2877 
+        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
2878 
+        // https://github.com/moment/moment/pull/1871
2879 
+        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
2880 
+    }
2881 
+
2882 
+    // HOOKS
2883 
+
2884 
+    // This function will be called whenever a moment is mutated.
2885 
+    // It is intended to keep the offset in sync with the timezone.
2886 
+    hooks.updateOffset = function () {};
2887 
+
2888 
+    // MOMENTS
2889 
+
2890 
+    // keepLocalTime = true means only change the timezone, without
2891 
+    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
2892 
+    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
2893 
+    // +0200, so we adjust the time as needed, to be valid.
2894 
+    //
2895 
+    // Keeping the time actually adds/subtracts (one hour)
2896 
+    // from the actual represented time. That is why we call updateOffset
2897 
+    // a second time. In case it wants us to change the offset again
2898 
+    // _changeInProgress == true case, then we have to adjust, because
2899 
+    // there is no such time in the given timezone.
2900 
+    function getSetOffset (input, keepLocalTime, keepMinutes) {
2901 
+        var offset = this._offset || 0,
2902 
+            localAdjust;
2903 
+        if (!this.isValid()) {
2904 
+            return input != null ? this : NaN;
2905 
+        }
2906 
+        if (input != null) {
2907 
+            if (typeof input === 'string') {
2908 
+                input = offsetFromString(matchShortOffset, input);
2909 
+                if (input === null) {
2910 
+                    return this;
2911 
+                }
2912 
+            } else if (Math.abs(input) < 16 && !keepMinutes) {
2913 
+                input = input * 60;
2914 
+            }
2915 
+            if (!this._isUTC && keepLocalTime) {
2916 
+                localAdjust = getDateOffset(this);
2917 
+            }
2918 
+            this._offset = input;
2919 
+            this._isUTC = true;
2920 
+            if (localAdjust != null) {
2921 
+                this.add(localAdjust, 'm');
2922 
+            }
2923 
+            if (offset !== input) {
2924 
+                if (!keepLocalTime || this._changeInProgress) {
2925 
+                    addSubtract(this, createDuration(input - offset, 'm'), 1, false);
2926 
+                } else if (!this._changeInProgress) {
2927 
+                    this._changeInProgress = true;
2928 
+                    hooks.updateOffset(this, true);
2929 
+                    this._changeInProgress = null;
2930 
+                }
2931 
+            }
2932 
+            return this;
2933 
+        } else {
2934 
+            return this._isUTC ? offset : getDateOffset(this);
2935 
+        }
2936 
+    }
2937 
+
2938 
+    function getSetZone (input, keepLocalTime) {
2939 
+        if (input != null) {
2940 
+            if (typeof input !== 'string') {
2941 
+                input = -input;
2942 
+            }
2943 
+
2944 
+            this.utcOffset(input, keepLocalTime);
2945 
+
2946 
+            return this;
2947 
+        } else {
2948 
+            return -this.utcOffset();
2949 
+        }
2950 
+    }
2951 
+
2952 
+    function setOffsetToUTC (keepLocalTime) {
2953 
+        return this.utcOffset(0, keepLocalTime);
2954 
+    }
2955 
+
2956 
+    function setOffsetToLocal (keepLocalTime) {
2957 
+        if (this._isUTC) {
2958 
+            this.utcOffset(0, keepLocalTime);
2959 
+            this._isUTC = false;
2960 
+
2961 
+            if (keepLocalTime) {
2962 
+                this.subtract(getDateOffset(this), 'm');
2963 
+            }
2964 
+        }
2965 
+        return this;
2966 
+    }
2967 
+
2968 
+    function setOffsetToParsedOffset () {
2969 
+        if (this._tzm != null) {
2970 
+            this.utcOffset(this._tzm, false, true);
2971 
+        } else if (typeof this._i === 'string') {
2972 
+            var tZone = offsetFromString(matchOffset, this._i);
2973 
+            if (tZone != null) {
2974 
+                this.utcOffset(tZone);
2975 
+            }
2976 
+            else {
2977 
+                this.utcOffset(0, true);
2978 
+            }
2979 
+        }
2980 
+        return this;
2981 
+    }
2982 
+
2983 
+    function hasAlignedHourOffset (input) {
2984 
+        if (!this.isValid()) {
2985 
+            return false;
2986 
+        }
2987 
+        input = input ? createLocal(input).utcOffset() : 0;
2988 
+
2989 
+        return (this.utcOffset() - input) % 60 === 0;
2990 
+    }
2991 
+
2992 
+    function isDaylightSavingTime () {
2993 
+        return (
2994 
+            this.utcOffset() > this.clone().month(0).utcOffset() ||
2995 
+            this.utcOffset() > this.clone().month(5).utcOffset()
2996 
+        );
2997 
+    }
2998 
+
2999 
+    function isDaylightSavingTimeShifted () {
3000 
+        if (!isUndefined(this._isDSTShifted)) {
3001 
+            return this._isDSTShifted;
3002 
+        }
3003 
+
3004 
+        var c = {};
3005 
+
3006 
+        copyConfig(c, this);
3007 
+        c = prepareConfig(c);
3008 
+
3009 
+        if (c._a) {
3010 
+            var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
3011 
+            this._isDSTShifted = this.isValid() &&
3012 
+                compareArrays(c._a, other.toArray()) > 0;
3013 
+        } else {
3014 
+            this._isDSTShifted = false;
3015 
+        }
3016 
+
3017 
+        return this._isDSTShifted;
3018 
+    }
3019 
+
3020 
+    function isLocal () {
3021 
+        return this.isValid() ? !this._isUTC : false;
3022 
+    }
3023 
+
3024 
+    function isUtcOffset () {
3025 
+        return this.isValid() ? this._isUTC : false;
3026 
+    }
3027 
+
3028 
+    function isUtc () {
3029 
+        return this.isValid() ? this._isUTC && this._offset === 0 : false;
3030 
+    }
3031 
+
3032 
+    // ASP.NET json date format regex
3033 
+    var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
3034 
+
3035 
+    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
3036 
+    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
3037 
+    // and further modified to allow for strings containing both week and day
3038 
+    var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
3039 
+
3040 
+    function createDuration (input, key) {
3041 
+        var duration = input,
3042 
+            // matching against regexp is expensive, do it on demand
3043 
+            match = null,
3044 
+            sign,
3045 
+            ret,
3046 
+            diffRes;
3047 
+
3048 
+        if (isDuration(input)) {
3049 
+            duration = {
3050 
+                ms : input._milliseconds,
3051 
+                d  : input._days,
3052 
+                M  : input._months
3053 
+            };
3054 
+        } else if (isNumber(input)) {
3055 
+            duration = {};
3056 
+            if (key) {
3057 
+                duration[key] = input;
3058 
+            } else {
3059 
+                duration.milliseconds = input;
3060 
+            }
3061 
+        } else if (!!(match = aspNetRegex.exec(input))) {
3062 
+            sign = (match[1] === '-') ? -1 : 1;
3063 
+            duration = {
3064 
+                y  : 0,
3065 
+                d  : toInt(match[DATE])                         * sign,
3066 
+                h  : toInt(match[HOUR])                         * sign,
3067 
+                m  : toInt(match[MINUTE])                       * sign,
3068 
+                s  : toInt(match[SECOND])                       * sign,
3069 
+                ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
3070 
+            };
3071 
+        } else if (!!(match = isoRegex.exec(input))) {
3072 
+            sign = (match[1] === '-') ? -1 : 1;
3073 
+            duration = {
3074 
+                y : parseIso(match[2], sign),
3075 
+                M : parseIso(match[3], sign),
3076 
+                w : parseIso(match[4], sign),
3077 
+                d : parseIso(match[5], sign),
3078 
+                h : parseIso(match[6], sign),
3079 
+                m : parseIso(match[7], sign),
3080 
+                s : parseIso(match[8], sign)
3081 
+            };
3082 
+        } else if (duration == null) {// checks for null or undefined
3083 
+            duration = {};
3084 
+        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
3085 
+            diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
3086 
+
3087 
+            duration = {};
3088 
+            duration.ms = diffRes.milliseconds;
3089 
+            duration.M = diffRes.months;
3090 
+        }
3091 
+
3092 
+        ret = new Duration(duration);
3093 
+
3094 
+        if (isDuration(input) && hasOwnProp(input, '_locale')) {
3095 
+            ret._locale = input._locale;
3096 
+        }
3097 
+
3098 
+        return ret;
3099 
+    }
3100 
+
3101 
+    createDuration.fn = Duration.prototype;
3102 
+    createDuration.invalid = createInvalid$1;
3103 
+
3104 
+    function parseIso (inp, sign) {
3105 
+        // We'd normally use ~~inp for this, but unfortunately it also
3106 
+        // converts floats to ints.
3107 
+        // inp may be undefined, so careful calling replace on it.
3108 
+        var res = inp && parseFloat(inp.replace(',', '.'));
3109 
+        // apply sign while we're at it
3110 
+        return (isNaN(res) ? 0 : res) * sign;
3111 
+    }
3112 
+
3113 
+    function positiveMomentsDifference(base, other) {
3114 
+        var res = {};
3115 
+
3116 
+        res.months = other.month() - base.month() +
3117 
+            (other.year() - base.year()) * 12;
3118 
+        if (base.clone().add(res.months, 'M').isAfter(other)) {
3119 
+            --res.months;
3120 
+        }
3121 
+
3122 
+        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
3123 
+
3124 
+        return res;
3125 
+    }
3126 
+
3127 
+    function momentsDifference(base, other) {
3128 
+        var res;
3129 
+        if (!(base.isValid() && other.isValid())) {
3130 
+            return {milliseconds: 0, months: 0};
3131 
+        }
3132 
+
3133 
+        other = cloneWithOffset(other, base);
3134 
+        if (base.isBefore(other)) {
3135 
+            res = positiveMomentsDifference(base, other);
3136 
+        } else {
3137 
+            res = positiveMomentsDifference(other, base);
3138 
+            res.milliseconds = -res.milliseconds;
3139 
+            res.months = -res.months;
3140 
+        }
3141 
+
3142 
+        return res;
3143 
+    }
3144 
+
3145 
+    // TODO: remove 'name' arg after deprecation is removed
3146 
+    function createAdder(direction, name) {
3147 
+        return function (val, period) {
3148 
+            var dur, tmp;
3149 
+            //invert the arguments, but complain about it
3150 
+            if (period !== null && !isNaN(+period)) {
3151 
+                deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
3152 
+                'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
3153 
+                tmp = val; val = period; period = tmp;
3154 
+            }
3155 
+
3156 
+            val = typeof val === 'string' ? +val : val;
3157 
+            dur = createDuration(val, period);
3158 
+            addSubtract(this, dur, direction);
3159 
+            return this;
3160 
+        };
3161 
+    }
3162 
+
3163 
+    function addSubtract (mom, duration, isAdding, updateOffset) {
3164 
+        var milliseconds = duration._milliseconds,
3165 
+            days = absRound(duration._days),
3166 
+            months = absRound(duration._months);
3167 
+
3168 
+        if (!mom.isValid()) {
3169 
+            // No op
3170 
+            return;
3171 
+        }
3172 
+
3173 
+        updateOffset = updateOffset == null ? true : updateOffset;
3174 
+
3175 
+        if (months) {
3176 
+            setMonth(mom, get(mom, 'Month') + months * isAdding);
3177 
+        }
3178 
+        if (days) {
3179 
+            set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
3180 
+        }
3181 
+        if (milliseconds) {
3182 
+            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
3183 
+        }
3184 
+        if (updateOffset) {
3185 
+            hooks.updateOffset(mom, days || months);
3186 
+        }
3187 
+    }
3188 
+
3189 
+    var add      = createAdder(1, 'add');
3190 
+    var subtract = createAdder(-1, 'subtract');
3191 
+
3192 
+    function getCalendarFormat(myMoment, now) {
3193 
+        var diff = myMoment.diff(now, 'days', true);
3194 
+        return diff < -6 ? 'sameElse' :
3195 
+                diff < -1 ? 'lastWeek' :
3196 
+                diff < 0 ? 'lastDay' :
3197 
+                diff < 1 ? 'sameDay' :
3198 
+                diff < 2 ? 'nextDay' :
3199 
+                diff < 7 ? 'nextWeek' : 'sameElse';
3200 
+    }
3201 
+
3202 
+    function calendar$1 (time, formats) {
3203 
+        // We want to compare the start of today, vs this.
3204 
+        // Getting start-of-today depends on whether we're local/utc/offset or not.
3205 
+        var now = time || createLocal(),
3206 
+            sod = cloneWithOffset(now, this).startOf('day'),
3207 
+            format = hooks.calendarFormat(this, sod) || 'sameElse';
3208 
+
3209 
+        var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
3210 
+
3211 
+        return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
3212 
+    }
3213 
+
3214 
+    function clone () {
3215 
+        return new Moment(this);
3216 
+    }
3217 
+
3218 
+    function isAfter (input, units) {
3219 
+        var localInput = isMoment(input) ? input : createLocal(input);
3220 
+        if (!(this.isValid() && localInput.isValid())) {
3221 
+            return false;
3222 
+        }
3223 
+        units = normalizeUnits(units) || 'millisecond';
3224 
+        if (units === 'millisecond') {
3225 
+            return this.valueOf() > localInput.valueOf();
3226 
+        } else {
3227 
+            return localInput.valueOf() < this.clone().startOf(units).valueOf();
3228 
+        }
3229 
+    }
3230 
+
3231 
+    function isBefore (input, units) {
3232 
+        var localInput = isMoment(input) ? input : createLocal(input);
3233 
+        if (!(this.isValid() && localInput.isValid())) {
3234 
+            return false;
3235 
+        }
3236 
+        units = normalizeUnits(units) || 'millisecond';
3237 
+        if (units === 'millisecond') {
3238 
+            return this.valueOf() < localInput.valueOf();
3239 
+        } else {
3240 
+            return this.clone().endOf(units).valueOf() < localInput.valueOf();
3241 
+        }
3242 
+    }
3243 
+
3244 
+    function isBetween (from, to, units, inclusivity) {
3245 
+        var localFrom = isMoment(from) ? from : createLocal(from),
3246 
+            localTo = isMoment(to) ? to : createLocal(to);
3247 
+        if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
3248 
+            return false;
3249 
+        }
3250 
+        inclusivity = inclusivity || '()';
3251 
+        return (inclusivity[0] === '(' ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) &&
3252 
+            (inclusivity[1] === ')' ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
3253 
+    }
3254 
+
3255 
+    function isSame (input, units) {
3256 
+        var localInput = isMoment(input) ? input : createLocal(input),
3257 
+            inputMs;
3258 
+        if (!(this.isValid() && localInput.isValid())) {
3259 
+            return false;
3260 
+        }
3261 
+        units = normalizeUnits(units) || 'millisecond';
3262 
+        if (units === 'millisecond') {
3263 
+            return this.valueOf() === localInput.valueOf();
3264 
+        } else {
3265 
+            inputMs = localInput.valueOf();
3266 
+            return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
3267 
+        }
3268 
+    }
3269 
+
3270 
+    function isSameOrAfter (input, units) {
3271 
+        return this.isSame(input, units) || this.isAfter(input, units);
3272 
+    }
3273 
+
3274 
+    function isSameOrBefore (input, units) {
3275 
+        return this.isSame(input, units) || this.isBefore(input, units);
3276 
+    }
3277 
+
3278 
+    function diff (input, units, asFloat) {
3279 
+        var that,
3280 
+            zoneDelta,
3281 
+            output;
3282 
+
3283 
+        if (!this.isValid()) {
3284 
+            return NaN;
3285 
+        }
3286 
+
3287 
+        that = cloneWithOffset(input, this);
3288 
+
3289 
+        if (!that.isValid()) {
3290 
+            return NaN;
3291 
+        }
3292 
+
3293 
+        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
3294 
+
3295 
+        units = normalizeUnits(units);
3296 
+
3297 
+        switch (units) {
3298 
+            case 'year': output = monthDiff(this, that) / 12; break;
3299 
+            case 'month': output = monthDiff(this, that); break;
3300 
+            case 'quarter': output = monthDiff(this, that) / 3; break;
3301 
+            case 'second': output = (this - that) / 1e3; break; // 1000
3302 
+            case 'minute': output = (this - that) / 6e4; break; // 1000 * 60
3303 
+            case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60
3304 
+            case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst
3305 
+            case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst
3306 
+            default: output = this - that;
3307 
+        }
3308 
+
3309 
+        return asFloat ? output : absFloor(output);
3310 
+    }
3311 
+
3312 
+    function monthDiff (a, b) {
3313 
+        // difference in months
3314 
+        var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
3315 
+            // b is in (anchor - 1 month, anchor + 1 month)
3316 
+            anchor = a.clone().add(wholeMonthDiff, 'months'),
3317 
+            anchor2, adjust;
3318 
+
3319 
+        if (b - anchor < 0) {
3320 
+            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
3321 
+            // linear across the month
3322 
+            adjust = (b - anchor) / (anchor - anchor2);
3323 
+        } else {
3324 
+            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
3325 
+            // linear across the month
3326 
+            adjust = (b - anchor) / (anchor2 - anchor);
3327 
+        }
3328 
+
3329 
+        //check for negative zero, return zero if negative zero
3330 
+        return -(wholeMonthDiff + adjust) || 0;
3331 
+    }
3332 
+
3333 
+    hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
3334 
+    hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
3335 
+
3336 
+    function toString () {
3337 
+        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
3338 
+    }
3339 
+
3340 
+    function toISOString(keepOffset) {
3341 
+        if (!this.isValid()) {
3342 
+            return null;
3343 
+        }
3344 
+        var utc = keepOffset !== true;
3345 
+        var m = utc ? this.clone().utc() : this;
3346 
+        if (m.year() < 0 || m.year() > 9999) {
3347 
+            return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
3348 
+        }
3349 
+        if (isFunction(Date.prototype.toISOString)) {
3350 
+            // native implementation is ~50x faster, use it when we can
3351 
+            if (utc) {
3352 
+                return this.toDate().toISOString();
3353 
+            } else {
3354 
+                return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));
3355 
+            }
3356 
+        }
3357 
+        return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
3358 
+    }
3359 
+
3360 
+    /**
3361 
+     * Return a human readable representation of a moment that can
3362 
+     * also be evaluated to get a new moment which is the same
3363 
+     *
3364 
+     * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
3365 
+     */
3366 
+    function inspect () {
3367 
+        if (!this.isValid()) {
3368 
+            return 'moment.invalid(/* ' + this._i + ' */)';
3369 
+        }
3370 
+        var func = 'moment';
3371 
+        var zone = '';
3372 
+        if (!this.isLocal()) {
3373 
+            func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
3374 
+            zone = 'Z';
3375 
+        }
3376 
+        var prefix = '[' + func + '("]';
3377 
+        var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
3378 
+        var datetime = '-MM-DD[T]HH:mm:ss.SSS';
3379 
+        var suffix = zone + '[")]';
3380 
+
3381 
+        return this.format(prefix + year + datetime + suffix);
3382 
+    }
3383 
+
3384 
+    function format (inputString) {
3385 
+        if (!inputString) {
3386 
+            inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
3387 
+        }
3388 
+        var output = formatMoment(this, inputString);
3389 
+        return this.localeData().postformat(output);
3390 
+    }
3391 
+
3392 
+    function from (time, withoutSuffix) {
3393 
+        if (this.isValid() &&
3394 
+                ((isMoment(time) && time.isValid()) ||
3395 
+                 createLocal(time).isValid())) {
3396 
+            return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
3397 
+        } else {
3398 
+            return this.localeData().invalidDate();
3399 
+        }
3400 
+    }
3401 
+
3402 
+    function fromNow (withoutSuffix) {
3403 
+        return this.from(createLocal(), withoutSuffix);
3404 
+    }
3405 
+
3406 
+    function to (time, withoutSuffix) {
3407 
+        if (this.isValid() &&
3408 
+                ((isMoment(time) && time.isValid()) ||
3409 
+                 createLocal(time).isValid())) {
3410 
+            return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
3411 
+        } else {
3412 
+            return this.localeData().invalidDate();
3413 
+        }
3414 
+    }
3415 
+
3416 
+    function toNow (withoutSuffix) {
3417 
+        return this.to(createLocal(), withoutSuffix);
3418 
+    }
3419 
+
3420 
+    // If passed a locale key, it will set the locale for this
3421 
+    // instance.  Otherwise, it will return the locale configuration
3422 
+    // variables for this instance.
3423 
+    function locale (key) {
3424 
+        var newLocaleData;
3425 
+
3426 
+        if (key === undefined) {
3427 
+            return this._locale._abbr;
3428 
+        } else {
3429 
+            newLocaleData = getLocale(key);
3430 
+            if (newLocaleData != null) {
3431 
+                this._locale = newLocaleData;
3432 
+            }
3433 
+            return this;
3434 
+        }
3435 
+    }
3436 
+
3437 
+    var lang = deprecate(
3438 
+        'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
3439 
+        function (key) {
3440 
+            if (key === undefined) {
3441 
+                return this.localeData();
3442 
+            } else {
3443 
+                return this.locale(key);
3444 
+            }
3445 
+        }
3446 
+    );
3447 
+
3448 
+    function localeData () {
3449 
+        return this._locale;
3450 
+    }
3451 
+
3452 
+    var MS_PER_SECOND = 1000;
3453 
+    var MS_PER_MINUTE = 60 * MS_PER_SECOND;
3454 
+    var MS_PER_HOUR = 60 * MS_PER_MINUTE;
3455 
+    var MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
3456 
+
3457 
+    // actual modulo - handles negative numbers (for dates before 1970):
3458 
+    function mod$1(dividend, divisor) {
3459 
+        return (dividend % divisor + divisor) % divisor;
3460 
+    }
3461 
+
3462 
+    function localStartOfDate(y, m, d) {
3463 
+        // the date constructor remaps years 0-99 to 1900-1999
3464 
+        if (y < 100 && y >= 0) {
3465 
+            // preserve leap years using a full 400 year cycle, then reset
3466 
+            return new Date(y + 400, m, d) - MS_PER_400_YEARS;
3467 
+        } else {
3468 
+            return new Date(y, m, d).valueOf();
3469 
+        }
3470 
+    }
3471 
+
3472 
+    function utcStartOfDate(y, m, d) {
3473 
+        // Date.UTC remaps years 0-99 to 1900-1999
3474 
+        if (y < 100 && y >= 0) {
3475 
+            // preserve leap years using a full 400 year cycle, then reset
3476 
+            return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
3477 
+        } else {
3478 
+            return Date.UTC(y, m, d);
3479 
+        }
3480 
+    }
3481 
+
3482 
+    function startOf (units) {
3483 
+        var time;
3484 
+        units = normalizeUnits(units);
3485 
+        if (units === undefined || units === 'millisecond' || !this.isValid()) {
3486 
+            return this;
3487 
+        }
3488 
+
3489 
+        var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
3490 
+
3491 
+        switch (units) {
3492 
+            case 'year':
3493 
+                time = startOfDate(this.year(), 0, 1);
3494 
+                break;
3495 
+            case 'quarter':
3496 
+                time = startOfDate(this.year(), this.month() - this.month() % 3, 1);
3497 
+                break;
3498 
+            case 'month':
3499 
+                time = startOfDate(this.year(), this.month(), 1);
3500 
+                break;
3501 
+            case 'week':
3502 
+                time = startOfDate(this.year(), this.month(), this.date() - this.weekday());
3503 
+                break;
3504 
+            case 'isoWeek':
3505 
+                time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1));
3506 
+                break;
3507 
+            case 'day':
3508 
+            case 'date':
3509 
+                time = startOfDate(this.year(), this.month(), this.date());
3510 
+                break;
3511 
+            case 'hour':
3512 
+                time = this._d.valueOf();
3513 
+                time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);
3514 
+                break;
3515 
+            case 'minute':
3516 
+                time = this._d.valueOf();
3517 
+                time -= mod$1(time, MS_PER_MINUTE);
3518 
+                break;
3519 
+            case 'second':
3520 
+                time = this._d.valueOf();
3521 
+                time -= mod$1(time, MS_PER_SECOND);
3522 
+                break;
3523 
+        }
3524 
+
3525 
+        this._d.setTime(time);
3526 
+        hooks.updateOffset(this, true);
3527 
+        return this;
3528 
+    }
3529 
+
3530 
+    function endOf (units) {
3531 
+        var time;
3532 
+        units = normalizeUnits(units);
3533 
+        if (units === undefined || units === 'millisecond' || !this.isValid()) {
3534 
+            return this;
3535 
+        }
3536 
+
3537 
+        var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
3538 
+
3539 
+        switch (units) {
3540 
+            case 'year':
3541 
+                time = startOfDate(this.year() + 1, 0, 1) - 1;
3542 
+                break;
3543 
+            case 'quarter':
3544 
+                time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1;
3545 
+                break;
3546 
+            case 'month':
3547 
+                time = startOfDate(this.year(), this.month() + 1, 1) - 1;
3548 
+                break;
3549 
+            case 'week':
3550 
+                time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1;
3551 
+                break;
3552 
+            case 'isoWeek':
3553 
+                time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) - 1;
3554 
+                break;
3555 
+            case 'day':
3556 
+            case 'date':
3557 
+                time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
3558 
+                break;
3559 
+            case 'hour':
3560 
+                time = this._d.valueOf();
3561 
+                time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1;
3562 
+                break;
3563 
+            case 'minute':
3564 
+                time = this._d.valueOf();
3565 
+                time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
3566 
+                break;
3567 
+            case 'second':
3568 
+                time = this._d.valueOf();
3569 
+                time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
3570 
+                break;
3571 
+        }
3572 
+
3573 
+        this._d.setTime(time);
3574 
+        hooks.updateOffset(this, true);
3575 
+        return this;
3576 
+    }
3577 
+
3578 
+    function valueOf () {
3579 
+        return this._d.valueOf() - ((this._offset || 0) * 60000);
3580 
+    }
3581 
+
3582 
+    function unix () {
3583 
+        return Math.floor(this.valueOf() / 1000);
3584 
+    }
3585 
+
3586 
+    function toDate () {
3587 
+        return new Date(this.valueOf());
3588 
+    }
3589 
+
3590 
+    function toArray () {
3591 
+        var m = this;
3592 
+        return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
3593 
+    }
3594 
+
3595 
+    function toObject () {
3596 
+        var m = this;
3597 
+        return {
3598 
+            years: m.year(),
3599 
+            months: m.month(),
3600 
+            date: m.date(),
3601 
+            hours: m.hours(),
3602 
+            minutes: m.minutes(),
3603 
+            seconds: m.seconds(),
3604 
+            milliseconds: m.milliseconds()
3605 
+        };
3606 
+    }
3607 
+
3608 
+    function toJSON () {
3609 
+        // new Date(NaN).toJSON() === null
3610 
+        return this.isValid() ? this.toISOString() : null;
3611 
+    }
3612 
+
3613 
+    function isValid$2 () {
3614 
+        return isValid(this);
3615 
+    }
3616 
+
3617 
+    function parsingFlags () {
3618 
+        return extend({}, getParsingFlags(this));
3619 
+    }
3620 
+
3621 
+    function invalidAt () {
3622 
+        return getParsingFlags(this).overflow;
3623 
+    }
3624 
+
3625 
+    function creationData() {
3626 
+        return {
3627 
+            input: this._i,
3628 
+            format: this._f,
3629 
+            locale: this._locale,
3630 
+            isUTC: this._isUTC,
3631 
+            strict: this._strict
3632 
+        };
3633 
+    }
3634 
+
3635 
+    // FORMATTING
3636 
+
3637 
+    addFormatToken(0, ['gg', 2], 0, function () {
3638 
+        return this.weekYear() % 100;
3639 
+    });
3640 
+
3641 
+    addFormatToken(0, ['GG', 2], 0, function () {
3642 
+        return this.isoWeekYear() % 100;
3643 
+    });
3644 
+
3645 
+    function addWeekYearFormatToken (token, getter) {
3646 
+        addFormatToken(0, [token, token.length], 0, getter);
3647 
+    }
3648 
+
3649 
+    addWeekYearFormatToken('gggg',     'weekYear');
3650 
+    addWeekYearFormatToken('ggggg',    'weekYear');
3651 
+    addWeekYearFormatToken('GGGG',  'isoWeekYear');
3652 
+    addWeekYearFormatToken('GGGGG', 'isoWeekYear');
3653 
+
3654 
+    // ALIASES
3655 
+
3656 
+    addUnitAlias('weekYear', 'gg');
3657 
+    addUnitAlias('isoWeekYear', 'GG');
3658 
+
3659 
+    // PRIORITY
3660 
+
3661 
+    addUnitPriority('weekYear', 1);
3662 
+    addUnitPriority('isoWeekYear', 1);
3663 
+
3664 
+
3665 
+    // PARSING
3666 
+
3667 
+    addRegexToken('G',      matchSigned);
3668 
+    addRegexToken('g',      matchSigned);
3669 
+    addRegexToken('GG',     match1to2, match2);
3670 
+    addRegexToken('gg',     match1to2, match2);
3671 
+    addRegexToken('GGGG',   match1to4, match4);
3672 
+    addRegexToken('gggg',   match1to4, match4);
3673 
+    addRegexToken('GGGGG',  match1to6, match6);
3674 
+    addRegexToken('ggggg',  match1to6, match6);
3675 
+
3676 
+    addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
3677 
+        week[token.substr(0, 2)] = toInt(input);
3678 
+    });
3679 
+
3680 
+    addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
3681 
+        week[token] = hooks.parseTwoDigitYear(input);
3682 
+    });
3683 
+
3684 
+    // MOMENTS
3685 
+
3686 
+    function getSetWeekYear (input) {
3687 
+        return getSetWeekYearHelper.call(this,
3688 
+                input,
3689 
+                this.week(),
3690 
+                this.weekday(),
3691 
+                this.localeData()._week.dow,
3692 
+                this.localeData()._week.doy);
3693 
+    }
3694 
+
3695 
+    function getSetISOWeekYear (input) {
3696 
+        return getSetWeekYearHelper.call(this,
3697 
+                input, this.isoWeek(), this.isoWeekday(), 1, 4);
3698 
+    }
3699 
+
3700 
+    function getISOWeeksInYear () {
3701 
+        return weeksInYear(this.year(), 1, 4);
3702 
+    }
3703 
+
3704 
+    function getWeeksInYear () {
3705 
+        var weekInfo = this.localeData()._week;
3706 
+        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
3707 
+    }
3708 
+
3709 
+    function getSetWeekYearHelper(input, week, weekday, dow, doy) {
3710 
+        var weeksTarget;
3711 
+        if (input == null) {
3712 
+            return weekOfYear(this, dow, doy).year;
3713 
+        } else {
3714 
+            weeksTarget = weeksInYear(input, dow, doy);
3715 
+            if (week > weeksTarget) {
3716 
+                week = weeksTarget;
3717 
+            }
3718 
+            return setWeekAll.call(this, input, week, weekday, dow, doy);
3719 
+        }
3720 
+    }
3721 
+
3722 
+    function setWeekAll(weekYear, week, weekday, dow, doy) {
3723 
+        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
3724 
+            date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
3725 
+
3726 
+        this.year(date.getUTCFullYear());
3727 
+        this.month(date.getUTCMonth());
3728 
+        this.date(date.getUTCDate());
3729 
+        return this;
3730 
+    }
3731 
+
3732 
+    // FORMATTING
3733 
+
3734 
+    addFormatToken('Q', 0, 'Qo', 'quarter');
3735 
+
3736 
+    // ALIASES
3737 
+
3738 
+    addUnitAlias('quarter', 'Q');
3739 
+
3740 
+    // PRIORITY
3741 
+
3742 
+    addUnitPriority('quarter', 7);
3743 
+
3744 
+    // PARSING
3745 
+
3746 
+    addRegexToken('Q', match1);
3747 
+    addParseToken('Q', function (input, array) {
3748 
+        array[MONTH] = (toInt(input) - 1) * 3;
3749 
+    });
3750 
+
3751 
+    // MOMENTS
3752 
+
3753 
+    function getSetQuarter (input) {
3754 
+        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
3755 
+    }
3756 
+
3757 
+    // FORMATTING
3758 
+
3759 
+    addFormatToken('D', ['DD', 2], 'Do', 'date');
3760 
+
3761 
+    // ALIASES
3762 
+
3763 
+    addUnitAlias('date', 'D');
3764 
+
3765 
+    // PRIORITY
3766 
+    addUnitPriority('date', 9);
3767 
+
3768 
+    // PARSING
3769 
+
3770 
+    addRegexToken('D',  match1to2);
3771 
+    addRegexToken('DD', match1to2, match2);
3772 
+    addRegexToken('Do', function (isStrict, locale) {
3773 
+        // TODO: Remove "ordinalParse" fallback in next major release.
3774 
+        return isStrict ?
3775 
+          (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
3776 
+          locale._dayOfMonthOrdinalParseLenient;
3777 
+    });
3778 
+
3779 
+    addParseToken(['D', 'DD'], DATE);
3780 
+    addParseToken('Do', function (input, array) {
3781 
+        array[DATE] = toInt(input.match(match1to2)[0]);
3782 
+    });
3783 
+
3784 
+    // MOMENTS
3785 
+
3786 
+    var getSetDayOfMonth = makeGetSet('Date', true);
3787 
+
3788 
+    // FORMATTING
3789 
+
3790 
+    addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
3791 
+
3792 
+    // ALIASES
3793 
+
3794 
+    addUnitAlias('dayOfYear', 'DDD');
3795 
+
3796 
+    // PRIORITY
3797 
+    addUnitPriority('dayOfYear', 4);
3798 
+
3799 
+    // PARSING
3800 
+
3801 
+    addRegexToken('DDD',  match1to3);
3802 
+    addRegexToken('DDDD', match3);
3803 
+    addParseToken(['DDD', 'DDDD'], function (input, array, config) {
3804 
+        config._dayOfYear = toInt(input);
3805 
+    });
3806 
+
3807 
+    // HELPERS
3808 
+
3809 
+    // MOMENTS
3810 
+
3811 
+    function getSetDayOfYear (input) {
3812 
+        var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
3813 
+        return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
3814 
+    }
3815 
+
3816 
+    // FORMATTING
3817 
+
3818 
+    addFormatToken('m', ['mm', 2], 0, 'minute');
3819 
+
3820 
+    // ALIASES
3821 
+
3822 
+    addUnitAlias('minute', 'm');
3823 
+
3824 
+    // PRIORITY
3825 
+
3826 
+    addUnitPriority('minute', 14);
3827 
+
3828 
+    // PARSING
3829 
+
3830 
+    addRegexToken('m',  match1to2);
3831 
+    addRegexToken('mm', match1to2, match2);
3832 
+    addParseToken(['m', 'mm'], MINUTE);
3833 
+
3834 
+    // MOMENTS
3835 
+
3836 
+    var getSetMinute = makeGetSet('Minutes', false);
3837 
+
3838 
+    // FORMATTING
3839 
+
3840 
+    addFormatToken('s', ['ss', 2], 0, 'second');
3841 
+
3842 
+    // ALIASES
3843 
+
3844 
+    addUnitAlias('second', 's');
3845 
+
3846 
+    // PRIORITY
3847 
+
3848 
+    addUnitPriority('second', 15);
3849 
+
3850 
+    // PARSING
3851 
+
3852 
+    addRegexToken('s',  match1to2);
3853 
+    addRegexToken('ss', match1to2, match2);
3854 
+    addParseToken(['s', 'ss'], SECOND);
3855 
+
3856 
+    // MOMENTS
3857 
+
3858 
+    var getSetSecond = makeGetSet('Seconds', false);
3859 
+
3860 
+    // FORMATTING
3861 
+
3862 
+    addFormatToken('S', 0, 0, function () {
3863 
+        return ~~(this.millisecond() / 100);
3864 
+    });
3865 
+
3866 
+    addFormatToken(0, ['SS', 2], 0, function () {
3867 
+        return ~~(this.millisecond() / 10);
3868 
+    });
3869 
+
3870 
+    addFormatToken(0, ['SSS', 3], 0, 'millisecond');
3871 
+    addFormatToken(0, ['SSSS', 4], 0, function () {
3872 
+        return this.millisecond() * 10;
3873 
+    });
3874 
+    addFormatToken(0, ['SSSSS', 5], 0, function () {
3875 
+        return this.millisecond() * 100;
3876 
+    });
3877 
+    addFormatToken(0, ['SSSSSS', 6], 0, function () {
3878 
+        return this.millisecond() * 1000;
3879 
+    });
3880 
+    addFormatToken(0, ['SSSSSSS', 7], 0, function () {
3881 
+        return this.millisecond() * 10000;
3882 
+    });
3883 
+    addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
3884 
+        return this.millisecond() * 100000;
3885 
+    });
3886 
+    addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
3887 
+        return this.millisecond() * 1000000;
3888 
+    });
3889 
+
3890 
+
3891 
+    // ALIASES
3892 
+
3893 
+    addUnitAlias('millisecond', 'ms');
3894 
+
3895 
+    // PRIORITY
3896 
+
3897 
+    addUnitPriority('millisecond', 16);
3898 
+
3899 
+    // PARSING
3900 
+
3901 
+    addRegexToken('S',    match1to3, match1);
3902 
+    addRegexToken('SS',   match1to3, match2);
3903 
+    addRegexToken('SSS',  match1to3, match3);
3904 
+
3905 
+    var token;
3906 
+    for (token = 'SSSS'; token.length <= 9; token += 'S') {
3907 
+        addRegexToken(token, matchUnsigned);
3908 
+    }
3909 
+
3910 
+    function parseMs(input, array) {
3911 
+        array[MILLISECOND] = toInt(('0.' + input) * 1000);
3912 
+    }
3913 
+
3914 
+    for (token = 'S'; token.length <= 9; token += 'S') {
3915 
+        addParseToken(token, parseMs);
3916 
+    }
3917 
+    // MOMENTS
3918 
+
3919 
+    var getSetMillisecond = makeGetSet('Milliseconds', false);
3920 
+
3921 
+    // FORMATTING
3922 
+
3923 
+    addFormatToken('z',  0, 0, 'zoneAbbr');
3924 
+    addFormatToken('zz', 0, 0, 'zoneName');
3925 
+
3926 
+    // MOMENTS
3927 
+
3928 
+    function getZoneAbbr () {
3929 
+        return this._isUTC ? 'UTC' : '';
3930 
+    }
3931 
+
3932 
+    function getZoneName () {
3933 
+        return this._isUTC ? 'Coordinated Universal Time' : '';
3934 
+    }
3935 
+
3936 
+    var proto = Moment.prototype;
3937 
+
3938 
+    proto.add               = add;
3939 
+    proto.calendar          = calendar$1;
3940 
+    proto.clone             = clone;
3941 
+    proto.diff              = diff;
3942 
+    proto.endOf             = endOf;
3943 
+    proto.format            = format;
3944 
+    proto.from              = from;
3945 
+    proto.fromNow           = fromNow;
3946 
+    proto.to                = to;
3947 
+    proto.toNow             = toNow;
3948 
+    proto.get               = stringGet;
3949 
+    proto.invalidAt         = invalidAt;
3950 
+    proto.isAfter           = isAfter;
3951 
+    proto.isBefore          = isBefore;
3952 
+    proto.isBetween         = isBetween;
3953 
+    proto.isSame            = isSame;
3954 
+    proto.isSameOrAfter     = isSameOrAfter;
3955 
+    proto.isSameOrBefore    = isSameOrBefore;
3956 
+    proto.isValid           = isValid$2;
3957 
+    proto.lang              = lang;
3958 
+    proto.locale            = locale;
3959 
+    proto.localeData        = localeData;
3960 
+    proto.max               = prototypeMax;
3961 
+    proto.min               = prototypeMin;
3962 
+    proto.parsingFlags      = parsingFlags;
3963 
+    proto.set               = stringSet;
3964 
+    proto.startOf           = startOf;
3965 
+    proto.subtract          = subtract;
3966 
+    proto.toArray           = toArray;
3967 
+    proto.toObject          = toObject;
3968 
+    proto.toDate            = toDate;
3969 
+    proto.toISOString       = toISOString;
3970 
+    proto.inspect           = inspect;
3971 
+    proto.toJSON            = toJSON;
3972 
+    proto.toString          = toString;
3973 
+    proto.unix              = unix;
3974 
+    proto.valueOf           = valueOf;
3975 
+    proto.creationData      = creationData;
3976 
+    proto.year       = getSetYear;
3977 
+    proto.isLeapYear = getIsLeapYear;
3978 
+    proto.weekYear    = getSetWeekYear;
3979 
+    proto.isoWeekYear = getSetISOWeekYear;
3980 
+    proto.quarter = proto.quarters = getSetQuarter;
3981 
+    proto.month       = getSetMonth;
3982 
+    proto.daysInMonth = getDaysInMonth;
3983 
+    proto.week           = proto.weeks        = getSetWeek;
3984 
+    proto.isoWeek        = proto.isoWeeks     = getSetISOWeek;
3985 
+    proto.weeksInYear    = getWeeksInYear;
3986 
+    proto.isoWeeksInYear = getISOWeeksInYear;
3987 
+    proto.date       = getSetDayOfMonth;
3988 
+    proto.day        = proto.days             = getSetDayOfWeek;
3989 
+    proto.weekday    = getSetLocaleDayOfWeek;
3990 
+    proto.isoWeekday = getSetISODayOfWeek;
3991 
+    proto.dayOfYear  = getSetDayOfYear;
3992 
+    proto.hour = proto.hours = getSetHour;
3993 
+    proto.minute = proto.minutes = getSetMinute;
3994 
+    proto.second = proto.seconds = getSetSecond;
3995 
+    proto.millisecond = proto.milliseconds = getSetMillisecond;
3996 
+    proto.utcOffset            = getSetOffset;
3997 
+    proto.utc                  = setOffsetToUTC;
3998 
+    proto.local                = setOffsetToLocal;
3999 
+    proto.parseZone            = setOffsetToParsedOffset;
4000 
+    proto.hasAlignedHourOffset = hasAlignedHourOffset;
4001 
+    proto.isDST                = isDaylightSavingTime;
4002 
+    proto.isLocal              = isLocal;
4003 
+    proto.isUtcOffset          = isUtcOffset;
4004 
+    proto.isUtc                = isUtc;
4005 
+    proto.isUTC                = isUtc;
4006 
+    proto.zoneAbbr = getZoneAbbr;
4007 
+    proto.zoneName = getZoneName;
4008 
+    proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
4009 
+    proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
4010 
+    proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
4011 
+    proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
4012 
+    proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
4013 
+
4014 
+    function createUnix (input) {
4015 
+        return createLocal(input * 1000);
4016 
+    }
4017 
+
4018 
+    function createInZone () {
4019 
+        return createLocal.apply(null, arguments).parseZone();
4020 
+    }
4021 
+
4022 
+    function preParsePostFormat (string) {
4023 
+        return string;
4024 
+    }
4025 
+
4026 
+    var proto$1 = Locale.prototype;
4027 
+
4028 
+    proto$1.calendar        = calendar;
4029 
+    proto$1.longDateFormat  = longDateFormat;
4030 
+    proto$1.invalidDate     = invalidDate;
4031 
+    proto$1.ordinal         = ordinal;
4032 
+    proto$1.preparse        = preParsePostFormat;
4033 
+    proto$1.postformat      = preParsePostFormat;
4034 
+    proto$1.relativeTime    = relativeTime;
4035 
+    proto$1.pastFuture      = pastFuture;
4036 
+    proto$1.set             = set;
4037 
+
4038 
+    proto$1.months            =        localeMonths;
4039 
+    proto$1.monthsShort       =        localeMonthsShort;
4040 
+    proto$1.monthsParse       =        localeMonthsParse;
4041 
+    proto$1.monthsRegex       = monthsRegex;
4042 
+    proto$1.monthsShortRegex  = monthsShortRegex;
4043 
+    proto$1.week = localeWeek;
4044 
+    proto$1.firstDayOfYear = localeFirstDayOfYear;
4045 
+    proto$1.firstDayOfWeek = localeFirstDayOfWeek;
4046 
+
4047 
+    proto$1.weekdays       =        localeWeekdays;
4048 
+    proto$1.weekdaysMin    =        localeWeekdaysMin;
4049 
+    proto$1.weekdaysShort  =        localeWeekdaysShort;
4050 
+    proto$1.weekdaysParse  =        localeWeekdaysParse;
4051 
+
4052 
+    proto$1.weekdaysRegex       =        weekdaysRegex;
4053 
+    proto$1.weekdaysShortRegex  =        weekdaysShortRegex;
4054 
+    proto$1.weekdaysMinRegex    =        weekdaysMinRegex;
4055 
+
4056 
+    proto$1.isPM = localeIsPM;
4057 
+    proto$1.meridiem = localeMeridiem;
4058 
+
4059 
+    function get$1 (format, index, field, setter) {
4060 
+        var locale = getLocale();
4061 
+        var utc = createUTC().set(setter, index);
4062 
+        return locale[field](utc, format);
4063 
+    }
4064 
+
4065 
+    function listMonthsImpl (format, index, field) {
4066 
+        if (isNumber(format)) {
4067 
+            index = format;
4068 
+            format = undefined;
4069 
+        }
4070 
+
4071 
+        format = format || '';
4072 
+
4073 
+        if (index != null) {
4074 
+            return get$1(format, index, field, 'month');
4075 
+        }
4076 
+
4077 
+        var i;
4078 
+        var out = [];
4079 
+        for (i = 0; i < 12; i++) {
4080 
+            out[i] = get$1(format, i, field, 'month');
4081 
+        }
4082 
+        return out;
4083 
+    }
4084 
+
4085 
+    // ()
4086 
+    // (5)
4087 
+    // (fmt, 5)
4088 
+    // (fmt)
4089 
+    // (true)
4090 
+    // (true, 5)
4091 
+    // (true, fmt, 5)
4092 
+    // (true, fmt)
4093 
+    function listWeekdaysImpl (localeSorted, format, index, field) {
4094 
+        if (typeof localeSorted === 'boolean') {
4095 
+            if (isNumber(format)) {
4096 
+                index = format;
4097 
+                format = undefined;
4098 
+            }
4099 
+
4100 
+            format = format || '';
4101 
+        } else {
4102 
+            format = localeSorted;
4103 
+            index = format;
4104 
+            localeSorted = false;
4105 
+
4106 
+            if (isNumber(format)) {
4107 
+                index = format;
4108 
+                format = undefined;
4109 
+            }
4110 
+
4111 
+            format = format || '';
4112 
+        }
4113 
+
4114 
+        var locale = getLocale(),
4115 
+            shift = localeSorted ? locale._week.dow : 0;
4116 
+
4117 
+        if (index != null) {
4118 
+            return get$1(format, (index + shift) % 7, field, 'day');
4119 
+        }
4120 
+
4121 
+        var i;
4122 
+        var out = [];
4123 
+        for (i = 0; i < 7; i++) {
4124 
+            out[i] = get$1(format, (i + shift) % 7, field, 'day');
4125 
+        }
4126 
+        return out;
4127 
+    }
4128 
+
4129 
+    function listMonths (format, index) {
4130 
+        return listMonthsImpl(format, index, 'months');
4131 
+    }
4132 
+
4133 
+    function listMonthsShort (format, index) {
4134 
+        return listMonthsImpl(format, index, 'monthsShort');
4135 
+    }
4136 
+
4137 
+    function listWeekdays (localeSorted, format, index) {
4138 
+        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
4139 
+    }
4140 
+
4141 
+    function listWeekdaysShort (localeSorted, format, index) {
4142 
+        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
4143 
+    }
4144 
+
4145 
+    function listWeekdaysMin (localeSorted, format, index) {
4146 
+        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
4147 
+    }
4148 
+
4149 
+    getSetGlobalLocale('en', {
4150 
+        dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
4151 
+        ordinal : function (number) {
4152 
+            var b = number % 10,
4153 
+                output = (toInt(number % 100 / 10) === 1) ? 'th' :
4154 
+                (b === 1) ? 'st' :
4155 
+                (b === 2) ? 'nd' :
4156 
+                (b === 3) ? 'rd' : 'th';
4157 
+            return number + output;
4158 
+        }
4159 
+    });
4160 
+
4161 
+    // Side effect imports
4162 
+
4163 
+    hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
4164 
+    hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
4165 
+
4166 
+    var mathAbs = Math.abs;
4167 
+
4168 
+    function abs () {
4169 
+        var data           = this._data;
4170 
+
4171 
+        this._milliseconds = mathAbs(this._milliseconds);
4172 
+        this._days         = mathAbs(this._days);
4173 
+        this._months       = mathAbs(this._months);
4174 
+
4175 
+        data.milliseconds  = mathAbs(data.milliseconds);
4176 
+        data.seconds       = mathAbs(data.seconds);
4177 
+        data.minutes       = mathAbs(data.minutes);
4178 
+        data.hours         = mathAbs(data.hours);
4179 
+        data.months        = mathAbs(data.months);
4180 
+        data.years         = mathAbs(data.years);
4181 
+
4182 
+        return this;
4183 
+    }
4184 
+
4185 
+    function addSubtract$1 (duration, input, value, direction) {
4186 
+        var other = createDuration(input, value);
4187 
+
4188 
+        duration._milliseconds += direction * other._milliseconds;
4189 
+        duration._days         += direction * other._days;
4190 
+        duration._months       += direction * other._months;
4191 
+
4192 
+        return duration._bubble();
4193 
+    }
4194 
+
4195 
+    // supports only 2.0-style add(1, 's') or add(duration)
4196 
+    function add$1 (input, value) {
4197 
+        return addSubtract$1(this, input, value, 1);
4198 
+    }
4199 
+
4200 
+    // supports only 2.0-style subtract(1, 's') or subtract(duration)
4201 
+    function subtract$1 (input, value) {
4202 
+        return addSubtract$1(this, input, value, -1);
4203 
+    }
4204 
+
4205 
+    function absCeil (number) {
4206 
+        if (number < 0) {
4207 
+            return Math.floor(number);
4208 
+        } else {
4209 
+            return Math.ceil(number);
4210 
+        }
4211 
+    }
4212 
+
4213 
+    function bubble () {
4214 
+        var milliseconds = this._milliseconds;
4215 
+        var days         = this._days;
4216 
+        var months       = this._months;
4217 
+        var data         = this._data;
4218 
+        var seconds, minutes, hours, years, monthsFromDays;
4219 
+
4220 
+        // if we have a mix of positive and negative values, bubble down first
4221 
+        // check: https://github.com/moment/moment/issues/2166
4222 
+        if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
4223 
+                (milliseconds <= 0 && days <= 0 && months <= 0))) {
4224 
+            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
4225 
+            days = 0;
4226 
+            months = 0;
4227 
+        }
4228 
+
4229 
+        // The following code bubbles up values, see the tests for
4230 
+        // examples of what that means.
4231 
+        data.milliseconds = milliseconds % 1000;
4232 
+
4233 
+        seconds           = absFloor(milliseconds / 1000);
4234 
+        data.seconds      = seconds % 60;
4235 
+
4236 
+        minutes           = absFloor(seconds / 60);
4237 
+        data.minutes      = minutes % 60;
4238 
+
4239 
+        hours             = absFloor(minutes / 60);
4240 
+        data.hours        = hours % 24;
4241 
+
4242 
+        days += absFloor(hours / 24);
4243 
+
4244 
+        // convert days to months
4245 
+        monthsFromDays = absFloor(daysToMonths(days));
4246 
+        months += monthsFromDays;
4247 
+        days -= absCeil(monthsToDays(monthsFromDays));
4248 
+
4249 
+        // 12 months -> 1 year
4250 
+        years = absFloor(months / 12);
4251 
+        months %= 12;
4252 
+
4253 
+        data.days   = days;
4254 
+        data.months = months;
4255 
+        data.years  = years;
4256 
+
4257 
+        return this;
4258 
+    }
4259 
+
4260 
+    function daysToMonths (days) {
4261 
+        // 400 years have 146097 days (taking into account leap year rules)
4262 
+        // 400 years have 12 months === 4800
4263 
+        return days * 4800 / 146097;
4264 
+    }
4265 
+
4266 
+    function monthsToDays (months) {
4267 
+        // the reverse of daysToMonths
4268 
+        return months * 146097 / 4800;
4269 
+    }
4270 
+
4271 
+    function as (units) {
4272 
+        if (!this.isValid()) {
4273 
+            return NaN;
4274 
+        }
4275 
+        var days;
4276 
+        var months;
4277 
+        var milliseconds = this._milliseconds;
4278 
+
4279 
+        units = normalizeUnits(units);
4280 
+
4281 
+        if (units === 'month' || units === 'quarter' || units === 'year') {
4282 
+            days = this._days + milliseconds / 864e5;
4283 
+            months = this._months + daysToMonths(days);
4284 
+            switch (units) {
4285 
+                case 'month':   return months;
4286 
+                case 'quarter': return months / 3;
4287 
+                case 'year':    return months / 12;
4288 
+            }
4289 
+        } else {
4290 
+            // handle milliseconds separately because of floating point math errors (issue #1867)
4291 
+            days = this._days + Math.round(monthsToDays(this._months));
4292 
+            switch (units) {
4293 
+                case 'week'   : return days / 7     + milliseconds / 6048e5;
4294 
+                case 'day'    : return days         + milliseconds / 864e5;
4295 
+                case 'hour'   : return days * 24    + milliseconds / 36e5;
4296 
+                case 'minute' : return days * 1440  + milliseconds / 6e4;
4297 
+                case 'second' : return days * 86400 + milliseconds / 1000;
4298 
+                // Math.floor prevents floating point math errors here
4299 
+                case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
4300 
+                default: throw new Error('Unknown unit ' + units);
4301 
+            }
4302 
+        }
4303 
+    }
4304 
+
4305 
+    // TODO: Use this.as('ms')?
4306 
+    function valueOf$1 () {
4307 
+        if (!this.isValid()) {
4308 
+            return NaN;
4309 
+        }
4310 
+        return (
4311 
+            this._milliseconds +
4312 
+            this._days * 864e5 +
4313 
+            (this._months % 12) * 2592e6 +
4314 
+            toInt(this._months / 12) * 31536e6
4315 
+        );
4316 
+    }
4317 
+
4318 
+    function makeAs (alias) {
4319 
+        return function () {
4320 
+            return this.as(alias);
4321 
+        };
4322 
+    }
4323 
+
4324 
+    var asMilliseconds = makeAs('ms');
4325 
+    var asSeconds      = makeAs('s');
4326 
+    var asMinutes      = makeAs('m');
4327 
+    var asHours        = makeAs('h');
4328 
+    var asDays         = makeAs('d');
4329 
+    var asWeeks        = makeAs('w');
4330 
+    var asMonths       = makeAs('M');
4331 
+    var asQuarters     = makeAs('Q');
4332 
+    var asYears        = makeAs('y');
4333 
+
4334 
+    function clone$1 () {
4335 
+        return createDuration(this);
4336 
+    }
4337 
+
4338 
+    function get$2 (units) {
4339 
+        units = normalizeUnits(units);
4340 
+        return this.isValid() ? this[units + 's']() : NaN;
4341 
+    }
4342 
+
4343 
+    function makeGetter(name) {
4344 
+        return function () {
4345 
+            return this.isValid() ? this._data[name] : NaN;
4346 
+        };
4347 
+    }
4348 
+
4349 
+    var milliseconds = makeGetter('milliseconds');
4350 
+    var seconds      = makeGetter('seconds');
4351 
+    var minutes      = makeGetter('minutes');
4352 
+    var hours        = makeGetter('hours');
4353 
+    var days         = makeGetter('days');
4354 
+    var months       = makeGetter('months');
4355 
+    var years        = makeGetter('years');
4356 
+
4357 
+    function weeks () {
4358 
+        return absFloor(this.days() / 7);
4359 
+    }
4360 
+
4361 
+    var round = Math.round;
4362 
+    var thresholds = {
4363 
+        ss: 44,         // a few seconds to seconds
4364 
+        s : 45,         // seconds to minute
4365 
+        m : 45,         // minutes to hour
4366 
+        h : 22,         // hours to day
4367 
+        d : 26,         // days to month
4368 
+        M : 11          // months to year
4369 
+    };
4370 
+
4371 
+    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
4372 
+    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
4373 
+        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
4374 
+    }
4375 
+
4376 
+    function relativeTime$1 (posNegDuration, withoutSuffix, locale) {
4377 
+        var duration = createDuration(posNegDuration).abs();
4378 
+        var seconds  = round(duration.as('s'));
4379 
+        var minutes  = round(duration.as('m'));
4380 
+        var hours    = round(duration.as('h'));
4381 
+        var days     = round(duration.as('d'));
4382 
+        var months   = round(duration.as('M'));
4383 
+        var years    = round(duration.as('y'));
4384 
+
4385 
+        var a = seconds <= thresholds.ss && ['s', seconds]  ||
4386 
+                seconds < thresholds.s   && ['ss', seconds] ||
4387 
+                minutes <= 1             && ['m']           ||
4388 
+                minutes < thresholds.m   && ['mm', minutes] ||
4389 
+                hours   <= 1             && ['h']           ||
4390 
+                hours   < thresholds.h   && ['hh', hours]   ||
4391 
+                days    <= 1             && ['d']           ||
4392 
+                days    < thresholds.d   && ['dd', days]    ||
4393 
+                months  <= 1             && ['M']           ||
4394 
+                months  < thresholds.M   && ['MM', months]  ||
4395 
+                years   <= 1             && ['y']           || ['yy', years];
4396 
+
4397 
+        a[2] = withoutSuffix;
4398 
+        a[3] = +posNegDuration > 0;
4399 
+        a[4] = locale;
4400 
+        return substituteTimeAgo.apply(null, a);
4401 
+    }
4402 
+
4403 
+    // This function allows you to set the rounding function for relative time strings
4404 
+    function getSetRelativeTimeRounding (roundingFunction) {
4405 
+        if (roundingFunction === undefined) {
4406 
+            return round;
4407 
+        }
4408 
+        if (typeof(roundingFunction) === 'function') {
4409 
+            round = roundingFunction;
4410 
+            return true;
4411 
+        }
4412 
+        return false;
4413 
+    }
4414 
+
4415 
+    // This function allows you to set a threshold for relative time strings
4416 
+    function getSetRelativeTimeThreshold (threshold, limit) {
4417 
+        if (thresholds[threshold] === undefined) {
4418 
+            return false;
4419 
+        }
4420 
+        if (limit === undefined) {
4421 
+            return thresholds[threshold];
4422 
+        }
4423 
+        thresholds[threshold] = limit;
4424 
+        if (threshold === 's') {
4425 
+            thresholds.ss = limit - 1;
4426 
+        }
4427 
+        return true;
4428 
+    }
4429 
+
4430 
+    function humanize (withSuffix) {
4431 
+        if (!this.isValid()) {
4432 
+            return this.localeData().invalidDate();
4433 
+        }
4434 
+
4435 
+        var locale = this.localeData();
4436 
+        var output = relativeTime$1(this, !withSuffix, locale);
4437 
+
4438 
+        if (withSuffix) {
4439 
+            output = locale.pastFuture(+this, output);
4440 
+        }
4441 
+
4442 
+        return locale.postformat(output);
4443 
+    }
4444 
+
4445 
+    var abs$1 = Math.abs;
4446 
+
4447 
+    function sign(x) {
4448 
+        return ((x > 0) - (x < 0)) || +x;
4449 
+    }
4450 
+
4451 
+    function toISOString$1() {
4452 
+        // for ISO strings we do not use the normal bubbling rules:
4453 
+        //  * milliseconds bubble up until they become hours
4454 
+        //  * days do not bubble at all
4455 
+        //  * months bubble up until they become years
4456 
+        // This is because there is no context-free conversion between hours and days
4457 
+        // (think of clock changes)
4458 
+        // and also not between days and months (28-31 days per month)
4459 
+        if (!this.isValid()) {
4460 
+            return this.localeData().invalidDate();
4461 
+        }
4462 
+
4463 
+        var seconds = abs$1(this._milliseconds) / 1000;
4464 
+        var days         = abs$1(this._days);
4465 
+        var months       = abs$1(this._months);
4466 
+        var minutes, hours, years;
4467 
+
4468 
+        // 3600 seconds -> 60 minutes -> 1 hour
4469 
+        minutes           = absFloor(seconds / 60);
4470 
+        hours             = absFloor(minutes / 60);
4471 
+        seconds %= 60;
4472 
+        minutes %= 60;
4473 
+
4474 
+        // 12 months -> 1 year
4475 
+        years  = absFloor(months / 12);
4476 
+        months %= 12;
4477 
+
4478 
+
4479 
+        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
4480 
+        var Y = years;
4481 
+        var M = months;
4482 
+        var D = days;
4483 
+        var h = hours;
4484 
+        var m = minutes;
4485 
+        var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
4486 
+        var total = this.asSeconds();
4487 
+
4488 
+        if (!total) {
4489 
+            // this is the same as C#'s (Noda) and python (isodate)...
4490 
+            // but not other JS (goog.date)
4491 
+            return 'P0D';
4492 
+        }
4493 
+
4494 
+        var totalSign = total < 0 ? '-' : '';
4495 
+        var ymSign = sign(this._months) !== sign(total) ? '-' : '';
4496 
+        var daysSign = sign(this._days) !== sign(total) ? '-' : '';
4497 
+        var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
4498 
+
4499 
+        return totalSign + 'P' +
4500 
+            (Y ? ymSign + Y + 'Y' : '') +
4501 
+            (M ? ymSign + M + 'M' : '') +
4502 
+            (D ? daysSign + D + 'D' : '') +
4503 
+            ((h || m || s) ? 'T' : '') +
4504 
+            (h ? hmsSign + h + 'H' : '') +
4505 
+            (m ? hmsSign + m + 'M' : '') +
4506 
+            (s ? hmsSign + s + 'S' : '');
4507 
+    }
4508 
+
4509 
+    var proto$2 = Duration.prototype;
4510 
+
4511 
+    proto$2.isValid        = isValid$1;
4512 
+    proto$2.abs            = abs;
4513 
+    proto$2.add            = add$1;
4514 
+    proto$2.subtract       = subtract$1;
4515 
+    proto$2.as             = as;
4516 
+    proto$2.asMilliseconds = asMilliseconds;
4517 
+    proto$2.asSeconds      = asSeconds;
4518 
+    proto$2.asMinutes      = asMinutes;
4519 
+    proto$2.asHours        = asHours;
4520 
+    proto$2.asDays         = asDays;
4521 
+    proto$2.asWeeks        = asWeeks;
4522 
+    proto$2.asMonths       = asMonths;
4523 
+    proto$2.asQuarters     = asQuarters;
4524 
+    proto$2.asYears        = asYears;
4525 
+    proto$2.valueOf        = valueOf$1;
4526 
+    proto$2._bubble        = bubble;
4527 
+    proto$2.clone          = clone$1;
4528 
+    proto$2.get            = get$2;
4529 
+    proto$2.milliseconds   = milliseconds;
4530 
+    proto$2.seconds        = seconds;
4531 
+    proto$2.minutes        = minutes;
4532 
+    proto$2.hours          = hours;
4533 
+    proto$2.days           = days;
4534 
+    proto$2.weeks          = weeks;
4535 
+    proto$2.months         = months;
4536 
+    proto$2.years          = years;
4537 
+    proto$2.humanize       = humanize;
4538 
+    proto$2.toISOString    = toISOString$1;
4539 
+    proto$2.toString       = toISOString$1;
4540 
+    proto$2.toJSON         = toISOString$1;
4541 
+    proto$2.locale         = locale;
4542 
+    proto$2.localeData     = localeData;
4543 
+
4544 
+    proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
4545 
+    proto$2.lang = lang;
4546 
+
4547 
+    // Side effect imports
4548 
+
4549 
+    // FORMATTING
4550 
+
4551 
+    addFormatToken('X', 0, 0, 'unix');
4552 
+    addFormatToken('x', 0, 0, 'valueOf');
4553 
+
4554 
+    // PARSING
4555 
+
4556 
+    addRegexToken('x', matchSigned);
4557 
+    addRegexToken('X', matchTimestamp);
4558 
+    addParseToken('X', function (input, array, config) {
4559 
+        config._d = new Date(parseFloat(input, 10) * 1000);
4560 
+    });
4561 
+    addParseToken('x', function (input, array, config) {
4562 
+        config._d = new Date(toInt(input));
4563 
+    });
4564 
+
4565 
+    // Side effect imports
4566 
+
4567 
+    //! moment.js
4568 
+
4569 
+    hooks.version = '2.24.0';
4570 
+
4571 
+    setHookCallback(createLocal);
4572 
+
4573 
+    hooks.fn                    = proto;
4574 
+    hooks.min                   = min;
4575 
+    hooks.max                   = max;
4576 
+    hooks.now                   = now;
4577 
+    hooks.utc                   = createUTC;
4578 
+    hooks.unix                  = createUnix;
4579 
+    hooks.months                = listMonths;
4580 
+    hooks.isDate                = isDate;
4581 
+    hooks.locale                = getSetGlobalLocale;
4582 
+    hooks.invalid               = createInvalid;
4583 
+    hooks.duration              = createDuration;
4584 
+    hooks.isMoment              = isMoment;
4585 
+    hooks.weekdays              = listWeekdays;
4586 
+    hooks.parseZone             = createInZone;
4587 
+    hooks.localeData            = getLocale;
4588 
+    hooks.isDuration            = isDuration;
4589 
+    hooks.monthsShort           = listMonthsShort;
4590 
+    hooks.weekdaysMin           = listWeekdaysMin;
4591 
+    hooks.defineLocale          = defineLocale;
4592 
+    hooks.updateLocale          = updateLocale;
4593 
+    hooks.locales               = listLocales;
4594 
+    hooks.weekdaysShort         = listWeekdaysShort;
4595 
+    hooks.normalizeUnits        = normalizeUnits;
4596 
+    hooks.relativeTimeRounding  = getSetRelativeTimeRounding;
4597 
+    hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
4598 
+    hooks.calendarFormat        = getCalendarFormat;
4599 
+    hooks.prototype             = proto;
4600 
+
4601 
+    // currently HTML5 input type only supports 24-hour formats
4602 
+    hooks.HTML5_FMT = {
4603 
+        DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm',             // <input type="datetime-local" />
4604 
+        DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss',  // <input type="datetime-local" step="1" />
4605 
+        DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS',   // <input type="datetime-local" step="0.001" />
4606 
+        DATE: 'YYYY-MM-DD',                             // <input type="date" />
4607 
+        TIME: 'HH:mm',                                  // <input type="time" />
4608 
+        TIME_SECONDS: 'HH:mm:ss',                       // <input type="time" step="1" />
4609 
+        TIME_MS: 'HH:mm:ss.SSS',                        // <input type="time" step="0.001" />
4610 
+        WEEK: 'GGGG-[W]WW',                             // <input type="week" />
4611 
+        MONTH: 'YYYY-MM'                                // <input type="month" />
4612 
+    };
4613 
+
4614 
+    //! moment.js locale configuration
4615 
+
4616 
+    hooks.defineLocale('af', {
4617 
+        months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
4618 
+        monthsShort : 'Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
4619 
+        weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
4620 
+        weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
4621 
+        weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
4622 
+        meridiemParse: /vm|nm/i,
4623 
+        isPM : function (input) {
4624 
+            return /^nm$/i.test(input);
4625 
+        },
4626 
+        meridiem : function (hours, minutes, isLower) {
4627 
+            if (hours < 12) {
4628 
+                return isLower ? 'vm' : 'VM';
4629 
+            } else {
4630 
+                return isLower ? 'nm' : 'NM';
4631 
+            }
4632 
+        },
4633 
+        longDateFormat : {
4634 
+            LT : 'HH:mm',
4635 
+            LTS : 'HH:mm:ss',
4636 
+            L : 'DD/MM/YYYY',
4637 
+            LL : 'D MMMM YYYY',
4638 
+            LLL : 'D MMMM YYYY HH:mm',
4639 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
4640 
+        },
4641 
+        calendar : {
4642 
+            sameDay : '[Vandag om] LT',
4643 
+            nextDay : '[Môre om] LT',
4644 
+            nextWeek : 'dddd [om] LT',
4645 
+            lastDay : '[Gister om] LT',
4646 
+            lastWeek : '[Laas] dddd [om] LT',
4647 
+            sameElse : 'L'
4648 
+        },
4649 
+        relativeTime : {
4650 
+            future : 'oor %s',
4651 
+            past : '%s gelede',
4652 
+            s : '\'n paar sekondes',
4653 
+            ss : '%d sekondes',
4654 
+            m : '\'n minuut',
4655 
+            mm : '%d minute',
4656 
+            h : '\'n uur',
4657 
+            hh : '%d ure',
4658 
+            d : '\'n dag',
4659 
+            dd : '%d dae',
4660 
+            M : '\'n maand',
4661 
+            MM : '%d maande',
4662 
+            y : '\'n jaar',
4663 
+            yy : '%d jaar'
4664 
+        },
4665 
+        dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
4666 
+        ordinal : function (number) {
4667 
+            return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
4668 
+        },
4669 
+        week : {
4670 
+            dow : 1, // Maandag is die eerste dag van die week.
4671 
+            doy : 4  // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
4672 
+        }
4673 
+    });
4674 
+
4675 
+    //! moment.js locale configuration
4676 
+
4677 
+    hooks.defineLocale('ar-dz', {
4678 
+        months : 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4679 
+        monthsShort : 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4680 
+        weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4681 
+        weekdaysShort : 'احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4682 
+        weekdaysMin : 'أح_إث_ثلا_أر_خم_جم_سب'.split('_'),
4683 
+        weekdaysParseExact : true,
4684 
+        longDateFormat : {
4685 
+            LT : 'HH:mm',
4686 
+            LTS : 'HH:mm:ss',
4687 
+            L : 'DD/MM/YYYY',
4688 
+            LL : 'D MMMM YYYY',
4689 
+            LLL : 'D MMMM YYYY HH:mm',
4690 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
4691 
+        },
4692 
+        calendar : {
4693 
+            sameDay: '[اليوم على الساعة] LT',
4694 
+            nextDay: '[غدا على الساعة] LT',
4695 
+            nextWeek: 'dddd [على الساعة] LT',
4696 
+            lastDay: '[أمس على الساعة] LT',
4697 
+            lastWeek: 'dddd [على الساعة] LT',
4698 
+            sameElse: 'L'
4699 
+        },
4700 
+        relativeTime : {
4701 
+            future : 'في %s',
4702 
+            past : 'منذ %s',
4703 
+            s : 'ثوان',
4704 
+            ss : '%d ثانية',
4705 
+            m : 'دقيقة',
4706 
+            mm : '%d دقائق',
4707 
+            h : 'ساعة',
4708 
+            hh : '%d ساعات',
4709 
+            d : 'يوم',
4710 
+            dd : '%d أيام',
4711 
+            M : 'شهر',
4712 
+            MM : '%d أشهر',
4713 
+            y : 'سنة',
4714 
+            yy : '%d سنوات'
4715 
+        },
4716 
+        week : {
4717 
+            dow : 0, // Sunday is the first day of the week.
4718 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
4719 
+        }
4720 
+    });
4721 
+
4722 
+    //! moment.js locale configuration
4723 
+
4724 
+    hooks.defineLocale('ar-kw', {
4725 
+        months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4726 
+        monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4727 
+        weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4728 
+        weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4729 
+        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4730 
+        weekdaysParseExact : true,
4731 
+        longDateFormat : {
4732 
+            LT : 'HH:mm',
4733 
+            LTS : 'HH:mm:ss',
4734 
+            L : 'DD/MM/YYYY',
4735 
+            LL : 'D MMMM YYYY',
4736 
+            LLL : 'D MMMM YYYY HH:mm',
4737 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
4738 
+        },
4739 
+        calendar : {
4740 
+            sameDay: '[اليوم على الساعة] LT',
4741 
+            nextDay: '[غدا على الساعة] LT',
4742 
+            nextWeek: 'dddd [على الساعة] LT',
4743 
+            lastDay: '[أمس على الساعة] LT',
4744 
+            lastWeek: 'dddd [على الساعة] LT',
4745 
+            sameElse: 'L'
4746 
+        },
4747 
+        relativeTime : {
4748 
+            future : 'في %s',
4749 
+            past : 'منذ %s',
4750 
+            s : 'ثوان',
4751 
+            ss : '%d ثانية',
4752 
+            m : 'دقيقة',
4753 
+            mm : '%d دقائق',
4754 
+            h : 'ساعة',
4755 
+            hh : '%d ساعات',
4756 
+            d : 'يوم',
4757 
+            dd : '%d أيام',
4758 
+            M : 'شهر',
4759 
+            MM : '%d أشهر',
4760 
+            y : 'سنة',
4761 
+            yy : '%d سنوات'
4762 
+        },
4763 
+        week : {
4764 
+            dow : 0, // Sunday is the first day of the week.
4765 
+            doy : 12  // The week that contains Jan 12th is the first week of the year.
4766 
+        }
4767 
+    });
4768 
+
4769 
+    //! moment.js locale configuration
4770 
+
4771 
+    var symbolMap = {
4772 
+        '1': '1',
4773 
+        '2': '2',
4774 
+        '3': '3',
4775 
+        '4': '4',
4776 
+        '5': '5',
4777 
+        '6': '6',
4778 
+        '7': '7',
4779 
+        '8': '8',
4780 
+        '9': '9',
4781 
+        '0': '0'
4782 
+    }, pluralForm = function (n) {
4783 
+        return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
4784 
+    }, plurals = {
4785 
+        s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
4786 
+        m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
4787 
+        h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
4788 
+        d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
4789 
+        M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
4790 
+        y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
4791 
+    }, pluralize = function (u) {
4792 
+        return function (number, withoutSuffix, string, isFuture) {
4793 
+            var f = pluralForm(number),
4794 
+                str = plurals[u][pluralForm(number)];
4795 
+            if (f === 2) {
4796 
+                str = str[withoutSuffix ? 0 : 1];
4797 
+            }
4798 
+            return str.replace(/%d/i, number);
4799 
+        };
4800 
+    }, months$1 = [
4801 
+        'يناير',
4802 
+        'فبراير',
4803 
+        'مارس',
4804 
+        'أبريل',
4805 
+        'مايو',
4806 
+        'يونيو',
4807 
+        'يوليو',
4808 
+        'أغسطس',
4809 
+        'سبتمبر',
4810 
+        'أكتوبر',
4811 
+        'نوفمبر',
4812 
+        'ديسمبر'
4813 
+    ];
4814 
+
4815 
+    hooks.defineLocale('ar-ly', {
4816 
+        months : months$1,
4817 
+        monthsShort : months$1,
4818 
+        weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4819 
+        weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4820 
+        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4821 
+        weekdaysParseExact : true,
4822 
+        longDateFormat : {
4823 
+            LT : 'HH:mm',
4824 
+            LTS : 'HH:mm:ss',
4825 
+            L : 'D/\u200FM/\u200FYYYY',
4826 
+            LL : 'D MMMM YYYY',
4827 
+            LLL : 'D MMMM YYYY HH:mm',
4828 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
4829 
+        },
4830 
+        meridiemParse: /ص|م/,
4831 
+        isPM : function (input) {
4832 
+            return 'م' === input;
4833 
+        },
4834 
+        meridiem : function (hour, minute, isLower) {
4835 
+            if (hour < 12) {
4836 
+                return 'ص';
4837 
+            } else {
4838 
+                return 'م';
4839 
+            }
4840 
+        },
4841 
+        calendar : {
4842 
+            sameDay: '[اليوم عند الساعة] LT',
4843 
+            nextDay: '[غدًا عند الساعة] LT',
4844 
+            nextWeek: 'dddd [عند الساعة] LT',
4845 
+            lastDay: '[أمس عند الساعة] LT',
4846 
+            lastWeek: 'dddd [عند الساعة] LT',
4847 
+            sameElse: 'L'
4848 
+        },
4849 
+        relativeTime : {
4850 
+            future : 'بعد %s',
4851 
+            past : 'منذ %s',
4852 
+            s : pluralize('s'),
4853 
+            ss : pluralize('s'),
4854 
+            m : pluralize('m'),
4855 
+            mm : pluralize('m'),
4856 
+            h : pluralize('h'),
4857 
+            hh : pluralize('h'),
4858 
+            d : pluralize('d'),
4859 
+            dd : pluralize('d'),
4860 
+            M : pluralize('M'),
4861 
+            MM : pluralize('M'),
4862 
+            y : pluralize('y'),
4863 
+            yy : pluralize('y')
4864 
+        },
4865 
+        preparse: function (string) {
4866 
+            return string.replace(/،/g, ',');
4867 
+        },
4868 
+        postformat: function (string) {
4869 
+            return string.replace(/\d/g, function (match) {
4870 
+                return symbolMap[match];
4871 
+            }).replace(/,/g, '،');
4872 
+        },
4873 
+        week : {
4874 
+            dow : 6, // Saturday is the first day of the week.
4875 
+            doy : 12  // The week that contains Jan 12th is the first week of the year.
4876 
+        }
4877 
+    });
4878 
+
4879 
+    //! moment.js locale configuration
4880 
+
4881 
+    hooks.defineLocale('ar-ma', {
4882 
+        months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4883 
+        monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
4884 
+        weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4885 
+        weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
4886 
+        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4887 
+        weekdaysParseExact : true,
4888 
+        longDateFormat : {
4889 
+            LT : 'HH:mm',
4890 
+            LTS : 'HH:mm:ss',
4891 
+            L : 'DD/MM/YYYY',
4892 
+            LL : 'D MMMM YYYY',
4893 
+            LLL : 'D MMMM YYYY HH:mm',
4894 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
4895 
+        },
4896 
+        calendar : {
4897 
+            sameDay: '[اليوم على الساعة] LT',
4898 
+            nextDay: '[غدا على الساعة] LT',
4899 
+            nextWeek: 'dddd [على الساعة] LT',
4900 
+            lastDay: '[أمس على الساعة] LT',
4901 
+            lastWeek: 'dddd [على الساعة] LT',
4902 
+            sameElse: 'L'
4903 
+        },
4904 
+        relativeTime : {
4905 
+            future : 'في %s',
4906 
+            past : 'منذ %s',
4907 
+            s : 'ثوان',
4908 
+            ss : '%d ثانية',
4909 
+            m : 'دقيقة',
4910 
+            mm : '%d دقائق',
4911 
+            h : 'ساعة',
4912 
+            hh : '%d ساعات',
4913 
+            d : 'يوم',
4914 
+            dd : '%d أيام',
4915 
+            M : 'شهر',
4916 
+            MM : '%d أشهر',
4917 
+            y : 'سنة',
4918 
+            yy : '%d سنوات'
4919 
+        },
4920 
+        week : {
4921 
+            dow : 6, // Saturday is the first day of the week.
4922 
+            doy : 12  // The week that contains Jan 12th is the first week of the year.
4923 
+        }
4924 
+    });
4925 
+
4926 
+    //! moment.js locale configuration
4927 
+
4928 
+    var symbolMap$1 = {
4929 
+        '1': '١',
4930 
+        '2': '٢',
4931 
+        '3': '٣',
4932 
+        '4': '٤',
4933 
+        '5': '٥',
4934 
+        '6': '٦',
4935 
+        '7': '٧',
4936 
+        '8': '٨',
4937 
+        '9': '٩',
4938 
+        '0': '٠'
4939 
+    }, numberMap = {
4940 
+        '١': '1',
4941 
+        '٢': '2',
4942 
+        '٣': '3',
4943 
+        '٤': '4',
4944 
+        '٥': '5',
4945 
+        '٦': '6',
4946 
+        '٧': '7',
4947 
+        '٨': '8',
4948 
+        '٩': '9',
4949 
+        '٠': '0'
4950 
+    };
4951 
+
4952 
+    hooks.defineLocale('ar-sa', {
4953 
+        months : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4954 
+        monthsShort : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
4955 
+        weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
4956 
+        weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
4957 
+        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
4958 
+        weekdaysParseExact : true,
4959 
+        longDateFormat : {
4960 
+            LT : 'HH:mm',
4961 
+            LTS : 'HH:mm:ss',
4962 
+            L : 'DD/MM/YYYY',
4963 
+            LL : 'D MMMM YYYY',
4964 
+            LLL : 'D MMMM YYYY HH:mm',
4965 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
4966 
+        },
4967 
+        meridiemParse: /ص|م/,
4968 
+        isPM : function (input) {
4969 
+            return 'م' === input;
4970 
+        },
4971 
+        meridiem : function (hour, minute, isLower) {
4972 
+            if (hour < 12) {
4973 
+                return 'ص';
4974 
+            } else {
4975 
+                return 'م';
4976 
+            }
4977 
+        },
4978 
+        calendar : {
4979 
+            sameDay: '[اليوم على الساعة] LT',
4980 
+            nextDay: '[غدا على الساعة] LT',
4981 
+            nextWeek: 'dddd [على الساعة] LT',
4982 
+            lastDay: '[أمس على الساعة] LT',
4983 
+            lastWeek: 'dddd [على الساعة] LT',
4984 
+            sameElse: 'L'
4985 
+        },
4986 
+        relativeTime : {
4987 
+            future : 'في %s',
4988 
+            past : 'منذ %s',
4989 
+            s : 'ثوان',
4990 
+            ss : '%d ثانية',
4991 
+            m : 'دقيقة',
4992 
+            mm : '%d دقائق',
4993 
+            h : 'ساعة',
4994 
+            hh : '%d ساعات',
4995 
+            d : 'يوم',
4996 
+            dd : '%d أيام',
4997 
+            M : 'شهر',
4998 
+            MM : '%d أشهر',
4999 
+            y : 'سنة',
5000 
+            yy : '%d سنوات'
5001 
+        },
5002 
+        preparse: function (string) {
5003 
+            return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
5004 
+                return numberMap[match];
5005 
+            }).replace(/،/g, ',');
5006 
+        },
5007 
+        postformat: function (string) {
5008 
+            return string.replace(/\d/g, function (match) {
5009 
+                return symbolMap$1[match];
5010 
+            }).replace(/,/g, '،');
5011 
+        },
5012 
+        week : {
5013 
+            dow : 0, // Sunday is the first day of the week.
5014 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
5015 
+        }
5016 
+    });
5017 
+
5018 
+    //! moment.js locale configuration
5019 
+
5020 
+    hooks.defineLocale('ar-tn', {
5021 
+        months: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
5022 
+        monthsShort: 'جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
5023 
+        weekdays: 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5024 
+        weekdaysShort: 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
5025 
+        weekdaysMin: 'ح_ن_ث_ر_خ_ج_س'.split('_'),
5026 
+        weekdaysParseExact : true,
5027 
+        longDateFormat: {
5028 
+            LT: 'HH:mm',
5029 
+            LTS: 'HH:mm:ss',
5030 
+            L: 'DD/MM/YYYY',
5031 
+            LL: 'D MMMM YYYY',
5032 
+            LLL: 'D MMMM YYYY HH:mm',
5033 
+            LLLL: 'dddd D MMMM YYYY HH:mm'
5034 
+        },
5035 
+        calendar: {
5036 
+            sameDay: '[اليوم على الساعة] LT',
5037 
+            nextDay: '[غدا على الساعة] LT',
5038 
+            nextWeek: 'dddd [على الساعة] LT',
5039 
+            lastDay: '[أمس على الساعة] LT',
5040 
+            lastWeek: 'dddd [على الساعة] LT',
5041 
+            sameElse: 'L'
5042 
+        },
5043 
+        relativeTime: {
5044 
+            future: 'في %s',
5045 
+            past: 'منذ %s',
5046 
+            s: 'ثوان',
5047 
+            ss : '%d ثانية',
5048 
+            m: 'دقيقة',
5049 
+            mm: '%d دقائق',
5050 
+            h: 'ساعة',
5051 
+            hh: '%d ساعات',
5052 
+            d: 'يوم',
5053 
+            dd: '%d أيام',
5054 
+            M: 'شهر',
5055 
+            MM: '%d أشهر',
5056 
+            y: 'سنة',
5057 
+            yy: '%d سنوات'
5058 
+        },
5059 
+        week: {
5060 
+            dow: 1, // Monday is the first day of the week.
5061 
+            doy: 4 // The week that contains Jan 4th is the first week of the year.
5062 
+        }
5063 
+    });
5064 
+
5065 
+    //! moment.js locale configuration
5066 
+
5067 
+    var symbolMap$2 = {
5068 
+        '1': '١',
5069 
+        '2': '٢',
5070 
+        '3': '٣',
5071 
+        '4': '٤',
5072 
+        '5': '٥',
5073 
+        '6': '٦',
5074 
+        '7': '٧',
5075 
+        '8': '٨',
5076 
+        '9': '٩',
5077 
+        '0': '٠'
5078 
+    }, numberMap$1 = {
5079 
+        '١': '1',
5080 
+        '٢': '2',
5081 
+        '٣': '3',
5082 
+        '٤': '4',
5083 
+        '٥': '5',
5084 
+        '٦': '6',
5085 
+        '٧': '7',
5086 
+        '٨': '8',
5087 
+        '٩': '9',
5088 
+        '٠': '0'
5089 
+    }, pluralForm$1 = function (n) {
5090 
+        return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
5091 
+    }, plurals$1 = {
5092 
+        s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
5093 
+        m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
5094 
+        h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
5095 
+        d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
5096 
+        M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
5097 
+        y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
5098 
+    }, pluralize$1 = function (u) {
5099 
+        return function (number, withoutSuffix, string, isFuture) {
5100 
+            var f = pluralForm$1(number),
5101 
+                str = plurals$1[u][pluralForm$1(number)];
5102 
+            if (f === 2) {
5103 
+                str = str[withoutSuffix ? 0 : 1];
5104 
+            }
5105 
+            return str.replace(/%d/i, number);
5106 
+        };
5107 
+    }, months$2 = [
5108 
+        'يناير',
5109 
+        'فبراير',
5110 
+        'مارس',
5111 
+        'أبريل',
5112 
+        'مايو',
5113 
+        'يونيو',
5114 
+        'يوليو',
5115 
+        'أغسطس',
5116 
+        'سبتمبر',
5117 
+        'أكتوبر',
5118 
+        'نوفمبر',
5119 
+        'ديسمبر'
5120 
+    ];
5121 
+
5122 
+    hooks.defineLocale('ar', {
5123 
+        months : months$2,
5124 
+        monthsShort : months$2,
5125 
+        weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
5126 
+        weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
5127 
+        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
5128 
+        weekdaysParseExact : true,
5129 
+        longDateFormat : {
5130 
+            LT : 'HH:mm',
5131 
+            LTS : 'HH:mm:ss',
5132 
+            L : 'D/\u200FM/\u200FYYYY',
5133 
+            LL : 'D MMMM YYYY',
5134 
+            LLL : 'D MMMM YYYY HH:mm',
5135 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
5136 
+        },
5137 
+        meridiemParse: /ص|م/,
5138 
+        isPM : function (input) {
5139 
+            return 'م' === input;
5140 
+        },
5141 
+        meridiem : function (hour, minute, isLower) {
5142 
+            if (hour < 12) {
5143 
+                return 'ص';
5144 
+            } else {
5145 
+                return 'م';
5146 
+            }
5147 
+        },
5148 
+        calendar : {
5149 
+            sameDay: '[اليوم عند الساعة] LT',
5150 
+            nextDay: '[غدًا عند الساعة] LT',
5151 
+            nextWeek: 'dddd [عند الساعة] LT',
5152 
+            lastDay: '[أمس عند الساعة] LT',
5153 
+            lastWeek: 'dddd [عند الساعة] LT',
5154 
+            sameElse: 'L'
5155 
+        },
5156 
+        relativeTime : {
5157 
+            future : 'بعد %s',
5158 
+            past : 'منذ %s',
5159 
+            s : pluralize$1('s'),
5160 
+            ss : pluralize$1('s'),
5161 
+            m : pluralize$1('m'),
5162 
+            mm : pluralize$1('m'),
5163 
+            h : pluralize$1('h'),
5164 
+            hh : pluralize$1('h'),
5165 
+            d : pluralize$1('d'),
5166 
+            dd : pluralize$1('d'),
5167 
+            M : pluralize$1('M'),
5168 
+            MM : pluralize$1('M'),
5169 
+            y : pluralize$1('y'),
5170 
+            yy : pluralize$1('y')
5171 
+        },
5172 
+        preparse: function (string) {
5173 
+            return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
5174 
+                return numberMap$1[match];
5175 
+            }).replace(/،/g, ',');
5176 
+        },
5177 
+        postformat: function (string) {
5178 
+            return string.replace(/\d/g, function (match) {
5179 
+                return symbolMap$2[match];
5180 
+            }).replace(/,/g, '،');
5181 
+        },
5182 
+        week : {
5183 
+            dow : 6, // Saturday is the first day of the week.
5184 
+            doy : 12  // The week that contains Jan 12th is the first week of the year.
5185 
+        }
5186 
+    });
5187 
+
5188 
+    //! moment.js locale configuration
5189 
+
5190 
+    var suffixes = {
5191 
+        1: '-inci',
5192 
+        5: '-inci',
5193 
+        8: '-inci',
5194 
+        70: '-inci',
5195 
+        80: '-inci',
5196 
+        2: '-nci',
5197 
+        7: '-nci',
5198 
+        20: '-nci',
5199 
+        50: '-nci',
5200 
+        3: '-üncü',
5201 
+        4: '-üncü',
5202 
+        100: '-üncü',
5203 
+        6: '-ncı',
5204 
+        9: '-uncu',
5205 
+        10: '-uncu',
5206 
+        30: '-uncu',
5207 
+        60: '-ıncı',
5208 
+        90: '-ıncı'
5209 
+    };
5210 
+
5211 
+    hooks.defineLocale('az', {
5212 
+        months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
5213 
+        monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
5214 
+        weekdays : 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
5215 
+        weekdaysShort : 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
5216 
+        weekdaysMin : 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
5217 
+        weekdaysParseExact : true,
5218 
+        longDateFormat : {
5219 
+            LT : 'HH:mm',
5220 
+            LTS : 'HH:mm:ss',
5221 
+            L : 'DD.MM.YYYY',
5222 
+            LL : 'D MMMM YYYY',
5223 
+            LLL : 'D MMMM YYYY HH:mm',
5224 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
5225 
+        },
5226 
+        calendar : {
5227 
+            sameDay : '[bugün saat] LT',
5228 
+            nextDay : '[sabah saat] LT',
5229 
+            nextWeek : '[gələn həftə] dddd [saat] LT',
5230 
+            lastDay : '[dünən] LT',
5231 
+            lastWeek : '[keçən həftə] dddd [saat] LT',
5232 
+            sameElse : 'L'
5233 
+        },
5234 
+        relativeTime : {
5235 
+            future : '%s sonra',
5236 
+            past : '%s əvvəl',
5237 
+            s : 'birneçə saniyə',
5238 
+            ss : '%d saniyə',
5239 
+            m : 'bir dəqiqə',
5240 
+            mm : '%d dəqiqə',
5241 
+            h : 'bir saat',
5242 
+            hh : '%d saat',
5243 
+            d : 'bir gün',
5244 
+            dd : '%d gün',
5245 
+            M : 'bir ay',
5246 
+            MM : '%d ay',
5247 
+            y : 'bir il',
5248 
+            yy : '%d il'
5249 
+        },
5250 
+        meridiemParse: /gecə|səhər|gündüz|axşam/,
5251 
+        isPM : function (input) {
5252 
+            return /^(gündüz|axşam)$/.test(input);
5253 
+        },
5254 
+        meridiem : function (hour, minute, isLower) {
5255 
+            if (hour < 4) {
5256 
+                return 'gecə';
5257 
+            } else if (hour < 12) {
5258 
+                return 'səhər';
5259 
+            } else if (hour < 17) {
5260 
+                return 'gündüz';
5261 
+            } else {
5262 
+                return 'axşam';
5263 
+            }
5264 
+        },
5265 
+        dayOfMonthOrdinalParse: /\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,
5266 
+        ordinal : function (number) {
5267 
+            if (number === 0) {  // special case for zero
5268 
+                return number + '-ıncı';
5269 
+            }
5270 
+            var a = number % 10,
5271 
+                b = number % 100 - a,
5272 
+                c = number >= 100 ? 100 : null;
5273 
+            return number + (suffixes[a] || suffixes[b] || suffixes[c]);
5274 
+        },
5275 
+        week : {
5276 
+            dow : 1, // Monday is the first day of the week.
5277 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
5278 
+        }
5279 
+    });
5280 
+
5281 
+    //! moment.js locale configuration
5282 
+
5283 
+    function plural(word, num) {
5284 
+        var forms = word.split('_');
5285 
+        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]);
5286 
+    }
5287 
+    function relativeTimeWithPlural(number, withoutSuffix, key) {
5288 
+        var format = {
5289 
+            'ss': withoutSuffix ? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
5290 
+            'mm': withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
5291 
+            'hh': withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
5292 
+            'dd': 'дзень_дні_дзён',
5293 
+            'MM': 'месяц_месяцы_месяцаў',
5294 
+            'yy': 'год_гады_гадоў'
5295 
+        };
5296 
+        if (key === 'm') {
5297 
+            return withoutSuffix ? 'хвіліна' : 'хвіліну';
5298 
+        }
5299 
+        else if (key === 'h') {
5300 
+            return withoutSuffix ? 'гадзіна' : 'гадзіну';
5301 
+        }
5302 
+        else {
5303 
+            return number + ' ' + plural(format[key], +number);
5304 
+        }
5305 
+    }
5306 
+
5307 
+    hooks.defineLocale('be', {
5308 
+        months : {
5309 
+            format: 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_'),
5310 
+            standalone: 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_')
5311 
+        },
5312 
+        monthsShort : 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split('_'),
5313 
+        weekdays : {
5314 
+            format: 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_'),
5315 
+            standalone: 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
5316 
+            isFormat: /\[ ?[Ууў] ?(?:мінулую|наступную)? ?\] ?dddd/
5317 
+        },
5318 
+        weekdaysShort : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
5319 
+        weekdaysMin : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
5320 
+        longDateFormat : {
5321 
+            LT : 'HH:mm',
5322 
+            LTS : 'HH:mm:ss',
5323 
+            L : 'DD.MM.YYYY',
5324 
+            LL : 'D MMMM YYYY г.',
5325 
+            LLL : 'D MMMM YYYY г., HH:mm',
5326 
+            LLLL : 'dddd, D MMMM YYYY г., HH:mm'
5327 
+        },
5328 
+        calendar : {
5329 
+            sameDay: '[Сёння ў] LT',
5330 
+            nextDay: '[Заўтра ў] LT',
5331 
+            lastDay: '[Учора ў] LT',
5332 
+            nextWeek: function () {
5333 
+                return '[У] dddd [ў] LT';
5334 
+            },
5335 
+            lastWeek: function () {
5336 
+                switch (this.day()) {
5337 
+                    case 0:
5338 
+                    case 3:
5339 
+                    case 5:
5340 
+                    case 6:
5341 
+                        return '[У мінулую] dddd [ў] LT';
5342 
+                    case 1:
5343 
+                    case 2:
5344 
+                    case 4:
5345 
+                        return '[У мінулы] dddd [ў] LT';
5346 
+                }
5347 
+            },
5348 
+            sameElse: 'L'
5349 
+        },
5350 
+        relativeTime : {
5351 
+            future : 'праз %s',
5352 
+            past : '%s таму',
5353 
+            s : 'некалькі секунд',
5354 
+            m : relativeTimeWithPlural,
5355 
+            mm : relativeTimeWithPlural,
5356 
+            h : relativeTimeWithPlural,
5357 
+            hh : relativeTimeWithPlural,
5358 
+            d : 'дзень',
5359 
+            dd : relativeTimeWithPlural,
5360 
+            M : 'месяц',
5361 
+            MM : relativeTimeWithPlural,
5362 
+            y : 'год',
5363 
+            yy : relativeTimeWithPlural
5364 
+        },
5365 
+        meridiemParse: /ночы|раніцы|дня|вечара/,
5366 
+        isPM : function (input) {
5367 
+            return /^(дня|вечара)$/.test(input);
5368 
+        },
5369 
+        meridiem : function (hour, minute, isLower) {
5370 
+            if (hour < 4) {
5371 
+                return 'ночы';
5372 
+            } else if (hour < 12) {
5373 
+                return 'раніцы';
5374 
+            } else if (hour < 17) {
5375 
+                return 'дня';
5376 
+            } else {
5377 
+                return 'вечара';
5378 
+            }
5379 
+        },
5380 
+        dayOfMonthOrdinalParse: /\d{1,2}-(і|ы|га)/,
5381 
+        ordinal: function (number, period) {
5382 
+            switch (period) {
5383 
+                case 'M':
5384 
+                case 'd':
5385 
+                case 'DDD':
5386 
+                case 'w':
5387 
+                case 'W':
5388 
+                    return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-і' : number + '-ы';
5389 
+                case 'D':
5390 
+                    return number + '-га';
5391 
+                default:
5392 
+                    return number;
5393 
+            }
5394 
+        },
5395 
+        week : {
5396 
+            dow : 1, // Monday is the first day of the week.
5397 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
5398 
+        }
5399 
+    });
5400 
+
5401 
+    //! moment.js locale configuration
5402 
+
5403 
+    hooks.defineLocale('bg', {
5404 
+        months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
5405 
+        monthsShort : 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
5406 
+        weekdays : 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
5407 
+        weekdaysShort : 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
5408 
+        weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
5409 
+        longDateFormat : {
5410 
+            LT : 'H:mm',
5411 
+            LTS : 'H:mm:ss',
5412 
+            L : 'D.MM.YYYY',
5413 
+            LL : 'D MMMM YYYY',
5414 
+            LLL : 'D MMMM YYYY H:mm',
5415 
+            LLLL : 'dddd, D MMMM YYYY H:mm'
5416 
+        },
5417 
+        calendar : {
5418 
+            sameDay : '[Днес в] LT',
5419 
+            nextDay : '[Утре в] LT',
5420 
+            nextWeek : 'dddd [в] LT',
5421 
+            lastDay : '[Вчера в] LT',
5422 
+            lastWeek : function () {
5423 
+                switch (this.day()) {
5424 
+                    case 0:
5425 
+                    case 3:
5426 
+                    case 6:
5427 
+                        return '[В изминалата] dddd [в] LT';
5428 
+                    case 1:
5429 
+                    case 2:
5430 
+                    case 4:
5431 
+                    case 5:
5432 
+                        return '[В изминалия] dddd [в] LT';
5433 
+                }
5434 
+            },
5435 
+            sameElse : 'L'
5436 
+        },
5437 
+        relativeTime : {
5438 
+            future : 'след %s',
5439 
+            past : 'преди %s',
5440 
+            s : 'няколко секунди',
5441 
+            ss : '%d секунди',
5442 
+            m : 'минута',
5443 
+            mm : '%d минути',
5444 
+            h : 'час',
5445 
+            hh : '%d часа',
5446 
+            d : 'ден',
5447 
+            dd : '%d дни',
5448 
+            M : 'месец',
5449 
+            MM : '%d месеца',
5450 
+            y : 'година',
5451 
+            yy : '%d години'
5452 
+        },
5453 
+        dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
5454 
+        ordinal : function (number) {
5455 
+            var lastDigit = number % 10,
5456 
+                last2Digits = number % 100;
5457 
+            if (number === 0) {
5458 
+                return number + '-ев';
5459 
+            } else if (last2Digits === 0) {
5460 
+                return number + '-ен';
5461 
+            } else if (last2Digits > 10 && last2Digits < 20) {
5462 
+                return number + '-ти';
5463 
+            } else if (lastDigit === 1) {
5464 
+                return number + '-ви';
5465 
+            } else if (lastDigit === 2) {
5466 
+                return number + '-ри';
5467 
+            } else if (lastDigit === 7 || lastDigit === 8) {
5468 
+                return number + '-ми';
5469 
+            } else {
5470 
+                return number + '-ти';
5471 
+            }
5472 
+        },
5473 
+        week : {
5474 
+            dow : 1, // Monday is the first day of the week.
5475 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
5476 
+        }
5477 
+    });
5478 
+
5479 
+    //! moment.js locale configuration
5480 
+
5481 
+    hooks.defineLocale('bm', {
5482 
+        months : 'Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo'.split('_'),
5483 
+        monthsShort : 'Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des'.split('_'),
5484 
+        weekdays : 'Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri'.split('_'),
5485 
+        weekdaysShort : 'Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib'.split('_'),
5486 
+        weekdaysMin : 'Ka_Nt_Ta_Ar_Al_Ju_Si'.split('_'),
5487 
+        longDateFormat : {
5488 
+            LT : 'HH:mm',
5489 
+            LTS : 'HH:mm:ss',
5490 
+            L : 'DD/MM/YYYY',
5491 
+            LL : 'MMMM [tile] D [san] YYYY',
5492 
+            LLL : 'MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm',
5493 
+            LLLL : 'dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm'
5494 
+        },
5495 
+        calendar : {
5496 
+            sameDay : '[Bi lɛrɛ] LT',
5497 
+            nextDay : '[Sini lɛrɛ] LT',
5498 
+            nextWeek : 'dddd [don lɛrɛ] LT',
5499 
+            lastDay : '[Kunu lɛrɛ] LT',
5500 
+            lastWeek : 'dddd [tɛmɛnen lɛrɛ] LT',
5501 
+            sameElse : 'L'
5502 
+        },
5503 
+        relativeTime : {
5504 
+            future : '%s kɔnɔ',
5505 
+            past : 'a bɛ %s bɔ',
5506 
+            s : 'sanga dama dama',
5507 
+            ss : 'sekondi %d',
5508 
+            m : 'miniti kelen',
5509 
+            mm : 'miniti %d',
5510 
+            h : 'lɛrɛ kelen',
5511 
+            hh : 'lɛrɛ %d',
5512 
+            d : 'tile kelen',
5513 
+            dd : 'tile %d',
5514 
+            M : 'kalo kelen',
5515 
+            MM : 'kalo %d',
5516 
+            y : 'san kelen',
5517 
+            yy : 'san %d'
5518 
+        },
5519 
+        week : {
5520 
+            dow : 1, // Monday is the first day of the week.
5521 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
5522 
+        }
5523 
+    });
5524 
+
5525 
+    //! moment.js locale configuration
5526 
+
5527 
+    var symbolMap$3 = {
5528 
+        '1': '১',
5529 
+        '2': '২',
5530 
+        '3': '৩',
5531 
+        '4': '৪',
5532 
+        '5': '৫',
5533 
+        '6': '৬',
5534 
+        '7': '৭',
5535 
+        '8': '৮',
5536 
+        '9': '৯',
5537 
+        '0': '০'
5538 
+    },
5539 
+    numberMap$2 = {
5540 
+        '১': '1',
5541 
+        '২': '2',
5542 
+        '৩': '3',
5543 
+        '৪': '4',
5544 
+        '৫': '5',
5545 
+        '৬': '6',
5546 
+        '৭': '7',
5547 
+        '৮': '8',
5548 
+        '৯': '9',
5549 
+        '০': '0'
5550 
+    };
5551 
+
5552 
+    hooks.defineLocale('bn', {
5553 
+        months : 'জানুয়ারী_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split('_'),
5554 
+        monthsShort : 'জানু_ফেব_মার্চ_এপ্র_মে_জুন_জুল_আগ_সেপ্ট_অক্টো_নভে_ডিসে'.split('_'),
5555 
+        weekdays : 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার'.split('_'),
5556 
+        weekdaysShort : 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি'.split('_'),
5557 
+        weekdaysMin : 'রবি_সোম_মঙ্গ_বুধ_বৃহঃ_শুক্র_শনি'.split('_'),
5558 
+        longDateFormat : {
5559 
+            LT : 'A h:mm সময়',
5560 
+            LTS : 'A h:mm:ss সময়',
5561 
+            L : 'DD/MM/YYYY',
5562 
+            LL : 'D MMMM YYYY',
5563 
+            LLL : 'D MMMM YYYY, A h:mm সময়',
5564 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm সময়'
5565 
+        },
5566 
+        calendar : {
5567 
+            sameDay : '[আজ] LT',
5568 
+            nextDay : '[আগামীকাল] LT',
5569 
+            nextWeek : 'dddd, LT',
5570 
+            lastDay : '[গতকাল] LT',
5571 
+            lastWeek : '[গত] dddd, LT',
5572 
+            sameElse : 'L'
5573 
+        },
5574 
+        relativeTime : {
5575 
+            future : '%s পরে',
5576 
+            past : '%s আগে',
5577 
+            s : 'কয়েক সেকেন্ড',
5578 
+            ss : '%d সেকেন্ড',
5579 
+            m : 'এক মিনিট',
5580 
+            mm : '%d মিনিট',
5581 
+            h : 'এক ঘন্টা',
5582 
+            hh : '%d ঘন্টা',
5583 
+            d : 'এক দিন',
5584 
+            dd : '%d দিন',
5585 
+            M : 'এক মাস',
5586 
+            MM : '%d মাস',
5587 
+            y : 'এক বছর',
5588 
+            yy : '%d বছর'
5589 
+        },
5590 
+        preparse: function (string) {
5591 
+            return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
5592 
+                return numberMap$2[match];
5593 
+            });
5594 
+        },
5595 
+        postformat: function (string) {
5596 
+            return string.replace(/\d/g, function (match) {
5597 
+                return symbolMap$3[match];
5598 
+            });
5599 
+        },
5600 
+        meridiemParse: /রাত|সকাল|দুপুর|বিকাল|রাত/,
5601 
+        meridiemHour : function (hour, meridiem) {
5602 
+            if (hour === 12) {
5603 
+                hour = 0;
5604 
+            }
5605 
+            if ((meridiem === 'রাত' && hour >= 4) ||
5606 
+                    (meridiem === 'দুপুর' && hour < 5) ||
5607 
+                    meridiem === 'বিকাল') {
5608 
+                return hour + 12;
5609 
+            } else {
5610 
+                return hour;
5611 
+            }
5612 
+        },
5613 
+        meridiem : function (hour, minute, isLower) {
5614 
+            if (hour < 4) {
5615 
+                return 'রাত';
5616 
+            } else if (hour < 10) {
5617 
+                return 'সকাল';
5618 
+            } else if (hour < 17) {
5619 
+                return 'দুপুর';
5620 
+            } else if (hour < 20) {
5621 
+                return 'বিকাল';
5622 
+            } else {
5623 
+                return 'রাত';
5624 
+            }
5625 
+        },
5626 
+        week : {
5627 
+            dow : 0, // Sunday is the first day of the week.
5628 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
5629 
+        }
5630 
+    });
5631 
+
5632 
+    //! moment.js locale configuration
5633 
+
5634 
+    var symbolMap$4 = {
5635 
+        '1': '༡',
5636 
+        '2': '༢',
5637 
+        '3': '༣',
5638 
+        '4': '༤',
5639 
+        '5': '༥',
5640 
+        '6': '༦',
5641 
+        '7': '༧',
5642 
+        '8': '༨',
5643 
+        '9': '༩',
5644 
+        '0': '༠'
5645 
+    },
5646 
+    numberMap$3 = {
5647 
+        '༡': '1',
5648 
+        '༢': '2',
5649 
+        '༣': '3',
5650 
+        '༤': '4',
5651 
+        '༥': '5',
5652 
+        '༦': '6',
5653 
+        '༧': '7',
5654 
+        '༨': '8',
5655 
+        '༩': '9',
5656 
+        '༠': '0'
5657 
+    };
5658 
+
5659 
+    hooks.defineLocale('bo', {
5660 
+        months : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
5661 
+        monthsShort : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
5662 
+        weekdays : 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
5663 
+        weekdaysShort : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
5664 
+        weekdaysMin : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
5665 
+        longDateFormat : {
5666 
+            LT : 'A h:mm',
5667 
+            LTS : 'A h:mm:ss',
5668 
+            L : 'DD/MM/YYYY',
5669 
+            LL : 'D MMMM YYYY',
5670 
+            LLL : 'D MMMM YYYY, A h:mm',
5671 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm'
5672 
+        },
5673 
+        calendar : {
5674 
+            sameDay : '[དི་རིང] LT',
5675 
+            nextDay : '[སང་ཉིན] LT',
5676 
+            nextWeek : '[བདུན་ཕྲག་རྗེས་མ], LT',
5677 
+            lastDay : '[ཁ་སང] LT',
5678 
+            lastWeek : '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
5679 
+            sameElse : 'L'
5680 
+        },
5681 
+        relativeTime : {
5682 
+            future : '%s ལ་',
5683 
+            past : '%s སྔན་ལ',
5684 
+            s : 'ལམ་སང',
5685 
+            ss : '%d སྐར་ཆ།',
5686 
+            m : 'སྐར་མ་གཅིག',
5687 
+            mm : '%d སྐར་མ',
5688 
+            h : 'ཆུ་ཚོད་གཅིག',
5689 
+            hh : '%d ཆུ་ཚོད',
5690 
+            d : 'ཉིན་གཅིག',
5691 
+            dd : '%d ཉིན་',
5692 
+            M : 'ཟླ་བ་གཅིག',
5693 
+            MM : '%d ཟླ་བ',
5694 
+            y : 'ལོ་གཅིག',
5695 
+            yy : '%d ལོ'
5696 
+        },
5697 
+        preparse: function (string) {
5698 
+            return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
5699 
+                return numberMap$3[match];
5700 
+            });
5701 
+        },
5702 
+        postformat: function (string) {
5703 
+            return string.replace(/\d/g, function (match) {
5704 
+                return symbolMap$4[match];
5705 
+            });
5706 
+        },
5707 
+        meridiemParse: /མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,
5708 
+        meridiemHour : function (hour, meridiem) {
5709 
+            if (hour === 12) {
5710 
+                hour = 0;
5711 
+            }
5712 
+            if ((meridiem === 'མཚན་མོ' && hour >= 4) ||
5713 
+                    (meridiem === 'ཉིན་གུང' && hour < 5) ||
5714 
+                    meridiem === 'དགོང་དག') {
5715 
+                return hour + 12;
5716 
+            } else {
5717 
+                return hour;
5718 
+            }
5719 
+        },
5720 
+        meridiem : function (hour, minute, isLower) {
5721 
+            if (hour < 4) {
5722 
+                return 'མཚན་མོ';
5723 
+            } else if (hour < 10) {
5724 
+                return 'ཞོགས་ཀས';
5725 
+            } else if (hour < 17) {
5726 
+                return 'ཉིན་གུང';
5727 
+            } else if (hour < 20) {
5728 
+                return 'དགོང་དག';
5729 
+            } else {
5730 
+                return 'མཚན་མོ';
5731 
+            }
5732 
+        },
5733 
+        week : {
5734 
+            dow : 0, // Sunday is the first day of the week.
5735 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
5736 
+        }
5737 
+    });
5738 
+
5739 
+    //! moment.js locale configuration
5740 
+
5741 
+    function relativeTimeWithMutation(number, withoutSuffix, key) {
5742 
+        var format = {
5743 
+            'mm': 'munutenn',
5744 
+            'MM': 'miz',
5745 
+            'dd': 'devezh'
5746 
+        };
5747 
+        return number + ' ' + mutation(format[key], number);
5748 
+    }
5749 
+    function specialMutationForYears(number) {
5750 
+        switch (lastNumber(number)) {
5751 
+            case 1:
5752 
+            case 3:
5753 
+            case 4:
5754 
+            case 5:
5755 
+            case 9:
5756 
+                return number + ' bloaz';
5757 
+            default:
5758 
+                return number + ' vloaz';
5759 
+        }
5760 
+    }
5761 
+    function lastNumber(number) {
5762 
+        if (number > 9) {
5763 
+            return lastNumber(number % 10);
5764 
+        }
5765 
+        return number;
5766 
+    }
5767 
+    function mutation(text, number) {
5768 
+        if (number === 2) {
5769 
+            return softMutation(text);
5770 
+        }
5771 
+        return text;
5772 
+    }
5773 
+    function softMutation(text) {
5774 
+        var mutationTable = {
5775 
+            'm': 'v',
5776 
+            'b': 'v',
5777 
+            'd': 'z'
5778 
+        };
5779 
+        if (mutationTable[text.charAt(0)] === undefined) {
5780 
+            return text;
5781 
+        }
5782 
+        return mutationTable[text.charAt(0)] + text.substring(1);
5783 
+    }
5784 
+
5785 
+    hooks.defineLocale('br', {
5786 
+        months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
5787 
+        monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
5788 
+        weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
5789 
+        weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
5790 
+        weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
5791 
+        weekdaysParseExact : true,
5792 
+        longDateFormat : {
5793 
+            LT : 'h[e]mm A',
5794 
+            LTS : 'h[e]mm:ss A',
5795 
+            L : 'DD/MM/YYYY',
5796 
+            LL : 'D [a viz] MMMM YYYY',
5797 
+            LLL : 'D [a viz] MMMM YYYY h[e]mm A',
5798 
+            LLLL : 'dddd, D [a viz] MMMM YYYY h[e]mm A'
5799 
+        },
5800 
+        calendar : {
5801 
+            sameDay : '[Hiziv da] LT',
5802 
+            nextDay : '[Warc\'hoazh da] LT',
5803 
+            nextWeek : 'dddd [da] LT',
5804 
+            lastDay : '[Dec\'h da] LT',
5805 
+            lastWeek : 'dddd [paset da] LT',
5806 
+            sameElse : 'L'
5807 
+        },
5808 
+        relativeTime : {
5809 
+            future : 'a-benn %s',
5810 
+            past : '%s \'zo',
5811 
+            s : 'un nebeud segondennoù',
5812 
+            ss : '%d eilenn',
5813 
+            m : 'ur vunutenn',
5814 
+            mm : relativeTimeWithMutation,
5815 
+            h : 'un eur',
5816 
+            hh : '%d eur',
5817 
+            d : 'un devezh',
5818 
+            dd : relativeTimeWithMutation,
5819 
+            M : 'ur miz',
5820 
+            MM : relativeTimeWithMutation,
5821 
+            y : 'ur bloaz',
5822 
+            yy : specialMutationForYears
5823 
+        },
5824 
+        dayOfMonthOrdinalParse: /\d{1,2}(añ|vet)/,
5825 
+        ordinal : function (number) {
5826 
+            var output = (number === 1) ? 'añ' : 'vet';
5827 
+            return number + output;
5828 
+        },
5829 
+        week : {
5830 
+            dow : 1, // Monday is the first day of the week.
5831 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
5832 
+        }
5833 
+    });
5834 
+
5835 
+    //! moment.js locale configuration
5836 
+
5837 
+    function translate(number, withoutSuffix, key) {
5838 
+        var result = number + ' ';
5839 
+        switch (key) {
5840 
+            case 'ss':
5841 
+                if (number === 1) {
5842 
+                    result += 'sekunda';
5843 
+                } else if (number === 2 || number === 3 || number === 4) {
5844 
+                    result += 'sekunde';
5845 
+                } else {
5846 
+                    result += 'sekundi';
5847 
+                }
5848 
+                return result;
5849 
+            case 'm':
5850 
+                return withoutSuffix ? 'jedna minuta' : 'jedne minute';
5851 
+            case 'mm':
5852 
+                if (number === 1) {
5853 
+                    result += 'minuta';
5854 
+                } else if (number === 2 || number === 3 || number === 4) {
5855 
+                    result += 'minute';
5856 
+                } else {
5857 
+                    result += 'minuta';
5858 
+                }
5859 
+                return result;
5860 
+            case 'h':
5861 
+                return withoutSuffix ? 'jedan sat' : 'jednog sata';
5862 
+            case 'hh':
5863 
+                if (number === 1) {
5864 
+                    result += 'sat';
5865 
+                } else if (number === 2 || number === 3 || number === 4) {
5866 
+                    result += 'sata';
5867 
+                } else {
5868 
+                    result += 'sati';
5869 
+                }
5870 
+                return result;
5871 
+            case 'dd':
5872 
+                if (number === 1) {
5873 
+                    result += 'dan';
5874 
+                } else {
5875 
+                    result += 'dana';
5876 
+                }
5877 
+                return result;
5878 
+            case 'MM':
5879 
+                if (number === 1) {
5880 
+                    result += 'mjesec';
5881 
+                } else if (number === 2 || number === 3 || number === 4) {
5882 
+                    result += 'mjeseca';
5883 
+                } else {
5884 
+                    result += 'mjeseci';
5885 
+                }
5886 
+                return result;
5887 
+            case 'yy':
5888 
+                if (number === 1) {
5889 
+                    result += 'godina';
5890 
+                } else if (number === 2 || number === 3 || number === 4) {
5891 
+                    result += 'godine';
5892 
+                } else {
5893 
+                    result += 'godina';
5894 
+                }
5895 
+                return result;
5896 
+        }
5897 
+    }
5898 
+
5899 
+    hooks.defineLocale('bs', {
5900 
+        months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
5901 
+        monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
5902 
+        monthsParseExact: true,
5903 
+        weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
5904 
+        weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
5905 
+        weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
5906 
+        weekdaysParseExact : true,
5907 
+        longDateFormat : {
5908 
+            LT : 'H:mm',
5909 
+            LTS : 'H:mm:ss',
5910 
+            L : 'DD.MM.YYYY',
5911 
+            LL : 'D. MMMM YYYY',
5912 
+            LLL : 'D. MMMM YYYY H:mm',
5913 
+            LLLL : 'dddd, D. MMMM YYYY H:mm'
5914 
+        },
5915 
+        calendar : {
5916 
+            sameDay  : '[danas u] LT',
5917 
+            nextDay  : '[sutra u] LT',
5918 
+            nextWeek : function () {
5919 
+                switch (this.day()) {
5920 
+                    case 0:
5921 
+                        return '[u] [nedjelju] [u] LT';
5922 
+                    case 3:
5923 
+                        return '[u] [srijedu] [u] LT';
5924 
+                    case 6:
5925 
+                        return '[u] [subotu] [u] LT';
5926 
+                    case 1:
5927 
+                    case 2:
5928 
+                    case 4:
5929 
+                    case 5:
5930 
+                        return '[u] dddd [u] LT';
5931 
+                }
5932 
+            },
5933 
+            lastDay  : '[jučer u] LT',
5934 
+            lastWeek : function () {
5935 
+                switch (this.day()) {
5936 
+                    case 0:
5937 
+                    case 3:
5938 
+                        return '[prošlu] dddd [u] LT';
5939 
+                    case 6:
5940 
+                        return '[prošle] [subote] [u] LT';
5941 
+                    case 1:
5942 
+                    case 2:
5943 
+                    case 4:
5944 
+                    case 5:
5945 
+                        return '[prošli] dddd [u] LT';
5946 
+                }
5947 
+            },
5948 
+            sameElse : 'L'
5949 
+        },
5950 
+        relativeTime : {
5951 
+            future : 'za %s',
5952 
+            past   : 'prije %s',
5953 
+            s      : 'par sekundi',
5954 
+            ss     : translate,
5955 
+            m      : translate,
5956 
+            mm     : translate,
5957 
+            h      : translate,
5958 
+            hh     : translate,
5959 
+            d      : 'dan',
5960 
+            dd     : translate,
5961 
+            M      : 'mjesec',
5962 
+            MM     : translate,
5963 
+            y      : 'godinu',
5964 
+            yy     : translate
5965 
+        },
5966 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
5967 
+        ordinal : '%d.',
5968 
+        week : {
5969 
+            dow : 1, // Monday is the first day of the week.
5970 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
5971 
+        }
5972 
+    });
5973 
+
5974 
+    //! moment.js locale configuration
5975 
+
5976 
+    hooks.defineLocale('ca', {
5977 
+        months : {
5978 
+            standalone: 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
5979 
+            format: 'de gener_de febrer_de març_d\'abril_de maig_de juny_de juliol_d\'agost_de setembre_d\'octubre_de novembre_de desembre'.split('_'),
5980 
+            isFormat: /D[oD]?(\s)+MMMM/
5981 
+        },
5982 
+        monthsShort : 'gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.'.split('_'),
5983 
+        monthsParseExact : true,
5984 
+        weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
5985 
+        weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
5986 
+        weekdaysMin : 'dg_dl_dt_dc_dj_dv_ds'.split('_'),
5987 
+        weekdaysParseExact : true,
5988 
+        longDateFormat : {
5989 
+            LT : 'H:mm',
5990 
+            LTS : 'H:mm:ss',
5991 
+            L : 'DD/MM/YYYY',
5992 
+            LL : 'D MMMM [de] YYYY',
5993 
+            ll : 'D MMM YYYY',
5994 
+            LLL : 'D MMMM [de] YYYY [a les] H:mm',
5995 
+            lll : 'D MMM YYYY, H:mm',
5996 
+            LLLL : 'dddd D MMMM [de] YYYY [a les] H:mm',
5997 
+            llll : 'ddd D MMM YYYY, H:mm'
5998 
+        },
5999 
+        calendar : {
6000 
+            sameDay : function () {
6001 
+                return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6002 
+            },
6003 
+            nextDay : function () {
6004 
+                return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6005 
+            },
6006 
+            nextWeek : function () {
6007 
+                return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6008 
+            },
6009 
+            lastDay : function () {
6010 
+                return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6011 
+            },
6012 
+            lastWeek : function () {
6013 
+                return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
6014 
+            },
6015 
+            sameElse : 'L'
6016 
+        },
6017 
+        relativeTime : {
6018 
+            future : 'd\'aquí %s',
6019 
+            past : 'fa %s',
6020 
+            s : 'uns segons',
6021 
+            ss : '%d segons',
6022 
+            m : 'un minut',
6023 
+            mm : '%d minuts',
6024 
+            h : 'una hora',
6025 
+            hh : '%d hores',
6026 
+            d : 'un dia',
6027 
+            dd : '%d dies',
6028 
+            M : 'un mes',
6029 
+            MM : '%d mesos',
6030 
+            y : 'un any',
6031 
+            yy : '%d anys'
6032 
+        },
6033 
+        dayOfMonthOrdinalParse: /\d{1,2}(r|n|t|è|a)/,
6034 
+        ordinal : function (number, period) {
6035 
+            var output = (number === 1) ? 'r' :
6036 
+                (number === 2) ? 'n' :
6037 
+                (number === 3) ? 'r' :
6038 
+                (number === 4) ? 't' : 'è';
6039 
+            if (period === 'w' || period === 'W') {
6040 
+                output = 'a';
6041 
+            }
6042 
+            return number + output;
6043 
+        },
6044 
+        week : {
6045 
+            dow : 1, // Monday is the first day of the week.
6046 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6047 
+        }
6048 
+    });
6049 
+
6050 
+    //! moment.js locale configuration
6051 
+
6052 
+    var months$3 = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_'),
6053 
+        monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_');
6054 
+
6055 
+    var monthsParse = [/^led/i, /^úno/i, /^bře/i, /^dub/i, /^kvě/i, /^(čvn|červen$|června)/i, /^(čvc|červenec|července)/i, /^srp/i, /^zář/i, /^říj/i, /^lis/i, /^pro/i];
6056 
+    // NOTE: 'červen' is substring of 'červenec'; therefore 'červenec' must precede 'červen' in the regex to be fully matched.
6057 
+    // Otherwise parser matches '1. červenec' as '1. červen' + 'ec'.
6058 
+    var monthsRegex$1 = /^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;
6059 
+
6060 
+    function plural$1(n) {
6061 
+        return (n > 1) && (n < 5) && (~~(n / 10) !== 1);
6062 
+    }
6063 
+    function translate$1(number, withoutSuffix, key, isFuture) {
6064 
+        var result = number + ' ';
6065 
+        switch (key) {
6066 
+            case 's':  // a few seconds / in a few seconds / a few seconds ago
6067 
+                return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
6068 
+            case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
6069 
+                if (withoutSuffix || isFuture) {
6070 
+                    return result + (plural$1(number) ? 'sekundy' : 'sekund');
6071 
+                } else {
6072 
+                    return result + 'sekundami';
6073 
+                }
6074 
+                break;
6075 
+            case 'm':  // a minute / in a minute / a minute ago
6076 
+                return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
6077 
+            case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
6078 
+                if (withoutSuffix || isFuture) {
6079 
+                    return result + (plural$1(number) ? 'minuty' : 'minut');
6080 
+                } else {
6081 
+                    return result + 'minutami';
6082 
+                }
6083 
+                break;
6084 
+            case 'h':  // an hour / in an hour / an hour ago
6085 
+                return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
6086 
+            case 'hh': // 9 hours / in 9 hours / 9 hours ago
6087 
+                if (withoutSuffix || isFuture) {
6088 
+                    return result + (plural$1(number) ? 'hodiny' : 'hodin');
6089 
+                } else {
6090 
+                    return result + 'hodinami';
6091 
+                }
6092 
+                break;
6093 
+            case 'd':  // a day / in a day / a day ago
6094 
+                return (withoutSuffix || isFuture) ? 'den' : 'dnem';
6095 
+            case 'dd': // 9 days / in 9 days / 9 days ago
6096 
+                if (withoutSuffix || isFuture) {
6097 
+                    return result + (plural$1(number) ? 'dny' : 'dní');
6098 
+                } else {
6099 
+                    return result + 'dny';
6100 
+                }
6101 
+                break;
6102 
+            case 'M':  // a month / in a month / a month ago
6103 
+                return (withoutSuffix || isFuture) ? 'měsíc' : 'měsícem';
6104 
+            case 'MM': // 9 months / in 9 months / 9 months ago
6105 
+                if (withoutSuffix || isFuture) {
6106 
+                    return result + (plural$1(number) ? 'měsíce' : 'měsíců');
6107 
+                } else {
6108 
+                    return result + 'měsíci';
6109 
+                }
6110 
+                break;
6111 
+            case 'y':  // a year / in a year / a year ago
6112 
+                return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
6113 
+            case 'yy': // 9 years / in 9 years / 9 years ago
6114 
+                if (withoutSuffix || isFuture) {
6115 
+                    return result + (plural$1(number) ? 'roky' : 'let');
6116 
+                } else {
6117 
+                    return result + 'lety';
6118 
+                }
6119 
+                break;
6120 
+        }
6121 
+    }
6122 
+
6123 
+    hooks.defineLocale('cs', {
6124 
+        months : months$3,
6125 
+        monthsShort : monthsShort,
6126 
+        monthsRegex : monthsRegex$1,
6127 
+        monthsShortRegex : monthsRegex$1,
6128 
+        // NOTE: 'červen' is substring of 'červenec'; therefore 'červenec' must precede 'červen' in the regex to be fully matched.
6129 
+        // Otherwise parser matches '1. červenec' as '1. červen' + 'ec'.
6130 
+        monthsStrictRegex : /^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,
6131 
+        monthsShortStrictRegex : /^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,
6132 
+        monthsParse : monthsParse,
6133 
+        longMonthsParse : monthsParse,
6134 
+        shortMonthsParse : monthsParse,
6135 
+        weekdays : 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
6136 
+        weekdaysShort : 'ne_po_út_st_čt_pá_so'.split('_'),
6137 
+        weekdaysMin : 'ne_po_út_st_čt_pá_so'.split('_'),
6138 
+        longDateFormat : {
6139 
+            LT: 'H:mm',
6140 
+            LTS : 'H:mm:ss',
6141 
+            L : 'DD.MM.YYYY',
6142 
+            LL : 'D. MMMM YYYY',
6143 
+            LLL : 'D. MMMM YYYY H:mm',
6144 
+            LLLL : 'dddd D. MMMM YYYY H:mm',
6145 
+            l : 'D. M. YYYY'
6146 
+        },
6147 
+        calendar : {
6148 
+            sameDay: '[dnes v] LT',
6149 
+            nextDay: '[zítra v] LT',
6150 
+            nextWeek: function () {
6151 
+                switch (this.day()) {
6152 
+                    case 0:
6153 
+                        return '[v neděli v] LT';
6154 
+                    case 1:
6155 
+                    case 2:
6156 
+                        return '[v] dddd [v] LT';
6157 
+                    case 3:
6158 
+                        return '[ve středu v] LT';
6159 
+                    case 4:
6160 
+                        return '[ve čtvrtek v] LT';
6161 
+                    case 5:
6162 
+                        return '[v pátek v] LT';
6163 
+                    case 6:
6164 
+                        return '[v sobotu v] LT';
6165 
+                }
6166 
+            },
6167 
+            lastDay: '[včera v] LT',
6168 
+            lastWeek: function () {
6169 
+                switch (this.day()) {
6170 
+                    case 0:
6171 
+                        return '[minulou neděli v] LT';
6172 
+                    case 1:
6173 
+                    case 2:
6174 
+                        return '[minulé] dddd [v] LT';
6175 
+                    case 3:
6176 
+                        return '[minulou středu v] LT';
6177 
+                    case 4:
6178 
+                    case 5:
6179 
+                        return '[minulý] dddd [v] LT';
6180 
+                    case 6:
6181 
+                        return '[minulou sobotu v] LT';
6182 
+                }
6183 
+            },
6184 
+            sameElse: 'L'
6185 
+        },
6186 
+        relativeTime : {
6187 
+            future : 'za %s',
6188 
+            past : 'před %s',
6189 
+            s : translate$1,
6190 
+            ss : translate$1,
6191 
+            m : translate$1,
6192 
+            mm : translate$1,
6193 
+            h : translate$1,
6194 
+            hh : translate$1,
6195 
+            d : translate$1,
6196 
+            dd : translate$1,
6197 
+            M : translate$1,
6198 
+            MM : translate$1,
6199 
+            y : translate$1,
6200 
+            yy : translate$1
6201 
+        },
6202 
+        dayOfMonthOrdinalParse : /\d{1,2}\./,
6203 
+        ordinal : '%d.',
6204 
+        week : {
6205 
+            dow : 1, // Monday is the first day of the week.
6206 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6207 
+        }
6208 
+    });
6209 
+
6210 
+    //! moment.js locale configuration
6211 
+
6212 
+    hooks.defineLocale('cv', {
6213 
+        months : 'кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав'.split('_'),
6214 
+        monthsShort : 'кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш'.split('_'),
6215 
+        weekdays : 'вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун'.split('_'),
6216 
+        weekdaysShort : 'выр_тун_ытл_юн_кӗҫ_эрн_шӑм'.split('_'),
6217 
+        weekdaysMin : 'вр_тн_ыт_юн_кҫ_эр_шм'.split('_'),
6218 
+        longDateFormat : {
6219 
+            LT : 'HH:mm',
6220 
+            LTS : 'HH:mm:ss',
6221 
+            L : 'DD-MM-YYYY',
6222 
+            LL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]',
6223 
+            LLL : 'YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm',
6224 
+            LLLL : 'dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm'
6225 
+        },
6226 
+        calendar : {
6227 
+            sameDay: '[Паян] LT [сехетре]',
6228 
+            nextDay: '[Ыран] LT [сехетре]',
6229 
+            lastDay: '[Ӗнер] LT [сехетре]',
6230 
+            nextWeek: '[Ҫитес] dddd LT [сехетре]',
6231 
+            lastWeek: '[Иртнӗ] dddd LT [сехетре]',
6232 
+            sameElse: 'L'
6233 
+        },
6234 
+        relativeTime : {
6235 
+            future : function (output) {
6236 
+                var affix = /сехет$/i.exec(output) ? 'рен' : /ҫул$/i.exec(output) ? 'тан' : 'ран';
6237 
+                return output + affix;
6238 
+            },
6239 
+            past : '%s каялла',
6240 
+            s : 'пӗр-ик ҫеккунт',
6241 
+            ss : '%d ҫеккунт',
6242 
+            m : 'пӗр минут',
6243 
+            mm : '%d минут',
6244 
+            h : 'пӗр сехет',
6245 
+            hh : '%d сехет',
6246 
+            d : 'пӗр кун',
6247 
+            dd : '%d кун',
6248 
+            M : 'пӗр уйӑх',
6249 
+            MM : '%d уйӑх',
6250 
+            y : 'пӗр ҫул',
6251 
+            yy : '%d ҫул'
6252 
+        },
6253 
+        dayOfMonthOrdinalParse: /\d{1,2}-мӗш/,
6254 
+        ordinal : '%d-мӗш',
6255 
+        week : {
6256 
+            dow : 1, // Monday is the first day of the week.
6257 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
6258 
+        }
6259 
+    });
6260 
+
6261 
+    //! moment.js locale configuration
6262 
+
6263 
+    hooks.defineLocale('cy', {
6264 
+        months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
6265 
+        monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
6266 
+        weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
6267 
+        weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
6268 
+        weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
6269 
+        weekdaysParseExact : true,
6270 
+        // time formats are the same as en-gb
6271 
+        longDateFormat: {
6272 
+            LT: 'HH:mm',
6273 
+            LTS : 'HH:mm:ss',
6274 
+            L: 'DD/MM/YYYY',
6275 
+            LL: 'D MMMM YYYY',
6276 
+            LLL: 'D MMMM YYYY HH:mm',
6277 
+            LLLL: 'dddd, D MMMM YYYY HH:mm'
6278 
+        },
6279 
+        calendar: {
6280 
+            sameDay: '[Heddiw am] LT',
6281 
+            nextDay: '[Yfory am] LT',
6282 
+            nextWeek: 'dddd [am] LT',
6283 
+            lastDay: '[Ddoe am] LT',
6284 
+            lastWeek: 'dddd [diwethaf am] LT',
6285 
+            sameElse: 'L'
6286 
+        },
6287 
+        relativeTime: {
6288 
+            future: 'mewn %s',
6289 
+            past: '%s yn ôl',
6290 
+            s: 'ychydig eiliadau',
6291 
+            ss: '%d eiliad',
6292 
+            m: 'munud',
6293 
+            mm: '%d munud',
6294 
+            h: 'awr',
6295 
+            hh: '%d awr',
6296 
+            d: 'diwrnod',
6297 
+            dd: '%d diwrnod',
6298 
+            M: 'mis',
6299 
+            MM: '%d mis',
6300 
+            y: 'blwyddyn',
6301 
+            yy: '%d flynedd'
6302 
+        },
6303 
+        dayOfMonthOrdinalParse: /\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,
6304 
+        // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
6305 
+        ordinal: function (number) {
6306 
+            var b = number,
6307 
+                output = '',
6308 
+                lookup = [
6309 
+                    '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
6310 
+                    'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
6311 
+                ];
6312 
+            if (b > 20) {
6313 
+                if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
6314 
+                    output = 'fed'; // not 30ain, 70ain or 90ain
6315 
+                } else {
6316 
+                    output = 'ain';
6317 
+                }
6318 
+            } else if (b > 0) {
6319 
+                output = lookup[b];
6320 
+            }
6321 
+            return number + output;
6322 
+        },
6323 
+        week : {
6324 
+            dow : 1, // Monday is the first day of the week.
6325 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6326 
+        }
6327 
+    });
6328 
+
6329 
+    //! moment.js locale configuration
6330 
+
6331 
+    hooks.defineLocale('da', {
6332 
+        months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
6333 
+        monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
6334 
+        weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
6335 
+        weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'),
6336 
+        weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
6337 
+        longDateFormat : {
6338 
+            LT : 'HH:mm',
6339 
+            LTS : 'HH:mm:ss',
6340 
+            L : 'DD.MM.YYYY',
6341 
+            LL : 'D. MMMM YYYY',
6342 
+            LLL : 'D. MMMM YYYY HH:mm',
6343 
+            LLLL : 'dddd [d.] D. MMMM YYYY [kl.] HH:mm'
6344 
+        },
6345 
+        calendar : {
6346 
+            sameDay : '[i dag kl.] LT',
6347 
+            nextDay : '[i morgen kl.] LT',
6348 
+            nextWeek : 'på dddd [kl.] LT',
6349 
+            lastDay : '[i går kl.] LT',
6350 
+            lastWeek : '[i] dddd[s kl.] LT',
6351 
+            sameElse : 'L'
6352 
+        },
6353 
+        relativeTime : {
6354 
+            future : 'om %s',
6355 
+            past : '%s siden',
6356 
+            s : 'få sekunder',
6357 
+            ss : '%d sekunder',
6358 
+            m : 'et minut',
6359 
+            mm : '%d minutter',
6360 
+            h : 'en time',
6361 
+            hh : '%d timer',
6362 
+            d : 'en dag',
6363 
+            dd : '%d dage',
6364 
+            M : 'en måned',
6365 
+            MM : '%d måneder',
6366 
+            y : 'et år',
6367 
+            yy : '%d år'
6368 
+        },
6369 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
6370 
+        ordinal : '%d.',
6371 
+        week : {
6372 
+            dow : 1, // Monday is the first day of the week.
6373 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6374 
+        }
6375 
+    });
6376 
+
6377 
+    //! moment.js locale configuration
6378 
+
6379 
+    function processRelativeTime(number, withoutSuffix, key, isFuture) {
6380 
+        var format = {
6381 
+            'm': ['eine Minute', 'einer Minute'],
6382 
+            'h': ['eine Stunde', 'einer Stunde'],
6383 
+            'd': ['ein Tag', 'einem Tag'],
6384 
+            'dd': [number + ' Tage', number + ' Tagen'],
6385 
+            'M': ['ein Monat', 'einem Monat'],
6386 
+            'MM': [number + ' Monate', number + ' Monaten'],
6387 
+            'y': ['ein Jahr', 'einem Jahr'],
6388 
+            'yy': [number + ' Jahre', number + ' Jahren']
6389 
+        };
6390 
+        return withoutSuffix ? format[key][0] : format[key][1];
6391 
+    }
6392 
+
6393 
+    hooks.defineLocale('de-at', {
6394 
+        months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6395 
+        monthsShort : 'Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6396 
+        monthsParseExact : true,
6397 
+        weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6398 
+        weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6399 
+        weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6400 
+        weekdaysParseExact : true,
6401 
+        longDateFormat : {
6402 
+            LT: 'HH:mm',
6403 
+            LTS: 'HH:mm:ss',
6404 
+            L : 'DD.MM.YYYY',
6405 
+            LL : 'D. MMMM YYYY',
6406 
+            LLL : 'D. MMMM YYYY HH:mm',
6407 
+            LLLL : 'dddd, D. MMMM YYYY HH:mm'
6408 
+        },
6409 
+        calendar : {
6410 
+            sameDay: '[heute um] LT [Uhr]',
6411 
+            sameElse: 'L',
6412 
+            nextDay: '[morgen um] LT [Uhr]',
6413 
+            nextWeek: 'dddd [um] LT [Uhr]',
6414 
+            lastDay: '[gestern um] LT [Uhr]',
6415 
+            lastWeek: '[letzten] dddd [um] LT [Uhr]'
6416 
+        },
6417 
+        relativeTime : {
6418 
+            future : 'in %s',
6419 
+            past : 'vor %s',
6420 
+            s : 'ein paar Sekunden',
6421 
+            ss : '%d Sekunden',
6422 
+            m : processRelativeTime,
6423 
+            mm : '%d Minuten',
6424 
+            h : processRelativeTime,
6425 
+            hh : '%d Stunden',
6426 
+            d : processRelativeTime,
6427 
+            dd : processRelativeTime,
6428 
+            M : processRelativeTime,
6429 
+            MM : processRelativeTime,
6430 
+            y : processRelativeTime,
6431 
+            yy : processRelativeTime
6432 
+        },
6433 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
6434 
+        ordinal : '%d.',
6435 
+        week : {
6436 
+            dow : 1, // Monday is the first day of the week.
6437 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6438 
+        }
6439 
+    });
6440 
+
6441 
+    //! moment.js locale configuration
6442 
+
6443 
+    function processRelativeTime$1(number, withoutSuffix, key, isFuture) {
6444 
+        var format = {
6445 
+            'm': ['eine Minute', 'einer Minute'],
6446 
+            'h': ['eine Stunde', 'einer Stunde'],
6447 
+            'd': ['ein Tag', 'einem Tag'],
6448 
+            'dd': [number + ' Tage', number + ' Tagen'],
6449 
+            'M': ['ein Monat', 'einem Monat'],
6450 
+            'MM': [number + ' Monate', number + ' Monaten'],
6451 
+            'y': ['ein Jahr', 'einem Jahr'],
6452 
+            'yy': [number + ' Jahre', number + ' Jahren']
6453 
+        };
6454 
+        return withoutSuffix ? format[key][0] : format[key][1];
6455 
+    }
6456 
+
6457 
+    hooks.defineLocale('de-ch', {
6458 
+        months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6459 
+        monthsShort : 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6460 
+        monthsParseExact : true,
6461 
+        weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6462 
+        weekdaysShort : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6463 
+        weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6464 
+        weekdaysParseExact : true,
6465 
+        longDateFormat : {
6466 
+            LT: 'HH:mm',
6467 
+            LTS: 'HH:mm:ss',
6468 
+            L : 'DD.MM.YYYY',
6469 
+            LL : 'D. MMMM YYYY',
6470 
+            LLL : 'D. MMMM YYYY HH:mm',
6471 
+            LLLL : 'dddd, D. MMMM YYYY HH:mm'
6472 
+        },
6473 
+        calendar : {
6474 
+            sameDay: '[heute um] LT [Uhr]',
6475 
+            sameElse: 'L',
6476 
+            nextDay: '[morgen um] LT [Uhr]',
6477 
+            nextWeek: 'dddd [um] LT [Uhr]',
6478 
+            lastDay: '[gestern um] LT [Uhr]',
6479 
+            lastWeek: '[letzten] dddd [um] LT [Uhr]'
6480 
+        },
6481 
+        relativeTime : {
6482 
+            future : 'in %s',
6483 
+            past : 'vor %s',
6484 
+            s : 'ein paar Sekunden',
6485 
+            ss : '%d Sekunden',
6486 
+            m : processRelativeTime$1,
6487 
+            mm : '%d Minuten',
6488 
+            h : processRelativeTime$1,
6489 
+            hh : '%d Stunden',
6490 
+            d : processRelativeTime$1,
6491 
+            dd : processRelativeTime$1,
6492 
+            M : processRelativeTime$1,
6493 
+            MM : processRelativeTime$1,
6494 
+            y : processRelativeTime$1,
6495 
+            yy : processRelativeTime$1
6496 
+        },
6497 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
6498 
+        ordinal : '%d.',
6499 
+        week : {
6500 
+            dow : 1, // Monday is the first day of the week.
6501 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6502 
+        }
6503 
+    });
6504 
+
6505 
+    //! moment.js locale configuration
6506 
+
6507 
+    function processRelativeTime$2(number, withoutSuffix, key, isFuture) {
6508 
+        var format = {
6509 
+            'm': ['eine Minute', 'einer Minute'],
6510 
+            'h': ['eine Stunde', 'einer Stunde'],
6511 
+            'd': ['ein Tag', 'einem Tag'],
6512 
+            'dd': [number + ' Tage', number + ' Tagen'],
6513 
+            'M': ['ein Monat', 'einem Monat'],
6514 
+            'MM': [number + ' Monate', number + ' Monaten'],
6515 
+            'y': ['ein Jahr', 'einem Jahr'],
6516 
+            'yy': [number + ' Jahre', number + ' Jahren']
6517 
+        };
6518 
+        return withoutSuffix ? format[key][0] : format[key][1];
6519 
+    }
6520 
+
6521 
+    hooks.defineLocale('de', {
6522 
+        months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
6523 
+        monthsShort : 'Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.'.split('_'),
6524 
+        monthsParseExact : true,
6525 
+        weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
6526 
+        weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
6527 
+        weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
6528 
+        weekdaysParseExact : true,
6529 
+        longDateFormat : {
6530 
+            LT: 'HH:mm',
6531 
+            LTS: 'HH:mm:ss',
6532 
+            L : 'DD.MM.YYYY',
6533 
+            LL : 'D. MMMM YYYY',
6534 
+            LLL : 'D. MMMM YYYY HH:mm',
6535 
+            LLLL : 'dddd, D. MMMM YYYY HH:mm'
6536 
+        },
6537 
+        calendar : {
6538 
+            sameDay: '[heute um] LT [Uhr]',
6539 
+            sameElse: 'L',
6540 
+            nextDay: '[morgen um] LT [Uhr]',
6541 
+            nextWeek: 'dddd [um] LT [Uhr]',
6542 
+            lastDay: '[gestern um] LT [Uhr]',
6543 
+            lastWeek: '[letzten] dddd [um] LT [Uhr]'
6544 
+        },
6545 
+        relativeTime : {
6546 
+            future : 'in %s',
6547 
+            past : 'vor %s',
6548 
+            s : 'ein paar Sekunden',
6549 
+            ss : '%d Sekunden',
6550 
+            m : processRelativeTime$2,
6551 
+            mm : '%d Minuten',
6552 
+            h : processRelativeTime$2,
6553 
+            hh : '%d Stunden',
6554 
+            d : processRelativeTime$2,
6555 
+            dd : processRelativeTime$2,
6556 
+            M : processRelativeTime$2,
6557 
+            MM : processRelativeTime$2,
6558 
+            y : processRelativeTime$2,
6559 
+            yy : processRelativeTime$2
6560 
+        },
6561 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
6562 
+        ordinal : '%d.',
6563 
+        week : {
6564 
+            dow : 1, // Monday is the first day of the week.
6565 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6566 
+        }
6567 
+    });
6568 
+
6569 
+    //! moment.js locale configuration
6570 
+
6571 
+    var months$4 = [
6572 
+        'ޖެނުއަރީ',
6573 
+        'ފެބްރުއަރީ',
6574 
+        'މާރިޗު',
6575 
+        'އޭޕްރީލު',
6576 
+        'މޭ',
6577 
+        'ޖޫން',
6578 
+        'ޖުލައި',
6579 
+        'އޯގަސްޓު',
6580 
+        'ސެޕްޓެމްބަރު',
6581 
+        'އޮކްޓޯބަރު',
6582 
+        'ނޮވެމްބަރު',
6583 
+        'ޑިސެމްބަރު'
6584 
+    ], weekdays = [
6585 
+        'އާދިއްތަ',
6586 
+        'ހޯމަ',
6587 
+        'އަންގާރަ',
6588 
+        'ބުދަ',
6589 
+        'ބުރާސްފަތި',
6590 
+        'ހުކުރު',
6591 
+        'ހޮނިހިރު'
6592 
+    ];
6593 
+
6594 
+    hooks.defineLocale('dv', {
6595 
+        months : months$4,
6596 
+        monthsShort : months$4,
6597 
+        weekdays : weekdays,
6598 
+        weekdaysShort : weekdays,
6599 
+        weekdaysMin : 'އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި'.split('_'),
6600 
+        longDateFormat : {
6601 
+
6602 
+            LT : 'HH:mm',
6603 
+            LTS : 'HH:mm:ss',
6604 
+            L : 'D/M/YYYY',
6605 
+            LL : 'D MMMM YYYY',
6606 
+            LLL : 'D MMMM YYYY HH:mm',
6607 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
6608 
+        },
6609 
+        meridiemParse: /މކ|މފ/,
6610 
+        isPM : function (input) {
6611 
+            return 'މފ' === input;
6612 
+        },
6613 
+        meridiem : function (hour, minute, isLower) {
6614 
+            if (hour < 12) {
6615 
+                return 'މކ';
6616 
+            } else {
6617 
+                return 'މފ';
6618 
+            }
6619 
+        },
6620 
+        calendar : {
6621 
+            sameDay : '[މިއަދު] LT',
6622 
+            nextDay : '[މާދަމާ] LT',
6623 
+            nextWeek : 'dddd LT',
6624 
+            lastDay : '[އިއްޔެ] LT',
6625 
+            lastWeek : '[ފާއިތުވި] dddd LT',
6626 
+            sameElse : 'L'
6627 
+        },
6628 
+        relativeTime : {
6629 
+            future : 'ތެރޭގައި %s',
6630 
+            past : 'ކުރިން %s',
6631 
+            s : 'ސިކުންތުކޮޅެއް',
6632 
+            ss : 'd% ސިކުންތު',
6633 
+            m : 'މިނިޓެއް',
6634 
+            mm : 'މިނިޓު %d',
6635 
+            h : 'ގަޑިއިރެއް',
6636 
+            hh : 'ގަޑިއިރު %d',
6637 
+            d : 'ދުވަހެއް',
6638 
+            dd : 'ދުވަސް %d',
6639 
+            M : 'މަހެއް',
6640 
+            MM : 'މަސް %d',
6641 
+            y : 'އަހަރެއް',
6642 
+            yy : 'އަހަރު %d'
6643 
+        },
6644 
+        preparse: function (string) {
6645 
+            return string.replace(/،/g, ',');
6646 
+        },
6647 
+        postformat: function (string) {
6648 
+            return string.replace(/,/g, '،');
6649 
+        },
6650 
+        week : {
6651 
+            dow : 7,  // Sunday is the first day of the week.
6652 
+            doy : 12  // The week that contains Jan 12th is the first week of the year.
6653 
+        }
6654 
+    });
6655 
+
6656 
+    //! moment.js locale configuration
6657 
+
6658 
+    hooks.defineLocale('el', {
6659 
+        monthsNominativeEl : 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
6660 
+        monthsGenitiveEl : 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split('_'),
6661 
+        months : function (momentToFormat, format) {
6662 
+            if (!momentToFormat) {
6663 
+                return this._monthsNominativeEl;
6664 
+            } else if (typeof format === 'string' && /D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
6665 
+                return this._monthsGenitiveEl[momentToFormat.month()];
6666 
+            } else {
6667 
+                return this._monthsNominativeEl[momentToFormat.month()];
6668 
+            }
6669 
+        },
6670 
+        monthsShort : 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
6671 
+        weekdays : 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split('_'),
6672 
+        weekdaysShort : 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
6673 
+        weekdaysMin : 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
6674 
+        meridiem : function (hours, minutes, isLower) {
6675 
+            if (hours > 11) {
6676 
+                return isLower ? 'μμ' : 'ΜΜ';
6677 
+            } else {
6678 
+                return isLower ? 'πμ' : 'ΠΜ';
6679 
+            }
6680 
+        },
6681 
+        isPM : function (input) {
6682 
+            return ((input + '').toLowerCase()[0] === 'μ');
6683 
+        },
6684 
+        meridiemParse : /[ΠΜ]\.?Μ?\.?/i,
6685 
+        longDateFormat : {
6686 
+            LT : 'h:mm A',
6687 
+            LTS : 'h:mm:ss A',
6688 
+            L : 'DD/MM/YYYY',
6689 
+            LL : 'D MMMM YYYY',
6690 
+            LLL : 'D MMMM YYYY h:mm A',
6691 
+            LLLL : 'dddd, D MMMM YYYY h:mm A'
6692 
+        },
6693 
+        calendarEl : {
6694 
+            sameDay : '[Σήμερα {}] LT',
6695 
+            nextDay : '[Αύριο {}] LT',
6696 
+            nextWeek : 'dddd [{}] LT',
6697 
+            lastDay : '[Χθες {}] LT',
6698 
+            lastWeek : function () {
6699 
+                switch (this.day()) {
6700 
+                    case 6:
6701 
+                        return '[το προηγούμενο] dddd [{}] LT';
6702 
+                    default:
6703 
+                        return '[την προηγούμενη] dddd [{}] LT';
6704 
+                }
6705 
+            },
6706 
+            sameElse : 'L'
6707 
+        },
6708 
+        calendar : function (key, mom) {
6709 
+            var output = this._calendarEl[key],
6710 
+                hours = mom && mom.hours();
6711 
+            if (isFunction(output)) {
6712 
+                output = output.apply(mom);
6713 
+            }
6714 
+            return output.replace('{}', (hours % 12 === 1 ? 'στη' : 'στις'));
6715 
+        },
6716 
+        relativeTime : {
6717 
+            future : 'σε %s',
6718 
+            past : '%s πριν',
6719 
+            s : 'λίγα δευτερόλεπτα',
6720 
+            ss : '%d δευτερόλεπτα',
6721 
+            m : 'ένα λεπτό',
6722 
+            mm : '%d λεπτά',
6723 
+            h : 'μία ώρα',
6724 
+            hh : '%d ώρες',
6725 
+            d : 'μία μέρα',
6726 
+            dd : '%d μέρες',
6727 
+            M : 'ένας μήνας',
6728 
+            MM : '%d μήνες',
6729 
+            y : 'ένας χρόνος',
6730 
+            yy : '%d χρόνια'
6731 
+        },
6732 
+        dayOfMonthOrdinalParse: /\d{1,2}η/,
6733 
+        ordinal: '%dη',
6734 
+        week : {
6735 
+            dow : 1, // Monday is the first day of the week.
6736 
+            doy : 4  // The week that contains Jan 4st is the first week of the year.
6737 
+        }
6738 
+    });
6739 
+
6740 
+    //! moment.js locale configuration
6741 
+
6742 
+    hooks.defineLocale('en-SG', {
6743 
+        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6744 
+        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6745 
+        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6746 
+        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6747 
+        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6748 
+        longDateFormat : {
6749 
+            LT : 'HH:mm',
6750 
+            LTS : 'HH:mm:ss',
6751 
+            L : 'DD/MM/YYYY',
6752 
+            LL : 'D MMMM YYYY',
6753 
+            LLL : 'D MMMM YYYY HH:mm',
6754 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
6755 
+        },
6756 
+        calendar : {
6757 
+            sameDay : '[Today at] LT',
6758 
+            nextDay : '[Tomorrow at] LT',
6759 
+            nextWeek : 'dddd [at] LT',
6760 
+            lastDay : '[Yesterday at] LT',
6761 
+            lastWeek : '[Last] dddd [at] LT',
6762 
+            sameElse : 'L'
6763 
+        },
6764 
+        relativeTime : {
6765 
+            future : 'in %s',
6766 
+            past : '%s ago',
6767 
+            s : 'a few seconds',
6768 
+            ss : '%d seconds',
6769 
+            m : 'a minute',
6770 
+            mm : '%d minutes',
6771 
+            h : 'an hour',
6772 
+            hh : '%d hours',
6773 
+            d : 'a day',
6774 
+            dd : '%d days',
6775 
+            M : 'a month',
6776 
+            MM : '%d months',
6777 
+            y : 'a year',
6778 
+            yy : '%d years'
6779 
+        },
6780 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
6781 
+        ordinal : function (number) {
6782 
+            var b = number % 10,
6783 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
6784 
+                (b === 1) ? 'st' :
6785 
+                (b === 2) ? 'nd' :
6786 
+                (b === 3) ? 'rd' : 'th';
6787 
+            return number + output;
6788 
+        },
6789 
+        week : {
6790 
+            dow : 1, // Monday is the first day of the week.
6791 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6792 
+        }
6793 
+    });
6794 
+
6795 
+    //! moment.js locale configuration
6796 
+
6797 
+    hooks.defineLocale('en-au', {
6798 
+        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6799 
+        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6800 
+        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6801 
+        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6802 
+        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6803 
+        longDateFormat : {
6804 
+            LT : 'h:mm A',
6805 
+            LTS : 'h:mm:ss A',
6806 
+            L : 'DD/MM/YYYY',
6807 
+            LL : 'D MMMM YYYY',
6808 
+            LLL : 'D MMMM YYYY h:mm A',
6809 
+            LLLL : 'dddd, D MMMM YYYY h:mm A'
6810 
+        },
6811 
+        calendar : {
6812 
+            sameDay : '[Today at] LT',
6813 
+            nextDay : '[Tomorrow at] LT',
6814 
+            nextWeek : 'dddd [at] LT',
6815 
+            lastDay : '[Yesterday at] LT',
6816 
+            lastWeek : '[Last] dddd [at] LT',
6817 
+            sameElse : 'L'
6818 
+        },
6819 
+        relativeTime : {
6820 
+            future : 'in %s',
6821 
+            past : '%s ago',
6822 
+            s : 'a few seconds',
6823 
+            ss : '%d seconds',
6824 
+            m : 'a minute',
6825 
+            mm : '%d minutes',
6826 
+            h : 'an hour',
6827 
+            hh : '%d hours',
6828 
+            d : 'a day',
6829 
+            dd : '%d days',
6830 
+            M : 'a month',
6831 
+            MM : '%d months',
6832 
+            y : 'a year',
6833 
+            yy : '%d years'
6834 
+        },
6835 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
6836 
+        ordinal : function (number) {
6837 
+            var b = number % 10,
6838 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
6839 
+                (b === 1) ? 'st' :
6840 
+                (b === 2) ? 'nd' :
6841 
+                (b === 3) ? 'rd' : 'th';
6842 
+            return number + output;
6843 
+        },
6844 
+        week : {
6845 
+            dow : 1, // Monday is the first day of the week.
6846 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6847 
+        }
6848 
+    });
6849 
+
6850 
+    //! moment.js locale configuration
6851 
+
6852 
+    hooks.defineLocale('en-ca', {
6853 
+        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6854 
+        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6855 
+        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6856 
+        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6857 
+        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6858 
+        longDateFormat : {
6859 
+            LT : 'h:mm A',
6860 
+            LTS : 'h:mm:ss A',
6861 
+            L : 'YYYY-MM-DD',
6862 
+            LL : 'MMMM D, YYYY',
6863 
+            LLL : 'MMMM D, YYYY h:mm A',
6864 
+            LLLL : 'dddd, MMMM D, YYYY h:mm A'
6865 
+        },
6866 
+        calendar : {
6867 
+            sameDay : '[Today at] LT',
6868 
+            nextDay : '[Tomorrow at] LT',
6869 
+            nextWeek : 'dddd [at] LT',
6870 
+            lastDay : '[Yesterday at] LT',
6871 
+            lastWeek : '[Last] dddd [at] LT',
6872 
+            sameElse : 'L'
6873 
+        },
6874 
+        relativeTime : {
6875 
+            future : 'in %s',
6876 
+            past : '%s ago',
6877 
+            s : 'a few seconds',
6878 
+            ss : '%d seconds',
6879 
+            m : 'a minute',
6880 
+            mm : '%d minutes',
6881 
+            h : 'an hour',
6882 
+            hh : '%d hours',
6883 
+            d : 'a day',
6884 
+            dd : '%d days',
6885 
+            M : 'a month',
6886 
+            MM : '%d months',
6887 
+            y : 'a year',
6888 
+            yy : '%d years'
6889 
+        },
6890 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
6891 
+        ordinal : function (number) {
6892 
+            var b = number % 10,
6893 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
6894 
+                (b === 1) ? 'st' :
6895 
+                (b === 2) ? 'nd' :
6896 
+                (b === 3) ? 'rd' : 'th';
6897 
+            return number + output;
6898 
+        }
6899 
+    });
6900 
+
6901 
+    //! moment.js locale configuration
6902 
+
6903 
+    hooks.defineLocale('en-gb', {
6904 
+        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6905 
+        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6906 
+        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6907 
+        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6908 
+        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6909 
+        longDateFormat : {
6910 
+            LT : 'HH:mm',
6911 
+            LTS : 'HH:mm:ss',
6912 
+            L : 'DD/MM/YYYY',
6913 
+            LL : 'D MMMM YYYY',
6914 
+            LLL : 'D MMMM YYYY HH:mm',
6915 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
6916 
+        },
6917 
+        calendar : {
6918 
+            sameDay : '[Today at] LT',
6919 
+            nextDay : '[Tomorrow at] LT',
6920 
+            nextWeek : 'dddd [at] LT',
6921 
+            lastDay : '[Yesterday at] LT',
6922 
+            lastWeek : '[Last] dddd [at] LT',
6923 
+            sameElse : 'L'
6924 
+        },
6925 
+        relativeTime : {
6926 
+            future : 'in %s',
6927 
+            past : '%s ago',
6928 
+            s : 'a few seconds',
6929 
+            ss : '%d seconds',
6930 
+            m : 'a minute',
6931 
+            mm : '%d minutes',
6932 
+            h : 'an hour',
6933 
+            hh : '%d hours',
6934 
+            d : 'a day',
6935 
+            dd : '%d days',
6936 
+            M : 'a month',
6937 
+            MM : '%d months',
6938 
+            y : 'a year',
6939 
+            yy : '%d years'
6940 
+        },
6941 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
6942 
+        ordinal : function (number) {
6943 
+            var b = number % 10,
6944 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
6945 
+                (b === 1) ? 'st' :
6946 
+                (b === 2) ? 'nd' :
6947 
+                (b === 3) ? 'rd' : 'th';
6948 
+            return number + output;
6949 
+        },
6950 
+        week : {
6951 
+            dow : 1, // Monday is the first day of the week.
6952 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
6953 
+        }
6954 
+    });
6955 
+
6956 
+    //! moment.js locale configuration
6957 
+
6958 
+    hooks.defineLocale('en-ie', {
6959 
+        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
6960 
+        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
6961 
+        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
6962 
+        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
6963 
+        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
6964 
+        longDateFormat : {
6965 
+            LT : 'HH:mm',
6966 
+            LTS : 'HH:mm:ss',
6967 
+            L : 'DD/MM/YYYY',
6968 
+            LL : 'D MMMM YYYY',
6969 
+            LLL : 'D MMMM YYYY HH:mm',
6970 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
6971 
+        },
6972 
+        calendar : {
6973 
+            sameDay : '[Today at] LT',
6974 
+            nextDay : '[Tomorrow at] LT',
6975 
+            nextWeek : 'dddd [at] LT',
6976 
+            lastDay : '[Yesterday at] LT',
6977 
+            lastWeek : '[Last] dddd [at] LT',
6978 
+            sameElse : 'L'
6979 
+        },
6980 
+        relativeTime : {
6981 
+            future : 'in %s',
6982 
+            past : '%s ago',
6983 
+            s : 'a few seconds',
6984 
+            ss : '%d seconds',
6985 
+            m : 'a minute',
6986 
+            mm : '%d minutes',
6987 
+            h : 'an hour',
6988 
+            hh : '%d hours',
6989 
+            d : 'a day',
6990 
+            dd : '%d days',
6991 
+            M : 'a month',
6992 
+            MM : '%d months',
6993 
+            y : 'a year',
6994 
+            yy : '%d years'
6995 
+        },
6996 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
6997 
+        ordinal : function (number) {
6998 
+            var b = number % 10,
6999 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
7000 
+                (b === 1) ? 'st' :
7001 
+                (b === 2) ? 'nd' :
7002 
+                (b === 3) ? 'rd' : 'th';
7003 
+            return number + output;
7004 
+        },
7005 
+        week : {
7006 
+            dow : 1, // Monday is the first day of the week.
7007 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7008 
+        }
7009 
+    });
7010 
+
7011 
+    //! moment.js locale configuration
7012 
+
7013 
+    hooks.defineLocale('en-il', {
7014 
+        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7015 
+        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7016 
+        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7017 
+        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7018 
+        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7019 
+        longDateFormat : {
7020 
+            LT : 'HH:mm',
7021 
+            LTS : 'HH:mm:ss',
7022 
+            L : 'DD/MM/YYYY',
7023 
+            LL : 'D MMMM YYYY',
7024 
+            LLL : 'D MMMM YYYY HH:mm',
7025 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
7026 
+        },
7027 
+        calendar : {
7028 
+            sameDay : '[Today at] LT',
7029 
+            nextDay : '[Tomorrow at] LT',
7030 
+            nextWeek : 'dddd [at] LT',
7031 
+            lastDay : '[Yesterday at] LT',
7032 
+            lastWeek : '[Last] dddd [at] LT',
7033 
+            sameElse : 'L'
7034 
+        },
7035 
+        relativeTime : {
7036 
+            future : 'in %s',
7037 
+            past : '%s ago',
7038 
+            s : 'a few seconds',
7039 
+            m : 'a minute',
7040 
+            mm : '%d minutes',
7041 
+            h : 'an hour',
7042 
+            hh : '%d hours',
7043 
+            d : 'a day',
7044 
+            dd : '%d days',
7045 
+            M : 'a month',
7046 
+            MM : '%d months',
7047 
+            y : 'a year',
7048 
+            yy : '%d years'
7049 
+        },
7050 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7051 
+        ordinal : function (number) {
7052 
+            var b = number % 10,
7053 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
7054 
+                (b === 1) ? 'st' :
7055 
+                (b === 2) ? 'nd' :
7056 
+                (b === 3) ? 'rd' : 'th';
7057 
+            return number + output;
7058 
+        }
7059 
+    });
7060 
+
7061 
+    //! moment.js locale configuration
7062 
+
7063 
+    hooks.defineLocale('en-nz', {
7064 
+        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
7065 
+        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
7066 
+        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
7067 
+        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
7068 
+        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
7069 
+        longDateFormat : {
7070 
+            LT : 'h:mm A',
7071 
+            LTS : 'h:mm:ss A',
7072 
+            L : 'DD/MM/YYYY',
7073 
+            LL : 'D MMMM YYYY',
7074 
+            LLL : 'D MMMM YYYY h:mm A',
7075 
+            LLLL : 'dddd, D MMMM YYYY h:mm A'
7076 
+        },
7077 
+        calendar : {
7078 
+            sameDay : '[Today at] LT',
7079 
+            nextDay : '[Tomorrow at] LT',
7080 
+            nextWeek : 'dddd [at] LT',
7081 
+            lastDay : '[Yesterday at] LT',
7082 
+            lastWeek : '[Last] dddd [at] LT',
7083 
+            sameElse : 'L'
7084 
+        },
7085 
+        relativeTime : {
7086 
+            future : 'in %s',
7087 
+            past : '%s ago',
7088 
+            s : 'a few seconds',
7089 
+            ss : '%d seconds',
7090 
+            m : 'a minute',
7091 
+            mm : '%d minutes',
7092 
+            h : 'an hour',
7093 
+            hh : '%d hours',
7094 
+            d : 'a day',
7095 
+            dd : '%d days',
7096 
+            M : 'a month',
7097 
+            MM : '%d months',
7098 
+            y : 'a year',
7099 
+            yy : '%d years'
7100 
+        },
7101 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
7102 
+        ordinal : function (number) {
7103 
+            var b = number % 10,
7104 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
7105 
+                (b === 1) ? 'st' :
7106 
+                (b === 2) ? 'nd' :
7107 
+                (b === 3) ? 'rd' : 'th';
7108 
+            return number + output;
7109 
+        },
7110 
+        week : {
7111 
+            dow : 1, // Monday is the first day of the week.
7112 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7113 
+        }
7114 
+    });
7115 
+
7116 
+    //! moment.js locale configuration
7117 
+
7118 
+    hooks.defineLocale('eo', {
7119 
+        months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
7120 
+        monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec'.split('_'),
7121 
+        weekdays : 'dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato'.split('_'),
7122 
+        weekdaysShort : 'dim_lun_mard_merk_ĵaŭ_ven_sab'.split('_'),
7123 
+        weekdaysMin : 'di_lu_ma_me_ĵa_ve_sa'.split('_'),
7124 
+        longDateFormat : {
7125 
+            LT : 'HH:mm',
7126 
+            LTS : 'HH:mm:ss',
7127 
+            L : 'YYYY-MM-DD',
7128 
+            LL : 'D[-a de] MMMM, YYYY',
7129 
+            LLL : 'D[-a de] MMMM, YYYY HH:mm',
7130 
+            LLLL : 'dddd, [la] D[-a de] MMMM, YYYY HH:mm'
7131 
+        },
7132 
+        meridiemParse: /[ap]\.t\.m/i,
7133 
+        isPM: function (input) {
7134 
+            return input.charAt(0).toLowerCase() === 'p';
7135 
+        },
7136 
+        meridiem : function (hours, minutes, isLower) {
7137 
+            if (hours > 11) {
7138 
+                return isLower ? 'p.t.m.' : 'P.T.M.';
7139 
+            } else {
7140 
+                return isLower ? 'a.t.m.' : 'A.T.M.';
7141 
+            }
7142 
+        },
7143 
+        calendar : {
7144 
+            sameDay : '[Hodiaŭ je] LT',
7145 
+            nextDay : '[Morgaŭ je] LT',
7146 
+            nextWeek : 'dddd [je] LT',
7147 
+            lastDay : '[Hieraŭ je] LT',
7148 
+            lastWeek : '[pasinta] dddd [je] LT',
7149 
+            sameElse : 'L'
7150 
+        },
7151 
+        relativeTime : {
7152 
+            future : 'post %s',
7153 
+            past : 'antaŭ %s',
7154 
+            s : 'sekundoj',
7155 
+            ss : '%d sekundoj',
7156 
+            m : 'minuto',
7157 
+            mm : '%d minutoj',
7158 
+            h : 'horo',
7159 
+            hh : '%d horoj',
7160 
+            d : 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
7161 
+            dd : '%d tagoj',
7162 
+            M : 'monato',
7163 
+            MM : '%d monatoj',
7164 
+            y : 'jaro',
7165 
+            yy : '%d jaroj'
7166 
+        },
7167 
+        dayOfMonthOrdinalParse: /\d{1,2}a/,
7168 
+        ordinal : '%da',
7169 
+        week : {
7170 
+            dow : 1, // Monday is the first day of the week.
7171 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
7172 
+        }
7173 
+    });
7174 
+
7175 
+    //! moment.js locale configuration
7176 
+
7177 
+    var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7178 
+        monthsShort$1 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7179 
+
7180 
+    var monthsParse$1 = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i];
7181 
+    var monthsRegex$2 = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
7182 
+
7183 
+    hooks.defineLocale('es-do', {
7184 
+        months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7185 
+        monthsShort : function (m, format) {
7186 
+            if (!m) {
7187 
+                return monthsShortDot;
7188 
+            } else if (/-MMM-/.test(format)) {
7189 
+                return monthsShort$1[m.month()];
7190 
+            } else {
7191 
+                return monthsShortDot[m.month()];
7192 
+            }
7193 
+        },
7194 
+        monthsRegex: monthsRegex$2,
7195 
+        monthsShortRegex: monthsRegex$2,
7196 
+        monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
7197 
+        monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
7198 
+        monthsParse: monthsParse$1,
7199 
+        longMonthsParse: monthsParse$1,
7200 
+        shortMonthsParse: monthsParse$1,
7201 
+        weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7202 
+        weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7203 
+        weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7204 
+        weekdaysParseExact : true,
7205 
+        longDateFormat : {
7206 
+            LT : 'h:mm A',
7207 
+            LTS : 'h:mm:ss A',
7208 
+            L : 'DD/MM/YYYY',
7209 
+            LL : 'D [de] MMMM [de] YYYY',
7210 
+            LLL : 'D [de] MMMM [de] YYYY h:mm A',
7211 
+            LLLL : 'dddd, D [de] MMMM [de] YYYY h:mm A'
7212 
+        },
7213 
+        calendar : {
7214 
+            sameDay : function () {
7215 
+                return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7216 
+            },
7217 
+            nextDay : function () {
7218 
+                return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7219 
+            },
7220 
+            nextWeek : function () {
7221 
+                return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7222 
+            },
7223 
+            lastDay : function () {
7224 
+                return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7225 
+            },
7226 
+            lastWeek : function () {
7227 
+                return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7228 
+            },
7229 
+            sameElse : 'L'
7230 
+        },
7231 
+        relativeTime : {
7232 
+            future : 'en %s',
7233 
+            past : 'hace %s',
7234 
+            s : 'unos segundos',
7235 
+            ss : '%d segundos',
7236 
+            m : 'un minuto',
7237 
+            mm : '%d minutos',
7238 
+            h : 'una hora',
7239 
+            hh : '%d horas',
7240 
+            d : 'un día',
7241 
+            dd : '%d días',
7242 
+            M : 'un mes',
7243 
+            MM : '%d meses',
7244 
+            y : 'un año',
7245 
+            yy : '%d años'
7246 
+        },
7247 
+        dayOfMonthOrdinalParse : /\d{1,2}º/,
7248 
+        ordinal : '%dº',
7249 
+        week : {
7250 
+            dow : 1, // Monday is the first day of the week.
7251 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7252 
+        }
7253 
+    });
7254 
+
7255 
+    //! moment.js locale configuration
7256 
+
7257 
+    var monthsShortDot$1 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7258 
+        monthsShort$2 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7259 
+
7260 
+    var monthsParse$2 = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i];
7261 
+    var monthsRegex$3 = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
7262 
+
7263 
+    hooks.defineLocale('es-us', {
7264 
+        months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7265 
+        monthsShort : function (m, format) {
7266 
+            if (!m) {
7267 
+                return monthsShortDot$1;
7268 
+            } else if (/-MMM-/.test(format)) {
7269 
+                return monthsShort$2[m.month()];
7270 
+            } else {
7271 
+                return monthsShortDot$1[m.month()];
7272 
+            }
7273 
+        },
7274 
+        monthsRegex: monthsRegex$3,
7275 
+        monthsShortRegex: monthsRegex$3,
7276 
+        monthsStrictRegex: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
7277 
+        monthsShortStrictRegex: /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
7278 
+        monthsParse: monthsParse$2,
7279 
+        longMonthsParse: monthsParse$2,
7280 
+        shortMonthsParse: monthsParse$2,
7281 
+        weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7282 
+        weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7283 
+        weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7284 
+        weekdaysParseExact : true,
7285 
+        longDateFormat : {
7286 
+            LT : 'h:mm A',
7287 
+            LTS : 'h:mm:ss A',
7288 
+            L : 'MM/DD/YYYY',
7289 
+            LL : 'D [de] MMMM [de] YYYY',
7290 
+            LLL : 'D [de] MMMM [de] YYYY h:mm A',
7291 
+            LLLL : 'dddd, D [de] MMMM [de] YYYY h:mm A'
7292 
+        },
7293 
+        calendar : {
7294 
+            sameDay : function () {
7295 
+                return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7296 
+            },
7297 
+            nextDay : function () {
7298 
+                return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7299 
+            },
7300 
+            nextWeek : function () {
7301 
+                return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7302 
+            },
7303 
+            lastDay : function () {
7304 
+                return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7305 
+            },
7306 
+            lastWeek : function () {
7307 
+                return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7308 
+            },
7309 
+            sameElse : 'L'
7310 
+        },
7311 
+        relativeTime : {
7312 
+            future : 'en %s',
7313 
+            past : 'hace %s',
7314 
+            s : 'unos segundos',
7315 
+            ss : '%d segundos',
7316 
+            m : 'un minuto',
7317 
+            mm : '%d minutos',
7318 
+            h : 'una hora',
7319 
+            hh : '%d horas',
7320 
+            d : 'un día',
7321 
+            dd : '%d días',
7322 
+            M : 'un mes',
7323 
+            MM : '%d meses',
7324 
+            y : 'un año',
7325 
+            yy : '%d años'
7326 
+        },
7327 
+        dayOfMonthOrdinalParse : /\d{1,2}º/,
7328 
+        ordinal : '%dº',
7329 
+        week : {
7330 
+            dow : 0, // Sunday is the first day of the week.
7331 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
7332 
+        }
7333 
+    });
7334 
+
7335 
+    //! moment.js locale configuration
7336 
+
7337 
+    var monthsShortDot$2 = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
7338 
+        monthsShort$3 = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');
7339 
+
7340 
+    var monthsParse$3 = [/^ene/i, /^feb/i, /^mar/i, /^abr/i, /^may/i, /^jun/i, /^jul/i, /^ago/i, /^sep/i, /^oct/i, /^nov/i, /^dic/i];
7341 
+    var monthsRegex$4 = /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;
7342 
+
7343 
+    hooks.defineLocale('es', {
7344 
+        months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
7345 
+        monthsShort : function (m, format) {
7346 
+            if (!m) {
7347 
+                return monthsShortDot$2;
7348 
+            } else if (/-MMM-/.test(format)) {
7349 
+                return monthsShort$3[m.month()];
7350 
+            } else {
7351 
+                return monthsShortDot$2[m.month()];
7352 
+            }
7353 
+        },
7354 
+        monthsRegex : monthsRegex$4,
7355 
+        monthsShortRegex : monthsRegex$4,
7356 
+        monthsStrictRegex : /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,
7357 
+        monthsShortStrictRegex : /^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,
7358 
+        monthsParse : monthsParse$3,
7359 
+        longMonthsParse : monthsParse$3,
7360 
+        shortMonthsParse : monthsParse$3,
7361 
+        weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
7362 
+        weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
7363 
+        weekdaysMin : 'do_lu_ma_mi_ju_vi_sá'.split('_'),
7364 
+        weekdaysParseExact : true,
7365 
+        longDateFormat : {
7366 
+            LT : 'H:mm',
7367 
+            LTS : 'H:mm:ss',
7368 
+            L : 'DD/MM/YYYY',
7369 
+            LL : 'D [de] MMMM [de] YYYY',
7370 
+            LLL : 'D [de] MMMM [de] YYYY H:mm',
7371 
+            LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
7372 
+        },
7373 
+        calendar : {
7374 
+            sameDay : function () {
7375 
+                return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7376 
+            },
7377 
+            nextDay : function () {
7378 
+                return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7379 
+            },
7380 
+            nextWeek : function () {
7381 
+                return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7382 
+            },
7383 
+            lastDay : function () {
7384 
+                return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7385 
+            },
7386 
+            lastWeek : function () {
7387 
+                return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
7388 
+            },
7389 
+            sameElse : 'L'
7390 
+        },
7391 
+        relativeTime : {
7392 
+            future : 'en %s',
7393 
+            past : 'hace %s',
7394 
+            s : 'unos segundos',
7395 
+            ss : '%d segundos',
7396 
+            m : 'un minuto',
7397 
+            mm : '%d minutos',
7398 
+            h : 'una hora',
7399 
+            hh : '%d horas',
7400 
+            d : 'un día',
7401 
+            dd : '%d días',
7402 
+            M : 'un mes',
7403 
+            MM : '%d meses',
7404 
+            y : 'un año',
7405 
+            yy : '%d años'
7406 
+        },
7407 
+        dayOfMonthOrdinalParse : /\d{1,2}º/,
7408 
+        ordinal : '%dº',
7409 
+        week : {
7410 
+            dow : 1, // Monday is the first day of the week.
7411 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7412 
+        }
7413 
+    });
7414 
+
7415 
+    //! moment.js locale configuration
7416 
+
7417 
+    function processRelativeTime$3(number, withoutSuffix, key, isFuture) {
7418 
+        var format = {
7419 
+            's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
7420 
+            'ss': [number + 'sekundi', number + 'sekundit'],
7421 
+            'm' : ['ühe minuti', 'üks minut'],
7422 
+            'mm': [number + ' minuti', number + ' minutit'],
7423 
+            'h' : ['ühe tunni', 'tund aega', 'üks tund'],
7424 
+            'hh': [number + ' tunni', number + ' tundi'],
7425 
+            'd' : ['ühe päeva', 'üks päev'],
7426 
+            'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
7427 
+            'MM': [number + ' kuu', number + ' kuud'],
7428 
+            'y' : ['ühe aasta', 'aasta', 'üks aasta'],
7429 
+            'yy': [number + ' aasta', number + ' aastat']
7430 
+        };
7431 
+        if (withoutSuffix) {
7432 
+            return format[key][2] ? format[key][2] : format[key][1];
7433 
+        }
7434 
+        return isFuture ? format[key][0] : format[key][1];
7435 
+    }
7436 
+
7437 
+    hooks.defineLocale('et', {
7438 
+        months        : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
7439 
+        monthsShort   : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
7440 
+        weekdays      : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
7441 
+        weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
7442 
+        weekdaysMin   : 'P_E_T_K_N_R_L'.split('_'),
7443 
+        longDateFormat : {
7444 
+            LT   : 'H:mm',
7445 
+            LTS : 'H:mm:ss',
7446 
+            L    : 'DD.MM.YYYY',
7447 
+            LL   : 'D. MMMM YYYY',
7448 
+            LLL  : 'D. MMMM YYYY H:mm',
7449 
+            LLLL : 'dddd, D. MMMM YYYY H:mm'
7450 
+        },
7451 
+        calendar : {
7452 
+            sameDay  : '[Täna,] LT',
7453 
+            nextDay  : '[Homme,] LT',
7454 
+            nextWeek : '[Järgmine] dddd LT',
7455 
+            lastDay  : '[Eile,] LT',
7456 
+            lastWeek : '[Eelmine] dddd LT',
7457 
+            sameElse : 'L'
7458 
+        },
7459 
+        relativeTime : {
7460 
+            future : '%s pärast',
7461 
+            past   : '%s tagasi',
7462 
+            s      : processRelativeTime$3,
7463 
+            ss     : processRelativeTime$3,
7464 
+            m      : processRelativeTime$3,
7465 
+            mm     : processRelativeTime$3,
7466 
+            h      : processRelativeTime$3,
7467 
+            hh     : processRelativeTime$3,
7468 
+            d      : processRelativeTime$3,
7469 
+            dd     : '%d päeva',
7470 
+            M      : processRelativeTime$3,
7471 
+            MM     : processRelativeTime$3,
7472 
+            y      : processRelativeTime$3,
7473 
+            yy     : processRelativeTime$3
7474 
+        },
7475 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
7476 
+        ordinal : '%d.',
7477 
+        week : {
7478 
+            dow : 1, // Monday is the first day of the week.
7479 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7480 
+        }
7481 
+    });
7482 
+
7483 
+    //! moment.js locale configuration
7484 
+
7485 
+    hooks.defineLocale('eu', {
7486 
+        months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
7487 
+        monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
7488 
+        monthsParseExact : true,
7489 
+        weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
7490 
+        weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
7491 
+        weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
7492 
+        weekdaysParseExact : true,
7493 
+        longDateFormat : {
7494 
+            LT : 'HH:mm',
7495 
+            LTS : 'HH:mm:ss',
7496 
+            L : 'YYYY-MM-DD',
7497 
+            LL : 'YYYY[ko] MMMM[ren] D[a]',
7498 
+            LLL : 'YYYY[ko] MMMM[ren] D[a] HH:mm',
7499 
+            LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] HH:mm',
7500 
+            l : 'YYYY-M-D',
7501 
+            ll : 'YYYY[ko] MMM D[a]',
7502 
+            lll : 'YYYY[ko] MMM D[a] HH:mm',
7503 
+            llll : 'ddd, YYYY[ko] MMM D[a] HH:mm'
7504 
+        },
7505 
+        calendar : {
7506 
+            sameDay : '[gaur] LT[etan]',
7507 
+            nextDay : '[bihar] LT[etan]',
7508 
+            nextWeek : 'dddd LT[etan]',
7509 
+            lastDay : '[atzo] LT[etan]',
7510 
+            lastWeek : '[aurreko] dddd LT[etan]',
7511 
+            sameElse : 'L'
7512 
+        },
7513 
+        relativeTime : {
7514 
+            future : '%s barru',
7515 
+            past : 'duela %s',
7516 
+            s : 'segundo batzuk',
7517 
+            ss : '%d segundo',
7518 
+            m : 'minutu bat',
7519 
+            mm : '%d minutu',
7520 
+            h : 'ordu bat',
7521 
+            hh : '%d ordu',
7522 
+            d : 'egun bat',
7523 
+            dd : '%d egun',
7524 
+            M : 'hilabete bat',
7525 
+            MM : '%d hilabete',
7526 
+            y : 'urte bat',
7527 
+            yy : '%d urte'
7528 
+        },
7529 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
7530 
+        ordinal : '%d.',
7531 
+        week : {
7532 
+            dow : 1, // Monday is the first day of the week.
7533 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
7534 
+        }
7535 
+    });
7536 
+
7537 
+    //! moment.js locale configuration
7538 
+
7539 
+    var symbolMap$5 = {
7540 
+        '1': '۱',
7541 
+        '2': '۲',
7542 
+        '3': '۳',
7543 
+        '4': '۴',
7544 
+        '5': '۵',
7545 
+        '6': '۶',
7546 
+        '7': '۷',
7547 
+        '8': '۸',
7548 
+        '9': '۹',
7549 
+        '0': '۰'
7550 
+    }, numberMap$4 = {
7551 
+        '۱': '1',
7552 
+        '۲': '2',
7553 
+        '۳': '3',
7554 
+        '۴': '4',
7555 
+        '۵': '5',
7556 
+        '۶': '6',
7557 
+        '۷': '7',
7558 
+        '۸': '8',
7559 
+        '۹': '9',
7560 
+        '۰': '0'
7561 
+    };
7562 
+
7563 
+    hooks.defineLocale('fa', {
7564 
+        months : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
7565 
+        monthsShort : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
7566 
+        weekdays : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
7567 
+        weekdaysShort : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
7568 
+        weekdaysMin : 'ی_د_س_چ_پ_ج_ش'.split('_'),
7569 
+        weekdaysParseExact : true,
7570 
+        longDateFormat : {
7571 
+            LT : 'HH:mm',
7572 
+            LTS : 'HH:mm:ss',
7573 
+            L : 'DD/MM/YYYY',
7574 
+            LL : 'D MMMM YYYY',
7575 
+            LLL : 'D MMMM YYYY HH:mm',
7576 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
7577 
+        },
7578 
+        meridiemParse: /قبل از ظهر|بعد از ظهر/,
7579 
+        isPM: function (input) {
7580 
+            return /بعد از ظهر/.test(input);
7581 
+        },
7582 
+        meridiem : function (hour, minute, isLower) {
7583 
+            if (hour < 12) {
7584 
+                return 'قبل از ظهر';
7585 
+            } else {
7586 
+                return 'بعد از ظهر';
7587 
+            }
7588 
+        },
7589 
+        calendar : {
7590 
+            sameDay : '[امروز ساعت] LT',
7591 
+            nextDay : '[فردا ساعت] LT',
7592 
+            nextWeek : 'dddd [ساعت] LT',
7593 
+            lastDay : '[دیروز ساعت] LT',
7594 
+            lastWeek : 'dddd [پیش] [ساعت] LT',
7595 
+            sameElse : 'L'
7596 
+        },
7597 
+        relativeTime : {
7598 
+            future : 'در %s',
7599 
+            past : '%s پیش',
7600 
+            s : 'چند ثانیه',
7601 
+            ss : 'ثانیه d%',
7602 
+            m : 'یک دقیقه',
7603 
+            mm : '%d دقیقه',
7604 
+            h : 'یک ساعت',
7605 
+            hh : '%d ساعت',
7606 
+            d : 'یک روز',
7607 
+            dd : '%d روز',
7608 
+            M : 'یک ماه',
7609 
+            MM : '%d ماه',
7610 
+            y : 'یک سال',
7611 
+            yy : '%d سال'
7612 
+        },
7613 
+        preparse: function (string) {
7614 
+            return string.replace(/[۰-۹]/g, function (match) {
7615 
+                return numberMap$4[match];
7616 
+            }).replace(/،/g, ',');
7617 
+        },
7618 
+        postformat: function (string) {
7619 
+            return string.replace(/\d/g, function (match) {
7620 
+                return symbolMap$5[match];
7621 
+            }).replace(/,/g, '،');
7622 
+        },
7623 
+        dayOfMonthOrdinalParse: /\d{1,2}م/,
7624 
+        ordinal : '%dم',
7625 
+        week : {
7626 
+            dow : 6, // Saturday is the first day of the week.
7627 
+            doy : 12 // The week that contains Jan 12th is the first week of the year.
7628 
+        }
7629 
+    });
7630 
+
7631 
+    //! moment.js locale configuration
7632 
+
7633 
+    var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '),
7634 
+        numbersFuture = [
7635 
+            'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
7636 
+            numbersPast[7], numbersPast[8], numbersPast[9]
7637 
+        ];
7638 
+    function translate$2(number, withoutSuffix, key, isFuture) {
7639 
+        var result = '';
7640 
+        switch (key) {
7641 
+            case 's':
7642 
+                return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
7643 
+            case 'ss':
7644 
+                return isFuture ? 'sekunnin' : 'sekuntia';
7645 
+            case 'm':
7646 
+                return isFuture ? 'minuutin' : 'minuutti';
7647 
+            case 'mm':
7648 
+                result = isFuture ? 'minuutin' : 'minuuttia';
7649 
+                break;
7650 
+            case 'h':
7651 
+                return isFuture ? 'tunnin' : 'tunti';
7652 
+            case 'hh':
7653 
+                result = isFuture ? 'tunnin' : 'tuntia';
7654 
+                break;
7655 
+            case 'd':
7656 
+                return isFuture ? 'päivän' : 'päivä';
7657 
+            case 'dd':
7658 
+                result = isFuture ? 'päivän' : 'päivää';
7659 
+                break;
7660 
+            case 'M':
7661 
+                return isFuture ? 'kuukauden' : 'kuukausi';
7662 
+            case 'MM':
7663 
+                result = isFuture ? 'kuukauden' : 'kuukautta';
7664 
+                break;
7665 
+            case 'y':
7666 
+                return isFuture ? 'vuoden' : 'vuosi';
7667 
+            case 'yy':
7668 
+                result = isFuture ? 'vuoden' : 'vuotta';
7669 
+                break;
7670 
+        }
7671 
+        result = verbalNumber(number, isFuture) + ' ' + result;
7672 
+        return result;
7673 
+    }
7674 
+    function verbalNumber(number, isFuture) {
7675 
+        return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;
7676 
+    }
7677 
+
7678 
+    hooks.defineLocale('fi', {
7679 
+        months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
7680 
+        monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
7681 
+        weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
7682 
+        weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
7683 
+        weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
7684 
+        longDateFormat : {
7685 
+            LT : 'HH.mm',
7686 
+            LTS : 'HH.mm.ss',
7687 
+            L : 'DD.MM.YYYY',
7688 
+            LL : 'Do MMMM[ta] YYYY',
7689 
+            LLL : 'Do MMMM[ta] YYYY, [klo] HH.mm',
7690 
+            LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] HH.mm',
7691 
+            l : 'D.M.YYYY',
7692 
+            ll : 'Do MMM YYYY',
7693 
+            lll : 'Do MMM YYYY, [klo] HH.mm',
7694 
+            llll : 'ddd, Do MMM YYYY, [klo] HH.mm'
7695 
+        },
7696 
+        calendar : {
7697 
+            sameDay : '[tänään] [klo] LT',
7698 
+            nextDay : '[huomenna] [klo] LT',
7699 
+            nextWeek : 'dddd [klo] LT',
7700 
+            lastDay : '[eilen] [klo] LT',
7701 
+            lastWeek : '[viime] dddd[na] [klo] LT',
7702 
+            sameElse : 'L'
7703 
+        },
7704 
+        relativeTime : {
7705 
+            future : '%s päästä',
7706 
+            past : '%s sitten',
7707 
+            s : translate$2,
7708 
+            ss : translate$2,
7709 
+            m : translate$2,
7710 
+            mm : translate$2,
7711 
+            h : translate$2,
7712 
+            hh : translate$2,
7713 
+            d : translate$2,
7714 
+            dd : translate$2,
7715 
+            M : translate$2,
7716 
+            MM : translate$2,
7717 
+            y : translate$2,
7718 
+            yy : translate$2
7719 
+        },
7720 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
7721 
+        ordinal : '%d.',
7722 
+        week : {
7723 
+            dow : 1, // Monday is the first day of the week.
7724 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7725 
+        }
7726 
+    });
7727 
+
7728 
+    //! moment.js locale configuration
7729 
+
7730 
+    hooks.defineLocale('fo', {
7731 
+        months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
7732 
+        monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
7733 
+        weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
7734 
+        weekdaysShort : 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
7735 
+        weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'),
7736 
+        longDateFormat : {
7737 
+            LT : 'HH:mm',
7738 
+            LTS : 'HH:mm:ss',
7739 
+            L : 'DD/MM/YYYY',
7740 
+            LL : 'D MMMM YYYY',
7741 
+            LLL : 'D MMMM YYYY HH:mm',
7742 
+            LLLL : 'dddd D. MMMM, YYYY HH:mm'
7743 
+        },
7744 
+        calendar : {
7745 
+            sameDay : '[Í dag kl.] LT',
7746 
+            nextDay : '[Í morgin kl.] LT',
7747 
+            nextWeek : 'dddd [kl.] LT',
7748 
+            lastDay : '[Í gjár kl.] LT',
7749 
+            lastWeek : '[síðstu] dddd [kl] LT',
7750 
+            sameElse : 'L'
7751 
+        },
7752 
+        relativeTime : {
7753 
+            future : 'um %s',
7754 
+            past : '%s síðani',
7755 
+            s : 'fá sekund',
7756 
+            ss : '%d sekundir',
7757 
+            m : 'ein minuttur',
7758 
+            mm : '%d minuttir',
7759 
+            h : 'ein tími',
7760 
+            hh : '%d tímar',
7761 
+            d : 'ein dagur',
7762 
+            dd : '%d dagar',
7763 
+            M : 'ein mánaður',
7764 
+            MM : '%d mánaðir',
7765 
+            y : 'eitt ár',
7766 
+            yy : '%d ár'
7767 
+        },
7768 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
7769 
+        ordinal : '%d.',
7770 
+        week : {
7771 
+            dow : 1, // Monday is the first day of the week.
7772 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7773 
+        }
7774 
+    });
7775 
+
7776 
+    //! moment.js locale configuration
7777 
+
7778 
+    hooks.defineLocale('fr-ca', {
7779 
+        months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
7780 
+        monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
7781 
+        monthsParseExact : true,
7782 
+        weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7783 
+        weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7784 
+        weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'),
7785 
+        weekdaysParseExact : true,
7786 
+        longDateFormat : {
7787 
+            LT : 'HH:mm',
7788 
+            LTS : 'HH:mm:ss',
7789 
+            L : 'YYYY-MM-DD',
7790 
+            LL : 'D MMMM YYYY',
7791 
+            LLL : 'D MMMM YYYY HH:mm',
7792 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
7793 
+        },
7794 
+        calendar : {
7795 
+            sameDay : '[Aujourd’hui à] LT',
7796 
+            nextDay : '[Demain à] LT',
7797 
+            nextWeek : 'dddd [à] LT',
7798 
+            lastDay : '[Hier à] LT',
7799 
+            lastWeek : 'dddd [dernier à] LT',
7800 
+            sameElse : 'L'
7801 
+        },
7802 
+        relativeTime : {
7803 
+            future : 'dans %s',
7804 
+            past : 'il y a %s',
7805 
+            s : 'quelques secondes',
7806 
+            ss : '%d secondes',
7807 
+            m : 'une minute',
7808 
+            mm : '%d minutes',
7809 
+            h : 'une heure',
7810 
+            hh : '%d heures',
7811 
+            d : 'un jour',
7812 
+            dd : '%d jours',
7813 
+            M : 'un mois',
7814 
+            MM : '%d mois',
7815 
+            y : 'un an',
7816 
+            yy : '%d ans'
7817 
+        },
7818 
+        dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
7819 
+        ordinal : function (number, period) {
7820 
+            switch (period) {
7821 
+                // Words with masculine grammatical gender: mois, trimestre, jour
7822 
+                default:
7823 
+                case 'M':
7824 
+                case 'Q':
7825 
+                case 'D':
7826 
+                case 'DDD':
7827 
+                case 'd':
7828 
+                    return number + (number === 1 ? 'er' : 'e');
7829 
+
7830 
+                // Words with feminine grammatical gender: semaine
7831 
+                case 'w':
7832 
+                case 'W':
7833 
+                    return number + (number === 1 ? 're' : 'e');
7834 
+            }
7835 
+        }
7836 
+    });
7837 
+
7838 
+    //! moment.js locale configuration
7839 
+
7840 
+    hooks.defineLocale('fr-ch', {
7841 
+        months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
7842 
+        monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
7843 
+        monthsParseExact : true,
7844 
+        weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7845 
+        weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7846 
+        weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'),
7847 
+        weekdaysParseExact : true,
7848 
+        longDateFormat : {
7849 
+            LT : 'HH:mm',
7850 
+            LTS : 'HH:mm:ss',
7851 
+            L : 'DD.MM.YYYY',
7852 
+            LL : 'D MMMM YYYY',
7853 
+            LLL : 'D MMMM YYYY HH:mm',
7854 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
7855 
+        },
7856 
+        calendar : {
7857 
+            sameDay : '[Aujourd’hui à] LT',
7858 
+            nextDay : '[Demain à] LT',
7859 
+            nextWeek : 'dddd [à] LT',
7860 
+            lastDay : '[Hier à] LT',
7861 
+            lastWeek : 'dddd [dernier à] LT',
7862 
+            sameElse : 'L'
7863 
+        },
7864 
+        relativeTime : {
7865 
+            future : 'dans %s',
7866 
+            past : 'il y a %s',
7867 
+            s : 'quelques secondes',
7868 
+            ss : '%d secondes',
7869 
+            m : 'une minute',
7870 
+            mm : '%d minutes',
7871 
+            h : 'une heure',
7872 
+            hh : '%d heures',
7873 
+            d : 'un jour',
7874 
+            dd : '%d jours',
7875 
+            M : 'un mois',
7876 
+            MM : '%d mois',
7877 
+            y : 'un an',
7878 
+            yy : '%d ans'
7879 
+        },
7880 
+        dayOfMonthOrdinalParse: /\d{1,2}(er|e)/,
7881 
+        ordinal : function (number, period) {
7882 
+            switch (period) {
7883 
+                // Words with masculine grammatical gender: mois, trimestre, jour
7884 
+                default:
7885 
+                case 'M':
7886 
+                case 'Q':
7887 
+                case 'D':
7888 
+                case 'DDD':
7889 
+                case 'd':
7890 
+                    return number + (number === 1 ? 'er' : 'e');
7891 
+
7892 
+                // Words with feminine grammatical gender: semaine
7893 
+                case 'w':
7894 
+                case 'W':
7895 
+                    return number + (number === 1 ? 're' : 'e');
7896 
+            }
7897 
+        },
7898 
+        week : {
7899 
+            dow : 1, // Monday is the first day of the week.
7900 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7901 
+        }
7902 
+    });
7903 
+
7904 
+    //! moment.js locale configuration
7905 
+
7906 
+    hooks.defineLocale('fr', {
7907 
+        months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
7908 
+        monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
7909 
+        monthsParseExact : true,
7910 
+        weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
7911 
+        weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
7912 
+        weekdaysMin : 'di_lu_ma_me_je_ve_sa'.split('_'),
7913 
+        weekdaysParseExact : true,
7914 
+        longDateFormat : {
7915 
+            LT : 'HH:mm',
7916 
+            LTS : 'HH:mm:ss',
7917 
+            L : 'DD/MM/YYYY',
7918 
+            LL : 'D MMMM YYYY',
7919 
+            LLL : 'D MMMM YYYY HH:mm',
7920 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
7921 
+        },
7922 
+        calendar : {
7923 
+            sameDay : '[Aujourd’hui à] LT',
7924 
+            nextDay : '[Demain à] LT',
7925 
+            nextWeek : 'dddd [à] LT',
7926 
+            lastDay : '[Hier à] LT',
7927 
+            lastWeek : 'dddd [dernier à] LT',
7928 
+            sameElse : 'L'
7929 
+        },
7930 
+        relativeTime : {
7931 
+            future : 'dans %s',
7932 
+            past : 'il y a %s',
7933 
+            s : 'quelques secondes',
7934 
+            ss : '%d secondes',
7935 
+            m : 'une minute',
7936 
+            mm : '%d minutes',
7937 
+            h : 'une heure',
7938 
+            hh : '%d heures',
7939 
+            d : 'un jour',
7940 
+            dd : '%d jours',
7941 
+            M : 'un mois',
7942 
+            MM : '%d mois',
7943 
+            y : 'un an',
7944 
+            yy : '%d ans'
7945 
+        },
7946 
+        dayOfMonthOrdinalParse: /\d{1,2}(er|)/,
7947 
+        ordinal : function (number, period) {
7948 
+            switch (period) {
7949 
+                // TODO: Return 'e' when day of month > 1. Move this case inside
7950 
+                // block for masculine words below.
7951 
+                // See https://github.com/moment/moment/issues/3375
7952 
+                case 'D':
7953 
+                    return number + (number === 1 ? 'er' : '');
7954 
+
7955 
+                // Words with masculine grammatical gender: mois, trimestre, jour
7956 
+                default:
7957 
+                case 'M':
7958 
+                case 'Q':
7959 
+                case 'DDD':
7960 
+                case 'd':
7961 
+                    return number + (number === 1 ? 'er' : 'e');
7962 
+
7963 
+                // Words with feminine grammatical gender: semaine
7964 
+                case 'w':
7965 
+                case 'W':
7966 
+                    return number + (number === 1 ? 're' : 'e');
7967 
+            }
7968 
+        },
7969 
+        week : {
7970 
+            dow : 1, // Monday is the first day of the week.
7971 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
7972 
+        }
7973 
+    });
7974 
+
7975 
+    //! moment.js locale configuration
7976 
+
7977 
+    var monthsShortWithDots = 'jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.'.split('_'),
7978 
+        monthsShortWithoutDots = 'jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_');
7979 
+
7980 
+    hooks.defineLocale('fy', {
7981 
+        months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
7982 
+        monthsShort : function (m, format) {
7983 
+            if (!m) {
7984 
+                return monthsShortWithDots;
7985 
+            } else if (/-MMM-/.test(format)) {
7986 
+                return monthsShortWithoutDots[m.month()];
7987 
+            } else {
7988 
+                return monthsShortWithDots[m.month()];
7989 
+            }
7990 
+        },
7991 
+        monthsParseExact : true,
7992 
+        weekdays : 'snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon'.split('_'),
7993 
+        weekdaysShort : 'si._mo._ti._wo._to._fr._so.'.split('_'),
7994 
+        weekdaysMin : 'Si_Mo_Ti_Wo_To_Fr_So'.split('_'),
7995 
+        weekdaysParseExact : true,
7996 
+        longDateFormat : {
7997 
+            LT : 'HH:mm',
7998 
+            LTS : 'HH:mm:ss',
7999 
+            L : 'DD-MM-YYYY',
8000 
+            LL : 'D MMMM YYYY',
8001 
+            LLL : 'D MMMM YYYY HH:mm',
8002 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
8003 
+        },
8004 
+        calendar : {
8005 
+            sameDay: '[hjoed om] LT',
8006 
+            nextDay: '[moarn om] LT',
8007 
+            nextWeek: 'dddd [om] LT',
8008 
+            lastDay: '[juster om] LT',
8009 
+            lastWeek: '[ôfrûne] dddd [om] LT',
8010 
+            sameElse: 'L'
8011 
+        },
8012 
+        relativeTime : {
8013 
+            future : 'oer %s',
8014 
+            past : '%s lyn',
8015 
+            s : 'in pear sekonden',
8016 
+            ss : '%d sekonden',
8017 
+            m : 'ien minút',
8018 
+            mm : '%d minuten',
8019 
+            h : 'ien oere',
8020 
+            hh : '%d oeren',
8021 
+            d : 'ien dei',
8022 
+            dd : '%d dagen',
8023 
+            M : 'ien moanne',
8024 
+            MM : '%d moannen',
8025 
+            y : 'ien jier',
8026 
+            yy : '%d jierren'
8027 
+        },
8028 
+        dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
8029 
+        ordinal : function (number) {
8030 
+            return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
8031 
+        },
8032 
+        week : {
8033 
+            dow : 1, // Monday is the first day of the week.
8034 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
8035 
+        }
8036 
+    });
8037 
+
8038 
+    //! moment.js locale configuration
8039 
+
8040 
+
8041 
+    var months$5 = [
8042 
+        'Eanáir', 'Feabhra', 'Márta', 'Aibreán', 'Bealtaine', 'Méitheamh', 'Iúil', 'Lúnasa', 'Meán Fómhair', 'Deaireadh Fómhair', 'Samhain', 'Nollaig'
8043 
+    ];
8044 
+
8045 
+    var monthsShort$4 = ['Eaná', 'Feab', 'Márt', 'Aibr', 'Beal', 'Méit', 'Iúil', 'Lúna', 'Meán', 'Deai', 'Samh', 'Noll'];
8046 
+
8047 
+    var weekdays$1 = ['Dé Domhnaigh', 'Dé Luain', 'Dé Máirt', 'Dé Céadaoin', 'Déardaoin', 'Dé hAoine', 'Dé Satharn'];
8048 
+
8049 
+    var weekdaysShort = ['Dom', 'Lua', 'Mái', 'Céa', 'Déa', 'hAo', 'Sat'];
8050 
+
8051 
+    var weekdaysMin = ['Do', 'Lu', 'Má', 'Ce', 'Dé', 'hA', 'Sa'];
8052 
+
8053 
+    hooks.defineLocale('ga', {
8054 
+        months: months$5,
8055 
+        monthsShort: monthsShort$4,
8056 
+        monthsParseExact: true,
8057 
+        weekdays: weekdays$1,
8058 
+        weekdaysShort: weekdaysShort,
8059 
+        weekdaysMin: weekdaysMin,
8060 
+        longDateFormat: {
8061 
+            LT: 'HH:mm',
8062 
+            LTS: 'HH:mm:ss',
8063 
+            L: 'DD/MM/YYYY',
8064 
+            LL: 'D MMMM YYYY',
8065 
+            LLL: 'D MMMM YYYY HH:mm',
8066 
+            LLLL: 'dddd, D MMMM YYYY HH:mm'
8067 
+        },
8068 
+        calendar: {
8069 
+            sameDay: '[Inniu ag] LT',
8070 
+            nextDay: '[Amárach ag] LT',
8071 
+            nextWeek: 'dddd [ag] LT',
8072 
+            lastDay: '[Inné aig] LT',
8073 
+            lastWeek: 'dddd [seo caite] [ag] LT',
8074 
+            sameElse: 'L'
8075 
+        },
8076 
+        relativeTime: {
8077 
+            future: 'i %s',
8078 
+            past: '%s ó shin',
8079 
+            s: 'cúpla soicind',
8080 
+            ss: '%d soicind',
8081 
+            m: 'nóiméad',
8082 
+            mm: '%d nóiméad',
8083 
+            h: 'uair an chloig',
8084 
+            hh: '%d uair an chloig',
8085 
+            d: 'lá',
8086 
+            dd: '%d lá',
8087 
+            M: 'mí',
8088 
+            MM: '%d mí',
8089 
+            y: 'bliain',
8090 
+            yy: '%d bliain'
8091 
+        },
8092 
+        dayOfMonthOrdinalParse: /\d{1,2}(d|na|mh)/,
8093 
+        ordinal: function (number) {
8094 
+            var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
8095 
+            return number + output;
8096 
+        },
8097 
+        week: {
8098 
+            dow: 1, // Monday is the first day of the week.
8099 
+            doy: 4  // The week that contains Jan 4th is the first week of the year.
8100 
+        }
8101 
+    });
8102 
+
8103 
+    //! moment.js locale configuration
8104 
+
8105 
+    var months$6 = [
8106 
+        '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'
8107 
+    ];
8108 
+
8109 
+    var monthsShort$5 = ['Faoi', 'Gear', 'Màrt', 'Gibl', 'Cèit', 'Ògmh', 'Iuch', 'Lùn', 'Sult', 'Dàmh', 'Samh', 'Dùbh'];
8110 
+
8111 
+    var weekdays$2 = ['Didòmhnaich', 'Diluain', 'Dimàirt', 'Diciadain', 'Diardaoin', 'Dihaoine', 'Disathairne'];
8112 
+
8113 
+    var weekdaysShort$1 = ['Did', 'Dil', 'Dim', 'Dic', 'Dia', 'Dih', 'Dis'];
8114 
+
8115 
+    var weekdaysMin$1 = ['Dò', 'Lu', 'Mà', 'Ci', 'Ar', 'Ha', 'Sa'];
8116 
+
8117 
+    hooks.defineLocale('gd', {
8118 
+        months : months$6,
8119 
+        monthsShort : monthsShort$5,
8120 
+        monthsParseExact : true,
8121 
+        weekdays : weekdays$2,
8122 
+        weekdaysShort : weekdaysShort$1,
8123 
+        weekdaysMin : weekdaysMin$1,
8124 
+        longDateFormat : {
8125 
+            LT : 'HH:mm',
8126 
+            LTS : 'HH:mm:ss',
8127 
+            L : 'DD/MM/YYYY',
8128 
+            LL : 'D MMMM YYYY',
8129 
+            LLL : 'D MMMM YYYY HH:mm',
8130 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
8131 
+        },
8132 
+        calendar : {
8133 
+            sameDay : '[An-diugh aig] LT',
8134 
+            nextDay : '[A-màireach aig] LT',
8135 
+            nextWeek : 'dddd [aig] LT',
8136 
+            lastDay : '[An-dè aig] LT',
8137 
+            lastWeek : 'dddd [seo chaidh] [aig] LT',
8138 
+            sameElse : 'L'
8139 
+        },
8140 
+        relativeTime : {
8141 
+            future : 'ann an %s',
8142 
+            past : 'bho chionn %s',
8143 
+            s : 'beagan diogan',
8144 
+            ss : '%d diogan',
8145 
+            m : 'mionaid',
8146 
+            mm : '%d mionaidean',
8147 
+            h : 'uair',
8148 
+            hh : '%d uairean',
8149 
+            d : 'latha',
8150 
+            dd : '%d latha',
8151 
+            M : 'mìos',
8152 
+            MM : '%d mìosan',
8153 
+            y : 'bliadhna',
8154 
+            yy : '%d bliadhna'
8155 
+        },
8156 
+        dayOfMonthOrdinalParse : /\d{1,2}(d|na|mh)/,
8157 
+        ordinal : function (number) {
8158 
+            var output = number === 1 ? 'd' : number % 10 === 2 ? 'na' : 'mh';
8159 
+            return number + output;
8160 
+        },
8161 
+        week : {
8162 
+            dow : 1, // Monday is the first day of the week.
8163 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
8164 
+        }
8165 
+    });
8166 
+
8167 
+    //! moment.js locale configuration
8168 
+
8169 
+    hooks.defineLocale('gl', {
8170 
+        months : 'xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro'.split('_'),
8171 
+        monthsShort : 'xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.'.split('_'),
8172 
+        monthsParseExact: true,
8173 
+        weekdays : 'domingo_luns_martes_mércores_xoves_venres_sábado'.split('_'),
8174 
+        weekdaysShort : 'dom._lun._mar._mér._xov._ven._sáb.'.split('_'),
8175 
+        weekdaysMin : 'do_lu_ma_mé_xo_ve_sá'.split('_'),
8176 
+        weekdaysParseExact : true,
8177 
+        longDateFormat : {
8178 
+            LT : 'H:mm',
8179 
+            LTS : 'H:mm:ss',
8180 
+            L : 'DD/MM/YYYY',
8181 
+            LL : 'D [de] MMMM [de] YYYY',
8182 
+            LLL : 'D [de] MMMM [de] YYYY H:mm',
8183 
+            LLLL : 'dddd, D [de] MMMM [de] YYYY H:mm'
8184 
+        },
8185 
+        calendar : {
8186 
+            sameDay : function () {
8187 
+                return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
8188 
+            },
8189 
+            nextDay : function () {
8190 
+                return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
8191 
+            },
8192 
+            nextWeek : function () {
8193 
+                return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
8194 
+            },
8195 
+            lastDay : function () {
8196 
+                return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
8197 
+            },
8198 
+            lastWeek : function () {
8199 
+                return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
8200 
+            },
8201 
+            sameElse : 'L'
8202 
+        },
8203 
+        relativeTime : {
8204 
+            future : function (str) {
8205 
+                if (str.indexOf('un') === 0) {
8206 
+                    return 'n' + str;
8207 
+                }
8208 
+                return 'en ' + str;
8209 
+            },
8210 
+            past : 'hai %s',
8211 
+            s : 'uns segundos',
8212 
+            ss : '%d segundos',
8213 
+            m : 'un minuto',
8214 
+            mm : '%d minutos',
8215 
+            h : 'unha hora',
8216 
+            hh : '%d horas',
8217 
+            d : 'un día',
8218 
+            dd : '%d días',
8219 
+            M : 'un mes',
8220 
+            MM : '%d meses',
8221 
+            y : 'un ano',
8222 
+            yy : '%d anos'
8223 
+        },
8224 
+        dayOfMonthOrdinalParse : /\d{1,2}º/,
8225 
+        ordinal : '%dº',
8226 
+        week : {
8227 
+            dow : 1, // Monday is the first day of the week.
8228 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
8229 
+        }
8230 
+    });
8231 
+
8232 
+    //! moment.js locale configuration
8233 
+
8234 
+    function processRelativeTime$4(number, withoutSuffix, key, isFuture) {
8235 
+        var format = {
8236 
+            's': ['thodde secondanim', 'thodde second'],
8237 
+            'ss': [number + ' secondanim', number + ' second'],
8238 
+            'm': ['eka mintan', 'ek minute'],
8239 
+            'mm': [number + ' mintanim', number + ' mintam'],
8240 
+            'h': ['eka voran', 'ek vor'],
8241 
+            'hh': [number + ' voranim', number + ' voram'],
8242 
+            'd': ['eka disan', 'ek dis'],
8243 
+            'dd': [number + ' disanim', number + ' dis'],
8244 
+            'M': ['eka mhoinean', 'ek mhoino'],
8245 
+            'MM': [number + ' mhoineanim', number + ' mhoine'],
8246 
+            'y': ['eka vorsan', 'ek voros'],
8247 
+            'yy': [number + ' vorsanim', number + ' vorsam']
8248 
+        };
8249 
+        return withoutSuffix ? format[key][0] : format[key][1];
8250 
+    }
8251 
+
8252 
+    hooks.defineLocale('gom-latn', {
8253 
+        months : 'Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr'.split('_'),
8254 
+        monthsShort : 'Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.'.split('_'),
8255 
+        monthsParseExact : true,
8256 
+        weekdays : 'Aitar_Somar_Mongllar_Budvar_Brestar_Sukrar_Son\'var'.split('_'),
8257 
+        weekdaysShort : 'Ait._Som._Mon._Bud._Bre._Suk._Son.'.split('_'),
8258 
+        weekdaysMin : 'Ai_Sm_Mo_Bu_Br_Su_Sn'.split('_'),
8259 
+        weekdaysParseExact : true,
8260 
+        longDateFormat : {
8261 
+            LT : 'A h:mm [vazta]',
8262 
+            LTS : 'A h:mm:ss [vazta]',
8263 
+            L : 'DD-MM-YYYY',
8264 
+            LL : 'D MMMM YYYY',
8265 
+            LLL : 'D MMMM YYYY A h:mm [vazta]',
8266 
+            LLLL : 'dddd, MMMM[achea] Do, YYYY, A h:mm [vazta]',
8267 
+            llll: 'ddd, D MMM YYYY, A h:mm [vazta]'
8268 
+        },
8269 
+        calendar : {
8270 
+            sameDay: '[Aiz] LT',
8271 
+            nextDay: '[Faleam] LT',
8272 
+            nextWeek: '[Ieta to] dddd[,] LT',
8273 
+            lastDay: '[Kal] LT',
8274 
+            lastWeek: '[Fatlo] dddd[,] LT',
8275 
+            sameElse: 'L'
8276 
+        },
8277 
+        relativeTime : {
8278 
+            future : '%s',
8279 
+            past : '%s adim',
8280 
+            s : processRelativeTime$4,
8281 
+            ss : processRelativeTime$4,
8282 
+            m : processRelativeTime$4,
8283 
+            mm : processRelativeTime$4,
8284 
+            h : processRelativeTime$4,
8285 
+            hh : processRelativeTime$4,
8286 
+            d : processRelativeTime$4,
8287 
+            dd : processRelativeTime$4,
8288 
+            M : processRelativeTime$4,
8289 
+            MM : processRelativeTime$4,
8290 
+            y : processRelativeTime$4,
8291 
+            yy : processRelativeTime$4
8292 
+        },
8293 
+        dayOfMonthOrdinalParse : /\d{1,2}(er)/,
8294 
+        ordinal : function (number, period) {
8295 
+            switch (period) {
8296 
+                // the ordinal 'er' only applies to day of the month
8297 
+                case 'D':
8298 
+                    return number + 'er';
8299 
+                default:
8300 
+                case 'M':
8301 
+                case 'Q':
8302 
+                case 'DDD':
8303 
+                case 'd':
8304 
+                case 'w':
8305 
+                case 'W':
8306 
+                    return number;
8307 
+            }
8308 
+        },
8309 
+        week : {
8310 
+            dow : 1, // Monday is the first day of the week.
8311 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
8312 
+        },
8313 
+        meridiemParse: /rati|sokalli|donparam|sanje/,
8314 
+        meridiemHour : function (hour, meridiem) {
8315 
+            if (hour === 12) {
8316 
+                hour = 0;
8317 
+            }
8318 
+            if (meridiem === 'rati') {
8319 
+                return hour < 4 ? hour : hour + 12;
8320 
+            } else if (meridiem === 'sokalli') {
8321 
+                return hour;
8322 
+            } else if (meridiem === 'donparam') {
8323 
+                return hour > 12 ? hour : hour + 12;
8324 
+            } else if (meridiem === 'sanje') {
8325 
+                return hour + 12;
8326 
+            }
8327 
+        },
8328 
+        meridiem : function (hour, minute, isLower) {
8329 
+            if (hour < 4) {
8330 
+                return 'rati';
8331 
+            } else if (hour < 12) {
8332 
+                return 'sokalli';
8333 
+            } else if (hour < 16) {
8334 
+                return 'donparam';
8335 
+            } else if (hour < 20) {
8336 
+                return 'sanje';
8337 
+            } else {
8338 
+                return 'rati';
8339 
+            }
8340 
+        }
8341 
+    });
8342 
+
8343 
+    //! moment.js locale configuration
8344 
+
8345 
+    var symbolMap$6 = {
8346 
+            '1': '૧',
8347 
+            '2': '૨',
8348 
+            '3': '૩',
8349 
+            '4': '૪',
8350 
+            '5': '૫',
8351 
+            '6': '૬',
8352 
+            '7': '૭',
8353 
+            '8': '૮',
8354 
+            '9': '૯',
8355 
+            '0': '૦'
8356 
+        },
8357 
+        numberMap$5 = {
8358 
+            '૧': '1',
8359 
+            '૨': '2',
8360 
+            '૩': '3',
8361 
+            '૪': '4',
8362 
+            '૫': '5',
8363 
+            '૬': '6',
8364 
+            '૭': '7',
8365 
+            '૮': '8',
8366 
+            '૯': '9',
8367 
+            '૦': '0'
8368 
+        };
8369 
+
8370 
+    hooks.defineLocale('gu', {
8371 
+        months: 'જાન્યુઆરી_ફેબ્રુઆરી_માર્ચ_એપ્રિલ_મે_જૂન_જુલાઈ_ઑગસ્ટ_સપ્ટેમ્બર_ઑક્ટ્બર_નવેમ્બર_ડિસેમ્બર'.split('_'),
8372 
+        monthsShort: 'જાન્યુ._ફેબ્રુ._માર્ચ_એપ્રિ._મે_જૂન_જુલા._ઑગ._સપ્ટે._ઑક્ટ્._નવે._ડિસે.'.split('_'),
8373 
+        monthsParseExact: true,
8374 
+        weekdays: 'રવિવાર_સોમવાર_મંગળવાર_બુધ્વાર_ગુરુવાર_શુક્રવાર_શનિવાર'.split('_'),
8375 
+        weekdaysShort: 'રવિ_સોમ_મંગળ_બુધ્_ગુરુ_શુક્ર_શનિ'.split('_'),
8376 
+        weekdaysMin: 'ર_સો_મં_બુ_ગુ_શુ_શ'.split('_'),
8377 
+        longDateFormat: {
8378 
+            LT: 'A h:mm વાગ્યે',
8379 
+            LTS: 'A h:mm:ss વાગ્યે',
8380 
+            L: 'DD/MM/YYYY',
8381 
+            LL: 'D MMMM YYYY',
8382 
+            LLL: 'D MMMM YYYY, A h:mm વાગ્યે',
8383 
+            LLLL: 'dddd, D MMMM YYYY, A h:mm વાગ્યે'
8384 
+        },
8385 
+        calendar: {
8386 
+            sameDay: '[આજ] LT',
8387 
+            nextDay: '[કાલે] LT',
8388 
+            nextWeek: 'dddd, LT',
8389 
+            lastDay: '[ગઇકાલે] LT',
8390 
+            lastWeek: '[પાછલા] dddd, LT',
8391 
+            sameElse: 'L'
8392 
+        },
8393 
+        relativeTime: {
8394 
+            future: '%s મા',
8395 
+            past: '%s પેહલા',
8396 
+            s: 'અમુક પળો',
8397 
+            ss: '%d સેકંડ',
8398 
+            m: 'એક મિનિટ',
8399 
+            mm: '%d મિનિટ',
8400 
+            h: 'એક કલાક',
8401 
+            hh: '%d કલાક',
8402 
+            d: 'એક દિવસ',
8403 
+            dd: '%d દિવસ',
8404 
+            M: 'એક મહિનો',
8405 
+            MM: '%d મહિનો',
8406 
+            y: 'એક વર્ષ',
8407 
+            yy: '%d વર્ષ'
8408 
+        },
8409 
+        preparse: function (string) {
8410 
+            return string.replace(/[૧૨૩૪૫૬૭૮૯૦]/g, function (match) {
8411 
+                return numberMap$5[match];
8412 
+            });
8413 
+        },
8414 
+        postformat: function (string) {
8415 
+            return string.replace(/\d/g, function (match) {
8416 
+                return symbolMap$6[match];
8417 
+            });
8418 
+        },
8419 
+        // Gujarati notation for meridiems are quite fuzzy in practice. While there exists
8420 
+        // a rigid notion of a 'Pahar' it is not used as rigidly in modern Gujarati.
8421 
+        meridiemParse: /રાત|બપોર|સવાર|સાંજ/,
8422 
+        meridiemHour: function (hour, meridiem) {
8423 
+            if (hour === 12) {
8424 
+                hour = 0;
8425 
+            }
8426 
+            if (meridiem === 'રાત') {
8427 
+                return hour < 4 ? hour : hour + 12;
8428 
+            } else if (meridiem === 'સવાર') {
8429 
+                return hour;
8430 
+            } else if (meridiem === 'બપોર') {
8431 
+                return hour >= 10 ? hour : hour + 12;
8432 
+            } else if (meridiem === 'સાંજ') {
8433 
+                return hour + 12;
8434 
+            }
8435 
+        },
8436 
+        meridiem: function (hour, minute, isLower) {
8437 
+            if (hour < 4) {
8438 
+                return 'રાત';
8439 
+            } else if (hour < 10) {
8440 
+                return 'સવાર';
8441 
+            } else if (hour < 17) {
8442 
+                return 'બપોર';
8443 
+            } else if (hour < 20) {
8444 
+                return 'સાંજ';
8445 
+            } else {
8446 
+                return 'રાત';
8447 
+            }
8448 
+        },
8449 
+        week: {
8450 
+            dow: 0, // Sunday is the first day of the week.
8451 
+            doy: 6 // The week that contains Jan 6th is the first week of the year.
8452 
+        }
8453 
+    });
8454 
+
8455 
+    //! moment.js locale configuration
8456 
+
8457 
+    hooks.defineLocale('he', {
8458 
+        months : 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
8459 
+        monthsShort : 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split('_'),
8460 
+        weekdays : 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
8461 
+        weekdaysShort : 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
8462 
+        weekdaysMin : 'א_ב_ג_ד_ה_ו_ש'.split('_'),
8463 
+        longDateFormat : {
8464 
+            LT : 'HH:mm',
8465 
+            LTS : 'HH:mm:ss',
8466 
+            L : 'DD/MM/YYYY',
8467 
+            LL : 'D [ב]MMMM YYYY',
8468 
+            LLL : 'D [ב]MMMM YYYY HH:mm',
8469 
+            LLLL : 'dddd, D [ב]MMMM YYYY HH:mm',
8470 
+            l : 'D/M/YYYY',
8471 
+            ll : 'D MMM YYYY',
8472 
+            lll : 'D MMM YYYY HH:mm',
8473 
+            llll : 'ddd, D MMM YYYY HH:mm'
8474 
+        },
8475 
+        calendar : {
8476 
+            sameDay : '[היום ב־]LT',
8477 
+            nextDay : '[מחר ב־]LT',
8478 
+            nextWeek : 'dddd [בשעה] LT',
8479 
+            lastDay : '[אתמול ב־]LT',
8480 
+            lastWeek : '[ביום] dddd [האחרון בשעה] LT',
8481 
+            sameElse : 'L'
8482 
+        },
8483 
+        relativeTime : {
8484 
+            future : 'בעוד %s',
8485 
+            past : 'לפני %s',
8486 
+            s : 'מספר שניות',
8487 
+            ss : '%d שניות',
8488 
+            m : 'דקה',
8489 
+            mm : '%d דקות',
8490 
+            h : 'שעה',
8491 
+            hh : function (number) {
8492 
+                if (number === 2) {
8493 
+                    return 'שעתיים';
8494 
+                }
8495 
+                return number + ' שעות';
8496 
+            },
8497 
+            d : 'יום',
8498 
+            dd : function (number) {
8499 
+                if (number === 2) {
8500 
+                    return 'יומיים';
8501 
+                }
8502 
+                return number + ' ימים';
8503 
+            },
8504 
+            M : 'חודש',
8505 
+            MM : function (number) {
8506 
+                if (number === 2) {
8507 
+                    return 'חודשיים';
8508 
+                }
8509 
+                return number + ' חודשים';
8510 
+            },
8511 
+            y : 'שנה',
8512 
+            yy : function (number) {
8513 
+                if (number === 2) {
8514 
+                    return 'שנתיים';
8515 
+                } else if (number % 10 === 0 && number !== 10) {
8516 
+                    return number + ' שנה';
8517 
+                }
8518 
+                return number + ' שנים';
8519 
+            }
8520 
+        },
8521 
+        meridiemParse: /אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,
8522 
+        isPM : function (input) {
8523 
+            return /^(אחה"צ|אחרי הצהריים|בערב)$/.test(input);
8524 
+        },
8525 
+        meridiem : function (hour, minute, isLower) {
8526 
+            if (hour < 5) {
8527 
+                return 'לפנות בוקר';
8528 
+            } else if (hour < 10) {
8529 
+                return 'בבוקר';
8530 
+            } else if (hour < 12) {
8531 
+                return isLower ? 'לפנה"צ' : 'לפני הצהריים';
8532 
+            } else if (hour < 18) {
8533 
+                return isLower ? 'אחה"צ' : 'אחרי הצהריים';
8534 
+            } else {
8535 
+                return 'בערב';
8536 
+            }
8537 
+        }
8538 
+    });
8539 
+
8540 
+    //! moment.js locale configuration
8541 
+
8542 
+    var symbolMap$7 = {
8543 
+        '1': '१',
8544 
+        '2': '२',
8545 
+        '3': '३',
8546 
+        '4': '४',
8547 
+        '5': '५',
8548 
+        '6': '६',
8549 
+        '7': '७',
8550 
+        '8': '८',
8551 
+        '9': '९',
8552 
+        '0': '०'
8553 
+    },
8554 
+    numberMap$6 = {
8555 
+        '१': '1',
8556 
+        '२': '2',
8557 
+        '३': '3',
8558 
+        '४': '4',
8559 
+        '५': '5',
8560 
+        '६': '6',
8561 
+        '७': '7',
8562 
+        '८': '8',
8563 
+        '९': '9',
8564 
+        '०': '0'
8565 
+    };
8566 
+
8567 
+    hooks.defineLocale('hi', {
8568 
+        months : 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split('_'),
8569 
+        monthsShort : 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split('_'),
8570 
+        monthsParseExact: true,
8571 
+        weekdays : 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
8572 
+        weekdaysShort : 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
8573 
+        weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
8574 
+        longDateFormat : {
8575 
+            LT : 'A h:mm बजे',
8576 
+            LTS : 'A h:mm:ss बजे',
8577 
+            L : 'DD/MM/YYYY',
8578 
+            LL : 'D MMMM YYYY',
8579 
+            LLL : 'D MMMM YYYY, A h:mm बजे',
8580 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm बजे'
8581 
+        },
8582 
+        calendar : {
8583 
+            sameDay : '[आज] LT',
8584 
+            nextDay : '[कल] LT',
8585 
+            nextWeek : 'dddd, LT',
8586 
+            lastDay : '[कल] LT',
8587 
+            lastWeek : '[पिछले] dddd, LT',
8588 
+            sameElse : 'L'
8589 
+        },
8590 
+        relativeTime : {
8591 
+            future : '%s में',
8592 
+            past : '%s पहले',
8593 
+            s : 'कुछ ही क्षण',
8594 
+            ss : '%d सेकंड',
8595 
+            m : 'एक मिनट',
8596 
+            mm : '%d मिनट',
8597 
+            h : 'एक घंटा',
8598 
+            hh : '%d घंटे',
8599 
+            d : 'एक दिन',
8600 
+            dd : '%d दिन',
8601 
+            M : 'एक महीने',
8602 
+            MM : '%d महीने',
8603 
+            y : 'एक वर्ष',
8604 
+            yy : '%d वर्ष'
8605 
+        },
8606 
+        preparse: function (string) {
8607 
+            return string.replace(/[१२३४५६७८९०]/g, function (match) {
8608 
+                return numberMap$6[match];
8609 
+            });
8610 
+        },
8611 
+        postformat: function (string) {
8612 
+            return string.replace(/\d/g, function (match) {
8613 
+                return symbolMap$7[match];
8614 
+            });
8615 
+        },
8616 
+        // Hindi notation for meridiems are quite fuzzy in practice. While there exists
8617 
+        // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
8618 
+        meridiemParse: /रात|सुबह|दोपहर|शाम/,
8619 
+        meridiemHour : function (hour, meridiem) {
8620 
+            if (hour === 12) {
8621 
+                hour = 0;
8622 
+            }
8623 
+            if (meridiem === 'रात') {
8624 
+                return hour < 4 ? hour : hour + 12;
8625 
+            } else if (meridiem === 'सुबह') {
8626 
+                return hour;
8627 
+            } else if (meridiem === 'दोपहर') {
8628 
+                return hour >= 10 ? hour : hour + 12;
8629 
+            } else if (meridiem === 'शाम') {
8630 
+                return hour + 12;
8631 
+            }
8632 
+        },
8633 
+        meridiem : function (hour, minute, isLower) {
8634 
+            if (hour < 4) {
8635 
+                return 'रात';
8636 
+            } else if (hour < 10) {
8637 
+                return 'सुबह';
8638 
+            } else if (hour < 17) {
8639 
+                return 'दोपहर';
8640 
+            } else if (hour < 20) {
8641 
+                return 'शाम';
8642 
+            } else {
8643 
+                return 'रात';
8644 
+            }
8645 
+        },
8646 
+        week : {
8647 
+            dow : 0, // Sunday is the first day of the week.
8648 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
8649 
+        }
8650 
+    });
8651 
+
8652 
+    //! moment.js locale configuration
8653 
+
8654 
+    function translate$3(number, withoutSuffix, key) {
8655 
+        var result = number + ' ';
8656 
+        switch (key) {
8657 
+            case 'ss':
8658 
+                if (number === 1) {
8659 
+                    result += 'sekunda';
8660 
+                } else if (number === 2 || number === 3 || number === 4) {
8661 
+                    result += 'sekunde';
8662 
+                } else {
8663 
+                    result += 'sekundi';
8664 
+                }
8665 
+                return result;
8666 
+            case 'm':
8667 
+                return withoutSuffix ? 'jedna minuta' : 'jedne minute';
8668 
+            case 'mm':
8669 
+                if (number === 1) {
8670 
+                    result += 'minuta';
8671 
+                } else if (number === 2 || number === 3 || number === 4) {
8672 
+                    result += 'minute';
8673 
+                } else {
8674 
+                    result += 'minuta';
8675 
+                }
8676 
+                return result;
8677 
+            case 'h':
8678 
+                return withoutSuffix ? 'jedan sat' : 'jednog sata';
8679 
+            case 'hh':
8680 
+                if (number === 1) {
8681 
+                    result += 'sat';
8682 
+                } else if (number === 2 || number === 3 || number === 4) {
8683 
+                    result += 'sata';
8684 
+                } else {
8685 
+                    result += 'sati';
8686 
+                }
8687 
+                return result;
8688 
+            case 'dd':
8689 
+                if (number === 1) {
8690 
+                    result += 'dan';
8691 
+                } else {
8692 
+                    result += 'dana';
8693 
+                }
8694 
+                return result;
8695 
+            case 'MM':
8696 
+                if (number === 1) {
8697 
+                    result += 'mjesec';
8698 
+                } else if (number === 2 || number === 3 || number === 4) {
8699 
+                    result += 'mjeseca';
8700 
+                } else {
8701 
+                    result += 'mjeseci';
8702 
+                }
8703 
+                return result;
8704 
+            case 'yy':
8705 
+                if (number === 1) {
8706 
+                    result += 'godina';
8707 
+                } else if (number === 2 || number === 3 || number === 4) {
8708 
+                    result += 'godine';
8709 
+                } else {
8710 
+                    result += 'godina';
8711 
+                }
8712 
+                return result;
8713 
+        }
8714 
+    }
8715 
+
8716 
+    hooks.defineLocale('hr', {
8717 
+        months : {
8718 
+            format: 'siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca'.split('_'),
8719 
+            standalone: 'siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_')
8720 
+        },
8721 
+        monthsShort : 'sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
8722 
+        monthsParseExact: true,
8723 
+        weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
8724 
+        weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
8725 
+        weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
8726 
+        weekdaysParseExact : true,
8727 
+        longDateFormat : {
8728 
+            LT : 'H:mm',
8729 
+            LTS : 'H:mm:ss',
8730 
+            L : 'DD.MM.YYYY',
8731 
+            LL : 'D. MMMM YYYY',
8732 
+            LLL : 'D. MMMM YYYY H:mm',
8733 
+            LLLL : 'dddd, D. MMMM YYYY H:mm'
8734 
+        },
8735 
+        calendar : {
8736 
+            sameDay  : '[danas u] LT',
8737 
+            nextDay  : '[sutra u] LT',
8738 
+            nextWeek : function () {
8739 
+                switch (this.day()) {
8740 
+                    case 0:
8741 
+                        return '[u] [nedjelju] [u] LT';
8742 
+                    case 3:
8743 
+                        return '[u] [srijedu] [u] LT';
8744 
+                    case 6:
8745 
+                        return '[u] [subotu] [u] LT';
8746 
+                    case 1:
8747 
+                    case 2:
8748 
+                    case 4:
8749 
+                    case 5:
8750 
+                        return '[u] dddd [u] LT';
8751 
+                }
8752 
+            },
8753 
+            lastDay  : '[jučer u] LT',
8754 
+            lastWeek : function () {
8755 
+                switch (this.day()) {
8756 
+                    case 0:
8757 
+                    case 3:
8758 
+                        return '[prošlu] dddd [u] LT';
8759 
+                    case 6:
8760 
+                        return '[prošle] [subote] [u] LT';
8761 
+                    case 1:
8762 
+                    case 2:
8763 
+                    case 4:
8764 
+                    case 5:
8765 
+                        return '[prošli] dddd [u] LT';
8766 
+                }
8767 
+            },
8768 
+            sameElse : 'L'
8769 
+        },
8770 
+        relativeTime : {
8771 
+            future : 'za %s',
8772 
+            past   : 'prije %s',
8773 
+            s      : 'par sekundi',
8774 
+            ss     : translate$3,
8775 
+            m      : translate$3,
8776 
+            mm     : translate$3,
8777 
+            h      : translate$3,
8778 
+            hh     : translate$3,
8779 
+            d      : 'dan',
8780 
+            dd     : translate$3,
8781 
+            M      : 'mjesec',
8782 
+            MM     : translate$3,
8783 
+            y      : 'godinu',
8784 
+            yy     : translate$3
8785 
+        },
8786 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
8787 
+        ordinal : '%d.',
8788 
+        week : {
8789 
+            dow : 1, // Monday is the first day of the week.
8790 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
8791 
+        }
8792 
+    });
8793 
+
8794 
+    //! moment.js locale configuration
8795 
+
8796 
+    var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');
8797 
+    function translate$4(number, withoutSuffix, key, isFuture) {
8798 
+        var num = number;
8799 
+        switch (key) {
8800 
+            case 's':
8801 
+                return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce';
8802 
+            case 'ss':
8803 
+                return num + (isFuture || withoutSuffix) ? ' másodperc' : ' másodperce';
8804 
+            case 'm':
8805 
+                return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
8806 
+            case 'mm':
8807 
+                return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
8808 
+            case 'h':
8809 
+                return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
8810 
+            case 'hh':
8811 
+                return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
8812 
+            case 'd':
8813 
+                return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
8814 
+            case 'dd':
8815 
+                return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
8816 
+            case 'M':
8817 
+                return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
8818 
+            case 'MM':
8819 
+                return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
8820 
+            case 'y':
8821 
+                return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
8822 
+            case 'yy':
8823 
+                return num + (isFuture || withoutSuffix ? ' év' : ' éve');
8824 
+        }
8825 
+        return '';
8826 
+    }
8827 
+    function week(isFuture) {
8828 
+        return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';
8829 
+    }
8830 
+
8831 
+    hooks.defineLocale('hu', {
8832 
+        months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
8833 
+        monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
8834 
+        weekdays : 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
8835 
+        weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
8836 
+        weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
8837 
+        longDateFormat : {
8838 
+            LT : 'H:mm',
8839 
+            LTS : 'H:mm:ss',
8840 
+            L : 'YYYY.MM.DD.',
8841 
+            LL : 'YYYY. MMMM D.',
8842 
+            LLL : 'YYYY. MMMM D. H:mm',
8843 
+            LLLL : 'YYYY. MMMM D., dddd H:mm'
8844 
+        },
8845 
+        meridiemParse: /de|du/i,
8846 
+        isPM: function (input) {
8847 
+            return input.charAt(1).toLowerCase() === 'u';
8848 
+        },
8849 
+        meridiem : function (hours, minutes, isLower) {
8850 
+            if (hours < 12) {
8851 
+                return isLower === true ? 'de' : 'DE';
8852 
+            } else {
8853 
+                return isLower === true ? 'du' : 'DU';
8854 
+            }
8855 
+        },
8856 
+        calendar : {
8857 
+            sameDay : '[ma] LT[-kor]',
8858 
+            nextDay : '[holnap] LT[-kor]',
8859 
+            nextWeek : function () {
8860 
+                return week.call(this, true);
8861 
+            },
8862 
+            lastDay : '[tegnap] LT[-kor]',
8863 
+            lastWeek : function () {
8864 
+                return week.call(this, false);
8865 
+            },
8866 
+            sameElse : 'L'
8867 
+        },
8868 
+        relativeTime : {
8869 
+            future : '%s múlva',
8870 
+            past : '%s',
8871 
+            s : translate$4,
8872 
+            ss : translate$4,
8873 
+            m : translate$4,
8874 
+            mm : translate$4,
8875 
+            h : translate$4,
8876 
+            hh : translate$4,
8877 
+            d : translate$4,
8878 
+            dd : translate$4,
8879 
+            M : translate$4,
8880 
+            MM : translate$4,
8881 
+            y : translate$4,
8882 
+            yy : translate$4
8883 
+        },
8884 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
8885 
+        ordinal : '%d.',
8886 
+        week : {
8887 
+            dow : 1, // Monday is the first day of the week.
8888 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
8889 
+        }
8890 
+    });
8891 
+
8892 
+    //! moment.js locale configuration
8893 
+
8894 
+    hooks.defineLocale('hy-am', {
8895 
+        months : {
8896 
+            format: 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_'),
8897 
+            standalone: 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_')
8898 
+        },
8899 
+        monthsShort : 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_'),
8900 
+        weekdays : 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split('_'),
8901 
+        weekdaysShort : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
8902 
+        weekdaysMin : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
8903 
+        longDateFormat : {
8904 
+            LT : 'HH:mm',
8905 
+            LTS : 'HH:mm:ss',
8906 
+            L : 'DD.MM.YYYY',
8907 
+            LL : 'D MMMM YYYY թ.',
8908 
+            LLL : 'D MMMM YYYY թ., HH:mm',
8909 
+            LLLL : 'dddd, D MMMM YYYY թ., HH:mm'
8910 
+        },
8911 
+        calendar : {
8912 
+            sameDay: '[այսօր] LT',
8913 
+            nextDay: '[վաղը] LT',
8914 
+            lastDay: '[երեկ] LT',
8915 
+            nextWeek: function () {
8916 
+                return 'dddd [օրը ժամը] LT';
8917 
+            },
8918 
+            lastWeek: function () {
8919 
+                return '[անցած] dddd [օրը ժամը] LT';
8920 
+            },
8921 
+            sameElse: 'L'
8922 
+        },
8923 
+        relativeTime : {
8924 
+            future : '%s հետո',
8925 
+            past : '%s առաջ',
8926 
+            s : 'մի քանի վայրկյան',
8927 
+            ss : '%d վայրկյան',
8928 
+            m : 'րոպե',
8929 
+            mm : '%d րոպե',
8930 
+            h : 'ժամ',
8931 
+            hh : '%d ժամ',
8932 
+            d : 'օր',
8933 
+            dd : '%d օր',
8934 
+            M : 'ամիս',
8935 
+            MM : '%d ամիս',
8936 
+            y : 'տարի',
8937 
+            yy : '%d տարի'
8938 
+        },
8939 
+        meridiemParse: /գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,
8940 
+        isPM: function (input) {
8941 
+            return /^(ցերեկվա|երեկոյան)$/.test(input);
8942 
+        },
8943 
+        meridiem : function (hour) {
8944 
+            if (hour < 4) {
8945 
+                return 'գիշերվա';
8946 
+            } else if (hour < 12) {
8947 
+                return 'առավոտվա';
8948 
+            } else if (hour < 17) {
8949 
+                return 'ցերեկվա';
8950 
+            } else {
8951 
+                return 'երեկոյան';
8952 
+            }
8953 
+        },
8954 
+        dayOfMonthOrdinalParse: /\d{1,2}|\d{1,2}-(ին|րդ)/,
8955 
+        ordinal: function (number, period) {
8956 
+            switch (period) {
8957 
+                case 'DDD':
8958 
+                case 'w':
8959 
+                case 'W':
8960 
+                case 'DDDo':
8961 
+                    if (number === 1) {
8962 
+                        return number + '-ին';
8963 
+                    }
8964 
+                    return number + '-րդ';
8965 
+                default:
8966 
+                    return number;
8967 
+            }
8968 
+        },
8969 
+        week : {
8970 
+            dow : 1, // Monday is the first day of the week.
8971 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
8972 
+        }
8973 
+    });
8974 
+
8975 
+    //! moment.js locale configuration
8976 
+
8977 
+    hooks.defineLocale('id', {
8978 
+        months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
8979 
+        monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des'.split('_'),
8980 
+        weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
8981 
+        weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
8982 
+        weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
8983 
+        longDateFormat : {
8984 
+            LT : 'HH.mm',
8985 
+            LTS : 'HH.mm.ss',
8986 
+            L : 'DD/MM/YYYY',
8987 
+            LL : 'D MMMM YYYY',
8988 
+            LLL : 'D MMMM YYYY [pukul] HH.mm',
8989 
+            LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
8990 
+        },
8991 
+        meridiemParse: /pagi|siang|sore|malam/,
8992 
+        meridiemHour : function (hour, meridiem) {
8993 
+            if (hour === 12) {
8994 
+                hour = 0;
8995 
+            }
8996 
+            if (meridiem === 'pagi') {
8997 
+                return hour;
8998 
+            } else if (meridiem === 'siang') {
8999 
+                return hour >= 11 ? hour : hour + 12;
9000 
+            } else if (meridiem === 'sore' || meridiem === 'malam') {
9001 
+                return hour + 12;
9002 
+            }
9003 
+        },
9004 
+        meridiem : function (hours, minutes, isLower) {
9005 
+            if (hours < 11) {
9006 
+                return 'pagi';
9007 
+            } else if (hours < 15) {
9008 
+                return 'siang';
9009 
+            } else if (hours < 19) {
9010 
+                return 'sore';
9011 
+            } else {
9012 
+                return 'malam';
9013 
+            }
9014 
+        },
9015 
+        calendar : {
9016 
+            sameDay : '[Hari ini pukul] LT',
9017 
+            nextDay : '[Besok pukul] LT',
9018 
+            nextWeek : 'dddd [pukul] LT',
9019 
+            lastDay : '[Kemarin pukul] LT',
9020 
+            lastWeek : 'dddd [lalu pukul] LT',
9021 
+            sameElse : 'L'
9022 
+        },
9023 
+        relativeTime : {
9024 
+            future : 'dalam %s',
9025 
+            past : '%s yang lalu',
9026 
+            s : 'beberapa detik',
9027 
+            ss : '%d detik',
9028 
+            m : 'semenit',
9029 
+            mm : '%d menit',
9030 
+            h : 'sejam',
9031 
+            hh : '%d jam',
9032 
+            d : 'sehari',
9033 
+            dd : '%d hari',
9034 
+            M : 'sebulan',
9035 
+            MM : '%d bulan',
9036 
+            y : 'setahun',
9037 
+            yy : '%d tahun'
9038 
+        },
9039 
+        week : {
9040 
+            dow : 1, // Monday is the first day of the week.
9041 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
9042 
+        }
9043 
+    });
9044 
+
9045 
+    //! moment.js locale configuration
9046 
+
9047 
+    function plural$2(n) {
9048 
+        if (n % 100 === 11) {
9049 
+            return true;
9050 
+        } else if (n % 10 === 1) {
9051 
+            return false;
9052 
+        }
9053 
+        return true;
9054 
+    }
9055 
+    function translate$5(number, withoutSuffix, key, isFuture) {
9056 
+        var result = number + ' ';
9057 
+        switch (key) {
9058 
+            case 's':
9059 
+                return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
9060 
+            case 'ss':
9061 
+                if (plural$2(number)) {
9062 
+                    return result + (withoutSuffix || isFuture ? 'sekúndur' : 'sekúndum');
9063 
+                }
9064 
+                return result + 'sekúnda';
9065 
+            case 'm':
9066 
+                return withoutSuffix ? 'mínúta' : 'mínútu';
9067 
+            case 'mm':
9068 
+                if (plural$2(number)) {
9069 
+                    return result + (withoutSuffix || isFuture ? 'mínútur' : 'mínútum');
9070 
+                } else if (withoutSuffix) {
9071 
+                    return result + 'mínúta';
9072 
+                }
9073 
+                return result + 'mínútu';
9074 
+            case 'hh':
9075 
+                if (plural$2(number)) {
9076 
+                    return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
9077 
+                }
9078 
+                return result + 'klukkustund';
9079 
+            case 'd':
9080 
+                if (withoutSuffix) {
9081 
+                    return 'dagur';
9082 
+                }
9083 
+                return isFuture ? 'dag' : 'degi';
9084 
+            case 'dd':
9085 
+                if (plural$2(number)) {
9086 
+                    if (withoutSuffix) {
9087 
+                        return result + 'dagar';
9088 
+                    }
9089 
+                    return result + (isFuture ? 'daga' : 'dögum');
9090 
+                } else if (withoutSuffix) {
9091 
+                    return result + 'dagur';
9092 
+                }
9093 
+                return result + (isFuture ? 'dag' : 'degi');
9094 
+            case 'M':
9095 
+                if (withoutSuffix) {
9096 
+                    return 'mánuður';
9097 
+                }
9098 
+                return isFuture ? 'mánuð' : 'mánuði';
9099 
+            case 'MM':
9100 
+                if (plural$2(number)) {
9101 
+                    if (withoutSuffix) {
9102 
+                        return result + 'mánuðir';
9103 
+                    }
9104 
+                    return result + (isFuture ? 'mánuði' : 'mánuðum');
9105 
+                } else if (withoutSuffix) {
9106 
+                    return result + 'mánuður';
9107 
+                }
9108 
+                return result + (isFuture ? 'mánuð' : 'mánuði');
9109 
+            case 'y':
9110 
+                return withoutSuffix || isFuture ? 'ár' : 'ári';
9111 
+            case 'yy':
9112 
+                if (plural$2(number)) {
9113 
+                    return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
9114 
+                }
9115 
+                return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
9116 
+        }
9117 
+    }
9118 
+
9119 
+    hooks.defineLocale('is', {
9120 
+        months : 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split('_'),
9121 
+        monthsShort : 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
9122 
+        weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
9123 
+        weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
9124 
+        weekdaysMin : 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
9125 
+        longDateFormat : {
9126 
+            LT : 'H:mm',
9127 
+            LTS : 'H:mm:ss',
9128 
+            L : 'DD.MM.YYYY',
9129 
+            LL : 'D. MMMM YYYY',
9130 
+            LLL : 'D. MMMM YYYY [kl.] H:mm',
9131 
+            LLLL : 'dddd, D. MMMM YYYY [kl.] H:mm'
9132 
+        },
9133 
+        calendar : {
9134 
+            sameDay : '[í dag kl.] LT',
9135 
+            nextDay : '[á morgun kl.] LT',
9136 
+            nextWeek : 'dddd [kl.] LT',
9137 
+            lastDay : '[í gær kl.] LT',
9138 
+            lastWeek : '[síðasta] dddd [kl.] LT',
9139 
+            sameElse : 'L'
9140 
+        },
9141 
+        relativeTime : {
9142 
+            future : 'eftir %s',
9143 
+            past : 'fyrir %s síðan',
9144 
+            s : translate$5,
9145 
+            ss : translate$5,
9146 
+            m : translate$5,
9147 
+            mm : translate$5,
9148 
+            h : 'klukkustund',
9149 
+            hh : translate$5,
9150 
+            d : translate$5,
9151 
+            dd : translate$5,
9152 
+            M : translate$5,
9153 
+            MM : translate$5,
9154 
+            y : translate$5,
9155 
+            yy : translate$5
9156 
+        },
9157 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
9158 
+        ordinal : '%d.',
9159 
+        week : {
9160 
+            dow : 1, // Monday is the first day of the week.
9161 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
9162 
+        }
9163 
+    });
9164 
+
9165 
+    //! moment.js locale configuration
9166 
+
9167 
+    hooks.defineLocale('it-ch', {
9168 
+        months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
9169 
+        monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
9170 
+        weekdays : 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
9171 
+        weekdaysShort : 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
9172 
+        weekdaysMin : 'do_lu_ma_me_gi_ve_sa'.split('_'),
9173 
+        longDateFormat : {
9174 
+            LT : 'HH:mm',
9175 
+            LTS : 'HH:mm:ss',
9176 
+            L : 'DD.MM.YYYY',
9177 
+            LL : 'D MMMM YYYY',
9178 
+            LLL : 'D MMMM YYYY HH:mm',
9179 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
9180 
+        },
9181 
+        calendar : {
9182 
+            sameDay: '[Oggi alle] LT',
9183 
+            nextDay: '[Domani alle] LT',
9184 
+            nextWeek: 'dddd [alle] LT',
9185 
+            lastDay: '[Ieri alle] LT',
9186 
+            lastWeek: function () {
9187 
+                switch (this.day()) {
9188 
+                    case 0:
9189 
+                        return '[la scorsa] dddd [alle] LT';
9190 
+                    default:
9191 
+                        return '[lo scorso] dddd [alle] LT';
9192 
+                }
9193 
+            },
9194 
+            sameElse: 'L'
9195 
+        },
9196 
+        relativeTime : {
9197 
+            future : function (s) {
9198 
+                return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
9199 
+            },
9200 
+            past : '%s fa',
9201 
+            s : 'alcuni secondi',
9202 
+            ss : '%d secondi',
9203 
+            m : 'un minuto',
9204 
+            mm : '%d minuti',
9205 
+            h : 'un\'ora',
9206 
+            hh : '%d ore',
9207 
+            d : 'un giorno',
9208 
+            dd : '%d giorni',
9209 
+            M : 'un mese',
9210 
+            MM : '%d mesi',
9211 
+            y : 'un anno',
9212 
+            yy : '%d anni'
9213 
+        },
9214 
+        dayOfMonthOrdinalParse : /\d{1,2}º/,
9215 
+        ordinal: '%dº',
9216 
+        week : {
9217 
+            dow : 1, // Monday is the first day of the week.
9218 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
9219 
+        }
9220 
+    });
9221 
+
9222 
+    //! moment.js locale configuration
9223 
+
9224 
+    hooks.defineLocale('it', {
9225 
+        months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
9226 
+        monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
9227 
+        weekdays : 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
9228 
+        weekdaysShort : 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
9229 
+        weekdaysMin : 'do_lu_ma_me_gi_ve_sa'.split('_'),
9230 
+        longDateFormat : {
9231 
+            LT : 'HH:mm',
9232 
+            LTS : 'HH:mm:ss',
9233 
+            L : 'DD/MM/YYYY',
9234 
+            LL : 'D MMMM YYYY',
9235 
+            LLL : 'D MMMM YYYY HH:mm',
9236 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
9237 
+        },
9238 
+        calendar : {
9239 
+            sameDay: '[Oggi alle] LT',
9240 
+            nextDay: '[Domani alle] LT',
9241 
+            nextWeek: 'dddd [alle] LT',
9242 
+            lastDay: '[Ieri alle] LT',
9243 
+            lastWeek: function () {
9244 
+                switch (this.day()) {
9245 
+                    case 0:
9246 
+                        return '[la scorsa] dddd [alle] LT';
9247 
+                    default:
9248 
+                        return '[lo scorso] dddd [alle] LT';
9249 
+                }
9250 
+            },
9251 
+            sameElse: 'L'
9252 
+        },
9253 
+        relativeTime : {
9254 
+            future : function (s) {
9255 
+                return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
9256 
+            },
9257 
+            past : '%s fa',
9258 
+            s : 'alcuni secondi',
9259 
+            ss : '%d secondi',
9260 
+            m : 'un minuto',
9261 
+            mm : '%d minuti',
9262 
+            h : 'un\'ora',
9263 
+            hh : '%d ore',
9264 
+            d : 'un giorno',
9265 
+            dd : '%d giorni',
9266 
+            M : 'un mese',
9267 
+            MM : '%d mesi',
9268 
+            y : 'un anno',
9269 
+            yy : '%d anni'
9270 
+        },
9271 
+        dayOfMonthOrdinalParse : /\d{1,2}º/,
9272 
+        ordinal: '%dº',
9273 
+        week : {
9274 
+            dow : 1, // Monday is the first day of the week.
9275 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
9276 
+        }
9277 
+    });
9278 
+
9279 
+    //! moment.js locale configuration
9280 
+
9281 
+    hooks.defineLocale('ja', {
9282 
+        months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
9283 
+        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
9284 
+        weekdays : '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
9285 
+        weekdaysShort : '日_月_火_水_木_金_土'.split('_'),
9286 
+        weekdaysMin : '日_月_火_水_木_金_土'.split('_'),
9287 
+        longDateFormat : {
9288 
+            LT : 'HH:mm',
9289 
+            LTS : 'HH:mm:ss',
9290 
+            L : 'YYYY/MM/DD',
9291 
+            LL : 'YYYY年M月D日',
9292 
+            LLL : 'YYYY年M月D日 HH:mm',
9293 
+            LLLL : 'YYYY年M月D日 dddd HH:mm',
9294 
+            l : 'YYYY/MM/DD',
9295 
+            ll : 'YYYY年M月D日',
9296 
+            lll : 'YYYY年M月D日 HH:mm',
9297 
+            llll : 'YYYY年M月D日(ddd) HH:mm'
9298 
+        },
9299 
+        meridiemParse: /午前|午後/i,
9300 
+        isPM : function (input) {
9301 
+            return input === '午後';
9302 
+        },
9303 
+        meridiem : function (hour, minute, isLower) {
9304 
+            if (hour < 12) {
9305 
+                return '午前';
9306 
+            } else {
9307 
+                return '午後';
9308 
+            }
9309 
+        },
9310 
+        calendar : {
9311 
+            sameDay : '[今日] LT',
9312 
+            nextDay : '[明日] LT',
9313 
+            nextWeek : function (now) {
9314 
+                if (now.week() < this.week()) {
9315 
+                    return '[来週]dddd LT';
9316 
+                } else {
9317 
+                    return 'dddd LT';
9318 
+                }
9319 
+            },
9320 
+            lastDay : '[昨日] LT',
9321 
+            lastWeek : function (now) {
9322 
+                if (this.week() < now.week()) {
9323 
+                    return '[先週]dddd LT';
9324 
+                } else {
9325 
+                    return 'dddd LT';
9326 
+                }
9327 
+            },
9328 
+            sameElse : 'L'
9329 
+        },
9330 
+        dayOfMonthOrdinalParse : /\d{1,2}日/,
9331 
+        ordinal : function (number, period) {
9332 
+            switch (period) {
9333 
+                case 'd':
9334 
+                case 'D':
9335 
+                case 'DDD':
9336 
+                    return number + '日';
9337 
+                default:
9338 
+                    return number;
9339 
+            }
9340 
+        },
9341 
+        relativeTime : {
9342 
+            future : '%s後',
9343 
+            past : '%s前',
9344 
+            s : '数秒',
9345 
+            ss : '%d秒',
9346 
+            m : '1分',
9347 
+            mm : '%d分',
9348 
+            h : '1時間',
9349 
+            hh : '%d時間',
9350 
+            d : '1日',
9351 
+            dd : '%d日',
9352 
+            M : '1ヶ月',
9353 
+            MM : '%dヶ月',
9354 
+            y : '1年',
9355 
+            yy : '%d年'
9356 
+        }
9357 
+    });
9358 
+
9359 
+    //! moment.js locale configuration
9360 
+
9361 
+    hooks.defineLocale('jv', {
9362 
+        months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember'.split('_'),
9363 
+        monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des'.split('_'),
9364 
+        weekdays : 'Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu'.split('_'),
9365 
+        weekdaysShort : 'Min_Sen_Sel_Reb_Kem_Jem_Sep'.split('_'),
9366 
+        weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sp'.split('_'),
9367 
+        longDateFormat : {
9368 
+            LT : 'HH.mm',
9369 
+            LTS : 'HH.mm.ss',
9370 
+            L : 'DD/MM/YYYY',
9371 
+            LL : 'D MMMM YYYY',
9372 
+            LLL : 'D MMMM YYYY [pukul] HH.mm',
9373 
+            LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
9374 
+        },
9375 
+        meridiemParse: /enjing|siyang|sonten|ndalu/,
9376 
+        meridiemHour : function (hour, meridiem) {
9377 
+            if (hour === 12) {
9378 
+                hour = 0;
9379 
+            }
9380 
+            if (meridiem === 'enjing') {
9381 
+                return hour;
9382 
+            } else if (meridiem === 'siyang') {
9383 
+                return hour >= 11 ? hour : hour + 12;
9384 
+            } else if (meridiem === 'sonten' || meridiem === 'ndalu') {
9385 
+                return hour + 12;
9386 
+            }
9387 
+        },
9388 
+        meridiem : function (hours, minutes, isLower) {
9389 
+            if (hours < 11) {
9390 
+                return 'enjing';
9391 
+            } else if (hours < 15) {
9392 
+                return 'siyang';
9393 
+            } else if (hours < 19) {
9394 
+                return 'sonten';
9395 
+            } else {
9396 
+                return 'ndalu';
9397 
+            }
9398 
+        },
9399 
+        calendar : {
9400 
+            sameDay : '[Dinten puniko pukul] LT',
9401 
+            nextDay : '[Mbenjang pukul] LT',
9402 
+            nextWeek : 'dddd [pukul] LT',
9403 
+            lastDay : '[Kala wingi pukul] LT',
9404 
+            lastWeek : 'dddd [kepengker pukul] LT',
9405 
+            sameElse : 'L'
9406 
+        },
9407 
+        relativeTime : {
9408 
+            future : 'wonten ing %s',
9409 
+            past : '%s ingkang kepengker',
9410 
+            s : 'sawetawis detik',
9411 
+            ss : '%d detik',
9412 
+            m : 'setunggal menit',
9413 
+            mm : '%d menit',
9414 
+            h : 'setunggal jam',
9415 
+            hh : '%d jam',
9416 
+            d : 'sedinten',
9417 
+            dd : '%d dinten',
9418 
+            M : 'sewulan',
9419 
+            MM : '%d wulan',
9420 
+            y : 'setaun',
9421 
+            yy : '%d taun'
9422 
+        },
9423 
+        week : {
9424 
+            dow : 1, // Monday is the first day of the week.
9425 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
9426 
+        }
9427 
+    });
9428 
+
9429 
+    //! moment.js locale configuration
9430 
+
9431 
+    hooks.defineLocale('ka', {
9432 
+        months : {
9433 
+            standalone: 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
9434 
+            format: 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
9435 
+        },
9436 
+        monthsShort : 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
9437 
+        weekdays : {
9438 
+            standalone: 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
9439 
+            format: 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_'),
9440 
+            isFormat: /(წინა|შემდეგ)/
9441 
+        },
9442 
+        weekdaysShort : 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
9443 
+        weekdaysMin : 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
9444 
+        longDateFormat : {
9445 
+            LT : 'h:mm A',
9446 
+            LTS : 'h:mm:ss A',
9447 
+            L : 'DD/MM/YYYY',
9448 
+            LL : 'D MMMM YYYY',
9449 
+            LLL : 'D MMMM YYYY h:mm A',
9450 
+            LLLL : 'dddd, D MMMM YYYY h:mm A'
9451 
+        },
9452 
+        calendar : {
9453 
+            sameDay : '[დღეს] LT[-ზე]',
9454 
+            nextDay : '[ხვალ] LT[-ზე]',
9455 
+            lastDay : '[გუშინ] LT[-ზე]',
9456 
+            nextWeek : '[შემდეგ] dddd LT[-ზე]',
9457 
+            lastWeek : '[წინა] dddd LT-ზე',
9458 
+            sameElse : 'L'
9459 
+        },
9460 
+        relativeTime : {
9461 
+            future : function (s) {
9462 
+                return (/(წამი|წუთი|საათი|წელი)/).test(s) ?
9463 
+                    s.replace(/ი$/, 'ში') :
9464 
+                    s + 'ში';
9465 
+            },
9466 
+            past : function (s) {
9467 
+                if ((/(წამი|წუთი|საათი|დღე|თვე)/).test(s)) {
9468 
+                    return s.replace(/(ი|ე)$/, 'ის წინ');
9469 
+                }
9470 
+                if ((/წელი/).test(s)) {
9471 
+                    return s.replace(/წელი$/, 'წლის წინ');
9472 
+                }
9473 
+            },
9474 
+            s : 'რამდენიმე წამი',
9475 
+            ss : '%d წამი',
9476 
+            m : 'წუთი',
9477 
+            mm : '%d წუთი',
9478 
+            h : 'საათი',
9479 
+            hh : '%d საათი',
9480 
+            d : 'დღე',
9481 
+            dd : '%d დღე',
9482 
+            M : 'თვე',
9483 
+            MM : '%d თვე',
9484 
+            y : 'წელი',
9485 
+            yy : '%d წელი'
9486 
+        },
9487 
+        dayOfMonthOrdinalParse: /0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,
9488 
+        ordinal : function (number) {
9489 
+            if (number === 0) {
9490 
+                return number;
9491 
+            }
9492 
+            if (number === 1) {
9493 
+                return number + '-ლი';
9494 
+            }
9495 
+            if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
9496 
+                return 'მე-' + number;
9497 
+            }
9498 
+            return number + '-ე';
9499 
+        },
9500 
+        week : {
9501 
+            dow : 1,
9502 
+            doy : 7
9503 
+        }
9504 
+    });
9505 
+
9506 
+    //! moment.js locale configuration
9507 
+
9508 
+    var suffixes$1 = {
9509 
+        0: '-ші',
9510 
+        1: '-ші',
9511 
+        2: '-ші',
9512 
+        3: '-ші',
9513 
+        4: '-ші',
9514 
+        5: '-ші',
9515 
+        6: '-шы',
9516 
+        7: '-ші',
9517 
+        8: '-ші',
9518 
+        9: '-шы',
9519 
+        10: '-шы',
9520 
+        20: '-шы',
9521 
+        30: '-шы',
9522 
+        40: '-шы',
9523 
+        50: '-ші',
9524 
+        60: '-шы',
9525 
+        70: '-ші',
9526 
+        80: '-ші',
9527 
+        90: '-шы',
9528 
+        100: '-ші'
9529 
+    };
9530 
+
9531 
+    hooks.defineLocale('kk', {
9532 
+        months : 'қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан'.split('_'),
9533 
+        monthsShort : 'қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел'.split('_'),
9534 
+        weekdays : 'жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі'.split('_'),
9535 
+        weekdaysShort : 'жек_дүй_сей_сәр_бей_жұм_сен'.split('_'),
9536 
+        weekdaysMin : 'жк_дй_сй_ср_бй_жм_сн'.split('_'),
9537 
+        longDateFormat : {
9538 
+            LT : 'HH:mm',
9539 
+            LTS : 'HH:mm:ss',
9540 
+            L : 'DD.MM.YYYY',
9541 
+            LL : 'D MMMM YYYY',
9542 
+            LLL : 'D MMMM YYYY HH:mm',
9543 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
9544 
+        },
9545 
+        calendar : {
9546 
+            sameDay : '[Бүгін сағат] LT',
9547 
+            nextDay : '[Ертең сағат] LT',
9548 
+            nextWeek : 'dddd [сағат] LT',
9549 
+            lastDay : '[Кеше сағат] LT',
9550 
+            lastWeek : '[Өткен аптаның] dddd [сағат] LT',
9551 
+            sameElse : 'L'
9552 
+        },
9553 
+        relativeTime : {
9554 
+            future : '%s ішінде',
9555 
+            past : '%s бұрын',
9556 
+            s : 'бірнеше секунд',
9557 
+            ss : '%d секунд',
9558 
+            m : 'бір минут',
9559 
+            mm : '%d минут',
9560 
+            h : 'бір сағат',
9561 
+            hh : '%d сағат',
9562 
+            d : 'бір күн',
9563 
+            dd : '%d күн',
9564 
+            M : 'бір ай',
9565 
+            MM : '%d ай',
9566 
+            y : 'бір жыл',
9567 
+            yy : '%d жыл'
9568 
+        },
9569 
+        dayOfMonthOrdinalParse: /\d{1,2}-(ші|шы)/,
9570 
+        ordinal : function (number) {
9571 
+            var a = number % 10,
9572 
+                b = number >= 100 ? 100 : null;
9573 
+            return number + (suffixes$1[number] || suffixes$1[a] || suffixes$1[b]);
9574 
+        },
9575 
+        week : {
9576 
+            dow : 1, // Monday is the first day of the week.
9577 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
9578 
+        }
9579 
+    });
9580 
+
9581 
+    //! moment.js locale configuration
9582 
+
9583 
+    var symbolMap$8 = {
9584 
+        '1': '១',
9585 
+        '2': '២',
9586 
+        '3': '៣',
9587 
+        '4': '៤',
9588 
+        '5': '៥',
9589 
+        '6': '៦',
9590 
+        '7': '៧',
9591 
+        '8': '៨',
9592 
+        '9': '៩',
9593 
+        '0': '០'
9594 
+    }, numberMap$7 = {
9595 
+        '១': '1',
9596 
+        '២': '2',
9597 
+        '៣': '3',
9598 
+        '៤': '4',
9599 
+        '៥': '5',
9600 
+        '៦': '6',
9601 
+        '៧': '7',
9602 
+        '៨': '8',
9603 
+        '៩': '9',
9604 
+        '០': '0'
9605 
+    };
9606 
+
9607 
+    hooks.defineLocale('km', {
9608 
+        months: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
9609 
+            '_'
9610 
+        ),
9611 
+        monthsShort: 'មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split(
9612 
+            '_'
9613 
+        ),
9614 
+        weekdays: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
9615 
+        weekdaysShort: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
9616 
+        weekdaysMin: 'អា_ច_អ_ព_ព្រ_សុ_ស'.split('_'),
9617 
+        weekdaysParseExact: true,
9618 
+        longDateFormat: {
9619 
+            LT: 'HH:mm',
9620 
+            LTS: 'HH:mm:ss',
9621 
+            L: 'DD/MM/YYYY',
9622 
+            LL: 'D MMMM YYYY',
9623 
+            LLL: 'D MMMM YYYY HH:mm',
9624 
+            LLLL: 'dddd, D MMMM YYYY HH:mm'
9625 
+        },
9626 
+        meridiemParse: /ព្រឹក|ល្ងាច/,
9627 
+        isPM: function (input) {
9628 
+            return input === 'ល្ងាច';
9629 
+        },
9630 
+        meridiem: function (hour, minute, isLower) {
9631 
+            if (hour < 12) {
9632 
+                return 'ព្រឹក';
9633 
+            } else {
9634 
+                return 'ល្ងាច';
9635 
+            }
9636 
+        },
9637 
+        calendar: {
9638 
+            sameDay: '[ថ្ងៃនេះ ម៉ោង] LT',
9639 
+            nextDay: '[ស្អែក ម៉ោង] LT',
9640 
+            nextWeek: 'dddd [ម៉ោង] LT',
9641 
+            lastDay: '[ម្សិលមិញ ម៉ោង] LT',
9642 
+            lastWeek: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
9643 
+            sameElse: 'L'
9644 
+        },
9645 
+        relativeTime: {
9646 
+            future: '%sទៀត',
9647 
+            past: '%sមុន',
9648 
+            s: 'ប៉ុន្មានវិនាទី',
9649 
+            ss: '%d វិនាទី',
9650 
+            m: 'មួយនាទី',
9651 
+            mm: '%d នាទី',
9652 
+            h: 'មួយម៉ោង',
9653 
+            hh: '%d ម៉ោង',
9654 
+            d: 'មួយថ្ងៃ',
9655 
+            dd: '%d ថ្ងៃ',
9656 
+            M: 'មួយខែ',
9657 
+            MM: '%d ខែ',
9658 
+            y: 'មួយឆ្នាំ',
9659 
+            yy: '%d ឆ្នាំ'
9660 
+        },
9661 
+        dayOfMonthOrdinalParse : /ទី\d{1,2}/,
9662 
+        ordinal : 'ទី%d',
9663 
+        preparse: function (string) {
9664 
+            return string.replace(/[១២៣៤៥៦៧៨៩០]/g, function (match) {
9665 
+                return numberMap$7[match];
9666 
+            });
9667 
+        },
9668 
+        postformat: function (string) {
9669 
+            return string.replace(/\d/g, function (match) {
9670 
+                return symbolMap$8[match];
9671 
+            });
9672 
+        },
9673 
+        week: {
9674 
+            dow: 1, // Monday is the first day of the week.
9675 
+            doy: 4 // The week that contains Jan 4th is the first week of the year.
9676 
+        }
9677 
+    });
9678 
+
9679 
+    //! moment.js locale configuration
9680 
+
9681 
+    var symbolMap$9 = {
9682 
+        '1': '೧',
9683 
+        '2': '೨',
9684 
+        '3': '೩',
9685 
+        '4': '೪',
9686 
+        '5': '೫',
9687 
+        '6': '೬',
9688 
+        '7': '೭',
9689 
+        '8': '೮',
9690 
+        '9': '೯',
9691 
+        '0': '೦'
9692 
+    },
9693 
+    numberMap$8 = {
9694 
+        '೧': '1',
9695 
+        '೨': '2',
9696 
+        '೩': '3',
9697 
+        '೪': '4',
9698 
+        '೫': '5',
9699 
+        '೬': '6',
9700 
+        '೭': '7',
9701 
+        '೮': '8',
9702 
+        '೯': '9',
9703 
+        '೦': '0'
9704 
+    };
9705 
+
9706 
+    hooks.defineLocale('kn', {
9707 
+        months : 'ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್'.split('_'),
9708 
+        monthsShort : 'ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂ_ಅಕ್ಟೋ_ನವೆಂ_ಡಿಸೆಂ'.split('_'),
9709 
+        monthsParseExact: true,
9710 
+        weekdays : 'ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ'.split('_'),
9711 
+        weekdaysShort : 'ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ'.split('_'),
9712 
+        weekdaysMin : 'ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ'.split('_'),
9713 
+        longDateFormat : {
9714 
+            LT : 'A h:mm',
9715 
+            LTS : 'A h:mm:ss',
9716 
+            L : 'DD/MM/YYYY',
9717 
+            LL : 'D MMMM YYYY',
9718 
+            LLL : 'D MMMM YYYY, A h:mm',
9719 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm'
9720 
+        },
9721 
+        calendar : {
9722 
+            sameDay : '[ಇಂದು] LT',
9723 
+            nextDay : '[ನಾಳೆ] LT',
9724 
+            nextWeek : 'dddd, LT',
9725 
+            lastDay : '[ನಿನ್ನೆ] LT',
9726 
+            lastWeek : '[ಕೊನೆಯ] dddd, LT',
9727 
+            sameElse : 'L'
9728 
+        },
9729 
+        relativeTime : {
9730 
+            future : '%s ನಂತರ',
9731 
+            past : '%s ಹಿಂದೆ',
9732 
+            s : 'ಕೆಲವು ಕ್ಷಣಗಳು',
9733 
+            ss : '%d ಸೆಕೆಂಡುಗಳು',
9734 
+            m : 'ಒಂದು ನಿಮಿಷ',
9735 
+            mm : '%d ನಿಮಿಷ',
9736 
+            h : 'ಒಂದು ಗಂಟೆ',
9737 
+            hh : '%d ಗಂಟೆ',
9738 
+            d : 'ಒಂದು ದಿನ',
9739 
+            dd : '%d ದಿನ',
9740 
+            M : 'ಒಂದು ತಿಂಗಳು',
9741 
+            MM : '%d ತಿಂಗಳು',
9742 
+            y : 'ಒಂದು ವರ್ಷ',
9743 
+            yy : '%d ವರ್ಷ'
9744 
+        },
9745 
+        preparse: function (string) {
9746 
+            return string.replace(/[೧೨೩೪೫೬೭೮೯೦]/g, function (match) {
9747 
+                return numberMap$8[match];
9748 
+            });
9749 
+        },
9750 
+        postformat: function (string) {
9751 
+            return string.replace(/\d/g, function (match) {
9752 
+                return symbolMap$9[match];
9753 
+            });
9754 
+        },
9755 
+        meridiemParse: /ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,
9756 
+        meridiemHour : function (hour, meridiem) {
9757 
+            if (hour === 12) {
9758 
+                hour = 0;
9759 
+            }
9760 
+            if (meridiem === 'ರಾತ್ರಿ') {
9761 
+                return hour < 4 ? hour : hour + 12;
9762 
+            } else if (meridiem === 'ಬೆಳಿಗ್ಗೆ') {
9763 
+                return hour;
9764 
+            } else if (meridiem === 'ಮಧ್ಯಾಹ್ನ') {
9765 
+                return hour >= 10 ? hour : hour + 12;
9766 
+            } else if (meridiem === 'ಸಂಜೆ') {
9767 
+                return hour + 12;
9768 
+            }
9769 
+        },
9770 
+        meridiem : function (hour, minute, isLower) {
9771 
+            if (hour < 4) {
9772 
+                return 'ರಾತ್ರಿ';
9773 
+            } else if (hour < 10) {
9774 
+                return 'ಬೆಳಿಗ್ಗೆ';
9775 
+            } else if (hour < 17) {
9776 
+                return 'ಮಧ್ಯಾಹ್ನ';
9777 
+            } else if (hour < 20) {
9778 
+                return 'ಸಂಜೆ';
9779 
+            } else {
9780 
+                return 'ರಾತ್ರಿ';
9781 
+            }
9782 
+        },
9783 
+        dayOfMonthOrdinalParse: /\d{1,2}(ನೇ)/,
9784 
+        ordinal : function (number) {
9785 
+            return number + 'ನೇ';
9786 
+        },
9787 
+        week : {
9788 
+            dow : 0, // Sunday is the first day of the week.
9789 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
9790 
+        }
9791 
+    });
9792 
+
9793 
+    //! moment.js locale configuration
9794 
+
9795 
+    hooks.defineLocale('ko', {
9796 
+        months : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
9797 
+        monthsShort : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
9798 
+        weekdays : '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
9799 
+        weekdaysShort : '일_월_화_수_목_금_토'.split('_'),
9800 
+        weekdaysMin : '일_월_화_수_목_금_토'.split('_'),
9801 
+        longDateFormat : {
9802 
+            LT : 'A h:mm',
9803 
+            LTS : 'A h:mm:ss',
9804 
+            L : 'YYYY.MM.DD.',
9805 
+            LL : 'YYYY년 MMMM D일',
9806 
+            LLL : 'YYYY년 MMMM D일 A h:mm',
9807 
+            LLLL : 'YYYY년 MMMM D일 dddd A h:mm',
9808 
+            l : 'YYYY.MM.DD.',
9809 
+            ll : 'YYYY년 MMMM D일',
9810 
+            lll : 'YYYY년 MMMM D일 A h:mm',
9811 
+            llll : 'YYYY년 MMMM D일 dddd A h:mm'
9812 
+        },
9813 
+        calendar : {
9814 
+            sameDay : '오늘 LT',
9815 
+            nextDay : '내일 LT',
9816 
+            nextWeek : 'dddd LT',
9817 
+            lastDay : '어제 LT',
9818 
+            lastWeek : '지난주 dddd LT',
9819 
+            sameElse : 'L'
9820 
+        },
9821 
+        relativeTime : {
9822 
+            future : '%s 후',
9823 
+            past : '%s 전',
9824 
+            s : '몇 초',
9825 
+            ss : '%d초',
9826 
+            m : '1분',
9827 
+            mm : '%d분',
9828 
+            h : '한 시간',
9829 
+            hh : '%d시간',
9830 
+            d : '하루',
9831 
+            dd : '%d일',
9832 
+            M : '한 달',
9833 
+            MM : '%d달',
9834 
+            y : '일 년',
9835 
+            yy : '%d년'
9836 
+        },
9837 
+        dayOfMonthOrdinalParse : /\d{1,2}(일|월|주)/,
9838 
+        ordinal : function (number, period) {
9839 
+            switch (period) {
9840 
+                case 'd':
9841 
+                case 'D':
9842 
+                case 'DDD':
9843 
+                    return number + '일';
9844 
+                case 'M':
9845 
+                    return number + '월';
9846 
+                case 'w':
9847 
+                case 'W':
9848 
+                    return number + '주';
9849 
+                default:
9850 
+                    return number;
9851 
+            }
9852 
+        },
9853 
+        meridiemParse : /오전|오후/,
9854 
+        isPM : function (token) {
9855 
+            return token === '오후';
9856 
+        },
9857 
+        meridiem : function (hour, minute, isUpper) {
9858 
+            return hour < 12 ? '오전' : '오후';
9859 
+        }
9860 
+    });
9861 
+
9862 
+    //! moment.js locale configuration
9863 
+
9864 
+    var symbolMap$a = {
9865 
+        '1': '١',
9866 
+        '2': '٢',
9867 
+        '3': '٣',
9868 
+        '4': '٤',
9869 
+        '5': '٥',
9870 
+        '6': '٦',
9871 
+        '7': '٧',
9872 
+        '8': '٨',
9873 
+        '9': '٩',
9874 
+        '0': '٠'
9875 
+    }, numberMap$9 = {
9876 
+        '١': '1',
9877 
+        '٢': '2',
9878 
+        '٣': '3',
9879 
+        '٤': '4',
9880 
+        '٥': '5',
9881 
+        '٦': '6',
9882 
+        '٧': '7',
9883 
+        '٨': '8',
9884 
+        '٩': '9',
9885 
+        '٠': '0'
9886 
+    },
9887 
+    months$7 = [
9888 
+        'کانونی دووەم',
9889 
+        'شوبات',
9890 
+        'ئازار',
9891 
+        'نیسان',
9892 
+        'ئایار',
9893 
+        'حوزەیران',
9894 
+        'تەمموز',
9895 
+        'ئاب',
9896 
+        'ئەیلوول',
9897 
+        'تشرینی یەكەم',
9898 
+        'تشرینی دووەم',
9899 
+        'كانونی یەکەم'
9900 
+    ];
9901 
+
9902 
+
9903 
+    hooks.defineLocale('ku', {
9904 
+        months : months$7,
9905 
+        monthsShort : months$7,
9906 
+        weekdays : 'یه‌كشه‌ممه‌_دووشه‌ممه‌_سێشه‌ممه‌_چوارشه‌ممه‌_پێنجشه‌ممه‌_هه‌ینی_شه‌ممه‌'.split('_'),
9907 
+        weekdaysShort : 'یه‌كشه‌م_دووشه‌م_سێشه‌م_چوارشه‌م_پێنجشه‌م_هه‌ینی_شه‌ممه‌'.split('_'),
9908 
+        weekdaysMin : 'ی_د_س_چ_پ_ه_ش'.split('_'),
9909 
+        weekdaysParseExact : true,
9910 
+        longDateFormat : {
9911 
+            LT : 'HH:mm',
9912 
+            LTS : 'HH:mm:ss',
9913 
+            L : 'DD/MM/YYYY',
9914 
+            LL : 'D MMMM YYYY',
9915 
+            LLL : 'D MMMM YYYY HH:mm',
9916 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
9917 
+        },
9918 
+        meridiemParse: /ئێواره‌|به‌یانی/,
9919 
+        isPM: function (input) {
9920 
+            return /ئێواره‌/.test(input);
9921 
+        },
9922 
+        meridiem : function (hour, minute, isLower) {
9923 
+            if (hour < 12) {
9924 
+                return 'به‌یانی';
9925 
+            } else {
9926 
+                return 'ئێواره‌';
9927 
+            }
9928 
+        },
9929 
+        calendar : {
9930 
+            sameDay : '[ئه‌مرۆ كاتژمێر] LT',
9931 
+            nextDay : '[به‌یانی كاتژمێر] LT',
9932 
+            nextWeek : 'dddd [كاتژمێر] LT',
9933 
+            lastDay : '[دوێنێ كاتژمێر] LT',
9934 
+            lastWeek : 'dddd [كاتژمێر] LT',
9935 
+            sameElse : 'L'
9936 
+        },
9937 
+        relativeTime : {
9938 
+            future : 'له‌ %s',
9939 
+            past : '%s',
9940 
+            s : 'چه‌ند چركه‌یه‌ك',
9941 
+            ss : 'چركه‌ %d',
9942 
+            m : 'یه‌ك خوله‌ك',
9943 
+            mm : '%d خوله‌ك',
9944 
+            h : 'یه‌ك كاتژمێر',
9945 
+            hh : '%d كاتژمێر',
9946 
+            d : 'یه‌ك ڕۆژ',
9947 
+            dd : '%d ڕۆژ',
9948 
+            M : 'یه‌ك مانگ',
9949 
+            MM : '%d مانگ',
9950 
+            y : 'یه‌ك ساڵ',
9951 
+            yy : '%d ساڵ'
9952 
+        },
9953 
+        preparse: function (string) {
9954 
+            return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
9955 
+                return numberMap$9[match];
9956 
+            }).replace(/،/g, ',');
9957 
+        },
9958 
+        postformat: function (string) {
9959 
+            return string.replace(/\d/g, function (match) {
9960 
+                return symbolMap$a[match];
9961 
+            }).replace(/,/g, '،');
9962 
+        },
9963 
+        week : {
9964 
+            dow : 6, // Saturday is the first day of the week.
9965 
+            doy : 12 // The week that contains Jan 12th is the first week of the year.
9966 
+        }
9967 
+    });
9968 
+
9969 
+    //! moment.js locale configuration
9970 
+
9971 
+    var suffixes$2 = {
9972 
+        0: '-чү',
9973 
+        1: '-чи',
9974 
+        2: '-чи',
9975 
+        3: '-чү',
9976 
+        4: '-чү',
9977 
+        5: '-чи',
9978 
+        6: '-чы',
9979 
+        7: '-чи',
9980 
+        8: '-чи',
9981 
+        9: '-чу',
9982 
+        10: '-чу',
9983 
+        20: '-чы',
9984 
+        30: '-чу',
9985 
+        40: '-чы',
9986 
+        50: '-чү',
9987 
+        60: '-чы',
9988 
+        70: '-чи',
9989 
+        80: '-чи',
9990 
+        90: '-чу',
9991 
+        100: '-чү'
9992 
+    };
9993 
+
9994 
+    hooks.defineLocale('ky', {
9995 
+        months : 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
9996 
+        monthsShort : 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
9997 
+        weekdays : 'Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби'.split('_'),
9998 
+        weekdaysShort : 'Жек_Дүй_Шей_Шар_Бей_Жум_Ише'.split('_'),
9999 
+        weekdaysMin : 'Жк_Дй_Шй_Шр_Бй_Жм_Иш'.split('_'),
10000 
+        longDateFormat : {
10001 
+            LT : 'HH:mm',
10002 
+            LTS : 'HH:mm:ss',
10003 
+            L : 'DD.MM.YYYY',
10004 
+            LL : 'D MMMM YYYY',
10005 
+            LLL : 'D MMMM YYYY HH:mm',
10006 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
10007 
+        },
10008 
+        calendar : {
10009 
+            sameDay : '[Бүгүн саат] LT',
10010 
+            nextDay : '[Эртең саат] LT',
10011 
+            nextWeek : 'dddd [саат] LT',
10012 
+            lastDay : '[Кечээ саат] LT',
10013 
+            lastWeek : '[Өткөн аптанын] dddd [күнү] [саат] LT',
10014 
+            sameElse : 'L'
10015 
+        },
10016 
+        relativeTime : {
10017 
+            future : '%s ичинде',
10018 
+            past : '%s мурун',
10019 
+            s : 'бирнече секунд',
10020 
+            ss : '%d секунд',
10021 
+            m : 'бир мүнөт',
10022 
+            mm : '%d мүнөт',
10023 
+            h : 'бир саат',
10024 
+            hh : '%d саат',
10025 
+            d : 'бир күн',
10026 
+            dd : '%d күн',
10027 
+            M : 'бир ай',
10028 
+            MM : '%d ай',
10029 
+            y : 'бир жыл',
10030 
+            yy : '%d жыл'
10031 
+        },
10032 
+        dayOfMonthOrdinalParse: /\d{1,2}-(чи|чы|чү|чу)/,
10033 
+        ordinal : function (number) {
10034 
+            var a = number % 10,
10035 
+                b = number >= 100 ? 100 : null;
10036 
+            return number + (suffixes$2[number] || suffixes$2[a] || suffixes$2[b]);
10037 
+        },
10038 
+        week : {
10039 
+            dow : 1, // Monday is the first day of the week.
10040 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
10041 
+        }
10042 
+    });
10043 
+
10044 
+    //! moment.js locale configuration
10045 
+
10046 
+    function processRelativeTime$5(number, withoutSuffix, key, isFuture) {
10047 
+        var format = {
10048 
+            'm': ['eng Minutt', 'enger Minutt'],
10049 
+            'h': ['eng Stonn', 'enger Stonn'],
10050 
+            'd': ['een Dag', 'engem Dag'],
10051 
+            'M': ['ee Mount', 'engem Mount'],
10052 
+            'y': ['ee Joer', 'engem Joer']
10053 
+        };
10054 
+        return withoutSuffix ? format[key][0] : format[key][1];
10055 
+    }
10056 
+    function processFutureTime(string) {
10057 
+        var number = string.substr(0, string.indexOf(' '));
10058 
+        if (eifelerRegelAppliesToNumber(number)) {
10059 
+            return 'a ' + string;
10060 
+        }
10061 
+        return 'an ' + string;
10062 
+    }
10063 
+    function processPastTime(string) {
10064 
+        var number = string.substr(0, string.indexOf(' '));
10065 
+        if (eifelerRegelAppliesToNumber(number)) {
10066 
+            return 'viru ' + string;
10067 
+        }
10068 
+        return 'virun ' + string;
10069 
+    }
10070 
+    /**
10071 
+     * Returns true if the word before the given number loses the '-n' ending.
10072 
+     * e.g. 'an 10 Deeg' but 'a 5 Deeg'
10073 
+     *
10074 
+     * @param number {integer}
10075 
+     * @returns {boolean}
10076 
+     */
10077 
+    function eifelerRegelAppliesToNumber(number) {
10078 
+        number = parseInt(number, 10);
10079 
+        if (isNaN(number)) {
10080 
+            return false;
10081 
+        }
10082 
+        if (number < 0) {
10083 
+            // Negative Number --> always true
10084 
+            return true;
10085 
+        } else if (number < 10) {
10086 
+            // Only 1 digit
10087 
+            if (4 <= number && number <= 7) {
10088 
+                return true;
10089 
+            }
10090 
+            return false;
10091 
+        } else if (number < 100) {
10092 
+            // 2 digits
10093 
+            var lastDigit = number % 10, firstDigit = number / 10;
10094 
+            if (lastDigit === 0) {
10095 
+                return eifelerRegelAppliesToNumber(firstDigit);
10096 
+            }
10097 
+            return eifelerRegelAppliesToNumber(lastDigit);
10098 
+        } else if (number < 10000) {
10099 
+            // 3 or 4 digits --> recursively check first digit
10100 
+            while (number >= 10) {
10101 
+                number = number / 10;
10102 
+            }
10103 
+            return eifelerRegelAppliesToNumber(number);
10104 
+        } else {
10105 
+            // Anything larger than 4 digits: recursively check first n-3 digits
10106 
+            number = number / 1000;
10107 
+            return eifelerRegelAppliesToNumber(number);
10108 
+        }
10109 
+    }
10110 
+
10111 
+    hooks.defineLocale('lb', {
10112 
+        months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
10113 
+        monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
10114 
+        monthsParseExact : true,
10115 
+        weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
10116 
+        weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
10117 
+        weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
10118 
+        weekdaysParseExact : true,
10119 
+        longDateFormat: {
10120 
+            LT: 'H:mm [Auer]',
10121 
+            LTS: 'H:mm:ss [Auer]',
10122 
+            L: 'DD.MM.YYYY',
10123 
+            LL: 'D. MMMM YYYY',
10124 
+            LLL: 'D. MMMM YYYY H:mm [Auer]',
10125 
+            LLLL: 'dddd, D. MMMM YYYY H:mm [Auer]'
10126 
+        },
10127 
+        calendar: {
10128 
+            sameDay: '[Haut um] LT',
10129 
+            sameElse: 'L',
10130 
+            nextDay: '[Muer um] LT',
10131 
+            nextWeek: 'dddd [um] LT',
10132 
+            lastDay: '[Gëschter um] LT',
10133 
+            lastWeek: function () {
10134 
+                // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
10135 
+                switch (this.day()) {
10136 
+                    case 2:
10137 
+                    case 4:
10138 
+                        return '[Leschten] dddd [um] LT';
10139 
+                    default:
10140 
+                        return '[Leschte] dddd [um] LT';
10141 
+                }
10142 
+            }
10143 
+        },
10144 
+        relativeTime : {
10145 
+            future : processFutureTime,
10146 
+            past : processPastTime,
10147 
+            s : 'e puer Sekonnen',
10148 
+            ss : '%d Sekonnen',
10149 
+            m : processRelativeTime$5,
10150 
+            mm : '%d Minutten',
10151 
+            h : processRelativeTime$5,
10152 
+            hh : '%d Stonnen',
10153 
+            d : processRelativeTime$5,
10154 
+            dd : '%d Deeg',
10155 
+            M : processRelativeTime$5,
10156 
+            MM : '%d Méint',
10157 
+            y : processRelativeTime$5,
10158 
+            yy : '%d Joer'
10159 
+        },
10160 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
10161 
+        ordinal: '%d.',
10162 
+        week: {
10163 
+            dow: 1, // Monday is the first day of the week.
10164 
+            doy: 4  // The week that contains Jan 4th is the first week of the year.
10165 
+        }
10166 
+    });
10167 
+
10168 
+    //! moment.js locale configuration
10169 
+
10170 
+    hooks.defineLocale('lo', {
10171 
+        months : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
10172 
+        monthsShort : 'ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ'.split('_'),
10173 
+        weekdays : 'ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
10174 
+        weekdaysShort : 'ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ'.split('_'),
10175 
+        weekdaysMin : 'ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ'.split('_'),
10176 
+        weekdaysParseExact : true,
10177 
+        longDateFormat : {
10178 
+            LT : 'HH:mm',
10179 
+            LTS : 'HH:mm:ss',
10180 
+            L : 'DD/MM/YYYY',
10181 
+            LL : 'D MMMM YYYY',
10182 
+            LLL : 'D MMMM YYYY HH:mm',
10183 
+            LLLL : 'ວັນdddd D MMMM YYYY HH:mm'
10184 
+        },
10185 
+        meridiemParse: /ຕອນເຊົ້າ|ຕອນແລງ/,
10186 
+        isPM: function (input) {
10187 
+            return input === 'ຕອນແລງ';
10188 
+        },
10189 
+        meridiem : function (hour, minute, isLower) {
10190 
+            if (hour < 12) {
10191 
+                return 'ຕອນເຊົ້າ';
10192 
+            } else {
10193 
+                return 'ຕອນແລງ';
10194 
+            }
10195 
+        },
10196 
+        calendar : {
10197 
+            sameDay : '[ມື້ນີ້ເວລາ] LT',
10198 
+            nextDay : '[ມື້ອື່ນເວລາ] LT',
10199 
+            nextWeek : '[ວັນ]dddd[ໜ້າເວລາ] LT',
10200 
+            lastDay : '[ມື້ວານນີ້ເວລາ] LT',
10201 
+            lastWeek : '[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT',
10202 
+            sameElse : 'L'
10203 
+        },
10204 
+        relativeTime : {
10205 
+            future : 'ອີກ %s',
10206 
+            past : '%sຜ່ານມາ',
10207 
+            s : 'ບໍ່ເທົ່າໃດວິນາທີ',
10208 
+            ss : '%d ວິນາທີ' ,
10209 
+            m : '1 ນາທີ',
10210 
+            mm : '%d ນາທີ',
10211 
+            h : '1 ຊົ່ວໂມງ',
10212 
+            hh : '%d ຊົ່ວໂມງ',
10213 
+            d : '1 ມື້',
10214 
+            dd : '%d ມື້',
10215 
+            M : '1 ເດືອນ',
10216 
+            MM : '%d ເດືອນ',
10217 
+            y : '1 ປີ',
10218 
+            yy : '%d ປີ'
10219 
+        },
10220 
+        dayOfMonthOrdinalParse: /(ທີ່)\d{1,2}/,
10221 
+        ordinal : function (number) {
10222 
+            return 'ທີ່' + number;
10223 
+        }
10224 
+    });
10225 
+
10226 
+    //! moment.js locale configuration
10227 
+
10228 
+    var units = {
10229 
+        'ss' : 'sekundė_sekundžių_sekundes',
10230 
+        'm' : 'minutė_minutės_minutę',
10231 
+        'mm': 'minutės_minučių_minutes',
10232 
+        'h' : 'valanda_valandos_valandą',
10233 
+        'hh': 'valandos_valandų_valandas',
10234 
+        'd' : 'diena_dienos_dieną',
10235 
+        'dd': 'dienos_dienų_dienas',
10236 
+        'M' : 'mėnuo_mėnesio_mėnesį',
10237 
+        'MM': 'mėnesiai_mėnesių_mėnesius',
10238 
+        'y' : 'metai_metų_metus',
10239 
+        'yy': 'metai_metų_metus'
10240 
+    };
10241 
+    function translateSeconds(number, withoutSuffix, key, isFuture) {
10242 
+        if (withoutSuffix) {
10243 
+            return 'kelios sekundės';
10244 
+        } else {
10245 
+            return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
10246 
+        }
10247 
+    }
10248 
+    function translateSingular(number, withoutSuffix, key, isFuture) {
10249 
+        return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);
10250 
+    }
10251 
+    function special(number) {
10252 
+        return number % 10 === 0 || (number > 10 && number < 20);
10253 
+    }
10254 
+    function forms(key) {
10255 
+        return units[key].split('_');
10256 
+    }
10257 
+    function translate$6(number, withoutSuffix, key, isFuture) {
10258 
+        var result = number + ' ';
10259 
+        if (number === 1) {
10260 
+            return result + translateSingular(number, withoutSuffix, key[0], isFuture);
10261 
+        } else if (withoutSuffix) {
10262 
+            return result + (special(number) ? forms(key)[1] : forms(key)[0]);
10263 
+        } else {
10264 
+            if (isFuture) {
10265 
+                return result + forms(key)[1];
10266 
+            } else {
10267 
+                return result + (special(number) ? forms(key)[1] : forms(key)[2]);
10268 
+            }
10269 
+        }
10270 
+    }
10271 
+    hooks.defineLocale('lt', {
10272 
+        months : {
10273 
+            format: 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
10274 
+            standalone: 'sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis'.split('_'),
10275 
+            isFormat: /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/
10276 
+        },
10277 
+        monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
10278 
+        weekdays : {
10279 
+            format: 'sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį'.split('_'),
10280 
+            standalone: 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split('_'),
10281 
+            isFormat: /dddd HH:mm/
10282 
+        },
10283 
+        weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
10284 
+        weekdaysMin : 'S_P_A_T_K_Pn_Š'.split('_'),
10285 
+        weekdaysParseExact : true,
10286 
+        longDateFormat : {
10287 
+            LT : 'HH:mm',
10288 
+            LTS : 'HH:mm:ss',
10289 
+            L : 'YYYY-MM-DD',
10290 
+            LL : 'YYYY [m.] MMMM D [d.]',
10291 
+            LLL : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
10292 
+            LLLL : 'YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]',
10293 
+            l : 'YYYY-MM-DD',
10294 
+            ll : 'YYYY [m.] MMMM D [d.]',
10295 
+            lll : 'YYYY [m.] MMMM D [d.], HH:mm [val.]',
10296 
+            llll : 'YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]'
10297 
+        },
10298 
+        calendar : {
10299 
+            sameDay : '[Šiandien] LT',
10300 
+            nextDay : '[Rytoj] LT',
10301 
+            nextWeek : 'dddd LT',
10302 
+            lastDay : '[Vakar] LT',
10303 
+            lastWeek : '[Praėjusį] dddd LT',
10304 
+            sameElse : 'L'
10305 
+        },
10306 
+        relativeTime : {
10307 
+            future : 'po %s',
10308 
+            past : 'prieš %s',
10309 
+            s : translateSeconds,
10310 
+            ss : translate$6,
10311 
+            m : translateSingular,
10312 
+            mm : translate$6,
10313 
+            h : translateSingular,
10314 
+            hh : translate$6,
10315 
+            d : translateSingular,
10316 
+            dd : translate$6,
10317 
+            M : translateSingular,
10318 
+            MM : translate$6,
10319 
+            y : translateSingular,
10320 
+            yy : translate$6
10321 
+        },
10322 
+        dayOfMonthOrdinalParse: /\d{1,2}-oji/,
10323 
+        ordinal : function (number) {
10324 
+            return number + '-oji';
10325 
+        },
10326 
+        week : {
10327 
+            dow : 1, // Monday is the first day of the week.
10328 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
10329 
+        }
10330 
+    });
10331 
+
10332 
+    //! moment.js locale configuration
10333 
+
10334 
+    var units$1 = {
10335 
+        'ss': 'sekundes_sekundēm_sekunde_sekundes'.split('_'),
10336 
+        'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
10337 
+        'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
10338 
+        'h': 'stundas_stundām_stunda_stundas'.split('_'),
10339 
+        'hh': 'stundas_stundām_stunda_stundas'.split('_'),
10340 
+        'd': 'dienas_dienām_diena_dienas'.split('_'),
10341 
+        'dd': 'dienas_dienām_diena_dienas'.split('_'),
10342 
+        'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
10343 
+        'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
10344 
+        'y': 'gada_gadiem_gads_gadi'.split('_'),
10345 
+        'yy': 'gada_gadiem_gads_gadi'.split('_')
10346 
+    };
10347 
+    /**
10348 
+     * @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
10349 
+     */
10350 
+    function format$1(forms, number, withoutSuffix) {
10351 
+        if (withoutSuffix) {
10352 
+            // E.g. "21 minūte", "3 minūtes".
10353 
+            return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3];
10354 
+        } else {
10355 
+            // E.g. "21 minūtes" as in "pēc 21 minūtes".
10356 
+            // E.g. "3 minūtēm" as in "pēc 3 minūtēm".
10357 
+            return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1];
10358 
+        }
10359 
+    }
10360 
+    function relativeTimeWithPlural$1(number, withoutSuffix, key) {
10361 
+        return number + ' ' + format$1(units$1[key], number, withoutSuffix);
10362 
+    }
10363 
+    function relativeTimeWithSingular(number, withoutSuffix, key) {
10364 
+        return format$1(units$1[key], number, withoutSuffix);
10365 
+    }
10366 
+    function relativeSeconds(number, withoutSuffix) {
10367 
+        return withoutSuffix ? 'dažas sekundes' : 'dažām sekundēm';
10368 
+    }
10369 
+
10370 
+    hooks.defineLocale('lv', {
10371 
+        months : 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
10372 
+        monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
10373 
+        weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
10374 
+        weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
10375 
+        weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
10376 
+        weekdaysParseExact : true,
10377 
+        longDateFormat : {
10378 
+            LT : 'HH:mm',
10379 
+            LTS : 'HH:mm:ss',
10380 
+            L : 'DD.MM.YYYY.',
10381 
+            LL : 'YYYY. [gada] D. MMMM',
10382 
+            LLL : 'YYYY. [gada] D. MMMM, HH:mm',
10383 
+            LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
10384 
+        },
10385 
+        calendar : {
10386 
+            sameDay : '[Šodien pulksten] LT',
10387 
+            nextDay : '[Rīt pulksten] LT',
10388 
+            nextWeek : 'dddd [pulksten] LT',
10389 
+            lastDay : '[Vakar pulksten] LT',
10390 
+            lastWeek : '[Pagājušā] dddd [pulksten] LT',
10391 
+            sameElse : 'L'
10392 
+        },
10393 
+        relativeTime : {
10394 
+            future : 'pēc %s',
10395 
+            past : 'pirms %s',
10396 
+            s : relativeSeconds,
10397 
+            ss : relativeTimeWithPlural$1,
10398 
+            m : relativeTimeWithSingular,
10399 
+            mm : relativeTimeWithPlural$1,
10400 
+            h : relativeTimeWithSingular,
10401 
+            hh : relativeTimeWithPlural$1,
10402 
+            d : relativeTimeWithSingular,
10403 
+            dd : relativeTimeWithPlural$1,
10404 
+            M : relativeTimeWithSingular,
10405 
+            MM : relativeTimeWithPlural$1,
10406 
+            y : relativeTimeWithSingular,
10407 
+            yy : relativeTimeWithPlural$1
10408 
+        },
10409 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
10410 
+        ordinal : '%d.',
10411 
+        week : {
10412 
+            dow : 1, // Monday is the first day of the week.
10413 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
10414 
+        }
10415 
+    });
10416 
+
10417 
+    //! moment.js locale configuration
10418 
+
10419 
+    var translator = {
10420 
+        words: { //Different grammatical cases
10421 
+            ss: ['sekund', 'sekunda', 'sekundi'],
10422 
+            m: ['jedan minut', 'jednog minuta'],
10423 
+            mm: ['minut', 'minuta', 'minuta'],
10424 
+            h: ['jedan sat', 'jednog sata'],
10425 
+            hh: ['sat', 'sata', 'sati'],
10426 
+            dd: ['dan', 'dana', 'dana'],
10427 
+            MM: ['mjesec', 'mjeseca', 'mjeseci'],
10428 
+            yy: ['godina', 'godine', 'godina']
10429 
+        },
10430 
+        correctGrammaticalCase: function (number, wordKey) {
10431 
+            return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
10432 
+        },
10433 
+        translate: function (number, withoutSuffix, key) {
10434 
+            var wordKey = translator.words[key];
10435 
+            if (key.length === 1) {
10436 
+                return withoutSuffix ? wordKey[0] : wordKey[1];
10437 
+            } else {
10438 
+                return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
10439 
+            }
10440 
+        }
10441 
+    };
10442 
+
10443 
+    hooks.defineLocale('me', {
10444 
+        months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
10445 
+        monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
10446 
+        monthsParseExact : true,
10447 
+        weekdays: 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
10448 
+        weekdaysShort: 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
10449 
+        weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
10450 
+        weekdaysParseExact : true,
10451 
+        longDateFormat: {
10452 
+            LT: 'H:mm',
10453 
+            LTS : 'H:mm:ss',
10454 
+            L: 'DD.MM.YYYY',
10455 
+            LL: 'D. MMMM YYYY',
10456 
+            LLL: 'D. MMMM YYYY H:mm',
10457 
+            LLLL: 'dddd, D. MMMM YYYY H:mm'
10458 
+        },
10459 
+        calendar: {
10460 
+            sameDay: '[danas u] LT',
10461 
+            nextDay: '[sjutra u] LT',
10462 
+
10463 
+            nextWeek: function () {
10464 
+                switch (this.day()) {
10465 
+                    case 0:
10466 
+                        return '[u] [nedjelju] [u] LT';
10467 
+                    case 3:
10468 
+                        return '[u] [srijedu] [u] LT';
10469 
+                    case 6:
10470 
+                        return '[u] [subotu] [u] LT';
10471 
+                    case 1:
10472 
+                    case 2:
10473 
+                    case 4:
10474 
+                    case 5:
10475 
+                        return '[u] dddd [u] LT';
10476 
+                }
10477 
+            },
10478 
+            lastDay  : '[juče u] LT',
10479 
+            lastWeek : function () {
10480 
+                var lastWeekDays = [
10481 
+                    '[prošle] [nedjelje] [u] LT',
10482 
+                    '[prošlog] [ponedjeljka] [u] LT',
10483 
+                    '[prošlog] [utorka] [u] LT',
10484 
+                    '[prošle] [srijede] [u] LT',
10485 
+                    '[prošlog] [četvrtka] [u] LT',
10486 
+                    '[prošlog] [petka] [u] LT',
10487 
+                    '[prošle] [subote] [u] LT'
10488 
+                ];
10489 
+                return lastWeekDays[this.day()];
10490 
+            },
10491 
+            sameElse : 'L'
10492 
+        },
10493 
+        relativeTime : {
10494 
+            future : 'za %s',
10495 
+            past   : 'prije %s',
10496 
+            s      : 'nekoliko sekundi',
10497 
+            ss     : translator.translate,
10498 
+            m      : translator.translate,
10499 
+            mm     : translator.translate,
10500 
+            h      : translator.translate,
10501 
+            hh     : translator.translate,
10502 
+            d      : 'dan',
10503 
+            dd     : translator.translate,
10504 
+            M      : 'mjesec',
10505 
+            MM     : translator.translate,
10506 
+            y      : 'godinu',
10507 
+            yy     : translator.translate
10508 
+        },
10509 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
10510 
+        ordinal : '%d.',
10511 
+        week : {
10512 
+            dow : 1, // Monday is the first day of the week.
10513 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
10514 
+        }
10515 
+    });
10516 
+
10517 
+    //! moment.js locale configuration
10518 
+
10519 
+    hooks.defineLocale('mi', {
10520 
+        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('_'),
10521 
+        monthsShort: 'Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki'.split('_'),
10522 
+        monthsRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
10523 
+        monthsStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
10524 
+        monthsShortRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,
10525 
+        monthsShortStrictRegex: /(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,
10526 
+        weekdays: 'Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei'.split('_'),
10527 
+        weekdaysShort: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
10528 
+        weekdaysMin: 'Ta_Ma_Tū_We_Tāi_Pa_Hā'.split('_'),
10529 
+        longDateFormat: {
10530 
+            LT: 'HH:mm',
10531 
+            LTS: 'HH:mm:ss',
10532 
+            L: 'DD/MM/YYYY',
10533 
+            LL: 'D MMMM YYYY',
10534 
+            LLL: 'D MMMM YYYY [i] HH:mm',
10535 
+            LLLL: 'dddd, D MMMM YYYY [i] HH:mm'
10536 
+        },
10537 
+        calendar: {
10538 
+            sameDay: '[i teie mahana, i] LT',
10539 
+            nextDay: '[apopo i] LT',
10540 
+            nextWeek: 'dddd [i] LT',
10541 
+            lastDay: '[inanahi i] LT',
10542 
+            lastWeek: 'dddd [whakamutunga i] LT',
10543 
+            sameElse: 'L'
10544 
+        },
10545 
+        relativeTime: {
10546 
+            future: 'i roto i %s',
10547 
+            past: '%s i mua',
10548 
+            s: 'te hēkona ruarua',
10549 
+            ss: '%d hēkona',
10550 
+            m: 'he meneti',
10551 
+            mm: '%d meneti',
10552 
+            h: 'te haora',
10553 
+            hh: '%d haora',
10554 
+            d: 'he ra',
10555 
+            dd: '%d ra',
10556 
+            M: 'he marama',
10557 
+            MM: '%d marama',
10558 
+            y: 'he tau',
10559 
+            yy: '%d tau'
10560 
+        },
10561 
+        dayOfMonthOrdinalParse: /\d{1,2}º/,
10562 
+        ordinal: '%dº',
10563 
+        week : {
10564 
+            dow : 1, // Monday is the first day of the week.
10565 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
10566 
+        }
10567 
+    });
10568 
+
10569 
+    //! moment.js locale configuration
10570 
+
10571 
+    hooks.defineLocale('mk', {
10572 
+        months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
10573 
+        monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
10574 
+        weekdays : 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
10575 
+        weekdaysShort : 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
10576 
+        weekdaysMin : 'нe_пo_вт_ср_че_пе_сa'.split('_'),
10577 
+        longDateFormat : {
10578 
+            LT : 'H:mm',
10579 
+            LTS : 'H:mm:ss',
10580 
+            L : 'D.MM.YYYY',
10581 
+            LL : 'D MMMM YYYY',
10582 
+            LLL : 'D MMMM YYYY H:mm',
10583 
+            LLLL : 'dddd, D MMMM YYYY H:mm'
10584 
+        },
10585 
+        calendar : {
10586 
+            sameDay : '[Денес во] LT',
10587 
+            nextDay : '[Утре во] LT',
10588 
+            nextWeek : '[Во] dddd [во] LT',
10589 
+            lastDay : '[Вчера во] LT',
10590 
+            lastWeek : function () {
10591 
+                switch (this.day()) {
10592 
+                    case 0:
10593 
+                    case 3:
10594 
+                    case 6:
10595 
+                        return '[Изминатата] dddd [во] LT';
10596 
+                    case 1:
10597 
+                    case 2:
10598 
+                    case 4:
10599 
+                    case 5:
10600 
+                        return '[Изминатиот] dddd [во] LT';
10601 
+                }
10602 
+            },
10603 
+            sameElse : 'L'
10604 
+        },
10605 
+        relativeTime : {
10606 
+            future : 'после %s',
10607 
+            past : 'пред %s',
10608 
+            s : 'неколку секунди',
10609 
+            ss : '%d секунди',
10610 
+            m : 'минута',
10611 
+            mm : '%d минути',
10612 
+            h : 'час',
10613 
+            hh : '%d часа',
10614 
+            d : 'ден',
10615 
+            dd : '%d дена',
10616 
+            M : 'месец',
10617 
+            MM : '%d месеци',
10618 
+            y : 'година',
10619 
+            yy : '%d години'
10620 
+        },
10621 
+        dayOfMonthOrdinalParse: /\d{1,2}-(ев|ен|ти|ви|ри|ми)/,
10622 
+        ordinal : function (number) {
10623 
+            var lastDigit = number % 10,
10624 
+                last2Digits = number % 100;
10625 
+            if (number === 0) {
10626 
+                return number + '-ев';
10627 
+            } else if (last2Digits === 0) {
10628 
+                return number + '-ен';
10629 
+            } else if (last2Digits > 10 && last2Digits < 20) {
10630 
+                return number + '-ти';
10631 
+            } else if (lastDigit === 1) {
10632 
+                return number + '-ви';
10633 
+            } else if (lastDigit === 2) {
10634 
+                return number + '-ри';
10635 
+            } else if (lastDigit === 7 || lastDigit === 8) {
10636 
+                return number + '-ми';
10637 
+            } else {
10638 
+                return number + '-ти';
10639 
+            }
10640 
+        },
10641 
+        week : {
10642 
+            dow : 1, // Monday is the first day of the week.
10643 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
10644 
+        }
10645 
+    });
10646 
+
10647 
+    //! moment.js locale configuration
10648 
+
10649 
+    hooks.defineLocale('ml', {
10650 
+        months : 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
10651 
+        monthsShort : 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split('_'),
10652 
+        monthsParseExact : true,
10653 
+        weekdays : 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split('_'),
10654 
+        weekdaysShort : 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
10655 
+        weekdaysMin : 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
10656 
+        longDateFormat : {
10657 
+            LT : 'A h:mm -നു',
10658 
+            LTS : 'A h:mm:ss -നു',
10659 
+            L : 'DD/MM/YYYY',
10660 
+            LL : 'D MMMM YYYY',
10661 
+            LLL : 'D MMMM YYYY, A h:mm -നു',
10662 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm -നു'
10663 
+        },
10664 
+        calendar : {
10665 
+            sameDay : '[ഇന്ന്] LT',
10666 
+            nextDay : '[നാളെ] LT',
10667 
+            nextWeek : 'dddd, LT',
10668 
+            lastDay : '[ഇന്നലെ] LT',
10669 
+            lastWeek : '[കഴിഞ്ഞ] dddd, LT',
10670 
+            sameElse : 'L'
10671 
+        },
10672 
+        relativeTime : {
10673 
+            future : '%s കഴിഞ്ഞ്',
10674 
+            past : '%s മുൻപ്',
10675 
+            s : 'അൽപ നിമിഷങ്ങൾ',
10676 
+            ss : '%d സെക്കൻഡ്',
10677 
+            m : 'ഒരു മിനിറ്റ്',
10678 
+            mm : '%d മിനിറ്റ്',
10679 
+            h : 'ഒരു മണിക്കൂർ',
10680 
+            hh : '%d മണിക്കൂർ',
10681 
+            d : 'ഒരു ദിവസം',
10682 
+            dd : '%d ദിവസം',
10683 
+            M : 'ഒരു മാസം',
10684 
+            MM : '%d മാസം',
10685 
+            y : 'ഒരു വർഷം',
10686 
+            yy : '%d വർഷം'
10687 
+        },
10688 
+        meridiemParse: /രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,
10689 
+        meridiemHour : function (hour, meridiem) {
10690 
+            if (hour === 12) {
10691 
+                hour = 0;
10692 
+            }
10693 
+            if ((meridiem === 'രാത്രി' && hour >= 4) ||
10694 
+                    meridiem === 'ഉച്ച കഴിഞ്ഞ്' ||
10695 
+                    meridiem === 'വൈകുന്നേരം') {
10696 
+                return hour + 12;
10697 
+            } else {
10698 
+                return hour;
10699 
+            }
10700 
+        },
10701 
+        meridiem : function (hour, minute, isLower) {
10702 
+            if (hour < 4) {
10703 
+                return 'രാത്രി';
10704 
+            } else if (hour < 12) {
10705 
+                return 'രാവിലെ';
10706 
+            } else if (hour < 17) {
10707 
+                return 'ഉച്ച കഴിഞ്ഞ്';
10708 
+            } else if (hour < 20) {
10709 
+                return 'വൈകുന്നേരം';
10710 
+            } else {
10711 
+                return 'രാത്രി';
10712 
+            }
10713 
+        }
10714 
+    });
10715 
+
10716 
+    //! moment.js locale configuration
10717 
+
10718 
+    function translate$7(number, withoutSuffix, key, isFuture) {
10719 
+        switch (key) {
10720 
+            case 's':
10721 
+                return withoutSuffix ? 'хэдхэн секунд' : 'хэдхэн секундын';
10722 
+            case 'ss':
10723 
+                return number + (withoutSuffix ? ' секунд' : ' секундын');
10724 
+            case 'm':
10725 
+            case 'mm':
10726 
+                return number + (withoutSuffix ? ' минут' : ' минутын');
10727 
+            case 'h':
10728 
+            case 'hh':
10729 
+                return number + (withoutSuffix ? ' цаг' : ' цагийн');
10730 
+            case 'd':
10731 
+            case 'dd':
10732 
+                return number + (withoutSuffix ? ' өдөр' : ' өдрийн');
10733 
+            case 'M':
10734 
+            case 'MM':
10735 
+                return number + (withoutSuffix ? ' сар' : ' сарын');
10736 
+            case 'y':
10737 
+            case 'yy':
10738 
+                return number + (withoutSuffix ? ' жил' : ' жилийн');
10739 
+            default:
10740 
+                return number;
10741 
+        }
10742 
+    }
10743 
+
10744 
+    hooks.defineLocale('mn', {
10745 
+        months : 'Нэгдүгээр сар_Хоёрдугаар сар_Гуравдугаар сар_Дөрөвдүгээр сар_Тавдугаар сар_Зургадугаар сар_Долдугаар сар_Наймдугаар сар_Есдүгээр сар_Аравдугаар сар_Арван нэгдүгээр сар_Арван хоёрдугаар сар'.split('_'),
10746 
+        monthsShort : '1 сар_2 сар_3 сар_4 сар_5 сар_6 сар_7 сар_8 сар_9 сар_10 сар_11 сар_12 сар'.split('_'),
10747 
+        monthsParseExact : true,
10748 
+        weekdays : 'Ням_Даваа_Мягмар_Лхагва_Пүрэв_Баасан_Бямба'.split('_'),
10749 
+        weekdaysShort : 'Ням_Дав_Мяг_Лха_Пүр_Баа_Бям'.split('_'),
10750 
+        weekdaysMin : 'Ня_Да_Мя_Лх_Пү_Ба_Бя'.split('_'),
10751 
+        weekdaysParseExact : true,
10752 
+        longDateFormat : {
10753 
+            LT : 'HH:mm',
10754 
+            LTS : 'HH:mm:ss',
10755 
+            L : 'YYYY-MM-DD',
10756 
+            LL : 'YYYY оны MMMMын D',
10757 
+            LLL : 'YYYY оны MMMMын D HH:mm',
10758 
+            LLLL : 'dddd, YYYY оны MMMMын D HH:mm'
10759 
+        },
10760 
+        meridiemParse: /ҮӨ|ҮХ/i,
10761 
+        isPM : function (input) {
10762 
+            return input === 'ҮХ';
10763 
+        },
10764 
+        meridiem : function (hour, minute, isLower) {
10765 
+            if (hour < 12) {
10766 
+                return 'ҮӨ';
10767 
+            } else {
10768 
+                return 'ҮХ';
10769 
+            }
10770 
+        },
10771 
+        calendar : {
10772 
+            sameDay : '[Өнөөдөр] LT',
10773 
+            nextDay : '[Маргааш] LT',
10774 
+            nextWeek : '[Ирэх] dddd LT',
10775 
+            lastDay : '[Өчигдөр] LT',
10776 
+            lastWeek : '[Өнгөрсөн] dddd LT',
10777 
+            sameElse : 'L'
10778 
+        },
10779 
+        relativeTime : {
10780 
+            future : '%s дараа',
10781 
+            past : '%s өмнө',
10782 
+            s : translate$7,
10783 
+            ss : translate$7,
10784 
+            m : translate$7,
10785 
+            mm : translate$7,
10786 
+            h : translate$7,
10787 
+            hh : translate$7,
10788 
+            d : translate$7,
10789 
+            dd : translate$7,
10790 
+            M : translate$7,
10791 
+            MM : translate$7,
10792 
+            y : translate$7,
10793 
+            yy : translate$7
10794 
+        },
10795 
+        dayOfMonthOrdinalParse: /\d{1,2} өдөр/,
10796 
+        ordinal : function (number, period) {
10797 
+            switch (period) {
10798 
+                case 'd':
10799 
+                case 'D':
10800 
+                case 'DDD':
10801 
+                    return number + ' өдөр';
10802 
+                default:
10803 
+                    return number;
10804 
+            }
10805 
+        }
10806 
+    });
10807 
+
10808 
+    //! moment.js locale configuration
10809 
+
10810 
+    var symbolMap$b = {
10811 
+        '1': '१',
10812 
+        '2': '२',
10813 
+        '3': '३',
10814 
+        '4': '४',
10815 
+        '5': '५',
10816 
+        '6': '६',
10817 
+        '7': '७',
10818 
+        '8': '८',
10819 
+        '9': '९',
10820 
+        '0': '०'
10821 
+    },
10822 
+    numberMap$a = {
10823 
+        '१': '1',
10824 
+        '२': '2',
10825 
+        '३': '3',
10826 
+        '४': '4',
10827 
+        '५': '5',
10828 
+        '६': '6',
10829 
+        '७': '7',
10830 
+        '८': '8',
10831 
+        '९': '9',
10832 
+        '०': '0'
10833 
+    };
10834 
+
10835 
+    function relativeTimeMr(number, withoutSuffix, string, isFuture)
10836 
+    {
10837 
+        var output = '';
10838 
+        if (withoutSuffix) {
10839 
+            switch (string) {
10840 
+                case 's': output = 'काही सेकंद'; break;
10841 
+                case 'ss': output = '%d सेकंद'; break;
10842 
+                case 'm': output = 'एक मिनिट'; break;
10843 
+                case 'mm': output = '%d मिनिटे'; break;
10844 
+                case 'h': output = 'एक तास'; break;
10845 
+                case 'hh': output = '%d तास'; break;
10846 
+                case 'd': output = 'एक दिवस'; break;
10847 
+                case 'dd': output = '%d दिवस'; break;
10848 
+                case 'M': output = 'एक महिना'; break;
10849 
+                case 'MM': output = '%d महिने'; break;
10850 
+                case 'y': output = 'एक वर्ष'; break;
10851 
+                case 'yy': output = '%d वर्षे'; break;
10852 
+            }
10853 
+        }
10854 
+        else {
10855 
+            switch (string) {
10856 
+                case 's': output = 'काही सेकंदां'; break;
10857 
+                case 'ss': output = '%d सेकंदां'; break;
10858 
+                case 'm': output = 'एका मिनिटा'; break;
10859 
+                case 'mm': output = '%d मिनिटां'; break;
10860 
+                case 'h': output = 'एका तासा'; break;
10861 
+                case 'hh': output = '%d तासां'; break;
10862 
+                case 'd': output = 'एका दिवसा'; break;
10863 
+                case 'dd': output = '%d दिवसां'; break;
10864 
+                case 'M': output = 'एका महिन्या'; break;
10865 
+                case 'MM': output = '%d महिन्यां'; break;
10866 
+                case 'y': output = 'एका वर्षा'; break;
10867 
+                case 'yy': output = '%d वर्षां'; break;
10868 
+            }
10869 
+        }
10870 
+        return output.replace(/%d/i, number);
10871 
+    }
10872 
+
10873 
+    hooks.defineLocale('mr', {
10874 
+        months : 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split('_'),
10875 
+        monthsShort: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split('_'),
10876 
+        monthsParseExact : true,
10877 
+        weekdays : 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
10878 
+        weekdaysShort : 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
10879 
+        weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
10880 
+        longDateFormat : {
10881 
+            LT : 'A h:mm वाजता',
10882 
+            LTS : 'A h:mm:ss वाजता',
10883 
+            L : 'DD/MM/YYYY',
10884 
+            LL : 'D MMMM YYYY',
10885 
+            LLL : 'D MMMM YYYY, A h:mm वाजता',
10886 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm वाजता'
10887 
+        },
10888 
+        calendar : {
10889 
+            sameDay : '[आज] LT',
10890 
+            nextDay : '[उद्या] LT',
10891 
+            nextWeek : 'dddd, LT',
10892 
+            lastDay : '[काल] LT',
10893 
+            lastWeek: '[मागील] dddd, LT',
10894 
+            sameElse : 'L'
10895 
+        },
10896 
+        relativeTime : {
10897 
+            future: '%sमध्ये',
10898 
+            past: '%sपूर्वी',
10899 
+            s: relativeTimeMr,
10900 
+            ss: relativeTimeMr,
10901 
+            m: relativeTimeMr,
10902 
+            mm: relativeTimeMr,
10903 
+            h: relativeTimeMr,
10904 
+            hh: relativeTimeMr,
10905 
+            d: relativeTimeMr,
10906 
+            dd: relativeTimeMr,
10907 
+            M: relativeTimeMr,
10908 
+            MM: relativeTimeMr,
10909 
+            y: relativeTimeMr,
10910 
+            yy: relativeTimeMr
10911 
+        },
10912 
+        preparse: function (string) {
10913 
+            return string.replace(/[१२३४५६७८९०]/g, function (match) {
10914 
+                return numberMap$a[match];
10915 
+            });
10916 
+        },
10917 
+        postformat: function (string) {
10918 
+            return string.replace(/\d/g, function (match) {
10919 
+                return symbolMap$b[match];
10920 
+            });
10921 
+        },
10922 
+        meridiemParse: /रात्री|सकाळी|दुपारी|सायंकाळी/,
10923 
+        meridiemHour : function (hour, meridiem) {
10924 
+            if (hour === 12) {
10925 
+                hour = 0;
10926 
+            }
10927 
+            if (meridiem === 'रात्री') {
10928 
+                return hour < 4 ? hour : hour + 12;
10929 
+            } else if (meridiem === 'सकाळी') {
10930 
+                return hour;
10931 
+            } else if (meridiem === 'दुपारी') {
10932 
+                return hour >= 10 ? hour : hour + 12;
10933 
+            } else if (meridiem === 'सायंकाळी') {
10934 
+                return hour + 12;
10935 
+            }
10936 
+        },
10937 
+        meridiem: function (hour, minute, isLower) {
10938 
+            if (hour < 4) {
10939 
+                return 'रात्री';
10940 
+            } else if (hour < 10) {
10941 
+                return 'सकाळी';
10942 
+            } else if (hour < 17) {
10943 
+                return 'दुपारी';
10944 
+            } else if (hour < 20) {
10945 
+                return 'सायंकाळी';
10946 
+            } else {
10947 
+                return 'रात्री';
10948 
+            }
10949 
+        },
10950 
+        week : {
10951 
+            dow : 0, // Sunday is the first day of the week.
10952 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
10953 
+        }
10954 
+    });
10955 
+
10956 
+    //! moment.js locale configuration
10957 
+
10958 
+    hooks.defineLocale('ms-my', {
10959 
+        months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
10960 
+        monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
10961 
+        weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
10962 
+        weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
10963 
+        weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
10964 
+        longDateFormat : {
10965 
+            LT : 'HH.mm',
10966 
+            LTS : 'HH.mm.ss',
10967 
+            L : 'DD/MM/YYYY',
10968 
+            LL : 'D MMMM YYYY',
10969 
+            LLL : 'D MMMM YYYY [pukul] HH.mm',
10970 
+            LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
10971 
+        },
10972 
+        meridiemParse: /pagi|tengahari|petang|malam/,
10973 
+        meridiemHour: function (hour, meridiem) {
10974 
+            if (hour === 12) {
10975 
+                hour = 0;
10976 
+            }
10977 
+            if (meridiem === 'pagi') {
10978 
+                return hour;
10979 
+            } else if (meridiem === 'tengahari') {
10980 
+                return hour >= 11 ? hour : hour + 12;
10981 
+            } else if (meridiem === 'petang' || meridiem === 'malam') {
10982 
+                return hour + 12;
10983 
+            }
10984 
+        },
10985 
+        meridiem : function (hours, minutes, isLower) {
10986 
+            if (hours < 11) {
10987 
+                return 'pagi';
10988 
+            } else if (hours < 15) {
10989 
+                return 'tengahari';
10990 
+            } else if (hours < 19) {
10991 
+                return 'petang';
10992 
+            } else {
10993 
+                return 'malam';
10994 
+            }
10995 
+        },
10996 
+        calendar : {
10997 
+            sameDay : '[Hari ini pukul] LT',
10998 
+            nextDay : '[Esok pukul] LT',
10999 
+            nextWeek : 'dddd [pukul] LT',
11000 
+            lastDay : '[Kelmarin pukul] LT',
11001 
+            lastWeek : 'dddd [lepas pukul] LT',
11002 
+            sameElse : 'L'
11003 
+        },
11004 
+        relativeTime : {
11005 
+            future : 'dalam %s',
11006 
+            past : '%s yang lepas',
11007 
+            s : 'beberapa saat',
11008 
+            ss : '%d saat',
11009 
+            m : 'seminit',
11010 
+            mm : '%d minit',
11011 
+            h : 'sejam',
11012 
+            hh : '%d jam',
11013 
+            d : 'sehari',
11014 
+            dd : '%d hari',
11015 
+            M : 'sebulan',
11016 
+            MM : '%d bulan',
11017 
+            y : 'setahun',
11018 
+            yy : '%d tahun'
11019 
+        },
11020 
+        week : {
11021 
+            dow : 1, // Monday is the first day of the week.
11022 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
11023 
+        }
11024 
+    });
11025 
+
11026 
+    //! moment.js locale configuration
11027 
+
11028 
+    hooks.defineLocale('ms', {
11029 
+        months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
11030 
+        monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
11031 
+        weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
11032 
+        weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
11033 
+        weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
11034 
+        longDateFormat : {
11035 
+            LT : 'HH.mm',
11036 
+            LTS : 'HH.mm.ss',
11037 
+            L : 'DD/MM/YYYY',
11038 
+            LL : 'D MMMM YYYY',
11039 
+            LLL : 'D MMMM YYYY [pukul] HH.mm',
11040 
+            LLLL : 'dddd, D MMMM YYYY [pukul] HH.mm'
11041 
+        },
11042 
+        meridiemParse: /pagi|tengahari|petang|malam/,
11043 
+        meridiemHour: function (hour, meridiem) {
11044 
+            if (hour === 12) {
11045 
+                hour = 0;
11046 
+            }
11047 
+            if (meridiem === 'pagi') {
11048 
+                return hour;
11049 
+            } else if (meridiem === 'tengahari') {
11050 
+                return hour >= 11 ? hour : hour + 12;
11051 
+            } else if (meridiem === 'petang' || meridiem === 'malam') {
11052 
+                return hour + 12;
11053 
+            }
11054 
+        },
11055 
+        meridiem : function (hours, minutes, isLower) {
11056 
+            if (hours < 11) {
11057 
+                return 'pagi';
11058 
+            } else if (hours < 15) {
11059 
+                return 'tengahari';
11060 
+            } else if (hours < 19) {
11061 
+                return 'petang';
11062 
+            } else {
11063 
+                return 'malam';
11064 
+            }
11065 
+        },
11066 
+        calendar : {
11067 
+            sameDay : '[Hari ini pukul] LT',
11068 
+            nextDay : '[Esok pukul] LT',
11069 
+            nextWeek : 'dddd [pukul] LT',
11070 
+            lastDay : '[Kelmarin pukul] LT',
11071 
+            lastWeek : 'dddd [lepas pukul] LT',
11072 
+            sameElse : 'L'
11073 
+        },
11074 
+        relativeTime : {
11075 
+            future : 'dalam %s',
11076 
+            past : '%s yang lepas',
11077 
+            s : 'beberapa saat',
11078 
+            ss : '%d saat',
11079 
+            m : 'seminit',
11080 
+            mm : '%d minit',
11081 
+            h : 'sejam',
11082 
+            hh : '%d jam',
11083 
+            d : 'sehari',
11084 
+            dd : '%d hari',
11085 
+            M : 'sebulan',
11086 
+            MM : '%d bulan',
11087 
+            y : 'setahun',
11088 
+            yy : '%d tahun'
11089 
+        },
11090 
+        week : {
11091 
+            dow : 1, // Monday is the first day of the week.
11092 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
11093 
+        }
11094 
+    });
11095 
+
11096 
+    //! moment.js locale configuration
11097 
+
11098 
+    hooks.defineLocale('mt', {
11099 
+        months : 'Jannar_Frar_Marzu_April_Mejju_Ġunju_Lulju_Awwissu_Settembru_Ottubru_Novembru_Diċembru'.split('_'),
11100 
+        monthsShort : 'Jan_Fra_Mar_Apr_Mej_Ġun_Lul_Aww_Set_Ott_Nov_Diċ'.split('_'),
11101 
+        weekdays : 'Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ġimgħa_Is-Sibt'.split('_'),
11102 
+        weekdaysShort : 'Ħad_Tne_Tli_Erb_Ħam_Ġim_Sib'.split('_'),
11103 
+        weekdaysMin : 'Ħa_Tn_Tl_Er_Ħa_Ġi_Si'.split('_'),
11104 
+        longDateFormat : {
11105 
+            LT : 'HH:mm',
11106 
+            LTS : 'HH:mm:ss',
11107 
+            L : 'DD/MM/YYYY',
11108 
+            LL : 'D MMMM YYYY',
11109 
+            LLL : 'D MMMM YYYY HH:mm',
11110 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
11111 
+        },
11112 
+        calendar : {
11113 
+            sameDay : '[Illum fil-]LT',
11114 
+            nextDay : '[Għada fil-]LT',
11115 
+            nextWeek : 'dddd [fil-]LT',
11116 
+            lastDay : '[Il-bieraħ fil-]LT',
11117 
+            lastWeek : 'dddd [li għadda] [fil-]LT',
11118 
+            sameElse : 'L'
11119 
+        },
11120 
+        relativeTime : {
11121 
+            future : 'f’ %s',
11122 
+            past : '%s ilu',
11123 
+            s : 'ftit sekondi',
11124 
+            ss : '%d sekondi',
11125 
+            m : 'minuta',
11126 
+            mm : '%d minuti',
11127 
+            h : 'siegħa',
11128 
+            hh : '%d siegħat',
11129 
+            d : 'ġurnata',
11130 
+            dd : '%d ġranet',
11131 
+            M : 'xahar',
11132 
+            MM : '%d xhur',
11133 
+            y : 'sena',
11134 
+            yy : '%d sni'
11135 
+        },
11136 
+        dayOfMonthOrdinalParse : /\d{1,2}º/,
11137 
+        ordinal: '%dº',
11138 
+        week : {
11139 
+            dow : 1, // Monday is the first day of the week.
11140 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
11141 
+        }
11142 
+    });
11143 
+
11144 
+    //! moment.js locale configuration
11145 
+
11146 
+    var symbolMap$c = {
11147 
+        '1': '၁',
11148 
+        '2': '၂',
11149 
+        '3': '၃',
11150 
+        '4': '၄',
11151 
+        '5': '၅',
11152 
+        '6': '၆',
11153 
+        '7': '၇',
11154 
+        '8': '၈',
11155 
+        '9': '၉',
11156 
+        '0': '၀'
11157 
+    }, numberMap$b = {
11158 
+        '၁': '1',
11159 
+        '၂': '2',
11160 
+        '၃': '3',
11161 
+        '၄': '4',
11162 
+        '၅': '5',
11163 
+        '၆': '6',
11164 
+        '၇': '7',
11165 
+        '၈': '8',
11166 
+        '၉': '9',
11167 
+        '၀': '0'
11168 
+    };
11169 
+
11170 
+    hooks.defineLocale('my', {
11171 
+        months: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split('_'),
11172 
+        monthsShort: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
11173 
+        weekdays: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split('_'),
11174 
+        weekdaysShort: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
11175 
+        weekdaysMin: 'နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
11176 
+
11177 
+        longDateFormat: {
11178 
+            LT: 'HH:mm',
11179 
+            LTS: 'HH:mm:ss',
11180 
+            L: 'DD/MM/YYYY',
11181 
+            LL: 'D MMMM YYYY',
11182 
+            LLL: 'D MMMM YYYY HH:mm',
11183 
+            LLLL: 'dddd D MMMM YYYY HH:mm'
11184 
+        },
11185 
+        calendar: {
11186 
+            sameDay: '[ယနေ.] LT [မှာ]',
11187 
+            nextDay: '[မနက်ဖြန်] LT [မှာ]',
11188 
+            nextWeek: 'dddd LT [မှာ]',
11189 
+            lastDay: '[မနေ.က] LT [မှာ]',
11190 
+            lastWeek: '[ပြီးခဲ့သော] dddd LT [မှာ]',
11191 
+            sameElse: 'L'
11192 
+        },
11193 
+        relativeTime: {
11194 
+            future: 'လာမည့် %s မှာ',
11195 
+            past: 'လွန်ခဲ့သော %s က',
11196 
+            s: 'စက္ကန်.အနည်းငယ်',
11197 
+            ss : '%d စက္ကန့်',
11198 
+            m: 'တစ်မိနစ်',
11199 
+            mm: '%d မိနစ်',
11200 
+            h: 'တစ်နာရီ',
11201 
+            hh: '%d နာရီ',
11202 
+            d: 'တစ်ရက်',
11203 
+            dd: '%d ရက်',
11204 
+            M: 'တစ်လ',
11205 
+            MM: '%d လ',
11206 
+            y: 'တစ်နှစ်',
11207 
+            yy: '%d နှစ်'
11208 
+        },
11209 
+        preparse: function (string) {
11210 
+            return string.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match) {
11211 
+                return numberMap$b[match];
11212 
+            });
11213 
+        },
11214 
+        postformat: function (string) {
11215 
+            return string.replace(/\d/g, function (match) {
11216 
+                return symbolMap$c[match];
11217 
+            });
11218 
+        },
11219 
+        week: {
11220 
+            dow: 1, // Monday is the first day of the week.
11221 
+            doy: 4 // The week that contains Jan 4th is the first week of the year.
11222 
+        }
11223 
+    });
11224 
+
11225 
+    //! moment.js locale configuration
11226 
+
11227 
+    hooks.defineLocale('nb', {
11228 
+        months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
11229 
+        monthsShort : 'jan._feb._mars_april_mai_juni_juli_aug._sep._okt._nov._des.'.split('_'),
11230 
+        monthsParseExact : true,
11231 
+        weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
11232 
+        weekdaysShort : 'sø._ma._ti._on._to._fr._lø.'.split('_'),
11233 
+        weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
11234 
+        weekdaysParseExact : true,
11235 
+        longDateFormat : {
11236 
+            LT : 'HH:mm',
11237 
+            LTS : 'HH:mm:ss',
11238 
+            L : 'DD.MM.YYYY',
11239 
+            LL : 'D. MMMM YYYY',
11240 
+            LLL : 'D. MMMM YYYY [kl.] HH:mm',
11241 
+            LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
11242 
+        },
11243 
+        calendar : {
11244 
+            sameDay: '[i dag kl.] LT',
11245 
+            nextDay: '[i morgen kl.] LT',
11246 
+            nextWeek: 'dddd [kl.] LT',
11247 
+            lastDay: '[i går kl.] LT',
11248 
+            lastWeek: '[forrige] dddd [kl.] LT',
11249 
+            sameElse: 'L'
11250 
+        },
11251 
+        relativeTime : {
11252 
+            future : 'om %s',
11253 
+            past : '%s siden',
11254 
+            s : 'noen sekunder',
11255 
+            ss : '%d sekunder',
11256 
+            m : 'ett minutt',
11257 
+            mm : '%d minutter',
11258 
+            h : 'en time',
11259 
+            hh : '%d timer',
11260 
+            d : 'en dag',
11261 
+            dd : '%d dager',
11262 
+            M : 'en måned',
11263 
+            MM : '%d måneder',
11264 
+            y : 'ett år',
11265 
+            yy : '%d år'
11266 
+        },
11267 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
11268 
+        ordinal : '%d.',
11269 
+        week : {
11270 
+            dow : 1, // Monday is the first day of the week.
11271 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
11272 
+        }
11273 
+    });
11274 
+
11275 
+    //! moment.js locale configuration
11276 
+
11277 
+    var symbolMap$d = {
11278 
+        '1': '१',
11279 
+        '2': '२',
11280 
+        '3': '३',
11281 
+        '4': '४',
11282 
+        '5': '५',
11283 
+        '6': '६',
11284 
+        '7': '७',
11285 
+        '8': '८',
11286 
+        '9': '९',
11287 
+        '0': '०'
11288 
+    },
11289 
+    numberMap$c = {
11290 
+        '१': '1',
11291 
+        '२': '2',
11292 
+        '३': '3',
11293 
+        '४': '4',
11294 
+        '५': '5',
11295 
+        '६': '6',
11296 
+        '७': '7',
11297 
+        '८': '8',
11298 
+        '९': '9',
11299 
+        '०': '0'
11300 
+    };
11301 
+
11302 
+    hooks.defineLocale('ne', {
11303 
+        months : 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split('_'),
11304 
+        monthsShort : 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split('_'),
11305 
+        monthsParseExact : true,
11306 
+        weekdays : 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split('_'),
11307 
+        weekdaysShort : 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
11308 
+        weekdaysMin : 'आ._सो._मं._बु._बि._शु._श.'.split('_'),
11309 
+        weekdaysParseExact : true,
11310 
+        longDateFormat : {
11311 
+            LT : 'Aको h:mm बजे',
11312 
+            LTS : 'Aको h:mm:ss बजे',
11313 
+            L : 'DD/MM/YYYY',
11314 
+            LL : 'D MMMM YYYY',
11315 
+            LLL : 'D MMMM YYYY, Aको h:mm बजे',
11316 
+            LLLL : 'dddd, D MMMM YYYY, Aको h:mm बजे'
11317 
+        },
11318 
+        preparse: function (string) {
11319 
+            return string.replace(/[१२३४५६७८९०]/g, function (match) {
11320 
+                return numberMap$c[match];
11321 
+            });
11322 
+        },
11323 
+        postformat: function (string) {
11324 
+            return string.replace(/\d/g, function (match) {
11325 
+                return symbolMap$d[match];
11326 
+            });
11327 
+        },
11328 
+        meridiemParse: /राति|बिहान|दिउँसो|साँझ/,
11329 
+        meridiemHour : function (hour, meridiem) {
11330 
+            if (hour === 12) {
11331 
+                hour = 0;
11332 
+            }
11333 
+            if (meridiem === 'राति') {
11334 
+                return hour < 4 ? hour : hour + 12;
11335 
+            } else if (meridiem === 'बिहान') {
11336 
+                return hour;
11337 
+            } else if (meridiem === 'दिउँसो') {
11338 
+                return hour >= 10 ? hour : hour + 12;
11339 
+            } else if (meridiem === 'साँझ') {
11340 
+                return hour + 12;
11341 
+            }
11342 
+        },
11343 
+        meridiem : function (hour, minute, isLower) {
11344 
+            if (hour < 3) {
11345 
+                return 'राति';
11346 
+            } else if (hour < 12) {
11347 
+                return 'बिहान';
11348 
+            } else if (hour < 16) {
11349 
+                return 'दिउँसो';
11350 
+            } else if (hour < 20) {
11351 
+                return 'साँझ';
11352 
+            } else {
11353 
+                return 'राति';
11354 
+            }
11355 
+        },
11356 
+        calendar : {
11357 
+            sameDay : '[आज] LT',
11358 
+            nextDay : '[भोलि] LT',
11359 
+            nextWeek : '[आउँदो] dddd[,] LT',
11360 
+            lastDay : '[हिजो] LT',
11361 
+            lastWeek : '[गएको] dddd[,] LT',
11362 
+            sameElse : 'L'
11363 
+        },
11364 
+        relativeTime : {
11365 
+            future : '%sमा',
11366 
+            past : '%s अगाडि',
11367 
+            s : 'केही क्षण',
11368 
+            ss : '%d सेकेण्ड',
11369 
+            m : 'एक मिनेट',
11370 
+            mm : '%d मिनेट',
11371 
+            h : 'एक घण्टा',
11372 
+            hh : '%d घण्टा',
11373 
+            d : 'एक दिन',
11374 
+            dd : '%d दिन',
11375 
+            M : 'एक महिना',
11376 
+            MM : '%d महिना',
11377 
+            y : 'एक बर्ष',
11378 
+            yy : '%d बर्ष'
11379 
+        },
11380 
+        week : {
11381 
+            dow : 0, // Sunday is the first day of the week.
11382 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
11383 
+        }
11384 
+    });
11385 
+
11386 
+    //! moment.js locale configuration
11387 
+
11388 
+    var monthsShortWithDots$1 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
11389 
+        monthsShortWithoutDots$1 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
11390 
+
11391 
+    var monthsParse$4 = [/^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];
11392 
+    var monthsRegex$5 = /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
11393 
+
11394 
+    hooks.defineLocale('nl-be', {
11395 
+        months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
11396 
+        monthsShort : function (m, format) {
11397 
+            if (!m) {
11398 
+                return monthsShortWithDots$1;
11399 
+            } else if (/-MMM-/.test(format)) {
11400 
+                return monthsShortWithoutDots$1[m.month()];
11401 
+            } else {
11402 
+                return monthsShortWithDots$1[m.month()];
11403 
+            }
11404 
+        },
11405 
+
11406 
+        monthsRegex: monthsRegex$5,
11407 
+        monthsShortRegex: monthsRegex$5,
11408 
+        monthsStrictRegex: /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,
11409 
+        monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
11410 
+
11411 
+        monthsParse : monthsParse$4,
11412 
+        longMonthsParse : monthsParse$4,
11413 
+        shortMonthsParse : monthsParse$4,
11414 
+
11415 
+        weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
11416 
+        weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
11417 
+        weekdaysMin : 'zo_ma_di_wo_do_vr_za'.split('_'),
11418 
+        weekdaysParseExact : true,
11419 
+        longDateFormat : {
11420 
+            LT : 'HH:mm',
11421 
+            LTS : 'HH:mm:ss',
11422 
+            L : 'DD/MM/YYYY',
11423 
+            LL : 'D MMMM YYYY',
11424 
+            LLL : 'D MMMM YYYY HH:mm',
11425 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
11426 
+        },
11427 
+        calendar : {
11428 
+            sameDay: '[vandaag om] LT',
11429 
+            nextDay: '[morgen om] LT',
11430 
+            nextWeek: 'dddd [om] LT',
11431 
+            lastDay: '[gisteren om] LT',
11432 
+            lastWeek: '[afgelopen] dddd [om] LT',
11433 
+            sameElse: 'L'
11434 
+        },
11435 
+        relativeTime : {
11436 
+            future : 'over %s',
11437 
+            past : '%s geleden',
11438 
+            s : 'een paar seconden',
11439 
+            ss : '%d seconden',
11440 
+            m : 'één minuut',
11441 
+            mm : '%d minuten',
11442 
+            h : 'één uur',
11443 
+            hh : '%d uur',
11444 
+            d : 'één dag',
11445 
+            dd : '%d dagen',
11446 
+            M : 'één maand',
11447 
+            MM : '%d maanden',
11448 
+            y : 'één jaar',
11449 
+            yy : '%d jaar'
11450 
+        },
11451 
+        dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
11452 
+        ordinal : function (number) {
11453 
+            return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
11454 
+        },
11455 
+        week : {
11456 
+            dow : 1, // Monday is the first day of the week.
11457 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
11458 
+        }
11459 
+    });
11460 
+
11461 
+    //! moment.js locale configuration
11462 
+
11463 
+    var monthsShortWithDots$2 = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
11464 
+        monthsShortWithoutDots$2 = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');
11465 
+
11466 
+    var monthsParse$5 = [/^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];
11467 
+    var monthsRegex$6 = /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;
11468 
+
11469 
+    hooks.defineLocale('nl', {
11470 
+        months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
11471 
+        monthsShort : function (m, format) {
11472 
+            if (!m) {
11473 
+                return monthsShortWithDots$2;
11474 
+            } else if (/-MMM-/.test(format)) {
11475 
+                return monthsShortWithoutDots$2[m.month()];
11476 
+            } else {
11477 
+                return monthsShortWithDots$2[m.month()];
11478 
+            }
11479 
+        },
11480 
+
11481 
+        monthsRegex: monthsRegex$6,
11482 
+        monthsShortRegex: monthsRegex$6,
11483 
+        monthsStrictRegex: /^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,
11484 
+        monthsShortStrictRegex: /^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,
11485 
+
11486 
+        monthsParse : monthsParse$5,
11487 
+        longMonthsParse : monthsParse$5,
11488 
+        shortMonthsParse : monthsParse$5,
11489 
+
11490 
+        weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
11491 
+        weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
11492 
+        weekdaysMin : 'zo_ma_di_wo_do_vr_za'.split('_'),
11493 
+        weekdaysParseExact : true,
11494 
+        longDateFormat : {
11495 
+            LT : 'HH:mm',
11496 
+            LTS : 'HH:mm:ss',
11497 
+            L : 'DD-MM-YYYY',
11498 
+            LL : 'D MMMM YYYY',
11499 
+            LLL : 'D MMMM YYYY HH:mm',
11500 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
11501 
+        },
11502 
+        calendar : {
11503 
+            sameDay: '[vandaag om] LT',
11504 
+            nextDay: '[morgen om] LT',
11505 
+            nextWeek: 'dddd [om] LT',
11506 
+            lastDay: '[gisteren om] LT',
11507 
+            lastWeek: '[afgelopen] dddd [om] LT',
11508 
+            sameElse: 'L'
11509 
+        },
11510 
+        relativeTime : {
11511 
+            future : 'over %s',
11512 
+            past : '%s geleden',
11513 
+            s : 'een paar seconden',
11514 
+            ss : '%d seconden',
11515 
+            m : 'één minuut',
11516 
+            mm : '%d minuten',
11517 
+            h : 'één uur',
11518 
+            hh : '%d uur',
11519 
+            d : 'één dag',
11520 
+            dd : '%d dagen',
11521 
+            M : 'één maand',
11522 
+            MM : '%d maanden',
11523 
+            y : 'één jaar',
11524 
+            yy : '%d jaar'
11525 
+        },
11526 
+        dayOfMonthOrdinalParse: /\d{1,2}(ste|de)/,
11527 
+        ordinal : function (number) {
11528 
+            return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
11529 
+        },
11530 
+        week : {
11531 
+            dow : 1, // Monday is the first day of the week.
11532 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
11533 
+        }
11534 
+    });
11535 
+
11536 
+    //! moment.js locale configuration
11537 
+
11538 
+    hooks.defineLocale('nn', {
11539 
+        months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
11540 
+        monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
11541 
+        weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
11542 
+        weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
11543 
+        weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),
11544 
+        longDateFormat : {
11545 
+            LT : 'HH:mm',
11546 
+            LTS : 'HH:mm:ss',
11547 
+            L : 'DD.MM.YYYY',
11548 
+            LL : 'D. MMMM YYYY',
11549 
+            LLL : 'D. MMMM YYYY [kl.] H:mm',
11550 
+            LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'
11551 
+        },
11552 
+        calendar : {
11553 
+            sameDay: '[I dag klokka] LT',
11554 
+            nextDay: '[I morgon klokka] LT',
11555 
+            nextWeek: 'dddd [klokka] LT',
11556 
+            lastDay: '[I går klokka] LT',
11557 
+            lastWeek: '[Føregåande] dddd [klokka] LT',
11558 
+            sameElse: 'L'
11559 
+        },
11560 
+        relativeTime : {
11561 
+            future : 'om %s',
11562 
+            past : '%s sidan',
11563 
+            s : 'nokre sekund',
11564 
+            ss : '%d sekund',
11565 
+            m : 'eit minutt',
11566 
+            mm : '%d minutt',
11567 
+            h : 'ein time',
11568 
+            hh : '%d timar',
11569 
+            d : 'ein dag',
11570 
+            dd : '%d dagar',
11571 
+            M : 'ein månad',
11572 
+            MM : '%d månader',
11573 
+            y : 'eit år',
11574 
+            yy : '%d år'
11575 
+        },
11576 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
11577 
+        ordinal : '%d.',
11578 
+        week : {
11579 
+            dow : 1, // Monday is the first day of the week.
11580 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
11581 
+        }
11582 
+    });
11583 
+
11584 
+    //! moment.js locale configuration
11585 
+
11586 
+    var symbolMap$e = {
11587 
+        '1': '੧',
11588 
+        '2': '੨',
11589 
+        '3': '੩',
11590 
+        '4': '੪',
11591 
+        '5': '੫',
11592 
+        '6': '੬',
11593 
+        '7': '੭',
11594 
+        '8': '੮',
11595 
+        '9': '੯',
11596 
+        '0': '੦'
11597 
+    },
11598 
+    numberMap$d = {
11599 
+        '੧': '1',
11600 
+        '੨': '2',
11601 
+        '੩': '3',
11602 
+        '੪': '4',
11603 
+        '੫': '5',
11604 
+        '੬': '6',
11605 
+        '੭': '7',
11606 
+        '੮': '8',
11607 
+        '੯': '9',
11608 
+        '੦': '0'
11609 
+    };
11610 
+
11611 
+    hooks.defineLocale('pa-in', {
11612 
+        // There are months name as per Nanakshahi Calendar but they are not used as rigidly in modern Punjabi.
11613 
+        months : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
11614 
+        monthsShort : 'ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ'.split('_'),
11615 
+        weekdays : 'ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ'.split('_'),
11616 
+        weekdaysShort : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
11617 
+        weekdaysMin : 'ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ'.split('_'),
11618 
+        longDateFormat : {
11619 
+            LT : 'A h:mm ਵਜੇ',
11620 
+            LTS : 'A h:mm:ss ਵਜੇ',
11621 
+            L : 'DD/MM/YYYY',
11622 
+            LL : 'D MMMM YYYY',
11623 
+            LLL : 'D MMMM YYYY, A h:mm ਵਜੇ',
11624 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm ਵਜੇ'
11625 
+        },
11626 
+        calendar : {
11627 
+            sameDay : '[ਅਜ] LT',
11628 
+            nextDay : '[ਕਲ] LT',
11629 
+            nextWeek : '[ਅਗਲਾ] dddd, LT',
11630 
+            lastDay : '[ਕਲ] LT',
11631 
+            lastWeek : '[ਪਿਛਲੇ] dddd, LT',
11632 
+            sameElse : 'L'
11633 
+        },
11634 
+        relativeTime : {
11635 
+            future : '%s ਵਿੱਚ',
11636 
+            past : '%s ਪਿਛਲੇ',
11637 
+            s : 'ਕੁਝ ਸਕਿੰਟ',
11638 
+            ss : '%d ਸਕਿੰਟ',
11639 
+            m : 'ਇਕ ਮਿੰਟ',
11640 
+            mm : '%d ਮਿੰਟ',
11641 
+            h : 'ਇੱਕ ਘੰਟਾ',
11642 
+            hh : '%d ਘੰਟੇ',
11643 
+            d : 'ਇੱਕ ਦਿਨ',
11644 
+            dd : '%d ਦਿਨ',
11645 
+            M : 'ਇੱਕ ਮਹੀਨਾ',
11646 
+            MM : '%d ਮਹੀਨੇ',
11647 
+            y : 'ਇੱਕ ਸਾਲ',
11648 
+            yy : '%d ਸਾਲ'
11649 
+        },
11650 
+        preparse: function (string) {
11651 
+            return string.replace(/[੧੨੩੪੫੬੭੮੯੦]/g, function (match) {
11652 
+                return numberMap$d[match];
11653 
+            });
11654 
+        },
11655 
+        postformat: function (string) {
11656 
+            return string.replace(/\d/g, function (match) {
11657 
+                return symbolMap$e[match];
11658 
+            });
11659 
+        },
11660 
+        // Punjabi notation for meridiems are quite fuzzy in practice. While there exists
11661 
+        // a rigid notion of a 'Pahar' it is not used as rigidly in modern Punjabi.
11662 
+        meridiemParse: /ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,
11663 
+        meridiemHour : function (hour, meridiem) {
11664 
+            if (hour === 12) {
11665 
+                hour = 0;
11666 
+            }
11667 
+            if (meridiem === 'ਰਾਤ') {
11668 
+                return hour < 4 ? hour : hour + 12;
11669 
+            } else if (meridiem === 'ਸਵੇਰ') {
11670 
+                return hour;
11671 
+            } else if (meridiem === 'ਦੁਪਹਿਰ') {
11672 
+                return hour >= 10 ? hour : hour + 12;
11673 
+            } else if (meridiem === 'ਸ਼ਾਮ') {
11674 
+                return hour + 12;
11675 
+            }
11676 
+        },
11677 
+        meridiem : function (hour, minute, isLower) {
11678 
+            if (hour < 4) {
11679 
+                return 'ਰਾਤ';
11680 
+            } else if (hour < 10) {
11681 
+                return 'ਸਵੇਰ';
11682 
+            } else if (hour < 17) {
11683 
+                return 'ਦੁਪਹਿਰ';
11684 
+            } else if (hour < 20) {
11685 
+                return 'ਸ਼ਾਮ';
11686 
+            } else {
11687 
+                return 'ਰਾਤ';
11688 
+            }
11689 
+        },
11690 
+        week : {
11691 
+            dow : 0, // Sunday is the first day of the week.
11692 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
11693 
+        }
11694 
+    });
11695 
+
11696 
+    //! moment.js locale configuration
11697 
+
11698 
+    var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'),
11699 
+        monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');
11700 
+    function plural$3(n) {
11701 
+        return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);
11702 
+    }
11703 
+    function translate$8(number, withoutSuffix, key) {
11704 
+        var result = number + ' ';
11705 
+        switch (key) {
11706 
+            case 'ss':
11707 
+                return result + (plural$3(number) ? 'sekundy' : 'sekund');
11708 
+            case 'm':
11709 
+                return withoutSuffix ? 'minuta' : 'minutę';
11710 
+            case 'mm':
11711 
+                return result + (plural$3(number) ? 'minuty' : 'minut');
11712 
+            case 'h':
11713 
+                return withoutSuffix  ? 'godzina'  : 'godzinę';
11714 
+            case 'hh':
11715 
+                return result + (plural$3(number) ? 'godziny' : 'godzin');
11716 
+            case 'MM':
11717 
+                return result + (plural$3(number) ? 'miesiące' : 'miesięcy');
11718 
+            case 'yy':
11719 
+                return result + (plural$3(number) ? 'lata' : 'lat');
11720 
+        }
11721 
+    }
11722 
+
11723 
+    hooks.defineLocale('pl', {
11724 
+        months : function (momentToFormat, format) {
11725 
+            if (!momentToFormat) {
11726 
+                return monthsNominative;
11727 
+            } else if (format === '') {
11728 
+                // Hack: if format empty we know this is used to generate
11729 
+                // RegExp by moment. Give then back both valid forms of months
11730 
+                // in RegExp ready format.
11731 
+                return '(' + monthsSubjective[momentToFormat.month()] + '|' + monthsNominative[momentToFormat.month()] + ')';
11732 
+            } else if (/D MMMM/.test(format)) {
11733 
+                return monthsSubjective[momentToFormat.month()];
11734 
+            } else {
11735 
+                return monthsNominative[momentToFormat.month()];
11736 
+            }
11737 
+        },
11738 
+        monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
11739 
+        weekdays : 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
11740 
+        weekdaysShort : 'ndz_pon_wt_śr_czw_pt_sob'.split('_'),
11741 
+        weekdaysMin : 'Nd_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
11742 
+        longDateFormat : {
11743 
+            LT : 'HH:mm',
11744 
+            LTS : 'HH:mm:ss',
11745 
+            L : 'DD.MM.YYYY',
11746 
+            LL : 'D MMMM YYYY',
11747 
+            LLL : 'D MMMM YYYY HH:mm',
11748 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
11749 
+        },
11750 
+        calendar : {
11751 
+            sameDay: '[Dziś o] LT',
11752 
+            nextDay: '[Jutro o] LT',
11753 
+            nextWeek: function () {
11754 
+                switch (this.day()) {
11755 
+                    case 0:
11756 
+                        return '[W niedzielę o] LT';
11757 
+
11758 
+                    case 2:
11759 
+                        return '[We wtorek o] LT';
11760 
+
11761 
+                    case 3:
11762 
+                        return '[W środę o] LT';
11763 
+
11764 
+                    case 6:
11765 
+                        return '[W sobotę o] LT';
11766 
+
11767 
+                    default:
11768 
+                        return '[W] dddd [o] LT';
11769 
+                }
11770 
+            },
11771 
+            lastDay: '[Wczoraj o] LT',
11772 
+            lastWeek: function () {
11773 
+                switch (this.day()) {
11774 
+                    case 0:
11775 
+                        return '[W zeszłą niedzielę o] LT';
11776 
+                    case 3:
11777 
+                        return '[W zeszłą środę o] LT';
11778 
+                    case 6:
11779 
+                        return '[W zeszłą sobotę o] LT';
11780 
+                    default:
11781 
+                        return '[W zeszły] dddd [o] LT';
11782 
+                }
11783 
+            },
11784 
+            sameElse: 'L'
11785 
+        },
11786 
+        relativeTime : {
11787 
+            future : 'za %s',
11788 
+            past : '%s temu',
11789 
+            s : 'kilka sekund',
11790 
+            ss : translate$8,
11791 
+            m : translate$8,
11792 
+            mm : translate$8,
11793 
+            h : translate$8,
11794 
+            hh : translate$8,
11795 
+            d : '1 dzień',
11796 
+            dd : '%d dni',
11797 
+            M : 'miesiąc',
11798 
+            MM : translate$8,
11799 
+            y : 'rok',
11800 
+            yy : translate$8
11801 
+        },
11802 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
11803 
+        ordinal : '%d.',
11804 
+        week : {
11805 
+            dow : 1, // Monday is the first day of the week.
11806 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
11807 
+        }
11808 
+    });
11809 
+
11810 
+    //! moment.js locale configuration
11811 
+
11812 
+    hooks.defineLocale('pt-br', {
11813 
+        months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
11814 
+        monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
11815 
+        weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
11816 
+        weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
11817 
+        weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
11818 
+        weekdaysParseExact : true,
11819 
+        longDateFormat : {
11820 
+            LT : 'HH:mm',
11821 
+            LTS : 'HH:mm:ss',
11822 
+            L : 'DD/MM/YYYY',
11823 
+            LL : 'D [de] MMMM [de] YYYY',
11824 
+            LLL : 'D [de] MMMM [de] YYYY [às] HH:mm',
11825 
+            LLLL : 'dddd, D [de] MMMM [de] YYYY [às] HH:mm'
11826 
+        },
11827 
+        calendar : {
11828 
+            sameDay: '[Hoje às] LT',
11829 
+            nextDay: '[Amanhã às] LT',
11830 
+            nextWeek: 'dddd [às] LT',
11831 
+            lastDay: '[Ontem às] LT',
11832 
+            lastWeek: function () {
11833 
+                return (this.day() === 0 || this.day() === 6) ?
11834 
+                    '[Último] dddd [às] LT' : // Saturday + Sunday
11835 
+                    '[Última] dddd [às] LT'; // Monday - Friday
11836 
+            },
11837 
+            sameElse: 'L'
11838 
+        },
11839 
+        relativeTime : {
11840 
+            future : 'em %s',
11841 
+            past : 'há %s',
11842 
+            s : 'poucos segundos',
11843 
+            ss : '%d segundos',
11844 
+            m : 'um minuto',
11845 
+            mm : '%d minutos',
11846 
+            h : 'uma hora',
11847 
+            hh : '%d horas',
11848 
+            d : 'um dia',
11849 
+            dd : '%d dias',
11850 
+            M : 'um mês',
11851 
+            MM : '%d meses',
11852 
+            y : 'um ano',
11853 
+            yy : '%d anos'
11854 
+        },
11855 
+        dayOfMonthOrdinalParse: /\d{1,2}º/,
11856 
+        ordinal : '%dº'
11857 
+    });
11858 
+
11859 
+    //! moment.js locale configuration
11860 
+
11861 
+    hooks.defineLocale('pt', {
11862 
+        months : 'Janeiro_Fevereiro_Março_Abril_Maio_Junho_Julho_Agosto_Setembro_Outubro_Novembro_Dezembro'.split('_'),
11863 
+        monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
11864 
+        weekdays : 'Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado'.split('_'),
11865 
+        weekdaysShort : 'Dom_Seg_Ter_Qua_Qui_Sex_Sáb'.split('_'),
11866 
+        weekdaysMin : 'Do_2ª_3ª_4ª_5ª_6ª_Sá'.split('_'),
11867 
+        weekdaysParseExact : true,
11868 
+        longDateFormat : {
11869 
+            LT : 'HH:mm',
11870 
+            LTS : 'HH:mm:ss',
11871 
+            L : 'DD/MM/YYYY',
11872 
+            LL : 'D [de] MMMM [de] YYYY',
11873 
+            LLL : 'D [de] MMMM [de] YYYY HH:mm',
11874 
+            LLLL : 'dddd, D [de] MMMM [de] YYYY HH:mm'
11875 
+        },
11876 
+        calendar : {
11877 
+            sameDay: '[Hoje às] LT',
11878 
+            nextDay: '[Amanhã às] LT',
11879 
+            nextWeek: 'dddd [às] LT',
11880 
+            lastDay: '[Ontem às] LT',
11881 
+            lastWeek: function () {
11882 
+                return (this.day() === 0 || this.day() === 6) ?
11883 
+                    '[Último] dddd [às] LT' : // Saturday + Sunday
11884 
+                    '[Última] dddd [às] LT'; // Monday - Friday
11885 
+            },
11886 
+            sameElse: 'L'
11887 
+        },
11888 
+        relativeTime : {
11889 
+            future : 'em %s',
11890 
+            past : 'há %s',
11891 
+            s : 'segundos',
11892 
+            ss : '%d segundos',
11893 
+            m : 'um minuto',
11894 
+            mm : '%d minutos',
11895 
+            h : 'uma hora',
11896 
+            hh : '%d horas',
11897 
+            d : 'um dia',
11898 
+            dd : '%d dias',
11899 
+            M : 'um mês',
11900 
+            MM : '%d meses',
11901 
+            y : 'um ano',
11902 
+            yy : '%d anos'
11903 
+        },
11904 
+        dayOfMonthOrdinalParse: /\d{1,2}º/,
11905 
+        ordinal : '%dº',
11906 
+        week : {
11907 
+            dow : 1, // Monday is the first day of the week.
11908 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
11909 
+        }
11910 
+    });
11911 
+
11912 
+    //! moment.js locale configuration
11913 
+
11914 
+    function relativeTimeWithPlural$2(number, withoutSuffix, key) {
11915 
+        var format = {
11916 
+                'ss': 'secunde',
11917 
+                'mm': 'minute',
11918 
+                'hh': 'ore',
11919 
+                'dd': 'zile',
11920 
+                'MM': 'luni',
11921 
+                'yy': 'ani'
11922 
+            },
11923 
+            separator = ' ';
11924 
+        if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
11925 
+            separator = ' de ';
11926 
+        }
11927 
+        return number + separator + format[key];
11928 
+    }
11929 
+
11930 
+    hooks.defineLocale('ro', {
11931 
+        months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
11932 
+        monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
11933 
+        monthsParseExact: true,
11934 
+        weekdays : 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
11935 
+        weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
11936 
+        weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
11937 
+        longDateFormat : {
11938 
+            LT : 'H:mm',
11939 
+            LTS : 'H:mm:ss',
11940 
+            L : 'DD.MM.YYYY',
11941 
+            LL : 'D MMMM YYYY',
11942 
+            LLL : 'D MMMM YYYY H:mm',
11943 
+            LLLL : 'dddd, D MMMM YYYY H:mm'
11944 
+        },
11945 
+        calendar : {
11946 
+            sameDay: '[azi la] LT',
11947 
+            nextDay: '[mâine la] LT',
11948 
+            nextWeek: 'dddd [la] LT',
11949 
+            lastDay: '[ieri la] LT',
11950 
+            lastWeek: '[fosta] dddd [la] LT',
11951 
+            sameElse: 'L'
11952 
+        },
11953 
+        relativeTime : {
11954 
+            future : 'peste %s',
11955 
+            past : '%s în urmă',
11956 
+            s : 'câteva secunde',
11957 
+            ss : relativeTimeWithPlural$2,
11958 
+            m : 'un minut',
11959 
+            mm : relativeTimeWithPlural$2,
11960 
+            h : 'o oră',
11961 
+            hh : relativeTimeWithPlural$2,
11962 
+            d : 'o zi',
11963 
+            dd : relativeTimeWithPlural$2,
11964 
+            M : 'o lună',
11965 
+            MM : relativeTimeWithPlural$2,
11966 
+            y : 'un an',
11967 
+            yy : relativeTimeWithPlural$2
11968 
+        },
11969 
+        week : {
11970 
+            dow : 1, // Monday is the first day of the week.
11971 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
11972 
+        }
11973 
+    });
11974 
+
11975 
+    //! moment.js locale configuration
11976 
+
11977 
+    function plural$4(word, num) {
11978 
+        var forms = word.split('_');
11979 
+        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]);
11980 
+    }
11981 
+    function relativeTimeWithPlural$3(number, withoutSuffix, key) {
11982 
+        var format = {
11983 
+            'ss': withoutSuffix ? 'секунда_секунды_секунд' : 'секунду_секунды_секунд',
11984 
+            'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
11985 
+            'hh': 'час_часа_часов',
11986 
+            'dd': 'день_дня_дней',
11987 
+            'MM': 'месяц_месяца_месяцев',
11988 
+            'yy': 'год_года_лет'
11989 
+        };
11990 
+        if (key === 'm') {
11991 
+            return withoutSuffix ? 'минута' : 'минуту';
11992 
+        }
11993 
+        else {
11994 
+            return number + ' ' + plural$4(format[key], +number);
11995 
+        }
11996 
+    }
11997 
+    var monthsParse$6 = [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[йя]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i];
11998 
+
11999 
+    // http://new.gramota.ru/spravka/rules/139-prop : § 103
12000 
+    // Сокращения месяцев: http://new.gramota.ru/spravka/buro/search-answer?s=242637
12001 
+    // CLDR data:          http://www.unicode.org/cldr/charts/28/summary/ru.html#1753
12002 
+    hooks.defineLocale('ru', {
12003 
+        months : {
12004 
+            format: 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_'),
12005 
+            standalone: 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_')
12006 
+        },
12007 
+        monthsShort : {
12008 
+            // по CLDR именно "июл." и "июн.", но какой смысл менять букву на точку ?
12009 
+            format: 'янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.'.split('_'),
12010 
+            standalone: 'янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.'.split('_')
12011 
+        },
12012 
+        weekdays : {
12013 
+            standalone: 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),
12014 
+            format: 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_'),
12015 
+            isFormat: /\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/
12016 
+        },
12017 
+        weekdaysShort : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
12018 
+        weekdaysMin : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
12019 
+        monthsParse : monthsParse$6,
12020 
+        longMonthsParse : monthsParse$6,
12021 
+        shortMonthsParse : monthsParse$6,
12022 
+
12023 
+        // полные названия с падежами, по три буквы, для некоторых, по 4 буквы, сокращения с точкой и без точки
12024 
+        monthsRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
12025 
+
12026 
+        // копия предыдущего
12027 
+        monthsShortRegex: /^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,
12028 
+
12029 
+        // полные названия с падежами
12030 
+        monthsStrictRegex: /^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,
12031 
+
12032 
+        // Выражение, которое соотвествует только сокращённым формам
12033 
+        monthsShortStrictRegex: /^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,
12034 
+        longDateFormat : {
12035 
+            LT : 'H:mm',
12036 
+            LTS : 'H:mm:ss',
12037 
+            L : 'DD.MM.YYYY',
12038 
+            LL : 'D MMMM YYYY г.',
12039 
+            LLL : 'D MMMM YYYY г., H:mm',
12040 
+            LLLL : 'dddd, D MMMM YYYY г., H:mm'
12041 
+        },
12042 
+        calendar : {
12043 
+            sameDay: '[Сегодня, в] LT',
12044 
+            nextDay: '[Завтра, в] LT',
12045 
+            lastDay: '[Вчера, в] LT',
12046 
+            nextWeek: function (now) {
12047 
+                if (now.week() !== this.week()) {
12048 
+                    switch (this.day()) {
12049 
+                        case 0:
12050 
+                            return '[В следующее] dddd, [в] LT';
12051 
+                        case 1:
12052 
+                        case 2:
12053 
+                        case 4:
12054 
+                            return '[В следующий] dddd, [в] LT';
12055 
+                        case 3:
12056 
+                        case 5:
12057 
+                        case 6:
12058 
+                            return '[В следующую] dddd, [в] LT';
12059 
+                    }
12060 
+                } else {
12061 
+                    if (this.day() === 2) {
12062 
+                        return '[Во] dddd, [в] LT';
12063 
+                    } else {
12064 
+                        return '[В] dddd, [в] LT';
12065 
+                    }
12066 
+                }
12067 
+            },
12068 
+            lastWeek: function (now) {
12069 
+                if (now.week() !== this.week()) {
12070 
+                    switch (this.day()) {
12071 
+                        case 0:
12072 
+                            return '[В прошлое] dddd, [в] LT';
12073 
+                        case 1:
12074 
+                        case 2:
12075 
+                        case 4:
12076 
+                            return '[В прошлый] dddd, [в] LT';
12077 
+                        case 3:
12078 
+                        case 5:
12079 
+                        case 6:
12080 
+                            return '[В прошлую] dddd, [в] LT';
12081 
+                    }
12082 
+                } else {
12083 
+                    if (this.day() === 2) {
12084 
+                        return '[Во] dddd, [в] LT';
12085 
+                    } else {
12086 
+                        return '[В] dddd, [в] LT';
12087 
+                    }
12088 
+                }
12089 
+            },
12090 
+            sameElse: 'L'
12091 
+        },
12092 
+        relativeTime : {
12093 
+            future : 'через %s',
12094 
+            past : '%s назад',
12095 
+            s : 'несколько секунд',
12096 
+            ss : relativeTimeWithPlural$3,
12097 
+            m : relativeTimeWithPlural$3,
12098 
+            mm : relativeTimeWithPlural$3,
12099 
+            h : 'час',
12100 
+            hh : relativeTimeWithPlural$3,
12101 
+            d : 'день',
12102 
+            dd : relativeTimeWithPlural$3,
12103 
+            M : 'месяц',
12104 
+            MM : relativeTimeWithPlural$3,
12105 
+            y : 'год',
12106 
+            yy : relativeTimeWithPlural$3
12107 
+        },
12108 
+        meridiemParse: /ночи|утра|дня|вечера/i,
12109 
+        isPM : function (input) {
12110 
+            return /^(дня|вечера)$/.test(input);
12111 
+        },
12112 
+        meridiem : function (hour, minute, isLower) {
12113 
+            if (hour < 4) {
12114 
+                return 'ночи';
12115 
+            } else if (hour < 12) {
12116 
+                return 'утра';
12117 
+            } else if (hour < 17) {
12118 
+                return 'дня';
12119 
+            } else {
12120 
+                return 'вечера';
12121 
+            }
12122 
+        },
12123 
+        dayOfMonthOrdinalParse: /\d{1,2}-(й|го|я)/,
12124 
+        ordinal: function (number, period) {
12125 
+            switch (period) {
12126 
+                case 'M':
12127 
+                case 'd':
12128 
+                case 'DDD':
12129 
+                    return number + '-й';
12130 
+                case 'D':
12131 
+                    return number + '-го';
12132 
+                case 'w':
12133 
+                case 'W':
12134 
+                    return number + '-я';
12135 
+                default:
12136 
+                    return number;
12137 
+            }
12138 
+        },
12139 
+        week : {
12140 
+            dow : 1, // Monday is the first day of the week.
12141 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
12142 
+        }
12143 
+    });
12144 
+
12145 
+    //! moment.js locale configuration
12146 
+
12147 
+    var months$8 = [
12148 
+        'جنوري',
12149 
+        'فيبروري',
12150 
+        'مارچ',
12151 
+        'اپريل',
12152 
+        'مئي',
12153 
+        'جون',
12154 
+        'جولاءِ',
12155 
+        'آگسٽ',
12156 
+        'سيپٽمبر',
12157 
+        'آڪٽوبر',
12158 
+        'نومبر',
12159 
+        'ڊسمبر'
12160 
+    ];
12161 
+    var days$1 = [
12162 
+        'آچر',
12163 
+        'سومر',
12164 
+        'اڱارو',
12165 
+        'اربع',
12166 
+        'خميس',
12167 
+        'جمع',
12168 
+        'ڇنڇر'
12169 
+    ];
12170 
+
12171 
+    hooks.defineLocale('sd', {
12172 
+        months : months$8,
12173 
+        monthsShort : months$8,
12174 
+        weekdays : days$1,
12175 
+        weekdaysShort : days$1,
12176 
+        weekdaysMin : days$1,
12177 
+        longDateFormat : {
12178 
+            LT : 'HH:mm',
12179 
+            LTS : 'HH:mm:ss',
12180 
+            L : 'DD/MM/YYYY',
12181 
+            LL : 'D MMMM YYYY',
12182 
+            LLL : 'D MMMM YYYY HH:mm',
12183 
+            LLLL : 'dddd، D MMMM YYYY HH:mm'
12184 
+        },
12185 
+        meridiemParse: /صبح|شام/,
12186 
+        isPM : function (input) {
12187 
+            return 'شام' === input;
12188 
+        },
12189 
+        meridiem : function (hour, minute, isLower) {
12190 
+            if (hour < 12) {
12191 
+                return 'صبح';
12192 
+            }
12193 
+            return 'شام';
12194 
+        },
12195 
+        calendar : {
12196 
+            sameDay : '[اڄ] LT',
12197 
+            nextDay : '[سڀاڻي] LT',
12198 
+            nextWeek : 'dddd [اڳين هفتي تي] LT',
12199 
+            lastDay : '[ڪالهه] LT',
12200 
+            lastWeek : '[گزريل هفتي] dddd [تي] LT',
12201 
+            sameElse : 'L'
12202 
+        },
12203 
+        relativeTime : {
12204 
+            future : '%s پوء',
12205 
+            past : '%s اڳ',
12206 
+            s : 'چند سيڪنڊ',
12207 
+            ss : '%d سيڪنڊ',
12208 
+            m : 'هڪ منٽ',
12209 
+            mm : '%d منٽ',
12210 
+            h : 'هڪ ڪلاڪ',
12211 
+            hh : '%d ڪلاڪ',
12212 
+            d : 'هڪ ڏينهن',
12213 
+            dd : '%d ڏينهن',
12214 
+            M : 'هڪ مهينو',
12215 
+            MM : '%d مهينا',
12216 
+            y : 'هڪ سال',
12217 
+            yy : '%d سال'
12218 
+        },
12219 
+        preparse: function (string) {
12220 
+            return string.replace(/،/g, ',');
12221 
+        },
12222 
+        postformat: function (string) {
12223 
+            return string.replace(/,/g, '،');
12224 
+        },
12225 
+        week : {
12226 
+            dow : 1, // Monday is the first day of the week.
12227 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
12228 
+        }
12229 
+    });
12230 
+
12231 
+    //! moment.js locale configuration
12232 
+
12233 
+    hooks.defineLocale('se', {
12234 
+        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('_'),
12235 
+        monthsShort : 'ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov'.split('_'),
12236 
+        weekdays : 'sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat'.split('_'),
12237 
+        weekdaysShort : 'sotn_vuos_maŋ_gask_duor_bear_láv'.split('_'),
12238 
+        weekdaysMin : 's_v_m_g_d_b_L'.split('_'),
12239 
+        longDateFormat : {
12240 
+            LT : 'HH:mm',
12241 
+            LTS : 'HH:mm:ss',
12242 
+            L : 'DD.MM.YYYY',
12243 
+            LL : 'MMMM D. [b.] YYYY',
12244 
+            LLL : 'MMMM D. [b.] YYYY [ti.] HH:mm',
12245 
+            LLLL : 'dddd, MMMM D. [b.] YYYY [ti.] HH:mm'
12246 
+        },
12247 
+        calendar : {
12248 
+            sameDay: '[otne ti] LT',
12249 
+            nextDay: '[ihttin ti] LT',
12250 
+            nextWeek: 'dddd [ti] LT',
12251 
+            lastDay: '[ikte ti] LT',
12252 
+            lastWeek: '[ovddit] dddd [ti] LT',
12253 
+            sameElse: 'L'
12254 
+        },
12255 
+        relativeTime : {
12256 
+            future : '%s geažes',
12257 
+            past : 'maŋit %s',
12258 
+            s : 'moadde sekunddat',
12259 
+            ss: '%d sekunddat',
12260 
+            m : 'okta minuhta',
12261 
+            mm : '%d minuhtat',
12262 
+            h : 'okta diimmu',
12263 
+            hh : '%d diimmut',
12264 
+            d : 'okta beaivi',
12265 
+            dd : '%d beaivvit',
12266 
+            M : 'okta mánnu',
12267 
+            MM : '%d mánut',
12268 
+            y : 'okta jahki',
12269 
+            yy : '%d jagit'
12270 
+        },
12271 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
12272 
+        ordinal : '%d.',
12273 
+        week : {
12274 
+            dow : 1, // Monday is the first day of the week.
12275 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
12276 
+        }
12277 
+    });
12278 
+
12279 
+    //! moment.js locale configuration
12280 
+
12281 
+    /*jshint -W100*/
12282 
+    hooks.defineLocale('si', {
12283 
+        months : 'ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්'.split('_'),
12284 
+        monthsShort : 'ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ'.split('_'),
12285 
+        weekdays : 'ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා'.split('_'),
12286 
+        weekdaysShort : 'ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන'.split('_'),
12287 
+        weekdaysMin : 'ඉ_ස_අ_බ_බ්‍ර_සි_සෙ'.split('_'),
12288 
+        weekdaysParseExact : true,
12289 
+        longDateFormat : {
12290 
+            LT : 'a h:mm',
12291 
+            LTS : 'a h:mm:ss',
12292 
+            L : 'YYYY/MM/DD',
12293 
+            LL : 'YYYY MMMM D',
12294 
+            LLL : 'YYYY MMMM D, a h:mm',
12295 
+            LLLL : 'YYYY MMMM D [වැනි] dddd, a h:mm:ss'
12296 
+        },
12297 
+        calendar : {
12298 
+            sameDay : '[අද] LT[ට]',
12299 
+            nextDay : '[හෙට] LT[ට]',
12300 
+            nextWeek : 'dddd LT[ට]',
12301 
+            lastDay : '[ඊයේ] LT[ට]',
12302 
+            lastWeek : '[පසුගිය] dddd LT[ට]',
12303 
+            sameElse : 'L'
12304 
+        },
12305 
+        relativeTime : {
12306 
+            future : '%sකින්',
12307 
+            past : '%sකට පෙර',
12308 
+            s : 'තත්පර කිහිපය',
12309 
+            ss : 'තත්පර %d',
12310 
+            m : 'මිනිත්තුව',
12311 
+            mm : 'මිනිත්තු %d',
12312 
+            h : 'පැය',
12313 
+            hh : 'පැය %d',
12314 
+            d : 'දිනය',
12315 
+            dd : 'දින %d',
12316 
+            M : 'මාසය',
12317 
+            MM : 'මාස %d',
12318 
+            y : 'වසර',
12319 
+            yy : 'වසර %d'
12320 
+        },
12321 
+        dayOfMonthOrdinalParse: /\d{1,2} වැනි/,
12322 
+        ordinal : function (number) {
12323 
+            return number + ' වැනි';
12324 
+        },
12325 
+        meridiemParse : /පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,
12326 
+        isPM : function (input) {
12327 
+            return input === 'ප.ව.' || input === 'පස් වරු';
12328 
+        },
12329 
+        meridiem : function (hours, minutes, isLower) {
12330 
+            if (hours > 11) {
12331 
+                return isLower ? 'ප.ව.' : 'පස් වරු';
12332 
+            } else {
12333 
+                return isLower ? 'පෙ.ව.' : 'පෙර වරු';
12334 
+            }
12335 
+        }
12336 
+    });
12337 
+
12338 
+    //! moment.js locale configuration
12339 
+
12340 
+    var months$9 = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_'),
12341 
+        monthsShort$6 = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');
12342 
+    function plural$5(n) {
12343 
+        return (n > 1) && (n < 5);
12344 
+    }
12345 
+    function translate$9(number, withoutSuffix, key, isFuture) {
12346 
+        var result = number + ' ';
12347 
+        switch (key) {
12348 
+            case 's':  // a few seconds / in a few seconds / a few seconds ago
12349 
+                return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
12350 
+            case 'ss': // 9 seconds / in 9 seconds / 9 seconds ago
12351 
+                if (withoutSuffix || isFuture) {
12352 
+                    return result + (plural$5(number) ? 'sekundy' : 'sekúnd');
12353 
+                } else {
12354 
+                    return result + 'sekundami';
12355 
+                }
12356 
+                break;
12357 
+            case 'm':  // a minute / in a minute / a minute ago
12358 
+                return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou');
12359 
+            case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
12360 
+                if (withoutSuffix || isFuture) {
12361 
+                    return result + (plural$5(number) ? 'minúty' : 'minút');
12362 
+                } else {
12363 
+                    return result + 'minútami';
12364 
+                }
12365 
+                break;
12366 
+            case 'h':  // an hour / in an hour / an hour ago
12367 
+                return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
12368 
+            case 'hh': // 9 hours / in 9 hours / 9 hours ago
12369 
+                if (withoutSuffix || isFuture) {
12370 
+                    return result + (plural$5(number) ? 'hodiny' : 'hodín');
12371 
+                } else {
12372 
+                    return result + 'hodinami';
12373 
+                }
12374 
+                break;
12375 
+            case 'd':  // a day / in a day / a day ago
12376 
+                return (withoutSuffix || isFuture) ? 'deň' : 'dňom';
12377 
+            case 'dd': // 9 days / in 9 days / 9 days ago
12378 
+                if (withoutSuffix || isFuture) {
12379 
+                    return result + (plural$5(number) ? 'dni' : 'dní');
12380 
+                } else {
12381 
+                    return result + 'dňami';
12382 
+                }
12383 
+                break;
12384 
+            case 'M':  // a month / in a month / a month ago
12385 
+                return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
12386 
+            case 'MM': // 9 months / in 9 months / 9 months ago
12387 
+                if (withoutSuffix || isFuture) {
12388 
+                    return result + (plural$5(number) ? 'mesiace' : 'mesiacov');
12389 
+                } else {
12390 
+                    return result + 'mesiacmi';
12391 
+                }
12392 
+                break;
12393 
+            case 'y':  // a year / in a year / a year ago
12394 
+                return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
12395 
+            case 'yy': // 9 years / in 9 years / 9 years ago
12396 
+                if (withoutSuffix || isFuture) {
12397 
+                    return result + (plural$5(number) ? 'roky' : 'rokov');
12398 
+                } else {
12399 
+                    return result + 'rokmi';
12400 
+                }
12401 
+                break;
12402 
+        }
12403 
+    }
12404 
+
12405 
+    hooks.defineLocale('sk', {
12406 
+        months : months$9,
12407 
+        monthsShort : monthsShort$6,
12408 
+        weekdays : 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
12409 
+        weekdaysShort : 'ne_po_ut_st_št_pi_so'.split('_'),
12410 
+        weekdaysMin : 'ne_po_ut_st_št_pi_so'.split('_'),
12411 
+        longDateFormat : {
12412 
+            LT: 'H:mm',
12413 
+            LTS : 'H:mm:ss',
12414 
+            L : 'DD.MM.YYYY',
12415 
+            LL : 'D. MMMM YYYY',
12416 
+            LLL : 'D. MMMM YYYY H:mm',
12417 
+            LLLL : 'dddd D. MMMM YYYY H:mm'
12418 
+        },
12419 
+        calendar : {
12420 
+            sameDay: '[dnes o] LT',
12421 
+            nextDay: '[zajtra o] LT',
12422 
+            nextWeek: function () {
12423 
+                switch (this.day()) {
12424 
+                    case 0:
12425 
+                        return '[v nedeľu o] LT';
12426 
+                    case 1:
12427 
+                    case 2:
12428 
+                        return '[v] dddd [o] LT';
12429 
+                    case 3:
12430 
+                        return '[v stredu o] LT';
12431 
+                    case 4:
12432 
+                        return '[vo štvrtok o] LT';
12433 
+                    case 5:
12434 
+                        return '[v piatok o] LT';
12435 
+                    case 6:
12436 
+                        return '[v sobotu o] LT';
12437 
+                }
12438 
+            },
12439 
+            lastDay: '[včera o] LT',
12440 
+            lastWeek: function () {
12441 
+                switch (this.day()) {
12442 
+                    case 0:
12443 
+                        return '[minulú nedeľu o] LT';
12444 
+                    case 1:
12445 
+                    case 2:
12446 
+                        return '[minulý] dddd [o] LT';
12447 
+                    case 3:
12448 
+                        return '[minulú stredu o] LT';
12449 
+                    case 4:
12450 
+                    case 5:
12451 
+                        return '[minulý] dddd [o] LT';
12452 
+                    case 6:
12453 
+                        return '[minulú sobotu o] LT';
12454 
+                }
12455 
+            },
12456 
+            sameElse: 'L'
12457 
+        },
12458 
+        relativeTime : {
12459 
+            future : 'za %s',
12460 
+            past : 'pred %s',
12461 
+            s : translate$9,
12462 
+            ss : translate$9,
12463 
+            m : translate$9,
12464 
+            mm : translate$9,
12465 
+            h : translate$9,
12466 
+            hh : translate$9,
12467 
+            d : translate$9,
12468 
+            dd : translate$9,
12469 
+            M : translate$9,
12470 
+            MM : translate$9,
12471 
+            y : translate$9,
12472 
+            yy : translate$9
12473 
+        },
12474 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
12475 
+        ordinal : '%d.',
12476 
+        week : {
12477 
+            dow : 1, // Monday is the first day of the week.
12478 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
12479 
+        }
12480 
+    });
12481 
+
12482 
+    //! moment.js locale configuration
12483 
+
12484 
+    function processRelativeTime$6(number, withoutSuffix, key, isFuture) {
12485 
+        var result = number + ' ';
12486 
+        switch (key) {
12487 
+            case 's':
12488 
+                return withoutSuffix || isFuture ? 'nekaj sekund' : 'nekaj sekundami';
12489 
+            case 'ss':
12490 
+                if (number === 1) {
12491 
+                    result += withoutSuffix ? 'sekundo' : 'sekundi';
12492 
+                } else if (number === 2) {
12493 
+                    result += withoutSuffix || isFuture ? 'sekundi' : 'sekundah';
12494 
+                } else if (number < 5) {
12495 
+                    result += withoutSuffix || isFuture ? 'sekunde' : 'sekundah';
12496 
+                } else {
12497 
+                    result += 'sekund';
12498 
+                }
12499 
+                return result;
12500 
+            case 'm':
12501 
+                return withoutSuffix ? 'ena minuta' : 'eno minuto';
12502 
+            case 'mm':
12503 
+                if (number === 1) {
12504 
+                    result += withoutSuffix ? 'minuta' : 'minuto';
12505 
+                } else if (number === 2) {
12506 
+                    result += withoutSuffix || isFuture ? 'minuti' : 'minutama';
12507 
+                } else if (number < 5) {
12508 
+                    result += withoutSuffix || isFuture ? 'minute' : 'minutami';
12509 
+                } else {
12510 
+                    result += withoutSuffix || isFuture ? 'minut' : 'minutami';
12511 
+                }
12512 
+                return result;
12513 
+            case 'h':
12514 
+                return withoutSuffix ? 'ena ura' : 'eno uro';
12515 
+            case 'hh':
12516 
+                if (number === 1) {
12517 
+                    result += withoutSuffix ? 'ura' : 'uro';
12518 
+                } else if (number === 2) {
12519 
+                    result += withoutSuffix || isFuture ? 'uri' : 'urama';
12520 
+                } else if (number < 5) {
12521 
+                    result += withoutSuffix || isFuture ? 'ure' : 'urami';
12522 
+                } else {
12523 
+                    result += withoutSuffix || isFuture ? 'ur' : 'urami';
12524 
+                }
12525 
+                return result;
12526 
+            case 'd':
12527 
+                return withoutSuffix || isFuture ? 'en dan' : 'enim dnem';
12528 
+            case 'dd':
12529 
+                if (number === 1) {
12530 
+                    result += withoutSuffix || isFuture ? 'dan' : 'dnem';
12531 
+                } else if (number === 2) {
12532 
+                    result += withoutSuffix || isFuture ? 'dni' : 'dnevoma';
12533 
+                } else {
12534 
+                    result += withoutSuffix || isFuture ? 'dni' : 'dnevi';
12535 
+                }
12536 
+                return result;
12537 
+            case 'M':
12538 
+                return withoutSuffix || isFuture ? 'en mesec' : 'enim mesecem';
12539 
+            case 'MM':
12540 
+                if (number === 1) {
12541 
+                    result += withoutSuffix || isFuture ? 'mesec' : 'mesecem';
12542 
+                } else if (number === 2) {
12543 
+                    result += withoutSuffix || isFuture ? 'meseca' : 'mesecema';
12544 
+                } else if (number < 5) {
12545 
+                    result += withoutSuffix || isFuture ? 'mesece' : 'meseci';
12546 
+                } else {
12547 
+                    result += withoutSuffix || isFuture ? 'mesecev' : 'meseci';
12548 
+                }
12549 
+                return result;
12550 
+            case 'y':
12551 
+                return withoutSuffix || isFuture ? 'eno leto' : 'enim letom';
12552 
+            case 'yy':
12553 
+                if (number === 1) {
12554 
+                    result += withoutSuffix || isFuture ? 'leto' : 'letom';
12555 
+                } else if (number === 2) {
12556 
+                    result += withoutSuffix || isFuture ? 'leti' : 'letoma';
12557 
+                } else if (number < 5) {
12558 
+                    result += withoutSuffix || isFuture ? 'leta' : 'leti';
12559 
+                } else {
12560 
+                    result += withoutSuffix || isFuture ? 'let' : 'leti';
12561 
+                }
12562 
+                return result;
12563 
+        }
12564 
+    }
12565 
+
12566 
+    hooks.defineLocale('sl', {
12567 
+        months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
12568 
+        monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
12569 
+        monthsParseExact: true,
12570 
+        weekdays : 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
12571 
+        weekdaysShort : 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
12572 
+        weekdaysMin : 'ne_po_to_sr_če_pe_so'.split('_'),
12573 
+        weekdaysParseExact : true,
12574 
+        longDateFormat : {
12575 
+            LT : 'H:mm',
12576 
+            LTS : 'H:mm:ss',
12577 
+            L : 'DD.MM.YYYY',
12578 
+            LL : 'D. MMMM YYYY',
12579 
+            LLL : 'D. MMMM YYYY H:mm',
12580 
+            LLLL : 'dddd, D. MMMM YYYY H:mm'
12581 
+        },
12582 
+        calendar : {
12583 
+            sameDay  : '[danes ob] LT',
12584 
+            nextDay  : '[jutri ob] LT',
12585 
+
12586 
+            nextWeek : function () {
12587 
+                switch (this.day()) {
12588 
+                    case 0:
12589 
+                        return '[v] [nedeljo] [ob] LT';
12590 
+                    case 3:
12591 
+                        return '[v] [sredo] [ob] LT';
12592 
+                    case 6:
12593 
+                        return '[v] [soboto] [ob] LT';
12594 
+                    case 1:
12595 
+                    case 2:
12596 
+                    case 4:
12597 
+                    case 5:
12598 
+                        return '[v] dddd [ob] LT';
12599 
+                }
12600 
+            },
12601 
+            lastDay  : '[včeraj ob] LT',
12602 
+            lastWeek : function () {
12603 
+                switch (this.day()) {
12604 
+                    case 0:
12605 
+                        return '[prejšnjo] [nedeljo] [ob] LT';
12606 
+                    case 3:
12607 
+                        return '[prejšnjo] [sredo] [ob] LT';
12608 
+                    case 6:
12609 
+                        return '[prejšnjo] [soboto] [ob] LT';
12610 
+                    case 1:
12611 
+                    case 2:
12612 
+                    case 4:
12613 
+                    case 5:
12614 
+                        return '[prejšnji] dddd [ob] LT';
12615 
+                }
12616 
+            },
12617 
+            sameElse : 'L'
12618 
+        },
12619 
+        relativeTime : {
12620 
+            future : 'čez %s',
12621 
+            past   : 'pred %s',
12622 
+            s      : processRelativeTime$6,
12623 
+            ss     : processRelativeTime$6,
12624 
+            m      : processRelativeTime$6,
12625 
+            mm     : processRelativeTime$6,
12626 
+            h      : processRelativeTime$6,
12627 
+            hh     : processRelativeTime$6,
12628 
+            d      : processRelativeTime$6,
12629 
+            dd     : processRelativeTime$6,
12630 
+            M      : processRelativeTime$6,
12631 
+            MM     : processRelativeTime$6,
12632 
+            y      : processRelativeTime$6,
12633 
+            yy     : processRelativeTime$6
12634 
+        },
12635 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
12636 
+        ordinal : '%d.',
12637 
+        week : {
12638 
+            dow : 1, // Monday is the first day of the week.
12639 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
12640 
+        }
12641 
+    });
12642 
+
12643 
+    //! moment.js locale configuration
12644 
+
12645 
+    hooks.defineLocale('sq', {
12646 
+        months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
12647 
+        monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
12648 
+        weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
12649 
+        weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
12650 
+        weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'),
12651 
+        weekdaysParseExact : true,
12652 
+        meridiemParse: /PD|MD/,
12653 
+        isPM: function (input) {
12654 
+            return input.charAt(0) === 'M';
12655 
+        },
12656 
+        meridiem : function (hours, minutes, isLower) {
12657 
+            return hours < 12 ? 'PD' : 'MD';
12658 
+        },
12659 
+        longDateFormat : {
12660 
+            LT : 'HH:mm',
12661 
+            LTS : 'HH:mm:ss',
12662 
+            L : 'DD/MM/YYYY',
12663 
+            LL : 'D MMMM YYYY',
12664 
+            LLL : 'D MMMM YYYY HH:mm',
12665 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
12666 
+        },
12667 
+        calendar : {
12668 
+            sameDay : '[Sot në] LT',
12669 
+            nextDay : '[Nesër në] LT',
12670 
+            nextWeek : 'dddd [në] LT',
12671 
+            lastDay : '[Dje në] LT',
12672 
+            lastWeek : 'dddd [e kaluar në] LT',
12673 
+            sameElse : 'L'
12674 
+        },
12675 
+        relativeTime : {
12676 
+            future : 'në %s',
12677 
+            past : '%s më parë',
12678 
+            s : 'disa sekonda',
12679 
+            ss : '%d sekonda',
12680 
+            m : 'një minutë',
12681 
+            mm : '%d minuta',
12682 
+            h : 'një orë',
12683 
+            hh : '%d orë',
12684 
+            d : 'një ditë',
12685 
+            dd : '%d ditë',
12686 
+            M : 'një muaj',
12687 
+            MM : '%d muaj',
12688 
+            y : 'një vit',
12689 
+            yy : '%d vite'
12690 
+        },
12691 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
12692 
+        ordinal : '%d.',
12693 
+        week : {
12694 
+            dow : 1, // Monday is the first day of the week.
12695 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
12696 
+        }
12697 
+    });
12698 
+
12699 
+    //! moment.js locale configuration
12700 
+
12701 
+    var translator$1 = {
12702 
+        words: { //Different grammatical cases
12703 
+            ss: ['секунда', 'секунде', 'секунди'],
12704 
+            m: ['један минут', 'једне минуте'],
12705 
+            mm: ['минут', 'минуте', 'минута'],
12706 
+            h: ['један сат', 'једног сата'],
12707 
+            hh: ['сат', 'сата', 'сати'],
12708 
+            dd: ['дан', 'дана', 'дана'],
12709 
+            MM: ['месец', 'месеца', 'месеци'],
12710 
+            yy: ['година', 'године', 'година']
12711 
+        },
12712 
+        correctGrammaticalCase: function (number, wordKey) {
12713 
+            return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
12714 
+        },
12715 
+        translate: function (number, withoutSuffix, key) {
12716 
+            var wordKey = translator$1.words[key];
12717 
+            if (key.length === 1) {
12718 
+                return withoutSuffix ? wordKey[0] : wordKey[1];
12719 
+            } else {
12720 
+                return number + ' ' + translator$1.correctGrammaticalCase(number, wordKey);
12721 
+            }
12722 
+        }
12723 
+    };
12724 
+
12725 
+    hooks.defineLocale('sr-cyrl', {
12726 
+        months: 'јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар'.split('_'),
12727 
+        monthsShort: 'јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.'.split('_'),
12728 
+        monthsParseExact: true,
12729 
+        weekdays: 'недеља_понедељак_уторак_среда_четвртак_петак_субота'.split('_'),
12730 
+        weekdaysShort: 'нед._пон._уто._сре._чет._пет._суб.'.split('_'),
12731 
+        weekdaysMin: 'не_по_ут_ср_че_пе_су'.split('_'),
12732 
+        weekdaysParseExact : true,
12733 
+        longDateFormat: {
12734 
+            LT: 'H:mm',
12735 
+            LTS : 'H:mm:ss',
12736 
+            L: 'DD.MM.YYYY',
12737 
+            LL: 'D. MMMM YYYY',
12738 
+            LLL: 'D. MMMM YYYY H:mm',
12739 
+            LLLL: 'dddd, D. MMMM YYYY H:mm'
12740 
+        },
12741 
+        calendar: {
12742 
+            sameDay: '[данас у] LT',
12743 
+            nextDay: '[сутра у] LT',
12744 
+            nextWeek: function () {
12745 
+                switch (this.day()) {
12746 
+                    case 0:
12747 
+                        return '[у] [недељу] [у] LT';
12748 
+                    case 3:
12749 
+                        return '[у] [среду] [у] LT';
12750 
+                    case 6:
12751 
+                        return '[у] [суботу] [у] LT';
12752 
+                    case 1:
12753 
+                    case 2:
12754 
+                    case 4:
12755 
+                    case 5:
12756 
+                        return '[у] dddd [у] LT';
12757 
+                }
12758 
+            },
12759 
+            lastDay  : '[јуче у] LT',
12760 
+            lastWeek : function () {
12761 
+                var lastWeekDays = [
12762 
+                    '[прошле] [недеље] [у] LT',
12763 
+                    '[прошлог] [понедељка] [у] LT',
12764 
+                    '[прошлог] [уторка] [у] LT',
12765 
+                    '[прошле] [среде] [у] LT',
12766 
+                    '[прошлог] [четвртка] [у] LT',
12767 
+                    '[прошлог] [петка] [у] LT',
12768 
+                    '[прошле] [суботе] [у] LT'
12769 
+                ];
12770 
+                return lastWeekDays[this.day()];
12771 
+            },
12772 
+            sameElse : 'L'
12773 
+        },
12774 
+        relativeTime : {
12775 
+            future : 'за %s',
12776 
+            past   : 'пре %s',
12777 
+            s      : 'неколико секунди',
12778 
+            ss     : translator$1.translate,
12779 
+            m      : translator$1.translate,
12780 
+            mm     : translator$1.translate,
12781 
+            h      : translator$1.translate,
12782 
+            hh     : translator$1.translate,
12783 
+            d      : 'дан',
12784 
+            dd     : translator$1.translate,
12785 
+            M      : 'месец',
12786 
+            MM     : translator$1.translate,
12787 
+            y      : 'годину',
12788 
+            yy     : translator$1.translate
12789 
+        },
12790 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
12791 
+        ordinal : '%d.',
12792 
+        week : {
12793 
+            dow : 1, // Monday is the first day of the week.
12794 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
12795 
+        }
12796 
+    });
12797 
+
12798 
+    //! moment.js locale configuration
12799 
+
12800 
+    var translator$2 = {
12801 
+        words: { //Different grammatical cases
12802 
+            ss: ['sekunda', 'sekunde', 'sekundi'],
12803 
+            m: ['jedan minut', 'jedne minute'],
12804 
+            mm: ['minut', 'minute', 'minuta'],
12805 
+            h: ['jedan sat', 'jednog sata'],
12806 
+            hh: ['sat', 'sata', 'sati'],
12807 
+            dd: ['dan', 'dana', 'dana'],
12808 
+            MM: ['mesec', 'meseca', 'meseci'],
12809 
+            yy: ['godina', 'godine', 'godina']
12810 
+        },
12811 
+        correctGrammaticalCase: function (number, wordKey) {
12812 
+            return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
12813 
+        },
12814 
+        translate: function (number, withoutSuffix, key) {
12815 
+            var wordKey = translator$2.words[key];
12816 
+            if (key.length === 1) {
12817 
+                return withoutSuffix ? wordKey[0] : wordKey[1];
12818 
+            } else {
12819 
+                return number + ' ' + translator$2.correctGrammaticalCase(number, wordKey);
12820 
+            }
12821 
+        }
12822 
+    };
12823 
+
12824 
+    hooks.defineLocale('sr', {
12825 
+        months: 'januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar'.split('_'),
12826 
+        monthsShort: 'jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.'.split('_'),
12827 
+        monthsParseExact: true,
12828 
+        weekdays: 'nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota'.split('_'),
12829 
+        weekdaysShort: 'ned._pon._uto._sre._čet._pet._sub.'.split('_'),
12830 
+        weekdaysMin: 'ne_po_ut_sr_če_pe_su'.split('_'),
12831 
+        weekdaysParseExact : true,
12832 
+        longDateFormat: {
12833 
+            LT: 'H:mm',
12834 
+            LTS : 'H:mm:ss',
12835 
+            L: 'DD.MM.YYYY',
12836 
+            LL: 'D. MMMM YYYY',
12837 
+            LLL: 'D. MMMM YYYY H:mm',
12838 
+            LLLL: 'dddd, D. MMMM YYYY H:mm'
12839 
+        },
12840 
+        calendar: {
12841 
+            sameDay: '[danas u] LT',
12842 
+            nextDay: '[sutra u] LT',
12843 
+            nextWeek: function () {
12844 
+                switch (this.day()) {
12845 
+                    case 0:
12846 
+                        return '[u] [nedelju] [u] LT';
12847 
+                    case 3:
12848 
+                        return '[u] [sredu] [u] LT';
12849 
+                    case 6:
12850 
+                        return '[u] [subotu] [u] LT';
12851 
+                    case 1:
12852 
+                    case 2:
12853 
+                    case 4:
12854 
+                    case 5:
12855 
+                        return '[u] dddd [u] LT';
12856 
+                }
12857 
+            },
12858 
+            lastDay  : '[juče u] LT',
12859 
+            lastWeek : function () {
12860 
+                var lastWeekDays = [
12861 
+                    '[prošle] [nedelje] [u] LT',
12862 
+                    '[prošlog] [ponedeljka] [u] LT',
12863 
+                    '[prošlog] [utorka] [u] LT',
12864 
+                    '[prošle] [srede] [u] LT',
12865 
+                    '[prošlog] [četvrtka] [u] LT',
12866 
+                    '[prošlog] [petka] [u] LT',
12867 
+                    '[prošle] [subote] [u] LT'
12868 
+                ];
12869 
+                return lastWeekDays[this.day()];
12870 
+            },
12871 
+            sameElse : 'L'
12872 
+        },
12873 
+        relativeTime : {
12874 
+            future : 'za %s',
12875 
+            past   : 'pre %s',
12876 
+            s      : 'nekoliko sekundi',
12877 
+            ss     : translator$2.translate,
12878 
+            m      : translator$2.translate,
12879 
+            mm     : translator$2.translate,
12880 
+            h      : translator$2.translate,
12881 
+            hh     : translator$2.translate,
12882 
+            d      : 'dan',
12883 
+            dd     : translator$2.translate,
12884 
+            M      : 'mesec',
12885 
+            MM     : translator$2.translate,
12886 
+            y      : 'godinu',
12887 
+            yy     : translator$2.translate
12888 
+        },
12889 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
12890 
+        ordinal : '%d.',
12891 
+        week : {
12892 
+            dow : 1, // Monday is the first day of the week.
12893 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
12894 
+        }
12895 
+    });
12896 
+
12897 
+    //! moment.js locale configuration
12898 
+
12899 
+    hooks.defineLocale('ss', {
12900 
+        months : "Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split('_'),
12901 
+        monthsShort : 'Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo'.split('_'),
12902 
+        weekdays : 'Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo'.split('_'),
12903 
+        weekdaysShort : 'Lis_Umb_Lsb_Les_Lsi_Lsh_Umg'.split('_'),
12904 
+        weekdaysMin : 'Li_Us_Lb_Lt_Ls_Lh_Ug'.split('_'),
12905 
+        weekdaysParseExact : true,
12906 
+        longDateFormat : {
12907 
+            LT : 'h:mm A',
12908 
+            LTS : 'h:mm:ss A',
12909 
+            L : 'DD/MM/YYYY',
12910 
+            LL : 'D MMMM YYYY',
12911 
+            LLL : 'D MMMM YYYY h:mm A',
12912 
+            LLLL : 'dddd, D MMMM YYYY h:mm A'
12913 
+        },
12914 
+        calendar : {
12915 
+            sameDay : '[Namuhla nga] LT',
12916 
+            nextDay : '[Kusasa nga] LT',
12917 
+            nextWeek : 'dddd [nga] LT',
12918 
+            lastDay : '[Itolo nga] LT',
12919 
+            lastWeek : 'dddd [leliphelile] [nga] LT',
12920 
+            sameElse : 'L'
12921 
+        },
12922 
+        relativeTime : {
12923 
+            future : 'nga %s',
12924 
+            past : 'wenteka nga %s',
12925 
+            s : 'emizuzwana lomcane',
12926 
+            ss : '%d mzuzwana',
12927 
+            m : 'umzuzu',
12928 
+            mm : '%d emizuzu',
12929 
+            h : 'lihora',
12930 
+            hh : '%d emahora',
12931 
+            d : 'lilanga',
12932 
+            dd : '%d emalanga',
12933 
+            M : 'inyanga',
12934 
+            MM : '%d tinyanga',
12935 
+            y : 'umnyaka',
12936 
+            yy : '%d iminyaka'
12937 
+        },
12938 
+        meridiemParse: /ekuseni|emini|entsambama|ebusuku/,
12939 
+        meridiem : function (hours, minutes, isLower) {
12940 
+            if (hours < 11) {
12941 
+                return 'ekuseni';
12942 
+            } else if (hours < 15) {
12943 
+                return 'emini';
12944 
+            } else if (hours < 19) {
12945 
+                return 'entsambama';
12946 
+            } else {
12947 
+                return 'ebusuku';
12948 
+            }
12949 
+        },
12950 
+        meridiemHour : function (hour, meridiem) {
12951 
+            if (hour === 12) {
12952 
+                hour = 0;
12953 
+            }
12954 
+            if (meridiem === 'ekuseni') {
12955 
+                return hour;
12956 
+            } else if (meridiem === 'emini') {
12957 
+                return hour >= 11 ? hour : hour + 12;
12958 
+            } else if (meridiem === 'entsambama' || meridiem === 'ebusuku') {
12959 
+                if (hour === 0) {
12960 
+                    return 0;
12961 
+                }
12962 
+                return hour + 12;
12963 
+            }
12964 
+        },
12965 
+        dayOfMonthOrdinalParse: /\d{1,2}/,
12966 
+        ordinal : '%d',
12967 
+        week : {
12968 
+            dow : 1, // Monday is the first day of the week.
12969 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
12970 
+        }
12971 
+    });
12972 
+
12973 
+    //! moment.js locale configuration
12974 
+
12975 
+    hooks.defineLocale('sv', {
12976 
+        months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
12977 
+        monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
12978 
+        weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
12979 
+        weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
12980 
+        weekdaysMin : 'sö_må_ti_on_to_fr_lö'.split('_'),
12981 
+        longDateFormat : {
12982 
+            LT : 'HH:mm',
12983 
+            LTS : 'HH:mm:ss',
12984 
+            L : 'YYYY-MM-DD',
12985 
+            LL : 'D MMMM YYYY',
12986 
+            LLL : 'D MMMM YYYY [kl.] HH:mm',
12987 
+            LLLL : 'dddd D MMMM YYYY [kl.] HH:mm',
12988 
+            lll : 'D MMM YYYY HH:mm',
12989 
+            llll : 'ddd D MMM YYYY HH:mm'
12990 
+        },
12991 
+        calendar : {
12992 
+            sameDay: '[Idag] LT',
12993 
+            nextDay: '[Imorgon] LT',
12994 
+            lastDay: '[Igår] LT',
12995 
+            nextWeek: '[På] dddd LT',
12996 
+            lastWeek: '[I] dddd[s] LT',
12997 
+            sameElse: 'L'
12998 
+        },
12999 
+        relativeTime : {
13000 
+            future : 'om %s',
13001 
+            past : 'för %s sedan',
13002 
+            s : 'några sekunder',
13003 
+            ss : '%d sekunder',
13004 
+            m : 'en minut',
13005 
+            mm : '%d minuter',
13006 
+            h : 'en timme',
13007 
+            hh : '%d timmar',
13008 
+            d : 'en dag',
13009 
+            dd : '%d dagar',
13010 
+            M : 'en månad',
13011 
+            MM : '%d månader',
13012 
+            y : 'ett år',
13013 
+            yy : '%d år'
13014 
+        },
13015 
+        dayOfMonthOrdinalParse: /\d{1,2}(e|a)/,
13016 
+        ordinal : function (number) {
13017 
+            var b = number % 10,
13018 
+                output = (~~(number % 100 / 10) === 1) ? 'e' :
13019 
+                (b === 1) ? 'a' :
13020 
+                (b === 2) ? 'a' :
13021 
+                (b === 3) ? 'e' : 'e';
13022 
+            return number + output;
13023 
+        },
13024 
+        week : {
13025 
+            dow : 1, // Monday is the first day of the week.
13026 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
13027 
+        }
13028 
+    });
13029 
+
13030 
+    //! moment.js locale configuration
13031 
+
13032 
+    hooks.defineLocale('sw', {
13033 
+        months : 'Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba'.split('_'),
13034 
+        monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des'.split('_'),
13035 
+        weekdays : 'Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi'.split('_'),
13036 
+        weekdaysShort : 'Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos'.split('_'),
13037 
+        weekdaysMin : 'J2_J3_J4_J5_Al_Ij_J1'.split('_'),
13038 
+        weekdaysParseExact : true,
13039 
+        longDateFormat : {
13040 
+            LT : 'HH:mm',
13041 
+            LTS : 'HH:mm:ss',
13042 
+            L : 'DD.MM.YYYY',
13043 
+            LL : 'D MMMM YYYY',
13044 
+            LLL : 'D MMMM YYYY HH:mm',
13045 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
13046 
+        },
13047 
+        calendar : {
13048 
+            sameDay : '[leo saa] LT',
13049 
+            nextDay : '[kesho saa] LT',
13050 
+            nextWeek : '[wiki ijayo] dddd [saat] LT',
13051 
+            lastDay : '[jana] LT',
13052 
+            lastWeek : '[wiki iliyopita] dddd [saat] LT',
13053 
+            sameElse : 'L'
13054 
+        },
13055 
+        relativeTime : {
13056 
+            future : '%s baadaye',
13057 
+            past : 'tokea %s',
13058 
+            s : 'hivi punde',
13059 
+            ss : 'sekunde %d',
13060 
+            m : 'dakika moja',
13061 
+            mm : 'dakika %d',
13062 
+            h : 'saa limoja',
13063 
+            hh : 'masaa %d',
13064 
+            d : 'siku moja',
13065 
+            dd : 'masiku %d',
13066 
+            M : 'mwezi mmoja',
13067 
+            MM : 'miezi %d',
13068 
+            y : 'mwaka mmoja',
13069 
+            yy : 'miaka %d'
13070 
+        },
13071 
+        week : {
13072 
+            dow : 1, // Monday is the first day of the week.
13073 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
13074 
+        }
13075 
+    });
13076 
+
13077 
+    //! moment.js locale configuration
13078 
+
13079 
+    var symbolMap$f = {
13080 
+        '1': '௧',
13081 
+        '2': '௨',
13082 
+        '3': '௩',
13083 
+        '4': '௪',
13084 
+        '5': '௫',
13085 
+        '6': '௬',
13086 
+        '7': '௭',
13087 
+        '8': '௮',
13088 
+        '9': '௯',
13089 
+        '0': '௦'
13090 
+    }, numberMap$e = {
13091 
+        '௧': '1',
13092 
+        '௨': '2',
13093 
+        '௩': '3',
13094 
+        '௪': '4',
13095 
+        '௫': '5',
13096 
+        '௬': '6',
13097 
+        '௭': '7',
13098 
+        '௮': '8',
13099 
+        '௯': '9',
13100 
+        '௦': '0'
13101 
+    };
13102 
+
13103 
+    hooks.defineLocale('ta', {
13104 
+        months : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
13105 
+        monthsShort : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
13106 
+        weekdays : 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split('_'),
13107 
+        weekdaysShort : 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split('_'),
13108 
+        weekdaysMin : 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
13109 
+        longDateFormat : {
13110 
+            LT : 'HH:mm',
13111 
+            LTS : 'HH:mm:ss',
13112 
+            L : 'DD/MM/YYYY',
13113 
+            LL : 'D MMMM YYYY',
13114 
+            LLL : 'D MMMM YYYY, HH:mm',
13115 
+            LLLL : 'dddd, D MMMM YYYY, HH:mm'
13116 
+        },
13117 
+        calendar : {
13118 
+            sameDay : '[இன்று] LT',
13119 
+            nextDay : '[நாளை] LT',
13120 
+            nextWeek : 'dddd, LT',
13121 
+            lastDay : '[நேற்று] LT',
13122 
+            lastWeek : '[கடந்த வாரம்] dddd, LT',
13123 
+            sameElse : 'L'
13124 
+        },
13125 
+        relativeTime : {
13126 
+            future : '%s இல்',
13127 
+            past : '%s முன்',
13128 
+            s : 'ஒரு சில விநாடிகள்',
13129 
+            ss : '%d விநாடிகள்',
13130 
+            m : 'ஒரு நிமிடம்',
13131 
+            mm : '%d நிமிடங்கள்',
13132 
+            h : 'ஒரு மணி நேரம்',
13133 
+            hh : '%d மணி நேரம்',
13134 
+            d : 'ஒரு நாள்',
13135 
+            dd : '%d நாட்கள்',
13136 
+            M : 'ஒரு மாதம்',
13137 
+            MM : '%d மாதங்கள்',
13138 
+            y : 'ஒரு வருடம்',
13139 
+            yy : '%d ஆண்டுகள்'
13140 
+        },
13141 
+        dayOfMonthOrdinalParse: /\d{1,2}வது/,
13142 
+        ordinal : function (number) {
13143 
+            return number + 'வது';
13144 
+        },
13145 
+        preparse: function (string) {
13146 
+            return string.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match) {
13147 
+                return numberMap$e[match];
13148 
+            });
13149 
+        },
13150 
+        postformat: function (string) {
13151 
+            return string.replace(/\d/g, function (match) {
13152 
+                return symbolMap$f[match];
13153 
+            });
13154 
+        },
13155 
+        // refer http://ta.wikipedia.org/s/1er1
13156 
+        meridiemParse: /யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,
13157 
+        meridiem : function (hour, minute, isLower) {
13158 
+            if (hour < 2) {
13159 
+                return ' யாமம்';
13160 
+            } else if (hour < 6) {
13161 
+                return ' வைகறை';  // வைகறை
13162 
+            } else if (hour < 10) {
13163 
+                return ' காலை'; // காலை
13164 
+            } else if (hour < 14) {
13165 
+                return ' நண்பகல்'; // நண்பகல்
13166 
+            } else if (hour < 18) {
13167 
+                return ' எற்பாடு'; // எற்பாடு
13168 
+            } else if (hour < 22) {
13169 
+                return ' மாலை'; // மாலை
13170 
+            } else {
13171 
+                return ' யாமம்';
13172 
+            }
13173 
+        },
13174 
+        meridiemHour : function (hour, meridiem) {
13175 
+            if (hour === 12) {
13176 
+                hour = 0;
13177 
+            }
13178 
+            if (meridiem === 'யாமம்') {
13179 
+                return hour < 2 ? hour : hour + 12;
13180 
+            } else if (meridiem === 'வைகறை' || meridiem === 'காலை') {
13181 
+                return hour;
13182 
+            } else if (meridiem === 'நண்பகல்') {
13183 
+                return hour >= 10 ? hour : hour + 12;
13184 
+            } else {
13185 
+                return hour + 12;
13186 
+            }
13187 
+        },
13188 
+        week : {
13189 
+            dow : 0, // Sunday is the first day of the week.
13190 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
13191 
+        }
13192 
+    });
13193 
+
13194 
+    //! moment.js locale configuration
13195 
+
13196 
+    hooks.defineLocale('te', {
13197 
+        months : 'జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జులై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్'.split('_'),
13198 
+        monthsShort : 'జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జులై_ఆగ._సెప్._అక్టో._నవ._డిసె.'.split('_'),
13199 
+        monthsParseExact : true,
13200 
+        weekdays : 'ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం'.split('_'),
13201 
+        weekdaysShort : 'ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని'.split('_'),
13202 
+        weekdaysMin : 'ఆ_సో_మం_బు_గు_శు_శ'.split('_'),
13203 
+        longDateFormat : {
13204 
+            LT : 'A h:mm',
13205 
+            LTS : 'A h:mm:ss',
13206 
+            L : 'DD/MM/YYYY',
13207 
+            LL : 'D MMMM YYYY',
13208 
+            LLL : 'D MMMM YYYY, A h:mm',
13209 
+            LLLL : 'dddd, D MMMM YYYY, A h:mm'
13210 
+        },
13211 
+        calendar : {
13212 
+            sameDay : '[నేడు] LT',
13213 
+            nextDay : '[రేపు] LT',
13214 
+            nextWeek : 'dddd, LT',
13215 
+            lastDay : '[నిన్న] LT',
13216 
+            lastWeek : '[గత] dddd, LT',
13217 
+            sameElse : 'L'
13218 
+        },
13219 
+        relativeTime : {
13220 
+            future : '%s లో',
13221 
+            past : '%s క్రితం',
13222 
+            s : 'కొన్ని క్షణాలు',
13223 
+            ss : '%d సెకన్లు',
13224 
+            m : 'ఒక నిమిషం',
13225 
+            mm : '%d నిమిషాలు',
13226 
+            h : 'ఒక గంట',
13227 
+            hh : '%d గంటలు',
13228 
+            d : 'ఒక రోజు',
13229 
+            dd : '%d రోజులు',
13230 
+            M : 'ఒక నెల',
13231 
+            MM : '%d నెలలు',
13232 
+            y : 'ఒక సంవత్సరం',
13233 
+            yy : '%d సంవత్సరాలు'
13234 
+        },
13235 
+        dayOfMonthOrdinalParse : /\d{1,2}వ/,
13236 
+        ordinal : '%dవ',
13237 
+        meridiemParse: /రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,
13238 
+        meridiemHour : function (hour, meridiem) {
13239 
+            if (hour === 12) {
13240 
+                hour = 0;
13241 
+            }
13242 
+            if (meridiem === 'రాత్రి') {
13243 
+                return hour < 4 ? hour : hour + 12;
13244 
+            } else if (meridiem === 'ఉదయం') {
13245 
+                return hour;
13246 
+            } else if (meridiem === 'మధ్యాహ్నం') {
13247 
+                return hour >= 10 ? hour : hour + 12;
13248 
+            } else if (meridiem === 'సాయంత్రం') {
13249 
+                return hour + 12;
13250 
+            }
13251 
+        },
13252 
+        meridiem : function (hour, minute, isLower) {
13253 
+            if (hour < 4) {
13254 
+                return 'రాత్రి';
13255 
+            } else if (hour < 10) {
13256 
+                return 'ఉదయం';
13257 
+            } else if (hour < 17) {
13258 
+                return 'మధ్యాహ్నం';
13259 
+            } else if (hour < 20) {
13260 
+                return 'సాయంత్రం';
13261 
+            } else {
13262 
+                return 'రాత్రి';
13263 
+            }
13264 
+        },
13265 
+        week : {
13266 
+            dow : 0, // Sunday is the first day of the week.
13267 
+            doy : 6  // The week that contains Jan 6th is the first week of the year.
13268 
+        }
13269 
+    });
13270 
+
13271 
+    //! moment.js locale configuration
13272 
+
13273 
+    hooks.defineLocale('tet', {
13274 
+        months : 'Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru'.split('_'),
13275 
+        monthsShort : 'Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez'.split('_'),
13276 
+        weekdays : 'Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu'.split('_'),
13277 
+        weekdaysShort : 'Dom_Seg_Ters_Kua_Kint_Sest_Sab'.split('_'),
13278 
+        weekdaysMin : 'Do_Seg_Te_Ku_Ki_Ses_Sa'.split('_'),
13279 
+        longDateFormat : {
13280 
+            LT : 'HH:mm',
13281 
+            LTS : 'HH:mm:ss',
13282 
+            L : 'DD/MM/YYYY',
13283 
+            LL : 'D MMMM YYYY',
13284 
+            LLL : 'D MMMM YYYY HH:mm',
13285 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
13286 
+        },
13287 
+        calendar : {
13288 
+            sameDay: '[Ohin iha] LT',
13289 
+            nextDay: '[Aban iha] LT',
13290 
+            nextWeek: 'dddd [iha] LT',
13291 
+            lastDay: '[Horiseik iha] LT',
13292 
+            lastWeek: 'dddd [semana kotuk] [iha] LT',
13293 
+            sameElse: 'L'
13294 
+        },
13295 
+        relativeTime : {
13296 
+            future : 'iha %s',
13297 
+            past : '%s liuba',
13298 
+            s : 'minutu balun',
13299 
+            ss : 'minutu %d',
13300 
+            m : 'minutu ida',
13301 
+            mm : 'minutu %d',
13302 
+            h : 'oras ida',
13303 
+            hh : 'oras %d',
13304 
+            d : 'loron ida',
13305 
+            dd : 'loron %d',
13306 
+            M : 'fulan ida',
13307 
+            MM : 'fulan %d',
13308 
+            y : 'tinan ida',
13309 
+            yy : 'tinan %d'
13310 
+        },
13311 
+        dayOfMonthOrdinalParse: /\d{1,2}(st|nd|rd|th)/,
13312 
+        ordinal : function (number) {
13313 
+            var b = number % 10,
13314 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
13315 
+                (b === 1) ? 'st' :
13316 
+                (b === 2) ? 'nd' :
13317 
+                (b === 3) ? 'rd' : 'th';
13318 
+            return number + output;
13319 
+        },
13320 
+        week : {
13321 
+            dow : 1, // Monday is the first day of the week.
13322 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
13323 
+        }
13324 
+    });
13325 
+
13326 
+    //! moment.js locale configuration
13327 
+
13328 
+    var suffixes$3 = {
13329 
+        0: '-ум',
13330 
+        1: '-ум',
13331 
+        2: '-юм',
13332 
+        3: '-юм',
13333 
+        4: '-ум',
13334 
+        5: '-ум',
13335 
+        6: '-ум',
13336 
+        7: '-ум',
13337 
+        8: '-ум',
13338 
+        9: '-ум',
13339 
+        10: '-ум',
13340 
+        12: '-ум',
13341 
+        13: '-ум',
13342 
+        20: '-ум',
13343 
+        30: '-юм',
13344 
+        40: '-ум',
13345 
+        50: '-ум',
13346 
+        60: '-ум',
13347 
+        70: '-ум',
13348 
+        80: '-ум',
13349 
+        90: '-ум',
13350 
+        100: '-ум'
13351 
+    };
13352 
+
13353 
+    hooks.defineLocale('tg', {
13354 
+        months : 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
13355 
+        monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
13356 
+        weekdays : 'якшанбе_душанбе_сешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе'.split('_'),
13357 
+        weekdaysShort : 'яшб_дшб_сшб_чшб_пшб_ҷум_шнб'.split('_'),
13358 
+        weekdaysMin : 'яш_дш_сш_чш_пш_ҷм_шб'.split('_'),
13359 
+        longDateFormat : {
13360 
+            LT : 'HH:mm',
13361 
+            LTS : 'HH:mm:ss',
13362 
+            L : 'DD/MM/YYYY',
13363 
+            LL : 'D MMMM YYYY',
13364 
+            LLL : 'D MMMM YYYY HH:mm',
13365 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
13366 
+        },
13367 
+        calendar : {
13368 
+            sameDay : '[Имрӯз соати] LT',
13369 
+            nextDay : '[Пагоҳ соати] LT',
13370 
+            lastDay : '[Дирӯз соати] LT',
13371 
+            nextWeek : 'dddd[и] [ҳафтаи оянда соати] LT',
13372 
+            lastWeek : 'dddd[и] [ҳафтаи гузашта соати] LT',
13373 
+            sameElse : 'L'
13374 
+        },
13375 
+        relativeTime : {
13376 
+            future : 'баъди %s',
13377 
+            past : '%s пеш',
13378 
+            s : 'якчанд сония',
13379 
+            m : 'як дақиқа',
13380 
+            mm : '%d дақиқа',
13381 
+            h : 'як соат',
13382 
+            hh : '%d соат',
13383 
+            d : 'як рӯз',
13384 
+            dd : '%d рӯз',
13385 
+            M : 'як моҳ',
13386 
+            MM : '%d моҳ',
13387 
+            y : 'як сол',
13388 
+            yy : '%d сол'
13389 
+        },
13390 
+        meridiemParse: /шаб|субҳ|рӯз|бегоҳ/,
13391 
+        meridiemHour: function (hour, meridiem) {
13392 
+            if (hour === 12) {
13393 
+                hour = 0;
13394 
+            }
13395 
+            if (meridiem === 'шаб') {
13396 
+                return hour < 4 ? hour : hour + 12;
13397 
+            } else if (meridiem === 'субҳ') {
13398 
+                return hour;
13399 
+            } else if (meridiem === 'рӯз') {
13400 
+                return hour >= 11 ? hour : hour + 12;
13401 
+            } else if (meridiem === 'бегоҳ') {
13402 
+                return hour + 12;
13403 
+            }
13404 
+        },
13405 
+        meridiem: function (hour, minute, isLower) {
13406 
+            if (hour < 4) {
13407 
+                return 'шаб';
13408 
+            } else if (hour < 11) {
13409 
+                return 'субҳ';
13410 
+            } else if (hour < 16) {
13411 
+                return 'рӯз';
13412 
+            } else if (hour < 19) {
13413 
+                return 'бегоҳ';
13414 
+            } else {
13415 
+                return 'шаб';
13416 
+            }
13417 
+        },
13418 
+        dayOfMonthOrdinalParse: /\d{1,2}-(ум|юм)/,
13419 
+        ordinal: function (number) {
13420 
+            var a = number % 10,
13421 
+                b = number >= 100 ? 100 : null;
13422 
+            return number + (suffixes$3[number] || suffixes$3[a] || suffixes$3[b]);
13423 
+        },
13424 
+        week : {
13425 
+            dow : 1, // Monday is the first day of the week.
13426 
+            doy : 7  // The week that contains Jan 1th is the first week of the year.
13427 
+        }
13428 
+    });
13429 
+
13430 
+    //! moment.js locale configuration
13431 
+
13432 
+    hooks.defineLocale('th', {
13433 
+        months : 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
13434 
+        monthsShort : 'ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.'.split('_'),
13435 
+        monthsParseExact: true,
13436 
+        weekdays : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
13437 
+        weekdaysShort : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
13438 
+        weekdaysMin : 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
13439 
+        weekdaysParseExact : true,
13440 
+        longDateFormat : {
13441 
+            LT : 'H:mm',
13442 
+            LTS : 'H:mm:ss',
13443 
+            L : 'DD/MM/YYYY',
13444 
+            LL : 'D MMMM YYYY',
13445 
+            LLL : 'D MMMM YYYY เวลา H:mm',
13446 
+            LLLL : 'วันddddที่ D MMMM YYYY เวลา H:mm'
13447 
+        },
13448 
+        meridiemParse: /ก่อนเที่ยง|หลังเที่ยง/,
13449 
+        isPM: function (input) {
13450 
+            return input === 'หลังเที่ยง';
13451 
+        },
13452 
+        meridiem : function (hour, minute, isLower) {
13453 
+            if (hour < 12) {
13454 
+                return 'ก่อนเที่ยง';
13455 
+            } else {
13456 
+                return 'หลังเที่ยง';
13457 
+            }
13458 
+        },
13459 
+        calendar : {
13460 
+            sameDay : '[วันนี้ เวลา] LT',
13461 
+            nextDay : '[พรุ่งนี้ เวลา] LT',
13462 
+            nextWeek : 'dddd[หน้า เวลา] LT',
13463 
+            lastDay : '[เมื่อวานนี้ เวลา] LT',
13464 
+            lastWeek : '[วัน]dddd[ที่แล้ว เวลา] LT',
13465 
+            sameElse : 'L'
13466 
+        },
13467 
+        relativeTime : {
13468 
+            future : 'อีก %s',
13469 
+            past : '%sที่แล้ว',
13470 
+            s : 'ไม่กี่วินาที',
13471 
+            ss : '%d วินาที',
13472 
+            m : '1 นาที',
13473 
+            mm : '%d นาที',
13474 
+            h : '1 ชั่วโมง',
13475 
+            hh : '%d ชั่วโมง',
13476 
+            d : '1 วัน',
13477 
+            dd : '%d วัน',
13478 
+            M : '1 เดือน',
13479 
+            MM : '%d เดือน',
13480 
+            y : '1 ปี',
13481 
+            yy : '%d ปี'
13482 
+        }
13483 
+    });
13484 
+
13485 
+    //! moment.js locale configuration
13486 
+
13487 
+    hooks.defineLocale('tl-ph', {
13488 
+        months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
13489 
+        monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
13490 
+        weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
13491 
+        weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
13492 
+        weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
13493 
+        longDateFormat : {
13494 
+            LT : 'HH:mm',
13495 
+            LTS : 'HH:mm:ss',
13496 
+            L : 'MM/D/YYYY',
13497 
+            LL : 'MMMM D, YYYY',
13498 
+            LLL : 'MMMM D, YYYY HH:mm',
13499 
+            LLLL : 'dddd, MMMM DD, YYYY HH:mm'
13500 
+        },
13501 
+        calendar : {
13502 
+            sameDay: 'LT [ngayong araw]',
13503 
+            nextDay: '[Bukas ng] LT',
13504 
+            nextWeek: 'LT [sa susunod na] dddd',
13505 
+            lastDay: 'LT [kahapon]',
13506 
+            lastWeek: 'LT [noong nakaraang] dddd',
13507 
+            sameElse: 'L'
13508 
+        },
13509 
+        relativeTime : {
13510 
+            future : 'sa loob ng %s',
13511 
+            past : '%s ang nakalipas',
13512 
+            s : 'ilang segundo',
13513 
+            ss : '%d segundo',
13514 
+            m : 'isang minuto',
13515 
+            mm : '%d minuto',
13516 
+            h : 'isang oras',
13517 
+            hh : '%d oras',
13518 
+            d : 'isang araw',
13519 
+            dd : '%d araw',
13520 
+            M : 'isang buwan',
13521 
+            MM : '%d buwan',
13522 
+            y : 'isang taon',
13523 
+            yy : '%d taon'
13524 
+        },
13525 
+        dayOfMonthOrdinalParse: /\d{1,2}/,
13526 
+        ordinal : function (number) {
13527 
+            return number;
13528 
+        },
13529 
+        week : {
13530 
+            dow : 1, // Monday is the first day of the week.
13531 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
13532 
+        }
13533 
+    });
13534 
+
13535 
+    //! moment.js locale configuration
13536 
+
13537 
+    var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');
13538 
+
13539 
+    function translateFuture(output) {
13540 
+        var time = output;
13541 
+        time = (output.indexOf('jaj') !== -1) ?
13542 
+        time.slice(0, -3) + 'leS' :
13543 
+        (output.indexOf('jar') !== -1) ?
13544 
+        time.slice(0, -3) + 'waQ' :
13545 
+        (output.indexOf('DIS') !== -1) ?
13546 
+        time.slice(0, -3) + 'nem' :
13547 
+        time + ' pIq';
13548 
+        return time;
13549 
+    }
13550 
+
13551 
+    function translatePast(output) {
13552 
+        var time = output;
13553 
+        time = (output.indexOf('jaj') !== -1) ?
13554 
+        time.slice(0, -3) + 'Hu’' :
13555 
+        (output.indexOf('jar') !== -1) ?
13556 
+        time.slice(0, -3) + 'wen' :
13557 
+        (output.indexOf('DIS') !== -1) ?
13558 
+        time.slice(0, -3) + 'ben' :
13559 
+        time + ' ret';
13560 
+        return time;
13561 
+    }
13562 
+
13563 
+    function translate$a(number, withoutSuffix, string, isFuture) {
13564 
+        var numberNoun = numberAsNoun(number);
13565 
+        switch (string) {
13566 
+            case 'ss':
13567 
+                return numberNoun + ' lup';
13568 
+            case 'mm':
13569 
+                return numberNoun + ' tup';
13570 
+            case 'hh':
13571 
+                return numberNoun + ' rep';
13572 
+            case 'dd':
13573 
+                return numberNoun + ' jaj';
13574 
+            case 'MM':
13575 
+                return numberNoun + ' jar';
13576 
+            case 'yy':
13577 
+                return numberNoun + ' DIS';
13578 
+        }
13579 
+    }
13580 
+
13581 
+    function numberAsNoun(number) {
13582 
+        var hundred = Math.floor((number % 1000) / 100),
13583 
+        ten = Math.floor((number % 100) / 10),
13584 
+        one = number % 10,
13585 
+        word = '';
13586 
+        if (hundred > 0) {
13587 
+            word += numbersNouns[hundred] + 'vatlh';
13588 
+        }
13589 
+        if (ten > 0) {
13590 
+            word += ((word !== '') ? ' ' : '') + numbersNouns[ten] + 'maH';
13591 
+        }
13592 
+        if (one > 0) {
13593 
+            word += ((word !== '') ? ' ' : '') + numbersNouns[one];
13594 
+        }
13595 
+        return (word === '') ? 'pagh' : word;
13596 
+    }
13597 
+
13598 
+    hooks.defineLocale('tlh', {
13599 
+        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('_'),
13600 
+        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('_'),
13601 
+        monthsParseExact : true,
13602 
+        weekdays : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
13603 
+        weekdaysShort : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
13604 
+        weekdaysMin : 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),
13605 
+        longDateFormat : {
13606 
+            LT : 'HH:mm',
13607 
+            LTS : 'HH:mm:ss',
13608 
+            L : 'DD.MM.YYYY',
13609 
+            LL : 'D MMMM YYYY',
13610 
+            LLL : 'D MMMM YYYY HH:mm',
13611 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
13612 
+        },
13613 
+        calendar : {
13614 
+            sameDay: '[DaHjaj] LT',
13615 
+            nextDay: '[wa’leS] LT',
13616 
+            nextWeek: 'LLL',
13617 
+            lastDay: '[wa’Hu’] LT',
13618 
+            lastWeek: 'LLL',
13619 
+            sameElse: 'L'
13620 
+        },
13621 
+        relativeTime : {
13622 
+            future : translateFuture,
13623 
+            past : translatePast,
13624 
+            s : 'puS lup',
13625 
+            ss : translate$a,
13626 
+            m : 'wa’ tup',
13627 
+            mm : translate$a,
13628 
+            h : 'wa’ rep',
13629 
+            hh : translate$a,
13630 
+            d : 'wa’ jaj',
13631 
+            dd : translate$a,
13632 
+            M : 'wa’ jar',
13633 
+            MM : translate$a,
13634 
+            y : 'wa’ DIS',
13635 
+            yy : translate$a
13636 
+        },
13637 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
13638 
+        ordinal : '%d.',
13639 
+        week : {
13640 
+            dow : 1, // Monday is the first day of the week.
13641 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
13642 
+        }
13643 
+    });
13644 
+
13645 
+    var suffixes$4 = {
13646 
+        1: '\'inci',
13647 
+        5: '\'inci',
13648 
+        8: '\'inci',
13649 
+        70: '\'inci',
13650 
+        80: '\'inci',
13651 
+        2: '\'nci',
13652 
+        7: '\'nci',
13653 
+        20: '\'nci',
13654 
+        50: '\'nci',
13655 
+        3: '\'üncü',
13656 
+        4: '\'üncü',
13657 
+        100: '\'üncü',
13658 
+        6: '\'ncı',
13659 
+        9: '\'uncu',
13660 
+        10: '\'uncu',
13661 
+        30: '\'uncu',
13662 
+        60: '\'ıncı',
13663 
+        90: '\'ıncı'
13664 
+    };
13665 
+
13666 
+    hooks.defineLocale('tr', {
13667 
+        months : 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
13668 
+        monthsShort : 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
13669 
+        weekdays : 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
13670 
+        weekdaysShort : 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
13671 
+        weekdaysMin : 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
13672 
+        longDateFormat : {
13673 
+            LT : 'HH:mm',
13674 
+            LTS : 'HH:mm:ss',
13675 
+            L : 'DD.MM.YYYY',
13676 
+            LL : 'D MMMM YYYY',
13677 
+            LLL : 'D MMMM YYYY HH:mm',
13678 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
13679 
+        },
13680 
+        calendar : {
13681 
+            sameDay : '[bugün saat] LT',
13682 
+            nextDay : '[yarın saat] LT',
13683 
+            nextWeek : '[gelecek] dddd [saat] LT',
13684 
+            lastDay : '[dün] LT',
13685 
+            lastWeek : '[geçen] dddd [saat] LT',
13686 
+            sameElse : 'L'
13687 
+        },
13688 
+        relativeTime : {
13689 
+            future : '%s sonra',
13690 
+            past : '%s önce',
13691 
+            s : 'birkaç saniye',
13692 
+            ss : '%d saniye',
13693 
+            m : 'bir dakika',
13694 
+            mm : '%d dakika',
13695 
+            h : 'bir saat',
13696 
+            hh : '%d saat',
13697 
+            d : 'bir gün',
13698 
+            dd : '%d gün',
13699 
+            M : 'bir ay',
13700 
+            MM : '%d ay',
13701 
+            y : 'bir yıl',
13702 
+            yy : '%d yıl'
13703 
+        },
13704 
+        ordinal: function (number, period) {
13705 
+            switch (period) {
13706 
+                case 'd':
13707 
+                case 'D':
13708 
+                case 'Do':
13709 
+                case 'DD':
13710 
+                    return number;
13711 
+                default:
13712 
+                    if (number === 0) {  // special case for zero
13713 
+                        return number + '\'ıncı';
13714 
+                    }
13715 
+                    var a = number % 10,
13716 
+                        b = number % 100 - a,
13717 
+                        c = number >= 100 ? 100 : null;
13718 
+                    return number + (suffixes$4[a] || suffixes$4[b] || suffixes$4[c]);
13719 
+            }
13720 
+        },
13721 
+        week : {
13722 
+            dow : 1, // Monday is the first day of the week.
13723 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
13724 
+        }
13725 
+    });
13726 
+
13727 
+    //! moment.js locale configuration
13728 
+
13729 
+    // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.
13730 
+    // This is currently too difficult (maybe even impossible) to add.
13731 
+    hooks.defineLocale('tzl', {
13732 
+        months : 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split('_'),
13733 
+        monthsShort : 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),
13734 
+        weekdays : 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),
13735 
+        weekdaysShort : 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),
13736 
+        weekdaysMin : 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),
13737 
+        longDateFormat : {
13738 
+            LT : 'HH.mm',
13739 
+            LTS : 'HH.mm.ss',
13740 
+            L : 'DD.MM.YYYY',
13741 
+            LL : 'D. MMMM [dallas] YYYY',
13742 
+            LLL : 'D. MMMM [dallas] YYYY HH.mm',
13743 
+            LLLL : 'dddd, [li] D. MMMM [dallas] YYYY HH.mm'
13744 
+        },
13745 
+        meridiemParse: /d\'o|d\'a/i,
13746 
+        isPM : function (input) {
13747 
+            return 'd\'o' === input.toLowerCase();
13748 
+        },
13749 
+        meridiem : function (hours, minutes, isLower) {
13750 
+            if (hours > 11) {
13751 
+                return isLower ? 'd\'o' : 'D\'O';
13752 
+            } else {
13753 
+                return isLower ? 'd\'a' : 'D\'A';
13754 
+            }
13755 
+        },
13756 
+        calendar : {
13757 
+            sameDay : '[oxhi à] LT',
13758 
+            nextDay : '[demà à] LT',
13759 
+            nextWeek : 'dddd [à] LT',
13760 
+            lastDay : '[ieiri à] LT',
13761 
+            lastWeek : '[sür el] dddd [lasteu à] LT',
13762 
+            sameElse : 'L'
13763 
+        },
13764 
+        relativeTime : {
13765 
+            future : 'osprei %s',
13766 
+            past : 'ja%s',
13767 
+            s : processRelativeTime$7,
13768 
+            ss : processRelativeTime$7,
13769 
+            m : processRelativeTime$7,
13770 
+            mm : processRelativeTime$7,
13771 
+            h : processRelativeTime$7,
13772 
+            hh : processRelativeTime$7,
13773 
+            d : processRelativeTime$7,
13774 
+            dd : processRelativeTime$7,
13775 
+            M : processRelativeTime$7,
13776 
+            MM : processRelativeTime$7,
13777 
+            y : processRelativeTime$7,
13778 
+            yy : processRelativeTime$7
13779 
+        },
13780 
+        dayOfMonthOrdinalParse: /\d{1,2}\./,
13781 
+        ordinal : '%d.',
13782 
+        week : {
13783 
+            dow : 1, // Monday is the first day of the week.
13784 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
13785 
+        }
13786 
+    });
13787 
+
13788 
+    function processRelativeTime$7(number, withoutSuffix, key, isFuture) {
13789 
+        var format = {
13790 
+            's': ['viensas secunds', '\'iensas secunds'],
13791 
+            'ss': [number + ' secunds', '' + number + ' secunds'],
13792 
+            'm': ['\'n míut', '\'iens míut'],
13793 
+            'mm': [number + ' míuts', '' + number + ' míuts'],
13794 
+            'h': ['\'n þora', '\'iensa þora'],
13795 
+            'hh': [number + ' þoras', '' + number + ' þoras'],
13796 
+            'd': ['\'n ziua', '\'iensa ziua'],
13797 
+            'dd': [number + ' ziuas', '' + number + ' ziuas'],
13798 
+            'M': ['\'n mes', '\'iens mes'],
13799 
+            'MM': [number + ' mesen', '' + number + ' mesen'],
13800 
+            'y': ['\'n ar', '\'iens ar'],
13801 
+            'yy': [number + ' ars', '' + number + ' ars']
13802 
+        };
13803 
+        return isFuture ? format[key][0] : (withoutSuffix ? format[key][0] : format[key][1]);
13804 
+    }
13805 
+
13806 
+    //! moment.js locale configuration
13807 
+
13808 
+    hooks.defineLocale('tzm-latn', {
13809 
+        months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
13810 
+        monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
13811 
+        weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
13812 
+        weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
13813 
+        weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
13814 
+        longDateFormat : {
13815 
+            LT : 'HH:mm',
13816 
+            LTS : 'HH:mm:ss',
13817 
+            L : 'DD/MM/YYYY',
13818 
+            LL : 'D MMMM YYYY',
13819 
+            LLL : 'D MMMM YYYY HH:mm',
13820 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
13821 
+        },
13822 
+        calendar : {
13823 
+            sameDay: '[asdkh g] LT',
13824 
+            nextDay: '[aska g] LT',
13825 
+            nextWeek: 'dddd [g] LT',
13826 
+            lastDay: '[assant g] LT',
13827 
+            lastWeek: 'dddd [g] LT',
13828 
+            sameElse: 'L'
13829 
+        },
13830 
+        relativeTime : {
13831 
+            future : 'dadkh s yan %s',
13832 
+            past : 'yan %s',
13833 
+            s : 'imik',
13834 
+            ss : '%d imik',
13835 
+            m : 'minuḍ',
13836 
+            mm : '%d minuḍ',
13837 
+            h : 'saɛa',
13838 
+            hh : '%d tassaɛin',
13839 
+            d : 'ass',
13840 
+            dd : '%d ossan',
13841 
+            M : 'ayowr',
13842 
+            MM : '%d iyyirn',
13843 
+            y : 'asgas',
13844 
+            yy : '%d isgasn'
13845 
+        },
13846 
+        week : {
13847 
+            dow : 6, // Saturday is the first day of the week.
13848 
+            doy : 12  // The week that contains Jan 12th is the first week of the year.
13849 
+        }
13850 
+    });
13851 
+
13852 
+    //! moment.js locale configuration
13853 
+
13854 
+    hooks.defineLocale('tzm', {
13855 
+        months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
13856 
+        monthsShort : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
13857 
+        weekdays : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
13858 
+        weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
13859 
+        weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
13860 
+        longDateFormat : {
13861 
+            LT : 'HH:mm',
13862 
+            LTS: 'HH:mm:ss',
13863 
+            L : 'DD/MM/YYYY',
13864 
+            LL : 'D MMMM YYYY',
13865 
+            LLL : 'D MMMM YYYY HH:mm',
13866 
+            LLLL : 'dddd D MMMM YYYY HH:mm'
13867 
+        },
13868 
+        calendar : {
13869 
+            sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
13870 
+            nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
13871 
+            nextWeek: 'dddd [ⴴ] LT',
13872 
+            lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
13873 
+            lastWeek: 'dddd [ⴴ] LT',
13874 
+            sameElse: 'L'
13875 
+        },
13876 
+        relativeTime : {
13877 
+            future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
13878 
+            past : 'ⵢⴰⵏ %s',
13879 
+            s : 'ⵉⵎⵉⴽ',
13880 
+            ss : '%d ⵉⵎⵉⴽ',
13881 
+            m : 'ⵎⵉⵏⵓⴺ',
13882 
+            mm : '%d ⵎⵉⵏⵓⴺ',
13883 
+            h : 'ⵙⴰⵄⴰ',
13884 
+            hh : '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
13885 
+            d : 'ⴰⵙⵙ',
13886 
+            dd : '%d oⵙⵙⴰⵏ',
13887 
+            M : 'ⴰⵢoⵓⵔ',
13888 
+            MM : '%d ⵉⵢⵢⵉⵔⵏ',
13889 
+            y : 'ⴰⵙⴳⴰⵙ',
13890 
+            yy : '%d ⵉⵙⴳⴰⵙⵏ'
13891 
+        },
13892 
+        week : {
13893 
+            dow : 6, // Saturday is the first day of the week.
13894 
+            doy : 12  // The week that contains Jan 12th is the first week of the year.
13895 
+        }
13896 
+    });
13897 
+
13898 
+    //! moment.js language configuration
13899 
+
13900 
+    hooks.defineLocale('ug-cn', {
13901 
+        months: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
13902 
+            '_'
13903 
+        ),
13904 
+        monthsShort: 'يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر'.split(
13905 
+            '_'
13906 
+        ),
13907 
+        weekdays: 'يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە'.split(
13908 
+            '_'
13909 
+        ),
13910 
+        weekdaysShort: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
13911 
+        weekdaysMin: 'يە_دۈ_سە_چا_پە_جۈ_شە'.split('_'),
13912 
+        longDateFormat: {
13913 
+            LT: 'HH:mm',
13914 
+            LTS: 'HH:mm:ss',
13915 
+            L: 'YYYY-MM-DD',
13916 
+            LL: 'YYYY-يىلىM-ئاينىڭD-كۈنى',
13917 
+            LLL: 'YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm',
13918 
+            LLLL: 'dddd، YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm'
13919 
+        },
13920 
+        meridiemParse: /يېرىم كېچە|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن كېيىن|كەچ/,
13921 
+        meridiemHour: function (hour, meridiem) {
13922 
+            if (hour === 12) {
13923 
+                hour = 0;
13924 
+            }
13925 
+            if (
13926 
+                meridiem === 'يېرىم كېچە' ||
13927 
+                meridiem === 'سەھەر' ||
13928 
+                meridiem === 'چۈشتىن بۇرۇن'
13929 
+            ) {
13930 
+                return hour;
13931 
+            } else if (meridiem === 'چۈشتىن كېيىن' || meridiem === 'كەچ') {
13932 
+                return hour + 12;
13933 
+            } else {
13934 
+                return hour >= 11 ? hour : hour + 12;
13935 
+            }
13936 
+        },
13937 
+        meridiem: function (hour, minute, isLower) {
13938 
+            var hm = hour * 100 + minute;
13939 
+            if (hm < 600) {
13940 
+                return 'يېرىم كېچە';
13941 
+            } else if (hm < 900) {
13942 
+                return 'سەھەر';
13943 
+            } else if (hm < 1130) {
13944 
+                return 'چۈشتىن بۇرۇن';
13945 
+            } else if (hm < 1230) {
13946 
+                return 'چۈش';
13947 
+            } else if (hm < 1800) {
13948 
+                return 'چۈشتىن كېيىن';
13949 
+            } else {
13950 
+                return 'كەچ';
13951 
+            }
13952 
+        },
13953 
+        calendar: {
13954 
+            sameDay: '[بۈگۈن سائەت] LT',
13955 
+            nextDay: '[ئەتە سائەت] LT',
13956 
+            nextWeek: '[كېلەركى] dddd [سائەت] LT',
13957 
+            lastDay: '[تۆنۈگۈن] LT',
13958 
+            lastWeek: '[ئالدىنقى] dddd [سائەت] LT',
13959 
+            sameElse: 'L'
13960 
+        },
13961 
+        relativeTime: {
13962 
+            future: '%s كېيىن',
13963 
+            past: '%s بۇرۇن',
13964 
+            s: 'نەچچە سېكونت',
13965 
+            ss: '%d سېكونت',
13966 
+            m: 'بىر مىنۇت',
13967 
+            mm: '%d مىنۇت',
13968 
+            h: 'بىر سائەت',
13969 
+            hh: '%d سائەت',
13970 
+            d: 'بىر كۈن',
13971 
+            dd: '%d كۈن',
13972 
+            M: 'بىر ئاي',
13973 
+            MM: '%d ئاي',
13974 
+            y: 'بىر يىل',
13975 
+            yy: '%d يىل'
13976 
+        },
13977 
+
13978 
+        dayOfMonthOrdinalParse: /\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,
13979 
+        ordinal: function (number, period) {
13980 
+            switch (period) {
13981 
+                case 'd':
13982 
+                case 'D':
13983 
+                case 'DDD':
13984 
+                    return number + '-كۈنى';
13985 
+                case 'w':
13986 
+                case 'W':
13987 
+                    return number + '-ھەپتە';
13988 
+                default:
13989 
+                    return number;
13990 
+            }
13991 
+        },
13992 
+        preparse: function (string) {
13993 
+            return string.replace(/،/g, ',');
13994 
+        },
13995 
+        postformat: function (string) {
13996 
+            return string.replace(/,/g, '،');
13997 
+        },
13998 
+        week: {
13999 
+            // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
14000 
+            dow: 1, // Monday is the first day of the week.
14001 
+            doy: 7 // The week that contains Jan 1st is the first week of the year.
14002 
+        }
14003 
+    });
14004 
+
14005 
+    //! moment.js locale configuration
14006 
+
14007 
+    function plural$6(word, num) {
14008 
+        var forms = word.split('_');
14009 
+        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]);
14010 
+    }
14011 
+    function relativeTimeWithPlural$4(number, withoutSuffix, key) {
14012 
+        var format = {
14013 
+            'ss': withoutSuffix ? 'секунда_секунди_секунд' : 'секунду_секунди_секунд',
14014 
+            'mm': withoutSuffix ? 'хвилина_хвилини_хвилин' : 'хвилину_хвилини_хвилин',
14015 
+            'hh': withoutSuffix ? 'година_години_годин' : 'годину_години_годин',
14016 
+            'dd': 'день_дні_днів',
14017 
+            'MM': 'місяць_місяці_місяців',
14018 
+            'yy': 'рік_роки_років'
14019 
+        };
14020 
+        if (key === 'm') {
14021 
+            return withoutSuffix ? 'хвилина' : 'хвилину';
14022 
+        }
14023 
+        else if (key === 'h') {
14024 
+            return withoutSuffix ? 'година' : 'годину';
14025 
+        }
14026 
+        else {
14027 
+            return number + ' ' + plural$6(format[key], +number);
14028 
+        }
14029 
+    }
14030 
+    function weekdaysCaseReplace(m, format) {
14031 
+        var weekdays = {
14032 
+            'nominative': 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
14033 
+            'accusative': 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split('_'),
14034 
+            'genitive': 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split('_')
14035 
+        };
14036 
+
14037 
+        if (m === true) {
14038 
+            return weekdays['nominative'].slice(1, 7).concat(weekdays['nominative'].slice(0, 1));
14039 
+        }
14040 
+        if (!m) {
14041 
+            return weekdays['nominative'];
14042 
+        }
14043 
+
14044 
+        var nounCase = (/(\[[ВвУу]\]) ?dddd/).test(format) ?
14045 
+            'accusative' :
14046 
+            ((/\[?(?:минулої|наступної)? ?\] ?dddd/).test(format) ?
14047 
+                'genitive' :
14048 
+                'nominative');
14049 
+        return weekdays[nounCase][m.day()];
14050 
+    }
14051 
+    function processHoursFunction(str) {
14052 
+        return function () {
14053 
+            return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
14054 
+        };
14055 
+    }
14056 
+
14057 
+    hooks.defineLocale('uk', {
14058 
+        months : {
14059 
+            'format': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_'),
14060 
+            'standalone': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_')
14061 
+        },
14062 
+        monthsShort : 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
14063 
+        weekdays : weekdaysCaseReplace,
14064 
+        weekdaysShort : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
14065 
+        weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
14066 
+        longDateFormat : {
14067 
+            LT : 'HH:mm',
14068 
+            LTS : 'HH:mm:ss',
14069 
+            L : 'DD.MM.YYYY',
14070 
+            LL : 'D MMMM YYYY р.',
14071 
+            LLL : 'D MMMM YYYY р., HH:mm',
14072 
+            LLLL : 'dddd, D MMMM YYYY р., HH:mm'
14073 
+        },
14074 
+        calendar : {
14075 
+            sameDay: processHoursFunction('[Сьогодні '),
14076 
+            nextDay: processHoursFunction('[Завтра '),
14077 
+            lastDay: processHoursFunction('[Вчора '),
14078 
+            nextWeek: processHoursFunction('[У] dddd ['),
14079 
+            lastWeek: function () {
14080 
+                switch (this.day()) {
14081 
+                    case 0:
14082 
+                    case 3:
14083 
+                    case 5:
14084 
+                    case 6:
14085 
+                        return processHoursFunction('[Минулої] dddd [').call(this);
14086 
+                    case 1:
14087 
+                    case 2:
14088 
+                    case 4:
14089 
+                        return processHoursFunction('[Минулого] dddd [').call(this);
14090 
+                }
14091 
+            },
14092 
+            sameElse: 'L'
14093 
+        },
14094 
+        relativeTime : {
14095 
+            future : 'за %s',
14096 
+            past : '%s тому',
14097 
+            s : 'декілька секунд',
14098 
+            ss : relativeTimeWithPlural$4,
14099 
+            m : relativeTimeWithPlural$4,
14100 
+            mm : relativeTimeWithPlural$4,
14101 
+            h : 'годину',
14102 
+            hh : relativeTimeWithPlural$4,
14103 
+            d : 'день',
14104 
+            dd : relativeTimeWithPlural$4,
14105 
+            M : 'місяць',
14106 
+            MM : relativeTimeWithPlural$4,
14107 
+            y : 'рік',
14108 
+            yy : relativeTimeWithPlural$4
14109 
+        },
14110 
+        // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason
14111 
+        meridiemParse: /ночі|ранку|дня|вечора/,
14112 
+        isPM: function (input) {
14113 
+            return /^(дня|вечора)$/.test(input);
14114 
+        },
14115 
+        meridiem : function (hour, minute, isLower) {
14116 
+            if (hour < 4) {
14117 
+                return 'ночі';
14118 
+            } else if (hour < 12) {
14119 
+                return 'ранку';
14120 
+            } else if (hour < 17) {
14121 
+                return 'дня';
14122 
+            } else {
14123 
+                return 'вечора';
14124 
+            }
14125 
+        },
14126 
+        dayOfMonthOrdinalParse: /\d{1,2}-(й|го)/,
14127 
+        ordinal: function (number, period) {
14128 
+            switch (period) {
14129 
+                case 'M':
14130 
+                case 'd':
14131 
+                case 'DDD':
14132 
+                case 'w':
14133 
+                case 'W':
14134 
+                    return number + '-й';
14135 
+                case 'D':
14136 
+                    return number + '-го';
14137 
+                default:
14138 
+                    return number;
14139 
+            }
14140 
+        },
14141 
+        week : {
14142 
+            dow : 1, // Monday is the first day of the week.
14143 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
14144 
+        }
14145 
+    });
14146 
+
14147 
+    //! moment.js locale configuration
14148 
+
14149 
+    var months$a = [
14150 
+        'جنوری',
14151 
+        'فروری',
14152 
+        'مارچ',
14153 
+        'اپریل',
14154 
+        'مئی',
14155 
+        'جون',
14156 
+        'جولائی',
14157 
+        'اگست',
14158 
+        'ستمبر',
14159 
+        'اکتوبر',
14160 
+        'نومبر',
14161 
+        'دسمبر'
14162 
+    ];
14163 
+    var days$2 = [
14164 
+        'اتوار',
14165 
+        'پیر',
14166 
+        'منگل',
14167 
+        'بدھ',
14168 
+        'جمعرات',
14169 
+        'جمعہ',
14170 
+        'ہفتہ'
14171 
+    ];
14172 
+
14173 
+    hooks.defineLocale('ur', {
14174 
+        months : months$a,
14175 
+        monthsShort : months$a,
14176 
+        weekdays : days$2,
14177 
+        weekdaysShort : days$2,
14178 
+        weekdaysMin : days$2,
14179 
+        longDateFormat : {
14180 
+            LT : 'HH:mm',
14181 
+            LTS : 'HH:mm:ss',
14182 
+            L : 'DD/MM/YYYY',
14183 
+            LL : 'D MMMM YYYY',
14184 
+            LLL : 'D MMMM YYYY HH:mm',
14185 
+            LLLL : 'dddd، D MMMM YYYY HH:mm'
14186 
+        },
14187 
+        meridiemParse: /صبح|شام/,
14188 
+        isPM : function (input) {
14189 
+            return 'شام' === input;
14190 
+        },
14191 
+        meridiem : function (hour, minute, isLower) {
14192 
+            if (hour < 12) {
14193 
+                return 'صبح';
14194 
+            }
14195 
+            return 'شام';
14196 
+        },
14197 
+        calendar : {
14198 
+            sameDay : '[آج بوقت] LT',
14199 
+            nextDay : '[کل بوقت] LT',
14200 
+            nextWeek : 'dddd [بوقت] LT',
14201 
+            lastDay : '[گذشتہ روز بوقت] LT',
14202 
+            lastWeek : '[گذشتہ] dddd [بوقت] LT',
14203 
+            sameElse : 'L'
14204 
+        },
14205 
+        relativeTime : {
14206 
+            future : '%s بعد',
14207 
+            past : '%s قبل',
14208 
+            s : 'چند سیکنڈ',
14209 
+            ss : '%d سیکنڈ',
14210 
+            m : 'ایک منٹ',
14211 
+            mm : '%d منٹ',
14212 
+            h : 'ایک گھنٹہ',
14213 
+            hh : '%d گھنٹے',
14214 
+            d : 'ایک دن',
14215 
+            dd : '%d دن',
14216 
+            M : 'ایک ماہ',
14217 
+            MM : '%d ماہ',
14218 
+            y : 'ایک سال',
14219 
+            yy : '%d سال'
14220 
+        },
14221 
+        preparse: function (string) {
14222 
+            return string.replace(/،/g, ',');
14223 
+        },
14224 
+        postformat: function (string) {
14225 
+            return string.replace(/,/g, '،');
14226 
+        },
14227 
+        week : {
14228 
+            dow : 1, // Monday is the first day of the week.
14229 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
14230 
+        }
14231 
+    });
14232 
+
14233 
+    //! moment.js locale configuration
14234 
+
14235 
+    hooks.defineLocale('uz-latn', {
14236 
+        months : 'Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr'.split('_'),
14237 
+        monthsShort : 'Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek'.split('_'),
14238 
+        weekdays : 'Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba'.split('_'),
14239 
+        weekdaysShort : 'Yak_Dush_Sesh_Chor_Pay_Jum_Shan'.split('_'),
14240 
+        weekdaysMin : 'Ya_Du_Se_Cho_Pa_Ju_Sha'.split('_'),
14241 
+        longDateFormat : {
14242 
+            LT : 'HH:mm',
14243 
+            LTS : 'HH:mm:ss',
14244 
+            L : 'DD/MM/YYYY',
14245 
+            LL : 'D MMMM YYYY',
14246 
+            LLL : 'D MMMM YYYY HH:mm',
14247 
+            LLLL : 'D MMMM YYYY, dddd HH:mm'
14248 
+        },
14249 
+        calendar : {
14250 
+            sameDay : '[Bugun soat] LT [da]',
14251 
+            nextDay : '[Ertaga] LT [da]',
14252 
+            nextWeek : 'dddd [kuni soat] LT [da]',
14253 
+            lastDay : '[Kecha soat] LT [da]',
14254 
+            lastWeek : '[O\'tgan] dddd [kuni soat] LT [da]',
14255 
+            sameElse : 'L'
14256 
+        },
14257 
+        relativeTime : {
14258 
+            future : 'Yaqin %s ichida',
14259 
+            past : 'Bir necha %s oldin',
14260 
+            s : 'soniya',
14261 
+            ss : '%d soniya',
14262 
+            m : 'bir daqiqa',
14263 
+            mm : '%d daqiqa',
14264 
+            h : 'bir soat',
14265 
+            hh : '%d soat',
14266 
+            d : 'bir kun',
14267 
+            dd : '%d kun',
14268 
+            M : 'bir oy',
14269 
+            MM : '%d oy',
14270 
+            y : 'bir yil',
14271 
+            yy : '%d yil'
14272 
+        },
14273 
+        week : {
14274 
+            dow : 1, // Monday is the first day of the week.
14275 
+            doy : 7  // The week that contains Jan 7th is the first week of the year.
14276 
+        }
14277 
+    });
14278 
+
14279 
+    //! moment.js locale configuration
14280 
+
14281 
+    hooks.defineLocale('uz', {
14282 
+        months : 'январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр'.split('_'),
14283 
+        monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
14284 
+        weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
14285 
+        weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
14286 
+        weekdaysMin : 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
14287 
+        longDateFormat : {
14288 
+            LT : 'HH:mm',
14289 
+            LTS : 'HH:mm:ss',
14290 
+            L : 'DD/MM/YYYY',
14291 
+            LL : 'D MMMM YYYY',
14292 
+            LLL : 'D MMMM YYYY HH:mm',
14293 
+            LLLL : 'D MMMM YYYY, dddd HH:mm'
14294 
+        },
14295 
+        calendar : {
14296 
+            sameDay : '[Бугун соат] LT [да]',
14297 
+            nextDay : '[Эртага] LT [да]',
14298 
+            nextWeek : 'dddd [куни соат] LT [да]',
14299 
+            lastDay : '[Кеча соат] LT [да]',
14300 
+            lastWeek : '[Утган] dddd [куни соат] LT [да]',
14301 
+            sameElse : 'L'
14302 
+        },
14303 
+        relativeTime : {
14304 
+            future : 'Якин %s ичида',
14305 
+            past : 'Бир неча %s олдин',
14306 
+            s : 'фурсат',
14307 
+            ss : '%d фурсат',
14308 
+            m : 'бир дакика',
14309 
+            mm : '%d дакика',
14310 
+            h : 'бир соат',
14311 
+            hh : '%d соат',
14312 
+            d : 'бир кун',
14313 
+            dd : '%d кун',
14314 
+            M : 'бир ой',
14315 
+            MM : '%d ой',
14316 
+            y : 'бир йил',
14317 
+            yy : '%d йил'
14318 
+        },
14319 
+        week : {
14320 
+            dow : 1, // Monday is the first day of the week.
14321 
+            doy : 7  // The week that contains Jan 4th is the first week of the year.
14322 
+        }
14323 
+    });
14324 
+
14325 
+    //! moment.js locale configuration
14326 
+
14327 
+    hooks.defineLocale('vi', {
14328 
+        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('_'),
14329 
+        monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
14330 
+        monthsParseExact : true,
14331 
+        weekdays : 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
14332 
+        weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
14333 
+        weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
14334 
+        weekdaysParseExact : true,
14335 
+        meridiemParse: /sa|ch/i,
14336 
+        isPM : function (input) {
14337 
+            return /^ch$/i.test(input);
14338 
+        },
14339 
+        meridiem : function (hours, minutes, isLower) {
14340 
+            if (hours < 12) {
14341 
+                return isLower ? 'sa' : 'SA';
14342 
+            } else {
14343 
+                return isLower ? 'ch' : 'CH';
14344 
+            }
14345 
+        },
14346 
+        longDateFormat : {
14347 
+            LT : 'HH:mm',
14348 
+            LTS : 'HH:mm:ss',
14349 
+            L : 'DD/MM/YYYY',
14350 
+            LL : 'D MMMM [năm] YYYY',
14351 
+            LLL : 'D MMMM [năm] YYYY HH:mm',
14352 
+            LLLL : 'dddd, D MMMM [năm] YYYY HH:mm',
14353 
+            l : 'DD/M/YYYY',
14354 
+            ll : 'D MMM YYYY',
14355 
+            lll : 'D MMM YYYY HH:mm',
14356 
+            llll : 'ddd, D MMM YYYY HH:mm'
14357 
+        },
14358 
+        calendar : {
14359 
+            sameDay: '[Hôm nay lúc] LT',
14360 
+            nextDay: '[Ngày mai lúc] LT',
14361 
+            nextWeek: 'dddd [tuần tới lúc] LT',
14362 
+            lastDay: '[Hôm qua lúc] LT',
14363 
+            lastWeek: 'dddd [tuần rồi lúc] LT',
14364 
+            sameElse: 'L'
14365 
+        },
14366 
+        relativeTime : {
14367 
+            future : '%s tới',
14368 
+            past : '%s trước',
14369 
+            s : 'vài giây',
14370 
+            ss : '%d giây' ,
14371 
+            m : 'một phút',
14372 
+            mm : '%d phút',
14373 
+            h : 'một giờ',
14374 
+            hh : '%d giờ',
14375 
+            d : 'một ngày',
14376 
+            dd : '%d ngày',
14377 
+            M : 'một tháng',
14378 
+            MM : '%d tháng',
14379 
+            y : 'một năm',
14380 
+            yy : '%d năm'
14381 
+        },
14382 
+        dayOfMonthOrdinalParse: /\d{1,2}/,
14383 
+        ordinal : function (number) {
14384 
+            return number;
14385 
+        },
14386 
+        week : {
14387 
+            dow : 1, // Monday is the first day of the week.
14388 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
14389 
+        }
14390 
+    });
14391 
+
14392 
+    //! moment.js locale configuration
14393 
+
14394 
+    hooks.defineLocale('x-pseudo', {
14395 
+        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('_'),
14396 
+        monthsShort : 'J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc'.split('_'),
14397 
+        monthsParseExact : true,
14398 
+        weekdays : 'S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý'.split('_'),
14399 
+        weekdaysShort : 'S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát'.split('_'),
14400 
+        weekdaysMin : 'S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá'.split('_'),
14401 
+        weekdaysParseExact : true,
14402 
+        longDateFormat : {
14403 
+            LT : 'HH:mm',
14404 
+            L : 'DD/MM/YYYY',
14405 
+            LL : 'D MMMM YYYY',
14406 
+            LLL : 'D MMMM YYYY HH:mm',
14407 
+            LLLL : 'dddd, D MMMM YYYY HH:mm'
14408 
+        },
14409 
+        calendar : {
14410 
+            sameDay : '[T~ódá~ý át] LT',
14411 
+            nextDay : '[T~ómó~rró~w át] LT',
14412 
+            nextWeek : 'dddd [át] LT',
14413 
+            lastDay : '[Ý~ést~érdá~ý át] LT',
14414 
+            lastWeek : '[L~ást] dddd [át] LT',
14415 
+            sameElse : 'L'
14416 
+        },
14417 
+        relativeTime : {
14418 
+            future : 'í~ñ %s',
14419 
+            past : '%s á~gó',
14420 
+            s : 'á ~féw ~sécó~ñds',
14421 
+            ss : '%d s~écóñ~ds',
14422 
+            m : 'á ~míñ~úté',
14423 
+            mm : '%d m~íñú~tés',
14424 
+            h : 'á~ñ hó~úr',
14425 
+            hh : '%d h~óúrs',
14426 
+            d : 'á ~dáý',
14427 
+            dd : '%d d~áýs',
14428 
+            M : 'á ~móñ~th',
14429 
+            MM : '%d m~óñt~hs',
14430 
+            y : 'á ~ýéár',
14431 
+            yy : '%d ý~éárs'
14432 
+        },
14433 
+        dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
14434 
+        ordinal : function (number) {
14435 
+            var b = number % 10,
14436 
+                output = (~~(number % 100 / 10) === 1) ? 'th' :
14437 
+                (b === 1) ? 'st' :
14438 
+                (b === 2) ? 'nd' :
14439 
+                (b === 3) ? 'rd' : 'th';
14440 
+            return number + output;
14441 
+        },
14442 
+        week : {
14443 
+            dow : 1, // Monday is the first day of the week.
14444 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
14445 
+        }
14446 
+    });
14447 
+
14448 
+    //! moment.js locale configuration
14449 
+
14450 
+    hooks.defineLocale('yo', {
14451 
+        months : 'Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀'.split('_'),
14452 
+        monthsShort : 'Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀'.split('_'),
14453 
+        weekdays : 'Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta'.split('_'),
14454 
+        weekdaysShort : 'Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá'.split('_'),
14455 
+        weekdaysMin : 'Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb'.split('_'),
14456 
+        longDateFormat : {
14457 
+            LT : 'h:mm A',
14458 
+            LTS : 'h:mm:ss A',
14459 
+            L : 'DD/MM/YYYY',
14460 
+            LL : 'D MMMM YYYY',
14461 
+            LLL : 'D MMMM YYYY h:mm A',
14462 
+            LLLL : 'dddd, D MMMM YYYY h:mm A'
14463 
+        },
14464 
+        calendar : {
14465 
+            sameDay : '[Ònì ni] LT',
14466 
+            nextDay : '[Ọ̀la ni] LT',
14467 
+            nextWeek : 'dddd [Ọsẹ̀ tón\'bọ] [ni] LT',
14468 
+            lastDay : '[Àna ni] LT',
14469 
+            lastWeek : 'dddd [Ọsẹ̀ tólọ́] [ni] LT',
14470 
+            sameElse : 'L'
14471 
+        },
14472 
+        relativeTime : {
14473 
+            future : 'ní %s',
14474 
+            past : '%s kọjá',
14475 
+            s : 'ìsẹjú aayá die',
14476 
+            ss :'aayá %d',
14477 
+            m : 'ìsẹjú kan',
14478 
+            mm : 'ìsẹjú %d',
14479 
+            h : 'wákati kan',
14480 
+            hh : 'wákati %d',
14481 
+            d : 'ọjọ́ kan',
14482 
+            dd : 'ọjọ́ %d',
14483 
+            M : 'osù kan',
14484 
+            MM : 'osù %d',
14485 
+            y : 'ọdún kan',
14486 
+            yy : 'ọdún %d'
14487 
+        },
14488 
+        dayOfMonthOrdinalParse : /ọjọ́\s\d{1,2}/,
14489 
+        ordinal : 'ọjọ́ %d',
14490 
+        week : {
14491 
+            dow : 1, // Monday is the first day of the week.
14492 
+            doy : 4 // The week that contains Jan 4th is the first week of the year.
14493 
+        }
14494 
+    });
14495 
+
14496 
+    //! moment.js locale configuration
14497 
+
14498 
+    hooks.defineLocale('zh-cn', {
14499 
+        months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
14500 
+        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
14501 
+        weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
14502 
+        weekdaysShort : '周日_周一_周二_周三_周四_周五_周六'.split('_'),
14503 
+        weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
14504 
+        longDateFormat : {
14505 
+            LT : 'HH:mm',
14506 
+            LTS : 'HH:mm:ss',
14507 
+            L : 'YYYY/MM/DD',
14508 
+            LL : 'YYYY年M月D日',
14509 
+            LLL : 'YYYY年M月D日Ah点mm分',
14510 
+            LLLL : 'YYYY年M月D日ddddAh点mm分',
14511 
+            l : 'YYYY/M/D',
14512 
+            ll : 'YYYY年M月D日',
14513 
+            lll : 'YYYY年M月D日 HH:mm',
14514 
+            llll : 'YYYY年M月D日dddd HH:mm'
14515 
+        },
14516 
+        meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
14517 
+        meridiemHour: function (hour, meridiem) {
14518 
+            if (hour === 12) {
14519 
+                hour = 0;
14520 
+            }
14521 
+            if (meridiem === '凌晨' || meridiem === '早上' ||
14522 
+                    meridiem === '上午') {
14523 
+                return hour;
14524 
+            } else if (meridiem === '下午' || meridiem === '晚上') {
14525 
+                return hour + 12;
14526 
+            } else {
14527 
+                // '中午'
14528 
+                return hour >= 11 ? hour : hour + 12;
14529 
+            }
14530 
+        },
14531 
+        meridiem : function (hour, minute, isLower) {
14532 
+            var hm = hour * 100 + minute;
14533 
+            if (hm < 600) {
14534 
+                return '凌晨';
14535 
+            } else if (hm < 900) {
14536 
+                return '早上';
14537 
+            } else if (hm < 1130) {
14538 
+                return '上午';
14539 
+            } else if (hm < 1230) {
14540 
+                return '中午';
14541 
+            } else if (hm < 1800) {
14542 
+                return '下午';
14543 
+            } else {
14544 
+                return '晚上';
14545 
+            }
14546 
+        },
14547 
+        calendar : {
14548 
+            sameDay : '[今天]LT',
14549 
+            nextDay : '[明天]LT',
14550 
+            nextWeek : '[下]ddddLT',
14551 
+            lastDay : '[昨天]LT',
14552 
+            lastWeek : '[上]ddddLT',
14553 
+            sameElse : 'L'
14554 
+        },
14555 
+        dayOfMonthOrdinalParse: /\d{1,2}(日|月|周)/,
14556 
+        ordinal : function (number, period) {
14557 
+            switch (period) {
14558 
+                case 'd':
14559 
+                case 'D':
14560 
+                case 'DDD':
14561 
+                    return number + '日';
14562 
+                case 'M':
14563 
+                    return number + '月';
14564 
+                case 'w':
14565 
+                case 'W':
14566 
+                    return number + '周';
14567 
+                default:
14568 
+                    return number;
14569 
+            }
14570 
+        },
14571 
+        relativeTime : {
14572 
+            future : '%s内',
14573 
+            past : '%s前',
14574 
+            s : '几秒',
14575 
+            ss : '%d 秒',
14576 
+            m : '1 分钟',
14577 
+            mm : '%d 分钟',
14578 
+            h : '1 小时',
14579 
+            hh : '%d 小时',
14580 
+            d : '1 天',
14581 
+            dd : '%d 天',
14582 
+            M : '1 个月',
14583 
+            MM : '%d 个月',
14584 
+            y : '1 年',
14585 
+            yy : '%d 年'
14586 
+        },
14587 
+        week : {
14588 
+            // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
14589 
+            dow : 1, // Monday is the first day of the week.
14590 
+            doy : 4  // The week that contains Jan 4th is the first week of the year.
14591 
+        }
14592 
+    });
14593 
+
14594 
+    //! moment.js locale configuration
14595 
+
14596 
+    hooks.defineLocale('zh-hk', {
14597 
+        months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
14598 
+        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
14599 
+        weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
14600 
+        weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
14601 
+        weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
14602 
+        longDateFormat : {
14603 
+            LT : 'HH:mm',
14604 
+            LTS : 'HH:mm:ss',
14605 
+            L : 'YYYY/MM/DD',
14606 
+            LL : 'YYYY年M月D日',
14607 
+            LLL : 'YYYY年M月D日 HH:mm',
14608 
+            LLLL : 'YYYY年M月D日dddd HH:mm',
14609 
+            l : 'YYYY/M/D',
14610 
+            ll : 'YYYY年M月D日',
14611 
+            lll : 'YYYY年M月D日 HH:mm',
14612 
+            llll : 'YYYY年M月D日dddd HH:mm'
14613 
+        },
14614 
+        meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
14615 
+        meridiemHour : function (hour, meridiem) {
14616 
+            if (hour === 12) {
14617 
+                hour = 0;
14618 
+            }
14619 
+            if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
14620 
+                return hour;
14621 
+            } else if (meridiem === '中午') {
14622 
+                return hour >= 11 ? hour : hour + 12;
14623 
+            } else if (meridiem === '下午' || meridiem === '晚上') {
14624 
+                return hour + 12;
14625 
+            }
14626 
+        },
14627 
+        meridiem : function (hour, minute, isLower) {
14628 
+            var hm = hour * 100 + minute;
14629 
+            if (hm < 600) {
14630 
+                return '凌晨';
14631 
+            } else if (hm < 900) {
14632 
+                return '早上';
14633 
+            } else if (hm < 1130) {
14634 
+                return '上午';
14635 
+            } else if (hm < 1230) {
14636 
+                return '中午';
14637 
+            } else if (hm < 1800) {
14638 
+                return '下午';
14639 
+            } else {
14640 
+                return '晚上';
14641 
+            }
14642 
+        },
14643 
+        calendar : {
14644 
+            sameDay : '[今天]LT',
14645 
+            nextDay : '[明天]LT',
14646 
+            nextWeek : '[下]ddddLT',
14647 
+            lastDay : '[昨天]LT',
14648 
+            lastWeek : '[上]ddddLT',
14649 
+            sameElse : 'L'
14650 
+        },
14651 
+        dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
14652 
+        ordinal : function (number, period) {
14653 
+            switch (period) {
14654 
+                case 'd' :
14655 
+                case 'D' :
14656 
+                case 'DDD' :
14657 
+                    return number + '日';
14658 
+                case 'M' :
14659 
+                    return number + '月';
14660 
+                case 'w' :
14661 
+                case 'W' :
14662 
+                    return number + '週';
14663 
+                default :
14664 
+                    return number;
14665 
+            }
14666 
+        },
14667 
+        relativeTime : {
14668 
+            future : '%s內',
14669 
+            past : '%s前',
14670 
+            s : '幾秒',
14671 
+            ss : '%d 秒',
14672 
+            m : '1 分鐘',
14673 
+            mm : '%d 分鐘',
14674 
+            h : '1 小時',
14675 
+            hh : '%d 小時',
14676 
+            d : '1 天',
14677 
+            dd : '%d 天',
14678 
+            M : '1 個月',
14679 
+            MM : '%d 個月',
14680 
+            y : '1 年',
14681 
+            yy : '%d 年'
14682 
+        }
14683 
+    });
14684 
+
14685 
+    //! moment.js locale configuration
14686 
+
14687 
+    hooks.defineLocale('zh-tw', {
14688 
+        months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
14689 
+        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
14690 
+        weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
14691 
+        weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
14692 
+        weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
14693 
+        longDateFormat : {
14694 
+            LT : 'HH:mm',
14695 
+            LTS : 'HH:mm:ss',
14696 
+            L : 'YYYY/MM/DD',
14697 
+            LL : 'YYYY年M月D日',
14698 
+            LLL : 'YYYY年M月D日 HH:mm',
14699 
+            LLLL : 'YYYY年M月D日dddd HH:mm',
14700 
+            l : 'YYYY/M/D',
14701 
+            ll : 'YYYY年M月D日',
14702 
+            lll : 'YYYY年M月D日 HH:mm',
14703 
+            llll : 'YYYY年M月D日dddd HH:mm'
14704 
+        },
14705 
+        meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
14706 
+        meridiemHour : function (hour, meridiem) {
14707 
+            if (hour === 12) {
14708 
+                hour = 0;
14709 
+            }
14710 
+            if (meridiem === '凌晨' || meridiem === '早上' || meridiem === '上午') {
14711 
+                return hour;
14712 
+            } else if (meridiem === '中午') {
14713 
+                return hour >= 11 ? hour : hour + 12;
14714 
+            } else if (meridiem === '下午' || meridiem === '晚上') {
14715 
+                return hour + 12;
14716 
+            }
14717 
+        },
14718 
+        meridiem : function (hour, minute, isLower) {
14719 
+            var hm = hour * 100 + minute;
14720 
+            if (hm < 600) {
14721 
+                return '凌晨';
14722 
+            } else if (hm < 900) {
14723 
+                return '早上';
14724 
+            } else if (hm < 1130) {
14725 
+                return '上午';
14726 
+            } else if (hm < 1230) {
14727 
+                return '中午';
14728 
+            } else if (hm < 1800) {
14729 
+                return '下午';
14730 
+            } else {
14731 
+                return '晚上';
14732 
+            }
14733 
+        },
14734 
+        calendar : {
14735 
+            sameDay : '[今天] LT',
14736 
+            nextDay : '[明天] LT',
14737 
+            nextWeek : '[下]dddd LT',
14738 
+            lastDay : '[昨天] LT',
14739 
+            lastWeek : '[上]dddd LT',
14740 
+            sameElse : 'L'
14741 
+        },
14742 
+        dayOfMonthOrdinalParse: /\d{1,2}(日|月|週)/,
14743 
+        ordinal : function (number, period) {
14744 
+            switch (period) {
14745 
+                case 'd' :
14746 
+                case 'D' :
14747 
+                case 'DDD' :
14748 
+                    return number + '日';
14749 
+                case 'M' :
14750 
+                    return number + '月';
14751 
+                case 'w' :
14752 
+                case 'W' :
14753 
+                    return number + '週';
14754 
+                default :
14755 
+                    return number;
14756 
+            }
14757 
+        },
14758 
+        relativeTime : {
14759 
+            future : '%s內',
14760 
+            past : '%s前',
14761 
+            s : '幾秒',
14762 
+            ss : '%d 秒',
14763 
+            m : '1 分鐘',
14764 
+            mm : '%d 分鐘',
14765 
+            h : '1 小時',
14766 
+            hh : '%d 小時',
14767 
+            d : '1 天',
14768 
+            dd : '%d 天',
14769 
+            M : '1 個月',
14770 
+            MM : '%d 個月',
14771 
+            y : '1 年',
14772 
+            yy : '%d 年'
14773 
+        }
14774 
+    });
14775 
+
14776 
+    hooks.locale('en');
14777 
+
14778 
+    return hooks;
14779 
+
14780 
+})));