Difference between revisions of "Team:Manchester/moment.js"

(Created page with "//! moment.js //! version : 2.18.1 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors //! license : MIT //! momentjs.com ;(function (global, factory) { typeof...")
 
 
Line 1: Line 1:
 
//! moment.js
 
//! moment.js
−
//! version : 2.18.1
+
//! version : 2.13.0
 
//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
 
//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
 
//! license : MIT
 
//! license : MIT
 
//! momentjs.com
 
//! momentjs.com
−
 
+
!function(a, b) {
−
;(function (global, factory) {
+
     "object" == typeof exports && "undefined" != typeof module ? module.exports = b() : "function" == typeof define && define.amd ? define(b) : a.moment = b()
−
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+
}(this, function() {
−
    typeof define === 'function' && define.amd ? define(factory) :
+
    "use strict";
−
    global.moment = factory()
+
    function a() {
−
}(this, (function () { 'use strict';
+
        return fd.apply(null, arguments)
−
 
+
−
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 isObjectEmpty(obj) {
+
−
    var k;
+
−
    for (k in obj) {
+
−
        // even if its not own property I'd still call it non-empty
+
−
        return false;
+
 
     }
 
     }
−
     return true;
+
     function b(a) {
−
}
+
        fd = a
−
 
+
−
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;
+
−
    for (i = 0; i < arr.length; ++i) {
+
−
        res.push(fn(arr[i], i));
+
 
     }
 
     }
−
     return res;
+
     function c(a) {
−
}
+
        return a instanceof Array || "[object Array]" === Object.prototype.toString.call(a)
−
 
+
−
function hasOwnProp(a, b) {
+
−
    return Object.prototype.hasOwnProperty.call(a, b);
+
−
}
+
−
 
+
−
function extend(a, b) {
+
−
    for (var i in b) {
+
−
        if (hasOwnProp(b, i)) {
+
−
            a[i] = b[i];
+
−
        }
+
 
     }
 
     }
−
 
+
     function d(a) {
−
     if (hasOwnProp(b, 'toString')) {
+
         return a instanceof Date || "[object Date]" === Object.prototype.toString.call(a)
−
         a.toString = b.toString;
+
 
     }
 
     }
−
 
+
     function e(a, b) {
−
     if (hasOwnProp(b, 'valueOf')) {
+
         var c, d = [];
−
         a.valueOf = b.valueOf;
+
        for (c = 0; c < a.length; ++c)
 +
            d.push(b(a[c], c));
 +
        return d
 
     }
 
     }
−
 
+
     function f(a, b) {
−
     return a;
+
        return Object.prototype.hasOwnProperty.call(a, b)
−
}
+
−
 
+
−
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,
+
−
        invalidMonth    : null,
+
−
        invalidFormat  : false,
+
−
        userInvalidated : false,
+
−
        iso            : false,
+
−
        parsedDateParts : [],
+
−
        meridiem        : null,
+
−
        rfc2822        : false,
+
−
        weekdayMismatch : false
+
−
    };
+
−
}
+
−
 
+
−
function getParsingFlags(m) {
+
−
    if (m._pf == null) {
+
−
        m._pf = defaultParsingFlags();
+
 
     }
 
     }
−
     return m._pf;
+
     function g(a, b) {
−
}
+
        for (var c in b)
−
 
+
            f(b, c) && (a[c] = b[c]);
−
var some;
+
        return f(b, "toString") && (a.toString = b.toString),
−
if (Array.prototype.some) {
+
        f(b, "valueOf") && (a.valueOf = b.valueOf),
−
    some = Array.prototype.some;
+
        a
−
} else {
+
    }
−
     some = function (fun) {
+
     function h(a, b, c, d) {
−
         var t = Object(this);
+
         return Ja(a, b, c, d, !0).utc()
−
        var len = t.length >>> 0;
+
    }
−
 
+
    function i() {
−
        for (var i = 0; i < len; i++) {
+
        return {
−
             if (i in t && fun.call(this, t[i], i, t)) {
+
             empty: !1,
−
                return true;
+
            unusedTokens: [],
−
             }
+
            unusedInput: [],
 +
            overflow: -2,
 +
             charsLeftOver: 0,
 +
            nullInput: !1,
 +
            invalidMonth: null,
 +
            invalidFormat: !1,
 +
            userInvalidated: !1,
 +
            iso: !1,
 +
            parsedDateParts: [],
 +
            meridiem: null
 
         }
 
         }
−
 
+
    }
−
         return false;
+
    function j(a) {
−
     };
+
         return null == a._pf && (a._pf = i()),
−
}
+
        a._pf
−
 
+
     }
−
var some$1 = some;
+
    function k(a) {
−
 
+
        if (null == a._isValid) {
−
function isValid(m) {
+
            var b = j(a)
−
    if (m._isValid == null) {
+
              , c = gd.call(b.parsedDateParts, function(a) {
−
        var flags = getParsingFlags(m);
+
                return null != a
−
        var parsedParts = some$1.call(flags.parsedDateParts, function (i) {
+
            });
−
            return i != null;
+
            a._isValid = !isNaN(a._d.getTime()) && b.overflow < 0 && !b.empty && !b.invalidMonth && !b.invalidWeekday && !b.nullInput && !b.invalidFormat && !b.userInvalidated && (!b.meridiem || b.meridiem && c),
−
        });
+
            a._strict && (a._isValid = a._isValid && 0 === b.charsLeftOver && 0 === b.unusedTokens.length && void 0 === b.bigHour)
−
        var isNowValid = !isNaN(m._d.getTime()) &&
+
−
            flags.overflow < 0 &&
+
−
            !flags.empty &&
+
−
            !flags.invalidMonth &&
+
−
            !flags.invalidWeekday &&
+
−
            !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 a._isValid
 
     }
 
     }
−
     return m._isValid;
+
     function l(a) {
−
}
+
        var b = h(NaN);
−
 
+
        return null != a ? g(j(b), a) : j(b).userInvalidated = !0,
−
function createInvalid (flags) {
+
        b
−
    var m = createUTC(NaN);
+
−
    if (flags != null) {
+
−
        extend(getParsingFlags(m), flags);
+
 
     }
 
     }
−
     else {
+
     function m(a) {
−
         getParsingFlags(m).userInvalidated = true;
+
         return void 0 === a
 
     }
 
     }
−
 
+
     function n(a, b) {
−
     return m;
+
        var c, d, e;
−
}
+
        if (m(b._isAMomentObject) || (a._isAMomentObject = b._isAMomentObject),
−
 
+
        m(b._i) || (a._i = b._i),
−
// Plugins that add properties should also add the key here (null value),
+
        m(b._f) || (a._f = b._f),
−
// so we can properly clone ourselves.
+
        m(b._l) || (a._l = b._l),
−
var momentProperties = hooks.momentProperties = [];
+
        m(b._strict) || (a._strict = b._strict),
−
 
+
        m(b._tzm) || (a._tzm = b._tzm),
−
function copyConfig(to, from) {
+
        m(b._isUTC) || (a._isUTC = b._isUTC),
−
    var i, prop, val;
+
        m(b._offset) || (a._offset = b._offset),
−
 
+
        m(b._pf) || (a._pf = j(b)),
−
    if (!isUndefined(from._isAMomentObject)) {
+
         m(b._locale) || (a._locale = b._locale),
−
         to._isAMomentObject = from._isAMomentObject;
+
        hd.length > 0)
 +
            for (c in hd)
 +
                d = hd[c],
 +
                e = b[d],
 +
                m(e) || (a[d] = e);
 +
        return a
 
     }
 
     }
−
     if (!isUndefined(from._i)) {
+
     function o(b) {
−
         to._i = from._i;
+
        n(this, b),
 +
        this._d = new Date(null != b._d ? b._d.getTime() : NaN),
 +
         id === !1 && (id = !0,
 +
        a.updateOffset(this),
 +
        id = !1)
 
     }
 
     }
−
     if (!isUndefined(from._f)) {
+
     function p(a) {
−
         to._f = from._f;
+
         return a instanceof o || null != a && null != a._isAMomentObject
 
     }
 
     }
−
     if (!isUndefined(from._l)) {
+
     function q(a) {
−
         to._l = from._l;
+
         return 0 > a ? Math.ceil(a) : Math.floor(a)
 
     }
 
     }
−
     if (!isUndefined(from._strict)) {
+
     function r(a) {
−
         to._strict = from._strict;
+
         var b = +a
 +
          , c = 0;
 +
        return 0 !== b && isFinite(b) && (c = q(b)),
 +
        c
 
     }
 
     }
−
     if (!isUndefined(from._tzm)) {
+
     function s(a, b, c) {
−
         to._tzm = from._tzm;
+
         var d, e = Math.min(a.length, b.length), f = Math.abs(a.length - b.length), g = 0;
 +
        for (d = 0; e > d; d++)
 +
            (c && a[d] !== b[d] || !c && r(a[d]) !== r(b[d])) && g++;
 +
        return g + f
 
     }
 
     }
−
     if (!isUndefined(from._isUTC)) {
+
     function t(b) {
−
         to._isUTC = from._isUTC;
+
         a.suppressDeprecationWarnings === !1 && "undefined" != typeof console && console.warn && console.warn("Deprecation warning: " + b)
 
     }
 
     }
−
     if (!isUndefined(from._offset)) {
+
     function u(b, c) {
−
        to._offset = from._offset;
+
        var d = !0;
 +
        return g(function() {
 +
            return null != a.deprecationHandler && a.deprecationHandler(null, b),
 +
            d && (t(b + "\nArguments: " + Array.prototype.slice.call(arguments).join(", ") + "\n" + (new Error).stack),
 +
            d = !1),
 +
            c.apply(this, arguments)
 +
        }, c)
 
     }
 
     }
−
     if (!isUndefined(from._pf)) {
+
     function v(b, c) {
−
         to._pf = getParsingFlags(from);
+
        null != a.deprecationHandler && a.deprecationHandler(b, c),
 +
        jd[b] || (t(c),
 +
         jd[b] = !0)
 
     }
 
     }
−
     if (!isUndefined(from._locale)) {
+
     function w(a) {
−
         to._locale = from._locale;
+
         return a instanceof Function || "[object Function]" === Object.prototype.toString.call(a)
 
     }
 
     }
−
 
+
    function x(a) {
−
     if (momentProperties.length > 0) {
+
        return "[object Object]" === Object.prototype.toString.call(a)
−
         for (i = 0; i < momentProperties.length; i++) {
+
     }
−
             prop = momentProperties[i];
+
    function y(a) {
−
             val = from[prop];
+
        var b, c;
−
             if (!isUndefined(val)) {
+
        for (c in a)
−
                 to[prop] = val;
+
            b = a[c],
 +
            w(b) ? this[c] = b : this["_" + c] = b;
 +
        this._config = a,
 +
        this._ordinalParseLenient = new RegExp(this._ordinalParse.source + "|" + /\d{1,2}/.source)
 +
    }
 +
    function z(a, b) {
 +
        var c, d = g({}, a);
 +
         for (c in b)
 +
            f(b, c) && (x(a[c]) && x(b[c]) ? (d[c] = {},
 +
            g(d[c], a[c]),
 +
            g(d[c], b[c])) : null != b[c] ? d[c] = b[c] : delete d[c]);
 +
        return d
 +
    }
 +
    function A(a) {
 +
        null != a && this.set(a)
 +
    }
 +
    function B(a) {
 +
        return a ? a.toLowerCase().replace("_", "-") : a
 +
    }
 +
    function C(a) {
 +
        for (var b, c, d, e, f = 0; f < a.length; ) {
 +
             for (e = B(a[f]).split("-"),
 +
             b = e.length,
 +
            c = B(a[f + 1]),
 +
             c = c ? c.split("-") : null; b > 0; ) {
 +
                if (d = D(e.slice(0, b).join("-")))
 +
                    return d;
 +
                 if (c && c.length >= b && s(e, c, !0) >= b - 1)
 +
                    break;
 +
                b--
 
             }
 
             }
 +
            f++
 
         }
 
         }
 +
        return null
 
     }
 
     }
−
 
+
     function D(a) {
−
     return to;
+
        var b = null;
−
}
+
        if (!nd[a] && "undefined" != typeof module && module && module.exports)
−
 
+
            try {
−
var updateInProgress = false;
+
                b = ld._abbr,
−
 
+
                require("./locale/" + a),
−
// Moment prototype object
+
                E(b)
−
function Moment(config) {
+
            } catch (c) {}
−
    copyConfig(this, config);
+
         return nd[a]
−
    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
+
     function E(a, b) {
−
    // objects.
+
         var c;
−
    if (updateInProgress === false) {
+
         return a && (c = m(b) ? H(a) : F(a, b),
−
         updateInProgress = true;
+
         c && (ld = c)),
−
         hooks.updateOffset(this);
+
        ld._abbr
−
         updateInProgress = false;
+
 
     }
 
     }
−
}
+
    function F(a, b) {
−
 
+
        return null !== b ? (b.abbr = a,
−
function isMoment (obj) {
+
        null != nd[a] ? (v("defineLocaleOverride", "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale"),
−
    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
+
        b = z(nd[a]._config, b)) : null != b.parentLocale && (null != nd[b.parentLocale] ? b = z(nd[b.parentLocale]._config, b) : v("parentLocaleUndefined", "specified parentLocale is not defined yet")),
−
}
+
        nd[a] = new A(b),
−
 
+
         E(a),
−
function absFloor (number) {
+
         nd[a]) : (delete nd[a],
−
    if (number < 0) {
+
        null)
−
        // -0 -> 0
+
−
         return Math.ceil(number) || 0;
+
−
    } else {
+
−
         return Math.floor(number);
+
 
     }
 
     }
−
}
+
    function G(a, b) {
−
 
+
         if (null != b) {
−
function toInt(argumentForCoercion) {
+
            var c;
−
    var coercedNumber = +argumentForCoercion,
+
            null != nd[a] && (b = z(nd[a]._config, b)),
−
         value = 0;
+
            c = new A(b),
−
 
+
            c.parentLocale = nd[a],
−
    if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+
            nd[a] = c,
−
         value = absFloor(coercedNumber);
+
            E(a)
 +
         } else
 +
            null != nd[a] && (null != nd[a].parentLocale ? nd[a] = nd[a].parentLocale : null != nd[a] && delete nd[a]);
 +
        return nd[a]
 
     }
 
     }
−
 
+
     function H(a) {
−
     return value;
+
        var b;
−
}
+
        if (a && a._locale && a._locale._abbr && (a = a._locale._abbr),
−
 
+
         !a)
−
// compare two arrays, return the number of differences
+
            return ld;
−
function compareArrays(array1, array2, dontConvert) {
+
         if (!c(a)) {
−
    var len = Math.min(array1.length, array2.length),
+
             if (b = D(a))
−
        lengthDiff = Math.abs(array1.length - array2.length),
+
                return b;
−
         diffs = 0,
+
            a = [a]
−
        i;
+
−
    for (i = 0; i < len; i++) {
+
−
         if ((dontConvert && array1[i] !== array2[i]) ||
+
−
             (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
+
−
            diffs++;
+
 
         }
 
         }
 +
        return C(a)
 
     }
 
     }
−
     return diffs + lengthDiff;
+
     function I() {
−
}
+
         return kd(nd)
−
 
+
−
function warn(msg) {
+
−
    if (hooks.suppressDeprecationWarnings === false &&
+
−
            (typeof console !==  'undefined') && console.warn) {
+
−
         console.warn('Deprecation warning: ' + msg);
+
 
     }
 
     }
−
}
+
    function J(a, b) {
−
 
+
        var c = a.toLowerCase();
−
function deprecate(msg, fn) {
+
         od[c] = od[c + "s"] = od[b] = a
−
    var firstTime = true;
+
−
 
+
−
    return extend(function () {
+
−
        if (hooks.deprecationHandler != null) {
+
−
            hooks.deprecationHandler(null, msg);
+
−
         }
+
−
        if (firstTime) {
+
−
            var args = [];
+
−
            var arg;
+
−
            for (var i = 0; i < arguments.length; i++) {
+
−
                arg = '';
+
−
                if (typeof arguments[i] === 'object') {
+
−
                    arg += '\n[' + i + '] ';
+
−
                    for (var key in arguments[0]) {
+
−
                        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]) {
+
     function K(a) {
−
         warn(msg);
+
         return "string" == typeof a ? od[a] || od[a.toLowerCase()] : void 0
−
        deprecations[name] = true;
+
 
     }
 
     }
−
}
+
     function L(a) {
−
 
+
        var b, c, d = {};
−
hooks.suppressDeprecationWarnings = false;
+
        for (c in a)
−
hooks.deprecationHandler = null;
+
            f(a, c) && (b = K(c),
−
 
+
             b && (d[b] = a[c]));
−
function isFunction(input) {
+
         return d
−
     return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
+
−
}
+
−
 
+
−
function set (config) {
+
−
    var prop, i;
+
−
    for (i in config) {
+
−
        prop = config[i];
+
−
        if (isFunction(prop)) {
+
−
             this[i] = prop;
+
−
        } else {
+
−
            this['_' + i] = prop;
+
−
         }
+
 
     }
 
     }
−
     this._config = config;
+
     function M(b, c) {
−
    // Lenient ordinal parsing accepts just a number in addition to
+
         return function(d) {
−
    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
+
            return null != d ? (O(this, b, d),
−
    // TODO: Remove "ordinalParse" fallback in next major release.
+
             a.updateOffset(this, c),
−
    this._dayOfMonthOrdinalParseLenient = new RegExp(
+
             this) : N(this, b)
−
         (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) {
+
     function N(a, b) {
−
         if (hasOwnProp(parentConfig, prop) &&
+
         return a.isValid() ? a._d["get" + (a._isUTC ? "UTC" : "") + b]() : NaN
−
                !hasOwnProp(childConfig, prop) &&
+
−
                isObject(parentConfig[prop])) {
+
−
            // make sure changes to properties don't modify parent config
+
−
            res[prop] = extend({}, res[prop]);
+
−
        }
+
 
     }
 
     }
−
     return res;
+
     function O(a, b, c) {
−
}
+
        a.isValid() && a._d["set" + (a._isUTC ? "UTC" : "") + b](c)
−
 
+
−
function Locale(config) {
+
−
    if (config != null) {
+
−
        this.set(config);
+
 
     }
 
     }
−
}
+
    function P(a, b) {
−
 
+
        var c;
−
var keys;
+
        if ("object" == typeof a)
−
 
+
            for (c in a)
−
if (Object.keys) {
+
                this.set(c, a[c]);
−
    keys = Object.keys;
+
        else if (a = K(a),
−
} else {
+
        w(this[a]))
−
     keys = function (obj) {
+
            return this[a](b);
−
         var i, res = [];
+
        return this
−
         for (i in obj) {
+
    }
−
            if (hasOwnProp(obj, i)) {
+
     function Q(a, b, c) {
−
                res.push(i);
+
         var d = "" + Math.abs(a)
−
             }
+
          , e = b - d.length
 +
          , f = a >= 0;
 +
         return (f ? c ? "+" : "" : "-") + Math.pow(10, Math.max(0, e)).toString().substr(1) + d
 +
    }
 +
    function R(a, b, c, d) {
 +
        var e = d;
 +
        "string" == typeof d && (e = function() {
 +
             return this[d]()
 
         }
 
         }
−
         return res;
+
         ),
−
    };
+
        a && (sd[a] = e),
−
}
+
         b && (sd[b[0]] = function() {
−
 
+
            return Q(e.apply(this, arguments), b[1], b[2])
−
var keys$1 = keys;
+
−
 
+
−
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;
+
−
}
+
−
 
+
−
var defaultLongDateFormat = {
+
−
    LTS  : 'h:mm:ss A',
+
−
    LT  : 'h:mm A',
+
−
    L    : 'MM/DD/YYYY',
+
−
    LL  : 'MMMM D, YYYY',
+
−
    LLL  : 'MMMM D, YYYY h:mm A',
+
−
    LLLL : 'dddd, MMMM D, YYYY h:mm A'
+
−
};
+
−
 
+
−
function longDateFormat (key) {
+
−
    var format = this._longDateFormat[key],
+
−
        formatUpper = this._longDateFormat[key.toUpperCase()];
+
−
 
+
−
    if (format || !formatUpper) {
+
−
        return format;
+
−
    }
+
−
 
+
−
    this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
+
−
         return val.slice(1);
+
−
    });
+
−
 
+
−
    return this._longDateFormat[key];
+
−
}
+
−
 
+
−
var defaultInvalidDate = 'Invalid date';
+
−
 
+
−
function invalidDate () {
+
−
    return this._invalidDate;
+
−
}
+
−
 
+
−
var defaultOrdinal = '%d';
+
−
var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
+
−
 
+
−
function ordinal (number) {
+
−
    return this._ordinal.replace('%d', number);
+
−
}
+
−
 
+
−
var defaultRelativeTime = {
+
−
    future : 'in %s',
+
−
    past  : '%s ago',
+
−
    s  : 'a few seconds',
+
−
    ss : '%d seconds',
+
−
    m  : 'a minute',
+
−
    mm : '%d minutes',
+
−
    h  : 'an hour',
+
−
    hh : '%d hours',
+
−
    d  : 'a day',
+
−
    dd : '%d days',
+
−
    M  : 'a month',
+
−
    MM : '%d months',
+
−
    y  : 'a year',
+
−
    yy : '%d years'
+
−
};
+
−
 
+
−
function relativeTime (number, withoutSuffix, string, isFuture) {
+
−
    var output = this._relativeTime[string];
+
−
    return (isFunction(output)) ?
+
−
        output(number, withoutSuffix, string, isFuture) :
+
−
        output.replace(/%d/i, number);
+
−
}
+
−
 
+
−
function pastFuture (diff, output) {
+
−
    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+
−
    return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+
−
}
+
−
 
+
−
var aliases = {};
+
−
 
+
−
function addUnitAlias (unit, shorthand) {
+
−
    var lowerCase = unit.toLowerCase();
+
−
    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+
−
}
+
−
 
+
−
function normalizeUnits(units) {
+
−
    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
+
−
}
+
−
 
+
−
function normalizeObjectUnits(inputObject) {
+
−
    var normalizedInput = {},
+
−
        normalizedProp,
+
−
        prop;
+
−
 
+
−
    for (prop in inputObject) {
+
−
        if (hasOwnProp(inputObject, prop)) {
+
−
            normalizedProp = normalizeUnits(prop);
+
−
            if (normalizedProp) {
+
−
                normalizedInput[normalizedProp] = inputObject[prop];
+
−
            }
+
 
         }
 
         }
 +
        ),
 +
        c && (sd[c] = function() {
 +
            return this.localeData().ordinal(e.apply(this, arguments), a)
 +
        }
 +
        )
 
     }
 
     }
−
 
+
     function S(a) {
−
     return normalizedInput;
+
        return a.match(/\[[\s\S]/) ? a.replace(/^\[|\]$/g, "") : a.replace(/\\/g, "")
−
}
+
−
 
+
−
var priorities = {};
+
−
 
+
−
function addUnitPriority(unit, priority) {
+
−
    priorities[unit] = priority;
+
−
}
+
−
 
+
−
function getPrioritizedUnits(unitsObj) {
+
−
    var units = [];
+
−
    for (var u in unitsObj) {
+
−
        units.push({unit: u, priority: priorities[u]});
+
 
     }
 
     }
−
     units.sort(function (a, b) {
+
     function T(a) {
−
         return a.priority - b.priority;
+
         var b, c, d = a.match(pd);
−
    });
+
        for (b = 0,
−
    return units;
+
        c = d.length; c > b; b++)
−
}
+
            sd[d[b]] ? d[b] = sd[d[b]] : d[b] = S(d[b]);
−
 
+
         return function(b) {
−
function makeGetSet (unit, keepTime) {
+
             var e, f = "";
−
    return function (value) {
+
             for (e = 0; c > e; e++)
−
         if (value != null) {
+
                f += d[e]instanceof Function ? d[e].call(b, a) : d[e];
−
             set$1(this, unit, value);
+
            return f
−
             hooks.updateOffset(this, keepTime);
+
−
            return this;
+
−
        } else {
+
−
            return get(this, unit);
+
 
         }
 
         }
−
    };
 
−
}
 
−
 
−
function get (mom, unit) {
 
−
    return mom.isValid() ?
 
−
        mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
 
−
}
 
−
 
−
function set$1 (mom, unit, value) {
 
−
    if (mom.isValid()) {
 
−
        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
 
 
     }
 
     }
−
}
+
    function U(a, b) {
−
 
+
        return a.isValid() ? (b = V(b, a.localeData()),
−
// MOMENTS
+
        rd[b] = rd[b] || T(b),
−
 
+
         rd[b](a)) : a.localeData().invalidDate()
−
function stringGet (units) {
+
−
    units = normalizeUnits(units);
+
−
    if (isFunction(this[units])) {
+
−
         return this[units]();
+
 
     }
 
     }
−
     return this;
+
     function V(a, b) {
−
}
+
         function c(a) {
−
 
+
             return b.longDateFormat(a) || a
−
 
+
−
function stringSet (units, value) {
+
−
    if (typeof units === 'object') {
+
−
         units = normalizeObjectUnits(units);
+
−
        var prioritized = getPrioritizedUnits(units);
+
−
        for (var i = 0; i < prioritized.length; i++) {
+
−
             this[prioritized[i].unit](units[prioritized[i].unit]);
+
 
         }
 
         }
−
    } else {
+
        var d = 5;
−
         units = normalizeUnits(units);
+
         for (qd.lastIndex = 0; d >= 0 && qd.test(a); )
−
        if (isFunction(this[units])) {
+
            a = a.replace(qd, c),
−
             return this[units](value);
+
            qd.lastIndex = 0,
 +
            d -= 1;
 +
        return a
 +
    }
 +
    function W(a, b, c) {
 +
        Kd[a] = w(b) ? b : function(a, d) {
 +
             return a && c ? c : b
 
         }
 
         }
 
     }
 
     }
−
     return this;
+
     function X(a, b) {
−
}
+
         return f(Kd, a) ? Kd[a](b._strict, b._locale) : new RegExp(Y(a))
−
 
+
−
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?|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;
+
−
 
+
−
var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
+
−
 
+
−
var formatFunctions = {};
+
−
 
+
−
var 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) {
+
     function Y(a) {
−
         formatTokenFunctions[token] = func;
+
         return Z(a.replace("\\", "").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function(a, b, c, d, e) {
 +
            return b || c || d || e
 +
        }))
 
     }
 
     }
−
     if (padded) {
+
     function Z(a) {
−
         formatTokenFunctions[padded[0]] = function () {
+
         return a.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")
−
            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
+
−
        };
+
 
     }
 
     }
−
     if (ordinal) {
+
     function $(a, b) {
−
         formatTokenFunctions[ordinal] = function () {
+
         var c, d = b;
−
             return this.localeData().ordinal(func.apply(this, arguments), token);
+
        for ("string" == typeof a && (a = [a]),
−
         };
+
        "number" == typeof b && (d = function(a, c) {
 +
             c[b] = r(a)
 +
        }
 +
        ),
 +
         c = 0; c < a.length; c++)
 +
            Ld[a[c]] = d
 
     }
 
     }
−
}
+
    function _(a, b) {
−
 
+
        $(a, function(a, c, d, e) {
−
function removeFormattingTokens(input) {
+
            d._w = d._w || {},
−
    if (input.match(/\[[\s\S]/)) {
+
            b(a, d._w, d, e)
−
        return input.replace(/^\[|\]$/g, '');
+
        })
 
     }
 
     }
−
     return input.replace(/\\/g, '');
+
     function aa(a, b, c) {
−
}
+
         null != b && f(Ld, a) && Ld[a](b, c._a, c, a)
−
 
+
−
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]);
+
−
        }
+
 
     }
 
     }
−
 
+
     function ba(a, b) {
−
     return function (mom) {
+
         return new Date(Date.UTC(a, b + 1, 0)).getUTCDate()
−
         var output = '', i;
+
−
        for (i = 0; i < length; i++) {
+
−
            output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
+
−
        }
+
−
        return output;
+
−
    };
+
−
}
+
−
 
+
−
// format date using native date object
+
−
function formatMoment(m, format) {
+
−
    if (!m.isValid()) {
+
−
        return m.localeData().invalidDate();
+
 
     }
 
     }
−
 
+
     function ca(a, b) {
−
     format = expandFormat(format, m.localeData());
+
        return c(this._months) ? this._months[a.month()] : this._months[Vd.test(b) ? "format" : "standalone"][a.month()]
−
    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
+
−
 
+
−
    return formatFunctions[format](m);
+
−
}
+
−
 
+
−
function expandFormat(format, locale) {
+
−
    var i = 5;
+
−
 
+
−
    function replaceLongDateFormatTokens(input) {
+
−
        return locale.longDateFormat(input) || input;
+
 
     }
 
     }
−
 
+
     function da(a, b) {
−
     localFormattingTokens.lastIndex = 0;
+
        return c(this._monthsShort) ? this._monthsShort[a.month()] : this._monthsShort[Vd.test(b) ? "format" : "standalone"][a.month()]
−
    while (i >= 0 && localFormattingTokens.test(format)) {
+
−
        format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
+
−
        localFormattingTokens.lastIndex = 0;
+
−
        i -= 1;
+
 
     }
 
     }
−
 
+
     function ea(a, b, c) {
−
     return format;
+
         var d, e, f, g = a.toLocaleLowerCase();
−
}
+
         if (!this._monthsParse)
−
 
+
            for (this._monthsParse = [],
−
var match1         = /\d/;            //      0 - 9
+
            this._longMonthsParse = [],
−
var match2        = /\d\d/;          //      00 - 99
+
            this._shortMonthsParse = [],
−
var match3        = /\d{3}/;         //    000 - 999
+
            d = 0; 12 > d; ++d)
−
var match4         = /\d{4}/;        //    0000 - 9999
+
                f = h([2e3, d]),
−
var match6        = /[+-]?\d{6}/;    // -999999 - 999999
+
                this._shortMonthsParse[d] = this.monthsShort(f, "").toLocaleLowerCase(),
−
var match1to2      = /\d\d?/;        //      0 - 99
+
                this._longMonthsParse[d] = this.months(f, "").toLocaleLowerCase();
−
var match3to4      = /\d\d\d\d?/;    //    999 - 9999
+
        return c ? "MMM" === b ? (e = md.call(this._shortMonthsParse, g),
−
var match5to6      = /\d\d\d\d\d\d?/; //  99999 - 999999
+
        -1 !== e ? e : null) : (e = md.call(this._longMonthsParse, g),
−
var match1to3      = /\d{1,3}/;      //      0 - 999
+
        -1 !== e ? e : null) : "MMM" === b ? (e = md.call(this._shortMonthsParse, g),
−
var match1to4      = /\d{1,4}/;      //      0 - 9999
+
         -1 !== e ? e : (e = md.call(this._longMonthsParse, g),
−
var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
+
        -1 !== e ? e : null)) : (e = md.call(this._longMonthsParse, g),
−
 
+
         -1 !== e ? e : (e = md.call(this._shortMonthsParse, g),
−
var matchUnsigned  = /\d+/;          //      0 - inf
+
        -1 !== e ? e : null))
−
var matchSigned    = /[+-]?\d+/;     //    -inf - inf
+
−
 
+
−
var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
+
−
var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
+
−
 
+
−
var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
+
−
 
+
−
// any word (or two) characters or numbers including two/three word month in arabic.
+
−
// includes scottish gaelic two word and hyphenated months
+
−
var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
+
−
 
+
−
 
+
−
var regexes = {};
+
−
 
+
−
function addRegexToken (token, regex, strictRegex) {
+
−
    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
+
−
         return (isStrict && strictRegex) ? strictRegex : regex;
+
−
    };
+
−
}
+
−
 
+
−
function getParseRegexForToken (token, config) {
+
−
    if (!hasOwnProp(regexes, token)) {
+
−
         return new RegExp(unescapeFormat(token));
+
 
     }
 
     }
−
 
+
     function fa(a, b, c) {
−
     return regexes[token](config._strict, config._locale);
+
        var d, e, f;
−
}
+
        if (this._monthsParseExact)
−
 
+
            return ea.call(this, a, b, c);
−
// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+
        for (this._monthsParse || (this._monthsParse = [],
−
function unescapeFormat(s) {
+
        this._longMonthsParse = [],
−
    return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
+
        this._shortMonthsParse = []),
−
        return p1 || p2 || p3 || p4;
+
        d = 0; 12 > d; d++) {
−
    }));
+
            if (e = h([2e3, d]),
−
}
+
            c && !this._longMonthsParse[d] && (this._longMonthsParse[d] = new RegExp("^" + this.months(e, "").replace(".", "") + "$","i"),
−
 
+
            this._shortMonthsParse[d] = new RegExp("^" + this.monthsShort(e, "").replace(".", "") + "$","i")),
−
function regexEscape(s) {
+
            c || this._monthsParse[d] || (f = "^" + this.months(e, "") + "|^" + this.monthsShort(e, ""),
−
    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+
            this._monthsParse[d] = new RegExp(f.replace(".", ""),"i")),
−
}
+
            c && "MMMM" === b && this._longMonthsParse[d].test(a))
−
 
+
                return d;
−
var tokens = {};
+
            if (c && "MMM" === b && this._shortMonthsParse[d].test(a))
−
 
+
                return d;
−
function addParseToken (token, callback) {
+
            if (!c && this._monthsParse[d].test(a))
−
    var i, func = callback;
+
                return d
−
    if (typeof token === 'string') {
+
        }
−
        token = [token];
+
 
     }
 
     }
−
     if (isNumber(callback)) {
+
     function ga(a, b) {
−
         func = function (input, array) {
+
        var c;
−
             array[callback] = toInt(input);
+
        if (!a.isValid())
−
         };
+
            return a;
 +
         if ("string" == typeof b)
 +
            if (/^\d+$/.test(b))
 +
                b = r(b);
 +
             else if (b = a.localeData().monthsParse(b),
 +
            "number" != typeof b)
 +
                return a;
 +
         return c = Math.min(a.date(), ba(a.year(), b)),
 +
        a._d["set" + (a._isUTC ? "UTC" : "") + "Month"](b, c),
 +
        a
 
     }
 
     }
−
     for (i = 0; i < token.length; i++) {
+
     function ha(b) {
−
         tokens[token[i]] = func;
+
         return null != b ? (ga(this, b),
 +
        a.updateOffset(this, !0),
 +
        this) : N(this, "Month")
 
     }
 
     }
−
}
+
     function ia() {
−
 
+
         return ba(this.year(), this.month())
−
function addWeekParseToken (token, callback) {
+
−
     addParseToken(token, function (input, array, config, token) {
+
−
         config._w = config._w || {};
+
−
        callback(input, config._w, config, token);
+
−
    });
+
−
}
+
−
 
+
−
function addTimeToArrayFromToken(token, input, config) {
+
−
    if (input != null && hasOwnProp(tokens, token)) {
+
−
        tokens[token](input, config._a, config, token);
+
 
     }
 
     }
−
}
+
     function ja(a) {
−
 
+
         return this._monthsParseExact ? (f(this, "_monthsRegex") || la.call(this),
−
var YEAR = 0;
+
        a ? this._monthsShortStrictRegex : this._monthsShortRegex) : this._monthsShortStrictRegex && a ? this._monthsShortStrictRegex : this._monthsShortRegex
−
var MONTH = 1;
+
−
var DATE = 2;
+
−
var HOUR = 3;
+
−
var MINUTE = 4;
+
−
var SECOND = 5;
+
−
var MILLISECOND = 6;
+
−
var WEEK = 7;
+
−
var WEEKDAY = 8;
+
−
 
+
−
var indexOf;
+
−
 
+
−
if (Array.prototype.indexOf) {
+
−
     indexOf = Array.prototype.indexOf;
+
−
} else {
+
−
    indexOf = function (o) {
+
−
         // I know
+
−
        var i;
+
−
        for (i = 0; i < this.length; ++i) {
+
−
            if (this[i] === o) {
+
−
                return i;
+
−
            }
+
−
        }
+
−
        return -1;
+
−
    };
+
−
}
+
−
 
+
−
var indexOf$1 = indexOf;
+
−
 
+
−
function daysInMonth(year, month) {
+
−
    return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+
−
}
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('M', ['MM', 2], 'Mo', function () {
+
−
    return this.month() + 1;
+
−
});
+
−
 
+
−
addFormatToken('MMM', 0, 0, function (format) {
+
−
    return this.localeData().monthsShort(this, format);
+
−
});
+
−
 
+
−
addFormatToken('MMMM', 0, 0, function (format) {
+
−
    return this.localeData().months(this, format);
+
−
});
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('month', 'M');
+
−
 
+
−
// PRIORITY
+
−
 
+
−
addUnitPriority('month', 8);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('M',    match1to2);
+
−
addRegexToken('MM',  match1to2, match2);
+
−
addRegexToken('MMM',  function (isStrict, locale) {
+
−
    return locale.monthsShortRegex(isStrict);
+
−
});
+
−
addRegexToken('MMMM', function (isStrict, locale) {
+
−
    return locale.monthsRegex(isStrict);
+
−
});
+
−
 
+
−
addParseToken(['M', 'MM'], function (input, array) {
+
−
    array[MONTH] = toInt(input) - 1;
+
−
});
+
−
 
+
−
addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
+
−
    var month = config._locale.monthsParse(input, token, config._strict);
+
−
    // if we didn't find a month name, mark the date as invalid.
+
−
    if (month != null) {
+
−
        array[MONTH] = month;
+
−
    } else {
+
−
        getParsingFlags(config).invalidMonth = input;
+
 
     }
 
     }
−
});
+
    function ka(a) {
−
 
+
        return this._monthsParseExact ? (f(this, "_monthsRegex") || la.call(this),
−
// LOCALES
+
         a ? this._monthsStrictRegex : this._monthsRegex) : this._monthsStrictRegex && a ? this._monthsStrictRegex : this._monthsRegex
−
 
+
−
var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
+
−
var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
+
−
function localeMonths (m, format) {
+
−
    if (!m) {
+
−
         return isArray(this._months) ? this._months :
+
−
            this._months['standalone'];
+
 
     }
 
     }
−
     return isArray(this._months) ? this._months[m.month()] :
+
     function la() {
−
        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
+
         function a(a, b) {
−
}
+
             return b.length - a.length
−
 
+
−
var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
+
−
function localeMonthsShort (m, format) {
+
−
    if (!m) {
+
−
         return isArray(this._monthsShort) ? this._monthsShort :
+
−
            this._monthsShort['standalone'];
+
−
    }
+
−
    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
+
−
        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
+
−
}
+
−
 
+
−
function handleStrictParse(monthName, format, strict) {
+
−
    var i, ii, mom, llc = monthName.toLocaleLowerCase();
+
−
    if (!this._monthsParse) {
+
−
        // this is not used
+
−
        this._monthsParse = [];
+
−
        this._longMonthsParse = [];
+
−
        this._shortMonthsParse = [];
+
−
        for (i = 0; i < 12; ++i) {
+
−
             mom = createUTC([2000, i]);
+
−
            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
+
−
            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
+
 
         }
 
         }
 +
        var b, c, d = [], e = [], f = [];
 +
        for (b = 0; 12 > b; b++)
 +
            c = h([2e3, b]),
 +
            d.push(this.monthsShort(c, "")),
 +
            e.push(this.months(c, "")),
 +
            f.push(this.months(c, "")),
 +
            f.push(this.monthsShort(c, ""));
 +
        for (d.sort(a),
 +
        e.sort(a),
 +
        f.sort(a),
 +
        b = 0; 12 > b; b++)
 +
            d[b] = Z(d[b]),
 +
            e[b] = Z(e[b]),
 +
            f[b] = Z(f[b]);
 +
        this._monthsRegex = new RegExp("^(" + f.join("|") + ")","i"),
 +
        this._monthsShortRegex = this._monthsRegex,
 +
        this._monthsStrictRegex = new RegExp("^(" + e.join("|") + ")","i"),
 +
        this._monthsShortStrictRegex = new RegExp("^(" + d.join("|") + ")","i")
 
     }
 
     }
−
 
+
     function ma(a) {
−
     if (strict) {
+
         var b, c = a._a;
−
         if (format === 'MMM') {
+
        return c && -2 === j(a).overflow && (b = c[Nd] < 0 || c[Nd] > 11 ? Nd : c[Od] < 1 || c[Od] > ba(c[Md], c[Nd]) ? Od : c[Pd] < 0 || c[Pd] > 24 || 24 === c[Pd] && (0 !== c[Qd] || 0 !== c[Rd] || 0 !== c[Sd]) ? Pd : c[Qd] < 0 || c[Qd] > 59 ? Qd : c[Rd] < 0 || c[Rd] > 59 ? Rd : c[Sd] < 0 || c[Sd] > 999 ? Sd : -1,
−
            ii = indexOf$1.call(this._shortMonthsParse, llc);
+
         j(a)._overflowDayOfYear && (Md > b || b > Od) && (b = Od),
−
            return ii !== -1 ? ii : null;
+
        j(a)._overflowWeeks && -1 === b && (b = Td),
−
         } else {
+
        j(a)._overflowWeekday && -1 === b && (b = Ud),
−
            ii = indexOf$1.call(this._longMonthsParse, llc);
+
        j(a).overflow = b),
−
             return ii !== -1 ? ii : null;
+
        a
−
        }
+
    }
−
    } else {
+
    function na(a) {
−
        if (format === 'MMM') {
+
        var b, c, d, e, f, g, h = a._i, i = $d.exec(h) || _d.exec(h);
−
            ii = indexOf$1.call(this._shortMonthsParse, llc);
+
        if (i) {
−
             if (ii !== -1) {
+
             for (j(a).iso = !0,
−
                 return ii;
+
            b = 0,
 +
            c = be.length; c > b; b++)
 +
                if (be[b][1].exec(i[1])) {
 +
                    e = be[b][0],
 +
                    d = be[b][2] !== !1;
 +
                    break
 +
                }
 +
            if (null == e)
 +
                return void (a._isValid = !1);
 +
             if (i[3]) {
 +
                for (b = 0,
 +
                c = ce.length; c > b; b++)
 +
                    if (ce[b][1].exec(i[3])) {
 +
                        f = (i[2] || " ") + ce[b][0];
 +
                        break
 +
                    }
 +
                 if (null == f)
 +
                    return void (a._isValid = !1)
 
             }
 
             }
−
             ii = indexOf$1.call(this._longMonthsParse, llc);
+
             if (!d && null != f)
−
            return ii !== -1 ? ii : null;
+
                return void (a._isValid = !1);
−
        } else {
+
             if (i[4]) {
−
             ii = indexOf$1.call(this._longMonthsParse, llc);
+
                if (!ae.exec(i[4]))
−
            if (ii !== -1) {
+
                    return void (a._isValid = !1);
−
                 return ii;
+
                 g = "Z"
 
             }
 
             }
−
             ii = indexOf$1.call(this._shortMonthsParse, llc);
+
             a._f = e + (f || "") + (g || ""),
−
             return ii !== -1 ? ii : null;
+
             Ca(a)
−
         }
+
         } else
 +
            a._isValid = !1
 
     }
 
     }
−
}
+
    function oa(b) {
−
 
+
        var c = de.exec(b._i);
−
function localeMonthsParse (monthName, format, strict) {
+
        return null !== c ? void (b._d = new Date(+c[1])) : (na(b),
−
    var i, mom, regex;
+
         void (b._isValid === !1 && (delete b._isValid,
−
 
+
        a.createFromInputFallback(b))))
−
    if (this._monthsParseExact) {
+
−
         return handleStrictParse.call(this, monthName, format, strict);
+
 
     }
 
     }
−
 
+
     function pa(a, b, c, d, e, f, g) {
−
     if (!this._monthsParse) {
+
         var h = new Date(a,b,c,d,e,f,g);
−
         this._monthsParse = [];
+
         return 100 > a && a >= 0 && isFinite(h.getFullYear()) && h.setFullYear(a),
−
         this._longMonthsParse = [];
+
         h
−
         this._shortMonthsParse = [];
+
 
     }
 
     }
−
 
+
     function qa(a) {
−
     // TODO: add sorting
+
         var b = new Date(Date.UTC.apply(null, arguments));
−
    // Sorting makes sure if one month (or abbr) is a prefix of another
+
         return 100 > a && a >= 0 && isFinite(b.getUTCFullYear()) && b.setUTCFullYear(a),
−
    // see sorting in computeMonthsParse
+
         b
−
    for (i = 0; i < 12; i++) {
+
−
         // make the regex if we don't have it already
+
−
        mom = createUTC([2000, i]);
+
−
        if (strict && !this._longMonthsParse[i]) {
+
−
            this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
+
−
            this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
+
−
         }
+
−
        if (!strict && !this._monthsParse[i]) {
+
−
            regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+
−
            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+
−
        }
+
−
        // test the regex
+
−
        if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
+
−
            return i;
+
−
        } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
+
−
            return i;
+
−
        } else if (!strict && this._monthsParse[i].test(monthName)) {
+
−
            return i;
+
−
         }
+
 
     }
 
     }
