https://www.zahnarzt-muehlheim-am-main.de/wp-content/themes/zahnarztpraxis-kusch/js/moment.js

1(function (global, factory) {
2    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
3    typeof define === 'function' && define.amd ? define(factory) :
4    global.moment = factory()
5}(this, function () { 'use strict';
6
7    var hookCallback;
8
9    function utils_hooks__hooks () {
10        return hookCallback.apply(null, arguments);
11    }
12
13    // This is done to register the method called with moment()
14    // without creating circular dependencies.
15    function setHookCallback (callback) {
16        hookCallback = callback;
17    }
18
19    function isArray(input) {
20        return Object.prototype.toString.call(input) === '[object Array]';
21    }
22
23    function isDate(input) {
24        return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
25    }
26
27    function map(arr, fn) {
28        var res = [], i;
29        for (i = 0; i < arr.length; ++i) {
30            res.push(fn(arr[i], i));
31        }
32        return res;
33    }
34
35    function hasOwnProp(a, b) {
36        return Object.prototype.hasOwnProperty.call(a, b);
37    }
38
39    function extend(a, b) {
40        for (var i in b) {
41            if (hasOwnProp(b, i)) {
42                a[i] = b[i];
43            }
44        }
45
46        if (hasOwnProp(b, 'toString')) {
47            a.toString = b.toString;
48        }
49
50        if (hasOwnProp(b, 'valueOf')) {
51            a.valueOf = b.valueOf;
52        }
53
54        return a;
55    }
56
57    function create_utc__createUTC (input, format, locale, strict) {
58        return createLocalOrUTC(input, format, locale, strict, true).utc();
59    }
60
61    function defaultParsingFlags() {
62        // We need to deep clone this object.
63        return {
64            empty           : false,
65            unusedTokens    : [],
66            unusedInput     : [],
67            overflow        : -2,
68            charsLeftOver   : 0,
69            nullInput       : false,
70            invalidMonth    : null,
71            invalidFormat   : false,
72            userInvalidated : false,
73            iso             : false
74        };
75    }
76
77    function getParsingFlags(m) {
78        if (m._pf == null) {
79            m._pf = defaultParsingFlags();
80        }
81        return m._pf;
82    }
83
84    function valid__isValid(m) {
85        if (m._isValid == null) {
86            var flags = getParsingFlags(m);
87            m._isValid = !isNaN(m._d.getTime()) &&
88                flags.overflow < 0 &&
89                !flags.empty &&
90                !flags.invalidMonth &&
91                !flags.nullInput &&
92                !flags.invalidFormat &&
93                !flags.userInvalidated;
94
95            if (m._strict) {
96                m._isValid = m._isValid &&
97                    flags.charsLeftOver === 0 &&
98                    flags.unusedTokens.length === 0 &&
99                    flags.bigHour === undefined;
100            }
101        }
102        return m._isValid;
103    }
104
105    function valid__createInvalid (flags) {
106        var m = create_utc__createUTC(NaN);
107        if (flags != null) {
108            extend(getParsingFlags(m), flags);
109        }
110        else {
111            getParsingFlags(m).userInvalidated = true;
112        }
113
114        return m;
115    }
116
117    var momentProperties = utils_hooks__hooks.momentProperties = [];
118
119    function copyConfig(to, from) {
120        var i, prop, val;
121
122        if (typeof from._isAMomentObject !== 'undefined') {
123            to._isAMomentObject = from._isAMomentObject;
124        }
125        if (typeof from._i !== 'undefined') {
126            to._i = from._i;
127        }
128        if (typeof from._f !== 'undefined') {
129            to._f = from._f;
130        }
131        if (typeof from._l !== 'undefined') {
132            to._l = from._l;
133        }
134        if (typeof from._strict !== 'undefined') {
135            to._strict = from._strict;
136        }
137        if (typeof from._tzm !== 'undefined') {
138            to._tzm = from._tzm;
139        }
140        if (typeof from._isUTC !== 'undefined') {
141            to._isUTC = from._isUTC;
142        }
143        if (typeof from._offset !== 'undefined') {
144            to._offset = from._offset;
145        }
146        if (typeof from._pf !== 'undefined') {
147            to._pf = getParsingFlags(from);
148        }
149        if (typeof from._locale !== 'undefined') {
150            to._locale = from._locale;
151        }
152
153        if (momentProperties.length > 0) {
154            for (i in momentProperties) {
155                prop = momentProperties[i];
156                val = from[prop];
157                if (typeof val !== 'undefined') {
158                    to[prop] = val;
159                }
160            }
161        }
162
163        return to;
164    }
165
166    var updateInProgress = false;

167
168    // Moment prototype object
169    function Moment(config) {
170        copyConfig(this, config);
171        this._d = new Date(+config._d);
172        // Prevent infinite loop in case updateOffset creates new moment
173        // objects.
174        if (updateInProgress === false) {
175            updateInProgress = true;
176            utils_hooks__hooks.updateOffset(this);
177            updateInProgress = false;
178        }
179    }
180
181    function isMoment (obj) {
182        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
183    }
184
185    function toInt(argumentForCoercion) {
186        var coercedNumber = +argumentForCoercion,
187            value = 0;
188
189        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
190            if (coercedNumber >= 0) {
191                value = Math.floor(coercedNumber);
192            } else {
193                value = Math.ceil(coercedNumber);
194            }
195        }
196
197        return value;
198    }
199
200    function compareArrays(array1, array2, dontConvert) {
201        var len = Math.min(array1.length, array2.length),
202            lengthDiff = Math.abs(array1.length - array2.length),
203            diffs = 0,
204            i;
205        for (i = 0; i < len; i++) {
206            if ((dontConvert && array1[i] !== array2[i]) ||
207                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
208                diffs++;
209            }
210        }
211        return diffs + lengthDiff;
212    }
213
214    function Locale() {
215    }
216
217    var locales = {};
218    var globalLocale;
219
220    function normalizeLocale(key) {
221        return key ? key.toLowerCase().replace('_', '-') : key;
222    }
223
224    // pick the locale from the array
225    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
226    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
227    function chooseLocale(names) {
228        var i = 0, j, next, locale, split;
229
230        while (i < names.length) {
231            split = normalizeLocale(names[i]).split('-');
232            j = split.length;
233            next = normalizeLocale(names[i + 1]);
234            next = next ? next.split('-') : null;
235            while (j > 0) {
236                locale = loadLocale(split.slice(0, j).join('-'));
237                if (locale) {
238                    return locale;
239                }
240                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
241                    //the next array item is better than a shallower substring of this one
242                    break;
243                }
244                j--;
245            }
246            i++;
247        }
248        return null;
249    }
250
251    function loadLocale(name) {
252        var oldLocale = null;
253        // TODO: Find a better way to register and load all the locales in Node
254        if (!locales[name] && typeof module !== 'undefined' &&
255                module && module.exports) {
256            try {
257                oldLocale = globalLocale._abbr;
258                require('./locale/' + name);
259                // because defineLocale currently also sets the global locale, we
260                // want to undo that for lazy loaded locales
261                locale_locales__getSetGlobalLocale(oldLocale);
262            } catch (e) { }
263        }
264        return locales[name];
265    }
266
267    // This function will load locale and then set the global locale.  If
268    // no arguments are passed in, it will simply return the current global
269    // locale key.
270    function locale_locales__getSetGlobalLocale (key, values) {
271        var data;
272        if (key) {
273            if (typeof values === 'undefined') {
274                data = locale_locales__getLocale(key);
275            }
276            else {
277                data = defineLocale(key, values);
278            }
279
280            if (data) {
281                // moment.duration._locale = moment._locale = data;
282                globalLocale = data;
283            }
284        }
285
286        return globalLocale._abbr;
287    }
288
289    function defineLocale (name, values) {
290        if (values !== null) {
291            values.abbr = name;
292            if (!locales[name]) {
293                locales[name] = new Locale();
294            }
295            locales[name].set(values);
296
297            // backwards compat for now: also set the locale
298            locale_locales__getSetGlobalLocale(name);
299
300            return locales[name];
301        } else {
302            // useful for testing
303            delete locales[name];
304            return null;
305        }
306    }
307
308    // returns locale data
309    function locale_locales__getLocale (key) {
310        var locale;
311
312        if (key && key._locale && key._locale._abbr) {
313            key = key._locale._abbr;
314        }
315
316        if (!key) {
317            return globalLocale;
318        }
319
320        if (!isArray(key)) {
321            //short-circuit everything else
322            locale = loadLocale(key);
323            if (locale) {
324                return locale;
325            }
326            key = [key];
327        }
328
329        return chooseLocale(key);
330    }
331
332    var aliases = {};
333
334    function addUnitAlias (unit, shorthand) {
335        var lowerCase = unit.toLowerCase();
336        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
337    }
338
339    function normalizeUnits(units) {
340        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
341    }
342
343    function normalizeObjectUnits(inputObject) {
344        var normalizedInput = {},
345            normalizedProp,
346            prop;
347
348        for (prop in inputObject) {
349            if (hasOwnProp(inputObject, prop)) {
350                normalizedProp = normalizeUnits(prop);
351                if (normalizedProp) {
352                    normalizedInput[normalizedProp] = inputObject[prop];
353                }
354            }
355        }
356
357        return normalizedInput;
358    }
359
360    function makeGetSet (unit, keepTime) {
361        return function (value) {
362            if (value != null) {
363                get_set__set(this, unit, value);
364                utils_hooks__hooks.updateOffset(this, keepTime);
365                return this;
366            } else {
367                return get_set__get(this, unit);
368            }
369        };
370    }
371
372    function get_set__get (mom, unit) {
373        return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
374    }
375
376    function get_set__set (mom, unit, value) {
377        return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
378    }
379
380    // MOMENTS
381
382    function getSet (units, value) {
383        var unit;
384        if (typeof units === 'object') {
385            for (unit in units) {
386                this.set(unit, units[unit]);
387            }
388        } else {
389            units = normalizeUnits(units);
390            if (typeof this[units] === 'function') {
391                return this[units](value);
392            }
393        }
394        return this;
395    }
396
397    function zeroFill(number, targetLength, forceSign) {
398        var output = '' + Math.abs(number),
399            sign = number >= 0;
400
401        while (output.length < targetLength) {
402            output = '0' + output;
403        }
404        return (sign ? (forceSign ? '+' : '') : '-') + output;
405    }
406
407    var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|x|X|zz?|ZZ?|.)/g;
408
409    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
410
411    var formatFunctions = {};
412
413    var formatTokenFunctions = {};
414
415    // token:    'M'
416    // padded:   ['MM', 2]
417    // ordinal:  'Mo'
418    // callback: function () { this.month() + 1 }
419    function addFormatToken (token, padded, ordinal, callback) {
420        var func = callback;
421        if (typeof callback === 'string') {
422            func = function () {
423                return this[callback]();
424            };
425        }
426        if (token) {
427            formatTokenFunctions[token] = func;
428        }
429        if (padded) {
430            formatTokenFunctions[padded[0]] = function () {
431                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
432            };
433        }
434        if (ordinal) {
435            formatTokenFunctions[ordinal] = function () {
436                return this.localeData().ordinal(func.apply(this, arguments), token);
437            };
438        }
439    }
440
441    function removeFormattingTokens(input) {
442        if (input.match(/\[[\s\S]/)) {
443            return input.replace(/^\[|\]$/g, '');
444        }
445        return input.replace(/\\/g, '');
446    }
447
448    function makeFormatFunction(format) {
449        var array = format.match(formattingTokens), i, length;
450
451        for (i = 0, length = array.length; i < length; i++) {
452            if (formatTokenFunctions[array[i]]) {
453                array[i] = formatTokenFunctions[array[i]];
454            } else {
455                array[i] = removeFormattingTokens(array[i]);
456            }
457        }
458
459        return function (mom) {
460            var output = '';
461            for (i = 0; i < length; i++) {
462                output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
463            }
464            return output;
465        };
466    }
467
468    // format date using native date object
469    function formatMoment(m, format) {
470        if (!m.isValid()) {
471            return m.localeData().invalidDate();
472        }
473
474        format = expandFormat(format, m.localeData());
475
476        if (!formatFunctions[format]) {
477            formatFunctions[format] = makeFormatFunction(format);
478        }
479
480        return formatFunctions[format](m);
481    }
482
483    function expandFormat(format, locale) {
484        var i = 5;
485
486        function replaceLongDateFormatTokens(input) {
487            return locale.longDateFormat(input) || input;
488        }
489
490        localFormattingTokens.lastIndex = 0;
491        while (i >= 0 && localFormattingTokens.test(format)) {
492            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
493            localFormattingTokens.lastIndex = 0;
494            i -= 1;
495        }
496
497        return format;
498    }
499
500    var match1         = /\d/;            //       0 - 9
501    var match2         = /\d\d/;          //      00 - 99
502    var match3         = /\d{3}/;         //     000 - 999
503    var match4         = /\d{4}/;         //    0000 - 9999
504    var match6         = /[+-]?\d{6}/;    // -999999 - 999999
505    var match1to2      = /\d\d?/;         //       0 - 99
506    var match1to3      = /\d{1,3}/;       //       0 - 999
507    var match1to4      = /\d{1,4}/;       //       0 - 9999
508    var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
509
510    var matchUnsigned  = /\d+/;           //       0 - inf
511    var matchSigned    = /[+-]?\d+/;      //    -inf - inf
512
513    var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
514
515    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
516
517    // any word (or two) characters or numbers including two/three word month in arabic.
518    var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
519
520    var regexes = {};
521
522    function addRegexToken (token, regex, strictRegex) {
523        regexes[token] = typeof regex === 'function' ? regex : function (isStrict) {
524            return (isStrict && strictRegex) ? strictRegex : regex;
525        };
526    }
527
528    function getParseRegexForToken (token, config) {
529        if (!hasOwnProp(regexes, token)) {
530            return new RegExp(unescapeFormat(token));
531        }
532
533        return regexes[token](config._strict, config._locale);
534    }
535
536    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
537    function unescapeFormat(s) {
538        return s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
539            return p1 || p2 || p3 || p4;
540        }).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
541    }
542
543    var tokens = {};
544
545    function addParseToken (token, callback) {
546        var i, func = callback;
547        if (typeof token === 'string') {
548            token = [token];
549        }
550        if (typeof callback === 'number') {
551            func = function (input, array) {
552                array[callback] = toInt(input);
553            };
554        }
555        for (i = 0; i < token.length; i++) {
556            tokens[token[i]] = func;
557        }
558    }
559
560    function addWeekParseToken (token, callback) {
561        addParseToken(token, function (input, array, config, token) {
562            config._w = config._w || {};
563            callback(input, config._w, config, token);
564        });
565    }
566
567    function addTimeToArrayFromToken(token, input, config) {
568        if (input != null && hasOwnProp(tokens, token)) {
569            tokens[token](input, config._a, config, token);
570        }
571    }
572
573    var YEAR = 0;
574    var MONTH = 1;
575    var DATE = 2;
576    var HOUR = 3;
577    var MINUTE = 4;
578    var SECOND = 5;
579    var MILLISECOND = 6;
580
581    function daysInMonth(year, month) {
582        return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
583    }
584
585    // FORMATTING
586
587    addFormatToken('M', ['MM', 2], 'Mo', function () {
588        return this.month() + 1;
589    });
590
591    addFormatToken('MMM', 0, 0, function (format) {
592        return this.localeData().monthsShort(this, format);
593    });
594
595    addFormatToken('MMMM', 0, 0, function (format) {
596        return this.localeData().months(this, format);
597    });
598
599    // ALIASES
600
601    addUnitAlias('month', 'M');
602
603    // PARSING
604
605    addRegexToken('M',    match1to2);
606    addRegexToken('MM',   match1to2, match2);
607    addRegexToken('MMM',  matchWord);
608    addRegexToken('MMMM', matchWord);
609
610    addParseToken(['M', 'MM'], function (input, array) {
611        array[MONTH] = toInt(input) - 1;
612    });
613
614    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
615        var month = config._locale.monthsParse(input, token, config._strict);
616        // if we didn't find a month name, mark the date as invalid.
617        if (month != null) {
618            array[MONTH] = month;
619        } else {
620            getParsingFlags(config).invalidMonth = input;
621        }
622    });
623
624    // LOCALES
625
626    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
627    function localeMonths (m) {
628        return this._months[m.month()];
629    }
630
631    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
632    function localeMonthsShort (m) {
633        return this._monthsShort[m.month()];
634    }
635
636    function localeMonthsParse (monthName, format, strict) {
637        var i, mom, regex;
638
639        if (!this._monthsParse) {
640            this._monthsParse = [];
641            this._longMonthsParse = [];
642            this._shortMonthsParse = [];
643        }
644
645        for (i = 0; i < 12; i++) {
646            // make the regex if we don't have it already
647            mom = create_utc__createUTC([2000, i]);
648            if (strict && !this._longMonthsParse[i]) {
649                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
650                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
651            }
652            if (!strict && !this._monthsParse[i]) {
653                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
654                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
655            }
656            // test the regex
657            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
658                return i;
659            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
660                return i;
661            } else if (!strict && this._monthsParse[i].test(monthName)) {
662                return i;
663            }
664        }
665    }
666
667    // MOMENTS
668
669    function setMonth (mom, value) {
670        var dayOfMonth;
671
672        // TODO: Move this out of here!
673        if (typeof value === 'string') {
674            value = mom.localeData().monthsParse(value);
675            // TODO: Another silent failure?
676            if (typeof value !== 'number') {
677                return mom;
678            }
679        }
680
681        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
682        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
683        return mom;
684    }
685
686    function getSetMonth (value) {
687        if (value != null) {
688            setMonth(this, value);
689            utils_hooks__hooks.updateOffset(this, true);
690            return this;
691        } else {
692            return get_set__get(this, 'Month');
693        }
694    }
695
696    function getDaysInMonth () {
697        return daysInMonth(this.year(), this.month());
698    }
699
700    function checkOverflow (m) {
701        var overflow;
702        var a = m._a;
703
704        if (a && getParsingFlags(m).overflow === -2) {
705            overflow =
706                a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
707                a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
708                a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
709                a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
710                a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
711                a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
712                -1;
713
714            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
715                overflow = DATE;
716            }
717
718            getParsingFlags(m).overflow = overflow;
719        }
720
721        return m;
722    }
723
724    function warn(msg) {
725        if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
726            console.warn('Deprecation warning: ' + msg);
727        }
728    }
729
730    function deprecate(msg, fn) {
731        var firstTime = true,
732            msgWithStack = msg + '\n' + (new Error()).stack;
733
734        return extend(function () {
735            if (firstTime) {
736                warn(msgWithStack);
737                firstTime = false;
738            }
739            return fn.apply(this, arguments);
740        }, fn);
741    }
742
743    var deprecations = {};
744
745    function deprecateSimple(name, msg) {
746        if (!deprecations[name]) {
747            warn(msg);
748            deprecations[name] = true;
749        }
750    }
751
752    utils_hooks__hooks.suppressDeprecationWarnings = false;
753
754    var from_string__isoRegex = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
755
756    var isoDates = [
757        ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
758        ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
759        ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
760        ['GGGG-[W]WW', /\d{4}-W\d{2}/],
761        ['YYYY-DDD', /\d{4}-\d{3}/]
762    ];
763
764    // iso time formats and regexes
765    var isoTimes = [
766        ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
767        ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
768        ['HH:mm', /(T| )\d\d:\d\d/],
769        ['HH', /(T| )\d\d/]
770    ];
771
772    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
773
774    // date from iso format
775    function configFromISO(config) {
776        var i, l,
777            string = config._i,
778            match = from_string__isoRegex.exec(string);
779
780        if (match) {
781            getParsingFlags(config).iso = true;
782            for (i = 0, l = isoDates.length; i < l; i++) {
783                if (isoDates[i][1].exec(string)) {
784                    // match[5] should be 'T' or undefined
785                    config._f = isoDates[i][0] + (match[6] || ' ');
786                    break;
787                }
788            }
789            for (i = 0, l = isoTimes.length; i < l; i++) {
790                if (isoTimes[i][1].exec(string)) {
791                    config._f += isoTimes[i][0];
792                    break;
793                }
794            }
795            if (string.match(matchOffset)) {
796                config._f += 'Z';
797            }
798            configFromStringAndFormat(config);
799        } else {
800            config._isValid = false;
801        }
802    }
803
804    // date from iso format or fallback
805    function configFromString(config) {
806        var matched = aspNetJsonRegex.exec(config._i);
807
808        if (matched !== null) {
809            config._d = new Date(+matched[1]);
810            return;
811        }
812
813        configFromISO(config);
814        if (config._isValid === false) {
815            delete config._isValid;
816            utils_hooks__hooks.createFromInputFallback(config);
817        }
818    }
819
820    utils_hooks__hooks.createFromInputFallback = deprecate(
821        'moment construction falls back to js Date. This is ' +
822        'discouraged and will be removed in upcoming major ' +
823        'release. Please refer to ' +
824        'https://github.com/moment/moment/issues/1407 for more info.',
825        function (config) {
826            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
827        }
828    );
829
830    function createDate (y, m, d, h, M, s, ms) {
831        //can't just apply() to create a date:
832        //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
833        var date = new Date(y, m, d, h, M, s, ms);
834
835        //the date constructor doesn't accept years < 1970
836        if (y < 1970) {
837            date.setFullYear(y);
838        }
839        return date;
840    }
841
842    function createUTCDate (y) {
843        var date = new Date(Date.UTC.apply(null, arguments));
844        if (y < 1970) {
845            date.setUTCFullYear(y);
846        }
847        return date;
848    }
849
850    addFormatToken(0, ['YY', 2], 0, function () {
851        return this.year() % 100;
852    });
853
854    addFormatToken(0, ['YYYY',   4],       0, 'year');
855    addFormatToken(0, ['YYYYY',  5],       0, 'year');
856    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
857
858    // ALIASES
859
860    addUnitAlias('year', 'y');
861
862    // PARSING
863
864    addRegexToken('Y',      matchSigned);
865    addRegexToken('YY',     match1to2, match2);
866    addRegexToken('YYYY',   match1to4, match4);
867    addRegexToken('YYYYY',  match1to6, match6);
868    addRegexToken('YYYYYY', match1to6, match6);
869
870    addParseToken(['YYYY', 'YYYYY', 'YYYYYY'], YEAR);
871    addParseToken('YY', function (input, array) {
872        array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
873    });
874
875    // HELPERS
876
877    function daysInYear(year) {
878        return isLeapYear(year) ? 366 : 365;
879    }
880
881    function isLeapYear(year) {
882        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
883    }
884
885    // HOOKS
886
887    utils_hooks__hooks.parseTwoDigitYear = function (input) {
888        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
889    };
890
891    // MOMENTS
892
893    var getSetYear = makeGetSet('FullYear', false);
894
895    function getIsLeapYear () {
896        return isLeapYear(this.year());
897    }
898
899    addFormatToken('w', ['ww', 2], 'wo', 'week');
900    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
901
902    // ALIASES
903
904    addUnitAlias('week', 'w');
905    addUnitAlias('isoWeek', 'W');
906
907    // PARSING
908
909    addRegexToken('w',  match1to2);
910    addRegexToken('ww', match1to2, match2);
911    addRegexToken('W',  match1to2);
912    addRegexToken('WW', match1to2, match2);
913

