//! moment.js

//! version : 2.30.1

//! authors : Tim Wood, Iskren Chernev, Moment.js contributors

//! license : MIT

//! momentjs.com

;(function (global, factory) {

    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

    typeof define === 'function' && define.amd ? define(factory) :

    global.moment = factory()

}(this, (function () { 'use strict';

    var hookCallback;

    function hooks() {

        return hookCallback.apply(null, arguments);

    }

    // This is done to register the method called with moment()

    // without creating circular dependencies.

    function setHookCallback(callback) {

        hookCallback = callback;

    }

    function isArray(input) {

        return (

            input instanceof Array ||

            Object.prototype.toString.call(input) === '[object Array]'

        );

    }

    function isObject(input) {

        // IE8 will treat undefined and null as object if it wasn't for

        // input != null

        return (

            input != null &&

            Object.prototype.toString.call(input) === '[object Object]'

        );

    }

    function hasOwnProp(a, b) {

        return Object.prototype.hasOwnProperty.call(a, b);

    }

    function isObjectEmpty(obj) {

        if (Object.getOwnPropertyNames) {

            return Object.getOwnPropertyNames(obj).length === 0;

        } else {

            var k;

            for (k in obj) {

                if (hasOwnProp(obj, k)) {

                    return false;

                }

            }

            return true;

        }

    }

    function isUndefined(input) {

        return input === void 0;

    }

    function isNumber(input) {

        return (

            typeof input === 'number' ||

            Object.prototype.toString.call(input) === '[object Number]'

        );

    }

    function isDate(input) {

        return (

            input instanceof Date ||

            Object.prototype.toString.call(input) === '[object Date]'

        );

    }

    function map(arr, fn) {

        var res = [],

            i,

            arrLen = arr.length;

        for (i = 0; i < arrLen; ++i) {

            res.push(fn(arr[i], i));

        }

        return res;

    }

    function extend(a, b) {

        for (var i in b) {

            if (hasOwnProp(b, i)) {

                a[i] = b[i];

            }

        }

        if (hasOwnProp(b, 'toString')) {

            a.toString = b.toString;

        }

        if (hasOwnProp(b, 'valueOf')) {

            a.valueOf = b.valueOf;

        }

        return a;

    }

    function createUTC(input, format, locale, strict) {

        return createLocalOrUTC(input, format, locale, strict, true).utc();

    }

    function defaultParsingFlags() {

        // We need to deep clone this object.

        return {

            empty: false,

            unusedTokens: [],

            unusedInput: [],

            overflow: -2,

            charsLeftOver: 0,

            nullInput: false,

            invalidEra: null,

            invalidMonth: null,

            invalidFormat: false,

            userInvalidated: false,

            iso: false,

            parsedDateParts: [],

            era: null,

            meridiem: null,

            rfc2822: false,

            weekdayMismatch: false,

        };

    }

    function getParsingFlags(m) {

        if (m._pf == null) {

            m._pf = defaultParsingFlags();

        }

        return m._pf;

    }

    var some;

    if (Array.prototype.some) {

        some = Array.prototype.some;

    } else {

        some = function (fun) {

            var t = Object(this),

                len = t.length >>> 0,

                i;

            for (i = 0; i < len; i++) {

                if (i in t && fun.call(this, t[i], i, t)) {

                    return true;

                }

            }

            return false;

        };

    }

    function isValid(m) {

        var flags = null,

            parsedParts = false,

            isNowValid = m._d && !isNaN(m._d.getTime());

        if (isNowValid) {

            flags = getParsingFlags(m);

            parsedParts = some.call(flags.parsedDateParts, function (i) {

                return i != null;

            });

            isNowValid =

                flags.overflow < 0 &&

                !flags.empty &&

                !flags.invalidEra &&

                !flags.invalidMonth &&

                !flags.invalidWeekday &&

                !flags.weekdayMismatch &&

                !flags.nullInput &&

                !flags.invalidFormat &&

                !flags.userInvalidated &&

                (!flags.meridiem || (flags.meridiem && parsedParts));

            if (m._strict) {

                isNowValid =

                    isNowValid &&

                    flags.charsLeftOver === 0 &&

                    flags.unusedTokens.length === 0 &&

                    flags.bigHour === undefined;

            }

        }

        if (Object.isFrozen == null || !Object.isFrozen(m)) {

            m._isValid = isNowValid;

        } else {

            return isNowValid;

        }

        return m._isValid;

    }

    function createInvalid(flags) {

        var m = createUTC(NaN);

        if (flags != null) {

            extend(getParsingFlags(m), flags);

        } else {

            getParsingFlags(m).userInvalidated = true;

        }

        return m;

    }

    // Plugins that add properties should also add the key here (null value),

    // so we can properly clone ourselves.

    var momentProperties = (hooks.momentProperties = []),

        updateInProgress = false;

    function copyConfig(to, from) {

        var i,

            prop,

            val,

            momentPropertiesLen = momentProperties.length;

        if (!isUndefined(from._isAMomentObject)) {

            to._isAMomentObject = from._isAMomentObject;

        }

        if (!isUndefined(from._i)) {

            to._i = from._i;

        }

        if (!isUndefined(from._f)) {

            to._f = from._f;

        }

        if (!isUndefined(from._l)) {

            to._l = from._l;

        }

        if (!isUndefined(from._strict)) {

            to._strict = from._strict;

        }

        if (!isUndefined(from._tzm)) {

            to._tzm = from._tzm;

        }

        if (!isUndefined(from._isUTC)) {

            to._isUTC = from._isUTC;

        }

        if (!isUndefined(from._offset)) {

            to._offset = from._offset;

        }

        if (!isUndefined(from._pf)) {

            to._pf = getParsingFlags(from);

        }

        if (!isUndefined(from._locale)) {

            to._locale = from._locale;

        }

        if (momentPropertiesLen > 0) {

            for (i = 0; i < momentPropertiesLen; i++) {

                prop = momentProperties[i];

                val = from[prop];

                if (!isUndefined(val)) {

                    to[prop] = val;

                }

            }

        }

        return to;

    }

    // Moment prototype object

    function Moment(config) {

        copyConfig(this, config);

        this._d = new Date(config._d != null ? config._d.getTime() : NaN);

        if (!this.isValid()) {

            this._d = new Date(NaN);

        }

        // Prevent infinite loop in case updateOffset creates new moment

        // objects.

        if (updateInProgress === false) {

            updateInProgress = true;

            hooks.updateOffset(this);

            updateInProgress = false;

        }

    }

    function isMoment(obj) {

        return (

            obj instanceof Moment || (obj != null && obj._isAMomentObject != null)

        );

    }

    function warn(msg) {

        if (

            hooks.suppressDeprecationWarnings === false &&

            typeof console !== 'undefined' &&

            console.warn

        ) {

            console.warn('Deprecation warning: ' + msg);

        }

    }

    function deprecate(msg, fn) {

        var firstTime = true;

        return extend(function () {

            if (hooks.deprecationHandler != null) {

                hooks.deprecationHandler(null, msg);

            }

            if (firstTime) {

                var args = [],

                    arg,

                    i,

                    key,

                    argLen = arguments.length;

                for (i = 0; i < argLen; i++) {

                    arg = '';

                    if (typeof arguments[i] === 'object') {

                        arg += '\n[' + i + '] ';

                        for (key in arguments[0]) {

                            if (hasOwnProp(arguments[0], key)) {

                                arg += key + ': ' + arguments[0][key] + ', ';

                            }

                        }

                        arg = arg.slice(0, -2); // Remove trailing comma and space

                    } else {

                        arg = arguments[i];

                    }

                    args.push(arg);

                }

                warn(

                    msg +

                        '\nArguments: ' +

                        Array.prototype.slice.call(args).join('') +

                        '\n' +

                        new Error().stack

                );

                firstTime = false;

            }

            return fn.apply(this, arguments);

        }, fn);

    }

    var deprecations = {};

    function deprecateSimple(name, msg) {

        if (hooks.deprecationHandler != null) {

            hooks.deprecationHandler(name, msg);

        }

        if (!deprecations[name]) {

            warn(msg);

            deprecations[name] = true;

        }

    }

    hooks.suppressDeprecationWarnings = false;

    hooks.deprecationHandler = null;

    function isFunction(input) {

        return (

            (typeof Function !== 'undefined' && input instanceof Function) ||

            Object.prototype.toString.call(input) === '[object Function]'

        );

    }

    function set(config) {

        var prop, i;

        for (i in config) {

            if (hasOwnProp(config, i)) {

                prop = config[i];

                if (isFunction(prop)) {

                    this[i] = prop;

                } else {

                    this['_' + i] = prop;

                }

            }

        }

        this._config = config;

        // Lenient ordinal parsing accepts just a number in addition to

        // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.

        // TODO: Remove "ordinalParse" fallback in next major release.

        this._dayOfMonthOrdinalParseLenient = new RegExp(

            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +

                '|' +

                /\d{1,2}/.source

        );

    }

    function mergeConfigs(parentConfig, childConfig) {

        var res = extend({}, parentConfig),

            prop;

        for (prop in childConfig) {

            if (hasOwnProp(childConfig, prop)) {

                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {

                    res[prop] = {};

                    extend(res[prop], parentConfig[prop]);

                    extend(res[prop], childConfig[prop]);

                } else if (childConfig[prop] != null) {

                    res[prop] = childConfig[prop];

                } else {

                    delete res[prop];

                }

            }

        }

        for (prop in parentConfig) {

            if (

                hasOwnProp(parentConfig, prop) &&

                !hasOwnProp(childConfig, prop) &&

                isObject(parentConfig[prop])

            ) {

                // make sure changes to properties don't modify parent config

                res[prop] = extend({}, res[prop]);

            }

        }

        return res;

    }

    function Locale(config) {

        if (config != null) {

            this.set(config);

        }

    }

    var keys;

    if (Object.keys) {

        keys = Object.keys;

    } else {

        keys = function (obj) {

            var i,

                res = [];

            for (i in obj) {

                if (hasOwnProp(obj, i)) {

                    res.push(i);

                }

            }

            return res;

        };

    }

    var defaultCalendar = {

        sameDay: '[Today at] LT',

        nextDay: '[Tomorrow at] LT',

        nextWeek: 'dddd [at] LT',

        lastDay: '[Yesterday at] LT',

        lastWeek: '[Last] dddd [at] LT',

        sameElse: 'L',

    };

    function calendar(key, mom, now) {

        var output = this._calendar[key] || this._calendar['sameElse'];

        return isFunction(output) ? output.call(mom, now) : output;

    }

    function zeroFill(number, targetLength, forceSign) {

        var absNumber = '' + Math.abs(number),

            zerosToFill = targetLength - absNumber.length,

            sign = number >= 0;

        return (

            (sign ? (forceSign ? '+' : '') : '-') +

            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +

            absNumber

        );

    }

    var formattingTokens =

            /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,

        localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,

        formatFunctions = {},

        formatTokenFunctions = {};

    // token:    'M'

    // padded:   ['MM', 2]

    // ordinal:  'Mo'

    // callback: function () { this.month() + 1 }

    function addFormatToken(token, padded, ordinal, callback) {

        var func = callback;

        if (typeof callback === 'string') {

            func = function () {

                return this[callback]();

            };

        }

        if (token) {

            formatTokenFunctions[token] = func;

        }

        if (padded) {

            formatTokenFunctions[padded[0]] = function () {

                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);

            };

        }

        if (ordinal) {

            formatTokenFunctions[ordinal] = function () {

                return this.localeData().ordinal(

                    func.apply(this, arguments),

                    token

                );

            };

        }

    }

    function removeFormattingTokens(input) {

        if (input.match(/\[[\s\S]/)) {

            return input.replace(/^\[|\]$/g, '');

        }

        return input.replace(/\\/g, '');

    }

    function makeFormatFunction(format) {

        var array = format.match(formattingTokens),

            i,

            length;

        for (i = 0, length = array.length; i < length; i++) {

            if (formatTokenFunctions[array[i]]) {

                array[i] = formatTokenFunctions[array[i]];

            } else {

                array[i] = removeFormattingTokens(array[i]);

            }

        }

        return function (mom) {