−
}
+
    function ra(a) {
−
 
+
        return sa(a) ? 366 : 365
−
// MOMENTS
+
−
 
+
−
function setMonth (mom, value) {
+
−
    var dayOfMonth;
+
−
 
+
−
    if (!mom.isValid()) {
+
−
        // No op
+
−
        return mom;
+
 
     }
 
     }
−
 
+
     function sa(a) {
−
     if (typeof value === 'string') {
+
         return a % 4 === 0 && a % 100 !== 0 || a % 400 === 0
−
         if (/^\d+$/.test(value)) {
+
    }
−
            value = toInt(value);
+
    function ta() {
−
        } else {
+
        return sa(this.year())
−
            value = mom.localeData().monthsParse(value);
+
−
            // TODO: Another silent failure?
+
−
            if (!isNumber(value)) {
+
−
                return mom;
+
−
            }
+
−
        }
+
 
     }
 
     }
−
 
+
     function ua(a, b, c) {
−
     dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
+
        var d = 7 + b - c
−
    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+
          , e = (7 + qa(a, 0, d).getUTCDay() - b) % 7;
−
    return mom;
+
         return -e + d - 1
−
}
+
−
 
+
−
function getSetMonth (value) {
+
−
    if (value != null) {
+
−
        setMonth(this, value);
+
−
        hooks.updateOffset(this, true);
+
−
         return this;
+
−
    } else {
+
−
        return get(this, 'Month');
+
 
     }
 
     }
−
}
+
    function va(a, b, c, d, e) {
−
 
+
        var f, g, h = (7 + c - d) % 7, i = ua(a, d, e), j = 1 + 7 * (b - 1) + h + i;
−
function getDaysInMonth () {
+
        return 0 >= j ? (f = a - 1,
−
    return daysInMonth(this.year(), this.month());
+
        g = ra(f) + j) : j > ra(a) ? (f = a + 1,
−
}
+
         g = j - ra(a)) : (f = a,
−
 
+
        g = j),
−
var defaultMonthsShortRegex = matchWord;
+
        {
−
function monthsShortRegex (isStrict) {
+
             year: f,
−
    if (this._monthsParseExact) {
+
            dayOfYear: g
−
         if (!hasOwnProp(this, '_monthsRegex')) {
+
−
             computeMonthsParse.call(this);
+
 
         }
 
         }
−
        if (isStrict) {
 
−
            return this._monthsShortStrictRegex;
 
−
        } else {
 
−
            return this._monthsShortRegex;
 
−
        }
 
−
    } else {
 
−
        if (!hasOwnProp(this, '_monthsShortRegex')) {
 
−
            this._monthsShortRegex = defaultMonthsShortRegex;
 
−
        }
 
−
        return this._monthsShortStrictRegex && isStrict ?
 
−
            this._monthsShortStrictRegex : this._monthsShortRegex;
 
 
     }
 
     }
−
}
+
    function wa(a, b, c) {
−
 
+
        var d, e, f = ua(a.year(), b, c), g = Math.floor((a.dayOfYear() - f - 1) / 7) + 1;
−
var defaultMonthsRegex = matchWord;
+
        return 1 > g ? (e = a.year() - 1,
−
function monthsRegex (isStrict) {
+
         d = g + xa(e, b, c)) : g > xa(a.year(), b, c) ? (d = g - xa(a.year(), b, c),
−
    if (this._monthsParseExact) {
+
         e = a.year() + 1) : (e = a.year(),
−
        if (!hasOwnProp(this, '_monthsRegex')) {
+
         d = g),
−
            computeMonthsParse.call(this);
+
        {
−
        }
+
            week: d,
−
         if (isStrict) {
+
             year: e
−
            return this._monthsStrictRegex;
+
−
         } else {
+
−
            return this._monthsRegex;
+
−
         }
+
−
    } else {
+
−
        if (!hasOwnProp(this, '_monthsRegex')) {
+
−
             this._monthsRegex = defaultMonthsRegex;
+
 
         }
 
         }
−
        return this._monthsStrictRegex && isStrict ?
 
−
            this._monthsStrictRegex : this._monthsRegex;
 
 
     }
 
     }
−
}
+
    function xa(a, b, c) {
−
 
+
        var d = ua(a, b, c)
−
function computeMonthsParse () {
+
          , e = ua(a + 1, b, c);
−
    function cmpLenRev(a, b) {
+
         return (ra(a) - d + e) / 7
−
         return b.length - a.length;
+
 
     }
 
     }
−
 
+
     function ya(a, b, c) {
−
     var shortPieces = [], longPieces = [], mixedPieces = [],
+
         return null != a ? a : null != b ? b : c
−
        i, mom;
+
−
    for (i = 0; i < 12; i++) {
+
−
         // make the regex if we don't have it already
+
−
        mom = createUTC([2000, i]);
+
−
        shortPieces.push(this.monthsShort(mom, ''));
+
−
        longPieces.push(this.months(mom, ''));
+
−
        mixedPieces.push(this.months(mom, ''));
+
−
        mixedPieces.push(this.monthsShort(mom, ''));
+
 
     }
 
     }
−
     // Sorting makes sure if one month (or abbr) is a prefix of another it
+
     function za(b) {
−
    // will match the longer piece.
+
        var c = new Date(a.now());
−
    shortPieces.sort(cmpLenRev);
+
        return b._useUTC ? [c.getUTCFullYear(), c.getUTCMonth(), c.getUTCDate()] : [c.getFullYear(), c.getMonth(), c.getDate()]
−
    longPieces.sort(cmpLenRev);
+
−
    mixedPieces.sort(cmpLenRev);
+
−
    for (i = 0; i < 12; i++) {
+
−
        shortPieces[i] = regexEscape(shortPieces[i]);
+
−
        longPieces[i] = regexEscape(longPieces[i]);
+
 
     }
 
     }
−
     for (i = 0; i < 24; i++) {
+
     function Aa(a) {
−
        mixedPieces[i] = regexEscape(mixedPieces[i]);
+
        var b, c, d, e, f = [];
 +
        if (!a._d) {
 +
            for (d = za(a),
 +
            a._w && null == a._a[Od] && null == a._a[Nd] && Ba(a),
 +
            a._dayOfYear && (e = ya(a._a[Md], d[Md]),
 +
            a._dayOfYear > ra(e) && (j(a)._overflowDayOfYear = !0),
 +
            c = qa(e, 0, a._dayOfYear),
 +
            a._a[Nd] = c.getUTCMonth(),
 +
            a._a[Od] = c.getUTCDate()),
 +
            b = 0; 3 > b && null == a._a[b]; ++b)
 +
                a._a[b] = f[b] = d[b];
 +
            for (; 7 > b; b++)
 +
                a._a[b] = f[b] = null == a._a[b] ? 2 === b ? 1 : 0 : a._a[b];
 +
            24 === a._a[Pd] && 0 === a._a[Qd] && 0 === a._a[Rd] && 0 === a._a[Sd] && (a._nextDay = !0,
 +
            a._a[Pd] = 0),
 +
            a._d = (a._useUTC ? qa : pa).apply(null, f),
 +
            null != a._tzm && a._d.setUTCMinutes(a._d.getUTCMinutes() - a._tzm),
 +
            a._nextDay && (a._a[Pd] = 24)
 +
        }
 
     }
 
     }
−
 
+
     function Ba(a) {
−
     this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+
        var b, c, d, e, f, g, h, i;
−
    this._monthsShortRegex = this._monthsRegex;
+
        b = a._w,
−
    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
+
        null != b.GG || null != b.W || null != b.E ? (f = 1,
−
    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
+
        g = 4,
−
}
+
        c = ya(b.GG, a._a[Md], wa(Ka(), 1, 4).year),
−
 
+
        d = ya(b.W, 1),
−
// FORMATTING
+
        e = ya(b.E, 1),
−
 
+
        (1 > e || e > 7) && (i = !0)) : (f = a._locale._week.dow,
−
addFormatToken('Y', 0, 0, function () {
+
        g = a._locale._week.doy,
−
    var y = this.year();
+
        c = ya(b.gg, a._a[Md], wa(Ka(), f, g).year),
−
    return y <= 9999 ? '' + y : '+' + y;
+
        d = ya(b.w, 1),
−
});
+
        null != b.d ? (e = b.d,
−
 
+
        (0 > e || e > 6) && (i = !0)) : null != b.e ? (e = b.e + f,
−
addFormatToken(0, ['YY', 2], 0, function () {
+
        (b.e < 0 || b.e > 6) && (i = !0)) : e = f),
−
    return this.year() % 100;
+
        1 > d || d > xa(c, f, g) ? j(a)._overflowWeeks = !0 : null != i ? j(a)._overflowWeekday = !0 : (h = va(c, d, e, f, g),
−
});
+
        a._a[Md] = h.year,
−
 
+
        a._dayOfYear = h.dayOfYear)
−
addFormatToken(0, ['YYYY',   4],      0, 'year');
+
−
addFormatToken(0, ['YYYYY',  5],      0, 'year');
+
−
addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('year', 'y');
+
−
 
+
−
// PRIORITIES
+
−
 
+
−
addUnitPriority('year', 1);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('Y',     matchSigned);
+
−
addRegexToken('YY',    match1to2, match2);
+
−
addRegexToken('YYYY',  match1to4, match4);
+
−
addRegexToken('YYYYY',  match1to6, match6);
+
−
addRegexToken('YYYYYY', match1to6, match6);
+
−
 
+
−
addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+
−
addParseToken('YYYY', function (input, array) {
+
−
    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+
−
});
+
−
addParseToken('YY', function (input, array) {
+
−
    array[YEAR] = hooks.parseTwoDigitYear(input);
+
−
});
+
−
addParseToken('Y', function (input, array) {
+
−
    array[YEAR] = parseInt(input, 10);
+
−
});
+
−
 
+
−
// HELPERS
+
−
 
+
−
function daysInYear(year) {
+
−
    return isLeapYear(year) ? 366 : 365;
+
−
}
+
−
 
+
−
function isLeapYear(year) {
+
−
    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+
−
}
+
−
 
+
−
// HOOKS
+
−
 
+
−
hooks.parseTwoDigitYear = function (input) {
+
−
    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+
−
};
+
−
 
+
−
// MOMENTS
+
−
 
+
−
var getSetYear = makeGetSet('FullYear', true);
+
−
 
+
−
function getIsLeapYear () {
+
−
    return isLeapYear(this.year());
+
−
}
+
−
 
+
−
function createDate (y, m, d, h, M, s, ms) {
+
−
    // can't just apply() to create a date:
+
−
    // https://stackoverflow.com/q/181348
+
−
    var date = new Date(y, m, d, h, M, s, ms);
+
−
 
+
−
    // the date constructor remaps years 0-99 to 1900-1999
+
−
    if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
+
−
        date.setFullYear(y);
+
 
     }
 
     }
−
     return date;
+
     function Ca(b) {
−
}
+
        if (b._f === a.ISO_8601)
−
 
+
            return void na(b);
−
function createUTCDate (y) {
+
        b._a = [],
−
    var date = new Date(Date.UTC.apply(null, arguments));
+
        j(b).empty = !0;
−
 
+
        var c, d, e, f, g, h = "" + b._i, i = h.length, k = 0;
−
    // the Date.UTC function remaps years 0-99 to 1900-1999
+
        for (e = V(b._f, b._locale).match(pd) || [],
−
    if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
+
        c = 0; c < e.length; c++)
−
         date.setUTCFullYear(y);
+
            f = e[c],
 +
            d = (h.match(X(f, b)) || [])[0],
 +
            d && (g = h.substr(0, h.indexOf(d)),
 +
            g.length > 0 && j(b).unusedInput.push(g),
 +
            h = h.slice(h.indexOf(d) + d.length),
 +
            k += d.length),
 +
            sd[f] ? (d ? j(b).empty = !1 : j(b).unusedTokens.push(f),
 +
            aa(f, d, b)) : b._strict && !d && j(b).unusedTokens.push(f);
 +
        j(b).charsLeftOver = i - k,
 +
        h.length > 0 && j(b).unusedInput.push(h),
 +
        j(b).bigHour === !0 && b._a[Pd] <= 12 && b._a[Pd] > 0 && (j(b).bigHour = void 0),
 +
        j(b).parsedDateParts = b._a.slice(0),
 +
        j(b).meridiem = b._meridiem,
 +
         b._a[Pd] = Da(b._locale, b._a[Pd], b._meridiem),
 +
        Aa(b),
 +
        ma(b)
 
     }
 
     }
−
     return date;
+
     function Da(a, b, c) {
−
}
+
        var d;
−
 
+
         return null == c ? b : null != a.meridiemHour ? a.meridiemHour(b, c) : null != a.isPM ? (d = a.isPM(c),
−
// start-of-first-week - start-of-year
+
         d && 12 > b && (b += 12),
−
function firstWeekOffset(year, dow, doy) {
+
         d || 12 !== b || (b = 0),
−
    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+
         b) : b
−
         fwd = 7 + dow - doy,
+
−
        // first-week day local weekday -- which local weekday is fwd
+
−
        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+
−
 
+
−
    return -fwdlw + fwd - 1;
+
−
}
+
−
 
+
−
// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+
−
function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+
−
    var localWeekday = (7 + weekday - dow) % 7,
+
−
        weekOffset = firstWeekOffset(year, dow, doy),
+
−
         dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
+
−
        resYear, resDayOfYear;
+
−
 
+
−
    if (dayOfYear <= 0) {
+
−
         resYear = year - 1;
+
−
        resDayOfYear = daysInYear(resYear) + dayOfYear;
+
−
    } else if (dayOfYear > daysInYear(year)) {
+
−
         resYear = year + 1;
+
−
        resDayOfYear = dayOfYear - daysInYear(year);
+
−
    } else {
+
−
        resYear = year;
+
−
        resDayOfYear = dayOfYear;
+
 
     }
 
     }
−
 
+
     function Ea(a) {
−
     return {
+
         var b, c, d, e, f;
−
         year: resYear,
+
         if (0 === a._f.length)
−
         dayOfYear: resDayOfYear
+
            return j(a).invalidFormat = !0,
−
    };
+
            void (a._d = new Date(NaN));
−
}
+
         for (e = 0; e < a._f.length; e++)
−
 
+
            f = 0,
−
function weekOfYear(mom, dow, doy) {
+
            b = n({}, a),
−
    var weekOffset = firstWeekOffset(mom.year(), dow, doy),
+
            null != a._useUTC && (b._useUTC = a._useUTC),
−
         week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
+
            b._f = a._f[e],
−
        resWeek, resYear;
+
            Ca(b),
−
 
+
            k(b) && (f += j(b).charsLeftOver,
−
    if (week < 1) {
+
            f += 10 * j(b).unusedTokens.length,
−
        resYear = mom.year() - 1;
+
            j(b).score = f,
−
        resWeek = week + weeksInYear(resYear, dow, doy);
+
            (null == d || d > f) && (d = f,
−
    } else if (week > weeksInYear(mom.year(), dow, doy)) {
+
            c = b));
−
        resWeek = week - weeksInYear(mom.year(), dow, doy);
+
         g(a, c || b)
−
        resYear = mom.year() + 1;
+
−
    } else {
+
−
         resYear = mom.year();
+
−
        resWeek = week;
+
 
     }
 
     }
−
 
+
     function Fa(a) {
−
     return {
+
         if (!a._d) {
−
        week: resWeek,
+
            var b = L(a._i);
−
        year: resYear
+
            a._a = e([b.year, b.month, b.day || b.date, b.hour, b.minute, b.second, b.millisecond], function(a) {
−
    };
+
                return a && parseInt(a, 10)
−
}
+
            }),
−
 
+
            Aa(a)
−
function weeksInYear(year, dow, doy) {
+
         }
−
    var weekOffset = firstWeekOffset(year, dow, doy),
+
−
         weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+
−
    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+
−
}
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('w', ['ww', 2], 'wo', 'week');
+
−
addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('week', 'w');
+
−
addUnitAlias('isoWeek', 'W');
+
−
 
+
−
// PRIORITIES
+
−
 
+
−
addUnitPriority('week', 5);
+
−
addUnitPriority('isoWeek', 5);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('w',  match1to2);
+
−
addRegexToken('ww', match1to2, match2);
+
−
addRegexToken('W',  match1to2);
+
−
addRegexToken('WW', match1to2, match2);
+
−
 
+
−
addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
+
−
    week[token.substr(0, 1)] = toInt(input);
+
−
});
+
−
 
+
−
// HELPERS
+
−
 
+
−
// LOCALES
+
−
 
+
−
function localeWeek (mom) {
+
−
    return weekOfYear(mom, this._week.dow, this._week.doy).week;
+
−
}
+
−
 
+
−
var defaultLocaleWeek = {
+
−
    dow : 0, // Sunday is the first day of the week.
+
−
    doy : 6  // The week that contains Jan 1st is the first week of the year.
+
−
};
+
−
 
+
−
function localeFirstDayOfWeek () {
+
−
    return this._week.dow;
+
−
}
+
−
 
+
−
function localeFirstDayOfYear () {
+
−
    return this._week.doy;
+
−
}
+
−
 
+
−
// MOMENTS
+
−
 
+
−
function getSetWeek (input) {
+
−
    var week = this.localeData().week(this);
+
−
    return input == null ? week : this.add((input - week) * 7, 'd');
+
−
}
+
−
 
+
−
function getSetISOWeek (input) {
+
−
    var week = weekOfYear(this, 1, 4).week;
+
−
    return input == null ? week : this.add((input - week) * 7, 'd');
+
−
}
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('d', 0, 'do', 'day');
+
−
 
+
−
addFormatToken('dd', 0, 0, function (format) {
+
−
    return this.localeData().weekdaysMin(this, format);
+
−
});
+
−
 
+
−
addFormatToken('ddd', 0, 0, function (format) {
+
−
    return this.localeData().weekdaysShort(this, format);
+
−
});
+
−
 
+
−
addFormatToken('dddd', 0, 0, function (format) {
+
−
    return this.localeData().weekdays(this, format);
+
−
});
+
−
 
+
−
addFormatToken('e', 0, 0, 'weekday');
+
−
addFormatToken('E', 0, 0, 'isoWeekday');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('day', 'd');
+
−
addUnitAlias('weekday', 'e');
+
−
addUnitAlias('isoWeekday', 'E');
+
−
 
+
−
// PRIORITY
+
−
addUnitPriority('day', 11);
+
−
addUnitPriority('weekday', 11);
+
−
addUnitPriority('isoWeekday', 11);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('d',    match1to2);
+
−
addRegexToken('e',    match1to2);
+
−
addRegexToken('E',    match1to2);
+
−
addRegexToken('dd',  function (isStrict, locale) {
+
−
    return locale.weekdaysMinRegex(isStrict);
+
−
});
+
−
addRegexToken('ddd',   function (isStrict, locale) {
+
−
    return locale.weekdaysShortRegex(isStrict);
+
−
});
+
−
addRegexToken('dddd',   function (isStrict, locale) {
+
−
    return locale.weekdaysRegex(isStrict);
+
−
});
+
−
 
+
−
addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
+
−
    var weekday = config._locale.weekdaysParse(input, token, config._strict);
+
−
    // if we didn't get a weekday name, mark the date as invalid
+
−
    if (weekday != null) {
+
−
         week.d = weekday;
+
−
    } else {
+
−
        getParsingFlags(config).invalidWeekday = input;
+
 
     }
 
     }
−
});
+
    function Ga(a) {
−
 
+
        var b = new o(ma(Ha(a)));
−
addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
+
        return b._nextDay && (b.add(1, "d"),
−
    week[token] = toInt(input);
+
        b._nextDay = void 0),
−
});
+
         b
−
 
+
−
// HELPERS
+
−
 
+
−
function parseWeekday(input, locale) {
+
−
    if (typeof input !== 'string') {
+
−
         return input;
+
 
     }
 
     }
−
 
+
     function Ha(a) {
−
     if (!isNaN(input)) {
+
        var b = a._i
−
         return parseInt(input, 10);
+
          , e = a._f;
 +
        return a._locale = a._locale || H(a._l),
 +
        null === b || void 0 === e && "" === b ? l({
 +
            nullInput: !0
 +
        }) : ("string" == typeof b && (a._i = b = a._locale.preparse(b)),
 +
         p(b) ? new o(ma(b)) : (c(e) ? Ea(a) : e ? Ca(a) : d(b) ? a._d = b : Ia(a),
 +
        k(a) || (a._d = null),
 +
        a))
 
     }
 
     }
−
 
+
     function Ia(b) {
−
     input = locale.weekdaysParse(input);
+
        var f = b._i;
−
    if (typeof input === 'number') {
+
        void 0 === f ? b._d = new Date(a.now()) : d(f) ? b._d = new Date(f.valueOf()) : "string" == typeof f ? oa(b) : c(f) ? (b._a = e(f.slice(0), function(a) {
−
        return input;
+
            return parseInt(a, 10)
 +
        }),
 +
        Aa(b)) : "object" == typeof f ? Fa(b) : "number" == typeof f ? b._d = new Date(f) : a.createFromInputFallback(b)
 
     }
 
     }
−
 
+
     function Ja(a, b, c, d, e) {
−
     return null;
+
        var f = {};
−
}
+
        return "boolean" == typeof c && (d = c,
−
 
+
        c = void 0),
−
function parseIsoWeekday(input, locale) {
+
         f._isAMomentObject = !0,
−
    if (typeof input === 'string') {
+
        f._useUTC = f._isUTC = e,
−
         return locale.weekdaysParse(input) % 7 || 7;
+
        f._l = c,
 +
        f._i = a,
 +
        f._f = b,
 +
        f._strict = d,
 +
        Ga(f)
 
     }
 
     }
−
     return isNaN(input) ? null : input;
+
     function Ka(a, b, c, d) {
−
}
+
         return Ja(a, b, c, d, !1)
−
 
+
−
// LOCALES
+
−
 
+
−
var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
+
−
function localeWeekdays (m, format) {
+
−
    if (!m) {
+
−
         return isArray(this._weekdays) ? this._weekdays :
+
−
            this._weekdays['standalone'];
+
 
     }
 
     }
−
     return isArray(this._weekdays) ? this._weekdays[m.day()] :
+
     function La(a, b) {
−
         this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
+
         var d, e;
−
}
+
        if (1 === b.length && c(b[0]) && (b = b[0]),
−
 
+
        !b.length)
−
var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
+
            return Ka();
−
function localeWeekdaysShort (m) {
+
         for (d = b[0],
−
    return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
+
         e = 1; e < b.length; ++e)
−
}
+
             (!b[e].isValid() || b[e][a](d)) && (d = b[e]);
−
 
+
         return d
−
var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
+
−
function localeWeekdaysMin (m) {
+
−
    return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
+
−
}
+
−
 
+
−
function handleStrictParse$1(weekdayName, format, strict) {
+
−
    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
+
−
    if (!this._weekdaysParse) {
+
−
        this._weekdaysParse = [];
+
−
         this._shortWeekdaysParse = [];
+
−
         this._minWeekdaysParse = [];
+
−
 
+
−
        for (i = 0; i < 7; ++i) {
+
−
             mom = createUTC([2000, 1]).day(i);
+
−
            this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
+
−
            this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
+
−
            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
+
−
         }
+
 
     }
 
     }
−
 
+
     function Ma() {
−
     if (strict) {
+
         var a = [].slice.call(arguments, 0);
−
         if (format === 'dddd') {
+
         return La("isBefore", a)
−
            ii = indexOf$1.call(this._weekdaysParse, llc);
+
−
            return ii !== -1 ? ii : null;
+
−
        } else if (format === 'ddd') {
+
−
            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+
−
            return ii !== -1 ? ii : null;
+
−
         } else {
+
−
            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+
−
            return ii !== -1 ? ii : null;
+
−
        }
+
−
    } else {
+
−
        if (format === 'dddd') {
+
−
            ii = indexOf$1.call(this._weekdaysParse, llc);
+
−
            if (ii !== -1) {
+
−
                return ii;
+
−
            }
+
−
            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+
−
            if (ii !== -1) {
+
−
                return ii;
+
−
            }
+
−
            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+
−
            return ii !== -1 ? ii : null;
+
−
        } else if (format === 'ddd') {
+
−
            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+
−
            if (ii !== -1) {
+
−
                return ii;
+
−
            }
+
−
            ii = indexOf$1.call(this._weekdaysParse, llc);
+
−
            if (ii !== -1) {
+
−
                return ii;
+
−
            }
+
−
            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+
−
            return ii !== -1 ? ii : null;
+
−
        } else {
+
−
            ii = indexOf$1.call(this._minWeekdaysParse, llc);
+
−
            if (ii !== -1) {
+
−
                return ii;
+
−
            }
+
−
            ii = indexOf$1.call(this._weekdaysParse, llc);
+
−
            if (ii !== -1) {
+
−
                return ii;
+
−
            }
+
−
            ii = indexOf$1.call(this._shortWeekdaysParse, llc);
+
−
            return ii !== -1 ? ii : null;
+
−
        }
+
 
     }
 
     }
−
}
+
    function Na() {
−
 
+
        var a = [].slice.call(arguments, 0);
−
function localeWeekdaysParse (weekdayName, format, strict) {
+
         return La("isAfter", a)
−
    var i, mom, regex;
+
−
 
+
−
    if (this._weekdaysParseExact) {
+
−
         return handleStrictParse$1.call(this, weekdayName, format, strict);
+
 
     }
 
     }
−
 
+
     function Oa(a) {
−
     if (!this._weekdaysParse) {
+
         var b = L(a)
−
         this._weekdaysParse = [];
+
          , c = b.year || 0
−
         this._minWeekdaysParse = [];
+
          , d = b.quarter || 0
−
         this._shortWeekdaysParse = [];
+
          , e = b.month || 0
−
         this._fullWeekdaysParse = [];
+
          , f = b.week || 0
 +
          , g = b.day || 0
 +
          , h = b.hour || 0
 +
          , i = b.minute || 0
 +
          , j = b.second || 0
 +
          , k = b.millisecond || 0;
 +
         this._milliseconds = +k + 1e3 * j + 6e4 * i + 1e3 * h * 60 * 60,
 +
         this._days = +g + 7 * f,
 +
         this._months = +e + 3 * d + 12 * c,
 +
        this._data = {},
 +
        this._locale = H(),
 +
        this._bubble()
 
     }
 
     }
−
 
+
     function Pa(a) {
−
     for (i = 0; i < 7; i++) {
+
         return a instanceof Oa
−
         // make the regex if we don't have it already
+
−
 
+
−
        mom = createUTC([2000, 1]).day(i);
+
−
        if (strict && !this._fullWeekdaysParse[i]) {
+
−
            this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
+
−
            this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
+
−
            this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
+
−
        }
+
−
        if (!this._weekdaysParse[i]) {
+
−
            regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
+
−
            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
+
−
        }
+
−
        // test the regex
+
−
        if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
+
−
            return i;
+
−
        } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
+
−
            return i;
+
−
        } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
+
−
            return i;
+
−
        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
+
−
            return i;
+
−
        }
+
 
     }
 
     }