1075            config._a[i] = input[i] = currentDate[i];
1076        }
1077
1078        // Zero out whatever was not defaulted, including time
1079        for (; i < 7; i++) {
1080            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
1081        }
1082
1083        // Check for 24:00:00.000
1084        if (config._a[HOUR] === 24 &&
1085                config._a[MINUTE] === 0 &&
1086                config._a[SECOND] === 0 &&
1087                config._a[MILLISECOND] === 0) {
1088            config._nextDay = true;
1089            config._a[HOUR] = 0;
1090        }
1091
1092        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
1093        // Apply timezone offset from input. The actual utcOffset can be changed
1094        // with parseZone.
1095        if (config._tzm != null) {
1096            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
1097        }
1098
1099        if (config._nextDay) {
1100            config._a[HOUR] = 24;
1101        }
1102    }
1103
1104    function dayOfYearFromWeekInfo(config) {
1105        var w, weekYear, week, weekday, dow, doy, temp;
1106
1107        w = config._w;
1108        if (w.GG != null || w.W != null || w.E != null) {
1109            dow = 1;
1110            doy = 4;
1111
1112            // TODO: We need to take the current isoWeekYear, but that depends on
1113            // how we interpret now (local, utc, fixed offset). So create
1114            // a now version of current config (take local/utc/offset flags, and
1115            // create now).
1116            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
1117            week = defaults(w.W, 1);
1118            weekday = defaults(w.E, 1);
1119        } else {
1120            dow = config._locale._week.dow;
1121            doy = config._locale._week.doy;
1122
1123            weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
1124            week = defaults(w.w, 1);
1125
1126            if (w.d != null) {
1127                // weekday -- low day numbers are considered next week
1128                weekday = w.d;
1129                if (weekday < dow) {
1130                    ++week;
1131                }
1132            } else if (w.e != null) {
1133                // local weekday -- counting starts from begining of week
1134                weekday = w.e + dow;
1135            } else {
1136                // default to begining of week
1137                weekday = dow;
1138            }
1139        }
1140        temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
1141
1142        config._a[YEAR] = temp.year;
1143        config._dayOfYear = temp.dayOfYear;
1144    }
1145
1146    utils_hooks__hooks.ISO_8601 = function () {};
1147
1148    // date from string and format string
1149    function configFromStringAndFormat(config) {
1150        // TODO: Move this to another part of the creation flow to prevent circular deps
1151        if (config._f === utils_hooks__hooks.ISO_8601) {
1152            configFromISO(config);
1153            return;
1154        }
1155
1156        config._a = [];
1157        getParsingFlags(config).empty = true;
1158
1159        // This array is used to make a Date, either with `new Date` or `Date.UTC`
1160        var string = '' + config._i,
1161            i, parsedInput, tokens, token, skipped,
1162            stringLength = string.length,
1163            totalParsedInputLength = 0;
1164
1165        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
1166
1167        for (i = 0; i < tokens.length; i++) {
1168            token = tokens[i];
1169            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
1170            if (parsedInput) {
1171                skipped = string.substr(0, string.indexOf(parsedInput));
1172                if (skipped.length > 0) {
1173                    getParsingFlags(config).unusedInput.push(skipped);
1174                }
1175                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
1176                totalParsedInputLength += parsedInput.length;
1177            }
1178            // don't parse if it's not a known token
1179            if (formatTokenFunctions[token]) {
1180                if (parsedInput) {
1181                    getParsingFlags(config).empty = false;
1182                }
1183                else {
1184                    getParsingFlags(config).unusedTokens.push(token);
1185                }
1186                addTimeToArrayFromToken(token, parsedInput, config);
1187            }
1188            else if (config._strict && !parsedInput) {
1189                getParsingFlags(config).unusedTokens.push(token);
1190            }
1191        }
1192
1193        // add remaining unparsed input length to the string
1194        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
1195        if (string.length > 0) {
1196            getParsingFlags(config).unusedInput.push(string);
1197        }
1198
1199        // clear _12h flag if hour is <= 12
1200        if (getParsingFlags(config).bigHour === true &&
1201                config._a[HOUR] <= 12 &&
1202                config._a[HOUR] > 0) {
1203            getParsingFlags(config).bigHour = undefined;
1204        }
1205        // handle meridiem
1206        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
1207
1208        configFromArray(config);
1209        checkOverflow(config);
1210    }
1211
1212
1213    function meridiemFixWrap (locale, hour, meridiem) {
1214        var isPm;
1215
1216        if (meridiem == null) {
1217            // nothing to do
1218            return hour;
1219        }
1220        if (locale.meridiemHour != null) {
1221            return locale.meridiemHour(hour, meridiem);
1222        } else if (locale.isPM != null) {
1223            // Fallback
1224            isPm = locale.isPM(meridiem);
1225            if (isPm && hour < 12) {
1226                hour += 12;
1227            }
1228            if (!isPm && hour === 12) {
1229                hour = 0;
1230            }
1231            return hour;
1232        } else {
1233            // this is not supposed to happen
1234            return hour;
1235        }
1236    }
1237
1238    function configFromStringAndArray(config) {
1239        var tempConfig,
1240            bestMoment,
1241
1242            scoreToBeat,
1243            i,
1244            currentScore;
1245
1246        if (config._f.length === 0) {
1247            getParsingFlags(config).invalidFormat = true;
1248            config._d = new Date(NaN);
1249            return;
1250        }
1251
1252        for (i = 0; i < config._f.length; i++) {
1253            currentScore = 0;
1254            tempConfig = copyConfig({}, config);
1255            if (config._useUTC != null) {
1256                tempConfig._useUTC = config._useUTC;
1257            }
1258            tempConfig._f = config._f[i];
1259            configFromStringAndFormat(tempConfig);
1260
1261            if (!valid__isValid(tempConfig)) {
1262                continue;
1263            }
1264
1265            // if there is any input that was not parsed add a penalty for that format
1266            currentScore += getParsingFlags(tempConfig).charsLeftOver;
1267
1268            //or tokens
1269            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
1270
1271            getParsingFlags(tempConfig).score = currentScore;
1272
1273            if (scoreToBeat == null || currentScore < scoreToBeat) {
1274                scoreToBeat = currentScore;
1275                bestMoment = tempConfig;
1276            }
1277        }
1278
1279        extend(config, bestMoment || tempConfig);
1280    }
1281
1282    function configFromObject(config) {
1283        if (config._d) {
1284            return;
1285        }
1286
1287        var i = normalizeObjectUnits(config._i);
1288        config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond];
1289
1290        configFromArray(config);
1291    }
1292
1293    function createFromConfig (config) {
1294        var input = config._i,
1295            format = config._f,
1296            res;
1297
1298        config._locale = config._locale || locale_locales__getLocale(config._l);
1299
1300        if (input === null || (format === undefined && input === '')) {
1301            return valid__createInvalid({nullInput: true});
1302        }
1303
1304        if (typeof input === 'string') {
1305            config._i = input = config._locale.preparse(input);
1306        }
1307
1308        if (isMoment(input)) {
1309            return new Moment(checkOverflow(input));
1310        } else if (isArray(format)) {
1311            configFromStringAndArray(config);
1312        } else if (format) {
1313            configFromStringAndFormat(config);
1314        } else if (isDate(input)) {
1315            config._d = input;
1316        } else {
1317            configFromInput(config);
1318        }
1319
1320        res = new Moment(checkOverflow(config));
1321        if (res._nextDay) {
1322            // Adding is smart enough around DST
1323            res.add(1, 'd');
1324            res._nextDay = undefined;
1325        }
1326
1327        return res;
1328    }
1329
1330    function configFromInput(config) {
1331        var input = config._i;
1332        if (input === undefined) {
1333            config._d = new Date();
1334        } else if (isDate(input)) {
1335            config._d = new Date(+input);
1336        } else if (typeof input === 'string') {
1337            configFromString(config);
1338        } else if (isArray(input)) {
1339            config._a = map(input.slice(0), function (obj) {
1340                return parseInt(obj, 10);
1341            });
1342            configFromArray(config);
1343        } else if (typeof(input) === 'object') {
1344            configFromObject(config);
1345        } else if (typeof(input) === 'number') {
1346            // from milliseconds
1347            config._d = new Date(input);
1348        } else {
1349            utils_hooks__hooks.createFromInputFallback(config);
1350        }
1351    }
1352
1353    function createLocalOrUTC (input, format, locale, strict, isUTC) {
1354        var c = {};
1355
1356        if (typeof(locale) === 'boolean') {
1357            strict = locale;
1358            locale = undefined;
1359        }
1360        // object construction must be done this way.
1361        // https://github.com/moment/moment/issues/1423
1362        c._isAMomentObject = true;
1363        c._useUTC = c._isUTC = isUTC;
1364        c._l = locale;
1365        c._i = input;
1366        c._f = format;
1367        c._strict = strict;
1368
1369        return createFromConfig(c);
1370    }
1371
1372    function local__createLocal (input, format, locale, strict) {
1373        return createLocalOrUTC(input, format, locale, strict, false);
1374    }
1375
1376    var prototypeMin = deprecate(
1377         'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
1378         function () {
1379             var other = local__createLocal.apply(null, arguments);
1380             return other < this ? this : other;
1381         }
1382     );
1383
1384    var prototypeMax = deprecate(
1385        'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
1386        function () {
1387            var other = local__createLocal.apply(null, arguments);
1388            return other > this ? this : other;
1389        }
1390    );
1391
1392    // Pick a moment m from moments so that m[fn](other) is true for all
1393    // other. This relies on the function fn to be transitive.
1394    //
1395    // moments should either be an array of moment objects or an array, whose
1396    // first element is an array of moment objects.
1397    function pickBy(fn, moments) {
1398        var res, i;
1399        if (moments.length === 1 && isArray(moments[0])) {
1400            moments = moments[0];
1401        }
1402        if (!moments.length) {
1403            return local__createLocal();
1404        }
1405        res = moments[0];
1406        for (i = 1; i < moments.length; ++i) {
1407            if (moments[i][fn](res)) {
1408                res = moments[i];
1409            }
1410        }
1411        return res;
1412    }
1413
1414    // TODO: Use [].sort instead?
1415    function min () {
1416        var args = [].slice.call(arguments, 0);
1417
1418        return pickBy('isBefore', args);
1419    }
1420
1421    function max () {
1422        var args = [].slice.call(arguments, 0);
1423
1424        return pickBy('isAfter', args);
1425    }
1426
1427    function Duration (duration) {
1428        var normalizedInput = normalizeObjectUnits(duration),
1429            years = normalizedInput.year || 0,
1430            quarters = normalizedInput.quarter || 0,
1431            months = normalizedInput.month || 0,
1432            weeks = normalizedInput.week || 0,
1433            days = normalizedInput.day || 0,
1434            hours = normalizedInput.hour || 0,
1435            minutes = normalizedInput.minute || 0,
1436            seconds = normalizedInput.second || 0,
1437            milliseconds = normalizedInput.millisecond || 0;
1438
1439        // representation for dateAddRemove
1440        this._milliseconds = +milliseconds +
1441            seconds * 1e3 + // 1000
1442            minutes * 6e4 + // 1000 * 60
1443            hours * 36e5; // 1000 * 60 * 60
1444        // Because of dateAddRemove treats 24 hours as different from a
1445        // day when working around DST, we need to store them separately
1446        this._days = +days +
1447            weeks * 7;
1448        // It is impossible translate months into days without knowing
1449        // which months you are are talking about, so we have to store
1450        // it separately.
1451        this._months = +months +
1452            quarters * 3 +
1453            years * 12;
1454
1455        this._data = {};
1456
1457        this._locale = locale_locales__getLocale();
1458
1459        this._bubble();
1460    }
1461
1462    function isDuration (obj) {
1463        return obj instanceof Duration;
1464    }
1465
1466    function offset (token, separator) {
1467        addFormatToken(token, 0, 0, function () {
1468            var offset = this.utcOffset();
1469            var sign = '+';
1470            if (offset < 0) {
1471                offset = -offset;
1472                sign = '-';
1473            }
1474            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
1475        });
1476    }
1477
1478    offset('Z', ':');
1479    offset('ZZ', '');
1480
1481    // PARSING
1482
1483    addRegexToken('Z',  matchOffset);
1484    addRegexToken('ZZ', matchOffset);
1485    addParseToken(['Z', 'ZZ'], function (input, array, config) {
1486        config._useUTC = true;
1487        config._tzm = offsetFromString(input);
1488    });
1489
1490    // HELPERS
1491
1492    // timezone chunker
1493    // '+10:00' > ['10',  '00']
1494    // '-1530'  > ['-15', '30']
1495    var chunkOffset = /([\+\-]|\d\d)/gi;
1496
1497    function offsetFromString(string) {
1498        var matches = ((string || '').match(matchOffset) || []);
1499        var chunk   = matches[matches.length - 1] || [];
1500        var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
1501        var minutes = +(parts[1] * 60) + toInt(parts[2]);
1502
1503        return parts[0] === '+' ? minutes : -minutes;
1504    }
1505
1506    // Return a moment from input, that is local/utc/zone equivalent to model.
1507    function cloneWithOffset(input, model) {
1508        var res, diff;
1509        if (model._isUTC) {
1510            res = model.clone();
1511            diff = (isMoment(input) || isDate(input) ? +input : +local__createLocal(input)) - (+res);
1512            // Use low-level api, because this fn is low-level api.
1513            res._d.setTime(+res._d + diff);
1514            utils_hooks__hooks.updateOffset(res, false);
1515            return res;
1516        } else {
1517            return local__createLocal(input).local();
1518        }
1519        return model._isUTC ? local__createLocal(input).zone(model._offset || 0) : local__createLocal(input).local();
1520    }
1521
1522    function getDateOffset (m) {
1523        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
1524        // https://github.com/moment/moment/pull/1871
1525        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
1526    }
1527
1528    // HOOKS
1529
1530    // This function will be called whenever a moment is mutated.
1531    // It is intended to keep the offset in sync with the timezone.
1532    utils_hooks__hooks.updateOffset = function () {};
1533
1534    // MOMENTS
1535
1536    // keepLocalTime = true means only change the timezone, without
1537    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
1538    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
1539    // +0200, so we adjust the time as needed, to be valid.
1540    //
1541    // Keeping the time actually adds/subtracts (one hour)
1542    // from the actual represented time. That is why we call updateOffset
1543    // a second time. In case it wants us to change the offset again
1544    // _changeInProgress == true case, then we have to adjust, because
1545    // there is no such time in the given timezone.
1546    function getSetOffset (input, keepLocalTime) {
1547        var offset = this._offset || 0,
1548            localAdjust;
1549        if (input != null) {
1550            if (typeof input === 'string') {
1551                input = offsetFromString(input);
1552            }
1553            if (Math.abs(input) < 16) {
1554                input = input * 60;
1555            }
1556            if (!this._isUTC && keepLocalTime) {
1557                localAdjust = getDateOffset(this);
1558            }
1559            this._offset = input;
1560            this._isUTC = true;
1561            if (localAdjust != null) {
1562                this.add(localAdjust, 'm');
1563            }
1564            if (offset !== input) {
1565                if (!keepLocalTime || this._changeInProgress) {
1566                    add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
1567                } else if (!this._changeInProgress) {
1568                    this._changeInProgress = true;
1569                    utils_hooks__hooks.updateOffset(this, true);
1570                    this._changeInProgress = null;
1571                }
1572            }
1573            return this;
1574        } else {
1575            return this._isUTC ? offset : getDateOffset(this);
1576        }
1577    }
1578
1579    function getSetZone (input, keepLocalTime) {
1580        if (input != null) {
1581            if (typeof input !== 'string') {
1582                input = -input;
1583            }
1584
1585            this.utcOffset(input, keepLocalTime);
1586
1587            return this;
1588        } else {
1589            return -this.utcOffset();
1590        }
1591    }
1592
1593    function setOffsetToUTC (keepLocalTime) {
1594        return this.utcOffset(0, keepLocalTime);
1595    }
1596
1597    function setOffsetToLocal (keepLocalTime) {
1598        if (this._isUTC) {
1599            this.utcOffset(0, keepLocalTime);
1600            this._isUTC = false;
1601
1602            if (keepLocalTime) {
1603                this.subtract(getDateOffset(this), 'm');
1604            }
1605        }
1606        return this;
1607    }
1608
1609    function setOffsetToParsedOffset () {
1610        if (this._tzm) {
1611            this.utcOffset(this._tzm);
1612        } else if (typeof this._i === 'string') {
1613            this.utcOffset(offsetFromString(this._i));
1614        }
1615        return this;
1616    }
1617
1618    function hasAlignedHourOffset (input) {
1619        if (!input) {
1620            input = 0;
1621        }
1622        else {
1623            input = local__createLocal(input).utcOffset();
1624        }
1625
1626        return (this.utcOffset() - input) % 60 === 0;
1627    }
1628
1629    function isDaylightSavingTime () {
1630        return (
1631            this.utcOffset() > this.clone().month(0).utcOffset() ||
1632            this.utcOffset() > this.clone().month(5).utcOffset()
1633        );
1634    }
1635
1636    function isDaylightSavingTimeShifted () {
1637        if (this._a) {
1638            var other = this._isUTC ? create_utc__createUTC(this._a) : local__createLocal(this._a);
1639            return this.isValid() && compareArrays(this._a, other.toArray()) > 0;
1640        }
1641
1642        return false;
1643    }
1644
1645    function isLocal () {
1646        return !this._isUTC;
1647    }
1648
1649    function isUtcOffset () {
1650        return this._isUTC;
1651    }
1652
1653    function isUtc () {
1654        return this._isUTC && this._offset === 0;
1655    }
1656
1657    var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
1658
1659    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
1660    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
1661    var create__isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
1662
1663    function create__createDuration (input, key) {
1664        var duration = input,
1665            // matching against regexp is expensive, do it on demand
1666            match = null,
1667            sign,
1668            ret,
1669            diffRes;
1670
1671        if (isDuration(input)) {
1672            duration = {
1673                ms : input._milliseconds,
1674                d  : input._days,
1675                M  : input._months
1676            };
1677        } else if (typeof input === 'number') {
1678            duration = {};
1679            if (key) {
1680                duration[key] = input;
1681            } else {
1682                duration.milliseconds = input;
1683            }
1684        } else if (!!(match = aspNetRegex.exec(input))) {
1685            sign = (match[1] === '-') ? -1 : 1;
1686            duration = {
1687                y  : 0,
1688                d  : toInt(match[DATE])        * sign,
1689                h  : toInt(match[HOUR])        * sign,
1690                m  : toInt(match[MINUTE])      * sign,
1691                s  : toInt(match[SECOND])      * sign,
1692                ms : toInt(match[MILLISECOND]) * sign
1693            };
1694        } else if (!!(match = create__isoRegex.exec(input))) {
1695            sign = (match[1] === '-') ? -1 : 1;
1696            duration = {
1697                y : parseIso(match[2], sign),
1698                M : parseIso(match[3], sign),
1699                d : parseIso(match[4], sign),
1700                h : parseIso(match[5], sign),
1701                m : parseIso(match[6], sign),
1702                s : parseIso(match[7], sign),
1703                w : parseIso(match[8], sign)
1704            };
1705        } else if (duration == null) {// checks for null or undefined
1706            duration = {};
1707        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
1708            diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
1709
1710            duration = {};
1711            duration.ms = diffRes.milliseconds;
1712            duration.M = diffRes.months;
1713        }
1714
1715        ret = new Duration(duration);
1716
1717        if (isDuration(input) && hasOwnProp(input, '_locale')) {
1718            ret._locale = input._locale;
1719        }
1720
1721        return ret;
1722    }
1723
1724    create__createDuration.fn = Duration.prototype;
1725
1726    function parseIso (inp, sign) {
1727        // We'd normally use ~~inp for this, but unfortunately it also
1728        // converts floats to ints.
1729        // inp may be undefined, so careful calling replace on it.
1730        var res = inp && parseFloat(inp.replace(',', '.'));
1731        // apply sign while we're at it
1732        return (isNaN(res) ? 0 : res) * sign;
1733    }
1734
1735    function positiveMomentsDifference(base, other) {
1736        var res = {milliseconds: 0, months: 0};
1737
1738        res.months = other.month() - base.month() +
1739            (other.year() - base.year()) * 12;
1740        if (base.clone().add(res.months, 'M').isAfter(other)) {
1741            --res.months;
1742        }
1743
1744        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
1745
1746        return res;
1747    }
1748
1749    function momentsDifference(base, other) {
1750        var res;
1751        other = cloneWithOffset(other, base);
1752        if (base.isBefore(other)) {
1753            res = positiveMomentsDifference(base, other);
1754        } else {
1755            res = positiveMomentsDifference(other, base);
1756            res.milliseconds = -res.milliseconds;
1757            res.months = -res.months;
1758        }
1759
1760        return res;
1761    }
1762
1763    function createAdder(direction, name) {
1764        return function (val, period) {
1765            var dur, tmp;
1766            //invert the arguments, but complain about it
1767            if (period !== null && !isNaN(+period)) {
1768                deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
1769                tmp = val; val = period; period = tmp;
1770            }
1771
1772            val = typeof val === 'string' ? +val : val;
1773            dur = create__createDuration(val, period);
1774            add_subtract__addSubtract(this, dur, direction);
1775            return this;
1776        };
1777    }
1778
1779    function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
1780        var milliseconds = duration._milliseconds,
1781            days = duration._days,
1782            months = duration._months;
1783        updateOffset = updateOffset == null ? true : updateOffset;
1784
1785        if (milliseconds) {
1786            mom._d.setTime(+mom._d + milliseconds * isAdding);
1787        }
1788        if (days) {
1789            get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
1790        }
1791        if (months) {
1792            setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
1793        }
1794        if (updateOffset) {
1795            utils_hooks__hooks.updateOffset(mom, days || months);
1796        }
1797    }
1798
1799    var add_subtract__add      = createAdder(1, 'add');
1800    var add_subtract__subtract = createAdder(-1, 'subtract');
1801
1802    function moment_calendar__calendar (time) {
1803        // We want to compare the start of today, vs this.
1804        // Getting start-of-today depends on whether we're local/utc/offset or not.
1805        var now = time || local__createLocal(),
1806            sod = cloneWithOffset(now, this).startOf('day'),
1807            diff = this.diff(sod, 'days', true),
1808            format = diff < -6 ? 'sameElse' :
1809                diff < -1 ? 'lastWeek' :
1810                diff < 0 ? 'lastDay' :
1811                diff < 1 ? 'sameDay' :
1812                diff < 2 ? 'nextDay' :
1813                diff < 7 ? 'nextWeek' : 'sameElse';
1814        return this.format(this.localeData().calendar(format, this, local__createLocal(now)));
1815    }
1816
1817    function clone () {
1818        return new Moment(this);
1819    }
1820
1821    function isAfter (input, units) {
1822        var inputMs;
1823        units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
1824        if (units === 'millisecond') {
1825            input = isMoment(input) ? input : local__createLocal(input);
1826            return +this > +input;
1827        } else {
1828            inputMs = isMoment(input) ? +input : +local__createLocal(input);
1829            return inputMs < +this.clone().startOf(units);
1830        }
1831    }
1832
1833    function isBefore (input, units) {
1834        var inputMs;
1835        units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
1836        if (units === 'millisecond') {
1837            input = isMoment(input) ? input : local__createLocal(input);
1838            return +this < +input;
1839        } else {
1840            inputMs = isMoment(input) ? +input : +local__createLocal(input);
1841            return +this.clone().endOf(units) < inputMs;
1842        }
1843    }
1844
1845    function isBetween (from, to, units) {
1846        return this.isAfter(from, units) && this.isBefore(to, units);
1847    }
1848
1849    function isSame (input, units) {
1850        var inputMs;
1851        units = normalizeUnits(units || 'millisecond');
1852        if (units === 'millisecond') {
1853            input = isMoment(input) ? input : local__createLocal(input);
1854            return +this === +input;
1855        } else {
1856            inputMs = +local__createLocal(input);
1857            return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units));
1858        }
1859    }
1860
1861    function absFloor (number) {
1862        if (number < 0) {
1863            return Math.ceil(number);
1864        } else {
1865            return Math.floor(number);
1866        }
1867    }
1868
1869    function diff (input, units, asFloat) {
1870        var that = cloneWithOffset(input, this),
1871            zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4,
1872            delta, output;
1873
1874        units = normalizeUnits(units);
1875
1876        if (units === 'year' || units === 'month' || units === 'quarter') {
1877            output = monthDiff(this, that);
1878            if (units === 'quarter') {
1879                output = output / 3;
1880            } else if (units === 'year') {
1881                output = output / 12;
1882            }
1883        } else {
1884            delta = this - that;
1885            output = units === 'second' ? delta / 1e3 : // 1000
1886                units === 'minute' ? delta / 6e4 : // 1000 * 60
1887                units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
1888                units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
1889                units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
1890                delta;
1891        }
1892        return asFloat ? output : absFloor(output);
1893    }
1894
1895    function monthDiff (a, b) {
1896        // difference in months
1897        var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
1898            // b is in (anchor - 1 month, anchor + 1 month)
1899            anchor = a.clone().add(wholeMonthDiff, 'months'),
1900            anchor2, adjust;
1901
1902        if (b - anchor < 0) {
1903            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
1904            // linear across the month
1905            adjust = (b - anchor) / (anchor - anchor2);
1906        } else {
1907            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
1908            // linear across the month
1909            adjust = (b - anchor) / (anchor2 - anchor);
1910        }
1911
1912        return -(wholeMonthDiff + adjust);
1913    }
1914
1915    utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
1916
1917    function toString () {
1918        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
1919    }
1920
1921    function moment_format__toISOString () {
1922        var m = this.clone().utc();
1923        if (0 < m.year() && m.year() <= 9999) {
1924            if ('function' === typeof Date.prototype.toISOString) {
1925                // native implementation is ~50x faster, use it when we can
1926                return this.toDate().toISOString();
1927            } else {
1928                return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
1929            }
1930        } else {
1931            return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
1932        }
1933    }
1934
1935    function moment_format__format (inputString) {
1936        var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);