−
}
+
    function Qa(a, b) {
−
 
+
        R(a, 0, 0, function() {
−
// MOMENTS
+
            var a = this.utcOffset()
−
 
+
              , c = "+";
−
function getSetDayOfWeek (input) {
+
            return 0 > a && (a = -a,
−
    if (!this.isValid()) {
+
            c = "-"),
−
        return input != null ? this : NaN;
+
            c + Q(~~(a / 60), 2) + b + Q(~~a % 60, 2)
 +
        })
 
     }
 
     }
−
     var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+
     function Ra(a, b) {
−
    if (input != null) {
+
        var c = (b || "").match(a) || []
−
        input = parseWeekday(input, this.localeData());
+
          , d = c[c.length - 1] || []
−
        return this.add(input - day, 'd');
+
          , e = (d + "").match(ie) || ["-", 0, 0]
−
    } else {
+
          , f = +(60 * e[1]) + r(e[2]);
−
         return day;
+
         return "+" === e[0] ? f : -f
 
     }
 
     }
−
}
+
    function Sa(b, c) {
−
 
+
        var e, f;
−
function getSetLocaleDayOfWeek (input) {
+
        return c._isUTC ? (e = c.clone(),
−
    if (!this.isValid()) {
+
         f = (p(b) || d(b) ? b.valueOf() : Ka(b).valueOf()) - e.valueOf(),
−
         return input != null ? this : NaN;
+
        e._d.setTime(e._d.valueOf() + f),
 +
        a.updateOffset(e, !1),
 +
        e) : Ka(b).local()
 
     }
 
     }
−
     var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+
     function Ta(a) {
−
    return input == null ? weekday : this.add(input - weekday, 'd');
+
        return 15 * -Math.round(a._d.getTimezoneOffset() / 15)
−
}
+
−
 
+
−
function getSetISODayOfWeek (input) {
+
−
    if (!this.isValid()) {
+
−
        return input != null ? this : NaN;
+
 
     }
 
     }
−
 
+
     function Ua(b, c) {
−
     // behaves the same as moment#day except
+
        var d, e = this._offset || 0;
−
    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
+
        return this.isValid() ? null != b ? ("string" == typeof b ? b = Ra(Hd, b) : Math.abs(b) < 16 && (b = 60 * b),
−
    // as a setter, sunday should belong to the previous week.
+
        !this._isUTC && c && (d = Ta(this)),
−
 
+
        this._offset = b,
−
    if (input != null) {
+
        this._isUTC = !0,
−
         var weekday = parseIsoWeekday(input, this.localeData());
+
        null != d && this.add(d, "m"),
−
        return this.day(this.day() % 7 ? weekday : weekday - 7);
+
         e !== b && (!c || this._changeInProgress ? jb(this, db(b - e, "m"), 1, !1) : this._changeInProgress || (this._changeInProgress = !0,
−
    } else {
+
        a.updateOffset(this, !0),
−
         return this.day() || 7;
+
        this._changeInProgress = null)),
 +
         this) : this._isUTC ? e : Ta(this) : null != b ? this : NaN
 
     }
 
     }
−
}
+
    function Va(a, b) {
−
 
+
         return null != a ? ("string" != typeof a && (a = -a),
−
var defaultWeekdaysRegex = matchWord;
+
         this.utcOffset(a, b),
−
function weekdaysRegex (isStrict) {
+
         this) : -this.utcOffset()
−
    if (this._weekdaysParseExact) {
+
−
         if (!hasOwnProp(this, '_weekdaysRegex')) {
+
−
            computeWeekdaysParse.call(this);
+
−
         }
+
−
        if (isStrict) {
+
−
            return this._weekdaysStrictRegex;
+
−
        } else {
+
−
            return this._weekdaysRegex;
+
−
        }
+
−
    } else {
+
−
        if (!hasOwnProp(this, '_weekdaysRegex')) {
+
−
            this._weekdaysRegex = defaultWeekdaysRegex;
+
−
         }
+
−
        return this._weekdaysStrictRegex && isStrict ?
+
−
            this._weekdaysStrictRegex : this._weekdaysRegex;
+
 
     }
 
     }
−
}
+
    function Wa(a) {
−
 
+
         return this.utcOffset(0, a)
−
var defaultWeekdaysShortRegex = matchWord;
+
−
function weekdaysShortRegex (isStrict) {
+
−
    if (this._weekdaysParseExact) {
+
−
         if (!hasOwnProp(this, '_weekdaysRegex')) {
+
−
            computeWeekdaysParse.call(this);
+
−
        }
+
−
        if (isStrict) {
+
−
            return this._weekdaysShortStrictRegex;
+
−
        } else {
+
−
            return this._weekdaysShortRegex;
+
−
        }
+
−
    } else {
+
−
        if (!hasOwnProp(this, '_weekdaysShortRegex')) {
+
−
            this._weekdaysShortRegex = defaultWeekdaysShortRegex;
+
−
        }
+
−
        return this._weekdaysShortStrictRegex && isStrict ?
+
−
            this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
+
 
     }
 
     }
−
}
+
    function Xa(a) {
−
 
+
        return this._isUTC && (this.utcOffset(0, a),
−
var defaultWeekdaysMinRegex = matchWord;
+
         this._isUTC = !1,
−
function weekdaysMinRegex (isStrict) {
+
         a && this.subtract(Ta(this), "m")),
−
    if (this._weekdaysParseExact) {
+
         this
−
        if (!hasOwnProp(this, '_weekdaysRegex')) {
+
−
            computeWeekdaysParse.call(this);
+
−
         }
+
−
        if (isStrict) {
+
−
            return this._weekdaysMinStrictRegex;
+
−
         } else {
+
−
            return this._weekdaysMinRegex;
+
−
        }
+
−
    } else {
+
−
        if (!hasOwnProp(this, '_weekdaysMinRegex')) {
+
−
            this._weekdaysMinRegex = defaultWeekdaysMinRegex;
+
−
         }
+
−
        return this._weekdaysMinStrictRegex && isStrict ?
+
−
            this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
+
 
     }
 
     }
−
}
+
     function Ya() {
−
 
+
         return this._tzm ? this.utcOffset(this._tzm) : "string" == typeof this._i && this.utcOffset(Ra(Gd, this._i)),
−
 
+
        this
−
function computeWeekdaysParse () {
+
−
     function cmpLenRev(a, b) {
+
−
         return b.length - a.length;
+
 
     }
 
     }
−
 
+
     function Za(a) {
−
     var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
+
         return this.isValid() ? (a = a ? Ka(a).utcOffset() : 0,
−
        i, mom, minp, shortp, longp;
+
         (this.utcOffset() - a) % 60 === 0) : !1
−
    for (i = 0; i < 7; i++) {
+
−
         // make the regex if we don't have it already
+
−
        mom = createUTC([2000, 1]).day(i);
+
−
        minp = this.weekdaysMin(mom, '');
+
−
        shortp = this.weekdaysShort(mom, '');
+
−
        longp = this.weekdays(mom, '');
+
−
        minPieces.push(minp);
+
−
         shortPieces.push(shortp);
+
−
        longPieces.push(longp);
+
−
        mixedPieces.push(minp);
+
−
        mixedPieces.push(shortp);
+
−
        mixedPieces.push(longp);
+
 
     }
 
     }
−
     // Sorting makes sure if one weekday (or abbr) is a prefix of another it
+
     function $a() {
−
    // will match the longer piece.
+
        return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset()
−
    minPieces.sort(cmpLenRev);
+
−
    shortPieces.sort(cmpLenRev);
+
−
    longPieces.sort(cmpLenRev);
+
−
    mixedPieces.sort(cmpLenRev);
+
−
    for (i = 0; i < 7; i++) {
+
−
        shortPieces[i] = regexEscape(shortPieces[i]);
+
−
        longPieces[i] = regexEscape(longPieces[i]);
+
−
        mixedPieces[i] = regexEscape(mixedPieces[i]);
+
 
     }
 
     }
−
 
+
     function _a() {
−
     this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+
        if (!m(this._isDSTShifted))
−
    this._weekdaysShortRegex = this._weekdaysRegex;
+
            return this._isDSTShifted;
−
    this._weekdaysMinRegex = this._weekdaysRegex;
+
        var a = {};
−
 
+
         if (n(a, this),
−
    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
+
         a = Ha(a),
−
    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
+
         a._a) {
−
    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
+
            var b = a._isUTC ? h(a._a) : Ka(a._a);
−
}
+
            this._isDSTShifted = this.isValid() && s(a._a, b.toArray()) > 0
−
 
+
        } else
−
// FORMATTING
+
            this._isDSTShifted = !1;
−
 
+
        return this._isDSTShifted
−
function hFormat() {
+
−
    return this.hours() % 12 || 12;
+
−
}
+
−
 
+
−
function kFormat() {
+
−
    return this.hours() || 24;
+
−
}
+
−
 
+
−
addFormatToken('H', ['HH', 2], 0, 'hour');
+
−
addFormatToken('h', ['hh', 2], 0, hFormat);
+
−
addFormatToken('k', ['kk', 2], 0, kFormat);
+
−
 
+
−
addFormatToken('hmm', 0, 0, function () {
+
−
    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
+
−
});
+
−
 
+
−
addFormatToken('hmmss', 0, 0, function () {
+
−
    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
+
−
         zeroFill(this.seconds(), 2);
+
−
});
+
−
 
+
−
addFormatToken('Hmm', 0, 0, function () {
+
−
    return '' + this.hours() + zeroFill(this.minutes(), 2);
+
−
});
+
−
 
+
−
addFormatToken('Hmmss', 0, 0, function () {
+
−
    return '' + this.hours() + zeroFill(this.minutes(), 2) +
+
−
         zeroFill(this.seconds(), 2);
+
−
});
+
−
 
+
−
function meridiem (token, lowercase) {
+
−
    addFormatToken(token, 0, 0, function () {
+
−
         return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
+
−
    });
+
−
}
+
−
 
+
−
meridiem('a', true);
+
−
meridiem('A', false);
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('hour', 'h');
+
−
 
+
−
// PRIORITY
+
−
addUnitPriority('hour', 13);
+
−
 
+
−
// PARSING
+
−
 
+
−
function matchMeridiem (isStrict, locale) {
+
−
    return locale._meridiemParse;
+
−
}
+
−
 
+
−
addRegexToken('a',  matchMeridiem);
+
−
addRegexToken('A',  matchMeridiem);
+
−
addRegexToken('H',  match1to2);
+
−
addRegexToken('h',  match1to2);
+
−
addRegexToken('k',  match1to2);
+
−
addRegexToken('HH', match1to2, match2);
+
−
addRegexToken('hh', match1to2, match2);
+
−
addRegexToken('kk', match1to2, match2);
+
−
 
+
−
addRegexToken('hmm', match3to4);
+
−
addRegexToken('hmmss', match5to6);
+
−
addRegexToken('Hmm', match3to4);
+
−
addRegexToken('Hmmss', match5to6);
+
−
 
+
−
addParseToken(['H', 'HH'], HOUR);
+
−
addParseToken(['k', 'kk'], function (input, array, config) {
+
−
    var kInput = toInt(input);
+
−
    array[HOUR] = kInput === 24 ? 0 : kInput;
+
−
});
+
−
addParseToken(['a', 'A'], function (input, array, config) {
+
−
    config._isPm = config._locale.isPM(input);
+
−
    config._meridiem = input;
+
−
});
+
−
addParseToken(['h', 'hh'], function (input, array, config) {
+
−
    array[HOUR] = toInt(input);
+
−
    getParsingFlags(config).bigHour = true;
+
−
});
+
−
addParseToken('hmm', function (input, array, config) {
+
−
    var pos = input.length - 2;
+
−
    array[HOUR] = toInt(input.substr(0, pos));
+
−
    array[MINUTE] = toInt(input.substr(pos));
+
−
    getParsingFlags(config).bigHour = true;
+
−
});
+
−
addParseToken('hmmss', function (input, array, config) {
+
−
    var pos1 = input.length - 4;
+
−
    var pos2 = input.length - 2;
+
−
    array[HOUR] = toInt(input.substr(0, pos1));
+
−
    array[MINUTE] = toInt(input.substr(pos1, 2));
+
−
    array[SECOND] = toInt(input.substr(pos2));
+
−
    getParsingFlags(config).bigHour = true;
+
−
});
+
−
addParseToken('Hmm', function (input, array, config) {
+
−
    var pos = input.length - 2;
+
−
    array[HOUR] = toInt(input.substr(0, pos));
+
−
    array[MINUTE] = toInt(input.substr(pos));
+
−
});
+
−
addParseToken('Hmmss', function (input, array, config) {
+
−
    var pos1 = input.length - 4;
+
−
    var pos2 = input.length - 2;
+
−
    array[HOUR] = toInt(input.substr(0, pos1));
+
−
    array[MINUTE] = toInt(input.substr(pos1, 2));
+
−
    array[SECOND] = toInt(input.substr(pos2));
+
−
});
+
−
 
+
−
// LOCALES
+
−
 
+
−
function localeIsPM (input) {
+
−
    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
+
−
    // Using charAt should be more compatible.
+
−
    return ((input + '').toLowerCase().charAt(0) === 'p');
+
−
}
+
−
 
+
−
var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
+
−
function localeMeridiem (hours, minutes, isLower) {
+
−
    if (hours > 11) {
+
−
        return isLower ? 'pm' : 'PM';
+
−
    } else {
+
−
        return isLower ? 'am' : 'AM';
+
 
     }
 
     }
−
}
+
     function ab() {
−
 
+
        return this.isValid() ? !this._isUTC : !1
−
 
+
−
// MOMENTS
+
−
 
+
−
// Setting the hour should keep the time, because the user explicitly
+
−
// specified which hour he wants. So trying to maintain the same hour (in
+
−
// a new timezone) makes sense. Adding/subtracting hours does not follow
+
−
// this rule.
+
−
var getSetHour = makeGetSet('Hours', true);
+
−
 
+
−
// months
+
−
// week
+
−
// weekdays
+
−
// meridiem
+
−
var baseConfig = {
+
−
     calendar: defaultCalendar,
+
−
    longDateFormat: defaultLongDateFormat,
+
−
    invalidDate: defaultInvalidDate,
+
−
    ordinal: defaultOrdinal,
+
−
    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+
−
    relativeTime: defaultRelativeTime,
+
−
 
+
−
    months: defaultLocaleMonths,
+
−
    monthsShort: defaultLocaleMonthsShort,
+
−
 
+
−
    week: defaultLocaleWeek,
+
−
 
+
−
    weekdays: defaultLocaleWeekdays,
+
−
    weekdaysMin: defaultLocaleWeekdaysMin,
+
−
    weekdaysShort: defaultLocaleWeekdaysShort,
+
−
 
+
−
    meridiemParse: defaultLocaleMeridiemParse
+
−
};
+
−
 
+
−
// internal storage for locale config files
+
−
var locales = {};
+
−
var localeFamilies = {};
+
−
var globalLocale;
+
−
 
+
−
function normalizeLocale(key) {
+
−
    return key ? key.toLowerCase().replace('_', '-') : key;
+
−
}
+
−
 
+
−
// pick the locale from the array
+
−
// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+
−
// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
+
−
function chooseLocale(names) {
+
−
    var i = 0, j, next, locale, split;
+
−
 
+
−
    while (i < names.length) {
+
−
        split = normalizeLocale(names[i]).split('-');
+
−
        j = split.length;
+
−
        next = normalizeLocale(names[i + 1]);
+
−
        next = next ? next.split('-') : null;
+
−
        while (j > 0) {
+
−
            locale = loadLocale(split.slice(0, j).join('-'));
+
−
            if (locale) {
+
−
                return locale;
+
−
            }
+
−
            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
+
−
                //the next array item is better than a shallower substring of this one
+
−
                break;
+
−
            }
+
−
            j--;
+
−
        }
+
−
        i++;
+
 
     }
 
     }
−
     return null;
+
     function bb() {
−
}
+
         return this.isValid() ? this._isUTC : !1
−
 
+
−
function loadLocale(name) {
+
−
    var oldLocale = null;
+
−
    // TODO: Find a better way to register and load all the locales in Node
+
−
    if (!locales[name] && (typeof module !== 'undefined') &&
+
−
            module && module.exports) {
+
−
         try {
+
−
            oldLocale = globalLocale._abbr;
+
−
            require('./locale/' + name);
+
−
            // because defineLocale currently also sets the global locale, we
+
−
            // want to undo that for lazy loaded locales
+
−
            getSetGlobalLocale(oldLocale);
+
−
        } catch (e) { }
+
 
     }
 
     }
−
     return locales[name];
+
     function cb() {
−
}
+
         return this.isValid() ? this._isUTC && 0 === this._offset : !1
−
 
+
−
// This function will load locale and then set the global locale.  If
+
−
// no arguments are passed in, it will simply return the current global
+
−
// locale key.
+
−
function getSetGlobalLocale (key, values) {
+
−
    var data;
+
−
    if (key) {
+
−
         if (isUndefined(values)) {
+
−
            data = getLocale(key);
+
−
        }
+
−
        else {
+
−
            data = defineLocale(key, values);
+
−
        }
+
−
 
+
−
        if (data) {
+
−
            // moment.duration._locale = moment._locale = data;
+
−
            globalLocale = data;
+
−
        }
+
 
     }
 
     }
−
 
+
     function db(a, b) {
−
     return globalLocale._abbr;
+
         var c, d, e, g = a, h = null;
−
}
+
         return Pa(a) ? g = {
−
 
+
             ms: a._milliseconds,
−
function defineLocale (name, config) {
+
            d: a._days,
−
    if (config !== null) {
+
            M: a._months
−
         var parentConfig = baseConfig;
+
        } : "number" == typeof a ? (g = {},
−
        config.abbr = name;
+
        b ? g[b] = a : g.milliseconds = a) : (h = je.exec(a)) ? (c = "-" === h[1] ? -1 : 1,
−
         if (locales[name] != null) {
+
         g = {
−
             deprecateSimple('defineLocaleOverride',
+
             y: 0,
−
                    'use moment.updateLocale(localeName, config) to change ' +
+
            d: r(h[Od]) * c,
−
                    'an existing locale. moment.defineLocale(localeName, ' +
+
            h: r(h[Pd]) * c,
−
                    'config) should only be used for creating a new locale ' +
+
             m: r(h[Qd]) * c,
−
                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
+
            s: r(h[Rd]) * c,
−
            parentConfig = locales[name]._config;
+
            ms: r(h[Sd]) * c
−
         } else if (config.parentLocale != null) {
+
        }) : (h = ke.exec(a)) ? (c = "-" === h[1] ? -1 : 1,
−
             if (locales[config.parentLocale] != null) {
+
        g = {
−
                parentConfig = locales[config.parentLocale]._config;
+
            y: eb(h[2], c),
−
             } else {
+
            M: eb(h[3], c),
−
                if (!localeFamilies[config.parentLocale]) {
+
             w: eb(h[4], c),
−
                    localeFamilies[config.parentLocale] = [];
+
            d: eb(h[5], c),
−
                }
+
            h: eb(h[6], c),
−
                localeFamilies[config.parentLocale].push({
+
             m: eb(h[7], c),
−
                    name: name,
+
            s: eb(h[8], c)
−
                    config: config
+
        }) : null == g ? g = {} : "object" == typeof g && ("from"in g || "to"in g) && (e = gb(Ka(g.from), Ka(g.to)),
−
                });
+
         g = {},
−
                return null;
+
         g.ms = e.milliseconds,
−
             }
+
         g.M = e.months),
−
        }
+
         d = new Oa(g),
−
        locales[name] = new Locale(mergeConfigs(parentConfig, config));
+
         Pa(a) && f(a, "_locale") && (d._locale = a._locale),
−
 
+
         d
−
        if (localeFamilies[name]) {
+
−
             localeFamilies[name].forEach(function (x) {
+
−
                defineLocale(x.name, x.config);
+
−
            });
+
−
         }
+
−
 
+
−
         // backwards compat for now: also set the locale
+
−
         // make sure we set the locale AFTER all child locales have been
+
−
         // created, so we won't end up with the child locale set.
+
−
         getSetGlobalLocale(name);
+
−
 
+
−
 
+
−
         return locales[name];
+
−
    } else {
+
−
        // useful for testing
+
−
        delete locales[name];
+
−
        return null;
+
 
     }
 
     }
−
}
+
    function eb(a, b) {
−
 
+
         var c = a && parseFloat(a.replace(",", "."));
−
function updateLocale(name, config) {
+
         return (isNaN(c) ? 0 : c) * b
−
    if (config != null) {
+
−
         var locale, parentConfig = baseConfig;
+
−
        // MERGE
+
−
        if (locales[name] != null) {
+
−
            parentConfig = locales[name]._config;
+
−
        }
+
−
        config = mergeConfigs(parentConfig, config);
+
−
        locale = new Locale(config);
+
−
         locale.parentLocale = locales[name];
+
−
        locales[name] = locale;
+
−
 
+
−
        // backwards compat for now: also set the locale
+
−
        getSetGlobalLocale(name);
+
−
    } else {
+
−
        // pass null for config to unupdate, useful for tests
+
−
        if (locales[name] != null) {
+
−
            if (locales[name].parentLocale != null) {
+
−
                locales[name] = locales[name].parentLocale;
+
−
            } else if (locales[name] != null) {
+
−
                delete locales[name];
+
−
            }
+
−
        }
+
 
     }
 
     }
−
     return locales[name];
+
     function fb(a, b) {
−
}
+
        var c = {
−
 
+
            milliseconds: 0,
−
// returns locale data
+
            months: 0
−
function getLocale (key) {
+
        };
−
    var locale;
+
        return c.months = b.month() - a.month() + 12 * (b.year() - a.year()),
−
 
+
        a.clone().add(c.months, "M").isAfter(b) && --c.months,
−
    if (key && key._locale && key._locale._abbr) {
+
         c.milliseconds = +b - +a.clone().add(c.months, "M"),
−
         key = key._locale._abbr;
+
         c
−
    }
+
−
 
+
−
    if (!key) {
+
−
         return globalLocale;
+
 
     }
 
     }
−
 
+
     function gb(a, b) {
−
     if (!isArray(key)) {
+
         var c;
−
         //short-circuit everything else
+
         return a.isValid() && b.isValid() ? (b = Sa(b, a),
−
         locale = loadLocale(key);
+
         a.isBefore(b) ? c = fb(a, b) : (c = fb(b, a),
−
         if (locale) {
+
        c.milliseconds = -c.milliseconds,
−
             return locale;
+
        c.months = -c.months),
 +
        c) : {
 +
             milliseconds: 0,
 +
            months: 0
 
         }
 
         }
−
        key = [key];
 
 
     }
 
     }
−
 
+
     function hb(a) {
−
     return chooseLocale(key);
+
         return 0 > a ? -1 * Math.round(-1 * a) : Math.round(a)
−
}
+
−
 
+
−
function listLocales() {
+
−
    return keys$1(locales);
+
−
}
+
−
 
+
−
function checkOverflow (m) {
+
−
    var overflow;
+
−
    var a = m._a;
+
−
 
+
−
    if (a && getParsingFlags(m).overflow === -2) {
+
−
         overflow =
+
−
            a[MONTH]      < 0 || a[MONTH]      > 11  ? MONTH :
+
−
            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
+
−
            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
+
−
            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
+
−
            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
+
−
            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
+
−
            -1;
+
−
 
+
−
        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+
−
            overflow = DATE;
+
−
        }
+
−
        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
+
−
            overflow = WEEK;
+
−
        }
+
−
        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
+
−
            overflow = WEEKDAY;
+
−
        }
+
−
 
+
−
        getParsingFlags(m).overflow = overflow;
+
 
     }
 
     }
−
 
+
     function ib(a, b) {
−
     return m;
+
        return function(c, d) {
−
}
+
            var e, f;
−
 
+
            return null === d || isNaN(+d) || (v(b, "moment()." + b + "(period, number) is deprecated. Please use moment()." + b + "(number, period)."),
−
// iso 8601 regex
+
            f = c,
−
// 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)
+
            c = d,
−
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)?)?$/;
+
            d = f),
−
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)?)?$/;
+
            c = "string" == typeof c ? +c : c,
−
 
+
            e = db(c, d),
−
var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
+
            jb(this, e, a),
−
 
+
             this
−
var isoDates = [
+
−
    ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
+
−
    ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
+
−
    ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
+
−
    ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
+
−
    ['YYYY-DDD', /\d{4}-\d{3}/],
+
−
    ['YYYY-MM', /\d{4}-\d\d/, false],
+
−
    ['YYYYYYMMDD', /[+-]\d{10}/],
+
−
    ['YYYYMMDD', /\d{8}/],
+
−
    // YYYYMM is NOT allowed by the standard
+
−
    ['GGGG[W]WWE', /\d{4}W\d{3}/],
+
−
    ['GGGG[W]WW', /\d{4}W\d{2}/, false],
+
−
    ['YYYYDDD', /\d{7}/]
+
−
];
+
−
 
+
−
// iso time formats and regexes
+
−
var isoTimes = [
+
−
    ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
+
−
    ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
+
−
    ['HH:mm:ss', /\d\d:\d\d:\d\d/],
+
−
    ['HH:mm', /\d\d:\d\d/],
+
−
    ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
+
−
    ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
+
−
    ['HHmmss', /\d\d\d\d\d\d/],
+
−
    ['HHmm', /\d\d\d\d/],
+
−
    ['HH', /\d\d/]
+
−
];
+
−
 
+
−
var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
+
−
 
+
−
// date from iso format
+
−
function configFromISO(config) {
+
−
    var i, l,
+
−
        string = config._i,
+
−
        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
+
−
        allowTime, dateFormat, timeFormat, tzFormat;
+
−
 
+
−
    if (match) {
+
−
        getParsingFlags(config).iso = true;
+
−
 
+
−
        for (i = 0, l = isoDates.length; i < l; i++) {
+
−
            if (isoDates[i][1].exec(match[1])) {
+
−
                dateFormat = isoDates[i][0];
+
−
                allowTime = isoDates[i][2] !== false;
+
−
                break;
+
−
             }
+
 
         }
 
         }
−
        if (dateFormat == null) {
 
−
            config._isValid = false;
 
−
            return;
 
−
        }
 
−
        if (match[3]) {
 
−
            for (i = 0, l = isoTimes.length; i < l; i++) {
 
−
                if (isoTimes[i][1].exec(match[3])) {
 
−
                    // match[2] should be 'T' or space
 
−
                    timeFormat = (match[2] || ' ') + isoTimes[i][0];
 
−
                    break;
 
−
                }
 
−
            }
 
−
            if (timeFormat == null) {
 
−
                config._isValid = false;
 
−
                return;
 
−
            }
 
−
        }
 
−
        if (!allowTime && timeFormat != null) {
 
−
            config._isValid = false;
 
−
            return;
 
−
        }
 
−
        if (match[4]) {
 
−
            if (tzRegex.exec(match[4])) {
 
−
                tzFormat = 'Z';
 
−
            } else {
 
−
                config._isValid = false;
 
−
                return;
 
−
            }
 
−
        }
 
−
        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
 
−
        configFromStringAndFormat(config);
 
−
    } else {
 
−
        config._isValid = false;
 
 
     }
 
     }
−
}
+
    function jb(b, c, d, e) {
−
 
+
         var f = c._milliseconds
−
// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
+
          , g = hb(c._days)
−
var basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d?\d\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?:\d\d)?\d\d\s)(\d\d:\d\d)(\:\d\d)?(\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\d{4}))$/;
+
          , h = hb(c._months);
−
 
+
        b.isValid() && (e = null == e ? !0 : e,
−
// date and time from ref 2822 format
+
         f && b._d.setTime(b._d.valueOf() + f * d),
−
function configFromRFC2822(config) {
+
         g && O(b, "Date", N(b, "Date") + g * d),
−
    var string, match, dayFormat,
+
         h && ga(b, N(b, "Month") + h * d),
−
        dateFormat, timeFormat, tzFormat;
+
         e && a.updateOffset(b, g || h))
−
    var timezones = {
+
−
         ' GMT': ' +0000',
+
−
        ' EDT': ' -0400',
+
−
        ' EST': ' -0500',
+
−
        ' CDT': ' -0500',
+
−
        ' CST': ' -0600',
+
−
        ' MDT': ' -0600',
+
−
        ' MST': ' -0700',
+
−
        ' PDT': ' -0700',
+
−
        ' PST': ' -0800'
+
−
    };
+
−
    var military = 'YXWVUTSRQPONZABCDEFGHIKLM';
+
−
    var timezone, timezoneIndex;
+
−
 
+
−
    string = config._i
+
−
        .replace(/\([^\)]*\)|[\n\t]/g, ' ') // Remove comments and folding whitespace
+
−
        .replace(/(\s\s+)/g, ' ') // Replace multiple-spaces with a single space
+
−
        .replace(/^\s|\s$/g, ''); // Remove leading and trailing spaces
+
−
    match = basicRfcRegex.exec(string);
+
−
 
+
−
    if (match) {
+
−
        dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';
+
−
         dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');
+
−
        timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');
+
−
 
+
−
         // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
+
−
        if (match[1]) { // day of week given
+
−
            var momentDate = new Date(match[2]);
+
−
            var momentDay = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][momentDate.getDay()];
+
−
 
+
−
            if (match[1].substr(0,3) !== momentDay) {
+
−
                getParsingFlags(config).weekdayMismatch = true;
+
−
                config._isValid = false;
+
−
                return;
+
−
            }
+
−
         }
+
−
 
+
−
        switch (match[5].length) {
+
−
            case 2: // military
+
−
                if (timezoneIndex === 0) {
+
−
                    timezone = ' +0000';
+
−
                } else {
+
−
                    timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;
+
−
                    timezone = ((timezoneIndex < 0) ? ' -' : ' +') +
+
−
                        (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';
+
−
                }
+
−
                break;
+
−
            case 4: // Zone
+
−
                timezone = timezones[match[5]];
+
−
                break;
+
−
            default: // UT or +/-9999
+
−
                timezone = timezones[' GMT'];
+
−
         }
+
−
        match[5] = timezone;
+
−
        config._i = match.splice(1).join('');
+
−
        tzFormat = ' ZZ';
+
−
        config._f = dayFormat + dateFormat + timeFormat + tzFormat;
+
−
        configFromStringAndFormat(config);
+
−
        getParsingFlags(config).rfc2822 = true;
+
−
    } else {
+
−
        config._isValid = false;
+
 
     }
 
     }
−
}
+
    function kb(a, b) {
−
 
+
        var c = a || Ka()
−
// date from iso format or fallback
+
          , d = Sa(c, this).startOf("day")
−
function configFromString(config) {
+
          , e = this.diff(d, "days", !0)
−
    var matched = aspNetJsonRegex.exec(config._i);
+
          , f = -6 > e ? "sameElse" : -1 > e ? "lastWeek" : 0 > e ? "lastDay" : 1 > e ? "sameDay" : 2 > e ? "nextDay" : 7 > e ? "nextWeek" : "sameElse"
−
 
+
          , g = b && (w(b[f]) ? b[f]() : b[f]);
−
    if (matched !== null) {
+
         return this.format(g || this.localeData().calendar(f, this, Ka(c)))
−
        config._d = new Date(+matched[1]);
+
−
         return;
+
 
     }
 
     }
−
 
+
     function lb() {
−
     configFromISO(config);
+
         return new o(this)
−
    if (config._isValid === false) {
+
−
        delete config._isValid;
+
−
    } else {
+
−
         return;
+
 
     }
 
     }
−
 
+
     function mb(a, b) {
−
     configFromRFC2822(config);
+
        var c = p(a) ? a : Ka(a);
−
    if (config._isValid === false) {
+
        return this.isValid() && c.isValid() ? (b = K(m(b) ? "millisecond" : b),
−
         delete config._isValid;
+
         "millisecond" === b ? this.valueOf() > c.valueOf() : c.valueOf() < this.clone().startOf(b).valueOf()) : !1
−
    } else {
+
−
        return;
+
 
     }
 
     }
−
 
+
     function nb(a, b) {
−
     // Final attempt, use Input Fallback
+
        var c = p(a) ? a : Ka(a);
−
    hooks.createFromInputFallback(config);
+
        return this.isValid() && c.isValid() ? (b = K(m(b) ? "millisecond" : b),
−
}
+
        "millisecond" === b ? this.valueOf() < c.valueOf() : this.clone().endOf(b).valueOf() < c.valueOf()) : !1
−
 
+
−
hooks.createFromInputFallback = deprecate(
+
−
    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
+
−
    'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
+
−
    'discouraged and will be removed in an upcoming major release. Please refer to ' +
+
−
    'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
+
−
    function (config) {
+
−
        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+
 
     }
 
     }
−
);
+
    function ob(a, b, c, d) {
−
 
+
        return d = d || "()",
−
// Pick the first defined of two or three arguments.
+
         ("(" === d[0] ? this.isAfter(a, c) : !this.isBefore(a, c)) && (")" === d[1] ? this.isBefore(b, c) : !this.isAfter(b, c))
−
function defaults(a, b, c) {
+
−
    if (a != null) {
+
−
         return a;
+
 
     }
 
     }
−
     if (b != null) {
+
     function pb(a, b) {
−
         return b;
+
        var c, d = p(a) ? a : Ka(a);
 +
         return this.isValid() && d.isValid() ? (b = K(b || "millisecond"),
 +
        "millisecond" === b ? this.valueOf() === d.valueOf() : (c = d.valueOf(),
 +
        this.clone().startOf(b).valueOf() <= c && c <= this.clone().endOf(b).valueOf())) : !1
 
     }
 
     }
−
     return c;
+
     function qb(a, b) {
−
}
+
         return this.isSame(a, b) || this.isAfter(a, b)
−
 
+
−
function currentDateArray(config) {
+
−
    // hooks is actually the exported moment object
+
−
    var nowValue = new Date(hooks.now());
+
−
    if (config._useUTC) {
+
−
         return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
+
 
     }
 
     }
−
     return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
+
     function rb(a, b) {
−
}
+
        return this.isSame(a, b) || this.isBefore(a, b)
−
 
+
−
// convert an array to a date.
+
−
// the array should mirror the parameters below
+
−
// note: all values past the year are optional and will default to the lowest possible value.
+
−
// [year, month, day , hour, minute, second, millisecond]
+
−
function configFromArray (config) {
+
−
    var i, date, input = [], currentDate, yearToUse;
+
−
 
+
−
    if (config._d) {
+
−
        return;
+
 
     }
 
     }
−
 
+
     function sb(a, b, c) {
−
     currentDate = currentDateArray(config);
+
        var d, e, f, g;
−
 
+
        return this.isValid() ? (d = Sa(a, this),
−
    //compute day of the year from weeks and weekdays
+
        d.isValid() ? (e = 6e4 * (d.utcOffset() - this.utcOffset()),
−
    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+
        b = K(b),
−
         dayOfYearFromWeekInfo(config);
+
        "year" === b || "month" === b || "quarter" === b ? (g = tb(this, d),
 +
        "quarter" === b ? g /= 3 : "year" === b && (g /= 12)) : (f = this - d,
 +
        g = "second" === b ? f / 1e3 : "minute" === b ? f / 6e4 : "hour" === b ? f / 36e5 : "day" === b ? (f - e) / 864e5 : "week" === b ? (f - e) / 6048e5 : f),
 +
         c ? g : q(g)) : NaN) : NaN
 
     }
 
     }
−
 
+
     function tb(a, b) {
−
     //if the day of the year is set, figure out what it is
+
         var c, d, e = 12 * (b.year() - a.year()) + (b.month() - a.month()), f = a.clone().add(e, "months");
−
    if (config._dayOfYear != null) {
+
         return 0 > b - f ? (c = a.clone().add(e - 1, "months"),
−
         yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+
         d = (b - f) / (f - c)) : (c = a.clone().add(e + 1, "months"),
−
 
+
         d = (b - f) / (c - f)),
−
        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
+
        -(e + d) || 0
−
            getParsingFlags(config)._overflowDayOfYear = true;
+
−
         }
+
−
 
+
−
        date = createUTCDate(yearToUse, 0, config._dayOfYear);
+
−
         config._a[MONTH] = date.getUTCMonth();
+
−
         config._a[DATE] = date.getUTCDate();
+
 
     }
 
     }
−
 
+
     function ub() {
−
     // Default to current date.
+
         return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")
−
    // * if no year, month, day of month are given, default to today
+
−
    // * if day of month is given, default month and year
+
−
    // * if month is given, default only year
+
−
    // * if year is given, don't default anything
+
−
    for (i = 0; i < 3 && config._a[i] == null; ++i) {
+
−
         config._a[i] = input[i] = currentDate[i];
+
 
     }
 
     }
−
 
+
     function vb() {
−
    // Zero out whatever was not defaulted, including time
+
         var a = this.clone().utc();
−
     for (; i < 7; i++) {
+
        return 0 < a.year() && a.year() <= 9999 ? w(Date.prototype.toISOString) ? this.toDate().toISOString() : U(a, "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]") : U(a, "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]")
−
         config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+
 
     }
 
     }
−
 
+
     function wb(b) {
−
     // Check for 24:00:00.000
+
        b || (b = this.isUtc() ? a.defaultFormatUtc : a.defaultFormat);
−
    if (config._a[HOUR] === 24 &&
+
         var c = U(this, b);
−
            config._a[MINUTE] === 0 &&
+
         return this.localeData().postformat(c)
−
            config._a[SECOND] === 0 &&
+
−
            config._a[MILLISECOND] === 0) {
+
−
         config._nextDay = true;
+
−
         config._a[HOUR] = 0;
+
 
     }
 
     }
−
 
+
     function xb(a, b) {
−
     config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
+
        return this.isValid() && (p(a) && a.isValid() || Ka(a).isValid()) ? db({
−
    // Apply timezone offset from input. The actual utcOffset can be changed
+
            to: this,
−
    // with parseZone.
+
            from: a
−
    if (config._tzm != null) {
+
        }).locale(this.locale()).humanize(!b) : this.localeData().invalidDate()
−
        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+
 
     }
 
     }
−
 
+
     function yb(a) {
−
     if (config._nextDay) {
+
         return this.from(Ka(), a)
−
         config._a[HOUR] = 24;
+
 
     }
 
     }
−
}
+
    function zb(a, b) {
−
 
+
         return this.isValid() && (p(a) && a.isValid() || Ka(a).isValid()) ? db({
−
function dayOfYearFromWeekInfo(config) {
+
             from: this,
−
    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
+
            to: a
−
 
+
         }).locale(this.locale()).humanize(!b) : this.localeData().invalidDate()
−
    w = config._w;
+
−
    if (w.GG != null || w.W != null || w.E != null) {
+
−
         dow = 1;
+
−
        doy = 4;
+
−
 
+
−
        // TODO: We need to take the current isoWeekYear, but that depends on
+
−
        // how we interpret now (local, utc, fixed offset). So create
+
−
        // a now version of current config (take local/utc/offset flags, and
+
−
        // create now).
+
−
        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
+
−
        week = defaults(w.W, 1);
+
−
        weekday = defaults(w.E, 1);
+
−
        if (weekday < 1 || weekday > 7) {
+
−
             weekdayOverflow = true;
+
−
         }
+
−
    } else {
+
−
        dow = config._locale._week.dow;
+
−
        doy = config._locale._week.doy;
+
−
 
+
−
        var curWeek = weekOfYear(createLocal(), dow, doy);
+
−
 
+
−
        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
+
−
 
+
−
        // Default to current week.
+
−
        week = defaults(w.w, curWeek.week);
+
−
 
+
−
        if (w.d != null) {
+
−
            // weekday -- low day numbers are considered next week
+
−
            weekday = w.d;
+
−
            if (weekday < 0 || weekday > 6) {
+
−
                weekdayOverflow = true;
+
−
            }
+
−
        } else if (w.e != null) {
+
−
            // local weekday -- counting starts from begining of week
+
−
            weekday = w.e + dow;
+
−
            if (w.e < 0 || w.e > 6) {
+
−
                weekdayOverflow = true;
+
−
            }
+
−
        } else {
+
−
            // default to begining of week
+
−
            weekday = dow;
+
−
        }
+
 
     }
 
     }
−
     if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
+
     function Ab(a) {
−
         getParsingFlags(config)._overflowWeeks = true;
+
         return this.to(Ka(), a)
−
    } else if (weekdayOverflow != null) {
+
−
        getParsingFlags(config)._overflowWeekday = true;
+
−
    } else {
+
−
        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
+
−
        config._a[YEAR] = temp.year;
+
−
        config._dayOfYear = temp.dayOfYear;
+
 
     }
 
     }
−
}
+
    function Bb(a) {
−
 
+
        var b;
−
// constant that refers to the ISO standard
+
        return void 0 === a ? this._locale._abbr : (b = H(a),
−
hooks.ISO_8601 = function () {};
+
        null != b && (this._locale = b),
−
 
+
         this)
−
// constant that refers to the RFC 2822 form
+
−
hooks.RFC_2822 = function () {};
+
−
 
+
−
// date from string and format string
+
−
function configFromStringAndFormat(config) {
+
−
    // TODO: Move this to another part of the creation flow to prevent circular deps
+
−
    if (config._f === hooks.ISO_8601) {
+
−
         configFromISO(config);
+
−
        return;
+
 
     }
 
     }
−
     if (config._f === hooks.RFC_2822) {
+
     function Cb() {
−
        configFromRFC2822(config);
+
         return this._locale
−
         return;
+
 
     }
 
     }
−
     config._a = [];
+
     function Db(a) {
−
    getParsingFlags(config).empty = true;
+
         switch (a = K(a)) {
−
 
+
         case "year":
−
    // This array is used to make a Date, either with `new Date` or `Date.UTC`
+
             this.month(0);
−
    var string = '' + config._i,
+
        case "quarter":
−
        i, parsedInput, tokens, token, skipped,
+
        case "month":
−
        stringLength = string.length,
+
             this.date(1);
−
        totalParsedInputLength = 0;
+
        case "week":
−
 
+
         case "isoWeek":
−
    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
+
         case "day":
−
 
+
         case "date":
−
    for (i = 0; i < tokens.length; i++) {
+
             this.hours(0);
−
         token = tokens[i];
+
        case "hour":
−
        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
+
             this.minutes(0);
−
         // console.log('token', token, 'parsedInput', parsedInput,
+
        case "minute":
−
        //        'regex', getParseRegexForToken(token, config));
+
             this.seconds(0);
−
        if (parsedInput) {
+
         case "second":
−
             skipped = string.substr(0, string.indexOf(parsedInput));
+
             this.milliseconds(0)
−
            if (skipped.length > 0) {
+
−
                getParsingFlags(config).unusedInput.push(skipped);
+
−
             }
+
−
            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
+
−
            totalParsedInputLength += parsedInput.length;
+
−
         }
+
−
         // don't parse if it's not a known token
+
−
         if (formatTokenFunctions[token]) {
+
−
             if (parsedInput) {
+
−
                getParsingFlags(config).empty = false;
+
−
            }
+
−
             else {
+
−
                getParsingFlags(config).unusedTokens.push(token);
+
−
            }
+
−
             addTimeToArrayFromToken(token, parsedInput, config);
+
−
         }
+
−
        else if (config._strict && !parsedInput) {
+
−
             getParsingFlags(config).unusedTokens.push(token);
+
 
         }
 
         }
 +
        return "week" === a && this.weekday(0),
 +
        "isoWeek" === a && this.isoWeekday(1),
 +
        "quarter" === a && this.month(3 * Math.floor(this.month() / 3)),
 +
        this
 
     }
 
     }
−
 
+
     function Eb(a) {
−
     // add remaining unparsed input length to the string
+
        return a = K(a),
−
    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
+
        void 0 === a || "millisecond" === a ? this : ("date" === a && (a = "day"),
−
    if (string.length > 0) {
+
         this.startOf(a).add(1, "isoWeek" === a ? "week" : a).subtract(1, "ms"))
−
         getParsingFlags(config).unusedInput.push(string);
+
 
     }
 
     }
−
 
+
     function Fb() {
−
    // clear _12h flag if hour is <= 12
+
         return this._d.valueOf() - 6e4 * (this._offset || 0)
−
     if (config._a[HOUR] <= 12 &&
+
−
         getParsingFlags(config).bigHour === true &&
+
−
        config._a[HOUR] > 0) {
+
−
        getParsingFlags(config).bigHour = undefined;
+
 
     }
 
     }
−
 
+
     function Gb() {
−
     getParsingFlags(config).parsedDateParts = config._a.slice(0);
+
        return Math.floor(this.valueOf() / 1e3)
−
    getParsingFlags(config).meridiem = config._meridiem;
+
−
    // handle meridiem
+
−
    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
+
−
 
+
−
    configFromArray(config);
+
−
    checkOverflow(config);
+
−
}
+
−
 
+
−
 
+
−
function meridiemFixWrap (locale, hour, meridiem) {
+
−
    var isPm;
+
−
 
+
−
    if (meridiem == null) {
+
−
        // nothing to do
+
−
        return hour;
+
 
     }
 
     }
−
     if (locale.meridiemHour != null) {
+
     function Hb() {
−
         return locale.meridiemHour(hour, meridiem);
+
         return this._offset ? new Date(this.valueOf()) : this._d
−
    } else if (locale.isPM != null) {
+
−
        // Fallback
+
−
        isPm = locale.isPM(meridiem);
+
−
        if (isPm && hour < 12) {
+
−
            hour += 12;
+
−
        }
+
−
        if (!isPm && hour === 12) {
+
−
            hour = 0;
+
−
        }
+
−
        return hour;
+
−
    } else {
+
−
        // this is not supposed to happen
+
−
        return hour;
+
 
     }
 
     }
−
}
+
    function Ib() {
−
 
+
        var a = this;
−
// date from string and array of format strings
+
         return [a.year(), a.month(), a.date(), a.hour(), a.minute(), a.second(), a.millisecond()]
−
function configFromStringAndArray(config) {
+
−
    var tempConfig,
+
−
         bestMoment,
+
−
 
+
−
        scoreToBeat,
+
−
        i,
+
−
        currentScore;
+
−
 
+
−
    if (config._f.length === 0) {
+
−
        getParsingFlags(config).invalidFormat = true;
+
−
        config._d = new Date(NaN);
+
−
        return;
+
 
     }
 
     }
−
 
+
     function Jb() {
−
     for (i = 0; i < config._f.length; i++) {
+
         var a = this;
−
         currentScore = 0;
+
         return {
−
         tempConfig = copyConfig({}, config);
+
            years: a.year(),
−
        if (config._useUTC != null) {
+
             months: a.month(),
−
             tempConfig._useUTC = config._useUTC;
+
            date: a.date(),
−
        }
+
            hours: a.hours(),
−
        tempConfig._f = config._f[i];
+
             minutes: a.minutes(),
−
        configFromStringAndFormat(tempConfig);
+
            seconds: a.seconds(),
−
 
+
            milliseconds: a.milliseconds()
−
        if (!isValid(tempConfig)) {
+
−
             continue;
+
−
        }
+
−
 
+
−
        // if there is any input that was not parsed add a penalty for that format
+
−
        currentScore += getParsingFlags(tempConfig).charsLeftOver;
+
−
 
+
−
        //or tokens
+
−
        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
+
−
 
+
−
        getParsingFlags(tempConfig).score = currentScore;
+
−
 
+
−
        if (scoreToBeat == null || currentScore < scoreToBeat) {
+
−
            scoreToBeat = currentScore;
+
−
            bestMoment = tempConfig;
+
 
         }
 
         }
 
     }
 
     }
−
 
+
     function Kb() {
−
     extend(config, bestMoment || tempConfig);
+
        return this.isValid() ? this.toISOString() : null
−
}
+
−
 
+
−
function configFromObject(config) {
+
−
    if (config._d) {
+
−
        return;
+
 
     }
 
     }
−
 
+
     function Lb() {
−
     var i = normalizeObjectUnits(config._i);
+
         return k(this)
−
    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
+
−
         return obj && parseInt(obj, 10);
+
−
    });
+
−
 
+
−
    configFromArray(config);
+
−
}
+
−
 
+
−
function createFromConfig (config) {
+
−
    var res = new Moment(checkOverflow(prepareConfig(config)));
+
−
    if (res._nextDay) {
+
−
        // Adding is smart enough around DST
+
−
        res.add(1, 'd');
+
−
        res._nextDay = undefined;
+
 
     }
 
     }
−
 
+
     function Mb() {
−
     return res;
+
         return g({}, j(this))
−
}
+
−
 
+
−
function prepareConfig (config) {
+
−
    var input = config._i,
+
−
        format = config._f;
+
−
 
+
−
    config._locale = config._locale || getLocale(config._l);
+
−
 
+
−
    if (input === null || (format === undefined && input === '')) {
+
−
         return createInvalid({nullInput: true});
+
 
     }
 
     }
−
 
+
     function Nb() {
−
     if (typeof input === 'string') {
+
         return j(this).overflow
−
         config._i = input = config._locale.preparse(input);
+
 
     }
 
     }
−
 
+
     function Ob() {
−
     if (isMoment(input)) {
+
         return {
−
         return new Moment(checkOverflow(input));
+
            input: this._i,
−
    } else if (isDate(input)) {
+
            format: this._f,
−
        config._d = input;
+
            locale: this._locale,
−
    } else if (isArray(format)) {
+
            isUTC: this._isUTC,
−
        configFromStringAndArray(config);
+
            strict: this._strict
−
    } else if (format) {
+
         }
−
         configFromStringAndFormat(config);
+
−
    } else {
+
−
        configFromInput(config);
+
 
     }
 
     }
−
 
+
     function Pb(a, b) {
−
     if (!isValid(config)) {
+
         R(0, [a, a.length], 0, b)
−
         config._d = null;
+
 
     }
 
     }
−
 
+
     function Qb(a) {
−
     return config;
+
         return Ub.call(this, a, this.week(), this.weekday(), this.localeData()._week.dow, this.localeData()._week.doy)
−
}
+
−
 
+
−
function configFromInput(config) {
+
−
    var input = config._i;
+
−
    if (isUndefined(input)) {
+
−
         config._d = new Date(hooks.now());
+
−
    } else if (isDate(input)) {
+
−
        config._d = new Date(input.valueOf());
+
−
    } else if (typeof input === 'string') {
+
−
        configFromString(config);
+
−
    } else if (isArray(input)) {
+
−
        config._a = map(input.slice(0), function (obj) {
+
−
            return parseInt(obj, 10);
+
−
        });
+
−
        configFromArray(config);
+
−
    } else if (isObject(input)) {
+
−
        configFromObject(config);
+
−
    } else if (isNumber(input)) {
+
−
        // from milliseconds
+
−
        config._d = new Date(input);
+
−
    } else {
+
−
        hooks.createFromInputFallback(config);
+
 
     }
 
     }
−
}
+
    function Rb(a) {
−
 
+
        return Ub.call(this, a, this.isoWeek(), this.isoWeekday(), 1, 4)
−
function createLocalOrUTC (input, format, locale, strict, isUTC) {
+
−
    var c = {};
+
−
 
+
−
    if (locale === true || locale === false) {
+
−
        strict = locale;
+
−
        locale = undefined;
+
 
     }
 
     }
−
 
+
     function Sb() {
−
     if ((isObject(input) && isObjectEmpty(input)) ||
+
        return xa(this.year(), 1, 4)
−
            (isArray(input) && input.length === 0)) {
+
−
        input = undefined;
+
 
     }
 
     }
−
     // object construction must be done this way.
+
     function Tb() {
−
    // https://github.com/moment/moment/issues/1423
+
        var a = this.localeData()._week;
−
    c._isAMomentObject = true;
+
         return xa(this.year(), a.dow, a.doy)
−
    c._useUTC = c._isUTC = isUTC;
+
−
    c._l = locale;
+
−
    c._i = input;
+
−
    c._f = format;
+
−
    c._strict = strict;
+
−
 
+
−
    return createFromConfig(c);
+
−
}
+
−
 
+
−
function createLocal (input, format, locale, strict) {
+
−
    return createLocalOrUTC(input, format, locale, strict, false);
+
−
}
+
−
 
+
−
var prototypeMin = deprecate(
+
−
    'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
+
−
    function () {
+
−
        var other = createLocal.apply(null, arguments);
+
−
         if (this.isValid() && other.isValid()) {
+
−
            return other < this ? this : other;
+
−
        } else {
+
−
            return createInvalid();
+
−
        }
+
 
     }
 
     }
−
);
+
     function Ub(a, b, c, d, e) {
−
 
+
         var f;
−
var prototypeMax = deprecate(
+
         return null == a ? wa(this, d, e).year : (f = xa(a, d, e),
−
     'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
+
        b > f && (b = f),
−
    function () {
+
         Vb.call(this, a, b, c, d, e))
−
         var other = createLocal.apply(null, arguments);
+
−
         if (this.isValid() && other.isValid()) {
+
−
            return other > this ? this : other;
+
−
         } else {
+
−
            return createInvalid();
+
−
        }
+
 
     }
 
     }
−
);
+
    function Vb(a, b, c, d, e) {
−
 
+
        var f = va(a, b, c, d, e)
−
// Pick a moment m from moments so that m[fn](other) is true for all
+
          , g = qa(f.year, 0, f.dayOfYear);
−
// other. This relies on the function fn to be transitive.
+
        return this.year(g.getUTCFullYear()),
−
//
+
        this.month(g.getUTCMonth()),
−
// moments should either be an array of moment objects or an array, whose
+
        this.date(g.getUTCDate()),
−
// first element is an array of moment objects.
+
         this
−
function pickBy(fn, moments) {
+
−
    var res, i;
+
−
    if (moments.length === 1 && isArray(moments[0])) {
+
−
         moments = moments[0];
+
 
     }
 
     }
−
     if (!moments.length) {
+
     function Wb(a) {
−
         return createLocal();
+
         return null == a ? Math.ceil((this.month() + 1) / 3) : this.month(3 * (a - 1) + this.month() % 3)
 
     }
 
     }
−
     res = moments[0];
+
     function Xb(a) {
−
    for (i = 1; i < moments.length; ++i) {
+
         return wa(a, this._week.dow, this._week.doy).week
−
         if (!moments[i].isValid() || moments[i][fn](res)) {
+
−
            res = moments[i];
+
−
        }
+
 
     }
 
     }
−
     return res;
+
     function Yb() {
−
}
+
        return this._week.dow
−
 
+
−
// TODO: Use [].sort instead?
+
−
function min () {
+
−
    var args = [].slice.call(arguments, 0);
+
−
 
+
−
    return pickBy('isBefore', args);
+
−
}
+
−
 
+
−
function max () {
+
−
    var args = [].slice.call(arguments, 0);
+
−
 
+
−
    return pickBy('isAfter', args);
+
−
}
+
−
 
+
−
var now = function () {
+
−
    return Date.now ? Date.now() : +(new Date());
+
−
};
+
−
 
+
−
var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
+
−
 
+
−
function isDurationValid(m) {
+
−
    for (var key in m) {
+
−
        if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
+
−
            return false;
+
−
        }
+
 
     }
 
     }
−
 
+
     function Zb() {
−
    var unitHasDecimal = false;
+
         return this._week.doy
−
     for (var i = 0; i < ordering.length; ++i) {
+
−
         if (m[ordering[i]]) {
+
−
            if (unitHasDecimal) {
+
−
                return false; // only allow non-integers for smallest unit
+
−
            }
+
−
            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
+
−
                unitHasDecimal = true;
+
−
            }
+
−
        }
+
 
     }
 
     }
−
 
+
     function $b(a) {
−
     return true;
+
        var b = this.localeData().week(this);
−
}
+
         return null == a ? b : this.add(7 * (a - b), "d")
−
 
+
−
function isValid$1() {
+
−
    return this._isValid;
+
−
}
+
−
 
+
−
function createInvalid$1() {
+
−
    return createDuration(NaN);
+
−
}
+
−
 
+
−
function Duration (duration) {
+
−
    var normalizedInput = normalizeObjectUnits(duration),
+
−
         years = normalizedInput.year || 0,
+
−
        quarters = normalizedInput.quarter || 0,
+
−
        months = normalizedInput.month || 0,
+
−
        weeks = normalizedInput.week || 0,
+
−
        days = normalizedInput.day || 0,
+
−
        hours = normalizedInput.hour || 0,
+
−
        minutes = normalizedInput.minute || 0,
+
−
        seconds = normalizedInput.second || 0,
+
−
        milliseconds = normalizedInput.millisecond || 0;
+
−
 
+
−
    this._isValid = isDurationValid(normalizedInput);
+
−
 
+
−
    // representation for dateAddRemove
+
−
    this._milliseconds = +milliseconds +
+
−
        seconds * 1e3 + // 1000
+
−
        minutes * 6e4 + // 1000 * 60
+
−
        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
+
−
    // Because of dateAddRemove treats 24 hours as different from a
+
−
    // day when working around DST, we need to store them separately
+
−
    this._days = +days +
+
−
        weeks * 7;
+
−
    // It is impossible translate months into days without knowing
+
−
    // which months you are are talking about, so we have to store
+
−
    // it separately.
+
−
    this._months = +months +
+
−
        quarters * 3 +
+
−
        years * 12;
+
−
 
+
−
    this._data = {};
+
−
 
+
−
    this._locale = getLocale();
+
−
 
+
−
    this._bubble();
+
−
}
+
−
 
+
−
function isDuration (obj) {
+
−
    return obj instanceof Duration;
+
−
}
+
−
 
+
−
function absRound (number) {
+
−
    if (number < 0) {
+
−
        return Math.round(-1 * number) * -1;
+
−
    } else {
+
−
        return Math.round(number);
+
 
     }
 
     }
−
}
+
     function _b(a) {
−
 
+
         var b = wa(this, 1, 4).week;
−
// FORMATTING
+
         return null == a ? b : this.add(7 * (a - b), "d")
−
 
+
−
function offset (token, separator) {
+
−
     addFormatToken(token, 0, 0, function () {
+
−
         var offset = this.utcOffset();
+
−
         var sign = '+';
+
−
        if (offset < 0) {
+
−
            offset = -offset;
+
−
            sign = '-';
+
−
        }
+
−
        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
+
−
    });
+
−
}
+
−
 
+
−
offset('Z', ':');
+
−
offset('ZZ', '');
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('Z',  matchShortOffset);
+
−
addRegexToken('ZZ', matchShortOffset);
+
−
addParseToken(['Z', 'ZZ'], function (input, array, config) {
+
−
    config._useUTC = true;
+
−
    config._tzm = offsetFromString(matchShortOffset, input);
+
−
});
+
−
 
+
−
// HELPERS
+
−
 
+
−
// timezone chunker
+
−
// '+10:00' > ['10',  '00']
+
−
// '-1530'  > ['-15', '30']
+
−
var chunkOffset = /([\+\-]|\d\d)/gi;
+
−
 
+
−
function offsetFromString(matcher, string) {
+
−
    var matches = (string || '').match(matcher);
+
−
 
+
−
    if (matches === null) {
+
−
        return null;
+
 
     }
 
     }
−
 
+
     function ac(a, b) {
−
     var chunk  = matches[matches.length - 1] || [];
+
        return "string" != typeof a ? a : isNaN(a) ? (a = b.weekdaysParse(a),
−
    var parts  = (chunk + '').match(chunkOffset) || ['-', 0, 0];
+
         "number" == typeof a ? a : null) : parseInt(a, 10)
−
    var minutes = +(parts[1] * 60) + toInt(parts[2]);
+
−
 
+
−
    return minutes === 0 ?
+
−
      0 :
+
−
      parts[0] === '+' ? minutes : -minutes;
+
−
}
+
−
 
+
−
// Return a moment from input, that is local/utc/zone equivalent to model.
+
−
function cloneWithOffset(input, model) {
+
−
    var res, diff;
+
−
    if (model._isUTC) {
+
−
        res = model.clone();
+
−
         diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
+
−
        // Use low-level api, because this fn is low-level api.
+
−
        res._d.setTime(res._d.valueOf() + diff);
+
−
        hooks.updateOffset(res, false);
+
−
        return res;
+
−
    } else {
+
−
        return createLocal(input).local();
+
 
     }
 
     }
−
}
+
    function bc(a, b) {
−
 
+
        return c(this._weekdays) ? this._weekdays[a.day()] : this._weekdays[this._weekdays.isFormat.test(b) ? "format" : "standalone"][a.day()]
−
function getDateOffset (m) {
+
−
    // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+
−
    // https://github.com/moment/moment/pull/1871
+
−
    return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
+
−
}
+
−
 
+
−
// HOOKS
+
−
 
+
−
// This function will be called whenever a moment is mutated.
+
−
// It is intended to keep the offset in sync with the timezone.
+
−
hooks.updateOffset = function () {};
+
−
 
+
−
// MOMENTS
+
−
 
+
−
// keepLocalTime = true means only change the timezone, without
+
−
// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
+
−
// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
+
−
// +0200, so we adjust the time as needed, to be valid.
+
−
//
+
−
// Keeping the time actually adds/subtracts (one hour)
+
−
// from the actual represented time. That is why we call updateOffset
+
−
// a second time. In case it wants us to change the offset again
+
−
// _changeInProgress == true case, then we have to adjust, because
+
−
// there is no such time in the given timezone.
+
−
function getSetOffset (input, keepLocalTime, keepMinutes) {
+
−
    var offset = this._offset || 0,
+
−
        localAdjust;
+
−
    if (!this.isValid()) {
+
−
        return input != null ? this : NaN;
+
 
     }
 
     }
−
     if (input != null) {
+
     function cc(a) {
−
         if (typeof input === 'string') {
+
         return this._weekdaysShort[a.day()]
−
            input = offsetFromString(matchShortOffset, input);
+
−
            if (input === null) {
+
−
                return this;
+
−
            }
+
−
        } else if (Math.abs(input) < 16 && !keepMinutes) {
+
−
            input = input * 60;
+
−
        }
+
−
        if (!this._isUTC && keepLocalTime) {
+
−
            localAdjust = getDateOffset(this);
+
−
        }
+
−
        this._offset = input;
+
−
        this._isUTC = true;
+
−
        if (localAdjust != null) {
+
−
            this.add(localAdjust, 'm');
+
−
        }
+
−
        if (offset !== input) {
+
−
            if (!keepLocalTime || this._changeInProgress) {
+
−
                addSubtract(this, createDuration(input - offset, 'm'), 1, false);
+
−
            } else if (!this._changeInProgress) {
+
−
                this._changeInProgress = true;
+
−
                hooks.updateOffset(this, true);
+
−
                this._changeInProgress = null;
+
−
            }
+
−
        }
+
−
        return this;
+
−
    } else {
+
−
        return this._isUTC ? offset : getDateOffset(this);
+
 
     }
 
     }
−
}
+
    function dc(a) {
−
 
+
        return this._weekdaysMin[a.day()]
−
function getSetZone (input, keepLocalTime) {
+
    }
−
    if (input != null) {
+
    function ec(a, b, c) {
−
         if (typeof input !== 'string') {
+
        var d, e, f, g = a.toLocaleLowerCase();
−
            input = -input;
+
        if (!this._weekdaysParse)
−
         }
+
            for (this._weekdaysParse = [],
−
 
+
            this._shortWeekdaysParse = [],
−
         this.utcOffset(input, keepLocalTime);
+
            this._minWeekdaysParse = [],
−
 
+
            d = 0; 7 > d; ++d)
−
         return this;
+
                f = h([2e3, 1]).day(d),
−
    } else {
+
                this._minWeekdaysParse[d] = this.weekdaysMin(f, "").toLocaleLowerCase(),
−
         return -this.utcOffset();
+
                this._shortWeekdaysParse[d] = this.weekdaysShort(f, "").toLocaleLowerCase(),
 +
                this._weekdaysParse[d] = this.weekdays(f, "").toLocaleLowerCase();
 +
         return c ? "dddd" === b ? (e = md.call(this._weekdaysParse, g),
 +
        -1 !== e ? e : null) : "ddd" === b ? (e = md.call(this._shortWeekdaysParse, g),
 +
        -1 !== e ? e : null) : (e = md.call(this._minWeekdaysParse, g),
 +
        -1 !== e ? e : null) : "dddd" === b ? (e = md.call(this._weekdaysParse, g),
 +
         -1 !== e ? e : (e = md.call(this._shortWeekdaysParse, g),
 +
        -1 !== e ? e : (e = md.call(this._minWeekdaysParse, g),
 +
         -1 !== e ? e : null))) : "ddd" === b ? (e = md.call(this._shortWeekdaysParse, g),
 +
        -1 !== e ? e : (e = md.call(this._weekdaysParse, g),
 +
        -1 !== e ? e : (e = md.call(this._minWeekdaysParse, g),
 +
         -1 !== e ? e : null))) : (e = md.call(this._minWeekdaysParse, g),
 +
         -1 !== e ? e : (e = md.call(this._weekdaysParse, g),
 +
        -1 !== e ? e : (e = md.call(this._shortWeekdaysParse, g),
 +
        -1 !== e ? e : null)))
 
     }
 
     }
−
}
+
    function fc(a, b, c) {
−
 
+
        var d, e, f;
−
function setOffsetToUTC (keepLocalTime) {
+
        if (this._weekdaysParseExact)
−
    return this.utcOffset(0, keepLocalTime);
+
            return ec.call(this, a, b, c);
−
}
+
        for (this._weekdaysParse || (this._weekdaysParse = [],
−
 
+
        this._minWeekdaysParse = [],
−
function setOffsetToLocal (keepLocalTime) {
+
        this._shortWeekdaysParse = [],
−
    if (this._isUTC) {
+
        this._fullWeekdaysParse = []),
−
        this.utcOffset(0, keepLocalTime);
+
        d = 0; 7 > d; d++) {
−
        this._isUTC = false;
+
            if (e = h([2e3, 1]).day(d),
−
 
+
            c && !this._fullWeekdaysParse[d] && (this._fullWeekdaysParse[d] = new RegExp("^" + this.weekdays(e, "").replace(".", ".?") + "$","i"),
−
        if (keepLocalTime) {
+
            this._shortWeekdaysParse[d] = new RegExp("^" + this.weekdaysShort(e, "").replace(".", ".?") + "$","i"),
−
             this.subtract(getDateOffset(this), 'm');
+
            this._minWeekdaysParse[d] = new RegExp("^" + this.weekdaysMin(e, "").replace(".", ".?") + "$","i")),
 +
            this._weekdaysParse[d] || (f = "^" + this.weekdays(e, "") + "|^" + this.weekdaysShort(e, "") + "|^" + this.weekdaysMin(e, ""),
 +
            this._weekdaysParse[d] = new RegExp(f.replace(".", ""),"i")),
 +
             c && "dddd" === b && this._fullWeekdaysParse[d].test(a))
 +
                return d;
 +
            if (c && "ddd" === b && this._shortWeekdaysParse[d].test(a))
 +
                return d;
 +
            if (c && "dd" === b && this._minWeekdaysParse[d].test(a))
 +
                return d;
 +
            if (!c && this._weekdaysParse[d].test(a))
 +
                return d
 
         }
 
         }
 
     }
 
     }
−
     return this;
+
     function gc(a) {
−
}
+
        if (!this.isValid())
−
 
+
            return null != a ? this : NaN;
−
function setOffsetToParsedOffset () {
+
         var b = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
−
    if (this._tzm != null) {
+
        return null != a ? (a = ac(a, this.localeData()),
−
         this.utcOffset(this._tzm, false, true);
+
        this.add(a - b, "d")) : b
−
     } else if (typeof this._i === 'string') {
+
     }
−
         var tZone = offsetFromString(matchOffset, this._i);
+
    function hc(a) {
−
         if (tZone != null) {
+
        if (!this.isValid())
−
            this.utcOffset(tZone);
+
            return null != a ? this : NaN;
−
        }
+
         var b = (this.day() + 7 - this.localeData()._week.dow) % 7;
−
        else {
+
         return null == a ? b : this.add(a - b, "d")
−
            this.utcOffset(0, true);
+
    }
−
        }
+
    function ic(a) {
 +
        return this.isValid() ? null == a ? this.day() || 7 : this.day(this.day() % 7 ? a : a - 7) : null != a ? this : NaN
 
     }
 
     }
−
     return this;
+
     function jc(a) {
−
}
+
        return this._weekdaysParseExact ? (f(this, "_weekdaysRegex") || mc.call(this),
−
 
+
         a ? this._weekdaysStrictRegex : this._weekdaysRegex) : this._weekdaysStrictRegex && a ? this._weekdaysStrictRegex : this._weekdaysRegex
−
function hasAlignedHourOffset (input) {
+
−
    if (!this.isValid()) {
+
−
         return false;
+
 
     }
 
     }
−
     input = input ? createLocal(input).utcOffset() : 0;
+
     function kc(a) {
−
 
+
        return this._weekdaysParseExact ? (f(this, "_weekdaysRegex") || mc.call(this),
−
    return (this.utcOffset() - input) % 60 === 0;
+
         a ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex) : this._weekdaysShortStrictRegex && a ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex
−
}
+
−
 
+
−
function isDaylightSavingTime () {
+
−
    return (
+
−
        this.utcOffset() > this.clone().month(0).utcOffset() ||
+
−
         this.utcOffset() > this.clone().month(5).utcOffset()
+
−
    );
+
−
}
+
−
 
+
−
function isDaylightSavingTimeShifted () {
+
−
    if (!isUndefined(this._isDSTShifted)) {
+
−
        return this._isDSTShifted;
+
 
     }
 
     }
−
 
+
     function lc(a) {
−
     var c = {};
+
         return this._weekdaysParseExact ? (f(this, "_weekdaysRegex") || mc.call(this),
−
 
+
         a ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex) : this._weekdaysMinStrictRegex && a ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex
−
    copyConfig(c, this);
+
−
    c = prepareConfig(c);
+
−
 
+
−
    if (c._a) {
+
−
         var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+
−
         this._isDSTShifted = this.isValid() &&
+
−
            compareArrays(c._a, other.toArray()) > 0;
+
−
    } else {
+
−
        this._isDSTShifted = false;
+
 
     }
 
     }
−
 
+
     function mc() {
−
     return this._isDSTShifted;
+
        function a(a, b) {
−
}
+
            return b.length - a.length
−
 
+
−
function isLocal () {
+
−
    return this.isValid() ? !this._isUTC : false;
+
−
}
+
−
 
+
−
function isUtcOffset () {
+
−
    return this.isValid() ? this._isUTC : false;
+
−
}
+
−
 
+
−
function isUtc () {
+
−
    return this.isValid() ? this._isUTC && this._offset === 0 : false;
+
−
}
+
−
 
+
−
// ASP.NET json date format regex
+
−
var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
+
−
 
+
−
// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+
−
// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+
−
// and further modified to allow for strings containing both week and day
+
−
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)?)?$/;
+
−
 
+
−
function createDuration (input, key) {
+
−
    var duration = input,
+
−
        // matching against regexp is expensive, do it on demand
+
−
        match = null,
+
−
        sign,
+
−
        ret,
+
−
        diffRes;
+
−
 
+
−
    if (isDuration(input)) {
+
−
        duration = {
+
−
            ms : input._milliseconds,
+
−
            d  : input._days,
+
−
            M  : input._months
+
−
        };
+
−
    } else if (isNumber(input)) {
+
−
        duration = {};
+
−
        if (key) {
+
−
            duration[key] = input;
+
−
        } else {
+
−
            duration.milliseconds = input;
+
 
         }
 
         }
−
    } else if (!!(match = aspNetRegex.exec(input))) {
+
         var b, c, d, e, f, g = [], i = [], j = [], k = [];
−
         sign = (match[1] === '-') ? -1 : 1;
+
         for (b = 0; 7 > b; b++)
−
         duration = {
+
             c = h([2e3, 1]).day(b),
−
            y  : 0,
+
             d = this.weekdaysMin(c, ""),
−
             d  : toInt(match[DATE])                         * sign,
+
             e = this.weekdaysShort(c, ""),
−
             h  : toInt(match[HOUR])                         * sign,
+
             f = this.weekdays(c, ""),
−
             m  : toInt(match[MINUTE])                       * sign,
+
             g.push(d),
−
             s  : toInt(match[SECOND])                       * sign,
+
            i.push(e),
−
             ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
+
            j.push(f),
−
        };
+
             k.push(d),
−
    } else if (!!(match = isoRegex.exec(input))) {
+
             k.push(e),
−
        sign = (match[1] === '-') ? -1 : 1;
+
             k.push(f);
−
        duration = {
+
        for (g.sort(a),
−
             y : parseIso(match[2], sign),
+
        i.sort(a),
−
             M : parseIso(match[3], sign),
+
        j.sort(a),
−
             w : parseIso(match[4], sign),
+
        k.sort(a),
−
            d : parseIso(match[5], sign),
+
        b = 0; 7 > b; b++)
−
             h : parseIso(match[6], sign),
+
             i[b] = Z(i[b]),
−
             m : parseIso(match[7], sign),
+
             j[b] = Z(j[b]),
−
             s : parseIso(match[8], sign)
+
             k[b] = Z(k[b]);
−
        };
+
        this._weekdaysRegex = new RegExp("^(" + k.join("|") + ")","i"),
−
    } else if (duration == null) {// checks for null or undefined
+
         this._weekdaysShortRegex = this._weekdaysRegex,
−
         duration = {};
+
        this._weekdaysMinRegex = this._weekdaysRegex,
−
    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
+
        this._weekdaysStrictRegex = new RegExp("^(" + j.join("|") + ")","i"),
−
         diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
+
         this._weekdaysShortStrictRegex = new RegExp("^(" + i.join("|") + ")","i"),
−
 
+
         this._weekdaysMinStrictRegex = new RegExp("^(" + g.join("|") + ")","i")
−
        duration = {};
+
−
         duration.ms = diffRes.milliseconds;
+
−
        duration.M = diffRes.months;
+
 
     }
 
     }
−
 
+
     function nc(a) {
−
     ret = new Duration(duration);
+
        var b = Math.round((this.clone().startOf("day") - this.clone().startOf("year")) / 864e5) + 1;
−
 
+
         return null == a ? b : this.add(a - b, "d")
−
    if (isDuration(input) && hasOwnProp(input, '_locale')) {
+
−
         ret._locale = input._locale;
+
 
     }
 
     }
−
 
+
     function oc() {
−
     return ret;
+
        return this.hours() % 12 || 12
−
}
+
−
 
+
−
createDuration.fn = Duration.prototype;
+
−
createDuration.invalid = createInvalid$1;
+
−
 
+
−
function parseIso (inp, sign) {
+
−
    // We'd normally use ~~inp for this, but unfortunately it also
+
−
    // converts floats to ints.
+
−
    // inp may be undefined, so careful calling replace on it.
+
−
    var res = inp && parseFloat(inp.replace(',', '.'));
+
−
    // apply sign while we're at it
+
−
    return (isNaN(res) ? 0 : res) * sign;
+
−
}
+
−
 
+
−
function positiveMomentsDifference(base, other) {
+
−
    var res = {milliseconds: 0, months: 0};
+
−
 
+
−
    res.months = other.month() - base.month() +
+
−
        (other.year() - base.year()) * 12;
+
−
    if (base.clone().add(res.months, 'M').isAfter(other)) {
+
−
        --res.months;
+
 
     }
 
     }
−
 
+
     function pc() {
−
     res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
+
        return this.hours() || 24
−
 
+
−
    return res;
+
−
}
+
−
 
+
−
function momentsDifference(base, other) {
+
−
    var res;
+
−
    if (!(base.isValid() && other.isValid())) {
+
−
        return {milliseconds: 0, months: 0};
+
 
     }
 
     }
−
 
+
     function qc(a, b) {
−
     other = cloneWithOffset(other, base);
+
         R(a, 0, 0, function() {
−
    if (base.isBefore(other)) {
+
            return this.localeData().meridiem(this.hours(), this.minutes(), b)
−
         res = positiveMomentsDifference(base, other);
+
         })
−
    } else {
+
−
        res = positiveMomentsDifference(other, base);
+
−
        res.milliseconds = -res.milliseconds;
+
−
         res.months = -res.months;
+
 
     }
 
     }
−
 
+
     function rc(a, b) {
−
     return res;
+
         return b._meridiemParse
−
}
+
−
 
+
−
// TODO: remove 'name' arg after deprecation is removed
+
−
function createAdder(direction, name) {
+
−
    return function (val, period) {
+
−
        var dur, tmp;
+
−
        //invert the arguments, but complain about it
+
−
        if (period !== null && !isNaN(+period)) {
+
−
            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
+
−
            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
+
−
            tmp = val; val = period; period = tmp;
+
−
        }
+
−
 
+
−
        val = typeof val === 'string' ? +val : val;
+
−
        dur = createDuration(val, period);
+
−
        addSubtract(this, dur, direction);
+
−
         return this;
+
−
    };
+
−
}
+
−
 
+
−
function addSubtract (mom, duration, isAdding, updateOffset) {
+
−
    var milliseconds = duration._milliseconds,
+
−
        days = absRound(duration._days),
+
−
        months = absRound(duration._months);
+
−
 
+
−
    if (!mom.isValid()) {
+
−
        // No op
+
−
        return;
+
 
     }
 
     }
−
 
+
    function sc(a) {
−
    updateOffset = updateOffset == null ? true : updateOffset;
+
        return "p" === (a + "").toLowerCase().charAt(0)
−
 
+
−
    if (milliseconds) {
+
−
        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
+
 
     }
 
     }
−
     if (days) {
+
     function tc(a, b, c) {
−
         set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
+
         return a > 11 ? c ? "pm" : "PM" : c ? "am" : "AM"
 
     }
 
     }
−
     if (months) {
+
     function uc(a, b) {
−
         setMonth(mom, get(mom, 'Month') + months * isAdding);
+
         b[Sd] = r(1e3 * ("0." + a))
 
     }
 
     }
−
     if (updateOffset) {
+
     function vc() {
−
         hooks.updateOffset(mom, days || months);
+
         return this._isUTC ? "UTC" : ""
 
     }
 
     }