1937        return this.localeData().postformat(output);
1938    }
1939
1940    function from (time, withoutSuffix) {
1941        if (!this.isValid()) {
1942            return this.localeData().invalidDate();
1943        }
1944        return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
1945    }
1946
1947    function fromNow (withoutSuffix) {
1948        return this.from(local__createLocal(), withoutSuffix);
1949    }
1950
1951    function to (time, withoutSuffix) {
1952        if (!this.isValid()) {
1953            return this.localeData().invalidDate();
1954        }
1955        return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
1956    }
1957
1958    function toNow (withoutSuffix) {
1959        return this.to(local__createLocal(), withoutSuffix);
1960    }
1961
1962    function locale (key) {
1963        var newLocaleData;
1964
1965        if (key === undefined) {
1966            return this._locale._abbr;
1967        } else {
1968            newLocaleData = locale_locales__getLocale(key);
1969            if (newLocaleData != null) {
1970                this._locale = newLocaleData;
1971            }
1972            return this;
1973        }
1974    }
1975
1976    var lang = deprecate(
1977        'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
1978        function (key) {
1979            if (key === undefined) {
1980                return this.localeData();
1981            } else {
1982                return this.locale(key);
1983            }
1984        }
1985    );
1986
1987    function localeData () {
1988        return this._locale;
1989    }
1990
1991    function startOf (units) {
1992        units = normalizeUnits(units);
1993        // the following switch intentionally omits break keywords
1994        // to utilize falling through the cases.
1995        switch (units) {
1996        case 'year':
1997            this.month(0);
1998            /* falls through */
1999        case 'quarter':
2000        case 'month':
2001            this.date(1);
2002            /* falls through */
2003        case 'week':
2004        case 'isoWeek':
2005        case 'day':
2006            this.hours(0);
2007            /* falls through */
2008        case 'hour':
2009            this.minutes(0);
2010            /* falls through */
2011        case 'minute':
2012            this.seconds(0);
2013            /* falls through */
2014        case 'second':
2015            this.milliseconds(0);
2016        }
2017
2018        // weeks are a special case
2019        if (units === 'week') {
2020            this.weekday(0);
2021        }
2022        if (units === 'isoWeek') {
2023            this.isoWeekday(1);
2024        }
2025
2026        // quarters are also special
2027        if (units === 'quarter') {
2028            this.month(Math.floor(this.month() / 3) * 3);
2029        }
2030
2031        return this;
2032    }
2033
2034    function endOf (units) {
2035        units = normalizeUnits(units);
2036        if (units === undefined || units === 'millisecond') {
2037            return this;
2038        }
2039        return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
2040    }
2041
2042    function to_type__valueOf () {
2043        return +this._d - ((this._offset || 0) * 60000);
2044    }
2045
2046    function unix () {
2047        return Math.floor(+this / 1000);
2048    }
2049
2050    function toDate () {
2051        return this._offset ? new Date(+this) : this._d;
2052    }
2053
2054    function toArray () {
2055        var m = this;
2056        return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
2057    }
2058
2059    function moment_valid__isValid () {
2060        return valid__isValid(this);
2061    }
2062
2063    function parsingFlags () {
2064        return extend({}, getParsingFlags(this));
2065    }
2066