−
}
+
     function wc() {
−
 
+
         return this._isUTC ? "Coordinated Universal Time" : ""
−
var add      = createAdder(1, 'add');
+
−
var subtract = createAdder(-1, 'subtract');
+
−
 
+
−
function getCalendarFormat(myMoment, now) {
+
−
     var diff = myMoment.diff(now, 'days', true);
+
−
    return diff < -6 ? 'sameElse' :
+
−
            diff < -1 ? 'lastWeek' :
+
−
            diff < 0 ? 'lastDay' :
+
−
            diff < 1 ? 'sameDay' :
+
−
            diff < 2 ? 'nextDay' :
+
−
            diff < 7 ? 'nextWeek' : 'sameElse';
+
−
}
+
−
 
+
−
function calendar$1 (time, formats) {
+
−
    // We want to compare the start of today, vs this.
+
−
    // Getting start-of-today depends on whether we're local/utc/offset or not.
+
−
    var now = time || createLocal(),
+
−
         sod = cloneWithOffset(now, this).startOf('day'),
+
−
        format = hooks.calendarFormat(this, sod) || 'sameElse';
+
−
 
+
−
    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
+
−
 
+
−
    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
+
−
}
+
−
 
+
−
function clone () {
+
−
    return new Moment(this);
+
−
}
+
−
 
+
−
function isAfter (input, units) {
+
−
    var localInput = isMoment(input) ? input : createLocal(input);
+
−
    if (!(this.isValid() && localInput.isValid())) {
+
−
        return false;
+
 
     }
 
     }
−
     units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
+
     function xc(a) {
−
    if (units === 'millisecond') {
+
         return Ka(1e3 * a)
−
         return this.valueOf() > localInput.valueOf();
+
−
    } else {
+
−
        return localInput.valueOf() < this.clone().startOf(units).valueOf();
+
 
     }
 
     }
−
}
+
    function yc() {
−
 
+
        return Ka.apply(null, arguments).parseZone()
−
function isBefore (input, units) {
+
−
    var localInput = isMoment(input) ? input : createLocal(input);
+
−
    if (!(this.isValid() && localInput.isValid())) {
+
−
        return false;
+
 
     }
 
     }
−
     units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
+
     function zc(a, b, c) {
−
    if (units === 'millisecond') {
+
         var d = this._calendar[a];
−
         return this.valueOf() < localInput.valueOf();
+
         return w(d) ? d.call(b, c) : d
−
    } else {
+
−
         return this.clone().endOf(units).valueOf() < localInput.valueOf();
+
 
     }
 
     }
−
}
+
    function Ac(a) {
−
 
+
        var b = this._longDateFormat[a]
−
function isBetween (from, to, units, inclusivity) {
+
          , c = this._longDateFormat[a.toUpperCase()];
−
    inclusivity = inclusivity || '()';
+
         return b || !c ? b : (this._longDateFormat[a] = c.replace(/MMMM|MM|DD|dddd/g, function(a) {
−
    return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
+
            return a.slice(1)
−
         (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
+
        }),
−
}
+
         this._longDateFormat[a])
−
 
+
−
function isSame (input, units) {
+
−
    var localInput = isMoment(input) ? input : createLocal(input),
+
−
         inputMs;
+
−
    if (!(this.isValid() && localInput.isValid())) {
+
−
        return false;
+
 
     }
 
     }
−
     units = normalizeUnits(units || 'millisecond');
+
     function Bc() {
−
    if (units === 'millisecond') {
+
         return this._invalidDate
−
         return this.valueOf() === localInput.valueOf();
+
−
    } else {
+
−
        inputMs = localInput.valueOf();
+
−
        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
+
 
     }
 
     }
−
}
+
     function Cc(a) {
−
 
+
        return this._ordinal.replace("%d", a)
−
function isSameOrAfter (input, units) {
+
−
     return this.isSame(input, units) || this.isAfter(input,units);
+
−
}
+
−
 
+
−
function isSameOrBefore (input, units) {
+
−
    return this.isSame(input, units) || this.isBefore(input,units);
+
−
}
+
−
 
+
−
function diff (input, units, asFloat) {
+
−
    var that,
+
−
        zoneDelta,
+
−
        delta, output;
+
−
 
+
−
    if (!this.isValid()) {
+
−
        return NaN;
+
 
     }
 
     }
−
 
+
     function Dc(a) {
−
     that = cloneWithOffset(input, this);
+
         return a
−
 
+
−
    if (!that.isValid()) {
+
−
         return NaN;
+
 
     }
 
     }
−
 
+
     function Ec(a, b, c, d) {
−
     zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
+
         var e = this._relativeTime[c];
−
 
+
         return w(e) ? e(a, b, c, d) : e.replace(/%d/i, a)
−
    units = normalizeUnits(units);
+
−
 
+
−
    if (units === 'year' || units === 'month' || units === 'quarter') {
+
−
         output = monthDiff(this, that);
+
−
         if (units === 'quarter') {
+
−
            output = output / 3;
+
−
        } else if (units === 'year') {
+
−
            output = output / 12;
+
−
        }
+
−
    } else {
+
−
        delta = this - that;
+
−
        output = units === 'second' ? delta / 1e3 : // 1000
+
−
            units === 'minute' ? delta / 6e4 : // 1000 * 60
+
−
            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
+
−
            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
+
−
            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
+
−
            delta;
+
 
     }
 
     }
−
     return asFloat ? output : absFloor(output);
+
     function Fc(a, b) {
−
}
+
        var c = this._relativeTime[a > 0 ? "future" : "past"];
−
 
+
         return w(c) ? c(b) : c.replace(/%s/i, b)
−
function monthDiff (a, b) {
+
−
    // difference in months
+
−
    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
+
−
         // b is in (anchor - 1 month, anchor + 1 month)
+
−
        anchor = a.clone().add(wholeMonthDiff, 'months'),
+
−
        anchor2, adjust;
+
−
 
+
−
    if (b - anchor < 0) {
+
−
        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
+
−
        // linear across the month
+
−
        adjust = (b - anchor) / (anchor - anchor2);
+
−
    } else {
+
−
        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
+
−
        // linear across the month
+
−
        adjust = (b - anchor) / (anchor2 - anchor);
+
 
     }
 
     }
−
 
+
     function Gc(a, b, c, d) {
−
     //check for negative zero, return zero if negative zero
+
        var e = H()
−
    return -(wholeMonthDiff + adjust) || 0;
+
          , f = h().set(d, b);
−
}
+
        return e[c](f, a)
−
 
+
−
hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
+
−
hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
+
−
 
+
−
function toString () {
+
−
    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
+
−
}
+
−
 
+
−
function toISOString() {
+
−
    if (!this.isValid()) {
+
−
        return null;
+
 
     }
 
     }
−
     var m = this.clone().utc();
+
     function Hc(a, b, c) {
−
    if (m.year() < 0 || m.year() > 9999) {
+
        if ("number" == typeof a && (b = a,
−
         return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+
        a = void 0),
 +
        a = a || "",
 +
         null != b)
 +
            return Gc(a, b, c, "month");
 +
        var d, e = [];
 +
        for (d = 0; 12 > d; d++)
 +
            e[d] = Gc(a, d, c, "month");
 +
        return e
 
     }
 
     }
−
     if (isFunction(Date.prototype.toISOString)) {
+
     function Ic(a, b, c, d) {
−
         // native implementation is ~50x faster, use it when we can
+
        "boolean" == typeof a ? ("number" == typeof b && (c = b,
−
         return this.toDate().toISOString();
+
        b = void 0),
 +
        b = b || "") : (b = a,
 +
        c = b,
 +
        a = !1,
 +
        "number" == typeof b && (c = b,
 +
        b = void 0),
 +
        b = b || "");
 +
        var e = H()
 +
          , f = a ? e._week.dow : 0;
 +
        if (null != c)
 +
            return Gc(b, (c + f) % 7, d, "day");
 +
         var g, h = [];
 +
         for (g = 0; 7 > g; g++)
 +
            h[g] = Gc(b, (g + f) % 7, d, "day");
 +
        return h
 
     }
 
     }
−
     return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+
     function Jc(a, b) {
−
}
+
         return Hc(a, b, "months")
−
 
+
−
/**
+
−
* Return a human readable representation of a moment that can
+
−
* also be evaluated to get a new moment which is the same
+
−
*
+
−
* @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
+
−
*/
+
−
function inspect () {
+
−
    if (!this.isValid()) {
+
−
         return 'moment.invalid(/* ' + this._i + ' */)';
+
 
     }
 
     }
−
     var func = 'moment';
+
     function Kc(a, b) {
−
    var zone = '';
+
         return Hc(a, b, "monthsShort")
−
    if (!this.isLocal()) {
+
−
         func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
+
−
        zone = 'Z';
+
 
     }
 
     }
−
     var prefix = '[' + func + '("]';
+
     function Lc(a, b, c) {
−
    var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
+
         return Ic(a, b, c, "weekdays")
−
    var datetime = '-MM-DD[T]HH:mm:ss.SSS';
+
−
    var suffix = zone + '[")]';
+
−
 
+
−
    return this.format(prefix + year + datetime + suffix);
+
−
}
+
−
 
+
−
function format (inputString) {
+
−
    if (!inputString) {
+
−
         inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
+
 
     }
 
     }
−
     var output = formatMoment(this, inputString);
+
     function Mc(a, b, c) {
−
    return this.localeData().postformat(output);
+
         return Ic(a, b, c, "weekdaysShort")
−
}
+
−
 
+
−
function from (time, withoutSuffix) {
+
−
    if (this.isValid() &&
+
−
            ((isMoment(time) && time.isValid()) ||
+
−
            createLocal(time).isValid())) {
+
−
         return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
+
−
    } else {
+
−
        return this.localeData().invalidDate();
+
 
     }
 
     }
−
}
+
     function Nc(a, b, c) {
−
 
+
         return Ic(a, b, c, "weekdaysMin")
−
function fromNow (withoutSuffix) {
+
−
     return this.from(createLocal(), withoutSuffix);
+
−
}
+
−
 
+
−
function to (time, withoutSuffix) {
+
−
    if (this.isValid() &&
+
−
            ((isMoment(time) && time.isValid()) ||
+
−
            createLocal(time).isValid())) {
+
−
         return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
+
−
    } else {
+
−
        return this.localeData().invalidDate();
+
 
     }
 
     }
−
}
+
    function Oc() {
−
 
+
        var a = this._data;
−
function toNow (withoutSuffix) {
+
        return this._milliseconds = Le(this._milliseconds),
−
    return this.to(createLocal(), withoutSuffix);
+
        this._days = Le(this._days),
−
}
+
        this._months = Le(this._months),
−
 
+
        a.milliseconds = Le(a.milliseconds),
−
// If passed a locale key, it will set the locale for this
+
         a.seconds = Le(a.seconds),
−
// instance. Otherwise, it will return the locale configuration
+
         a.minutes = Le(a.minutes),
−
// variables for this instance.
+
         a.hours = Le(a.hours),
−
function locale (key) {
+
        a.months = Le(a.months),
−
    var newLocaleData;
+
         a.years = Le(a.years),
−
 
+
         this
−
    if (key === undefined) {
+
−
         return this._locale._abbr;
+
−
    } else {
+
−
         newLocaleData = getLocale(key);
+
−
         if (newLocaleData != null) {
+
−
            this._locale = newLocaleData;
+
−
         }
+
−
         return this;
+
 
     }
 
     }
−
}
+
    function Pc(a, b, c, d) {
−
 
+
        var e = db(b, c);
−
var lang = deprecate(
+
        return a._milliseconds += d * e._milliseconds,
−
    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
+
        a._days += d * e._days,
−
    function (key) {
+
         a._months += d * e._months,
−
         if (key === undefined) {
+
         a._bubble()
−
            return this.localeData();
+
−
         } else {
+
−
            return this.locale(key);
+
−
        }
+
 
     }
 
     }
−
);
+
     function Qc(a, b) {
−
 
+
         return Pc(this, a, b, 1)
−
function localeData () {
+
−
     return this._locale;
+
−
}
+
−
 
+
−
function startOf (units) {
+
−
    units = normalizeUnits(units);
+
−
    // the following switch intentionally omits break keywords
+
−
    // to utilize falling through the cases.
+
−
    switch (units) {
+
−
         case 'year':
+
−
            this.month(0);
+
−
            /* falls through */
+
−
        case 'quarter':
+
−
        case 'month':
+
−
            this.date(1);
+
−
            /* falls through */
+
−
        case 'week':
+
−
        case 'isoWeek':
+
−
        case 'day':
+
−
        case 'date':
+
−
            this.hours(0);
+
−
            /* falls through */
+
−
        case 'hour':
+
−
            this.minutes(0);
+
−
            /* falls through */
+
−
        case 'minute':
+
−
            this.seconds(0);
+
−
            /* falls through */
+
−
        case 'second':
+
−
            this.milliseconds(0);
+
 
     }
 
     }
−
 
+
     function Rc(a, b) {
−
     // weeks are a special case
+
         return Pc(this, a, b, -1)
−
    if (units === 'week') {
+
−
         this.weekday(0);
+
 
     }
 
     }
−
     if (units === 'isoWeek') {
+
     function Sc(a) {
−
         this.isoWeekday(1);
+
         return 0 > a ? Math.floor(a) : Math.ceil(a)
 
     }
 
     }
−
 
+
     function Tc() {
−
     // quarters are also special
+
        var a, b, c, d, e, f = this._milliseconds, g = this._days, h = this._months, i = this._data;
−
    if (units === 'quarter') {
+
        return f >= 0 && g >= 0 && h >= 0 || 0 >= f && 0 >= g && 0 >= h || (f += 864e5 * Sc(Vc(h) + g),
−
         this.month(Math.floor(this.month() / 3) * 3);
+
        g = 0,
 +
        h = 0),
 +
         i.milliseconds = f % 1e3,
 +
        a = q(f / 1e3),
 +
        i.seconds = a % 60,
 +
        b = q(a / 60),
 +
        i.minutes = b % 60,
 +
        c = q(b / 60),
 +
        i.hours = c % 24,
 +
        g += q(c / 24),
 +
        e = q(Uc(g)),
 +
        h += e,
 +
        g -= Sc(Vc(e)),
 +
        d = q(h / 12),
 +
        h %= 12,
 +
        i.days = g,
 +
        i.months = h,
 +
        i.years = d,
 +
        this
 
     }
 
     }
−
 
+
     function Uc(a) {
−
     return this;
+
         return 4800 * a / 146097
−
}
+
−
 
+
−
function endOf (units) {
+
−
    units = normalizeUnits(units);
+
−
    if (units === undefined || units === 'millisecond') {
+
−
         return this;
+
 
     }
 
     }
−
 
+
     function Vc(a) {
−
     // 'date' is an alias for 'day', so it should be considered as such.
+
         return 146097 * a / 4800
−
    if (units === 'date') {
+
−
         units = 'day';
+
 
     }
 
     }
−
 
+
     function Wc(a) {
−
     return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
+
        var b, c, d = this._milliseconds;
−
}
+
        if (a = K(a),
−
 
+
        "month" === a || "year" === a)
−
function valueOf () {
+
            return b = this._days + d / 864e5,
−
    return this._d.valueOf() - ((this._offset || 0) * 60000);
+
            c = this._months + Uc(b),
−
}
+
            "month" === a ? c : c / 12;
−
 
+
        switch (b = this._days + Math.round(Vc(this._months)),
−
function unix () {
+
        a) {
−
    return Math.floor(this.valueOf() / 1000);
+
        case "week":
−
}
+
            return b / 7 + d / 6048e5;
−
 
+
        case "day":
−
function toDate () {
+
            return b + d / 864e5;
−
    return new Date(this.valueOf());
+
        case "hour":
−
}
+
            return 24 * b + d / 36e5;
−
 
+
        case "minute":
−
function toArray () {
+
            return 1440 * b + d / 6e4;
−
    var m = this;
+
        case "second":
−
    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
+
             return 86400 * b + d / 1e3;
−
}
+
        case "millisecond":
−
 
+
            return Math.floor(864e5 * b) + d;
−
function toObject () {
+
         default:
−
    var m = this;
+
            throw new Error("Unknown unit " + a)
−
    return {
+
−
        years: m.year(),
+
−
        months: m.month(),
+
−
        date: m.date(),
+
−
        hours: m.hours(),
+
−
        minutes: m.minutes(),
+
−
        seconds: m.seconds(),
+
−
        milliseconds: m.milliseconds()
+
−
    };
+
−
}
+
−
 
+
−
function toJSON () {
+
−
    // new Date(NaN).toJSON() === null
+
−
    return this.isValid() ? this.toISOString() : null;
+
−
}
+
−
 
+
−
function isValid$2 () {
+
−
    return isValid(this);
+
−
}
+
−
 
+
−
function parsingFlags () {
+
−
    return extend({}, getParsingFlags(this));
+
−
}
+
−
 
+
−
function invalidAt () {
+
−
    return getParsingFlags(this).overflow;
+
−
}
+
−
 
+
−
function creationData() {
+
−
    return {
+
−
        input: this._i,
+
−
        format: this._f,
+
−
        locale: this._locale,
+
−
        isUTC: this._isUTC,
+
−
        strict: this._strict
+
−
    };
+
−
}
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken(0, ['gg', 2], 0, function () {
+
−
    return this.weekYear() % 100;
+
−
});
+
−
 
+
−
addFormatToken(0, ['GG', 2], 0, function () {
+
−
    return this.isoWeekYear() % 100;
+
−
});
+
−
 
+
−
function addWeekYearFormatToken (token, getter) {
+
−
    addFormatToken(0, [token, token.length], 0, getter);
+
−
}
+
−
 
+
−
addWeekYearFormatToken('gggg',    'weekYear');
+
−
addWeekYearFormatToken('ggggg',    'weekYear');
+
−
addWeekYearFormatToken('GGGG',  'isoWeekYear');
+
−
addWeekYearFormatToken('GGGGG', 'isoWeekYear');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('weekYear', 'gg');
+
−
addUnitAlias('isoWeekYear', 'GG');
+
−
 
+
−
// PRIORITY
+
−
 
+
−
addUnitPriority('weekYear', 1);
+
−
addUnitPriority('isoWeekYear', 1);
+
−
 
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('G',      matchSigned);
+
−
addRegexToken('g',      matchSigned);
+
−
addRegexToken('GG',    match1to2, match2);
+
−
addRegexToken('gg',    match1to2, match2);
+
−
addRegexToken('GGGG',  match1to4, match4);
+
−
addRegexToken('gggg',  match1to4, match4);
+
−
addRegexToken('GGGGG',  match1to6, match6);
+
−
addRegexToken('ggggg',  match1to6, match6);
+
−
 
+
−
addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
+
−
    week[token.substr(0, 2)] = toInt(input);
+
−
});
+
−
 
+
−
addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
+
−
    week[token] = hooks.parseTwoDigitYear(input);
+
−
});
+
−
 
+
−
// MOMENTS
+
−
 
+
−
function getSetWeekYear (input) {
+
−
    return getSetWeekYearHelper.call(this,
+
−
            input,
+
−
            this.week(),
+
−
            this.weekday(),
+
−
            this.localeData()._week.dow,
+
−
            this.localeData()._week.doy);
+
−
}
+
−
 
+
−
function getSetISOWeekYear (input) {
+
−
    return getSetWeekYearHelper.call(this,
+
−
             input, this.isoWeek(), this.isoWeekday(), 1, 4);
+
−
}
+
−
 
+
−
function getISOWeeksInYear () {
+
−
    return weeksInYear(this.year(), 1, 4);
+
−
}
+
−
 
+
−
function getWeeksInYear () {
+
−
    var weekInfo = this.localeData()._week;
+
−
    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
+
−
}
+
−
 
+
−
function getSetWeekYearHelper(input, week, weekday, dow, doy) {
+
−
    var weeksTarget;
+
−
    if (input == null) {
+
−
         return weekOfYear(this, dow, doy).year;
+
−
    } else {
+
−
        weeksTarget = weeksInYear(input, dow, doy);
+
−
        if (week > weeksTarget) {
+
−
            week = weeksTarget;
+
 
         }
 
         }
−
        return setWeekAll.call(this, input, week, weekday, dow, doy);
 
 
     }
 
     }
−
}
+
    function Xc() {
−
 
+
         return this._milliseconds + 864e5 * this._days + this._months % 12 * 2592e6 + 31536e6 * r(this._months / 12)
−
function setWeekAll(weekYear, week, weekday, dow, doy) {
+
−
    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
+
−
         date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
+
−
 
+
−
    this.year(date.getUTCFullYear());
+
−
    this.month(date.getUTCMonth());
+
−
    this.date(date.getUTCDate());
+
−
    return this;
+
−
}
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('Q', 0, 'Qo', 'quarter');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('quarter', 'Q');
+
−
 
+
−
// PRIORITY
+
−
 
+
−
addUnitPriority('quarter', 7);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('Q', match1);
+
−
addParseToken('Q', function (input, array) {
+
−
    array[MONTH] = (toInt(input) - 1) * 3;
+
−
});
+
−
 
+
−
// MOMENTS
+
−
 
+
−
function getSetQuarter (input) {
+
−
    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
+
−
}
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('D', ['DD', 2], 'Do', 'date');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('date', 'D');
+
−
 
+
−
// PRIOROITY
+
−
addUnitPriority('date', 9);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('D',  match1to2);
+
−
addRegexToken('DD', match1to2, match2);
+
−
addRegexToken('Do', function (isStrict, locale) {
+
−
    // TODO: Remove "ordinalParse" fallback in next major release.
+
−
    return isStrict ?
+
−
      (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
+
−
      locale._dayOfMonthOrdinalParseLenient;
+
−
});
+
−
 
+
−
addParseToken(['D', 'DD'], DATE);
+
−
addParseToken('Do', function (input, array) {
+
−
    array[DATE] = toInt(input.match(match1to2)[0], 10);
+
−
});
+
−
 
+
−
// MOMENTS
+
−
 
+
−
var getSetDayOfMonth = makeGetSet('Date', true);
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('dayOfYear', 'DDD');
+
−
 
+
−
// PRIORITY
+
−
addUnitPriority('dayOfYear', 4);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('DDD',  match1to3);
+
−
addRegexToken('DDDD', match3);
+
−
addParseToken(['DDD', 'DDDD'], function (input, array, config) {
+
−
    config._dayOfYear = toInt(input);
+
−
});
+
−
 
+
−
// HELPERS
+
−
 
+
−
// MOMENTS
+
−
 
+
−
function getSetDayOfYear (input) {
+
−
    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
+
−
    return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
+
−
}
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('m', ['mm', 2], 0, 'minute');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('minute', 'm');
+
−
 
+
−
// PRIORITY
+
−
 
+
−
addUnitPriority('minute', 14);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('m',  match1to2);
+
−
addRegexToken('mm', match1to2, match2);
+
−
addParseToken(['m', 'mm'], MINUTE);
+
−
 
+
−
// MOMENTS
+
−
 
+
−
var getSetMinute = makeGetSet('Minutes', false);
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('s', ['ss', 2], 0, 'second');
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('second', 's');
+
−
 
+
−
// PRIORITY
+
−
 
+
−
addUnitPriority('second', 15);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('s',  match1to2);
+
−
addRegexToken('ss', match1to2, match2);
+
−
addParseToken(['s', 'ss'], SECOND);
+
−
 
+
−
// MOMENTS
+
−
 
+
−
var getSetSecond = makeGetSet('Seconds', false);
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('S', 0, 0, function () {
+
−
    return ~~(this.millisecond() / 100);
+
−
});
+
−
 
+
−
addFormatToken(0, ['SS', 2], 0, function () {
+
−
    return ~~(this.millisecond() / 10);
+
−
});
+
−
 
+
−
addFormatToken(0, ['SSS', 3], 0, 'millisecond');
+
−
addFormatToken(0, ['SSSS', 4], 0, function () {
+
−
    return this.millisecond() * 10;
+
−
});
+
−
addFormatToken(0, ['SSSSS', 5], 0, function () {
+
−
    return this.millisecond() * 100;
+
−
});
+
−
addFormatToken(0, ['SSSSSS', 6], 0, function () {
+
−
    return this.millisecond() * 1000;
+
−
});
+
−
addFormatToken(0, ['SSSSSSS', 7], 0, function () {
+
−
    return this.millisecond() * 10000;
+
−
});
+
−
addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
+
−
    return this.millisecond() * 100000;
+
−
});
+
−
addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
+
−
    return this.millisecond() * 1000000;
+
−
});
+
−
 
+
−
 
+
−
// ALIASES
+
−
 
+
−
addUnitAlias('millisecond', 'ms');
+
−
 
+
−
// PRIORITY
+
−
 
+
−
addUnitPriority('millisecond', 16);
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('S',    match1to3, match1);
+
−
addRegexToken('SS',  match1to3, match2);
+
−
addRegexToken('SSS',  match1to3, match3);
+
−
 
+
−
var token;
+
−
for (token = 'SSSS'; token.length <= 9; token += 'S') {
+
−
    addRegexToken(token, matchUnsigned);
+
−
}
+
−
 
+
−
function parseMs(input, array) {
+
−
    array[MILLISECOND] = toInt(('0.' + input) * 1000);
+
−
}
+
−
 
+
−
for (token = 'S'; token.length <= 9; token += 'S') {
+
−
    addParseToken(token, parseMs);
+
−
}
+
−
// MOMENTS
+
−
 
+
−
var getSetMillisecond = makeGetSet('Milliseconds', false);
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('z',  0, 0, 'zoneAbbr');
+
−
addFormatToken('zz', 0, 0, 'zoneName');
+
−
 
+
−
// MOMENTS
+
−
 
+
−
function getZoneAbbr () {
+
−
    return this._isUTC ? 'UTC' : '';
+
−
}
+
−
 
+
−
function getZoneName () {
+
−
    return this._isUTC ? 'Coordinated Universal Time' : '';
+
−
}
+
−
 
+
−
var proto = Moment.prototype;
+
−
 
+
−
proto.add              = add;
+
−
proto.calendar          = calendar$1;
+
−
proto.clone            = clone;
+
−
proto.diff              = diff;
+
−
proto.endOf            = endOf;
+
−
proto.format            = format;
+
−
proto.from              = from;
+
−
proto.fromNow          = fromNow;
+
−
proto.to                = to;
+
−
proto.toNow            = toNow;
+
−
proto.get              = stringGet;
+
−
proto.invalidAt        = invalidAt;
+
−
proto.isAfter          = isAfter;
+
−
proto.isBefore          = isBefore;
+
−
proto.isBetween        = isBetween;
+
−
proto.isSame            = isSame;
+
−
proto.isSameOrAfter    = isSameOrAfter;
+
−
proto.isSameOrBefore    = isSameOrBefore;
+
−
proto.isValid          = isValid$2;
+
−
proto.lang              = lang;
+
−
proto.locale            = locale;
+
−
proto.localeData        = localeData;
+
−
proto.max              = prototypeMax;
+
−
proto.min              = prototypeMin;
+
−
proto.parsingFlags      = parsingFlags;
+
−
proto.set              = stringSet;
+
−
proto.startOf          = startOf;
+
−
proto.subtract          = subtract;
+
−
proto.toArray          = toArray;
+
−
proto.toObject          = toObject;
+
−
proto.toDate            = toDate;
+
−
proto.toISOString      = toISOString;
+
−
proto.inspect          = inspect;
+
−
proto.toJSON            = toJSON;
+
−
proto.toString          = toString;
+
−
proto.unix              = unix;
+
−
proto.valueOf          = valueOf;
+
−
proto.creationData      = creationData;
+
−
 
+
−
// Year
+
−
proto.year      = getSetYear;
+
−
proto.isLeapYear = getIsLeapYear;
+
−
 
+
−
// Week Year
+
−
proto.weekYear    = getSetWeekYear;
+
−
proto.isoWeekYear = getSetISOWeekYear;
+
−
 
+
−
// Quarter
+
−
proto.quarter = proto.quarters = getSetQuarter;
+
−
 
+
−
// Month
+
−
proto.month      = getSetMonth;
+
−
proto.daysInMonth = getDaysInMonth;
+
−
 
+
−
// Week
+
−
proto.week          = proto.weeks        = getSetWeek;
+
−
proto.isoWeek        = proto.isoWeeks    = getSetISOWeek;
+
−
proto.weeksInYear    = getWeeksInYear;
+
−
proto.isoWeeksInYear = getISOWeeksInYear;
+
−
 
+
−
// Day
+
−
proto.date      = getSetDayOfMonth;
+
−
proto.day        = proto.days            = getSetDayOfWeek;
+
−
proto.weekday    = getSetLocaleDayOfWeek;
+
−
proto.isoWeekday = getSetISODayOfWeek;
+
−
proto.dayOfYear  = getSetDayOfYear;
+
−
 
+
−
// Hour
+
−
proto.hour = proto.hours = getSetHour;
+
−
 
+
−
// Minute
+
−
proto.minute = proto.minutes = getSetMinute;
+
−
 
+
−
// Second
+
−
proto.second = proto.seconds = getSetSecond;
+
−
 
+
−
// Millisecond
+
−
proto.millisecond = proto.milliseconds = getSetMillisecond;
+
−
 
+
−
// Offset
+
−
proto.utcOffset            = getSetOffset;
+
−
proto.utc                  = setOffsetToUTC;
+
−
proto.local                = setOffsetToLocal;
+
−
proto.parseZone            = setOffsetToParsedOffset;
+
−
proto.hasAlignedHourOffset = hasAlignedHourOffset;
+
−
proto.isDST                = isDaylightSavingTime;
+
−
proto.isLocal              = isLocal;
+
−
proto.isUtcOffset          = isUtcOffset;
+
−
proto.isUtc                = isUtc;
+
−
proto.isUTC                = isUtc;
+
−
 
+
−
// Timezone
+
−
proto.zoneAbbr = getZoneAbbr;
+
−
proto.zoneName = getZoneName;
+
−
 
+
−
// Deprecations
+
−
proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
+
−
proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
+
−
proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
+
−
proto.zone  = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
+
−
proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
+
−
 
+
−
function createUnix (input) {
+
−
    return createLocal(input * 1000);
+
−
}
+
−
 
+
−
function createInZone () {
+
−
    return createLocal.apply(null, arguments).parseZone();
+
−
}
+
−
 
+
−
function preParsePostFormat (string) {
+
−
    return string;
+
−
}
+
−
 
+
−
var proto$1 = Locale.prototype;
+
−
 
+
−
proto$1.calendar        = calendar;
+
−
proto$1.longDateFormat  = longDateFormat;
+
−
proto$1.invalidDate    = invalidDate;
+
−
proto$1.ordinal        = ordinal;
+
−
proto$1.preparse        = preParsePostFormat;
+
−
proto$1.postformat      = preParsePostFormat;
+
−
proto$1.relativeTime    = relativeTime;
+
−
proto$1.pastFuture      = pastFuture;
+
−
proto$1.set            = set;
+
−
 
+
−
// Month
+
−
proto$1.months            =        localeMonths;
+
−
proto$1.monthsShort      =        localeMonthsShort;
+
−
proto$1.monthsParse      =        localeMonthsParse;
+
−
proto$1.monthsRegex      = monthsRegex;
+
−
proto$1.monthsShortRegex  = monthsShortRegex;
+
−
 
+
−
// Week
+
−
proto$1.week = localeWeek;
+
−
proto$1.firstDayOfYear = localeFirstDayOfYear;
+
−
proto$1.firstDayOfWeek = localeFirstDayOfWeek;
+
−
 
+
−
// Day of Week
+
−
proto$1.weekdays      =        localeWeekdays;
+
−
proto$1.weekdaysMin    =        localeWeekdaysMin;
+
−
proto$1.weekdaysShort  =        localeWeekdaysShort;
+
−
proto$1.weekdaysParse  =        localeWeekdaysParse;
+
−
 
+
−
proto$1.weekdaysRegex      =        weekdaysRegex;
+
−
proto$1.weekdaysShortRegex  =        weekdaysShortRegex;
+
−
proto$1.weekdaysMinRegex    =        weekdaysMinRegex;
+
−
 
+
−
// Hours
+
−
proto$1.isPM = localeIsPM;
+
−
proto$1.meridiem = localeMeridiem;
+
−
 
+
−
function get$1 (format, index, field, setter) {
+
−
    var locale = getLocale();
+
−
    var utc = createUTC().set(setter, index);
+
−
    return locale[field](utc, format);
+
−
}
+
−
 
+
−
function listMonthsImpl (format, index, field) {
+
−
    if (isNumber(format)) {
+
−
        index = format;
+
−
        format = undefined;
+
 
     }
 
     }
−
 
+
     function Yc(a) {
−
     format = format || '';
+
         return function() {
−
 
+
            return this.as(a)
−
    if (index != null) {
+
        }
−
         return get$1(format, index, field, 'month');
+
 
     }
 
     }
−
 
+
     function Zc(a) {
−
     var i;
+
        return a = K(a),
−
    var out = [];
+
         this[a + "s"]()
−
    for (i = 0; i < 12; i++) {
+
−
         out[i] = get$1(format, i, field, 'month');
+
 
     }
 
     }
−
     return out;
+
     function $c(a) {
−
}
+
         return function() {
−
 
+
             return this._data[a]
−
// ()
+
−
// (5)
+
−
// (fmt, 5)
+
−
// (fmt)
+
−
// (true)
+
−
// (true, 5)
+
−
// (true, fmt, 5)
+
−
// (true, fmt)
+
−
function listWeekdaysImpl (localeSorted, format, index, field) {
+
−
    if (typeof localeSorted === 'boolean') {
+
−
         if (isNumber(format)) {
+
−
             index = format;
+
−
            format = undefined;
+
 
         }
 
         }
−
 
−
        format = format || '';
 
−
    } else {
 
−
        format = localeSorted;
 
−
        index = format;
 
−
        localeSorted = false;
 
−
 
−
        if (isNumber(format)) {
 
−
            index = format;
 
−
            format = undefined;
 
−
        }
 
−
 
−
        format = format || '';
 
 
     }
 
     }
−
 
+
     function _c() {
−
     var locale = getLocale(),
+
         return q(this.days() / 7)
−
        shift = localeSorted ? locale._week.dow : 0;
+
−
 
+
−
    if (index != null) {
+
−
         return get$1(format, (index + shift) % 7, field, 'day');
+
 
     }
 
     }
−
 
+
     function ad(a, b, c, d, e) {
−
    var i;
+
         return e.relativeTime(b || 1, !!c, a, d)
−
    var out = [];
+
−
     for (i = 0; i < 7; i++) {
+
−
         out[i] = get$1(format, (i + shift) % 7, field, 'day');
+
 
     }
 
     }
−
     return out;
+
     function bd(a, b, c) {
−
}
+
        var d = db(a).abs()
−
 
+
          , e = _e(d.as("s"))
−
function listMonths (format, index) {
+
          , f = _e(d.as("m"))
−
    return listMonthsImpl(format, index, 'months');
+
          , g = _e(d.as("h"))
−
}
+
          , h = _e(d.as("d"))
−
 
+
          , i = _e(d.as("M"))
−
function listMonthsShort (format, index) {
+
          , j = _e(d.as("y"))
−
    return listMonthsImpl(format, index, 'monthsShort');
+
          , k = e < af.s && ["s", e] || 1 >= f && ["m"] || f < af.m && ["mm", f] || 1 >= g && ["h"] || g < af.h && ["hh", g] || 1 >= h && ["d"] || h < af.d && ["dd", h] || 1 >= i && ["M"] || i < af.M && ["MM", i] || 1 >= j && ["y"] || ["yy", j];
−
}
+
        return k[2] = b,
−
 
+
        k[3] = +a > 0,
−
function listWeekdays (localeSorted, format, index) {
+
        k[4] = c,
−
    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
+
         ad.apply(null, k)
−
}
+
−
 
+
−
function listWeekdaysShort (localeSorted, format, index) {
+
−
    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
+
−
}
+
−
 
+
−
function listWeekdaysMin (localeSorted, format, index) {
+
−
    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
+
−
}
+
−
 
+
−
getSetGlobalLocale('en', {
+
−
    dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+
−
    ordinal : function (number) {
+
−
        var b = number % 10,
+
−
            output = (toInt(number % 100 / 10) === 1) ? 'th' :
+
−
            (b === 1) ? 'st' :
+
−
            (b === 2) ? 'nd' :
+
−
            (b === 3) ? 'rd' : 'th';
+
−
         return number + output;
+
 
     }
 
     }
−
});
+
    function cd(a, b) {
−
 
+
         return void 0 === af[a] ? !1 : void 0 === b ? af[a] : (af[a] = b,
−
// Side effect imports
+
         !0)
−
hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
+
−
hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
+
−
 
+
−
var mathAbs = Math.abs;
+
−
 
+
−
function abs () {
+
−
    var data          = this._data;
+
−
 
+
−
    this._milliseconds = mathAbs(this._milliseconds);
+
−
    this._days         = mathAbs(this._days);
+
−
    this._months      = mathAbs(this._months);
+
−
 
+
−
    data.milliseconds  = mathAbs(data.milliseconds);
+
−
    data.seconds      = mathAbs(data.seconds);
+
−
    data.minutes      = mathAbs(data.minutes);
+
−
    data.hours        = mathAbs(data.hours);
+
−
    data.months        = mathAbs(data.months);
+
−
    data.years        = mathAbs(data.years);
+
−
 
+
−
    return this;
+
−
}
+
−
 
+
−
function addSubtract$1 (duration, input, value, direction) {
+
−
    var other = createDuration(input, value);
+
−
 
+
−
    duration._milliseconds += direction * other._milliseconds;
+
−
    duration._days         += direction * other._days;
+
−
    duration._months      += direction * other._months;
+
−
 
+
−
    return duration._bubble();
+
−
}
+
−
 
+
−
// supports only 2.0-style add(1, 's') or add(duration)
+
−
function add$1 (input, value) {
+
−
    return addSubtract$1(this, input, value, 1);
+
−
}
+
−
 
+
−
// supports only 2.0-style subtract(1, 's') or subtract(duration)
+
−
function subtract$1 (input, value) {
+
−
    return addSubtract$1(this, input, value, -1);
+
−
}
+
−
 
+
−
function absCeil (number) {
+
−
    if (number < 0) {
+
−
        return Math.floor(number);
+
−
    } else {
+
−
        return Math.ceil(number);
+
 
     }
 
     }
−
}
+
    function dd(a) {
−
 
+
         var b = this.localeData()
−
function bubble () {
+
          , c = bd(this, !a, b);
−
    var milliseconds = this._milliseconds;
+
        return a && (c = b.pastFuture(+this, c)),
−
    var days         = this._days;
+
         b.postformat(c)
−
    var months      = this._months;
+
−
    var data        = this._data;
+
−
    var seconds, minutes, hours, years, monthsFromDays;
+
−
 
+
−
    // if we have a mix of positive and negative values, bubble down first
+
−
    // check: https://github.com/moment/moment/issues/2166
+
−
    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
+
−
            (milliseconds <= 0 && days <= 0 && months <= 0))) {
+
−
         milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
+
−
        days = 0;
+
−
        months = 0;
+
 
     }
 
     }
−
 
+
     function ed() {
−
     // The following code bubbles up values, see the tests for
+
        var a, b, c, d = bf(this._milliseconds) / 1e3, e = bf(this._days), f = bf(this._months);
−
    // examples of what that means.
+
        a = q(d / 60),
−
    data.milliseconds = milliseconds % 1000;
+
        b = q(a / 60),
−
 
+
        d %= 60,
−
    seconds          = absFloor(milliseconds / 1000);
+
        a %= 60,
−
    data.seconds      = seconds % 60;
+
        c = q(f / 12),
−
 
+
        f %= 12;
−
    minutes          = absFloor(seconds / 60);
+
        var g = c
−
    data.minutes      = minutes % 60;
+
          , h = f
−
 
+
          , i = e
−
    hours            = absFloor(minutes / 60);
+
          , j = b
−
    data.hours        = hours % 24;
+
          , k = a
−
 
+
          , l = d
−
    days += absFloor(hours / 24);
+
          , m = this.asSeconds();
−
 
+
        return m ? (0 > m ? "-" : "") + "P" + (g ? g + "Y" : "") + (h ? h + "M" : "") + (i ? i + "D" : "") + (j || k || l ? "T" : "") + (j ? j + "H" : "") + (k ? k + "M" : "") + (l ? l + "S" : "") : "P0D"
−
    // convert days to months
+
−
    monthsFromDays = absFloor(daysToMonths(days));
+
−
    months += monthsFromDays;
+
−
    days -= absCeil(monthsToDays(monthsFromDays));
+
−
 
+
−
    // 12 months -> 1 year
+
−
    years = absFloor(months / 12);
+
−
    months %= 12;
+
−
 
+
−
    data.days  = days;
+
−
    data.months = months;
+
−
    data.years  = years;
+
−
 
+
−
    return this;
+
−
}
+
−
 
+
−
function daysToMonths (days) {
+
−
    // 400 years have 146097 days (taking into account leap year rules)
+
−
    // 400 years have 12 months === 4800
+
−
    return days * 4800 / 146097;
+
−
}
+
−
 
+
−
function monthsToDays (months) {
+
−
    // the reverse of daysToMonths
+
−
    return months * 146097 / 4800;
+
−
}
+
−
 
+
−
function as (units) {
+
−
    if (!this.isValid()) {
+
−
        return NaN;
+
 
     }
 
     }
−
     var days;
+
     var fd, gd;
−
     var months;
+
     gd = Array.prototype.some ? Array.prototype.some : function(a) {
−
    var milliseconds = this._milliseconds;
+
         for (var b = Object(this), c = b.length >>> 0, d = 0; c > d; d++)
−
 
+
             if (d in b && a.call(this, b[d], d, b))
−
    units = normalizeUnits(units);
+
                return !0;
−
 
+
         return !1
−
    if (units === 'month' || units === 'year') {
+
−
        days  = this._days  + milliseconds / 864e5;
+
−
        months = this._months + daysToMonths(days);
+
−
        return units === 'month' ? months : months / 12;
+
−
    } else {
+
−
         // handle milliseconds separately because of floating point math errors (issue #1867)
+
−
        days = this._days + Math.round(monthsToDays(this._months));
+
−
        switch (units) {
+
−
            case 'week'  : return days / 7    + milliseconds / 6048e5;
+
−
            case 'day'    : return days        + milliseconds / 864e5;
+
−
            case 'hour'  : return days * 24    + milliseconds / 36e5;
+
−
             case 'minute' : return days * 1440  + milliseconds / 6e4;
+
−
            case 'second' : return days * 86400 + milliseconds / 1000;
+
−
            // Math.floor prevents floating point math errors here
+
−
            case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
+
−
            default: throw new Error('Unknown unit ' + units);
+
−
         }
+
 
     }
 
     }
−
}
+
    ;
−
 
+
    var hd = a.momentProperties = []
−
// TODO: Use this.as('ms')?
+
      , id = !1
−
function valueOf$1 () {
+
      , jd = {};
−
    if (!this.isValid()) {
+
    a.suppressDeprecationWarnings = !1,
−
         return NaN;
+
    a.deprecationHandler = null;
 +
    var kd;
 +
    kd = Object.keys ? Object.keys : function(a) {
 +
        var b, c = [];
 +
        for (b in a)
 +
            f(a, b) && c.push(b);
 +
         return c
 
     }
 
     }
−
     return (
+
     ;
−
         this._milliseconds +
+
    var ld, md, nd = {}, od = {}, pd = /(\[[^\[]*\])|(\\)?([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, qd = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, rd = {}, sd = {}, td = /\d/, ud = /\d\d/, vd = /\d{3}/, wd = /\d{4}/, xd = /[+-]?\d{6}/, yd = /\d\d?/, zd = /\d\d\d\d?/, Ad = /\d\d\d\d\d\d?/, Bd = /\d{1,3}/, Cd = /\d{1,4}/, Dd = /[+-]?\d{1,6}/, Ed = /\d+/, Fd = /[+-]?\d+/, Gd = /Z|[+-]\d\d:?\d\d/gi, Hd = /Z|[+-]\d\d(?::?\d\d)?/gi, Id = /[+-]?\d+(\.\d{1,3})?/, Jd = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i, Kd = {}, Ld = {}, Md = 0, Nd = 1, Od = 2, Pd = 3, Qd = 4, Rd = 5, Sd = 6, Td = 7, Ud = 8;
−
         this._days * 864e5 +
+
    md = Array.prototype.indexOf ? Array.prototype.indexOf : function(a) {
−
         (this._months % 12) * 2592e6 +
+
         var b;
−
        toInt(this._months / 12) * 31536e6
+
        for (b = 0; b < this.length; ++b)
−
     );
+
            if (this[b] === a)
−
}
+
                return b;
−
 
+
         return -1
−
function makeAs (alias) {
+
    }
−
     return function () {
+
    ,
−
         return this.as(alias);
+
    R("M", ["MM", 2], "Mo", function() {
 +
        return this.month() + 1
 +
    }),
 +
    R("MMM", 0, 0, function(a) {
 +
         return this.localeData().monthsShort(this, a)
 +
    }),
 +
    R("MMMM", 0, 0, function(a) {
 +
        return this.localeData().months(this, a)
 +
    }),
 +
    J("month", "M"),
 +
    W("M", yd),
 +
    W("MM", yd, ud),
 +
    W("MMM", function(a, b) {
 +
        return b.monthsShortRegex(a)
 +
    }),
 +
    W("MMMM", function(a, b) {
 +
        return b.monthsRegex(a)
 +
    }),
 +
    $(["M", "MM"], function(a, b) {
 +
        b[Nd] = r(a) - 1
 +
    }),
 +
    $(["MMM", "MMMM"], function(a, b, c, d) {
 +
        var e = c._locale.monthsParse(a, d, c._strict);
 +
        null != e ? b[Nd] = e : j(c).invalidMonth = a
 +
    });
 +
    var Vd = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/
 +
      , Wd = "January_February_March_April_May_June_July_August_September_October_November_December".split("_")
 +
      , Xd = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_")
 +
      , Yd = Jd
 +
      , Zd = Jd
 +
      , $d = /^\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)?)?/
 +
      , _d = /^\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)?)?/
 +
      , ae = /Z|[+-]\d\d(?::?\d\d)?/
 +
      , be = [["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/], ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/], ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/], ["GGGG-[W]WW", /\d{4}-W\d\d/, !1], ["YYYY-DDD", /\d{4}-\d{3}/], ["YYYY-MM", /\d{4}-\d\d/, !1], ["YYYYYYMMDD", /[+-]\d{10}/], ["YYYYMMDD", /\d{8}/], ["GGGG[W]WWE", /\d{4}W\d{3}/], ["GGGG[W]WW", /\d{4}W\d{2}/, !1], ["YYYYDDD", /\d{7}/]]
 +
      , ce = [["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/], ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/], ["HH:mm:ss", /\d\d:\d\d:\d\d/], ["HH:mm", /\d\d:\d\d/], ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/], ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/], ["HHmmss", /\d\d\d\d\d\d/], ["HHmm", /\d\d\d\d/], ["HH", /\d\d/]]
 +
      , de = /^\/?Date\((\-?\d+)/i;
 +
     a.createFromInputFallback = u("moment construction falls back to js Date. This is discouraged and will be removed in upcoming major release. Please refer to https://github.com/moment/moment/issues/1407 for more info.", function(a) {
 +
        a._d = new Date(a._i + (a._useUTC ? " UTC" : ""))
 +
    }),
 +
    R("Y", 0, 0, function() {
 +
        var a = this.year();
 +
        return 9999 >= a ? "" + a : "+" + a
 +
    }),
 +
    R(0, ["YY", 2], 0, function() {
 +
        return this.year() % 100
 +
    }),
 +
    R(0, ["YYYY", 4], 0, "year"),
 +
    R(0, ["YYYYY", 5], 0, "year"),
 +
    R(0, ["YYYYYY", 6, !0], 0, "year"),
 +
    J("year", "y"),
 +
    W("Y", Fd),
 +
    W("YY", yd, ud),
 +
    W("YYYY", Cd, wd),
 +
    W("YYYYY", Dd, xd),
 +
    W("YYYYYY", Dd, xd),
 +
    $(["YYYYY", "YYYYYY"], Md),
 +
    $("YYYY", function(b, c) {
 +
        c[Md] = 2 === b.length ? a.parseTwoDigitYear(b) : r(b)
 +
     }),
 +
    $("YY", function(b, c) {
 +
        c[Md] = a.parseTwoDigitYear(b)
 +
    }),
 +
    $("Y", function(a, b) {
 +
        b[Md] = parseInt(a, 10)
 +
    }),
 +
    a.parseTwoDigitYear = function(a) {
 +
        return r(a) + (r(a) > 68 ? 1900 : 2e3)
 +
    }
 +
    ;
 +
    var ee = M("FullYear", !0);
 +
    a.ISO_8601 = function() {}
 +
    ;
 +
    var fe = u("moment().min is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548", function() {
 +
        var a = Ka.apply(null, arguments);
 +
         return this.isValid() && a.isValid() ? this > a ? this : a : l()
 +
    })
 +
      , ge = u("moment().max is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548", function() {
 +
        var a = Ka.apply(null, arguments);
 +
        return this.isValid() && a.isValid() ? a > this ? this : a : l()
 +
    })
 +
      , he = function() {
 +
        return Date.now ? Date.now() : +new Date
 
     };
 
     };
−
}
+
    Qa("Z", ":"),
−
 
+
    Qa("ZZ", ""),
−
var asMilliseconds = makeAs('ms');
+
    W("Z", Hd),
−
var asSeconds      = makeAs('s');
+
    W("ZZ", Hd),
−
var asMinutes      = makeAs('m');
+
    $(["Z", "ZZ"], function(a, b, c) {
−
var asHours        = makeAs('h');
+
        c._useUTC = !0,
−
var asDays        = makeAs('d');
+
        c._tzm = Ra(Hd, a)
−
var asWeeks        = makeAs('w');
+
    });
−
var asMonths       = makeAs('M');
+
    var ie = /([\+\-]|\d\d)/gi;
−
var asYears        = makeAs('y');
+
    a.updateOffset = function() {}
−
 
+
    ;
−
function get$2 (units) {
+
    var je = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/
−
    units = normalizeUnits(units);
+
       , ke = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
−
     return this.isValid() ? this[units + 's']() : NaN;
+
    db.fn = Oa.prototype;
−
}
+
    var le = ib(1, "add")
−
 
+
      , me = ib(-1, "subtract");
−
function makeGetter(name) {
+
    a.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ",
−
     return function () {
+
    a.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
−
         return this.isValid() ? this._data[name] : NaN;
+
    var ne = u("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.", function(a) {
 +
        return void 0 === a ? this.localeData() : this.locale(a)
 +
    });
 +
     R(0, ["gg", 2], 0, function() {
 +
        return this.weekYear() % 100
 +
    }),
 +
    R(0, ["GG", 2], 0, function() {
 +
        return this.isoWeekYear() % 100
 +
    }),
 +
    Pb("gggg", "weekYear"),
 +
    Pb("ggggg", "weekYear"),
 +
    Pb("GGGG", "isoWeekYear"),
 +
    Pb("GGGGG", "isoWeekYear"),
 +
    J("weekYear", "gg"),
 +
    J("isoWeekYear", "GG"),
 +
    W("G", Fd),
 +
    W("g", Fd),
 +
    W("GG", yd, ud),
 +
    W("gg", yd, ud),
 +
    W("GGGG", Cd, wd),
 +
    W("gggg", Cd, wd),
 +
    W("GGGGG", Dd, xd),
 +
    W("ggggg", Dd, xd),
 +
    _(["gggg", "ggggg", "GGGG", "GGGGG"], function(a, b, c, d) {
 +
        b[d.substr(0, 2)] = r(a)
 +
     }),
 +
    _(["gg", "GG"], function(b, c, d, e) {
 +
         c[e] = a.parseTwoDigitYear(b)
 +
    }),
 +
    R("Q", 0, "Qo", "quarter"),
 +
    J("quarter", "Q"),
 +
    W("Q", td),
 +
    $("Q", function(a, b) {
 +
        b[Nd] = 3 * (r(a) - 1)
 +
    }),
 +
    R("w", ["ww", 2], "wo", "week"),
 +
    R("W", ["WW", 2], "Wo", "isoWeek"),
 +
    J("week", "w"),
 +
    J("isoWeek", "W"),
 +
    W("w", yd),
 +
    W("ww", yd, ud),
 +
    W("W", yd),
 +
    W("WW", yd, ud),
 +
    _(["w", "ww", "W", "WW"], function(a, b, c, d) {
 +
        b[d.substr(0, 1)] = r(a)
 +
    });
 +
    var oe = {
 +
        dow: 0,
 +
        doy: 6
 
     };
 
     };
−
}
+
    R("D", ["DD", 2], "Do", "date"),
−
 
+
    J("date", "D"),
−
var milliseconds = makeGetter('milliseconds');
+
    W("D", yd),
−
var seconds      = makeGetter('seconds');
+
    W("DD", yd, ud),
−
var minutes      = makeGetter('minutes');
+
    W("Do", function(a, b) {
−
var hours        = makeGetter('hours');
+
        return a ? b._ordinalParse : b._ordinalParseLenient
−
var days         = makeGetter('days');
+
    }),
−
var months       = makeGetter('months');
+
    $(["D", "DD"], Od),
−
var years        = makeGetter('years');
+
    $("Do", function(a, b) {
−
 
+
        b[Od] = r(a.match(yd)[0], 10)
−
function weeks () {
+
    });
−
     return absFloor(this.days() / 7);
+
    var pe = M("Date", !0);
−
}
+
    R("d", 0, "do", "day"),
−
 
+
    R("dd", 0, 0, function(a) {
−
var round = Math.round;
+
        return this.localeData().weekdaysMin(this, a)
−
var thresholds = {
+
    }),
−
     ss: 44,        // a few seconds to seconds
+
    R("ddd", 0, 0, function(a) {
−
     s : 45,         // seconds to minute
+
        return this.localeData().weekdaysShort(this, a)
−
     m : 45,        // minutes to hour
+
    }),
−
     h : 22,         // hours to day
+
    R("dddd", 0, 0, function(a) {
−
     d : 26,         // days to month
+
        return this.localeData().weekdays(this, a)
−
     M : 11          // months to year
+
    }),
−
};
+
    R("e", 0, 0, "weekday"),
−
 
+
    R("E", 0, 0, "isoWeekday"),
−
// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+
    J("day", "d"),
−
function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
+
    J("weekday", "e"),
−
    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+
    J("isoWeekday", "E"),
−
}
+
    W("d", yd),
−
 
+
    W("e", yd),
−
function relativeTime$1 (posNegDuration, withoutSuffix, locale) {
+
    W("E", yd),
−
    var duration = createDuration(posNegDuration).abs();
+
    W("dd", function(a, b) {
−
    var seconds  = round(duration.as('s'));
+
        return b.weekdaysMinRegex(a)
−
     var minutes  = round(duration.as('m'));
+
    }),
−
    var hours    = round(duration.as('h'));
+
    W("ddd", function(a, b) {
−
     var days     = round(duration.as('d'));
+
        return b.weekdaysShortRegex(a)
−
    var months  = round(duration.as('M'));
+
    }),
−
    var years    = round(duration.as('y'));
+
    W("dddd", function(a, b) {
−
 
+
        return b.weekdaysRegex(a)
−
     var a = seconds <= thresholds.ss && ['s', seconds] ||
+
    }),
−
            seconds < thresholds.s  && ['ss', seconds] ||
+
    _(["dd", "ddd", "dddd"], function(a, b, c, d) {
−
            minutes <= 1             && ['m']           ||
+
        var e = c._locale.weekdaysParse(a, d, c._strict);
−
            minutes < thresholds.m  && ['mm', minutes] ||
+
        null != e ? b.d = e : j(c).invalidWeekday = a
−
            hours  <= 1             && ['h']           ||
+
    }),
−
            hours  < thresholds.h  && ['hh', hours]   ||
+
    _(["d", "e", "E"], function(a, b, c, d) {
−
            days    <= 1            && ['d']           ||
+
         b[d] = r(a)
−
            days    < thresholds.d  && ['dd', days]   ||
+
    });
−
            months  <= 1            && ['M']           ||
+
    var qe = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_")
−
            months  < thresholds.M  && ['MM', months] ||
+
       , re = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_")
−
            years  <= 1            && ['y']           || ['yy', years];
+
      , se = "Su_Mo_Tu_We_Th_Fr_Sa".split("_")
−
 
+
      , te = Jd
−
     a[2] = withoutSuffix;
+
      , ue = Jd
−
     a[3] = +posNegDuration > 0;
+
      , ve = Jd;
−
     a[4] = locale;
+
    R("DDD", ["DDDD", 3], "DDDo", "dayOfYear"),
−
     return substituteTimeAgo.apply(null, a);
+
    J("dayOfYear", "DDD"),
−
}
+
    W("DDD", Bd),
−
 
+
    W("DDDD", vd),
−
// This function allows you to set the rounding function for relative time strings
+
    $(["DDD", "DDDD"], function(a, b, c) {
−
function getSetRelativeTimeRounding (roundingFunction) {
+
        c._dayOfYear = r(a)
−
     if (roundingFunction === undefined) {
+
     }),
−
         return round;
+
    R("H", ["HH", 2], 0, "hour"),
 +
    R("h", ["hh", 2], 0, oc),
 +
    R("k", ["kk", 2], 0, pc),
 +
    R("hmm", 0, 0, function() {
 +
        return "" + oc.apply(this) + Q(this.minutes(), 2)
 +
    }),
 +
    R("hmmss", 0, 0, function() {
 +
        return "" + oc.apply(this) + Q(this.minutes(), 2) + Q(this.seconds(), 2)
 +
    }),
 +
     R("Hmm", 0, 0, function() {
 +
         return "" + this.hours() + Q(this.minutes(), 2)
 +
     }),
 +
     R("Hmmss", 0, 0, function() {
 +
         return "" + this.hours() + Q(this.minutes(), 2) + Q(this.seconds(), 2)
 +
    }),
 +
    qc("a", !0),
 +
    qc("A", !1),
 +
    J("hour", "h"),
 +
     W("a", rc),
 +
    W("A", rc),
 +
    W("H", yd),
 +
    W("h", yd),
 +
     W("HH", yd, ud),
 +
     W("hh", yd, ud),
 +
    W("hmm", zd),
 +
    W("hmmss", Ad),
 +
    W("Hmm", zd),
 +
    W("Hmmss", Ad),
 +
    $(["H", "HH"], Pd),
 +
    $(["a", "A"], function(a, b, c) {
 +
        c._isPm = c._locale.isPM(a),
 +
        c._meridiem = a
 +
    }),
 +
    $(["h", "hh"], function(a, b, c) {
 +
        b[Pd] = r(a),
 +
        j(c).bigHour = !0
 +
    }),
 +
    $("hmm", function(a, b, c) {
 +
        var d = a.length - 2;
 +
        b[Pd] = r(a.substr(0, d)),
 +
        b[Qd] = r(a.substr(d)),
 +
        j(c).bigHour = !0
 +
    }),
 +
    $("hmmss", function(a, b, c) {
 +
        var d = a.length - 4
 +
          , e = a.length - 2;
 +
        b[Pd] = r(a.substr(0, d)),
 +
        b[Qd] = r(a.substr(d, 2)),
 +
        b[Rd] = r(a.substr(e)),
 +
        j(c).bigHour = !0
 +
     }),
 +
    $("Hmm", function(a, b, c) {
 +
        var d = a.length - 2;
 +
        b[Pd] = r(a.substr(0, d)),
 +
        b[Qd] = r(a.substr(d))
 +
     }),
 +
     $("Hmmss", function(a, b, c) {
 +
        var d = a.length - 4
 +
          , e = a.length - 2;
 +
        b[Pd] = r(a.substr(0, d)),
 +
        b[Qd] = r(a.substr(d, 2)),
 +
        b[Rd] = r(a.substr(e))
 +
    });
 +
     var we = /[ap]\.?m?\.?/i
 +
      , xe = M("Hours", !0);
 +
    R("m", ["mm", 2], 0, "minute"),
 +
    J("minute", "m"),
 +
    W("m", yd),
 +
    W("mm", yd, ud),
 +
    $(["m", "mm"], Qd);
 +
    var ye = M("Minutes", !1);
 +
    R("s", ["ss", 2], 0, "second"),
 +
    J("second", "s"),
 +
    W("s", yd),
 +
    W("ss", yd, ud),
 +
    $(["s", "ss"], Rd);
 +
    var ze = M("Seconds", !1);
 +
    R("S", 0, 0, function() {
 +
        return ~~(this.millisecond() / 100)
 +
    }),
 +
    R(0, ["SS", 2], 0, function() {
 +
        return ~~(this.millisecond() / 10)
 +
    }),
 +
    R(0, ["SSS", 3], 0, "millisecond"),
 +
    R(0, ["SSSS", 4], 0, function() {
 +
        return 10 * this.millisecond()
 +
    }),
 +
    R(0, ["SSSSS", 5], 0, function() {
 +
        return 100 * this.millisecond()
 +
    }),
 +
    R(0, ["SSSSSS", 6], 0, function() {
 +
        return 1e3 * this.millisecond()
 +
    }),
 +
    R(0, ["SSSSSSS", 7], 0, function() {
 +
        return 1e4 * this.millisecond()
 +
    }),
 +
    R(0, ["SSSSSSSS", 8], 0, function() {
 +
        return 1e5 * this.millisecond()
 +
    }),
 +
    R(0, ["SSSSSSSSS", 9], 0, function() {
 +
        return 1e6 * this.millisecond()
 +
    }),
 +
    J("millisecond", "ms"),
 +
    W("S", Bd, td),
 +
    W("SS", Bd, ud),
 +
    W("SSS", Bd, vd);
 +
    var Ae;
 +
     for (Ae = "SSSS"; Ae.length <= 9; Ae += "S")
 +
        W(Ae, Ed);
 +
     for (Ae = "S"; Ae.length <= 9; Ae += "S")
 +
        $(Ae, uc);
 +
     var Be = M("Milliseconds", !1);
 +
     R("z", 0, 0, "zoneAbbr"),
 +
    R("zz", 0, 0, "zoneName");
 +
    var Ce = o.prototype;
 +
    Ce.add = le,
 +
    Ce.calendar = kb,
 +
    Ce.clone = lb,
 +
    Ce.diff = sb,
 +
    Ce.endOf = Eb,
 +
    Ce.format = wb,
 +
    Ce.from = xb,
 +
    Ce.fromNow = yb,
 +
    Ce.to = zb,
 +
    Ce.toNow = Ab,
 +
    Ce.get = P,
 +
    Ce.invalidAt = Nb,
 +
    Ce.isAfter = mb,
 +
    Ce.isBefore = nb,
 +
    Ce.isBetween = ob,
 +
    Ce.isSame = pb,
 +
    Ce.isSameOrAfter = qb,
 +
    Ce.isSameOrBefore = rb,
 +
    Ce.isValid = Lb,
 +
    Ce.lang = ne,
 +
    Ce.locale = Bb,
 +
    Ce.localeData = Cb,
 +
    Ce.max = ge,
 +
    Ce.min = fe,
 +
    Ce.parsingFlags = Mb,
 +
    Ce.set = P,
 +
    Ce.startOf = Db,
 +
    Ce.subtract = me,
 +
    Ce.toArray = Ib,
 +
    Ce.toObject = Jb,
 +
    Ce.toDate = Hb,
 +
    Ce.toISOString = vb,
 +
    Ce.toJSON = Kb,
 +
    Ce.toString = ub,
 +
    Ce.unix = Gb,
 +
    Ce.valueOf = Fb,
 +
    Ce.creationData = Ob,
 +
    Ce.year = ee,
 +
    Ce.isLeapYear = ta,
 +
    Ce.weekYear = Qb,
 +
    Ce.isoWeekYear = Rb,
 +
    Ce.quarter = Ce.quarters = Wb,
 +
    Ce.month = ha,
 +
    Ce.daysInMonth = ia,
 +
    Ce.week = Ce.weeks = $b,
 +
    Ce.isoWeek = Ce.isoWeeks = _b,
 +
    Ce.weeksInYear = Tb,
 +
    Ce.isoWeeksInYear = Sb,
 +
    Ce.date = pe,
 +
    Ce.day = Ce.days = gc,
 +
    Ce.weekday = hc,
 +
    Ce.isoWeekday = ic,
 +
    Ce.dayOfYear = nc,
 +
    Ce.hour = Ce.hours = xe,
 +
    Ce.minute = Ce.minutes = ye,
 +
    Ce.second = Ce.seconds = ze,
 +
    Ce.millisecond = Ce.milliseconds = Be,
 +
    Ce.utcOffset = Ua,
 +
    Ce.utc = Wa,
 +
    Ce.local = Xa,
 +
    Ce.parseZone = Ya,
 +
    Ce.hasAlignedHourOffset = Za,
 +
    Ce.isDST = $a,
 +
    Ce.isDSTShifted = _a,
 +
    Ce.isLocal = ab,
 +
    Ce.isUtcOffset = bb,
 +
    Ce.isUtc = cb,
 +
    Ce.isUTC = cb,
 +
    Ce.zoneAbbr = vc,
 +
    Ce.zoneName = wc,
 +
    Ce.dates = u("dates accessor is deprecated. Use date instead.", pe),
 +
     Ce.months = u("months accessor is deprecated. Use month instead", ha),
 +
    Ce.years = u("years accessor is deprecated. Use year instead", ee),
 +
    Ce.zone = u("moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779", Va);
 +
    var De = Ce
 +
      , Ee = {
 +
         sameDay: "[Today at] LT",
 +
        nextDay: "[Tomorrow at] LT",
 +
        nextWeek: "dddd [at] LT",
 +
        lastDay: "[Yesterday at] LT",
 +
        lastWeek: "[Last] dddd [at] LT",
 +
        sameElse: "L"
 
     }
 
     }
−
    if (typeof(roundingFunction) === 'function') {
+
      , Fe = {
−
         round = roundingFunction;
+
         LTS: "h:mm:ss A",
−
         return true;
+
        LT: "h:mm A",
 +
        L: "MM/DD/YYYY",
 +
        LL: "MMMM D, YYYY",
 +
        LLL: "MMMM D, YYYY h:mm A",
 +
         LLLL: "dddd, MMMM D, YYYY h:mm A"
 
     }
 
     }
−
    return false;
+
      , Ge = "Invalid date"
−
}
+
      , He = "%d"
−
 
+
      , Ie = /\d{1,2}/
−
// This function allows you to set a threshold for relative time strings
+
      , Je = {
−
function getSetRelativeTimeThreshold (threshold, limit) {
+
         future: "in %s",
−
    if (thresholds[threshold] === undefined) {
+
        past: "%s ago",
−
         return false;
+
        s: "a few seconds",
 +
        m: "a minute",
 +
        mm: "%d minutes",
 +
        h: "an hour",
 +
        hh: "%d hours",
 +
        d: "a day",
 +
        dd: "%d days",
 +
        M: "a month",
 +
        MM: "%d months",
 +
        y: "a year",
 +
        yy: "%d years"
 
     }
 
     }
−
     if (limit === undefined) {
+
      , Ke = A.prototype;
−
         return thresholds[threshold];
+
     Ke._calendar = Ee,
 +
    Ke.calendar = zc,
 +
    Ke._longDateFormat = Fe,
 +
    Ke.longDateFormat = Ac,
 +
    Ke._invalidDate = Ge,
 +
    Ke.invalidDate = Bc,
 +
    Ke._ordinal = He,
 +
    Ke.ordinal = Cc,
 +
    Ke._ordinalParse = Ie,
 +
    Ke.preparse = Dc,
 +
    Ke.postformat = Dc,
 +
    Ke._relativeTime = Je,
 +
    Ke.relativeTime = Ec,
 +
    Ke.pastFuture = Fc,
 +
    Ke.set = y,
 +
    Ke.months = ca,
 +
    Ke._months = Wd,
 +
    Ke.monthsShort = da,
 +
    Ke._monthsShort = Xd,
 +
    Ke.monthsParse = fa,
 +
    Ke._monthsRegex = Zd,
 +
    Ke.monthsRegex = ka,
 +
    Ke._monthsShortRegex = Yd,
 +
    Ke.monthsShortRegex = ja,
 +
    Ke.week = Xb,
 +
    Ke._week = oe,
 +
    Ke.firstDayOfYear = Zb,
 +
    Ke.firstDayOfWeek = Yb,
 +
    Ke.weekdays = bc,
 +
    Ke._weekdays = qe,
 +
    Ke.weekdaysMin = dc,
 +
    Ke._weekdaysMin = se,
 +
    Ke.weekdaysShort = cc,
 +
    Ke._weekdaysShort = re,
 +
    Ke.weekdaysParse = fc,
 +
    Ke._weekdaysRegex = te,
 +
    Ke.weekdaysRegex = jc,
 +
    Ke._weekdaysShortRegex = ue,
 +
    Ke.weekdaysShortRegex = kc,
 +
    Ke._weekdaysMinRegex = ve,
 +
    Ke.weekdaysMinRegex = lc,
 +
    Ke.isPM = sc,
 +
    Ke._meridiemParse = we,
 +
    Ke.meridiem = tc,
 +
    E("en", {
 +
         ordinalParse: /\d{1,2}(th|st|nd|rd)/,
 +
        ordinal: function(a) {
 +
            var b = a % 10
 +
              , c = 1 === r(a % 100 / 10) ? "th" : 1 === b ? "st" : 2 === b ? "nd" : 3 === b ? "rd" : "th";
 +
            return a + c
 +
        }
 +
    }),
 +
    a.lang = u("moment.lang is deprecated. Use moment.locale instead.", E),
 +
    a.langData = u("moment.langData is deprecated. Use moment.localeData instead.", H);
 +
    var Le = Math.abs
 +
      , Me = Yc("ms")
 +
      , Ne = Yc("s")
 +
      , Oe = Yc("m")
 +
      , Pe = Yc("h")
 +
      , Qe = Yc("d")
 +
      , Re = Yc("w")
 +
      , Se = Yc("M")
 +
      , Te = Yc("y")
 +
      , Ue = $c("milliseconds")
 +
      , Ve = $c("seconds")
 +
      , We = $c("minutes")
 +
      , Xe = $c("hours")
 +
      , Ye = $c("days")
 +
      , Ze = $c("months")
 +
      , $e = $c("years")
 +
      , _e = Math.round
 +
      , af = {
 +
        s: 45,
 +
        m: 45,
 +
        h: 22,
 +
        d: 26,
 +
        M: 11
 
     }
 
     }
−
    thresholds[threshold] = limit;
+
      , bf = Math.abs
−
    if (threshold === 's') {
+
       , cf = Oa.prototype;
−
        thresholds.ss = limit - 1;
+
     cf.abs = Oc,
−
    }
+
    cf.add = Qc,
−
    return true;
+
    cf.subtract = Rc,
−
}
+
    cf.as = Wc,
−
 
+
    cf.asMilliseconds = Me,
−
function humanize (withSuffix) {
+
    cf.asSeconds = Ne,
−
    if (!this.isValid()) {
+
    cf.asMinutes = Oe,
−
        return this.localeData().invalidDate();
+
    cf.asHours = Pe,
−
    }
+
    cf.asDays = Qe,
−
 
+
    cf.asWeeks = Re,
−
    var locale = this.localeData();
+
    cf.asMonths = Se,
−
    var output = relativeTime$1(this, !withSuffix, locale);
+
    cf.asYears = Te,
−
 
+
    cf.valueOf = Xc,
−
    if (withSuffix) {
+
    cf._bubble = Tc,
−
        output = locale.pastFuture(+this, output);
+
    cf.get = Zc,
−
    }
+
    cf.milliseconds = Ue,
−
 
+
    cf.seconds = Ve,
−
    return locale.postformat(output);
+
    cf.minutes = We,
−
}
+
    cf.hours = Xe,
−
 
+
    cf.days = Ye,
−
var abs$1 = Math.abs;
+
    cf.weeks = _c,
−
 
+
    cf.months = Ze,
−
function toISOString$1() {
+
    cf.years = $e,
−
    // for ISO strings we do not use the normal bubbling rules:
+
    cf.humanize = dd,
−
    //  * milliseconds bubble up until they become hours
+
    cf.toISOString = ed,
−
    //  * days do not bubble at all
+
    cf.toString = ed,
−
    //  * months bubble up until they become years
+
    cf.toJSON = ed,
−
    // This is because there is no context-free conversion between hours and days
+
    cf.locale = Bb,
−
    // (think of clock changes)
+
    cf.localeData = Cb,
−
    // and also not between days and months (28-31 days per month)
+
    cf.toIsoString = u("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)", ed),
−
    if (!this.isValid()) {
+
    cf.lang = ne,
−
        return this.localeData().invalidDate();
+
    R("X", 0, 0, "unix"),
−
    }
+
    R("x", 0, 0, "valueOf"),
−
 
+
    W("x", Fd),
−
    var seconds = abs$1(this._milliseconds) / 1000;
+
    W("X", Id),
−
    var days        = abs$1(this._days);
+
    $("X", function(a, b, c) {
−
    var months       = abs$1(this._months);
+
        c._d = new Date(1e3 * parseFloat(a, 10))
−
    var minutes, hours, years;
+
    }),
−
 
+
    $("x", function(a, b, c) {
−
    // 3600 seconds -> 60 minutes -> 1 hour
+
        c._d = new Date(r(a))
−
    minutes          = absFloor(seconds / 60);
+
    }),
−
    hours            = absFloor(minutes / 60);
+
    a.version = "2.13.0",
−
    seconds %= 60;
+
    b(Ka),
−
    minutes %= 60;
+
    a.fn = De,
−
 
+
    a.min = Ma,
−
    // 12 months -> 1 year
+
    a.max = Na,
−
    years  = absFloor(months / 12);
+
    a.now = he,
−
    months %= 12;
+
    a.utc = h,
−
 
+
    a.unix = xc,
−
 
+
    a.months = Jc,
−
    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+
    a.isDate = d,
−
    var Y = years;
+
    a.locale = E,
−
     var M = months;
+
    a.invalid = l,
−
    var D = days;
+
    a.duration = db,
−
    var h = hours;
+
    a.isMoment = p,
−
    var m = minutes;
+
    a.weekdays = Lc,
−
    var s = seconds;
+
    a.parseZone = yc,
−
    var total = this.asSeconds();
+
    a.localeData = H,
−
 
+
    a.isDuration = Pa,
−
    if (!total) {
+
    a.monthsShort = Kc,
−
        // this is the same as C#'s (Noda) and python (isodate)...
+
    a.weekdaysMin = Nc,
−
        // but not other JS (goog.date)
+
    a.defineLocale = F,
−
        return 'P0D';
+
    a.updateLocale = G,
−
    }
+
    a.locales = I,
−
 
+
    a.weekdaysShort = Mc,
−
    return (total < 0 ? '-' : '') +
+
    a.normalizeUnits = K,
−
        'P' +
+
    a.relativeTimeThreshold = cd,
−
        (Y ? Y + 'Y' : '') +
+
    a.prototype = De;
−
        (M ? M + 'M' : '') +
+
    var df = a;
−
        (D ? D + 'D' : '') +
+
    return df
−
        ((h || m || s) ? 'T' : '') +
+
−
        (h ? h + 'H' : '') +
+
−
        (m ? m + 'M' : '') +
+
−
        (s ? s + 'S' : '');
+
−
}
+
−
 
+
−
var proto$2 = Duration.prototype;
+
−
 
+
−
proto$2.isValid        = isValid$1;
+
−
proto$2.abs           = abs;
+
−
proto$2.add           = add$1;
+
−
proto$2.subtract       = subtract$1;
+
−
proto$2.as             = as;
+
−
proto$2.asMilliseconds = asMilliseconds;
+
−
proto$2.asSeconds     = asSeconds;
+
−
proto$2.asMinutes     = asMinutes;
+
−
proto$2.asHours       = asHours;
+
−
proto$2.asDays         = asDays;
+
−
proto$2.asWeeks       = asWeeks;
+
−
proto$2.asMonths       = asMonths;
+
−
proto$2.asYears       = asYears;
+
−
proto$2.valueOf       = valueOf$1;
+
−
proto$2._bubble       = bubble;
+
−
proto$2.get           = get$2;
+
−
proto$2.milliseconds   = milliseconds;
+
−
proto$2.seconds       = seconds;
+
−
proto$2.minutes       = minutes;
+
−
proto$2.hours         = hours;
+
−
proto$2.days           = days;
+
−
proto$2.weeks         = weeks;
+
−
proto$2.months         = months;
+
−
proto$2.years         = years;
+
−
proto$2.humanize       = humanize;
+
−
proto$2.toISOString   = toISOString$1;
+
−
proto$2.toString       = toISOString$1;
+
−
proto$2.toJSON         = toISOString$1;
+
−
proto$2.locale         = locale;
+
−
proto$2.localeData     = localeData;
+
−
 
+
−
// Deprecations
+
−
proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
+
−
proto$2.lang = lang;
+
−
 
+
−
// Side effect imports
+
−
 
+
−
// FORMATTING
+
−
 
+
−
addFormatToken('X', 0, 0, 'unix');
+
−
addFormatToken('x', 0, 0, 'valueOf');
+
−
 
+
−
// PARSING
+
−
 
+
−
addRegexToken('x', matchSigned);
+
−
addRegexToken('X', matchTimestamp);
+
−
addParseToken('X', function (input, array, config) {
+
−
    config._d = new Date(parseFloat(input, 10) * 1000);
+
−
});
+
−
addParseToken('x', function (input, array, config) {
+
−
    config._d = new Date(toInt(input));
+
 
});
 
});
−
 
−
// Side effect imports
 
−
 
−
 
−
hooks.version = '2.18.1';
 
−
 
−
setHookCallback(createLocal);
 
−
 
−
hooks.fn                    = proto;
 
−
hooks.min                  = min;
 
−
hooks.max                  = max;
 
−
hooks.now                  = now;
 
−
hooks.utc                  = createUTC;
 
−
hooks.unix                  = createUnix;
 
−
hooks.months                = listMonths;
 
−
hooks.isDate                = isDate;
 
−
hooks.locale                = getSetGlobalLocale;
 
−
hooks.invalid              = createInvalid;
 
−
hooks.duration              = createDuration;
 
−
hooks.isMoment              = isMoment;
 
−
hooks.weekdays              = listWeekdays;
 
−
hooks.parseZone            = createInZone;
 
−
hooks.localeData            = getLocale;
 
−
hooks.isDuration            = isDuration;
 
−
hooks.monthsShort          = listMonthsShort;
 
−
hooks.weekdaysMin          = listWeekdaysMin;
 
−
hooks.defineLocale          = defineLocale;
 
−
hooks.updateLocale          = updateLocale;
 
−
hooks.locales              = listLocales;
 
−
hooks.weekdaysShort        = listWeekdaysShort;
 
−
hooks.normalizeUnits        = normalizeUnits;
 
−
hooks.relativeTimeRounding = getSetRelativeTimeRounding;
 
−
hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
 
−
hooks.calendarFormat        = getCalendarFormat;
 
−
hooks.prototype            = proto;
 
−
 
−
return hooks;
 
−
 
−
})));
 

Latest revision as of 10:49, 6 July 2017