2067    function invalidAt () {
2068        return getParsingFlags(this).overflow;
2069    }
2070
2071    addFormatToken(0, ['gg', 2], 0, function () {
2072        return this.weekYear() % 100;
2073    });
2074
2075    addFormatToken(0, ['GG', 2], 0, function () {
2076        return this.isoWeekYear() % 100;
2077    });
2078
2079    function addWeekYearFormatToken (token, getter) {
2080        addFormatToken(0, [token, token.length], 0, getter);
2081    }
2082
2083    addWeekYearFormatToken('gggg',     'weekYear');
2084    addWeekYearFormatToken('ggggg',    'weekYear');
2085    addWeekYearFormatToken('GGGG',  'isoWeekYear');
2086    addWeekYearFormatToken('GGGGG', 'isoWeekYear');
2087
2088    // ALIASES
2089
2090    addUnitAlias('weekYear', 'gg');
2091    addUnitAlias('isoWeekYear', 'GG');
2092
2093    // PARSING
2094
2095    addRegexToken('G',      matchSigned);
2096    addRegexToken('g',      matchSigned);
2097    addRegexToken('GG',     match1to2, match2);
2098    addRegexToken('gg',     match1to2, match2);
2099    addRegexToken('GGGG',   match1to4, match4);
2100    addRegexToken('gggg',   match1to4, match4);
2101    addRegexToken('GGGGG',  match1to6, match6);
2102    addRegexToken('ggggg',  match1to6, match6);
2103
2104    addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
2105        week[token.substr(0, 2)] = toInt(input);
2106    });
2107
2108    addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
2109        week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
2110    });
2111
2112    // HELPERS
2113
2114    function weeksInYear(year, dow, doy) {
2115        return weekOfYear(local__createLocal([year, 11, 31 + dow - doy]), dow, doy).week;
2116    }
2117
2118    // MOMENTS
2119
2120    function getSetWeekYear (input) {
2121        var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
2122        return input == null ? year : this.add((input - year), 'y');
2123    }
2124
2125    function getSetISOWeekYear (input) {
2126        var year = weekOfYear(this, 1, 4).year;
2127        return input == null ? year : this.add((input - year), 'y');
2128    }
2129
2130    function getISOWeeksInYear () {
2131        return weeksInYear(this.year(), 1, 4);
2132    }
2133
2134    function getWeeksInYear () {
2135        var weekInfo = this.localeData()._week;
2136        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
2137    }
2138
2139    addFormatToken('Q', 0, 0, 'quarter');
2140
2141    // ALIASES
2142
2143    addUnitAlias('quarter', 'Q');
2144
2145    // PARSING
2146
2147    addRegexToken('Q', match1);
2148    addParseToken('Q', function (input, array) {
2149        array[MONTH] = (toInt(input) - 1) * 3;
2150    });
2151
2152    // MOMENTS
2153
2154    function getSetQuarter (input) {
2155        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
2156    }
2157
2158    addFormatToken('D', ['DD', 2], 'Do', 'date');
2159
2160    // ALIASES
2161
2162    addUnitAlias('date', 'D');
2163
2164    // PARSING
2165
2166    addRegexToken('D',  match1to2);
2167    addRegexToken('DD', match1to2, match2);
2168    addRegexToken('Do', function (isStrict, locale) {
2169        return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
2170    });
2171
2172    addParseToken(['D', 'DD'], DATE);
2173    addParseToken('Do', function (input, array) {
2174        array[DATE] = toInt(input.match(match1to2)[0], 10);
2175    });
2176
2177    // MOMENTS
2178
2179    var getSetDayOfMonth = makeGetSet('Date', true);
2180
2181    addFormatToken('d', 0, 'do', 'day');
2182
2183    addFormatToken('dd', 0, 0, function (format) {
2184        return this.localeData().weekdaysMin(this, format);
2185    });
2186
2187    addFormatToken('ddd', 0, 0, function (format) {
2188        return this.localeData().weekdaysShort(this, format);
2189    });
2190
2191    addFormatToken('dddd', 0, 0, function (format) {
2192        return this.localeData().weekdays(this, format);
2193    });
2194
2195    addFormatToken('e', 0, 0, 'weekday');
2196    addFormatToken('E', 0, 0, 'isoWeekday');
2197
2198    // ALIASES
2199
2200    addUnitAlias('day', 'd');
2201    addUnitAlias('weekday', 'e');
2202    addUnitAlias('isoWeekday', 'E');
2203
2204    // PARSING
2205
2206    addRegexToken('d',    match1to2);
2207    addRegexToken('e',    match1to2);
2208    addRegexToken('E',    match1to2);
2209    addRegexToken('dd',   matchWord);
2210    addRegexToken('ddd',  matchWord);
2211    addRegexToken('dddd', matchWord);
2212
2213    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) {
2214        var weekday = config._locale.weekdaysParse(input);
2215        // if we didn't get a weekday name, mark the date as invali