//! moment.js //! version : 2.13.0 //! authors : Tim Wood, Iskren Chernev, Moment.js contributors //! license : MIT //! momentjs.com !function(a, b) { 

   "object" == typeof exports && "undefined" != typeof module ? module.exports = b() : "function" == typeof define && define.amd ? define(b) : a.moment = b()

}(this, function() { 

   "use strict";
   function a() {
       return fd.apply(null, arguments)
   }
   function b(a) {
       fd = a
   }
   function c(a) {
       return a instanceof Array || "[object Array]" === Object.prototype.toString.call(a)
   }
   function d(a) {
       return a instanceof Date || "[object Date]" === Object.prototype.toString.call(a)
   }
   function e(a, b) {
       var c, d = [];
       for (c = 0; c < a.length; ++c)
           d.push(b(a[c], c));
       return d
   }
   function f(a, b) {
       return Object.prototype.hasOwnProperty.call(a, b)
   }
   function g(a, b) {
       for (var c in b)
           f(b, c) && (a[c] = b[c]);
       return f(b, "toString") && (a.toString = b.toString),
       f(b, "valueOf") && (a.valueOf = b.valueOf),
       a
   }
   function h(a, b, c, d) {
       return Ja(a, b, c, d, !0).utc()
   }
   function i() {
       return {
           empty: !1,
           unusedTokens: [],
           unusedInput: [],
           overflow: -2,
           charsLeftOver: 0,
           nullInput: !1,
           invalidMonth: null,
           invalidFormat: !1,
           userInvalidated: !1,
           iso: !1,
           parsedDateParts: [],
           meridiem: null
       }
   }
   function j(a) {
       return null == a._pf && (a._pf = i()),
       a._pf
   }
   function k(a) {
       if (null == a._isValid) {
           var b = j(a)
             , c = gd.call(b.parsedDateParts, function(a) {
               return null != a
           });
           a._isValid = !isNaN(a._d.getTime()) && b.overflow < 0 && !b.empty && !b.invalidMonth && !b.invalidWeekday && !b.nullInput && !b.invalidFormat && !b.userInvalidated && (!b.meridiem || b.meridiem && c),
           a._strict && (a._isValid = a._isValid && 0 === b.charsLeftOver && 0 === b.unusedTokens.length && void 0 === b.bigHour)
       }
       return a._isValid
   }
   function l(a) {
       var b = h(NaN);
       return null != a ? g(j(b), a) : j(b).userInvalidated = !0,
       b
   }
   function m(a) {
       return void 0 === a
   }
   function n(a, b) {
       var c, d, e;
       if (m(b._isAMomentObject) || (a._isAMomentObject = b._isAMomentObject),
       m(b._i) || (a._i = b._i),
       m(b._f) || (a._f = b._f),
       m(b._l) || (a._l = b._l),
       m(b._strict) || (a._strict = b._strict),
       m(b._tzm) || (a._tzm = b._tzm),
       m(b._isUTC) || (a._isUTC = b._isUTC),
       m(b._offset) || (a._offset = b._offset),
       m(b._pf) || (a._pf = j(b)),
       m(b._locale) || (a._locale = b._locale),
       hd.length > 0)
           for (c in hd)
               d = hd[c],
               e = b[d],
               m(e) || (a[d] = e);
       return a
   }
   function o(b) {
       n(this, b),
       this._d = new Date(null != b._d ? b._d.getTime() : NaN),
       id === !1 && (id = !0,
       a.updateOffset(this),
       id = !1)
   }
   function p(a) {
       return a instanceof o || null != a && null != a._isAMomentObject
   }
   function q(a) {
       return 0 > a ? Math.ceil(a) : Math.floor(a)
   }
   function r(a) {
       var b = +a
         , c = 0;
       return 0 !== b && isFinite(b) && (c = q(b)),
       c
   }
   function s(a, b, c) {
       var d, e = Math.min(a.length, b.length), f = Math.abs(a.length - b.length), g = 0;
       for (d = 0; e > d; d++)
           (c && a[d] !== b[d] || !c && r(a[d]) !== r(b[d])) && g++;
       return g + f
   }
   function t(b) {
       a.suppressDeprecationWarnings === !1 && "undefined" != typeof console && console.warn && console.warn("Deprecation warning: " + b)
   }
   function u(b, c) {
       var d = !0;
       return g(function() {
           return null != a.deprecationHandler && a.deprecationHandler(null, b),
           d && (t(b + "\nArguments: " + Array.prototype.slice.call(arguments).join(", ") + "\n" + (new Error).stack),
           d = !1),
           c.apply(this, arguments)
       }, c)
   }
   function v(b, c) {
       null != a.deprecationHandler && a.deprecationHandler(b, c),
       jd[b] || (t(c),
       jd[b] = !0)
   }
   function w(a) {
       return a instanceof Function || "[object Function]" === Object.prototype.toString.call(a)
   }
   function x(a) {
       return "[object Object]" === Object.prototype.toString.call(a)
   }
   function y(a) {
       var b, c;
       for (c in a)
           b = a[c],
           w(b) ? this[c] = b : this["_" + c] = b;
       this._config = a,
       this._ordinalParseLenient = new RegExp(this._ordinalParse.source + "|" + /\d{1,2}/.source)
   }
   function z(a, b) {
       var c, d = g({}, a);
       for (c in b)
           f(b, c) && (x(a[c]) && x(b[c]) ? (d[c] = {},
           g(d[c], a[c]),
           g(d[c], b[c])) : null != b[c] ? d[c] = b[c] : delete d[c]);
       return d
   }
   function A(a) {
       null != a && this.set(a)
   }
   function B(a) {
       return a ? a.toLowerCase().replace("_", "-") : a
   }
   function C(a) {
       for (var b, c, d, e, f = 0; f < a.length; ) {
           for (e = B(a[f]).split("-"),
           b = e.length,
           c = B(a[f + 1]),
           c = c ? c.split("-") : null; b > 0; ) {
               if (d = D(e.slice(0, b).join("-")))
                   return d;
               if (c && c.length >= b && s(e, c, !0) >= b - 1)
                   break;
               b--
           }
           f++
       }
       return null
   }
   function D(a) {
       var b = null;
       if (!nd[a] && "undefined" != typeof module && module && module.exports)
           try {
               b = ld._abbr,
               require("./locale/" + a),
               E(b)
           } catch (c) {}
       return nd[a]
   }
   function E(a, b) {
       var c;
       return a && (c = m(b) ? H(a) : F(a, b),
       c && (ld = c)),
       ld._abbr
   }
   function F(a, b) {
       return null !== b ? (b.abbr = a,
       null != nd[a] ? (v("defineLocaleOverride", "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale"),
       b = z(nd[a]._config, b)) : null != b.parentLocale && (null != nd[b.parentLocale] ? b = z(nd[b.parentLocale]._config, b) : v("parentLocaleUndefined", "specified parentLocale is not defined yet")),
       nd[a] = new A(b),
       E(a),
       nd[a]) : (delete nd[a],
       null)
   }
   function G(a, b) {
       if (null != b) {
           var c;
           null != nd[a] && (b = z(nd[a]._config, b)),
           c = new A(b),
           c.parentLocale = nd[a],
           nd[a] = c,
           E(a)
       } else
           null != nd[a] && (null != nd[a].parentLocale ? nd[a] = nd[a].parentLocale : null != nd[a] && delete nd[a]);
       return nd[a]
   }
   function H(a) {
       var b;
       if (a && a._locale && a._locale._abbr && (a = a._locale._abbr),
       !a)
           return ld;
       if (!c(a)) {
           if (b = D(a))
               return b;
           a = [a]
       }
       return C(a)
   }
   function I() {
       return kd(nd)
   }
   function J(a, b) {
       var c = a.toLowerCase();
       od[c] = od[c + "s"] = od[b] = a
   }
   function K(a) {
       return "string" == typeof a ? od[a] || od[a.toLowerCase()] : void 0
   }
   function L(a) {
       var b, c, d = {};
       for (c in a)
           f(a, c) && (b = K(c),
           b && (d[b] = a[c]));
       return d
   }
   function M(b, c) {
       return function(d) {
           return null != d ? (O(this, b, d),
           a.updateOffset(this, c),
           this) : N(this, b)
       }
   }
   function N(a, b) {
       return a.isValid() ? a._d["get" + (a._isUTC ? "UTC" : "") + b]() : NaN
   }
   function O(a, b, c) {
       a.isValid() && a._d["set" + (a._isUTC ? "UTC" : "") + b](c)
   }
   function P(a, b) {
       var c;
       if ("object" == typeof a)
           for (c in a)
               this.set(c, a[c]);
       else if (a = K(a),
       w(this[a]))
           return this[a](b);
       return this
   }
   function Q(a, b, c) {
       var d = "" + Math.abs(a)
         , e = b - d.length
         , f = a >= 0;
       return (f ? c ? "+" : "" : "-") + Math.pow(10, Math.max(0, e)).toString().substr(1) + d
   }
   function R(a, b, c, d) {
       var e = d;
       "string" == typeof d && (e = function() {
           return this[d]()
       }
       ),
       a && (sd[a] = e),
       b && (sd[b[0]] = function() {
           return Q(e.apply(this, arguments), b[1], b[2])
       }
       ),
       c && (sd[c] = function() {
           return this.localeData().ordinal(e.apply(this, arguments), a)
       }
       )
   }
   function S(a) {
       return a.match(/\[[\s\S]/) ? a.replace(/^\[|\]$/g, "") : a.replace(/\\/g, "")
   }
   function T(a) {
       var b, c, d = a.match(pd);
       for (b = 0,
       c = d.length; c > b; b++)
           sd[d[b]] ? d[b] = sd[d[b]] : d[b] = S(d[b]);
       return function(b) {
           var e, f = "";
           for (e = 0; c > e; e++)
               f += d[e]instanceof Function ? d[e].call(b, a) : d[e];
           return f
       }
   }
   function U(a, b) {
       return a.isValid() ? (b = V(b, a.localeData()),
       rd[b] = rd[b] || T(b),
       rd[b](a)) : a.localeData().invalidDate()
   }
   function V(a, b) {
       function c(a) {
           return b.longDateFormat(a) || a
       }
       var d = 5;
       for (qd.lastIndex = 0; d >= 0 && qd.test(a); )
           a = a.replace(qd, c),
           qd.lastIndex = 0,
           d -= 1;
       return a
   }
   function W(a, b, c) {
       Kd[a] = w(b) ? b : function(a, d) {
           return a && c ? c : b
       }
   }
   function X(a, b) {
       return f(Kd, a) ? Kd[a](b._strict, b._locale) : new RegExp(Y(a))
   }
   function Y(a) {
       return Z(a.replace("\\", "").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function(a, b, c, d, e) {
           return b || c || d || e
       }))
   }
   function Z(a) {
       return a.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")
   }
   function $(a, b) {
       var c, d = b;
       for ("string" == typeof a && (a = [a]),
       "number" == typeof b && (d = function(a, c) {
           c[b] = r(a)
       }
       ),
       c = 0; c < a.length; c++)
           Ld[a[c]] = d
   }
   function _(a, b) {
       $(a, function(a, c, d, e) {
           d._w = d._w || {},
           b(a, d._w, d, e)
       })
   }
   function aa(a, b, c) {
       null != b && f(Ld, a) && Ld[a](b, c._a, c, a)
   }
   function ba(a, b) {
       return new Date(Date.UTC(a, b + 1, 0)).getUTCDate()
   }
   function ca(a, b) {
       return c(this._months) ? this._months[a.month()] : this._months[Vd.test(b) ? "format" : "standalone"][a.month()]
   }
   function da(a, b) {
       return c(this._monthsShort) ? this._monthsShort[a.month()] : this._monthsShort[Vd.test(b) ? "format" : "standalone"][a.month()]
   }
   function ea(a, b, c) {
       var d, e, f, g = a.toLocaleLowerCase();
       if (!this._monthsParse)
           for (this._monthsParse = [],
           this._longMonthsParse = [],
           this._shortMonthsParse = [],
           d = 0; 12 > d; ++d)
               f = h([2e3, d]),
               this._shortMonthsParse[d] = this.monthsShort(f, "").toLocaleLowerCase(),
               this._longMonthsParse[d] = this.months(f, "").toLocaleLowerCase();
       return c ? "MMM" === b ? (e = md.call(this._shortMonthsParse, g),
       -1 !== e ? e : null) : (e = md.call(this._longMonthsParse, g),
       -1 !== e ? e : null) : "MMM" === b ? (e = md.call(this._shortMonthsParse, g),
       -1 !== e ? e : (e = md.call(this._longMonthsParse, g),
       -1 !== e ? e : null)) : (e = md.call(this._longMonthsParse, g),
       -1 !== e ? e : (e = md.call(this._shortMonthsParse, g),
       -1 !== e ? e : null))
   }
   function fa(a, b, c) {
       var d, e, f;
       if (this._monthsParseExact)
           return ea.call(this, a, b, c);
       for (this._monthsParse || (this._monthsParse = [],
       this._longMonthsParse = [],
       this._shortMonthsParse = []),
       d = 0; 12 > d; d++) {
           if (e = h([2e3, d]),
           c && !this._longMonthsParse[d] && (this._longMonthsParse[d] = new RegExp("^" + this.months(e, "").replace(".", "") + "$","i"),
           this._shortMonthsParse[d] = new RegExp("^" + this.monthsShort(e, "").replace(".", "") + "$","i")),
           c || this._monthsParse[d] || (f = "^" + this.months(e, "") + "|^" + this.monthsShort(e, ""),
           this._monthsParse[d] = new RegExp(f.replace(".", ""),"i")),
           c && "MMMM" === b && this._longMonthsParse[d].test(a))
               return d;
           if (c && "MMM" === b && this._shortMonthsParse[d].test(a))
               return d;
           if (!c && this._monthsParse[d].test(a))
               return d
       }
   }
   function ga(a, b) {
       var c;
       if (!a.isValid())
           return a;
       if ("string" == typeof b)
           if (/^\d+$/.test(b))
               b = r(b);
           else if (b = a.localeData().monthsParse(b),
           "number" != typeof b)
               return a;
       return c = Math.min(a.date(), ba(a.year(), b)),
       a._d["set" + (a._isUTC ? "UTC" : "") + "Month"](b, c),
       a
   }
   function ha(b) {
       return null != b ? (ga(this, b),
       a.updateOffset(this, !0),
       this) : N(this, "Month")
   }
   function ia() {
       return ba(this.year(), this.month())
   }
   function ja(a) {
       return this._monthsParseExact ? (f(this, "_monthsRegex") || la.call(this),
       a ? this._monthsShortStrictRegex : this._monthsShortRegex) : this._monthsShortStrictRegex && a ? this._monthsShortStrictRegex : this._monthsShortRegex
   }
   function ka(a) {
       return this._monthsParseExact ? (f(this, "_monthsRegex") || la.call(this),
       a ? this._monthsStrictRegex : this._monthsRegex) : this._monthsStrictRegex && a ? this._monthsStrictRegex : this._monthsRegex
   }
   function la() {
       function a(a, b) {
           return b.length - a.length
       }
       var b, c, d = [], e = [], f = [];
       for (b = 0; 12 > b; b++)
           c = h([2e3, b]),
           d.push(this.monthsShort(c, "")),
           e.push(this.months(c, "")),
           f.push(this.months(c, "")),
           f.push(this.monthsShort(c, ""));
       for (d.sort(a),
       e.sort(a),
       f.sort(a),
       b = 0; 12 > b; b++)
           d[b] = Z(d[b]),
           e[b] = Z(e[b]),
           f[b] = Z(f[b]);
       this._monthsRegex = new RegExp("^(" + f.join("|") + ")","i"),
       this._monthsShortRegex = this._monthsRegex,
       this._monthsStrictRegex = new RegExp("^(" + e.join("|") + ")","i"),
       this._monthsShortStrictRegex = new RegExp("^(" + d.join("|") + ")","i")
   }
   function ma(a) {
       var b, c = a._a;
       return c && -2 === j(a).overflow && (b = c[Nd] < 0 || c[Nd] > 11 ? Nd : c[Od] < 1 || c[Od] > ba(c[Md], c[Nd]) ? Od : c[Pd] < 0 || c[Pd] > 24 || 24 === c[Pd] && (0 !== c[Qd] || 0 !== c[Rd] || 0 !== c[Sd]) ? Pd : c[Qd] < 0 || c[Qd] > 59 ? Qd : c[Rd] < 0 || c[Rd] > 59 ? Rd : c[Sd] < 0 || c[Sd] > 999 ? Sd : -1,
       j(a)._overflowDayOfYear && (Md > b || b > Od) && (b = Od),
       j(a)._overflowWeeks && -1 === b && (b = Td),
       j(a)._overflowWeekday && -1 === b && (b = Ud),
       j(a).overflow = b),
       a
   }
   function na(a) {
       var b, c, d, e, f, g, h = a._i, i = $d.exec(h) || _d.exec(h);
       if (i) {
           for (j(a).iso = !0,
           b = 0,
           c = be.length; c > b; b++)
               if (be[b][1].exec(i[1])) {
                   e = be[b][0],
                   d = be[b][2] !== !1;
                   break
               }
           if (null == e)
               return void (a._isValid = !1);
           if (i[3]) {
               for (b = 0,
               c = ce.length; c > b; b++)
                   if (ce[b][1].exec(i[3])) {
                       f = (i[2] || " ") + ce[b][0];
                       break
                   }
               if (null == f)
                   return void (a._isValid = !1)
           }
           if (!d && null != f)
               return void (a._isValid = !1);
           if (i[4]) {
               if (!ae.exec(i[4]))
                   return void (a._isValid = !1);
               g = "Z"
           }
           a._f = e + (f || "") + (g || ""),
           Ca(a)
       } else
           a._isValid = !1
   }
   function oa(b) {
       var c = de.exec(b._i);
       return null !== c ? void (b._d = new Date(+c[1])) : (na(b),
       void (b._isValid === !1 && (delete b._isValid,
       a.createFromInputFallback(b))))
   }
   function pa(a, b, c, d, e, f, g) {
       var h = new Date(a,b,c,d,e,f,g);
       return 100 > a && a >= 0 && isFinite(h.getFullYear()) && h.setFullYear(a),
       h
   }
   function qa(a) {
       var b = new Date(Date.UTC.apply(null, arguments));
       return 100 > a && a >= 0 && isFinite(b.getUTCFullYear()) && b.setUTCFullYear(a),
       b
   }
   function ra(a) {
       return sa(a) ? 366 : 365
   }
   function sa(a) {
       return a % 4 === 0 && a % 100 !== 0 || a % 400 === 0
   }
   function ta() {
       return sa(this.year())
   }
   function ua(a, b, c) {
       var d = 7 + b - c
         , e = (7 + qa(a, 0, d).getUTCDay() - b) % 7;
       return -e + d - 1
   }
   function va(a, b, c, d, e) {
       var f, g, h = (7 + c - d) % 7, i = ua(a, d, e), j = 1 + 7 * (b - 1) + h + i;
       return 0 >= j ? (f = a - 1,
       g = ra(f) + j) : j > ra(a) ? (f = a + 1,
       g = j - ra(a)) : (f = a,
       g = j),
       {
           year: f,
           dayOfYear: g
       }
   }
   function wa(a, b, c) {
       var d, e, f = ua(a.year(), b, c), g = Math.floor((a.dayOfYear() - f - 1) / 7) + 1;
       return 1 > g ? (e = a.year() - 1,
       d = g + xa(e, b, c)) : g > xa(a.year(), b, c) ? (d = g - xa(a.year(), b, c),
       e = a.year() + 1) : (e = a.year(),
       d = g),
       {
           week: d,
           year: e
       }
   }
   function xa(a, b, c) {
       var d = ua(a, b, c)
         , e = ua(a + 1, b, c);
       return (ra(a) - d + e) / 7
   }
   function ya(a, b, c) {
       return null != a ? a : null != b ? b : c
   }
   function za(b) {
       var c = new Date(a.now());
       return b._useUTC ? [c.getUTCFullYear(), c.getUTCMonth(), c.getUTCDate()] : [c.getFullYear(), c.getMonth(), c.getDate()]
   }
   function Aa(a) {
       var b, c, d, e, f = [];
       if (!a._d) {
           for (d = za(a),
           a._w && null == a._a[Od] && null == a._a[Nd] && Ba(a),
           a._dayOfYear && (e = ya(a._a[Md], d[Md]),
           a._dayOfYear > ra(e) && (j(a)._overflowDayOfYear = !0),
           c = qa(e, 0, a._dayOfYear),
           a._a[Nd] = c.getUTCMonth(),
           a._a[Od] = c.getUTCDate()),
           b = 0; 3 > b && null == a._a[b]; ++b)
               a._a[b] = f[b] = d[b];
           for (; 7 > b; b++)
               a._a[b] = f[b] = null == a._a[b] ? 2 === b ? 1 : 0 : a._a[b];
           24 === a._a[Pd] && 0 === a._a[Qd] && 0 === a._a[Rd] && 0 === a._a[Sd] && (a._nextDay = !0,
           a._a[Pd] = 0),
           a._d = (a._useUTC ? qa : pa).apply(null, f),
           null != a._tzm && a._d.setUTCMinutes(a._d.getUTCMinutes() - a._tzm),
           a._nextDay && (a._a[Pd] = 24)
       }
   }
   function Ba(a) {
       var b, c, d, e, f, g, h, i;
       b = a._w,
       null != b.GG || null != b.W || null != b.E ? (f = 1,
       g = 4,
       c = ya(b.GG, a._a[Md], wa(Ka(), 1, 4).year),
       d = ya(b.W, 1),
       e = ya(b.E, 1),
       (1 > e || e > 7) && (i = !0)) : (f = a._locale._week.dow,
       g = a._locale._week.doy,
       c = ya(b.gg, a._a[Md], wa(Ka(), f, g).year),
       d = ya(b.w, 1),
       null != b.d ? (e = b.d,
       (0 > e || e > 6) && (i = !0)) : null != b.e ? (e = b.e + f,
       (b.e < 0 || b.e > 6) && (i = !0)) : e = f),
       1 > d || d > xa(c, f, g) ? j(a)._overflowWeeks = !0 : null != i ? j(a)._overflowWeekday = !0 : (h = va(c, d, e, f, g),
       a._a[Md] = h.year,
       a._dayOfYear = h.dayOfYear)
   }
   function Ca(b) {
       if (b._f === a.ISO_8601)
           return void na(b);
       b._a = [],
       j(b).empty = !0;
       var c, d, e, f, g, h = "" + b._i, i = h.length, k = 0;
       for (e = V(b._f, b._locale).match(pd) || [],
       c = 0; c < e.length; c++)
           f = e[c],
           d = (h.match(X(f, b)) || [])[0],
           d && (g = h.substr(0, h.indexOf(d)),
           g.length > 0 && j(b).unusedInput.push(g),
           h = h.slice(h.indexOf(d) + d.length),
           k += d.length),
           sd[f] ? (d ? j(b).empty = !1 : j(b).unusedTokens.push(f),
           aa(f, d, b)) : b._strict && !d && j(b).unusedTokens.push(f);
       j(b).charsLeftOver = i - k,
       h.length > 0 && j(b).unusedInput.push(h),
       j(b).bigHour === !0 && b._a[Pd] <= 12 && b._a[Pd] > 0 && (j(b).bigHour = void 0),
       j(b).parsedDateParts = b._a.slice(0),
       j(b).meridiem = b._meridiem,
       b._a[Pd] = Da(b._locale, b._a[Pd], b._meridiem),
       Aa(b),
       ma(b)
   }
   function Da(a, b, c) {
       var d;
       return null == c ? b : null != a.meridiemHour ? a.meridiemHour(b, c) : null != a.isPM ? (d = a.isPM(c),
       d && 12 > b && (b += 12),
       d || 12 !== b || (b = 0),
       b) : b
   }
   function Ea(a) {
       var b, c, d, e, f;
       if (0 === a._f.length)
           return j(a).invalidFormat = !0,
           void (a._d = new Date(NaN));
       for (e = 0; e < a._f.length; e++)
           f = 0,
           b = n({}, a),
           null != a._useUTC && (b._useUTC = a._useUTC),
           b._f = a._f[e],
           Ca(b),
           k(b) && (f += j(b).charsLeftOver,
           f += 10 * j(b).unusedTokens.length,
           j(b).score = f,
           (null == d || d > f) && (d = f,
           c = b));
       g(a, c || b)
   }
   function Fa(a) {
       if (!a._d) {
           var b = L(a._i);
           a._a = e([b.year, b.month, b.day || b.date, b.hour, b.minute, b.second, b.millisecond], function(a) {
               return a && parseInt(a, 10)
           }),
           Aa(a)
       }
   }
   function Ga(a) {
       var b = new o(ma(Ha(a)));
       return b._nextDay && (b.add(1, "d"),
       b._nextDay = void 0),
       b
   }
   function Ha(a) {
       var b = a._i
         , e = a._f;
       return a._locale = a._locale || H(a._l),
       null === b || void 0 === e && "" === b ? l({
           nullInput: !0
       }) : ("string" == typeof b && (a._i = b = a._locale.preparse(b)),
       p(b) ? new o(ma(b)) : (c(e) ? Ea(a) : e ? Ca(a) : d(b) ? a._d = b : Ia(a),
       k(a) || (a._d = null),
       a))
   }
   function Ia(b) {
       var f = b._i;
       void 0 === f ? b._d = new Date(a.now()) : d(f) ? b._d = new Date(f.valueOf()) : "string" == typeof f ? oa(b) : c(f) ? (b._a = e(f.slice(0), function(a) {
           return parseInt(a, 10)
       }),
       Aa(b)) : "object" == typeof f ? Fa(b) : "number" == typeof f ? b._d = new Date(f) : a.createFromInputFallback(b)
   }
   function Ja(a, b, c, d, e) {
       var f = {};
       return "boolean" == typeof c && (d = c,
       c = void 0),
       f._isAMomentObject = !0,
       f._useUTC = f._isUTC = e,
       f._l = c,
       f._i = a,
       f._f = b,
       f._strict = d,
       Ga(f)
   }
   function Ka(a, b, c, d) {
       return Ja(a, b, c, d, !1)
   }
   function La(a, b) {
       var d, e;
       if (1 === b.length && c(b[0]) && (b = b[0]),
       !b.length)
           return Ka();
       for (d = b[0],
       e = 1; e < b.length; ++e)
           (!b[e].isValid() || b[e][a](d)) && (d = b[e]);
       return d
   }
   function Ma() {
       var a = [].slice.call(arguments, 0);
       return La("isBefore", a)
   }
   function Na() {
       var a = [].slice.call(arguments, 0);
       return La("isAfter", a)
   }
   function Oa(a) {
       var b = L(a)
         , c = b.year || 0
         , d = b.quarter || 0
         , e = b.month || 0
         , f = b.week || 0
         , g = b.day || 0
         , h = b.hour || 0
         , i = b.minute || 0
         , j = b.second || 0
         , k = b.millisecond || 0;
       this._milliseconds = +k + 1e3 * j + 6e4 * i + 1e3 * h * 60 * 60,
       this._days = +g + 7 * f,
       this._months = +e + 3 * d + 12 * c,
       this._data = {},
       this._locale = H(),
       this._bubble()
   }
   function Pa(a) {
       return a instanceof Oa
   }
   function Qa(a, b) {
       R(a, 0, 0, function() {
           var a = this.utcOffset()
             , c = "+";
           return 0 > a && (a = -a,
           c = "-"),
           c + Q(~~(a / 60), 2) + b + Q(~~a % 60, 2)
       })
   }
   function Ra(a, b) {
       var c = (b || "").match(a) || []
         , d = c[c.length - 1] || []
         , e = (d + "").match(ie) || ["-", 0, 0]
         , f = +(60 * e[1]) + r(e[2]);
       return "+" === e[0] ? f : -f
   }
   function Sa(b, c) {
       var e, f;
       return c._isUTC ? (e = c.clone(),
       f = (p(b) || d(b) ? b.valueOf() : Ka(b).valueOf()) - e.valueOf(),
       e._d.setTime(e._d.valueOf() + f),
       a.updateOffset(e, !1),
       e) : Ka(b).local()
   }
   function Ta(a) {
       return 15 * -Math.round(a._d.getTimezoneOffset() / 15)
   }
   function Ua(b, c) {
       var d, e = this._offset || 0;
       return this.isValid() ? null != b ? ("string" == typeof b ? b = Ra(Hd, b) : Math.abs(b) < 16 && (b = 60 * b),
       !this._isUTC && c && (d = Ta(this)),
       this._offset = b,
       this._isUTC = !0,
       null != d && this.add(d, "m"),
       e !== b && (!c || this._changeInProgress ? jb(this, db(b - e, "m"), 1, !1) : this._changeInProgress || (this._changeInProgress = !0,
       a.updateOffset(this, !0),
       this._changeInProgress = null)),
       this) : this._isUTC ? e : Ta(this) : null != b ? this : NaN
   }
   function Va(a, b) {
       return null != a ? ("string" != typeof a && (a = -a),
       this.utcOffset(a, b),
       this) : -this.utcOffset()
   }
   function Wa(a) {
       return this.utcOffset(0, a)
   }
   function Xa(a) {
       return this._isUTC && (this.utcOffset(0, a),
       this._isUTC = !1,
       a && this.subtract(Ta(this), "m")),
       this
   }
   function Ya() {
       return this._tzm ? this.utcOffset(this._tzm) : "string" == typeof this._i && this.utcOffset(Ra(Gd, this._i)),
       this
   }
   function Za(a) {
       return this.isValid() ? (a = a ? Ka(a).utcOffset() : 0,
       (this.utcOffset() - a) % 60 === 0) : !1
   }
   function $a() {
       return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset()
   }
   function _a() {
       if (!m(this._isDSTShifted))
           return this._isDSTShifted;
       var a = {};
       if (n(a, this),
       a = Ha(a),
       a._a) {
           var b = a._isUTC ? h(a._a) : Ka(a._a);
           this._isDSTShifted = this.isValid() && s(a._a, b.toArray()) > 0
       } else
           this._isDSTShifted = !1;
       return this._isDSTShifted
   }
   function ab() {
       return this.isValid() ? !this._isUTC : !1
   }
   function bb() {
       return this.isValid() ? this._isUTC : !1
   }
   function cb() {
       return this.isValid() ? this._isUTC && 0 === this._offset : !1
   }
   function db(a, b) {
       var c, d, e, g = a, h = null;
       return Pa(a) ? g = {
           ms: a._milliseconds,
           d: a._days,
           M: a._months
       } : "number" == typeof a ? (g = {},
       b ? g[b] = a : g.milliseconds = a) : (h = je.exec(a)) ? (c = "-" === h[1] ? -1 : 1,
       g = {
           y: 0,
           d: r(h[Od]) * c,
           h: r(h[Pd]) * c,
           m: r(h[Qd]) * c,
           s: r(h[Rd]) * c,
           ms: r(h[Sd]) * c
       }) : (h = ke.exec(a)) ? (c = "-" === h[1] ? -1 : 1,
       g = {
           y: eb(h[2], c),
           M: eb(h[3], c),
           w: eb(h[4], c),
           d: eb(h[5], c),
           h: eb(h[6], c),
           m: eb(h[7], c),
           s: eb(h[8], c)
       }) : null == g ? g = {} : "object" == typeof g && ("from"in g || "to"in g) && (e = gb(Ka(g.from), Ka(g.to)),
       g = {},
       g.ms = e.milliseconds,
       g.M = e.months),
       d = new Oa(g),
       Pa(a) && f(a, "_locale") && (d._locale = a._locale),
       d
   }
   function eb(a, b) {
       var c = a && parseFloat(a.replace(",", "."));
       return (isNaN(c) ? 0 : c) * b
   }
   function fb(a, b) {
       var c = {
           milliseconds: 0,
           months: 0
       };
       return c.months = b.month() - a.month() + 12 * (b.year() - a.year()),
       a.clone().add(c.months, "M").isAfter(b) && --c.months,
       c.milliseconds = +b - +a.clone().add(c.months, "M"),
       c
   }
   function gb(a, b) {
       var c;
       return a.isValid() && b.isValid() ? (b = Sa(b, a),
       a.isBefore(b) ? c = fb(a, b) : (c = fb(b, a),
       c.milliseconds = -c.milliseconds,
       c.months = -c.months),
       c) : {
           milliseconds: 0,
           months: 0
       }
   }
   function hb(a) {
       return 0 > a ? -1 * Math.round(-1 * a) : Math.round(a)
   }
   function ib(a, b) {
       return function(c, d) {
           var e, f;
           return null === d || isNaN(+d) || (v(b, "moment()." + b + "(period, number) is deprecated. Please use moment()." + b + "(number, period)."),
           f = c,
           c = d,
           d = f),
           c = "string" == typeof c ? +c : c,
           e = db(c, d),
           jb(this, e, a),
           this
       }
   }
   function jb(b, c, d, e) {
       var f = c._milliseconds
         , g = hb(c._days)
         , h = hb(c._months);
       b.isValid() && (e = null == e ? !0 : e,
       f && b._d.setTime(b._d.valueOf() + f * d),
       g && O(b, "Date", N(b, "Date") + g * d),
       h && ga(b, N(b, "Month") + h * d),
       e && a.updateOffset(b, g || h))
   }
   function kb(a, b) {
       var c = a || Ka()
         , d = Sa(c, this).startOf("day")
         , e = this.diff(d, "days", !0)
         , f = -6 > e ? "sameElse" : -1 > e ? "lastWeek" : 0 > e ? "lastDay" : 1 > e ? "sameDay" : 2 > e ? "nextDay" : 7 > e ? "nextWeek" : "sameElse"
         , g = b && (w(b[f]) ? b[f]() : b[f]);
       return this.format(g || this.localeData().calendar(f, this, Ka(c)))
   }
   function lb() {
       return new o(this)
   }
   function mb(a, b) {
       var c = p(a) ? a : Ka(a);
       return this.isValid() && c.isValid() ? (b = K(m(b) ? "millisecond" : b),
       "millisecond" === b ? this.valueOf() > c.valueOf() : c.valueOf() < this.clone().startOf(b).valueOf()) : !1
   }
   function nb(a, b) {
       var c = p(a) ? a : Ka(a);
       return this.isValid() && c.isValid() ? (b = K(m(b) ? "millisecond" : b),
       "millisecond" === b ? this.valueOf() < c.valueOf() : this.clone().endOf(b).valueOf() < c.valueOf()) : !1
   }
   function ob(a, b, c, d) {
       return d = d || "()",
       ("(" === d[0] ? this.isAfter(a, c) : !this.isBefore(a, c)) && (")" === d[1] ? this.isBefore(b, c) : !this.isAfter(b, c))
   }
   function pb(a, b) {
       var c, d = p(a) ? a : Ka(a);
       return this.isValid() && d.isValid() ? (b = K(b || "millisecond"),
       "millisecond" === b ? this.valueOf() === d.valueOf() : (c = d.valueOf(),
       this.clone().startOf(b).valueOf() <= c && c <= this.clone().endOf(b).valueOf())) : !1
   }
   function qb(a, b) {
       return this.isSame(a, b) || this.isAfter(a, b)
   }
   function rb(a, b) {
       return this.isSame(a, b) || this.isBefore(a, b)
   }
   function sb(a, b, c) {
       var d, e, f, g;
       return this.isValid() ? (d = Sa(a, this),
       d.isValid() ? (e = 6e4 * (d.utcOffset() - this.utcOffset()),
       b = K(b),
       "year" === b || "month" === b || "quarter" === b ? (g = tb(this, d),
       "quarter" === b ? g /= 3 : "year" === b && (g /= 12)) : (f = this - d,
       g = "second" === b ? f / 1e3 : "minute" === b ? f / 6e4 : "hour" === b ? f / 36e5 : "day" === b ? (f - e) / 864e5 : "week" === b ? (f - e) / 6048e5 : f),
       c ? g : q(g)) : NaN) : NaN
   }
   function tb(a, b) {
       var c, d, e = 12 * (b.year() - a.year()) + (b.month() - a.month()), f = a.clone().add(e, "months");
       return 0 > b - f ? (c = a.clone().add(e - 1, "months"),
       d = (b - f) / (f - c)) : (c = a.clone().add(e + 1, "months"),
       d = (b - f) / (c - f)),
       -(e + d) || 0
   }
   function ub() {
       return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")
   }
   function vb() {
       var a = this.clone().utc();
       return 0 < a.year() && a.year() <= 9999 ? w(Date.prototype.toISOString) ? this.toDate().toISOString() : U(a, "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]") : U(a, "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]")
   }
   function wb(b) {
       b || (b = this.isUtc() ? a.defaultFormatUtc : a.defaultFormat);
       var c = U(this, b);
       return this.localeData().postformat(c)
   }
   function xb(a, b) {
       return this.isValid() && (p(a) && a.isValid() || Ka(a).isValid()) ? db({
           to: this,
           from: a
       }).locale(this.locale()).humanize(!b) : this.localeData().invalidDate()
   }
   function yb(a) {
       return this.from(Ka(), a)
   }
   function zb(a, b) {
       return this.isValid() && (p(a) && a.isValid() || Ka(a).isValid()) ? db({
           from: this,
           to: a
       }).locale(this.locale()).humanize(!b) : this.localeData().invalidDate()
   }
   function Ab(a) {
       return this.to(Ka(), a)
   }
   function Bb(a) {
       var b;
       return void 0 === a ? this._locale._abbr : (b = H(a),
       null != b && (this._locale = b),
       this)
   }
   function Cb() {
       return this._locale
   }
   function Db(a) {
       switch (a = K(a)) {
       case "year":
           this.month(0);
       case "quarter":
       case "month":
           this.date(1);
       case "week":
       case "isoWeek":
       case "day":
       case "date":
           this.hours(0);
       case "hour":
           this.minutes(0);
       case "minute":
           this.seconds(0);
       case "second":
           this.milliseconds(0)
       }
       return "week" === a && this.weekday(0),
       "isoWeek" === a && this.isoWeekday(1),
       "quarter" === a && this.month(3 * Math.floor(this.month() / 3)),
       this
   }
   function Eb(a) {
       return a = K(a),
       void 0 === a || "millisecond" === a ? this : ("date" === a && (a = "day"),
       this.startOf(a).add(1, "isoWeek" === a ? "week" : a).subtract(1, "ms"))
   }
   function Fb() {
       return this._d.valueOf() - 6e4 * (this._offset || 0)
   }
   function Gb() {
       return Math.floor(this.valueOf() / 1e3)
   }
   function Hb() {
       return this._offset ? new Date(this.valueOf()) : this._d
   }
   function Ib() {
       var a = this;
       return [a.year(), a.month(), a.date(), a.hour(), a.minute(), a.second(), a.millisecond()]
   }
   function Jb() {
       var a = this;
       return {
           years: a.year(),
           months: a.month(),
           date: a.date(),
           hours: a.hours(),
           minutes: a.minutes(),
           seconds: a.seconds(),
           milliseconds: a.milliseconds()
       }
   }
   function Kb() {
       return this.isValid() ? this.toISOString() : null
   }
   function Lb() {
       return k(this)
   }
   function Mb() {
       return g({}, j(this))
   }
   function Nb() {
       return j(this).overflow
   }
   function Ob() {
       return {
           input: this._i,
           format: this._f,
           locale: this._locale,
           isUTC: this._isUTC,
           strict: this._strict
       }
   }
   function Pb(a, b) {
       R(0, [a, a.length], 0, b)
   }
   function Qb(a) {
       return Ub.call(this, a, this.week(), this.weekday(), this.localeData()._week.dow, this.localeData()._week.doy)
   }
   function Rb(a) {
       return Ub.call(this, a, this.isoWeek(), this.isoWeekday(), 1, 4)
   }
   function Sb() {
       return xa(this.year(), 1, 4)
   }
   function Tb() {
       var a = this.localeData()._week;
       return xa(this.year(), a.dow, a.doy)
   }
   function Ub(a, b, c, d, e) {
       var f;
       return null == a ? wa(this, d, e).year : (f = xa(a, d, e),
       b > f && (b = f),
       Vb.call(this, a, b, c, d, e))
   }
   function Vb(a, b, c, d, e) {
       var f = va(a, b, c, d, e)
         , g = qa(f.year, 0, f.dayOfYear);
       return this.year(g.getUTCFullYear()),
       this.month(g.getUTCMonth()),
       this.date(g.getUTCDate()),
       this
   }
   function Wb(a) {
       return null == a ? Math.ceil((this.month() + 1) / 3) : this.month(3 * (a - 1) + this.month() % 3)
   }
   function Xb(a) {
       return wa(a, this._week.dow, this._week.doy).week
   }
   function Yb() {
       return this._week.dow
   }
   function Zb() {
       return this._week.doy
   }
   function $b(a) {
       var b = this.localeData().week(this);
       return null == a ? b : this.add(7 * (a - b), "d")
   }
   function _b(a) {
       var b = wa(this, 1, 4).week;
       return null == a ? b : this.add(7 * (a - b), "d")
   }
   function ac(a, b) {
       return "string" != typeof a ? a : isNaN(a) ? (a = b.weekdaysParse(a),
       "number" == typeof a ? a : null) : parseInt(a, 10)
   }
   function bc(a, b) {
       return c(this._weekdays) ? this._weekdays[a.day()] : this._weekdays[this._weekdays.isFormat.test(b) ? "format" : "standalone"][a.day()]
   }
   function cc(a) {
       return this._weekdaysShort[a.day()]
   }
   function dc(a) {
       return this._weekdaysMin[a.day()]
   }
   function ec(a, b, c) {
       var d, e, f, g = a.toLocaleLowerCase();
       if (!this._weekdaysParse)
           for (this._weekdaysParse = [],
           this._shortWeekdaysParse = [],
           this._minWeekdaysParse = [],
           d = 0; 7 > d; ++d)
               f = h([2e3, 1]).day(d),
               this._minWeekdaysParse[d] = this.weekdaysMin(f, "").toLocaleLowerCase(),
               this._shortWeekdaysParse[d] = this.weekdaysShort(f, "").toLocaleLowerCase(),
               this._weekdaysParse[d] = this.weekdays(f, "").toLocaleLowerCase();
       return c ? "dddd" === b ? (e = md.call(this._weekdaysParse, g),
       -1 !== e ? e : null) : "ddd" === b ? (e = md.call(this._shortWeekdaysParse, g),
       -1 !== e ? e : null) : (e = md.call(this._minWeekdaysParse, g),
       -1 !== e ? e : null) : "dddd" === b ? (e = md.call(this._weekdaysParse, g),
       -1 !== e ? e : (e = md.call(this._shortWeekdaysParse, g),
       -1 !== e ? e : (e = md.call(this._minWeekdaysParse, g),
       -1 !== e ? e : null))) : "ddd" === b ? (e = md.call(this._shortWeekdaysParse, g),
       -1 !== e ? e : (e = md.call(this._weekdaysParse, g),
       -1 !== e ? e : (e = md.call(this._minWeekdaysParse, g),
       -1 !== e ? e : null))) : (e = md.call(this._minWeekdaysParse, g),
       -1 !== e ? e : (e = md.call(this._weekdaysParse, g),
       -1 !== e ? e : (e = md.call(this._shortWeekdaysParse, g),
       -1 !== e ? e : null)))
   }
   function fc(a, b, c) {
       var d, e, f;
       if (this._weekdaysParseExact)
           return ec.call(this, a, b, c);
       for (this._weekdaysParse || (this._weekdaysParse = [],
       this._minWeekdaysParse = [],
       this._shortWeekdaysParse = [],
       this._fullWeekdaysParse = []),
       d = 0; 7 > d; d++) {
           if (e = h([2e3, 1]).day(d),
           c && !this._fullWeekdaysParse[d] && (this._fullWeekdaysParse[d] = new RegExp("^" + this.weekdays(e, "").replace(".", ".?") + "$","i"),
           this._shortWeekdaysParse[d] = new RegExp("^" + this.weekdaysShort(e, "").replace(".", ".?") + "$","i"),
           this._minWeekdaysParse[d] = new RegExp("^" + this.weekdaysMin(e, "").replace(".", ".?") + "$","i")),
           this._weekdaysParse[d] || (f = "^" + this.weekdays(e, "") + "|^" + this.weekdaysShort(e, "") + "|^" + this.weekdaysMin(e, ""),
           this._weekdaysParse[d] = new RegExp(f.replace(".", ""),"i")),
           c && "dddd" === b && this._fullWeekdaysParse[d].test(a))
               return d;
           if (c && "ddd" === b && this._shortWeekdaysParse[d].test(a))
               return d;
           if (c && "dd" === b && this._minWeekdaysParse[d].test(a))
               return d;
           if (!c && this._weekdaysParse[d].test(a))
               return d
       }
   }
   function gc(a) {
       if (!this.isValid())
           return null != a ? this : NaN;
       var b = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
       return null != a ? (a = ac(a, this.localeData()),
       this.add(a - b, "d")) : b
   }
   function hc(a) {
       if (!this.isValid())
           return null != a ? this : NaN;
       var b = (this.day() + 7 - this.localeData()._week.dow) % 7;
       return null == a ? b : this.add(a - b, "d")
   }
   function ic(a) {
       return this.isValid() ? null == a ? this.day() || 7 : this.day(this.day() % 7 ? a : a - 7) : null != a ? this : NaN
   }
   function jc(a) {
       return this._weekdaysParseExact ? (f(this, "_weekdaysRegex") || mc.call(this),
       a ? this._weekdaysStrictRegex : this._weekdaysRegex) : this._weekdaysStrictRegex && a ? this._weekdaysStrictRegex : this._weekdaysRegex
   }
   function kc(a) {
       return this._weekdaysParseExact ? (f(this, "_weekdaysRegex") || mc.call(this),
       a ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex) : this._weekdaysShortStrictRegex && a ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex
   }
   function lc(a) {
       return this._weekdaysParseExact ? (f(this, "_weekdaysRegex") || mc.call(this),
       a ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex) : this._weekdaysMinStrictRegex && a ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex
   }
   function mc() {
       function a(a, b) {
           return b.length - a.length
       }
       var b, c, d, e, f, g = [], i = [], j = [], k = [];
       for (b = 0; 7 > b; b++)
           c = h([2e3, 1]).day(b),
           d = this.weekdaysMin(c, ""),
           e = this.weekdaysShort(c, ""),
           f = this.weekdays(c, ""),
           g.push(d),
           i.push(e),
           j.push(f),
           k.push(d),
           k.push(e),
           k.push(f);
       for (g.sort(a),
       i.sort(a),
       j.sort(a),
       k.sort(a),
       b = 0; 7 > b; b++)
           i[b] = Z(i[b]),
           j[b] = Z(j[b]),
           k[b] = Z(k[b]);
       this._weekdaysRegex = new RegExp("^(" + k.join("|") + ")","i"),
       this._weekdaysShortRegex = this._weekdaysRegex,
       this._weekdaysMinRegex = this._weekdaysRegex,
       this._weekdaysStrictRegex = new RegExp("^(" + j.join("|") + ")","i"),
       this._weekdaysShortStrictRegex = new RegExp("^(" + i.join("|") + ")","i"),
       this._weekdaysMinStrictRegex = new RegExp("^(" + g.join("|") + ")","i")
   }
   function nc(a) {
       var b = Math.round((this.clone().startOf("day") - this.clone().startOf("year")) / 864e5) + 1;
       return null == a ? b : this.add(a - b, "d")
   }
   function oc() {
       return this.hours() % 12 || 12
   }
   function pc() {
       return this.hours() || 24
   }
   function qc(a, b) {
       R(a, 0, 0, function() {
           return this.localeData().meridiem(this.hours(), this.minutes(), b)
       })
   }
   function rc(a, b) {
       return b._meridiemParse
   }
   function sc(a) {
       return "p" === (a + "").toLowerCase().charAt(0)
   }
   function tc(a, b, c) {
       return a > 11 ? c ? "pm" : "PM" : c ? "am" : "AM"
   }
   function uc(a, b) {
       b[Sd] = r(1e3 * ("0." + a))
   }
   function vc() {
       return this._isUTC ? "UTC" : ""
   }
   function wc() {
       return this._isUTC ? "Coordinated Universal Time" : ""
   }
   function xc(a) {
       return Ka(1e3 * a)
   }
   function yc() {
       return Ka.apply(null, arguments).parseZone()
   }
   function zc(a, b, c) {
       var d = this._calendar[a];
       return w(d) ? d.call(b, c) : d
   }
   function Ac(a) {
       var b = this._longDateFormat[a]
         , c = this._longDateFormat[a.toUpperCase()];
       return b || !c ? b : (this._longDateFormat[a] = c.replace(/MMMM|MM|DD|dddd/g, function(a) {
           return a.slice(1)
       }),
       this._longDateFormat[a])
   }
   function Bc() {
       return this._invalidDate
   }
   function Cc(a) {
       return this._ordinal.replace("%d", a)
   }
   function Dc(a) {
       return a
   }
   function Ec(a, b, c, d) {
       var e = this._relativeTime[c];
       return w(e) ? e(a, b, c, d) : e.replace(/%d/i, a)
   }
   function Fc(a, b) {
       var c = this._relativeTime[a > 0 ? "future" : "past"];
       return w(c) ? c(b) : c.replace(/%s/i, b)
   }
   function Gc(a, b, c, d) {
       var e = H()
         , f = h().set(d, b);
       return e[c](f, a)
   }
   function Hc(a, b, c) {
       if ("number" == typeof a && (b = a,
       a = void 0),
       a = a || "",
       null != b)
           return Gc(a, b, c, "month");
       var d, e = [];
       for (d = 0; 12 > d; d++)
           e[d] = Gc(a, d, c, "month");
       return e
   }
   function Ic(a, b, c, d) {
       "boolean" == typeof a ? ("number" == typeof b && (c = b,
       b = void 0),
       b = b || "") : (b = a,
       c = b,
       a = !1,
       "number" == typeof b && (c = b,
       b = void 0),
       b = b || "");
       var e = H()
         , f = a ? e._week.dow : 0;
       if (null != c)
           return Gc(b, (c + f) % 7, d, "day");
       var g, h = [];
       for (g = 0; 7 > g; g++)
           h[g] = Gc(b, (g + f) % 7, d, "day");
       return h
   }
   function Jc(a, b) {
       return Hc(a, b, "months")
   }
   function Kc(a, b) {
       return Hc(a, b, "monthsShort")
   }
   function Lc(a, b, c) {
       return Ic(a, b, c, "weekdays")
   }
   function Mc(a, b, c) {
       return Ic(a, b, c, "weekdaysShort")
   }
   function Nc(a, b, c) {
       return Ic(a, b, c, "weekdaysMin")
   }
   function Oc() {
       var a = this._data;
       return this._milliseconds = Le(this._milliseconds),
       this._days = Le(this._days),
       this._months = Le(this._months),
       a.milliseconds = Le(a.milliseconds),
       a.seconds = Le(a.seconds),
       a.minutes = Le(a.minutes),
       a.hours = Le(a.hours),
       a.months = Le(a.months),
       a.years = Le(a.years),
       this
   }
   function Pc(a, b, c, d) {
       var e = db(b, c);
       return a._milliseconds += d * e._milliseconds,
       a._days += d * e._days,
       a._months += d * e._months,
       a._bubble()
   }
   function Qc(a, b) {
       return Pc(this, a, b, 1)
   }
   function Rc(a, b) {
       return Pc(this, a, b, -1)
   }
   function Sc(a) {
       return 0 > a ? Math.floor(a) : Math.ceil(a)
   }
   function Tc() {
       var a, b, c, d, e, f = this._milliseconds, g = this._days, h = this._months, i = this._data;
       return f >= 0 && g >= 0 && h >= 0 || 0 >= f && 0 >= g && 0 >= h || (f += 864e5 * Sc(Vc(h) + g),
       g = 0,
       h = 0),
       i.milliseconds = f % 1e3,
       a = q(f / 1e3),
       i.seconds = a % 60,
       b = q(a / 60),
       i.minutes = b % 60,
       c = q(b / 60),
       i.hours = c % 24,
       g += q(c / 24),
       e = q(Uc(g)),
       h += e,
       g -= Sc(Vc(e)),
       d = q(h / 12),
       h %= 12,
       i.days = g,
       i.months = h,
       i.years = d,
       this
   }
   function Uc(a) {
       return 4800 * a / 146097
   }
   function Vc(a) {
       return 146097 * a / 4800
   }
   function Wc(a) {
       var b, c, d = this._milliseconds;
       if (a = K(a),
       "month" === a || "year" === a)
           return b = this._days + d / 864e5,
           c = this._months + Uc(b),
           "month" === a ? c : c / 12;
       switch (b = this._days + Math.round(Vc(this._months)),
       a) {
       case "week":
           return b / 7 + d / 6048e5;
       case "day":
           return b + d / 864e5;
       case "hour":
           return 24 * b + d / 36e5;
       case "minute":
           return 1440 * b + d / 6e4;
       case "second":
           return 86400 * b + d / 1e3;
       case "millisecond":
           return Math.floor(864e5 * b) + d;
       default:
           throw new Error("Unknown unit " + a)
       }
   }
   function Xc() {
       return this._milliseconds + 864e5 * this._days + this._months % 12 * 2592e6 + 31536e6 * r(this._months / 12)
   }
   function Yc(a) {
       return function() {
           return this.as(a)
       }
   }
   function Zc(a) {
       return a = K(a),
       this[a + "s"]()
   }
   function $c(a) {
       return function() {
           return this._data[a]
       }
   }
   function _c() {
       return q(this.days() / 7)
   }
   function ad(a, b, c, d, e) {
       return e.relativeTime(b || 1, !!c, a, d)
   }
   function bd(a, b, c) {
       var d = db(a).abs()
         , e = _e(d.as("s"))
         , f = _e(d.as("m"))
         , g = _e(d.as("h"))
         , h = _e(d.as("d"))
         , i = _e(d.as("M"))
         , j = _e(d.as("y"))
         , k = e < af.s && ["s", e] || 1 >= f && ["m"] || f < af.m && ["mm", f] || 1 >= g && ["h"] || g < af.h && ["hh", g] || 1 >= h && ["d"] || h < af.d && ["dd", h] || 1 >= i && ["M"] || i < af.M && ["MM", i] || 1 >= j && ["y"] || ["yy", j];
       return k[2] = b,
       k[3] = +a > 0,
       k[4] = c,
       ad.apply(null, k)
   }
   function cd(a, b) {
       return void 0 === af[a] ? !1 : void 0 === b ? af[a] : (af[a] = b,
       !0)
   }
   function dd(a) {
       var b = this.localeData()
         , c = bd(this, !a, b);
       return a && (c = b.pastFuture(+this, c)),
       b.postformat(c)
   }
   function ed() {
       var a, b, c, d = bf(this._milliseconds) / 1e3, e = bf(this._days), f = bf(this._months);
       a = q(d / 60),
       b = q(a / 60),
       d %= 60,
       a %= 60,
       c = q(f / 12),
       f %= 12;
       var g = c
         , h = f
         , i = e
         , j = b
         , k = a
         , l = d
         , m = this.asSeconds();
       return m ? (0 > m ? "-" : "") + "P" + (g ? g + "Y" : "") + (h ? h + "M" : "") + (i ? i + "D" : "") + (j || k || l ? "T" : "") + (j ? j + "H" : "") + (k ? k + "M" : "") + (l ? l + "S" : "") : "P0D"
   }
   var fd, gd;
   gd = Array.prototype.some ? Array.prototype.some : function(a) {
       for (var b = Object(this), c = b.length >>> 0, d = 0; c > d; d++)
           if (d in b && a.call(this, b[d], d, b))
               return !0;
       return !1
   }
   ;
   var hd = a.momentProperties = []
     , id = !1
     , jd = {};
   a.suppressDeprecationWarnings = !1,
   a.deprecationHandler = null;
   var kd;
   kd = Object.keys ? Object.keys : function(a) {
       var b, c = [];
       for (b in a)
           f(a, b) && c.push(b);
       return c
   }
   ;
   var ld, md, nd = {}, od = {}, pd = /(\[[^\[]*\])|(\\)?([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, qd = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, rd = {}, sd = {}, td = /\d/, ud = /\d\d/, vd = /\d{3}/, wd = /\d{4}/, xd = /[+-]?\d{6}/, yd = /\d\d?/, zd = /\d\d\d\d?/, Ad = /\d\d\d\d\d\d?/, Bd = /\d{1,3}/, Cd = /\d{1,4}/, Dd = /[+-]?\d{1,6}/, Ed = /\d+/, Fd = /[+-]?\d+/, Gd = /Z|[+-]\d\d:?\d\d/gi, Hd = /Z|[+-]\d\d(?::?\d\d)?/gi, Id = /[+-]?\d+(\.\d{1,3})?/, Jd = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i, Kd = {}, Ld = {}, Md = 0, Nd = 1, Od = 2, Pd = 3, Qd = 4, Rd = 5, Sd = 6, Td = 7, Ud = 8;
   md = Array.prototype.indexOf ? Array.prototype.indexOf : function(a) {
       var b;
       for (b = 0; b < this.length; ++b)
           if (this[b] === a)
               return b;
       return -1
   }
   ,
   R("M", ["MM", 2], "Mo", function() {
       return this.month() + 1
   }),
   R("MMM", 0, 0, function(a) {
       return this.localeData().monthsShort(this, a)
   }),
   R("MMMM", 0, 0, function(a) {
       return this.localeData().months(this, a)
   }),
   J("month", "M"),
   W("M", yd),
   W("MM", yd, ud),
   W("MMM", function(a, b) {
       return b.monthsShortRegex(a)
   }),
   W("MMMM", function(a, b) {
       return b.monthsRegex(a)
   }),
   $(["M", "MM"], function(a, b) {
       b[Nd] = r(a) - 1
   }),
   $(["MMM", "MMMM"], function(a, b, c, d) {
       var e = c._locale.monthsParse(a, d, c._strict);
       null != e ? b[Nd] = e : j(c).invalidMonth = a
   });
   var Vd = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/
     , Wd = "January_February_March_April_May_June_July_August_September_October_November_December".split("_")
     , Xd = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_")
     , Yd = Jd
     , Zd = Jd
     , $d = /^\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)?)?/
     , _d = /^\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)?)?/
     , ae = /Z|[+-]\d\d(?::?\d\d)?/
     , be = [["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/], ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/], ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/], ["GGGG-[W]WW", /\d{4}-W\d\d/, !1], ["YYYY-DDD", /\d{4}-\d{3}/], ["YYYY-MM", /\d{4}-\d\d/, !1], ["YYYYYYMMDD", /[+-]\d{10}/], ["YYYYMMDD", /\d{8}/], ["GGGG[W]WWE", /\d{4}W\d{3}/], ["GGGG[W]WW", /\d{4}W\d{2}/, !1], ["YYYYDDD", /\d{7}/]]
     , ce = [["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/], ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/], ["HH:mm:ss", /\d\d:\d\d:\d\d/], ["HH:mm", /\d\d:\d\d/], ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/], ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/], ["HHmmss", /\d\d\d\d\d\d/], ["HHmm", /\d\d\d\d/], ["HH", /\d\d/]]
     , de = /^\/?Date\((\-?\d+)/i;
   a.createFromInputFallback = u("moment construction falls back to js Date. This is discouraged and will be removed in upcoming major release. Please refer to https://github.com/moment/moment/issues/1407 for more info.", function(a) {
       a._d = new Date(a._i + (a._useUTC ? " UTC" : ""))
   }),
   R("Y", 0, 0, function() {
       var a = this.year();
       return 9999 >= a ? "" + a : "+" + a
   }),
   R(0, ["YY", 2], 0, function() {
       return this.year() % 100
   }),
   R(0, ["YYYY", 4], 0, "year"),
   R(0, ["YYYYY", 5], 0, "year"),
   R(0, ["YYYYYY", 6, !0], 0, "year"),
   J("year", "y"),
   W("Y", Fd),
   W("YY", yd, ud),
   W("YYYY", Cd, wd),
   W("YYYYY", Dd, xd),
   W("YYYYYY", Dd, xd),
   $(["YYYYY", "YYYYYY"], Md),
   $("YYYY", function(b, c) {
       c[Md] = 2 === b.length ? a.parseTwoDigitYear(b) : r(b)
   }),
   $("YY", function(b, c) {
       c[Md] = a.parseTwoDigitYear(b)
   }),
   $("Y", function(a, b) {
       b[Md] = parseInt(a, 10)
   }),
   a.parseTwoDigitYear = function(a) {
       return r(a) + (r(a) > 68 ? 1900 : 2e3)
   }
   ;
   var ee = M("FullYear", !0);
   a.ISO_8601 = function() {}
   ;
   var fe = u("moment().min is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548", function() {
       var a = Ka.apply(null, arguments);
       return this.isValid() && a.isValid() ? this > a ? this : a : l()
   })
     , ge = u("moment().max is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548", function() {
       var a = Ka.apply(null, arguments);
       return this.isValid() && a.isValid() ? a > this ? this : a : l()
   })
     , he = function() {
       return Date.now ? Date.now() : +new Date
   };
   Qa("Z", ":"),
   Qa("ZZ", ""),
   W("Z", Hd),
   W("ZZ", Hd),
   $(["Z", "ZZ"], function(a, b, c) {
       c._useUTC = !0,
       c._tzm = Ra(Hd, a)
   });
   var ie = /([\+\-]|\d\d)/gi;
   a.updateOffset = function() {}
   ;
   var je = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/
     , ke = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;
   db.fn = Oa.prototype;
   var le = ib(1, "add")
     , me = ib(-1, "subtract");
   a.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ",
   a.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]";
   var ne = u("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.", function(a) {
       return void 0 === a ? this.localeData() : this.locale(a)
   });
   R(0, ["gg", 2], 0, function() {
       return this.weekYear() % 100
   }),
   R(0, ["GG", 2], 0, function() {
       return this.isoWeekYear() % 100
   }),
   Pb("gggg", "weekYear"),
   Pb("ggggg", "weekYear"),
   Pb("GGGG", "isoWeekYear"),
   Pb("GGGGG", "isoWeekYear"),
   J("weekYear", "gg"),
   J("isoWeekYear", "GG"),
   W("G", Fd),
   W("g", Fd),
   W("GG", yd, ud),
   W("gg", yd, ud),
   W("GGGG", Cd, wd),
   W("gggg", Cd, wd),
   W("GGGGG", Dd, xd),
   W("ggggg", Dd, xd),
   _(["gggg", "ggggg", "GGGG", "GGGGG"], function(a, b, c, d) {
       b[d.substr(0, 2)] = r(a)
   }),
   _(["gg", "GG"], function(b, c, d, e) {
       c[e] = a.parseTwoDigitYear(b)
   }),
   R("Q", 0, "Qo", "quarter"),
   J("quarter", "Q"),
   W("Q", td),
   $("Q", function(a, b) {
       b[Nd] = 3 * (r(a) - 1)
   }),
   R("w", ["ww", 2], "wo", "week"),
   R("W", ["WW", 2], "Wo", "isoWeek"),
   J("week", "w"),
   J("isoWeek", "W"),
   W("w", yd),
   W("ww", yd, ud),
   W("W", yd),
   W("WW", yd, ud),
   _(["w", "ww", "W", "WW"], function(a, b, c, d) {
       b[d.substr(0, 1)] = r(a)
   });
   var oe = {
       dow: 0,
       doy: 6
   };
   R("D", ["DD", 2], "Do", "date"),
   J("date", "D"),
   W("D", yd),
   W("DD", yd, ud),
   W("Do", function(a, b) {
       return a ? b._ordinalParse : b._ordinalParseLenient
   }),
   $(["D", "DD"], Od),
   $("Do", function(a, b) {
       b[Od] = r(a.match(yd)[0], 10)
   });
   var pe = M("Date", !0);
   R("d", 0, "do", "day"),
   R("dd", 0, 0, function(a) {
       return this.localeData().weekdaysMin(this, a)
   }),
   R("ddd", 0, 0, function(a) {
       return this.localeData().weekdaysShort(this, a)
   }),
   R("dddd", 0, 0, function(a) {
       return this.localeData().weekdays(this, a)
   }),
   R("e", 0, 0, "weekday"),
   R("E", 0, 0, "isoWeekday"),
   J("day", "d"),
   J("weekday", "e"),
   J("isoWeekday", "E"),
   W("d", yd),
   W("e", yd),
   W("E", yd),
   W("dd", function(a, b) {
       return b.weekdaysMinRegex(a)
   }),
   W("ddd", function(a, b) {
       return b.weekdaysShortRegex(a)
   }),
   W("dddd", function(a, b) {
       return b.weekdaysRegex(a)
   }),
   _(["dd", "ddd", "dddd"], function(a, b, c, d) {
       var e = c._locale.weekdaysParse(a, d, c._strict);
       null != e ? b.d = e : j(c).invalidWeekday = a
   }),
   _(["d", "e", "E"], function(a, b, c, d) {
       b[d] = r(a)
   });
   var qe = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_")
     , re = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_")
     , se = "Su_Mo_Tu_We_Th_Fr_Sa".split("_")
     , te = Jd
     , ue = Jd
     , ve = Jd;
   R("DDD", ["DDDD", 3], "DDDo", "dayOfYear"),
   J("dayOfYear", "DDD"),
   W("DDD", Bd),
   W("DDDD", vd),
   $(["DDD", "DDDD"], function(a, b, c) {
       c._dayOfYear = r(a)
   }),
   R("H", ["HH", 2], 0, "hour"),
   R("h", ["hh", 2], 0, oc),
   R("k", ["kk", 2], 0, pc),
   R("hmm", 0, 0, function() {
       return "" + oc.apply(this) + Q(this.minutes(), 2)
   }),
   R("hmmss", 0, 0, function() {
       return "" + oc.apply(this) + Q(this.minutes(), 2) + Q(this.seconds(), 2)
   }),
   R("Hmm", 0, 0, function() {
       return "" + this.hours() + Q(this.minutes(), 2)
   }),
   R("Hmmss", 0, 0, function() {
       return "" + this.hours() + Q(this.minutes(), 2) + Q(this.seconds(), 2)
   }),
   qc("a", !0),
   qc("A", !1),
   J("hour", "h"),
   W("a", rc),
   W("A", rc),
   W("H", yd),
   W("h", yd),
   W("HH", yd, ud),
   W("hh", yd, ud),
   W("hmm", zd),
   W("hmmss", Ad),
   W("Hmm", zd),
   W("Hmmss", Ad),
   $(["H", "HH"], Pd),
   $(["a", "A"], function(a, b, c) {
       c._isPm = c._locale.isPM(a),
       c._meridiem = a
   }),
   $(["h", "hh"], function(a, b, c) {
       b[Pd] = r(a),
       j(c).bigHour = !0
   }),
   $("hmm", function(a, b, c) {
       var d = a.length - 2;
       b[Pd] = r(a.substr(0, d)),
       b[Qd] = r(a.substr(d)),
       j(c).bigHour = !0
   }),
   $("hmmss", function(a, b, c) {
       var d = a.length - 4
         , e = a.length - 2;
       b[Pd] = r(a.substr(0, d)),
       b[Qd] = r(a.substr(d, 2)),
       b[Rd] = r(a.substr(e)),
       j(c).bigHour = !0
   }),
   $("Hmm", function(a, b, c) {
       var d = a.length - 2;
       b[Pd] = r(a.substr(0, d)),
       b[Qd] = r(a.substr(d))
   }),
   $("Hmmss", function(a, b, c) {
       var d = a.length - 4
         , e = a.length - 2;
       b[Pd] = r(a.substr(0, d)),
       b[Qd] = r(a.substr(d, 2)),
       b[Rd] = r(a.substr(e))
   });
   var we = /[ap]\.?m?\.?/i
     , xe = M("Hours", !0);
   R("m", ["mm", 2], 0, "minute"),
   J("minute", "m"),
   W("m", yd),
   W("mm", yd, ud),
   $(["m", "mm"], Qd);
   var ye = M("Minutes", !1);
   R("s", ["ss", 2], 0, "second"),
   J("second", "s"),
   W("s", yd),
   W("ss", yd, ud),
   $(["s", "ss"], Rd);
   var ze = M("Seconds", !1);
   R("S", 0, 0, function() {
       return ~~(this.millisecond() / 100)
   }),
   R(0, ["SS", 2], 0, function() {
       return ~~(this.millisecond() / 10)
   }),
   R(0, ["SSS", 3], 0, "millisecond"),
   R(0, ["SSSS", 4], 0, function() {
       return 10 * this.millisecond()
   }),
   R(0, ["SSSSS", 5], 0, function() {
       return 100 * this.millisecond()
   }),
   R(0, ["SSSSSS", 6], 0, function() {
       return 1e3 * this.millisecond()
   }),
   R(0, ["SSSSSSS", 7], 0, function() {
       return 1e4 * this.millisecond()
   }),
   R(0, ["SSSSSSSS", 8], 0, function() {
       return 1e5 * this.millisecond()
   }),
   R(0, ["SSSSSSSSS", 9], 0, function() {
       return 1e6 * this.millisecond()
   }),
   J("millisecond", "ms"),
   W("S", Bd, td),
   W("SS", Bd, ud),
   W("SSS", Bd, vd);
   var Ae;
   for (Ae = "SSSS"; Ae.length <= 9; Ae += "S")
       W(Ae, Ed);
   for (Ae = "S"; Ae.length <= 9; Ae += "S")
       $(Ae, uc);
   var Be = M("Milliseconds", !1);
   R("z", 0, 0, "zoneAbbr"),
   R("zz", 0, 0, "zoneName");
   var Ce = o.prototype;
   Ce.add = le,
   Ce.calendar = kb,
   Ce.clone = lb,
   Ce.diff = sb,
   Ce.endOf = Eb,
   Ce.format = wb,
   Ce.from = xb,
   Ce.fromNow = yb,
   Ce.to = zb,
   Ce.toNow = Ab,
   Ce.get = P,
   Ce.invalidAt = Nb,
   Ce.isAfter = mb,
   Ce.isBefore = nb,
   Ce.isBetween = ob,
   Ce.isSame = pb,
   Ce.isSameOrAfter = qb,
   Ce.isSameOrBefore = rb,
   Ce.isValid = Lb,
   Ce.lang = ne,
   Ce.locale = Bb,
   Ce.localeData = Cb,
   Ce.max = ge,
   Ce.min = fe,
   Ce.parsingFlags = Mb,
   Ce.set = P,
   Ce.startOf = Db,
   Ce.subtract = me,
   Ce.toArray = Ib,
   Ce.toObject = Jb,
   Ce.toDate = Hb,
   Ce.toISOString = vb,
   Ce.toJSON = Kb,
   Ce.toString = ub,
   Ce.unix = Gb,
   Ce.valueOf = Fb,
   Ce.creationData = Ob,
   Ce.year = ee,
   Ce.isLeapYear = ta,
   Ce.weekYear = Qb,
   Ce.isoWeekYear = Rb,
   Ce.quarter = Ce.quarters = Wb,
   Ce.month = ha,
   Ce.daysInMonth = ia,
   Ce.week = Ce.weeks = $b,
   Ce.isoWeek = Ce.isoWeeks = _b,
   Ce.weeksInYear = Tb,
   Ce.isoWeeksInYear = Sb,
   Ce.date = pe,
   Ce.day = Ce.days = gc,
   Ce.weekday = hc,
   Ce.isoWeekday = ic,
   Ce.dayOfYear = nc,
   Ce.hour = Ce.hours = xe,
   Ce.minute = Ce.minutes = ye,
   Ce.second = Ce.seconds = ze,
   Ce.millisecond = Ce.milliseconds = Be,
   Ce.utcOffset = Ua,
   Ce.utc = Wa,
   Ce.local = Xa,
   Ce.parseZone = Ya,
   Ce.hasAlignedHourOffset = Za,
   Ce.isDST = $a,
   Ce.isDSTShifted = _a,
   Ce.isLocal = ab,
   Ce.isUtcOffset = bb,
   Ce.isUtc = cb,
   Ce.isUTC = cb,
   Ce.zoneAbbr = vc,
   Ce.zoneName = wc,
   Ce.dates = u("dates accessor is deprecated. Use date instead.", pe),
   Ce.months = u("months accessor is deprecated. Use month instead", ha),
   Ce.years = u("years accessor is deprecated. Use year instead", ee),
   Ce.zone = u("moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779", Va);
   var De = Ce
     , Ee = {
       sameDay: "[Today at] LT",
       nextDay: "[Tomorrow at] LT",
       nextWeek: "dddd [at] LT",
       lastDay: "[Yesterday at] LT",
       lastWeek: "[Last] dddd [at] LT",
       sameElse: "L"
   }
     , Fe = {
       LTS: "h:mm:ss A",
       LT: "h:mm A",
       L: "MM/DD/YYYY",
       LL: "MMMM D, YYYY",
       LLL: "MMMM D, YYYY h:mm A",
       LLLL: "dddd, MMMM D, YYYY h:mm A"
   }
     , Ge = "Invalid date"
     , He = "%d"
     , Ie = /\d{1,2}/
     , Je = {
       future: "in %s",
       past: "%s ago",
       s: "a few seconds",
       m: "a minute",
       mm: "%d minutes",
       h: "an hour",
       hh: "%d hours",
       d: "a day",
       dd: "%d days",
       M: "a month",
       MM: "%d months",
       y: "a year",
       yy: "%d years"
   }
     , Ke = A.prototype;
   Ke._calendar = Ee,
   Ke.calendar = zc,
   Ke._longDateFormat = Fe,
   Ke.longDateFormat = Ac,
   Ke._invalidDate = Ge,
   Ke.invalidDate = Bc,
   Ke._ordinal = He,
   Ke.ordinal = Cc,
   Ke._ordinalParse = Ie,
   Ke.preparse = Dc,
   Ke.postformat = Dc,
   Ke._relativeTime = Je,
   Ke.relativeTime = Ec,
   Ke.pastFuture = Fc,
   Ke.set = y,
   Ke.months = ca,
   Ke._months = Wd,
   Ke.monthsShort = da,
   Ke._monthsShort = Xd,
   Ke.monthsParse = fa,
   Ke._monthsRegex = Zd,
   Ke.monthsRegex = ka,
   Ke._monthsShortRegex = Yd,
   Ke.monthsShortRegex = ja,
   Ke.week = Xb,
   Ke._week = oe,
   Ke.firstDayOfYear = Zb,
   Ke.firstDayOfWeek = Yb,
   Ke.weekdays = bc,
   Ke._weekdays = qe,
   Ke.weekdaysMin = dc,
   Ke._weekdaysMin = se,
   Ke.weekdaysShort = cc,
   Ke._weekdaysShort = re,
   Ke.weekdaysParse = fc,
   Ke._weekdaysRegex = te,
   Ke.weekdaysRegex = jc,
   Ke._weekdaysShortRegex = ue,
   Ke.weekdaysShortRegex = kc,
   Ke._weekdaysMinRegex = ve,
   Ke.weekdaysMinRegex = lc,
   Ke.isPM = sc,
   Ke._meridiemParse = we,
   Ke.meridiem = tc,
   E("en", {
       ordinalParse: /\d{1,2}(th|st|nd|rd)/,
       ordinal: function(a) {
           var b = a % 10
             , c = 1 === r(a % 100 / 10) ? "th" : 1 === b ? "st" : 2 === b ? "nd" : 3 === b ? "rd" : "th";
           return a + c
       }
   }),
   a.lang = u("moment.lang is deprecated. Use moment.locale instead.", E),
   a.langData = u("moment.langData is deprecated. Use moment.localeData instead.", H);
   var Le = Math.abs
     , Me = Yc("ms")
     , Ne = Yc("s")
     , Oe = Yc("m")
     , Pe = Yc("h")
     , Qe = Yc("d")
     , Re = Yc("w")
     , Se = Yc("M")
     , Te = Yc("y")
     , Ue = $c("milliseconds")
     , Ve = $c("seconds")
     , We = $c("minutes")
     , Xe = $c("hours")
     , Ye = $c("days")
     , Ze = $c("months")
     , $e = $c("years")
     , _e = Math.round
     , af = {
       s: 45,
       m: 45,
       h: 22,
       d: 26,
       M: 11
   }
     , bf = Math.abs
     , cf = Oa.prototype;
   cf.abs = Oc,
   cf.add = Qc,
   cf.subtract = Rc,
   cf.as = Wc,
   cf.asMilliseconds = Me,
   cf.asSeconds = Ne,
   cf.asMinutes = Oe,
   cf.asHours = Pe,
   cf.asDays = Qe,
   cf.asWeeks = Re,
   cf.asMonths = Se,
   cf.asYears = Te,
   cf.valueOf = Xc,
   cf._bubble = Tc,
   cf.get = Zc,
   cf.milliseconds = Ue,
   cf.seconds = Ve,
   cf.minutes = We,
   cf.hours = Xe,
   cf.days = Ye,
   cf.weeks = _c,
   cf.months = Ze,
   cf.years = $e,
   cf.humanize = dd,
   cf.toISOString = ed,
   cf.toString = ed,
   cf.toJSON = ed,
   cf.locale = Bb,
   cf.localeData = Cb,
   cf.toIsoString = u("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)", ed),
   cf.lang = ne,
   R("X", 0, 0, "unix"),
   R("x", 0, 0, "valueOf"),
   W("x", Fd),
   W("X", Id),
   $("X", function(a, b, c) {
       c._d = new Date(1e3 * parseFloat(a, 10))
   }),
   $("x", function(a, b, c) {
       c._d = new Date(r(a))
   }),
   a.version = "2.13.0",
   b(Ka),
   a.fn = De,
   a.min = Ma,
   a.max = Na,
   a.now = he,
   a.utc = h,
   a.unix = xc,
   a.months = Jc,
   a.isDate = d,
   a.locale = E,
   a.invalid = l,
   a.duration = db,
   a.isMoment = p,
   a.weekdays = Lc,
   a.parseZone = yc,
   a.localeData = H,
   a.isDuration = Pa,
   a.monthsShort = Kc,
   a.weekdaysMin = Nc,
   a.defineLocale = F,
   a.updateLocale = G,
   a.locales = I,
   a.weekdaysShort = Mc,
   a.normalizeUnits = K,
   a.relativeTimeThreshold = cd,
   a.prototype = De;
   var df = a;
   return df

});