{"version":3,"file":"static/js/195.615031ad.chunk.js","mappings":"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","sources":["../node_modules/moment/moment.js","../node_modules/react-zoom-pan-pinch/src/utils/calculations.utils.ts","../node_modules/react-zoom-pan-pinch/src/utils/callback.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/animations/animations.constants.ts","../node_modules/react-zoom-pan-pinch/src/core/animations/animations.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/bounds/bounds.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/zoom/zoom.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/pan/panning.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/pan/velocity.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/pan/velocity.logic.ts","../node_modules/react-zoom-pan-pinch/src/core/pan/panning.logic.ts","../node_modules/react-zoom-pan-pinch/src/core/zoom/zoom.logic.ts","../node_modules/react-zoom-pan-pinch/node_modules/tslib/tslib.es6.js","../node_modules/react-zoom-pan-pinch/src/constants/state.constants.ts","../node_modules/react-zoom-pan-pinch/src/utils/state.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/handlers/handlers.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/handlers/handlers.logic.ts","../node_modules/react-zoom-pan-pinch/src/utils/context.utils.ts","../node_modules/react-zoom-pan-pinch/src/utils/event.utils.ts","../node_modules/react-zoom-pan-pinch/src/utils/helpers.utils.ts","../node_modules/react-zoom-pan-pinch/src/utils/styles.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/wheel/wheel.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/pinch/pinch.utils.ts","../node_modules/react-zoom-pan-pinch/src/core/wheel/wheel.logic.ts","../node_modules/react-zoom-pan-pinch/src/core/pinch/pinch.logic.ts","../node_modules/react-zoom-pan-pinch/src/core/double-click/double-click.logic.ts","../node_modules/react-zoom-pan-pinch/src/core/instance.core.ts","../node_modules/react-zoom-pan-pinch/src/components/transform-wrapper/transform-wrapper.tsx","../node_modules/react-zoom-pan-pinch/src/components/keep-scale/keep-scale.tsx","../node_modules/react-zoom-pan-pinch/src/utils/ref.utils.ts","../node_modules/react-zoom-pan-pinch/node_modules/style-inject/dist/style-inject.es.js","../node_modules/react-zoom-pan-pinch/src/components/transform-component/transform-component.tsx"],"sourcesContent":["//! moment.js\n//! version : 2.29.4\n//! authors : Tim Wood, Iskren Chernev, Moment.js contributors\n//! license : MIT\n//! momentjs.com\n\n;(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    global.moment = factory()\n}(this, (function () { 'use strict';\n\n    var hookCallback;\n\n    function hooks() {\n        return hookCallback.apply(null, arguments);\n    }\n\n    // This is done to register the method called with moment()\n    // without creating circular dependencies.\n    function setHookCallback(callback) {\n        hookCallback = callback;\n    }\n\n    function isArray(input) {\n        return (\n            input instanceof Array ||\n            Object.prototype.toString.call(input) === '[object Array]'\n        );\n    }\n\n    function isObject(input) {\n        // IE8 will treat undefined and null as object if it wasn't for\n        // input != null\n        return (\n            input != null &&\n            Object.prototype.toString.call(input) === '[object Object]'\n        );\n    }\n\n    function hasOwnProp(a, b) {\n        return Object.prototype.hasOwnProperty.call(a, b);\n    }\n\n    function isObjectEmpty(obj) {\n        if (Object.getOwnPropertyNames) {\n            return Object.getOwnPropertyNames(obj).length === 0;\n        } else {\n            var k;\n            for (k in obj) {\n                if (hasOwnProp(obj, k)) {\n                    return false;\n                }\n            }\n            return true;\n        }\n    }\n\n    function isUndefined(input) {\n        return input === void 0;\n    }\n\n    function isNumber(input) {\n        return (\n            typeof input === 'number' ||\n            Object.prototype.toString.call(input) === '[object Number]'\n        );\n    }\n\n    function isDate(input) {\n        return (\n            input instanceof Date ||\n            Object.prototype.toString.call(input) === '[object Date]'\n        );\n    }\n\n    function map(arr, fn) {\n        var res = [],\n            i,\n            arrLen = arr.length;\n        for (i = 0; i < arrLen; ++i) {\n            res.push(fn(arr[i], i));\n        }\n        return res;\n    }\n\n    function extend(a, b) {\n        for (var i in b) {\n            if (hasOwnProp(b, i)) {\n                a[i] = b[i];\n            }\n        }\n\n        if (hasOwnProp(b, 'toString')) {\n            a.toString = b.toString;\n        }\n\n        if (hasOwnProp(b, 'valueOf')) {\n            a.valueOf = b.valueOf;\n        }\n\n        return a;\n    }\n\n    function createUTC(input, format, locale, strict) {\n        return createLocalOrUTC(input, format, locale, strict, true).utc();\n    }\n\n    function defaultParsingFlags() {\n        // We need to deep clone this object.\n        return {\n            empty: false,\n            unusedTokens: [],\n            unusedInput: [],\n            overflow: -2,\n            charsLeftOver: 0,\n            nullInput: false,\n            invalidEra: null,\n            invalidMonth: null,\n            invalidFormat: false,\n            userInvalidated: false,\n            iso: false,\n            parsedDateParts: [],\n            era: null,\n            meridiem: null,\n            rfc2822: false,\n            weekdayMismatch: false,\n        };\n    }\n\n    function getParsingFlags(m) {\n        if (m._pf == null) {\n            m._pf = defaultParsingFlags();\n        }\n        return m._pf;\n    }\n\n    var some;\n    if (Array.prototype.some) {\n        some = Array.prototype.some;\n    } else {\n        some = function (fun) {\n            var t = Object(this),\n                len = t.length >>> 0,\n                i;\n\n            for (i = 0; i < len; i++) {\n                if (i in t && fun.call(this, t[i], i, t)) {\n                    return true;\n                }\n            }\n\n            return false;\n        };\n    }\n\n    function isValid(m) {\n        if (m._isValid == null) {\n            var flags = getParsingFlags(m),\n                parsedParts = some.call(flags.parsedDateParts, function (i) {\n                    return i != null;\n                }),\n                isNowValid =\n                    !isNaN(m._d.getTime()) &&\n                    flags.overflow < 0 &&\n                    !flags.empty &&\n                    !flags.invalidEra &&\n                    !flags.invalidMonth &&\n                    !flags.invalidWeekday &&\n                    !flags.weekdayMismatch &&\n                    !flags.nullInput &&\n                    !flags.invalidFormat &&\n                    !flags.userInvalidated &&\n                    (!flags.meridiem || (flags.meridiem && parsedParts));\n\n            if (m._strict) {\n                isNowValid =\n                    isNowValid &&\n                    flags.charsLeftOver === 0 &&\n                    flags.unusedTokens.length === 0 &&\n                    flags.bigHour === undefined;\n            }\n\n            if (Object.isFrozen == null || !Object.isFrozen(m)) {\n                m._isValid = isNowValid;\n            } else {\n                return isNowValid;\n            }\n        }\n        return m._isValid;\n    }\n\n    function createInvalid(flags) {\n        var m = createUTC(NaN);\n        if (flags != null) {\n            extend(getParsingFlags(m), flags);\n        } else {\n            getParsingFlags(m).userInvalidated = true;\n        }\n\n        return m;\n    }\n\n    // Plugins that add properties should also add the key here (null value),\n    // so we can properly clone ourselves.\n    var momentProperties = (hooks.momentProperties = []),\n        updateInProgress = false;\n\n    function copyConfig(to, from) {\n        var i,\n            prop,\n            val,\n            momentPropertiesLen = momentProperties.length;\n\n        if (!isUndefined(from._isAMomentObject)) {\n            to._isAMomentObject = from._isAMomentObject;\n        }\n        if (!isUndefined(from._i)) {\n            to._i = from._i;\n        }\n        if (!isUndefined(from._f)) {\n            to._f = from._f;\n        }\n        if (!isUndefined(from._l)) {\n            to._l = from._l;\n        }\n        if (!isUndefined(from._strict)) {\n            to._strict = from._strict;\n        }\n        if (!isUndefined(from._tzm)) {\n            to._tzm = from._tzm;\n        }\n        if (!isUndefined(from._isUTC)) {\n            to._isUTC = from._isUTC;\n        }\n        if (!isUndefined(from._offset)) {\n            to._offset = from._offset;\n        }\n        if (!isUndefined(from._pf)) {\n            to._pf = getParsingFlags(from);\n        }\n        if (!isUndefined(from._locale)) {\n            to._locale = from._locale;\n        }\n\n        if (momentPropertiesLen > 0) {\n            for (i = 0; i < momentPropertiesLen; i++) {\n                prop = momentProperties[i];\n                val = from[prop];\n                if (!isUndefined(val)) {\n                    to[prop] = val;\n                }\n            }\n        }\n\n        return to;\n    }\n\n    // Moment prototype object\n    function Moment(config) {\n        copyConfig(this, config);\n        this._d = new Date(config._d != null ? config._d.getTime() : NaN);\n        if (!this.isValid()) {\n            this._d = new Date(NaN);\n        }\n        // Prevent infinite loop in case updateOffset creates new moment\n        // objects.\n        if (updateInProgress === false) {\n            updateInProgress = true;\n            hooks.updateOffset(this);\n            updateInProgress = false;\n        }\n    }\n\n    function isMoment(obj) {\n        return (\n            obj instanceof Moment || (obj != null && obj._isAMomentObject != null)\n        );\n    }\n\n    function warn(msg) {\n        if (\n            hooks.suppressDeprecationWarnings === false &&\n            typeof console !== 'undefined' &&\n            console.warn\n        ) {\n            console.warn('Deprecation warning: ' + msg);\n        }\n    }\n\n    function deprecate(msg, fn) {\n        var firstTime = true;\n\n        return extend(function () {\n            if (hooks.deprecationHandler != null) {\n                hooks.deprecationHandler(null, msg);\n            }\n            if (firstTime) {\n                var args = [],\n                    arg,\n                    i,\n                    key,\n                    argLen = arguments.length;\n                for (i = 0; i < argLen; i++) {\n                    arg = '';\n                    if (typeof arguments[i] === 'object') {\n                        arg += '\\n[' + i + '] ';\n                        for (key in arguments[0]) {\n                            if (hasOwnProp(arguments[0], key)) {\n                                arg += key + ': ' + arguments[0][key] + ', ';\n                            }\n                        }\n                        arg = arg.slice(0, -2); // Remove trailing comma and space\n                    } else {\n                        arg = arguments[i];\n                    }\n                    args.push(arg);\n                }\n                warn(\n                    msg +\n                        '\\nArguments: ' +\n                        Array.prototype.slice.call(args).join('') +\n                        '\\n' +\n                        new Error().stack\n                );\n                firstTime = false;\n            }\n            return fn.apply(this, arguments);\n        }, fn);\n    }\n\n    var deprecations = {};\n\n    function deprecateSimple(name, msg) {\n        if (hooks.deprecationHandler != null) {\n            hooks.deprecationHandler(name, msg);\n        }\n        if (!deprecations[name]) {\n            warn(msg);\n            deprecations[name] = true;\n        }\n    }\n\n    hooks.suppressDeprecationWarnings = false;\n    hooks.deprecationHandler = null;\n\n    function isFunction(input) {\n        return (\n            (typeof Function !== 'undefined' && input instanceof Function) ||\n            Object.prototype.toString.call(input) === '[object Function]'\n        );\n    }\n\n    function set(config) {\n        var prop, i;\n        for (i in config) {\n            if (hasOwnProp(config, i)) {\n                prop = config[i];\n                if (isFunction(prop)) {\n                    this[i] = prop;\n                } else {\n                    this['_' + i] = prop;\n                }\n            }\n        }\n        this._config = config;\n        // Lenient ordinal parsing accepts just a number in addition to\n        // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.\n        // TODO: Remove \"ordinalParse\" fallback in next major release.\n        this._dayOfMonthOrdinalParseLenient = new RegExp(\n            (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +\n                '|' +\n                /\\d{1,2}/.source\n        );\n    }\n\n    function mergeConfigs(parentConfig, childConfig) {\n        var res = extend({}, parentConfig),\n            prop;\n        for (prop in childConfig) {\n            if (hasOwnProp(childConfig, prop)) {\n                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {\n                    res[prop] = {};\n                    extend(res[prop], parentConfig[prop]);\n                    extend(res[prop], childConfig[prop]);\n                } else if (childConfig[prop] != null) {\n                    res[prop] = childConfig[prop];\n                } else {\n                    delete res[prop];\n                }\n            }\n        }\n        for (prop in parentConfig) {\n            if (\n                hasOwnProp(parentConfig, prop) &&\n                !hasOwnProp(childConfig, prop) &&\n                isObject(parentConfig[prop])\n            ) {\n                // make sure changes to properties don't modify parent config\n                res[prop] = extend({}, res[prop]);\n            }\n        }\n        return res;\n    }\n\n    function Locale(config) {\n        if (config != null) {\n            this.set(config);\n        }\n    }\n\n    var keys;\n\n    if (Object.keys) {\n        keys = Object.keys;\n    } else {\n        keys = function (obj) {\n            var i,\n                res = [];\n            for (i in obj) {\n                if (hasOwnProp(obj, i)) {\n                    res.push(i);\n                }\n            }\n            return res;\n        };\n    }\n\n    var defaultCalendar = {\n        sameDay: '[Today at] LT',\n        nextDay: '[Tomorrow at] LT',\n        nextWeek: 'dddd [at] LT',\n        lastDay: '[Yesterday at] LT',\n        lastWeek: '[Last] dddd [at] LT',\n        sameElse: 'L',\n    };\n\n    function calendar(key, mom, now) {\n        var output = this._calendar[key] || this._calendar['sameElse'];\n        return isFunction(output) ? output.call(mom, now) : output;\n    }\n\n    function zeroFill(number, targetLength, forceSign) {\n        var absNumber = '' + Math.abs(number),\n            zerosToFill = targetLength - absNumber.length,\n            sign = number >= 0;\n        return (\n            (sign ? (forceSign ? '+' : '') : '-') +\n            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +\n            absNumber\n        );\n    }\n\n    var formattingTokens =\n            /(\\[[^\\[]*\\])|(\\\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,\n        localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g,\n        formatFunctions = {},\n        formatTokenFunctions = {};\n\n    // token:    'M'\n    // padded:   ['MM', 2]\n    // ordinal:  'Mo'\n    // callback: function () { this.month() + 1 }\n    function addFormatToken(token, padded, ordinal, callback) {\n        var func = callback;\n        if (typeof callback === 'string') {\n            func = function () {\n                return this[callback]();\n            };\n        }\n        if (token) {\n            formatTokenFunctions[token] = func;\n        }\n        if (padded) {\n            formatTokenFunctions[padded[0]] = function () {\n                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);\n            };\n        }\n        if (ordinal) {\n            formatTokenFunctions[ordinal] = function () {\n                return this.localeData().ordinal(\n                    func.apply(this, arguments),\n                    token\n                );\n            };\n        }\n    }\n\n    function removeFormattingTokens(input) {\n        if (input.match(/\\[[\\s\\S]/)) {\n            return input.replace(/^\\[|\\]$/g, '');\n        }\n        return input.replace(/\\\\/g, '');\n    }\n\n    function makeFormatFunction(format) {\n        var array = format.match(formattingTokens),\n            i,\n            length;\n\n        for (i = 0, length = array.length; i < length; i++) {\n            if (formatTokenFunctions[array[i]]) {\n                array[i] = formatTokenFunctions[array[i]];\n            } else {\n                array[i] = removeFormattingTokens(array[i]);\n            }\n        }\n\n        return function (mom) {\n            var output = '',\n                i;\n            for (i = 0; i < length; i++) {\n                output += isFunction(array[i])\n                    ? array[i].call(mom, format)\n                    : array[i];\n            }\n            return output;\n        };\n    }\n\n    // format date using native date object\n    function formatMoment(m, format) {\n        if (!m.isValid()) {\n            return m.localeData().invalidDate();\n        }\n\n        format = expandFormat(format, m.localeData());\n        formatFunctions[format] =\n            formatFunctions[format] || makeFormatFunction(format);\n\n        return formatFunctions[format](m);\n    }\n\n    function expandFormat(format, locale) {\n        var i = 5;\n\n        function replaceLongDateFormatTokens(input) {\n            return locale.longDateFormat(input) || input;\n        }\n\n        localFormattingTokens.lastIndex = 0;\n        while (i >= 0 && localFormattingTokens.test(format)) {\n            format = format.replace(\n                localFormattingTokens,\n                replaceLongDateFormatTokens\n            );\n            localFormattingTokens.lastIndex = 0;\n            i -= 1;\n        }\n\n        return format;\n    }\n\n    var defaultLongDateFormat = {\n        LTS: 'h:mm:ss A',\n        LT: 'h:mm A',\n        L: 'MM/DD/YYYY',\n        LL: 'MMMM D, YYYY',\n        LLL: 'MMMM D, YYYY h:mm A',\n        LLLL: 'dddd, MMMM D, YYYY h:mm A',\n    };\n\n    function longDateFormat(key) {\n        var format = this._longDateFormat[key],\n            formatUpper = this._longDateFormat[key.toUpperCase()];\n\n        if (format || !formatUpper) {\n            return format;\n        }\n\n        this._longDateFormat[key] = formatUpper\n            .match(formattingTokens)\n            .map(function (tok) {\n                if (\n                    tok === 'MMMM' ||\n                    tok === 'MM' ||\n                    tok === 'DD' ||\n                    tok === 'dddd'\n                ) {\n                    return tok.slice(1);\n                }\n                return tok;\n            })\n            .join('');\n\n        return this._longDateFormat[key];\n    }\n\n    var defaultInvalidDate = 'Invalid date';\n\n    function invalidDate() {\n        return this._invalidDate;\n    }\n\n    var defaultOrdinal = '%d',\n        defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n\n    function ordinal(number) {\n        return this._ordinal.replace('%d', number);\n    }\n\n    var defaultRelativeTime = {\n        future: 'in %s',\n        past: '%s ago',\n        s: 'a few seconds',\n        ss: '%d seconds',\n        m: 'a minute',\n        mm: '%d minutes',\n        h: 'an hour',\n        hh: '%d hours',\n        d: 'a day',\n        dd: '%d days',\n        w: 'a week',\n        ww: '%d weeks',\n        M: 'a month',\n        MM: '%d months',\n        y: 'a year',\n        yy: '%d years',\n    };\n\n    function relativeTime(number, withoutSuffix, string, isFuture) {\n        var output = this._relativeTime[string];\n        return isFunction(output)\n            ? output(number, withoutSuffix, string, isFuture)\n            : output.replace(/%d/i, number);\n    }\n\n    function pastFuture(diff, output) {\n        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n        return isFunction(format) ? format(output) : format.replace(/%s/i, output);\n    }\n\n    var aliases = {};\n\n    function addUnitAlias(unit, shorthand) {\n        var lowerCase = unit.toLowerCase();\n        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n    }\n\n    function normalizeUnits(units) {\n        return typeof units === 'string'\n            ? aliases[units] || aliases[units.toLowerCase()]\n            : undefined;\n    }\n\n    function normalizeObjectUnits(inputObject) {\n        var normalizedInput = {},\n            normalizedProp,\n            prop;\n\n        for (prop in inputObject) {\n            if (hasOwnProp(inputObject, prop)) {\n                normalizedProp = normalizeUnits(prop);\n                if (normalizedProp) {\n                    normalizedInput[normalizedProp] = inputObject[prop];\n                }\n            }\n        }\n\n        return normalizedInput;\n    }\n\n    var priorities = {};\n\n    function addUnitPriority(unit, priority) {\n        priorities[unit] = priority;\n    }\n\n    function getPrioritizedUnits(unitsObj) {\n        var units = [],\n            u;\n        for (u in unitsObj) {\n            if (hasOwnProp(unitsObj, u)) {\n                units.push({ unit: u, priority: priorities[u] });\n            }\n        }\n        units.sort(function (a, b) {\n            return a.priority - b.priority;\n        });\n        return units;\n    }\n\n    function isLeapYear(year) {\n        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n    }\n\n    function absFloor(number) {\n        if (number < 0) {\n            // -0 -> 0\n            return Math.ceil(number) || 0;\n        } else {\n            return Math.floor(number);\n        }\n    }\n\n    function toInt(argumentForCoercion) {\n        var coercedNumber = +argumentForCoercion,\n            value = 0;\n\n        if (coercedNumber !== 0 && isFinite(coercedNumber)) {\n            value = absFloor(coercedNumber);\n        }\n\n        return value;\n    }\n\n    function makeGetSet(unit, keepTime) {\n        return function (value) {\n            if (value != null) {\n                set$1(this, unit, value);\n                hooks.updateOffset(this, keepTime);\n                return this;\n            } else {\n                return get(this, unit);\n            }\n        };\n    }\n\n    function get(mom, unit) {\n        return mom.isValid()\n            ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()\n            : NaN;\n    }\n\n    function set$1(mom, unit, value) {\n        if (mom.isValid() && !isNaN(value)) {\n            if (\n                unit === 'FullYear' &&\n                isLeapYear(mom.year()) &&\n                mom.month() === 1 &&\n                mom.date() === 29\n            ) {\n                value = toInt(value);\n                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](\n                    value,\n                    mom.month(),\n                    daysInMonth(value, mom.month())\n                );\n            } else {\n                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);\n            }\n        }\n    }\n\n    // MOMENTS\n\n    function stringGet(units) {\n        units = normalizeUnits(units);\n        if (isFunction(this[units])) {\n            return this[units]();\n        }\n        return this;\n    }\n\n    function stringSet(units, value) {\n        if (typeof units === 'object') {\n            units = normalizeObjectUnits(units);\n            var prioritized = getPrioritizedUnits(units),\n                i,\n                prioritizedLen = prioritized.length;\n            for (i = 0; i < prioritizedLen; i++) {\n                this[prioritized[i].unit](units[prioritized[i].unit]);\n            }\n        } else {\n            units = normalizeUnits(units);\n            if (isFunction(this[units])) {\n                return this[units](value);\n            }\n        }\n        return this;\n    }\n\n    var match1 = /\\d/, //       0 - 9\n        match2 = /\\d\\d/, //      00 - 99\n        match3 = /\\d{3}/, //     000 - 999\n        match4 = /\\d{4}/, //    0000 - 9999\n        match6 = /[+-]?\\d{6}/, // -999999 - 999999\n        match1to2 = /\\d\\d?/, //       0 - 99\n        match3to4 = /\\d\\d\\d\\d?/, //     999 - 9999\n        match5to6 = /\\d\\d\\d\\d\\d\\d?/, //   99999 - 999999\n        match1to3 = /\\d{1,3}/, //       0 - 999\n        match1to4 = /\\d{1,4}/, //       0 - 9999\n        match1to6 = /[+-]?\\d{1,6}/, // -999999 - 999999\n        matchUnsigned = /\\d+/, //       0 - inf\n        matchSigned = /[+-]?\\d+/, //    -inf - inf\n        matchOffset = /Z|[+-]\\d\\d:?\\d\\d/gi, // +00:00 -00:00 +0000 -0000 or Z\n        matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n        matchTimestamp = /[+-]?\\d+(\\.\\d{1,3})?/, // 123456789 123456789.123\n        // any word (or two) characters or numbers including two/three word month in arabic.\n        // includes scottish gaelic two word and hyphenated months\n        matchWord =\n            /[0-9]{0,256}['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFF07\\uFF10-\\uFFEF]{1,256}|[\\u0600-\\u06FF\\/]{1,256}(\\s*?[\\u0600-\\u06FF]{1,256}){1,2}/i,\n        regexes;\n\n    regexes = {};\n\n    function addRegexToken(token, regex, strictRegex) {\n        regexes[token] = isFunction(regex)\n            ? regex\n            : function (isStrict, localeData) {\n                  return isStrict && strictRegex ? strictRegex : regex;\n              };\n    }\n\n    function getParseRegexForToken(token, config) {\n        if (!hasOwnProp(regexes, token)) {\n            return new RegExp(unescapeFormat(token));\n        }\n\n        return regexes[token](config._strict, config._locale);\n    }\n\n    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript\n    function unescapeFormat(s) {\n        return regexEscape(\n            s\n                .replace('\\\\', '')\n                .replace(\n                    /\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g,\n                    function (matched, p1, p2, p3, p4) {\n                        return p1 || p2 || p3 || p4;\n                    }\n                )\n        );\n    }\n\n    function regexEscape(s) {\n        return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n    }\n\n    var tokens = {};\n\n    function addParseToken(token, callback) {\n        var i,\n            func = callback,\n            tokenLen;\n        if (typeof token === 'string') {\n            token = [token];\n        }\n        if (isNumber(callback)) {\n            func = function (input, array) {\n                array[callback] = toInt(input);\n            };\n        }\n        tokenLen = token.length;\n        for (i = 0; i < tokenLen; i++) {\n            tokens[token[i]] = func;\n        }\n    }\n\n    function addWeekParseToken(token, callback) {\n        addParseToken(token, function (input, array, config, token) {\n            config._w = config._w || {};\n            callback(input, config._w, config, token);\n        });\n    }\n\n    function addTimeToArrayFromToken(token, input, config) {\n        if (input != null && hasOwnProp(tokens, token)) {\n            tokens[token](input, config._a, config, token);\n        }\n    }\n\n    var YEAR = 0,\n        MONTH = 1,\n        DATE = 2,\n        HOUR = 3,\n        MINUTE = 4,\n        SECOND = 5,\n        MILLISECOND = 6,\n        WEEK = 7,\n        WEEKDAY = 8;\n\n    function mod(n, x) {\n        return ((n % x) + x) % x;\n    }\n\n    var indexOf;\n\n    if (Array.prototype.indexOf) {\n        indexOf = Array.prototype.indexOf;\n    } else {\n        indexOf = function (o) {\n            // I know\n            var i;\n            for (i = 0; i < this.length; ++i) {\n                if (this[i] === o) {\n                    return i;\n                }\n            }\n            return -1;\n        };\n    }\n\n    function daysInMonth(year, month) {\n        if (isNaN(year) || isNaN(month)) {\n            return NaN;\n        }\n        var modMonth = mod(month, 12);\n        year += (month - modMonth) / 12;\n        return modMonth === 1\n            ? isLeapYear(year)\n                ? 29\n                : 28\n            : 31 - ((modMonth % 7) % 2);\n    }\n\n    // FORMATTING\n\n    addFormatToken('M', ['MM', 2], 'Mo', function () {\n        return this.month() + 1;\n    });\n\n    addFormatToken('MMM', 0, 0, function (format) {\n        return this.localeData().monthsShort(this, format);\n    });\n\n    addFormatToken('MMMM', 0, 0, function (format) {\n        return this.localeData().months(this, format);\n    });\n\n    // ALIASES\n\n    addUnitAlias('month', 'M');\n\n    // PRIORITY\n\n    addUnitPriority('month', 8);\n\n    // PARSING\n\n    addRegexToken('M', match1to2);\n    addRegexToken('MM', match1to2, match2);\n    addRegexToken('MMM', function (isStrict, locale) {\n        return locale.monthsShortRegex(isStrict);\n    });\n    addRegexToken('MMMM', function (isStrict, locale) {\n        return locale.monthsRegex(isStrict);\n    });\n\n    addParseToken(['M', 'MM'], function (input, array) {\n        array[MONTH] = toInt(input) - 1;\n    });\n\n    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {\n        var month = config._locale.monthsParse(input, token, config._strict);\n        // if we didn't find a month name, mark the date as invalid.\n        if (month != null) {\n            array[MONTH] = month;\n        } else {\n            getParsingFlags(config).invalidMonth = input;\n        }\n    });\n\n    // LOCALES\n\n    var defaultLocaleMonths =\n            'January_February_March_April_May_June_July_August_September_October_November_December'.split(\n                '_'\n            ),\n        defaultLocaleMonthsShort =\n            'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),\n        MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/,\n        defaultMonthsShortRegex = matchWord,\n        defaultMonthsRegex = matchWord;\n\n    function localeMonths(m, format) {\n        if (!m) {\n            return isArray(this._months)\n                ? this._months\n                : this._months['standalone'];\n        }\n        return isArray(this._months)\n            ? this._months[m.month()]\n            : this._months[\n                  (this._months.isFormat || MONTHS_IN_FORMAT).test(format)\n                      ? 'format'\n                      : 'standalone'\n              ][m.month()];\n    }\n\n    function localeMonthsShort(m, format) {\n        if (!m) {\n            return isArray(this._monthsShort)\n                ? this._monthsShort\n                : this._monthsShort['standalone'];\n        }\n        return isArray(this._monthsShort)\n            ? this._monthsShort[m.month()]\n            : this._monthsShort[\n                  MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'\n              ][m.month()];\n    }\n\n    function handleStrictParse(monthName, format, strict) {\n        var i,\n            ii,\n            mom,\n            llc = monthName.toLocaleLowerCase();\n        if (!this._monthsParse) {\n            // this is not used\n            this._monthsParse = [];\n            this._longMonthsParse = [];\n            this._shortMonthsParse = [];\n            for (i = 0; i < 12; ++i) {\n                mom = createUTC([2000, i]);\n                this._shortMonthsParse[i] = this.monthsShort(\n                    mom,\n                    ''\n                ).toLocaleLowerCase();\n                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();\n            }\n        }\n\n        if (strict) {\n            if (format === 'MMM') {\n                ii = indexOf.call(this._shortMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._longMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        } else {\n            if (format === 'MMM') {\n                ii = indexOf.call(this._shortMonthsParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._longMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._longMonthsParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._shortMonthsParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        }\n    }\n\n    function localeMonthsParse(monthName, format, strict) {\n        var i, mom, regex;\n\n        if (this._monthsParseExact) {\n            return handleStrictParse.call(this, monthName, format, strict);\n        }\n\n        if (!this._monthsParse) {\n            this._monthsParse = [];\n            this._longMonthsParse = [];\n            this._shortMonthsParse = [];\n        }\n\n        // TODO: add sorting\n        // Sorting makes sure if one month (or abbr) is a prefix of another\n        // see sorting in computeMonthsParse\n        for (i = 0; i < 12; i++) {\n            // make the regex if we don't have it already\n            mom = createUTC([2000, i]);\n            if (strict && !this._longMonthsParse[i]) {\n                this._longMonthsParse[i] = new RegExp(\n                    '^' + this.months(mom, '').replace('.', '') + '$',\n                    'i'\n                );\n                this._shortMonthsParse[i] = new RegExp(\n                    '^' + this.monthsShort(mom, '').replace('.', '') + '$',\n                    'i'\n                );\n            }\n            if (!strict && !this._monthsParse[i]) {\n                regex =\n                    '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n            }\n            // test the regex\n            if (\n                strict &&\n                format === 'MMMM' &&\n                this._longMonthsParse[i].test(monthName)\n            ) {\n                return i;\n            } else if (\n                strict &&\n                format === 'MMM' &&\n                this._shortMonthsParse[i].test(monthName)\n            ) {\n                return i;\n            } else if (!strict && this._monthsParse[i].test(monthName)) {\n                return i;\n            }\n        }\n    }\n\n    // MOMENTS\n\n    function setMonth(mom, value) {\n        var dayOfMonth;\n\n        if (!mom.isValid()) {\n            // No op\n            return mom;\n        }\n\n        if (typeof value === 'string') {\n            if (/^\\d+$/.test(value)) {\n                value = toInt(value);\n            } else {\n                value = mom.localeData().monthsParse(value);\n                // TODO: Another silent failure?\n                if (!isNumber(value)) {\n                    return mom;\n                }\n            }\n        }\n\n        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);\n        return mom;\n    }\n\n    function getSetMonth(value) {\n        if (value != null) {\n            setMonth(this, value);\n            hooks.updateOffset(this, true);\n            return this;\n        } else {\n            return get(this, 'Month');\n        }\n    }\n\n    function getDaysInMonth() {\n        return daysInMonth(this.year(), this.month());\n    }\n\n    function monthsShortRegex(isStrict) {\n        if (this._monthsParseExact) {\n            if (!hasOwnProp(this, '_monthsRegex')) {\n                computeMonthsParse.call(this);\n            }\n            if (isStrict) {\n                return this._monthsShortStrictRegex;\n            } else {\n                return this._monthsShortRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_monthsShortRegex')) {\n                this._monthsShortRegex = defaultMonthsShortRegex;\n            }\n            return this._monthsShortStrictRegex && isStrict\n                ? this._monthsShortStrictRegex\n                : this._monthsShortRegex;\n        }\n    }\n\n    function monthsRegex(isStrict) {\n        if (this._monthsParseExact) {\n            if (!hasOwnProp(this, '_monthsRegex')) {\n                computeMonthsParse.call(this);\n            }\n            if (isStrict) {\n                return this._monthsStrictRegex;\n            } else {\n                return this._monthsRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_monthsRegex')) {\n                this._monthsRegex = defaultMonthsRegex;\n            }\n            return this._monthsStrictRegex && isStrict\n                ? this._monthsStrictRegex\n                : this._monthsRegex;\n        }\n    }\n\n    function computeMonthsParse() {\n        function cmpLenRev(a, b) {\n            return b.length - a.length;\n        }\n\n        var shortPieces = [],\n            longPieces = [],\n            mixedPieces = [],\n            i,\n            mom;\n        for (i = 0; i < 12; i++) {\n            // make the regex if we don't have it already\n            mom = createUTC([2000, i]);\n            shortPieces.push(this.monthsShort(mom, ''));\n            longPieces.push(this.months(mom, ''));\n            mixedPieces.push(this.months(mom, ''));\n            mixedPieces.push(this.monthsShort(mom, ''));\n        }\n        // Sorting makes sure if one month (or abbr) is a prefix of another it\n        // will match the longer piece.\n        shortPieces.sort(cmpLenRev);\n        longPieces.sort(cmpLenRev);\n        mixedPieces.sort(cmpLenRev);\n        for (i = 0; i < 12; i++) {\n            shortPieces[i] = regexEscape(shortPieces[i]);\n            longPieces[i] = regexEscape(longPieces[i]);\n        }\n        for (i = 0; i < 24; i++) {\n            mixedPieces[i] = regexEscape(mixedPieces[i]);\n        }\n\n        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n        this._monthsShortRegex = this._monthsRegex;\n        this._monthsStrictRegex = new RegExp(\n            '^(' + longPieces.join('|') + ')',\n            'i'\n        );\n        this._monthsShortStrictRegex = new RegExp(\n            '^(' + shortPieces.join('|') + ')',\n            'i'\n        );\n    }\n\n    // FORMATTING\n\n    addFormatToken('Y', 0, 0, function () {\n        var y = this.year();\n        return y <= 9999 ? zeroFill(y, 4) : '+' + y;\n    });\n\n    addFormatToken(0, ['YY', 2], 0, function () {\n        return this.year() % 100;\n    });\n\n    addFormatToken(0, ['YYYY', 4], 0, 'year');\n    addFormatToken(0, ['YYYYY', 5], 0, 'year');\n    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n    // ALIASES\n\n    addUnitAlias('year', 'y');\n\n    // PRIORITIES\n\n    addUnitPriority('year', 1);\n\n    // PARSING\n\n    addRegexToken('Y', matchSigned);\n    addRegexToken('YY', match1to2, match2);\n    addRegexToken('YYYY', match1to4, match4);\n    addRegexToken('YYYYY', match1to6, match6);\n    addRegexToken('YYYYYY', match1to6, match6);\n\n    addParseToken(['YYYYY', 'YYYYYY'], YEAR);\n    addParseToken('YYYY', function (input, array) {\n        array[YEAR] =\n            input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n    });\n    addParseToken('YY', function (input, array) {\n        array[YEAR] = hooks.parseTwoDigitYear(input);\n    });\n    addParseToken('Y', function (input, array) {\n        array[YEAR] = parseInt(input, 10);\n    });\n\n    // HELPERS\n\n    function daysInYear(year) {\n        return isLeapYear(year) ? 366 : 365;\n    }\n\n    // HOOKS\n\n    hooks.parseTwoDigitYear = function (input) {\n        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n    };\n\n    // MOMENTS\n\n    var getSetYear = makeGetSet('FullYear', true);\n\n    function getIsLeapYear() {\n        return isLeapYear(this.year());\n    }\n\n    function createDate(y, m, d, h, M, s, ms) {\n        // can't just apply() to create a date:\n        // https://stackoverflow.com/q/181348\n        var date;\n        // the date constructor remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            // preserve leap years using a full 400 year cycle, then reset\n            date = new Date(y + 400, m, d, h, M, s, ms);\n            if (isFinite(date.getFullYear())) {\n                date.setFullYear(y);\n            }\n        } else {\n            date = new Date(y, m, d, h, M, s, ms);\n        }\n\n        return date;\n    }\n\n    function createUTCDate(y) {\n        var date, args;\n        // the Date.UTC function remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            args = Array.prototype.slice.call(arguments);\n            // preserve leap years using a full 400 year cycle, then reset\n            args[0] = y + 400;\n            date = new Date(Date.UTC.apply(null, args));\n            if (isFinite(date.getUTCFullYear())) {\n                date.setUTCFullYear(y);\n            }\n        } else {\n            date = new Date(Date.UTC.apply(null, arguments));\n        }\n\n        return date;\n    }\n\n    // start-of-first-week - start-of-year\n    function firstWeekOffset(year, dow, doy) {\n        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)\n            fwd = 7 + dow - doy,\n            // first-week day local weekday -- which local weekday is fwd\n            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;\n\n        return -fwdlw + fwd - 1;\n    }\n\n    // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday\n    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {\n        var localWeekday = (7 + weekday - dow) % 7,\n            weekOffset = firstWeekOffset(year, dow, doy),\n            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,\n            resYear,\n            resDayOfYear;\n\n        if (dayOfYear <= 0) {\n            resYear = year - 1;\n            resDayOfYear = daysInYear(resYear) + dayOfYear;\n        } else if (dayOfYear > daysInYear(year)) {\n            resYear = year + 1;\n            resDayOfYear = dayOfYear - daysInYear(year);\n        } else {\n            resYear = year;\n            resDayOfYear = dayOfYear;\n        }\n\n        return {\n            year: resYear,\n            dayOfYear: resDayOfYear,\n        };\n    }\n\n    function weekOfYear(mom, dow, doy) {\n        var weekOffset = firstWeekOffset(mom.year(), dow, doy),\n            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,\n            resWeek,\n            resYear;\n\n        if (week < 1) {\n            resYear = mom.year() - 1;\n            resWeek = week + weeksInYear(resYear, dow, doy);\n        } else if (week > weeksInYear(mom.year(), dow, doy)) {\n            resWeek = week - weeksInYear(mom.year(), dow, doy);\n            resYear = mom.year() + 1;\n        } else {\n            resYear = mom.year();\n            resWeek = week;\n        }\n\n        return {\n            week: resWeek,\n            year: resYear,\n        };\n    }\n\n    function weeksInYear(year, dow, doy) {\n        var weekOffset = firstWeekOffset(year, dow, doy),\n            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);\n        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;\n    }\n\n    // FORMATTING\n\n    addFormatToken('w', ['ww', 2], 'wo', 'week');\n    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n    // ALIASES\n\n    addUnitAlias('week', 'w');\n    addUnitAlias('isoWeek', 'W');\n\n    // PRIORITIES\n\n    addUnitPriority('week', 5);\n    addUnitPriority('isoWeek', 5);\n\n    // PARSING\n\n    addRegexToken('w', match1to2);\n    addRegexToken('ww', match1to2, match2);\n    addRegexToken('W', match1to2);\n    addRegexToken('WW', match1to2, match2);\n\n    addWeekParseToken(\n        ['w', 'ww', 'W', 'WW'],\n        function (input, week, config, token) {\n            week[token.substr(0, 1)] = toInt(input);\n        }\n    );\n\n    // HELPERS\n\n    // LOCALES\n\n    function localeWeek(mom) {\n        return weekOfYear(mom, this._week.dow, this._week.doy).week;\n    }\n\n    var defaultLocaleWeek = {\n        dow: 0, // Sunday is the first day of the week.\n        doy: 6, // The week that contains Jan 6th is the first week of the year.\n    };\n\n    function localeFirstDayOfWeek() {\n        return this._week.dow;\n    }\n\n    function localeFirstDayOfYear() {\n        return this._week.doy;\n    }\n\n    // MOMENTS\n\n    function getSetWeek(input) {\n        var week = this.localeData().week(this);\n        return input == null ? week : this.add((input - week) * 7, 'd');\n    }\n\n    function getSetISOWeek(input) {\n        var week = weekOfYear(this, 1, 4).week;\n        return input == null ? week : this.add((input - week) * 7, 'd');\n    }\n\n    // FORMATTING\n\n    addFormatToken('d', 0, 'do', 'day');\n\n    addFormatToken('dd', 0, 0, function (format) {\n        return this.localeData().weekdaysMin(this, format);\n    });\n\n    addFormatToken('ddd', 0, 0, function (format) {\n        return this.localeData().weekdaysShort(this, format);\n    });\n\n    addFormatToken('dddd', 0, 0, function (format) {\n        return this.localeData().weekdays(this, format);\n    });\n\n    addFormatToken('e', 0, 0, 'weekday');\n    addFormatToken('E', 0, 0, 'isoWeekday');\n\n    // ALIASES\n\n    addUnitAlias('day', 'd');\n    addUnitAlias('weekday', 'e');\n    addUnitAlias('isoWeekday', 'E');\n\n    // PRIORITY\n    addUnitPriority('day', 11);\n    addUnitPriority('weekday', 11);\n    addUnitPriority('isoWeekday', 11);\n\n    // PARSING\n\n    addRegexToken('d', match1to2);\n    addRegexToken('e', match1to2);\n    addRegexToken('E', match1to2);\n    addRegexToken('dd', function (isStrict, locale) {\n        return locale.weekdaysMinRegex(isStrict);\n    });\n    addRegexToken('ddd', function (isStrict, locale) {\n        return locale.weekdaysShortRegex(isStrict);\n    });\n    addRegexToken('dddd', function (isStrict, locale) {\n        return locale.weekdaysRegex(isStrict);\n    });\n\n    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {\n        var weekday = config._locale.weekdaysParse(input, token, config._strict);\n        // if we didn't get a weekday name, mark the date as invalid\n        if (weekday != null) {\n            week.d = weekday;\n        } else {\n            getParsingFlags(config).invalidWeekday = input;\n        }\n    });\n\n    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n        week[token] = toInt(input);\n    });\n\n    // HELPERS\n\n    function parseWeekday(input, locale) {\n        if (typeof input !== 'string') {\n            return input;\n        }\n\n        if (!isNaN(input)) {\n            return parseInt(input, 10);\n        }\n\n        input = locale.weekdaysParse(input);\n        if (typeof input === 'number') {\n            return input;\n        }\n\n        return null;\n    }\n\n    function parseIsoWeekday(input, locale) {\n        if (typeof input === 'string') {\n            return locale.weekdaysParse(input) % 7 || 7;\n        }\n        return isNaN(input) ? null : input;\n    }\n\n    // LOCALES\n    function shiftWeekdays(ws, n) {\n        return ws.slice(n, 7).concat(ws.slice(0, n));\n    }\n\n    var defaultLocaleWeekdays =\n            'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),\n        defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),\n        defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),\n        defaultWeekdaysRegex = matchWord,\n        defaultWeekdaysShortRegex = matchWord,\n        defaultWeekdaysMinRegex = matchWord;\n\n    function localeWeekdays(m, format) {\n        var weekdays = isArray(this._weekdays)\n            ? this._weekdays\n            : this._weekdays[\n                  m && m !== true && this._weekdays.isFormat.test(format)\n                      ? 'format'\n                      : 'standalone'\n              ];\n        return m === true\n            ? shiftWeekdays(weekdays, this._week.dow)\n            : m\n            ? weekdays[m.day()]\n            : weekdays;\n    }\n\n    function localeWeekdaysShort(m) {\n        return m === true\n            ? shiftWeekdays(this._weekdaysShort, this._week.dow)\n            : m\n            ? this._weekdaysShort[m.day()]\n            : this._weekdaysShort;\n    }\n\n    function localeWeekdaysMin(m) {\n        return m === true\n            ? shiftWeekdays(this._weekdaysMin, this._week.dow)\n            : m\n            ? this._weekdaysMin[m.day()]\n            : this._weekdaysMin;\n    }\n\n    function handleStrictParse$1(weekdayName, format, strict) {\n        var i,\n            ii,\n            mom,\n            llc = weekdayName.toLocaleLowerCase();\n        if (!this._weekdaysParse) {\n            this._weekdaysParse = [];\n            this._shortWeekdaysParse = [];\n            this._minWeekdaysParse = [];\n\n            for (i = 0; i < 7; ++i) {\n                mom = createUTC([2000, 1]).day(i);\n                this._minWeekdaysParse[i] = this.weekdaysMin(\n                    mom,\n                    ''\n                ).toLocaleLowerCase();\n                this._shortWeekdaysParse[i] = this.weekdaysShort(\n                    mom,\n                    ''\n                ).toLocaleLowerCase();\n                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();\n            }\n        }\n\n        if (strict) {\n            if (format === 'dddd') {\n                ii = indexOf.call(this._weekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else if (format === 'ddd') {\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        } else {\n            if (format === 'dddd') {\n                ii = indexOf.call(this._weekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else if (format === 'ddd') {\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._weekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            } else {\n                ii = indexOf.call(this._minWeekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._weekdaysParse, llc);\n                if (ii !== -1) {\n                    return ii;\n                }\n                ii = indexOf.call(this._shortWeekdaysParse, llc);\n                return ii !== -1 ? ii : null;\n            }\n        }\n    }\n\n    function localeWeekdaysParse(weekdayName, format, strict) {\n        var i, mom, regex;\n\n        if (this._weekdaysParseExact) {\n            return handleStrictParse$1.call(this, weekdayName, format, strict);\n        }\n\n        if (!this._weekdaysParse) {\n            this._weekdaysParse = [];\n            this._minWeekdaysParse = [];\n            this._shortWeekdaysParse = [];\n            this._fullWeekdaysParse = [];\n        }\n\n        for (i = 0; i < 7; i++) {\n            // make the regex if we don't have it already\n\n            mom = createUTC([2000, 1]).day(i);\n            if (strict && !this._fullWeekdaysParse[i]) {\n                this._fullWeekdaysParse[i] = new RegExp(\n                    '^' + this.weekdays(mom, '').replace('.', '\\\\.?') + '$',\n                    'i'\n                );\n                this._shortWeekdaysParse[i] = new RegExp(\n                    '^' + this.weekdaysShort(mom, '').replace('.', '\\\\.?') + '$',\n                    'i'\n                );\n                this._minWeekdaysParse[i] = new RegExp(\n                    '^' + this.weekdaysMin(mom, '').replace('.', '\\\\.?') + '$',\n                    'i'\n                );\n            }\n            if (!this._weekdaysParse[i]) {\n                regex =\n                    '^' +\n                    this.weekdays(mom, '') +\n                    '|^' +\n                    this.weekdaysShort(mom, '') +\n                    '|^' +\n                    this.weekdaysMin(mom, '');\n                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');\n            }\n            // test the regex\n            if (\n                strict &&\n                format === 'dddd' &&\n                this._fullWeekdaysParse[i].test(weekdayName)\n            ) {\n                return i;\n            } else if (\n                strict &&\n                format === 'ddd' &&\n                this._shortWeekdaysParse[i].test(weekdayName)\n            ) {\n                return i;\n            } else if (\n                strict &&\n                format === 'dd' &&\n                this._minWeekdaysParse[i].test(weekdayName)\n            ) {\n                return i;\n            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {\n                return i;\n            }\n        }\n    }\n\n    // MOMENTS\n\n    function getSetDayOfWeek(input) {\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n        if (input != null) {\n            input = parseWeekday(input, this.localeData());\n            return this.add(input - day, 'd');\n        } else {\n            return day;\n        }\n    }\n\n    function getSetLocaleDayOfWeek(input) {\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;\n        return input == null ? weekday : this.add(input - weekday, 'd');\n    }\n\n    function getSetISODayOfWeek(input) {\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n\n        // behaves the same as moment#day except\n        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)\n        // as a setter, sunday should belong to the previous week.\n\n        if (input != null) {\n            var weekday = parseIsoWeekday(input, this.localeData());\n            return this.day(this.day() % 7 ? weekday : weekday - 7);\n        } else {\n            return this.day() || 7;\n        }\n    }\n\n    function weekdaysRegex(isStrict) {\n        if (this._weekdaysParseExact) {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                computeWeekdaysParse.call(this);\n            }\n            if (isStrict) {\n                return this._weekdaysStrictRegex;\n            } else {\n                return this._weekdaysRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                this._weekdaysRegex = defaultWeekdaysRegex;\n            }\n            return this._weekdaysStrictRegex && isStrict\n                ? this._weekdaysStrictRegex\n                : this._weekdaysRegex;\n        }\n    }\n\n    function weekdaysShortRegex(isStrict) {\n        if (this._weekdaysParseExact) {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                computeWeekdaysParse.call(this);\n            }\n            if (isStrict) {\n                return this._weekdaysShortStrictRegex;\n            } else {\n                return this._weekdaysShortRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_weekdaysShortRegex')) {\n                this._weekdaysShortRegex = defaultWeekdaysShortRegex;\n            }\n            return this._weekdaysShortStrictRegex && isStrict\n                ? this._weekdaysShortStrictRegex\n                : this._weekdaysShortRegex;\n        }\n    }\n\n    function weekdaysMinRegex(isStrict) {\n        if (this._weekdaysParseExact) {\n            if (!hasOwnProp(this, '_weekdaysRegex')) {\n                computeWeekdaysParse.call(this);\n            }\n            if (isStrict) {\n                return this._weekdaysMinStrictRegex;\n            } else {\n                return this._weekdaysMinRegex;\n            }\n        } else {\n            if (!hasOwnProp(this, '_weekdaysMinRegex')) {\n                this._weekdaysMinRegex = defaultWeekdaysMinRegex;\n            }\n            return this._weekdaysMinStrictRegex && isStrict\n                ? this._weekdaysMinStrictRegex\n                : this._weekdaysMinRegex;\n        }\n    }\n\n    function computeWeekdaysParse() {\n        function cmpLenRev(a, b) {\n            return b.length - a.length;\n        }\n\n        var minPieces = [],\n            shortPieces = [],\n            longPieces = [],\n            mixedPieces = [],\n            i,\n            mom,\n            minp,\n            shortp,\n            longp;\n        for (i = 0; i < 7; i++) {\n            // make the regex if we don't have it already\n            mom = createUTC([2000, 1]).day(i);\n            minp = regexEscape(this.weekdaysMin(mom, ''));\n            shortp = regexEscape(this.weekdaysShort(mom, ''));\n            longp = regexEscape(this.weekdays(mom, ''));\n            minPieces.push(minp);\n            shortPieces.push(shortp);\n            longPieces.push(longp);\n            mixedPieces.push(minp);\n            mixedPieces.push(shortp);\n            mixedPieces.push(longp);\n        }\n        // Sorting makes sure if one weekday (or abbr) is a prefix of another it\n        // will match the longer piece.\n        minPieces.sort(cmpLenRev);\n        shortPieces.sort(cmpLenRev);\n        longPieces.sort(cmpLenRev);\n        mixedPieces.sort(cmpLenRev);\n\n        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n        this._weekdaysShortRegex = this._weekdaysRegex;\n        this._weekdaysMinRegex = this._weekdaysRegex;\n\n        this._weekdaysStrictRegex = new RegExp(\n            '^(' + longPieces.join('|') + ')',\n            'i'\n        );\n        this._weekdaysShortStrictRegex = new RegExp(\n            '^(' + shortPieces.join('|') + ')',\n            'i'\n        );\n        this._weekdaysMinStrictRegex = new RegExp(\n            '^(' + minPieces.join('|') + ')',\n            'i'\n        );\n    }\n\n    // FORMATTING\n\n    function hFormat() {\n        return this.hours() % 12 || 12;\n    }\n\n    function kFormat() {\n        return this.hours() || 24;\n    }\n\n    addFormatToken('H', ['HH', 2], 0, 'hour');\n    addFormatToken('h', ['hh', 2], 0, hFormat);\n    addFormatToken('k', ['kk', 2], 0, kFormat);\n\n    addFormatToken('hmm', 0, 0, function () {\n        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n    });\n\n    addFormatToken('hmmss', 0, 0, function () {\n        return (\n            '' +\n            hFormat.apply(this) +\n            zeroFill(this.minutes(), 2) +\n            zeroFill(this.seconds(), 2)\n        );\n    });\n\n    addFormatToken('Hmm', 0, 0, function () {\n        return '' + this.hours() + zeroFill(this.minutes(), 2);\n    });\n\n    addFormatToken('Hmmss', 0, 0, function () {\n        return (\n            '' +\n            this.hours() +\n            zeroFill(this.minutes(), 2) +\n            zeroFill(this.seconds(), 2)\n        );\n    });\n\n    function meridiem(token, lowercase) {\n        addFormatToken(token, 0, 0, function () {\n            return this.localeData().meridiem(\n                this.hours(),\n                this.minutes(),\n                lowercase\n            );\n        });\n    }\n\n    meridiem('a', true);\n    meridiem('A', false);\n\n    // ALIASES\n\n    addUnitAlias('hour', 'h');\n\n    // PRIORITY\n    addUnitPriority('hour', 13);\n\n    // PARSING\n\n    function matchMeridiem(isStrict, locale) {\n        return locale._meridiemParse;\n    }\n\n    addRegexToken('a', matchMeridiem);\n    addRegexToken('A', matchMeridiem);\n    addRegexToken('H', match1to2);\n    addRegexToken('h', match1to2);\n    addRegexToken('k', match1to2);\n    addRegexToken('HH', match1to2, match2);\n    addRegexToken('hh', match1to2, match2);\n    addRegexToken('kk', match1to2, match2);\n\n    addRegexToken('hmm', match3to4);\n    addRegexToken('hmmss', match5to6);\n    addRegexToken('Hmm', match3to4);\n    addRegexToken('Hmmss', match5to6);\n\n    addParseToken(['H', 'HH'], HOUR);\n    addParseToken(['k', 'kk'], function (input, array, config) {\n        var kInput = toInt(input);\n        array[HOUR] = kInput === 24 ? 0 : kInput;\n    });\n    addParseToken(['a', 'A'], function (input, array, config) {\n        config._isPm = config._locale.isPM(input);\n        config._meridiem = input;\n    });\n    addParseToken(['h', 'hh'], function (input, array, config) {\n        array[HOUR] = toInt(input);\n        getParsingFlags(config).bigHour = true;\n    });\n    addParseToken('hmm', function (input, array, config) {\n        var pos = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos));\n        array[MINUTE] = toInt(input.substr(pos));\n        getParsingFlags(config).bigHour = true;\n    });\n    addParseToken('hmmss', function (input, array, config) {\n        var pos1 = input.length - 4,\n            pos2 = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos1));\n        array[MINUTE] = toInt(input.substr(pos1, 2));\n        array[SECOND] = toInt(input.substr(pos2));\n        getParsingFlags(config).bigHour = true;\n    });\n    addParseToken('Hmm', function (input, array, config) {\n        var pos = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos));\n        array[MINUTE] = toInt(input.substr(pos));\n    });\n    addParseToken('Hmmss', function (input, array, config) {\n        var pos1 = input.length - 4,\n            pos2 = input.length - 2;\n        array[HOUR] = toInt(input.substr(0, pos1));\n        array[MINUTE] = toInt(input.substr(pos1, 2));\n        array[SECOND] = toInt(input.substr(pos2));\n    });\n\n    // LOCALES\n\n    function localeIsPM(input) {\n        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays\n        // Using charAt should be more compatible.\n        return (input + '').toLowerCase().charAt(0) === 'p';\n    }\n\n    var defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i,\n        // Setting the hour should keep the time, because the user explicitly\n        // specified which hour they want. So trying to maintain the same hour (in\n        // a new timezone) makes sense. Adding/subtracting hours does not follow\n        // this rule.\n        getSetHour = makeGetSet('Hours', true);\n\n    function localeMeridiem(hours, minutes, isLower) {\n        if (hours > 11) {\n            return isLower ? 'pm' : 'PM';\n        } else {\n            return isLower ? 'am' : 'AM';\n        }\n    }\n\n    var baseConfig = {\n        calendar: defaultCalendar,\n        longDateFormat: defaultLongDateFormat,\n        invalidDate: defaultInvalidDate,\n        ordinal: defaultOrdinal,\n        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,\n        relativeTime: defaultRelativeTime,\n\n        months: defaultLocaleMonths,\n        monthsShort: defaultLocaleMonthsShort,\n\n        week: defaultLocaleWeek,\n\n        weekdays: defaultLocaleWeekdays,\n        weekdaysMin: defaultLocaleWeekdaysMin,\n        weekdaysShort: defaultLocaleWeekdaysShort,\n\n        meridiemParse: defaultLocaleMeridiemParse,\n    };\n\n    // internal storage for locale config files\n    var locales = {},\n        localeFamilies = {},\n        globalLocale;\n\n    function commonPrefix(arr1, arr2) {\n        var i,\n            minl = Math.min(arr1.length, arr2.length);\n        for (i = 0; i < minl; i += 1) {\n            if (arr1[i] !== arr2[i]) {\n                return i;\n            }\n        }\n        return minl;\n    }\n\n    function normalizeLocale(key) {\n        return key ? key.toLowerCase().replace('_', '-') : key;\n    }\n\n    // pick the locale from the array\n    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root\n    function chooseLocale(names) {\n        var i = 0,\n            j,\n            next,\n            locale,\n            split;\n\n        while (i < names.length) {\n            split = normalizeLocale(names[i]).split('-');\n            j = split.length;\n            next = normalizeLocale(names[i + 1]);\n            next = next ? next.split('-') : null;\n            while (j > 0) {\n                locale = loadLocale(split.slice(0, j).join('-'));\n                if (locale) {\n                    return locale;\n                }\n                if (\n                    next &&\n                    next.length >= j &&\n                    commonPrefix(split, next) >= j - 1\n                ) {\n                    //the next array item is better than a shallower substring of this one\n                    break;\n                }\n                j--;\n            }\n            i++;\n        }\n        return globalLocale;\n    }\n\n    function isLocaleNameSane(name) {\n        // Prevent names that look like filesystem paths, i.e contain '/' or '\\'\n        return name.match('^[^/\\\\\\\\]*$') != null;\n    }\n\n    function loadLocale(name) {\n        var oldLocale = null,\n            aliasedRequire;\n        // TODO: Find a better way to register and load all the locales in Node\n        if (\n            locales[name] === undefined &&\n            typeof module !== 'undefined' &&\n            module &&\n            module.exports &&\n            isLocaleNameSane(name)\n        ) {\n            try {\n                oldLocale = globalLocale._abbr;\n                aliasedRequire = require;\n                aliasedRequire('./locale/' + name);\n                getSetGlobalLocale(oldLocale);\n            } catch (e) {\n                // mark as not found to avoid repeating expensive file require call causing high CPU\n                // when trying to find en-US, en_US, en-us for every format call\n                locales[name] = null; // null means not found\n            }\n        }\n        return locales[name];\n    }\n\n    // This function will load locale and then set the global locale.  If\n    // no arguments are passed in, it will simply return the current global\n    // locale key.\n    function getSetGlobalLocale(key, values) {\n        var data;\n        if (key) {\n            if (isUndefined(values)) {\n                data = getLocale(key);\n            } else {\n                data = defineLocale(key, values);\n            }\n\n            if (data) {\n                // moment.duration._locale = moment._locale = data;\n                globalLocale = data;\n            } else {\n                if (typeof console !== 'undefined' && console.warn) {\n                    //warn user if arguments are passed but the locale could not be set\n                    console.warn(\n                        'Locale ' + key + ' not found. Did you forget to load it?'\n                    );\n                }\n            }\n        }\n\n        return globalLocale._abbr;\n    }\n\n    function defineLocale(name, config) {\n        if (config !== null) {\n            var locale,\n                parentConfig = baseConfig;\n            config.abbr = name;\n            if (locales[name] != null) {\n                deprecateSimple(\n                    'defineLocaleOverride',\n                    'use moment.updateLocale(localeName, config) to change ' +\n                        'an existing locale. moment.defineLocale(localeName, ' +\n                        'config) should only be used for creating a new locale ' +\n                        'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'\n                );\n                parentConfig = locales[name]._config;\n            } else if (config.parentLocale != null) {\n                if (locales[config.parentLocale] != null) {\n                    parentConfig = locales[config.parentLocale]._config;\n                } else {\n                    locale = loadLocale(config.parentLocale);\n                    if (locale != null) {\n                        parentConfig = locale._config;\n                    } else {\n                        if (!localeFamilies[config.parentLocale]) {\n                            localeFamilies[config.parentLocale] = [];\n                        }\n                        localeFamilies[config.parentLocale].push({\n                            name: name,\n                            config: config,\n                        });\n                        return null;\n                    }\n                }\n            }\n            locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n            if (localeFamilies[name]) {\n                localeFamilies[name].forEach(function (x) {\n                    defineLocale(x.name, x.config);\n                });\n            }\n\n            // backwards compat for now: also set the locale\n            // make sure we set the locale AFTER all child locales have been\n            // created, so we won't end up with the child locale set.\n            getSetGlobalLocale(name);\n\n            return locales[name];\n        } else {\n            // useful for testing\n            delete locales[name];\n            return null;\n        }\n    }\n\n    function updateLocale(name, config) {\n        if (config != null) {\n            var locale,\n                tmpLocale,\n                parentConfig = baseConfig;\n\n            if (locales[name] != null && locales[name].parentLocale != null) {\n                // Update existing child locale in-place to avoid memory-leaks\n                locales[name].set(mergeConfigs(locales[name]._config, config));\n            } else {\n                // MERGE\n                tmpLocale = loadLocale(name);\n                if (tmpLocale != null) {\n                    parentConfig = tmpLocale._config;\n                }\n                config = mergeConfigs(parentConfig, config);\n                if (tmpLocale == null) {\n                    // updateLocale is called for creating a new locale\n                    // Set abbr so it will have a name (getters return\n                    // undefined otherwise).\n                    config.abbr = name;\n                }\n                locale = new Locale(config);\n                locale.parentLocale = locales[name];\n                locales[name] = locale;\n            }\n\n            // backwards compat for now: also set the locale\n            getSetGlobalLocale(name);\n        } else {\n            // pass null for config to unupdate, useful for tests\n            if (locales[name] != null) {\n                if (locales[name].parentLocale != null) {\n                    locales[name] = locales[name].parentLocale;\n                    if (name === getSetGlobalLocale()) {\n                        getSetGlobalLocale(name);\n                    }\n                } else if (locales[name] != null) {\n                    delete locales[name];\n                }\n            }\n        }\n        return locales[name];\n    }\n\n    // returns locale data\n    function getLocale(key) {\n        var locale;\n\n        if (key && key._locale && key._locale._abbr) {\n            key = key._locale._abbr;\n        }\n\n        if (!key) {\n            return globalLocale;\n        }\n\n        if (!isArray(key)) {\n            //short-circuit everything else\n            locale = loadLocale(key);\n            if (locale) {\n                return locale;\n            }\n            key = [key];\n        }\n\n        return chooseLocale(key);\n    }\n\n    function listLocales() {\n        return keys(locales);\n    }\n\n    function checkOverflow(m) {\n        var overflow,\n            a = m._a;\n\n        if (a && getParsingFlags(m).overflow === -2) {\n            overflow =\n                a[MONTH] < 0 || a[MONTH] > 11\n                    ? MONTH\n                    : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])\n                    ? DATE\n                    : a[HOUR] < 0 ||\n                      a[HOUR] > 24 ||\n                      (a[HOUR] === 24 &&\n                          (a[MINUTE] !== 0 ||\n                              a[SECOND] !== 0 ||\n                              a[MILLISECOND] !== 0))\n                    ? HOUR\n                    : a[MINUTE] < 0 || a[MINUTE] > 59\n                    ? MINUTE\n                    : a[SECOND] < 0 || a[SECOND] > 59\n                    ? SECOND\n                    : a[MILLISECOND] < 0 || a[MILLISECOND] > 999\n                    ? MILLISECOND\n                    : -1;\n\n            if (\n                getParsingFlags(m)._overflowDayOfYear &&\n                (overflow < YEAR || overflow > DATE)\n            ) {\n                overflow = DATE;\n            }\n            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {\n                overflow = WEEK;\n            }\n            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {\n                overflow = WEEKDAY;\n            }\n\n            getParsingFlags(m).overflow = overflow;\n        }\n\n        return m;\n    }\n\n    // iso 8601 regex\n    // 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)\n    var extendedIsoRegex =\n            /^\\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)?)?$/,\n        basicIsoRegex =\n            /^\\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)?)?$/,\n        tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/,\n        isoDates = [\n            ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/],\n            ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/],\n            ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/],\n            ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n            ['YYYY-DDD', /\\d{4}-\\d{3}/],\n            ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n            ['YYYYYYMMDD', /[+-]\\d{10}/],\n            ['YYYYMMDD', /\\d{8}/],\n            ['GGGG[W]WWE', /\\d{4}W\\d{3}/],\n            ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n            ['YYYYDDD', /\\d{7}/],\n            ['YYYYMM', /\\d{6}/, false],\n            ['YYYY', /\\d{4}/, false],\n        ],\n        // iso time formats and regexes\n        isoTimes = [\n            ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n            ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n            ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n            ['HH:mm', /\\d\\d:\\d\\d/],\n            ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n            ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n            ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n            ['HHmm', /\\d\\d\\d\\d/],\n            ['HH', /\\d\\d/],\n        ],\n        aspNetJsonRegex = /^\\/?Date\\((-?\\d+)/i,\n        // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\n        rfc2822 =\n            /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d{1,2})\\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(\\d{2,4})\\s(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\\d{4}))$/,\n        obsOffsets = {\n            UT: 0,\n            GMT: 0,\n            EDT: -4 * 60,\n            EST: -5 * 60,\n            CDT: -5 * 60,\n            CST: -6 * 60,\n            MDT: -6 * 60,\n            MST: -7 * 60,\n            PDT: -7 * 60,\n            PST: -8 * 60,\n        };\n\n    // date from iso format\n    function configFromISO(config) {\n        var i,\n            l,\n            string = config._i,\n            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),\n            allowTime,\n            dateFormat,\n            timeFormat,\n            tzFormat,\n            isoDatesLen = isoDates.length,\n            isoTimesLen = isoTimes.length;\n\n        if (match) {\n            getParsingFlags(config).iso = true;\n            for (i = 0, l = isoDatesLen; i < l; i++) {\n                if (isoDates[i][1].exec(match[1])) {\n                    dateFormat = isoDates[i][0];\n                    allowTime = isoDates[i][2] !== false;\n                    break;\n                }\n            }\n            if (dateFormat == null) {\n                config._isValid = false;\n                return;\n            }\n            if (match[3]) {\n                for (i = 0, l = isoTimesLen; i < l; i++) {\n                    if (isoTimes[i][1].exec(match[3])) {\n                        // match[2] should be 'T' or space\n                        timeFormat = (match[2] || ' ') + isoTimes[i][0];\n                        break;\n                    }\n                }\n                if (timeFormat == null) {\n                    config._isValid = false;\n                    return;\n                }\n            }\n            if (!allowTime && timeFormat != null) {\n                config._isValid = false;\n                return;\n            }\n            if (match[4]) {\n                if (tzRegex.exec(match[4])) {\n                    tzFormat = 'Z';\n                } else {\n                    config._isValid = false;\n                    return;\n                }\n            }\n            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n            configFromStringAndFormat(config);\n        } else {\n            config._isValid = false;\n        }\n    }\n\n    function extractFromRFC2822Strings(\n        yearStr,\n        monthStr,\n        dayStr,\n        hourStr,\n        minuteStr,\n        secondStr\n    ) {\n        var result = [\n            untruncateYear(yearStr),\n            defaultLocaleMonthsShort.indexOf(monthStr),\n            parseInt(dayStr, 10),\n            parseInt(hourStr, 10),\n            parseInt(minuteStr, 10),\n        ];\n\n        if (secondStr) {\n            result.push(parseInt(secondStr, 10));\n        }\n\n        return result;\n    }\n\n    function untruncateYear(yearStr) {\n        var year = parseInt(yearStr, 10);\n        if (year <= 49) {\n            return 2000 + year;\n        } else if (year <= 999) {\n            return 1900 + year;\n        }\n        return year;\n    }\n\n    function preprocessRFC2822(s) {\n        // Remove comments and folding whitespace and replace multiple-spaces with a single space\n        return s\n            .replace(/\\([^()]*\\)|[\\n\\t]/g, ' ')\n            .replace(/(\\s\\s+)/g, ' ')\n            .replace(/^\\s\\s*/, '')\n            .replace(/\\s\\s*$/, '');\n    }\n\n    function checkWeekday(weekdayStr, parsedInput, config) {\n        if (weekdayStr) {\n            // TODO: Replace the vanilla JS Date object with an independent day-of-week check.\n            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),\n                weekdayActual = new Date(\n                    parsedInput[0],\n                    parsedInput[1],\n                    parsedInput[2]\n                ).getDay();\n            if (weekdayProvided !== weekdayActual) {\n                getParsingFlags(config).weekdayMismatch = true;\n                config._isValid = false;\n                return false;\n            }\n        }\n        return true;\n    }\n\n    function calculateOffset(obsOffset, militaryOffset, numOffset) {\n        if (obsOffset) {\n            return obsOffsets[obsOffset];\n        } else if (militaryOffset) {\n            // the only allowed military tz is Z\n            return 0;\n        } else {\n            var hm = parseInt(numOffset, 10),\n                m = hm % 100,\n                h = (hm - m) / 100;\n            return h * 60 + m;\n        }\n    }\n\n    // date and time from ref 2822 format\n    function configFromRFC2822(config) {\n        var match = rfc2822.exec(preprocessRFC2822(config._i)),\n            parsedArray;\n        if (match) {\n            parsedArray = extractFromRFC2822Strings(\n                match[4],\n                match[3],\n                match[2],\n                match[5],\n                match[6],\n                match[7]\n            );\n            if (!checkWeekday(match[1], parsedArray, config)) {\n                return;\n            }\n\n            config._a = parsedArray;\n            config._tzm = calculateOffset(match[8], match[9], match[10]);\n\n            config._d = createUTCDate.apply(null, config._a);\n            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n\n            getParsingFlags(config).rfc2822 = true;\n        } else {\n            config._isValid = false;\n        }\n    }\n\n    // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict\n    function configFromString(config) {\n        var matched = aspNetJsonRegex.exec(config._i);\n        if (matched !== null) {\n            config._d = new Date(+matched[1]);\n            return;\n        }\n\n        configFromISO(config);\n        if (config._isValid === false) {\n            delete config._isValid;\n        } else {\n            return;\n        }\n\n        configFromRFC2822(config);\n        if (config._isValid === false) {\n            delete config._isValid;\n        } else {\n            return;\n        }\n\n        if (config._strict) {\n            config._isValid = false;\n        } else {\n            // Final attempt, use Input Fallback\n            hooks.createFromInputFallback(config);\n        }\n    }\n\n    hooks.createFromInputFallback = deprecate(\n        'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n            'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n            'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n        function (config) {\n            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n        }\n    );\n\n    // Pick the first defined of two or three arguments.\n    function defaults(a, b, c) {\n        if (a != null) {\n            return a;\n        }\n        if (b != null) {\n            return b;\n        }\n        return c;\n    }\n\n    function currentDateArray(config) {\n        // hooks is actually the exported moment object\n        var nowValue = new Date(hooks.now());\n        if (config._useUTC) {\n            return [\n                nowValue.getUTCFullYear(),\n                nowValue.getUTCMonth(),\n                nowValue.getUTCDate(),\n            ];\n        }\n        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n    }\n\n    // convert an array to a date.\n    // the array should mirror the parameters below\n    // note: all values past the year are optional and will default to the lowest possible value.\n    // [year, month, day , hour, minute, second, millisecond]\n    function configFromArray(config) {\n        var i,\n            date,\n            input = [],\n            currentDate,\n            expectedWeekday,\n            yearToUse;\n\n        if (config._d) {\n            return;\n        }\n\n        currentDate = currentDateArray(config);\n\n        //compute day of the year from weeks and weekdays\n        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n            dayOfYearFromWeekInfo(config);\n        }\n\n        //if the day of the year is set, figure out what it is\n        if (config._dayOfYear != null) {\n            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n\n            if (\n                config._dayOfYear > daysInYear(yearToUse) ||\n                config._dayOfYear === 0\n            ) {\n                getParsingFlags(config)._overflowDayOfYear = true;\n            }\n\n            date = createUTCDate(yearToUse, 0, config._dayOfYear);\n            config._a[MONTH] = date.getUTCMonth();\n            config._a[DATE] = date.getUTCDate();\n        }\n\n        // Default to current date.\n        // * if no year, month, day of month are given, default to today\n        // * if day of month is given, default month and year\n        // * if month is given, default only year\n        // * if year is given, don't default anything\n        for (i = 0; i < 3 && config._a[i] == null; ++i) {\n            config._a[i] = input[i] = currentDate[i];\n        }\n\n        // Zero out whatever was not defaulted, including time\n        for (; i < 7; i++) {\n            config._a[i] = input[i] =\n                config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i];\n        }\n\n        // Check for 24:00:00.000\n        if (\n            config._a[HOUR] === 24 &&\n            config._a[MINUTE] === 0 &&\n            config._a[SECOND] === 0 &&\n            config._a[MILLISECOND] === 0\n        ) {\n            config._nextDay = true;\n            config._a[HOUR] = 0;\n        }\n\n        config._d = (config._useUTC ? createUTCDate : createDate).apply(\n            null,\n            input\n        );\n        expectedWeekday = config._useUTC\n            ? config._d.getUTCDay()\n            : config._d.getDay();\n\n        // Apply timezone offset from input. The actual utcOffset can be changed\n        // with parseZone.\n        if (config._tzm != null) {\n            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n        }\n\n        if (config._nextDay) {\n            config._a[HOUR] = 24;\n        }\n\n        // check for mismatching day of week\n        if (\n            config._w &&\n            typeof config._w.d !== 'undefined' &&\n            config._w.d !== expectedWeekday\n        ) {\n            getParsingFlags(config).weekdayMismatch = true;\n        }\n    }\n\n    function dayOfYearFromWeekInfo(config) {\n        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;\n\n        w = config._w;\n        if (w.GG != null || w.W != null || w.E != null) {\n            dow = 1;\n            doy = 4;\n\n            // TODO: We need to take the current isoWeekYear, but that depends on\n            // how we interpret now (local, utc, fixed offset). So create\n            // a now version of current config (take local/utc/offset flags, and\n            // create now).\n            weekYear = defaults(\n                w.GG,\n                config._a[YEAR],\n                weekOfYear(createLocal(), 1, 4).year\n            );\n            week = defaults(w.W, 1);\n            weekday = defaults(w.E, 1);\n            if (weekday < 1 || weekday > 7) {\n                weekdayOverflow = true;\n            }\n        } else {\n            dow = config._locale._week.dow;\n            doy = config._locale._week.doy;\n\n            curWeek = weekOfYear(createLocal(), dow, doy);\n\n            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n            // Default to current week.\n            week = defaults(w.w, curWeek.week);\n\n            if (w.d != null) {\n                // weekday -- low day numbers are considered next week\n                weekday = w.d;\n                if (weekday < 0 || weekday > 6) {\n                    weekdayOverflow = true;\n                }\n            } else if (w.e != null) {\n                // local weekday -- counting starts from beginning of week\n                weekday = w.e + dow;\n                if (w.e < 0 || w.e > 6) {\n                    weekdayOverflow = true;\n                }\n            } else {\n                // default to beginning of week\n                weekday = dow;\n            }\n        }\n        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n            getParsingFlags(config)._overflowWeeks = true;\n        } else if (weekdayOverflow != null) {\n            getParsingFlags(config)._overflowWeekday = true;\n        } else {\n            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n            config._a[YEAR] = temp.year;\n            config._dayOfYear = temp.dayOfYear;\n        }\n    }\n\n    // constant that refers to the ISO standard\n    hooks.ISO_8601 = function () {};\n\n    // constant that refers to the RFC 2822 form\n    hooks.RFC_2822 = function () {};\n\n    // date from string and format string\n    function configFromStringAndFormat(config) {\n        // TODO: Move this to another part of the creation flow to prevent circular deps\n        if (config._f === hooks.ISO_8601) {\n            configFromISO(config);\n            return;\n        }\n        if (config._f === hooks.RFC_2822) {\n            configFromRFC2822(config);\n            return;\n        }\n        config._a = [];\n        getParsingFlags(config).empty = true;\n\n        // This array is used to make a Date, either with `new Date` or `Date.UTC`\n        var string = '' + config._i,\n            i,\n            parsedInput,\n            tokens,\n            token,\n            skipped,\n            stringLength = string.length,\n            totalParsedInputLength = 0,\n            era,\n            tokenLen;\n\n        tokens =\n            expandFormat(config._f, config._locale).match(formattingTokens) || [];\n        tokenLen = tokens.length;\n        for (i = 0; i < tokenLen; i++) {\n            token = tokens[i];\n            parsedInput = (string.match(getParseRegexForToken(token, config)) ||\n                [])[0];\n            if (parsedInput) {\n                skipped = string.substr(0, string.indexOf(parsedInput));\n                if (skipped.length > 0) {\n                    getParsingFlags(config).unusedInput.push(skipped);\n                }\n                string = string.slice(\n                    string.indexOf(parsedInput) + parsedInput.length\n                );\n                totalParsedInputLength += parsedInput.length;\n            }\n            // don't parse if it's not a known token\n            if (formatTokenFunctions[token]) {\n                if (parsedInput) {\n                    getParsingFlags(config).empty = false;\n                } else {\n                    getParsingFlags(config).unusedTokens.push(token);\n                }\n                addTimeToArrayFromToken(token, parsedInput, config);\n            } else if (config._strict && !parsedInput) {\n                getParsingFlags(config).unusedTokens.push(token);\n            }\n        }\n\n        // add remaining unparsed input length to the string\n        getParsingFlags(config).charsLeftOver =\n            stringLength - totalParsedInputLength;\n        if (string.length > 0) {\n            getParsingFlags(config).unusedInput.push(string);\n        }\n\n        // clear _12h flag if hour is <= 12\n        if (\n            config._a[HOUR] <= 12 &&\n            getParsingFlags(config).bigHour === true &&\n            config._a[HOUR] > 0\n        ) {\n            getParsingFlags(config).bigHour = undefined;\n        }\n\n        getParsingFlags(config).parsedDateParts = config._a.slice(0);\n        getParsingFlags(config).meridiem = config._meridiem;\n        // handle meridiem\n        config._a[HOUR] = meridiemFixWrap(\n            config._locale,\n            config._a[HOUR],\n            config._meridiem\n        );\n\n        // handle era\n        era = getParsingFlags(config).era;\n        if (era !== null) {\n            config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);\n        }\n\n        configFromArray(config);\n        checkOverflow(config);\n    }\n\n    function meridiemFixWrap(locale, hour, meridiem) {\n        var isPm;\n\n        if (meridiem == null) {\n            // nothing to do\n            return hour;\n        }\n        if (locale.meridiemHour != null) {\n            return locale.meridiemHour(hour, meridiem);\n        } else if (locale.isPM != null) {\n            // Fallback\n            isPm = locale.isPM(meridiem);\n            if (isPm && hour < 12) {\n                hour += 12;\n            }\n            if (!isPm && hour === 12) {\n                hour = 0;\n            }\n            return hour;\n        } else {\n            // this is not supposed to happen\n            return hour;\n        }\n    }\n\n    // date from string and array of format strings\n    function configFromStringAndArray(config) {\n        var tempConfig,\n            bestMoment,\n            scoreToBeat,\n            i,\n            currentScore,\n            validFormatFound,\n            bestFormatIsValid = false,\n            configfLen = config._f.length;\n\n        if (configfLen === 0) {\n            getParsingFlags(config).invalidFormat = true;\n            config._d = new Date(NaN);\n            return;\n        }\n\n        for (i = 0; i < configfLen; i++) {\n            currentScore = 0;\n            validFormatFound = false;\n            tempConfig = copyConfig({}, config);\n            if (config._useUTC != null) {\n                tempConfig._useUTC = config._useUTC;\n            }\n            tempConfig._f = config._f[i];\n            configFromStringAndFormat(tempConfig);\n\n            if (isValid(tempConfig)) {\n                validFormatFound = true;\n            }\n\n            // if there is any input that was not parsed add a penalty for that format\n            currentScore += getParsingFlags(tempConfig).charsLeftOver;\n\n            //or tokens\n            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;\n\n            getParsingFlags(tempConfig).score = currentScore;\n\n            if (!bestFormatIsValid) {\n                if (\n                    scoreToBeat == null ||\n                    currentScore < scoreToBeat ||\n                    validFormatFound\n                ) {\n                    scoreToBeat = currentScore;\n                    bestMoment = tempConfig;\n                    if (validFormatFound) {\n                        bestFormatIsValid = true;\n                    }\n                }\n            } else {\n                if (currentScore < scoreToBeat) {\n                    scoreToBeat = currentScore;\n                    bestMoment = tempConfig;\n                }\n            }\n        }\n\n        extend(config, bestMoment || tempConfig);\n    }\n\n    function configFromObject(config) {\n        if (config._d) {\n            return;\n        }\n\n        var i = normalizeObjectUnits(config._i),\n            dayOrDate = i.day === undefined ? i.date : i.day;\n        config._a = map(\n            [i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],\n            function (obj) {\n                return obj && parseInt(obj, 10);\n            }\n        );\n\n        configFromArray(config);\n    }\n\n    function createFromConfig(config) {\n        var res = new Moment(checkOverflow(prepareConfig(config)));\n        if (res._nextDay) {\n            // Adding is smart enough around DST\n            res.add(1, 'd');\n            res._nextDay = undefined;\n        }\n\n        return res;\n    }\n\n    function prepareConfig(config) {\n        var input = config._i,\n            format = config._f;\n\n        config._locale = config._locale || getLocale(config._l);\n\n        if (input === null || (format === undefined && input === '')) {\n            return createInvalid({ nullInput: true });\n        }\n\n        if (typeof input === 'string') {\n            config._i = input = config._locale.preparse(input);\n        }\n\n        if (isMoment(input)) {\n            return new Moment(checkOverflow(input));\n        } else if (isDate(input)) {\n            config._d = input;\n        } else if (isArray(format)) {\n            configFromStringAndArray(config);\n        } else if (format) {\n            configFromStringAndFormat(config);\n        } else {\n            configFromInput(config);\n        }\n\n        if (!isValid(config)) {\n            config._d = null;\n        }\n\n        return config;\n    }\n\n    function configFromInput(config) {\n        var input = config._i;\n        if (isUndefined(input)) {\n            config._d = new Date(hooks.now());\n        } else if (isDate(input)) {\n            config._d = new Date(input.valueOf());\n        } else if (typeof input === 'string') {\n            configFromString(config);\n        } else if (isArray(input)) {\n            config._a = map(input.slice(0), function (obj) {\n                return parseInt(obj, 10);\n            });\n            configFromArray(config);\n        } else if (isObject(input)) {\n            configFromObject(config);\n        } else if (isNumber(input)) {\n            // from milliseconds\n            config._d = new Date(input);\n        } else {\n            hooks.createFromInputFallback(config);\n        }\n    }\n\n    function createLocalOrUTC(input, format, locale, strict, isUTC) {\n        var c = {};\n\n        if (format === true || format === false) {\n            strict = format;\n            format = undefined;\n        }\n\n        if (locale === true || locale === false) {\n            strict = locale;\n            locale = undefined;\n        }\n\n        if (\n            (isObject(input) && isObjectEmpty(input)) ||\n            (isArray(input) && input.length === 0)\n        ) {\n            input = undefined;\n        }\n        // object construction must be done this way.\n        // https://github.com/moment/moment/issues/1423\n        c._isAMomentObject = true;\n        c._useUTC = c._isUTC = isUTC;\n        c._l = locale;\n        c._i = input;\n        c._f = format;\n        c._strict = strict;\n\n        return createFromConfig(c);\n    }\n\n    function createLocal(input, format, locale, strict) {\n        return createLocalOrUTC(input, format, locale, strict, false);\n    }\n\n    var prototypeMin = deprecate(\n            'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',\n            function () {\n                var other = createLocal.apply(null, arguments);\n                if (this.isValid() && other.isValid()) {\n                    return other < this ? this : other;\n                } else {\n                    return createInvalid();\n                }\n            }\n        ),\n        prototypeMax = deprecate(\n            'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',\n            function () {\n                var other = createLocal.apply(null, arguments);\n                if (this.isValid() && other.isValid()) {\n                    return other > this ? this : other;\n                } else {\n                    return createInvalid();\n                }\n            }\n        );\n\n    // Pick a moment m from moments so that m[fn](other) is true for all\n    // other. This relies on the function fn to be transitive.\n    //\n    // moments should either be an array of moment objects or an array, whose\n    // first element is an array of moment objects.\n    function pickBy(fn, moments) {\n        var res, i;\n        if (moments.length === 1 && isArray(moments[0])) {\n            moments = moments[0];\n        }\n        if (!moments.length) {\n            return createLocal();\n        }\n        res = moments[0];\n        for (i = 1; i < moments.length; ++i) {\n            if (!moments[i].isValid() || moments[i][fn](res)) {\n                res = moments[i];\n            }\n        }\n        return res;\n    }\n\n    // TODO: Use [].sort instead?\n    function min() {\n        var args = [].slice.call(arguments, 0);\n\n        return pickBy('isBefore', args);\n    }\n\n    function max() {\n        var args = [].slice.call(arguments, 0);\n\n        return pickBy('isAfter', args);\n    }\n\n    var now = function () {\n        return Date.now ? Date.now() : +new Date();\n    };\n\n    var ordering = [\n        'year',\n        'quarter',\n        'month',\n        'week',\n        'day',\n        'hour',\n        'minute',\n        'second',\n        'millisecond',\n    ];\n\n    function isDurationValid(m) {\n        var key,\n            unitHasDecimal = false,\n            i,\n            orderLen = ordering.length;\n        for (key in m) {\n            if (\n                hasOwnProp(m, key) &&\n                !(\n                    indexOf.call(ordering, key) !== -1 &&\n                    (m[key] == null || !isNaN(m[key]))\n                )\n            ) {\n                return false;\n            }\n        }\n\n        for (i = 0; i < orderLen; ++i) {\n            if (m[ordering[i]]) {\n                if (unitHasDecimal) {\n                    return false; // only allow non-integers for smallest unit\n                }\n                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {\n                    unitHasDecimal = true;\n                }\n            }\n        }\n\n        return true;\n    }\n\n    function isValid$1() {\n        return this._isValid;\n    }\n\n    function createInvalid$1() {\n        return createDuration(NaN);\n    }\n\n    function Duration(duration) {\n        var normalizedInput = normalizeObjectUnits(duration),\n            years = normalizedInput.year || 0,\n            quarters = normalizedInput.quarter || 0,\n            months = normalizedInput.month || 0,\n            weeks = normalizedInput.week || normalizedInput.isoWeek || 0,\n            days = normalizedInput.day || 0,\n            hours = normalizedInput.hour || 0,\n            minutes = normalizedInput.minute || 0,\n            seconds = normalizedInput.second || 0,\n            milliseconds = normalizedInput.millisecond || 0;\n\n        this._isValid = isDurationValid(normalizedInput);\n\n        // representation for dateAddRemove\n        this._milliseconds =\n            +milliseconds +\n            seconds * 1e3 + // 1000\n            minutes * 6e4 + // 1000 * 60\n            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n        // Because of dateAddRemove treats 24 hours as different from a\n        // day when working around DST, we need to store them separately\n        this._days = +days + weeks * 7;\n        // It is impossible to translate months into days without knowing\n        // which months you are are talking about, so we have to store\n        // it separately.\n        this._months = +months + quarters * 3 + years * 12;\n\n        this._data = {};\n\n        this._locale = getLocale();\n\n        this._bubble();\n    }\n\n    function isDuration(obj) {\n        return obj instanceof Duration;\n    }\n\n    function absRound(number) {\n        if (number < 0) {\n            return Math.round(-1 * number) * -1;\n        } else {\n            return Math.round(number);\n        }\n    }\n\n    // compare two arrays, return the number of differences\n    function compareArrays(array1, array2, dontConvert) {\n        var len = Math.min(array1.length, array2.length),\n            lengthDiff = Math.abs(array1.length - array2.length),\n            diffs = 0,\n            i;\n        for (i = 0; i < len; i++) {\n            if (\n                (dontConvert && array1[i] !== array2[i]) ||\n                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))\n            ) {\n                diffs++;\n            }\n        }\n        return diffs + lengthDiff;\n    }\n\n    // FORMATTING\n\n    function offset(token, separator) {\n        addFormatToken(token, 0, 0, function () {\n            var offset = this.utcOffset(),\n                sign = '+';\n            if (offset < 0) {\n                offset = -offset;\n                sign = '-';\n            }\n            return (\n                sign +\n                zeroFill(~~(offset / 60), 2) +\n                separator +\n                zeroFill(~~offset % 60, 2)\n            );\n        });\n    }\n\n    offset('Z', ':');\n    offset('ZZ', '');\n\n    // PARSING\n\n    addRegexToken('Z', matchShortOffset);\n    addRegexToken('ZZ', matchShortOffset);\n    addParseToken(['Z', 'ZZ'], function (input, array, config) {\n        config._useUTC = true;\n        config._tzm = offsetFromString(matchShortOffset, input);\n    });\n\n    // HELPERS\n\n    // timezone chunker\n    // '+10:00' > ['10',  '00']\n    // '-1530'  > ['-15', '30']\n    var chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\n    function offsetFromString(matcher, string) {\n        var matches = (string || '').match(matcher),\n            chunk,\n            parts,\n            minutes;\n\n        if (matches === null) {\n            return null;\n        }\n\n        chunk = matches[matches.length - 1] || [];\n        parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];\n        minutes = +(parts[1] * 60) + toInt(parts[2]);\n\n        return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;\n    }\n\n    // Return a moment from input, that is local/utc/zone equivalent to model.\n    function cloneWithOffset(input, model) {\n        var res, diff;\n        if (model._isUTC) {\n            res = model.clone();\n            diff =\n                (isMoment(input) || isDate(input)\n                    ? input.valueOf()\n                    : createLocal(input).valueOf()) - res.valueOf();\n            // Use low-level api, because this fn is low-level api.\n            res._d.setTime(res._d.valueOf() + diff);\n            hooks.updateOffset(res, false);\n            return res;\n        } else {\n            return createLocal(input).local();\n        }\n    }\n\n    function getDateOffset(m) {\n        // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n        // https://github.com/moment/moment/pull/1871\n        return -Math.round(m._d.getTimezoneOffset());\n    }\n\n    // HOOKS\n\n    // This function will be called whenever a moment is mutated.\n    // It is intended to keep the offset in sync with the timezone.\n    hooks.updateOffset = function () {};\n\n    // MOMENTS\n\n    // keepLocalTime = true means only change the timezone, without\n    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n    // +0200, so we adjust the time as needed, to be valid.\n    //\n    // Keeping the time actually adds/subtracts (one hour)\n    // from the actual represented time. That is why we call updateOffset\n    // a second time. In case it wants us to change the offset again\n    // _changeInProgress == true case, then we have to adjust, because\n    // there is no such time in the given timezone.\n    function getSetOffset(input, keepLocalTime, keepMinutes) {\n        var offset = this._offset || 0,\n            localAdjust;\n        if (!this.isValid()) {\n            return input != null ? this : NaN;\n        }\n        if (input != null) {\n            if (typeof input === 'string') {\n                input = offsetFromString(matchShortOffset, input);\n                if (input === null) {\n                    return this;\n                }\n            } else if (Math.abs(input) < 16 && !keepMinutes) {\n                input = input * 60;\n            }\n            if (!this._isUTC && keepLocalTime) {\n                localAdjust = getDateOffset(this);\n            }\n            this._offset = input;\n            this._isUTC = true;\n            if (localAdjust != null) {\n                this.add(localAdjust, 'm');\n            }\n            if (offset !== input) {\n                if (!keepLocalTime || this._changeInProgress) {\n                    addSubtract(\n                        this,\n                        createDuration(input - offset, 'm'),\n                        1,\n                        false\n                    );\n                } else if (!this._changeInProgress) {\n                    this._changeInProgress = true;\n                    hooks.updateOffset(this, true);\n                    this._changeInProgress = null;\n                }\n            }\n            return this;\n        } else {\n            return this._isUTC ? offset : getDateOffset(this);\n        }\n    }\n\n    function getSetZone(input, keepLocalTime) {\n        if (input != null) {\n            if (typeof input !== 'string') {\n                input = -input;\n            }\n\n            this.utcOffset(input, keepLocalTime);\n\n            return this;\n        } else {\n            return -this.utcOffset();\n        }\n    }\n\n    function setOffsetToUTC(keepLocalTime) {\n        return this.utcOffset(0, keepLocalTime);\n    }\n\n    function setOffsetToLocal(keepLocalTime) {\n        if (this._isUTC) {\n            this.utcOffset(0, keepLocalTime);\n            this._isUTC = false;\n\n            if (keepLocalTime) {\n                this.subtract(getDateOffset(this), 'm');\n            }\n        }\n        return this;\n    }\n\n    function setOffsetToParsedOffset() {\n        if (this._tzm != null) {\n            this.utcOffset(this._tzm, false, true);\n        } else if (typeof this._i === 'string') {\n            var tZone = offsetFromString(matchOffset, this._i);\n            if (tZone != null) {\n                this.utcOffset(tZone);\n            } else {\n                this.utcOffset(0, true);\n            }\n        }\n        return this;\n    }\n\n    function hasAlignedHourOffset(input) {\n        if (!this.isValid()) {\n            return false;\n        }\n        input = input ? createLocal(input).utcOffset() : 0;\n\n        return (this.utcOffset() - input) % 60 === 0;\n    }\n\n    function isDaylightSavingTime() {\n        return (\n            this.utcOffset() > this.clone().month(0).utcOffset() ||\n            this.utcOffset() > this.clone().month(5).utcOffset()\n        );\n    }\n\n    function isDaylightSavingTimeShifted() {\n        if (!isUndefined(this._isDSTShifted)) {\n            return this._isDSTShifted;\n        }\n\n        var c = {},\n            other;\n\n        copyConfig(c, this);\n        c = prepareConfig(c);\n\n        if (c._a) {\n            other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n            this._isDSTShifted =\n                this.isValid() && compareArrays(c._a, other.toArray()) > 0;\n        } else {\n            this._isDSTShifted = false;\n        }\n\n        return this._isDSTShifted;\n    }\n\n    function isLocal() {\n        return this.isValid() ? !this._isUTC : false;\n    }\n\n    function isUtcOffset() {\n        return this.isValid() ? this._isUTC : false;\n    }\n\n    function isUtc() {\n        return this.isValid() ? this._isUTC && this._offset === 0 : false;\n    }\n\n    // ASP.NET json date format regex\n    var aspNetRegex = /^(-|\\+)?(?:(\\d*)[. ])?(\\d+):(\\d+)(?::(\\d+)(\\.\\d*)?)?$/,\n        // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n        // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n        // and further modified to allow for strings containing both week and day\n        isoRegex =\n            /^(-|\\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;\n\n    function createDuration(input, key) {\n        var duration = input,\n            // matching against regexp is expensive, do it on demand\n            match = null,\n            sign,\n            ret,\n            diffRes;\n\n        if (isDuration(input)) {\n            duration = {\n                ms: input._milliseconds,\n                d: input._days,\n                M: input._months,\n            };\n        } else if (isNumber(input) || !isNaN(+input)) {\n            duration = {};\n            if (key) {\n                duration[key] = +input;\n            } else {\n                duration.milliseconds = +input;\n            }\n        } else if ((match = aspNetRegex.exec(input))) {\n            sign = match[1] === '-' ? -1 : 1;\n            duration = {\n                y: 0,\n                d: toInt(match[DATE]) * sign,\n                h: toInt(match[HOUR]) * sign,\n                m: toInt(match[MINUTE]) * sign,\n                s: toInt(match[SECOND]) * sign,\n                ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match\n            };\n        } else if ((match = isoRegex.exec(input))) {\n            sign = match[1] === '-' ? -1 : 1;\n            duration = {\n                y: parseIso(match[2], sign),\n                M: parseIso(match[3], sign),\n                w: parseIso(match[4], sign),\n                d: parseIso(match[5], sign),\n                h: parseIso(match[6], sign),\n                m: parseIso(match[7], sign),\n                s: parseIso(match[8], sign),\n            };\n        } else if (duration == null) {\n            // checks for null or undefined\n            duration = {};\n        } else if (\n            typeof duration === 'object' &&\n            ('from' in duration || 'to' in duration)\n        ) {\n            diffRes = momentsDifference(\n                createLocal(duration.from),\n                createLocal(duration.to)\n            );\n\n            duration = {};\n            duration.ms = diffRes.milliseconds;\n            duration.M = diffRes.months;\n        }\n\n        ret = new Duration(duration);\n\n        if (isDuration(input) && hasOwnProp(input, '_locale')) {\n            ret._locale = input._locale;\n        }\n\n        if (isDuration(input) && hasOwnProp(input, '_isValid')) {\n            ret._isValid = input._isValid;\n        }\n\n        return ret;\n    }\n\n    createDuration.fn = Duration.prototype;\n    createDuration.invalid = createInvalid$1;\n\n    function parseIso(inp, sign) {\n        // We'd normally use ~~inp for this, but unfortunately it also\n        // converts floats to ints.\n        // inp may be undefined, so careful calling replace on it.\n        var res = inp && parseFloat(inp.replace(',', '.'));\n        // apply sign while we're at it\n        return (isNaN(res) ? 0 : res) * sign;\n    }\n\n    function positiveMomentsDifference(base, other) {\n        var res = {};\n\n        res.months =\n            other.month() - base.month() + (other.year() - base.year()) * 12;\n        if (base.clone().add(res.months, 'M').isAfter(other)) {\n            --res.months;\n        }\n\n        res.milliseconds = +other - +base.clone().add(res.months, 'M');\n\n        return res;\n    }\n\n    function momentsDifference(base, other) {\n        var res;\n        if (!(base.isValid() && other.isValid())) {\n            return { milliseconds: 0, months: 0 };\n        }\n\n        other = cloneWithOffset(other, base);\n        if (base.isBefore(other)) {\n            res = positiveMomentsDifference(base, other);\n        } else {\n            res = positiveMomentsDifference(other, base);\n            res.milliseconds = -res.milliseconds;\n            res.months = -res.months;\n        }\n\n        return res;\n    }\n\n    // TODO: remove 'name' arg after deprecation is removed\n    function createAdder(direction, name) {\n        return function (val, period) {\n            var dur, tmp;\n            //invert the arguments, but complain about it\n            if (period !== null && !isNaN(+period)) {\n                deprecateSimple(\n                    name,\n                    'moment().' +\n                        name +\n                        '(period, number) is deprecated. Please use moment().' +\n                        name +\n                        '(number, period). ' +\n                        'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'\n                );\n                tmp = val;\n                val = period;\n                period = tmp;\n            }\n\n            dur = createDuration(val, period);\n            addSubtract(this, dur, direction);\n            return this;\n        };\n    }\n\n    function addSubtract(mom, duration, isAdding, updateOffset) {\n        var milliseconds = duration._milliseconds,\n            days = absRound(duration._days),\n            months = absRound(duration._months);\n\n        if (!mom.isValid()) {\n            // No op\n            return;\n        }\n\n        updateOffset = updateOffset == null ? true : updateOffset;\n\n        if (months) {\n            setMonth(mom, get(mom, 'Month') + months * isAdding);\n        }\n        if (days) {\n            set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);\n        }\n        if (milliseconds) {\n            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);\n        }\n        if (updateOffset) {\n            hooks.updateOffset(mom, days || months);\n        }\n    }\n\n    var add = createAdder(1, 'add'),\n        subtract = createAdder(-1, 'subtract');\n\n    function isString(input) {\n        return typeof input === 'string' || input instanceof String;\n    }\n\n    // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined\n    function isMomentInput(input) {\n        return (\n            isMoment(input) ||\n            isDate(input) ||\n            isString(input) ||\n            isNumber(input) ||\n            isNumberOrStringArray(input) ||\n            isMomentInputObject(input) ||\n            input === null ||\n            input === undefined\n        );\n    }\n\n    function isMomentInputObject(input) {\n        var objectTest = isObject(input) && !isObjectEmpty(input),\n            propertyTest = false,\n            properties = [\n                'years',\n                'year',\n                'y',\n                'months',\n                'month',\n                'M',\n                'days',\n                'day',\n                'd',\n                'dates',\n                'date',\n                'D',\n                'hours',\n                'hour',\n                'h',\n                'minutes',\n                'minute',\n                'm',\n                'seconds',\n                'second',\n                's',\n                'milliseconds',\n                'millisecond',\n                'ms',\n            ],\n            i,\n            property,\n            propertyLen = properties.length;\n\n        for (i = 0; i < propertyLen; i += 1) {\n            property = properties[i];\n            propertyTest = propertyTest || hasOwnProp(input, property);\n        }\n\n        return objectTest && propertyTest;\n    }\n\n    function isNumberOrStringArray(input) {\n        var arrayTest = isArray(input),\n            dataTypeTest = false;\n        if (arrayTest) {\n            dataTypeTest =\n                input.filter(function (item) {\n                    return !isNumber(item) && isString(input);\n                }).length === 0;\n        }\n        return arrayTest && dataTypeTest;\n    }\n\n    function isCalendarSpec(input) {\n        var objectTest = isObject(input) && !isObjectEmpty(input),\n            propertyTest = false,\n            properties = [\n                'sameDay',\n                'nextDay',\n                'lastDay',\n                'nextWeek',\n                'lastWeek',\n                'sameElse',\n            ],\n            i,\n            property;\n\n        for (i = 0; i < properties.length; i += 1) {\n            property = properties[i];\n            propertyTest = propertyTest || hasOwnProp(input, property);\n        }\n\n        return objectTest && propertyTest;\n    }\n\n    function getCalendarFormat(myMoment, now) {\n        var diff = myMoment.diff(now, 'days', true);\n        return diff < -6\n            ? 'sameElse'\n            : diff < -1\n            ? 'lastWeek'\n            : diff < 0\n            ? 'lastDay'\n            : diff < 1\n            ? 'sameDay'\n            : diff < 2\n            ? 'nextDay'\n            : diff < 7\n            ? 'nextWeek'\n            : 'sameElse';\n    }\n\n    function calendar$1(time, formats) {\n        // Support for single parameter, formats only overload to the calendar function\n        if (arguments.length === 1) {\n            if (!arguments[0]) {\n                time = undefined;\n                formats = undefined;\n            } else if (isMomentInput(arguments[0])) {\n                time = arguments[0];\n                formats = undefined;\n            } else if (isCalendarSpec(arguments[0])) {\n                formats = arguments[0];\n                time = undefined;\n            }\n        }\n        // We want to compare the start of today, vs this.\n        // Getting start-of-today depends on whether we're local/utc/offset or not.\n        var now = time || createLocal(),\n            sod = cloneWithOffset(now, this).startOf('day'),\n            format = hooks.calendarFormat(this, sod) || 'sameElse',\n            output =\n                formats &&\n                (isFunction(formats[format])\n                    ? formats[format].call(this, now)\n                    : formats[format]);\n\n        return this.format(\n            output || this.localeData().calendar(format, this, createLocal(now))\n        );\n    }\n\n    function clone() {\n        return new Moment(this);\n    }\n\n    function isAfter(input, units) {\n        var localInput = isMoment(input) ? input : createLocal(input);\n        if (!(this.isValid() && localInput.isValid())) {\n            return false;\n        }\n        units = normalizeUnits(units) || 'millisecond';\n        if (units === 'millisecond') {\n            return this.valueOf() > localInput.valueOf();\n        } else {\n            return localInput.valueOf() < this.clone().startOf(units).valueOf();\n        }\n    }\n\n    function isBefore(input, units) {\n        var localInput = isMoment(input) ? input : createLocal(input);\n        if (!(this.isValid() && localInput.isValid())) {\n            return false;\n        }\n        units = normalizeUnits(units) || 'millisecond';\n        if (units === 'millisecond') {\n            return this.valueOf() < localInput.valueOf();\n        } else {\n            return this.clone().endOf(units).valueOf() < localInput.valueOf();\n        }\n    }\n\n    function isBetween(from, to, units, inclusivity) {\n        var localFrom = isMoment(from) ? from : createLocal(from),\n            localTo = isMoment(to) ? to : createLocal(to);\n        if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {\n            return false;\n        }\n        inclusivity = inclusivity || '()';\n        return (\n            (inclusivity[0] === '('\n                ? this.isAfter(localFrom, units)\n                : !this.isBefore(localFrom, units)) &&\n            (inclusivity[1] === ')'\n                ? this.isBefore(localTo, units)\n                : !this.isAfter(localTo, units))\n        );\n    }\n\n    function isSame(input, units) {\n        var localInput = isMoment(input) ? input : createLocal(input),\n            inputMs;\n        if (!(this.isValid() && localInput.isValid())) {\n            return false;\n        }\n        units = normalizeUnits(units) || 'millisecond';\n        if (units === 'millisecond') {\n            return this.valueOf() === localInput.valueOf();\n        } else {\n            inputMs = localInput.valueOf();\n            return (\n                this.clone().startOf(units).valueOf() <= inputMs &&\n                inputMs <= this.clone().endOf(units).valueOf()\n            );\n        }\n    }\n\n    function isSameOrAfter(input, units) {\n        return this.isSame(input, units) || this.isAfter(input, units);\n    }\n\n    function isSameOrBefore(input, units) {\n        return this.isSame(input, units) || this.isBefore(input, units);\n    }\n\n    function diff(input, units, asFloat) {\n        var that, zoneDelta, output;\n\n        if (!this.isValid()) {\n            return NaN;\n        }\n\n        that = cloneWithOffset(input, this);\n\n        if (!that.isValid()) {\n            return NaN;\n        }\n\n        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;\n\n        units = normalizeUnits(units);\n\n        switch (units) {\n            case 'year':\n                output = monthDiff(this, that) / 12;\n                break;\n            case 'month':\n                output = monthDiff(this, that);\n                break;\n            case 'quarter':\n                output = monthDiff(this, that) / 3;\n                break;\n            case 'second':\n                output = (this - that) / 1e3;\n                break; // 1000\n            case 'minute':\n                output = (this - that) / 6e4;\n                break; // 1000 * 60\n            case 'hour':\n                output = (this - that) / 36e5;\n                break; // 1000 * 60 * 60\n            case 'day':\n                output = (this - that - zoneDelta) / 864e5;\n                break; // 1000 * 60 * 60 * 24, negate dst\n            case 'week':\n                output = (this - that - zoneDelta) / 6048e5;\n                break; // 1000 * 60 * 60 * 24 * 7, negate dst\n            default:\n                output = this - that;\n        }\n\n        return asFloat ? output : absFloor(output);\n    }\n\n    function monthDiff(a, b) {\n        if (a.date() < b.date()) {\n            // end-of-month calculations work correct when the start month has more\n            // days than the end month.\n            return -monthDiff(b, a);\n        }\n        // difference in months\n        var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),\n            // b is in (anchor - 1 month, anchor + 1 month)\n            anchor = a.clone().add(wholeMonthDiff, 'months'),\n            anchor2,\n            adjust;\n\n        if (b - anchor < 0) {\n            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');\n            // linear across the month\n            adjust = (b - anchor) / (anchor - anchor2);\n        } else {\n            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');\n            // linear across the month\n            adjust = (b - anchor) / (anchor2 - anchor);\n        }\n\n        //check for negative zero, return zero if negative zero\n        return -(wholeMonthDiff + adjust) || 0;\n    }\n\n    hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\n    hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n\n    function toString() {\n        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n    }\n\n    function toISOString(keepOffset) {\n        if (!this.isValid()) {\n            return null;\n        }\n        var utc = keepOffset !== true,\n            m = utc ? this.clone().utc() : this;\n        if (m.year() < 0 || m.year() > 9999) {\n            return formatMoment(\n                m,\n                utc\n                    ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'\n                    : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'\n            );\n        }\n        if (isFunction(Date.prototype.toISOString)) {\n            // native implementation is ~50x faster, use it when we can\n            if (utc) {\n                return this.toDate().toISOString();\n            } else {\n                return new Date(this.valueOf() + this.utcOffset() * 60 * 1000)\n                    .toISOString()\n                    .replace('Z', formatMoment(m, 'Z'));\n            }\n        }\n        return formatMoment(\n            m,\n            utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'\n        );\n    }\n\n    /**\n     * Return a human readable representation of a moment that can\n     * also be evaluated to get a new moment which is the same\n     *\n     * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects\n     */\n    function inspect() {\n        if (!this.isValid()) {\n            return 'moment.invalid(/* ' + this._i + ' */)';\n        }\n        var func = 'moment',\n            zone = '',\n            prefix,\n            year,\n            datetime,\n            suffix;\n        if (!this.isLocal()) {\n            func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';\n            zone = 'Z';\n        }\n        prefix = '[' + func + '(\"]';\n        year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';\n        datetime = '-MM-DD[T]HH:mm:ss.SSS';\n        suffix = zone + '[\")]';\n\n        return this.format(prefix + year + datetime + suffix);\n    }\n\n    function format(inputString) {\n        if (!inputString) {\n            inputString = this.isUtc()\n                ? hooks.defaultFormatUtc\n                : hooks.defaultFormat;\n        }\n        var output = formatMoment(this, inputString);\n        return this.localeData().postformat(output);\n    }\n\n    function from(time, withoutSuffix) {\n        if (\n            this.isValid() &&\n            ((isMoment(time) && time.isValid()) || createLocal(time).isValid())\n        ) {\n            return createDuration({ to: this, from: time })\n                .locale(this.locale())\n                .humanize(!withoutSuffix);\n        } else {\n            return this.localeData().invalidDate();\n        }\n    }\n\n    function fromNow(withoutSuffix) {\n        return this.from(createLocal(), withoutSuffix);\n    }\n\n    function to(time, withoutSuffix) {\n        if (\n            this.isValid() &&\n            ((isMoment(time) && time.isValid()) || createLocal(time).isValid())\n        ) {\n            return createDuration({ from: this, to: time })\n                .locale(this.locale())\n                .humanize(!withoutSuffix);\n        } else {\n            return this.localeData().invalidDate();\n        }\n    }\n\n    function toNow(withoutSuffix) {\n        return this.to(createLocal(), withoutSuffix);\n    }\n\n    // If passed a locale key, it will set the locale for this\n    // instance.  Otherwise, it will return the locale configuration\n    // variables for this instance.\n    function locale(key) {\n        var newLocaleData;\n\n        if (key === undefined) {\n            return this._locale._abbr;\n        } else {\n            newLocaleData = getLocale(key);\n            if (newLocaleData != null) {\n                this._locale = newLocaleData;\n            }\n            return this;\n        }\n    }\n\n    var lang = deprecate(\n        'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',\n        function (key) {\n            if (key === undefined) {\n                return this.localeData();\n            } else {\n                return this.locale(key);\n            }\n        }\n    );\n\n    function localeData() {\n        return this._locale;\n    }\n\n    var MS_PER_SECOND = 1000,\n        MS_PER_MINUTE = 60 * MS_PER_SECOND,\n        MS_PER_HOUR = 60 * MS_PER_MINUTE,\n        MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;\n\n    // actual modulo - handles negative numbers (for dates before 1970):\n    function mod$1(dividend, divisor) {\n        return ((dividend % divisor) + divisor) % divisor;\n    }\n\n    function localStartOfDate(y, m, d) {\n        // the date constructor remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            // preserve leap years using a full 400 year cycle, then reset\n            return new Date(y + 400, m, d) - MS_PER_400_YEARS;\n        } else {\n            return new Date(y, m, d).valueOf();\n        }\n    }\n\n    function utcStartOfDate(y, m, d) {\n        // Date.UTC remaps years 0-99 to 1900-1999\n        if (y < 100 && y >= 0) {\n            // preserve leap years using a full 400 year cycle, then reset\n            return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;\n        } else {\n            return Date.UTC(y, m, d);\n        }\n    }\n\n    function startOf(units) {\n        var time, startOfDate;\n        units = normalizeUnits(units);\n        if (units === undefined || units === 'millisecond' || !this.isValid()) {\n            return this;\n        }\n\n        startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;\n\n        switch (units) {\n            case 'year':\n                time = startOfDate(this.year(), 0, 1);\n                break;\n            case 'quarter':\n                time = startOfDate(\n                    this.year(),\n                    this.month() - (this.month() % 3),\n                    1\n                );\n                break;\n            case 'month':\n                time = startOfDate(this.year(), this.month(), 1);\n                break;\n            case 'week':\n                time = startOfDate(\n                    this.year(),\n                    this.month(),\n                    this.date() - this.weekday()\n                );\n                break;\n            case 'isoWeek':\n                time = startOfDate(\n                    this.year(),\n                    this.month(),\n                    this.date() - (this.isoWeekday() - 1)\n                );\n                break;\n            case 'day':\n            case 'date':\n                time = startOfDate(this.year(), this.month(), this.date());\n                break;\n            case 'hour':\n                time = this._d.valueOf();\n                time -= mod$1(\n                    time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),\n                    MS_PER_HOUR\n                );\n                break;\n            case 'minute':\n                time = this._d.valueOf();\n                time -= mod$1(time, MS_PER_MINUTE);\n                break;\n            case 'second':\n                time = this._d.valueOf();\n                time -= mod$1(time, MS_PER_SECOND);\n                break;\n        }\n\n        this._d.setTime(time);\n        hooks.updateOffset(this, true);\n        return this;\n    }\n\n    function endOf(units) {\n        var time, startOfDate;\n        units = normalizeUnits(units);\n        if (units === undefined || units === 'millisecond' || !this.isValid()) {\n            return this;\n        }\n\n        startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;\n\n        switch (units) {\n            case 'year':\n                time = startOfDate(this.year() + 1, 0, 1) - 1;\n                break;\n            case 'quarter':\n                time =\n                    startOfDate(\n                        this.year(),\n                        this.month() - (this.month() % 3) + 3,\n                        1\n                    ) - 1;\n                break;\n            case 'month':\n                time = startOfDate(this.year(), this.month() + 1, 1) - 1;\n                break;\n            case 'week':\n                time =\n                    startOfDate(\n                        this.year(),\n                        this.month(),\n                        this.date() - this.weekday() + 7\n                    ) - 1;\n                break;\n            case 'isoWeek':\n                time =\n                    startOfDate(\n                        this.year(),\n                        this.month(),\n                        this.date() - (this.isoWeekday() - 1) + 7\n                    ) - 1;\n                break;\n            case 'day':\n            case 'date':\n                time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;\n                break;\n            case 'hour':\n                time = this._d.valueOf();\n                time +=\n                    MS_PER_HOUR -\n                    mod$1(\n                        time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),\n                        MS_PER_HOUR\n                    ) -\n                    1;\n                break;\n            case 'minute':\n                time = this._d.valueOf();\n                time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;\n                break;\n            case 'second':\n                time = this._d.valueOf();\n                time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;\n                break;\n        }\n\n        this._d.setTime(time);\n        hooks.updateOffset(this, true);\n        return this;\n    }\n\n    function valueOf() {\n        return this._d.valueOf() - (this._offset || 0) * 60000;\n    }\n\n    function unix() {\n        return Math.floor(this.valueOf() / 1000);\n    }\n\n    function toDate() {\n        return new Date(this.valueOf());\n    }\n\n    function toArray() {\n        var m = this;\n        return [\n            m.year(),\n            m.month(),\n            m.date(),\n            m.hour(),\n            m.minute(),\n            m.second(),\n            m.millisecond(),\n        ];\n    }\n\n    function toObject() {\n        var m = this;\n        return {\n            years: m.year(),\n            months: m.month(),\n            date: m.date(),\n            hours: m.hours(),\n            minutes: m.minutes(),\n            seconds: m.seconds(),\n            milliseconds: m.milliseconds(),\n        };\n    }\n\n    function toJSON() {\n        // new Date(NaN).toJSON() === null\n        return this.isValid() ? this.toISOString() : null;\n    }\n\n    function isValid$2() {\n        return isValid(this);\n    }\n\n    function parsingFlags() {\n        return extend({}, getParsingFlags(this));\n    }\n\n    function invalidAt() {\n        return getParsingFlags(this).overflow;\n    }\n\n    function creationData() {\n        return {\n            input: this._i,\n            format: this._f,\n            locale: this._locale,\n            isUTC: this._isUTC,\n            strict: this._strict,\n        };\n    }\n\n    addFormatToken('N', 0, 0, 'eraAbbr');\n    addFormatToken('NN', 0, 0, 'eraAbbr');\n    addFormatToken('NNN', 0, 0, 'eraAbbr');\n    addFormatToken('NNNN', 0, 0, 'eraName');\n    addFormatToken('NNNNN', 0, 0, 'eraNarrow');\n\n    addFormatToken('y', ['y', 1], 'yo', 'eraYear');\n    addFormatToken('y', ['yy', 2], 0, 'eraYear');\n    addFormatToken('y', ['yyy', 3], 0, 'eraYear');\n    addFormatToken('y', ['yyyy', 4], 0, 'eraYear');\n\n    addRegexToken('N', matchEraAbbr);\n    addRegexToken('NN', matchEraAbbr);\n    addRegexToken('NNN', matchEraAbbr);\n    addRegexToken('NNNN', matchEraName);\n    addRegexToken('NNNNN', matchEraNarrow);\n\n    addParseToken(\n        ['N', 'NN', 'NNN', 'NNNN', 'NNNNN'],\n        function (input, array, config, token) {\n            var era = config._locale.erasParse(input, token, config._strict);\n            if (era) {\n                getParsingFlags(config).era = era;\n            } else {\n                getParsingFlags(config).invalidEra = input;\n            }\n        }\n    );\n\n    addRegexToken('y', matchUnsigned);\n    addRegexToken('yy', matchUnsigned);\n    addRegexToken('yyy', matchUnsigned);\n    addRegexToken('yyyy', matchUnsigned);\n    addRegexToken('yo', matchEraYearOrdinal);\n\n    addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR);\n    addParseToken(['yo'], function (input, array, config, token) {\n        var match;\n        if (config._locale._eraYearOrdinalRegex) {\n            match = input.match(config._locale._eraYearOrdinalRegex);\n        }\n\n        if (config._locale.eraYearOrdinalParse) {\n            array[YEAR] = config._locale.eraYearOrdinalParse(input, match);\n        } else {\n            array[YEAR] = parseInt(input, 10);\n        }\n    });\n\n    function localeEras(m, format) {\n        var i,\n            l,\n            date,\n            eras = this._eras || getLocale('en')._eras;\n        for (i = 0, l = eras.length; i < l; ++i) {\n            switch (typeof eras[i].since) {\n                case 'string':\n                    // truncate time\n                    date = hooks(eras[i].since).startOf('day');\n                    eras[i].since = date.valueOf();\n                    break;\n            }\n\n            switch (typeof eras[i].until) {\n                case 'undefined':\n                    eras[i].until = +Infinity;\n                    break;\n                case 'string':\n                    // truncate time\n                    date = hooks(eras[i].until).startOf('day').valueOf();\n                    eras[i].until = date.valueOf();\n                    break;\n            }\n        }\n        return eras;\n    }\n\n    function localeErasParse(eraName, format, strict) {\n        var i,\n            l,\n            eras = this.eras(),\n            name,\n            abbr,\n            narrow;\n        eraName = eraName.toUpperCase();\n\n        for (i = 0, l = eras.length; i < l; ++i) {\n            name = eras[i].name.toUpperCase();\n            abbr = eras[i].abbr.toUpperCase();\n            narrow = eras[i].narrow.toUpperCase();\n\n            if (strict) {\n                switch (format) {\n                    case 'N':\n                    case 'NN':\n                    case 'NNN':\n                        if (abbr === eraName) {\n                            return eras[i];\n                        }\n                        break;\n\n                    case 'NNNN':\n                        if (name === eraName) {\n                            return eras[i];\n                        }\n                        break;\n\n                    case 'NNNNN':\n                        if (narrow === eraName) {\n                            return eras[i];\n                        }\n                        break;\n                }\n            } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {\n                return eras[i];\n            }\n        }\n    }\n\n    function localeErasConvertYear(era, year) {\n        var dir = era.since <= era.until ? +1 : -1;\n        if (year === undefined) {\n            return hooks(era.since).year();\n        } else {\n            return hooks(era.since).year() + (year - era.offset) * dir;\n        }\n    }\n\n    function getEraName() {\n        var i,\n            l,\n            val,\n            eras = this.localeData().eras();\n        for (i = 0, l = eras.length; i < l; ++i) {\n            // truncate time\n            val = this.clone().startOf('day').valueOf();\n\n            if (eras[i].since <= val && val <= eras[i].until) {\n                return eras[i].name;\n            }\n            if (eras[i].until <= val && val <= eras[i].since) {\n                return eras[i].name;\n            }\n        }\n\n        return '';\n    }\n\n    function getEraNarrow() {\n        var i,\n            l,\n            val,\n            eras = this.localeData().eras();\n        for (i = 0, l = eras.length; i < l; ++i) {\n            // truncate time\n            val = this.clone().startOf('day').valueOf();\n\n            if (eras[i].since <= val && val <= eras[i].until) {\n                return eras[i].narrow;\n            }\n            if (eras[i].until <= val && val <= eras[i].since) {\n                return eras[i].narrow;\n            }\n        }\n\n        return '';\n    }\n\n    function getEraAbbr() {\n        var i,\n            l,\n            val,\n            eras = this.localeData().eras();\n        for (i = 0, l = eras.length; i < l; ++i) {\n            // truncate time\n            val = this.clone().startOf('day').valueOf();\n\n            if (eras[i].since <= val && val <= eras[i].until) {\n                return eras[i].abbr;\n            }\n            if (eras[i].until <= val && val <= eras[i].since) {\n                return eras[i].abbr;\n            }\n        }\n\n        return '';\n    }\n\n    function getEraYear() {\n        var i,\n            l,\n            dir,\n            val,\n            eras = this.localeData().eras();\n        for (i = 0, l = eras.length; i < l; ++i) {\n            dir = eras[i].since <= eras[i].until ? +1 : -1;\n\n            // truncate time\n            val = this.clone().startOf('day').valueOf();\n\n            if (\n                (eras[i].since <= val && val <= eras[i].until) ||\n                (eras[i].until <= val && val <= eras[i].since)\n            ) {\n                return (\n                    (this.year() - hooks(eras[i].since).year()) * dir +\n                    eras[i].offset\n                );\n            }\n        }\n\n        return this.year();\n    }\n\n    function erasNameRegex(isStrict) {\n        if (!hasOwnProp(this, '_erasNameRegex')) {\n            computeErasParse.call(this);\n        }\n        return isStrict ? this._erasNameRegex : this._erasRegex;\n    }\n\n    function erasAbbrRegex(isStrict) {\n        if (!hasOwnProp(this, '_erasAbbrRegex')) {\n            computeErasParse.call(this);\n        }\n        return isStrict ? this._erasAbbrRegex : this._erasRegex;\n    }\n\n    function erasNarrowRegex(isStrict) {\n        if (!hasOwnProp(this, '_erasNarrowRegex')) {\n            computeErasParse.call(this);\n        }\n        return isStrict ? this._erasNarrowRegex : this._erasRegex;\n    }\n\n    function matchEraAbbr(isStrict, locale) {\n        return locale.erasAbbrRegex(isStrict);\n    }\n\n    function matchEraName(isStrict, locale) {\n        return locale.erasNameRegex(isStrict);\n    }\n\n    function matchEraNarrow(isStrict, locale) {\n        return locale.erasNarrowRegex(isStrict);\n    }\n\n    function matchEraYearOrdinal(isStrict, locale) {\n        return locale._eraYearOrdinalRegex || matchUnsigned;\n    }\n\n    function computeErasParse() {\n        var abbrPieces = [],\n            namePieces = [],\n            narrowPieces = [],\n            mixedPieces = [],\n            i,\n            l,\n            eras = this.eras();\n\n        for (i = 0, l = eras.length; i < l; ++i) {\n            namePieces.push(regexEscape(eras[i].name));\n            abbrPieces.push(regexEscape(eras[i].abbr));\n            narrowPieces.push(regexEscape(eras[i].narrow));\n\n            mixedPieces.push(regexEscape(eras[i].name));\n            mixedPieces.push(regexEscape(eras[i].abbr));\n            mixedPieces.push(regexEscape(eras[i].narrow));\n        }\n\n        this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n        this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i');\n        this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i');\n        this._erasNarrowRegex = new RegExp(\n            '^(' + narrowPieces.join('|') + ')',\n            'i'\n        );\n    }\n\n    // FORMATTING\n\n    addFormatToken(0, ['gg', 2], 0, function () {\n        return this.weekYear() % 100;\n    });\n\n    addFormatToken(0, ['GG', 2], 0, function () {\n        return this.isoWeekYear() % 100;\n    });\n\n    function addWeekYearFormatToken(token, getter) {\n        addFormatToken(0, [token, token.length], 0, getter);\n    }\n\n    addWeekYearFormatToken('gggg', 'weekYear');\n    addWeekYearFormatToken('ggggg', 'weekYear');\n    addWeekYearFormatToken('GGGG', 'isoWeekYear');\n    addWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n    // ALIASES\n\n    addUnitAlias('weekYear', 'gg');\n    addUnitAlias('isoWeekYear', 'GG');\n\n    // PRIORITY\n\n    addUnitPriority('weekYear', 1);\n    addUnitPriority('isoWeekYear', 1);\n\n    // PARSING\n\n    addRegexToken('G', matchSigned);\n    addRegexToken('g', matchSigned);\n    addRegexToken('GG', match1to2, match2);\n    addRegexToken('gg', match1to2, match2);\n    addRegexToken('GGGG', match1to4, match4);\n    addRegexToken('gggg', match1to4, match4);\n    addRegexToken('GGGGG', match1to6, match6);\n    addRegexToken('ggggg', match1to6, match6);\n\n    addWeekParseToken(\n        ['gggg', 'ggggg', 'GGGG', 'GGGGG'],\n        function (input, week, config, token) {\n            week[token.substr(0, 2)] = toInt(input);\n        }\n    );\n\n    addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n        week[token] = hooks.parseTwoDigitYear(input);\n    });\n\n    // MOMENTS\n\n    function getSetWeekYear(input) {\n        return getSetWeekYearHelper.call(\n            this,\n            input,\n            this.week(),\n            this.weekday(),\n            this.localeData()._week.dow,\n            this.localeData()._week.doy\n        );\n    }\n\n    function getSetISOWeekYear(input) {\n        return getSetWeekYearHelper.call(\n            this,\n            input,\n            this.isoWeek(),\n            this.isoWeekday(),\n            1,\n            4\n        );\n    }\n\n    function getISOWeeksInYear() {\n        return weeksInYear(this.year(), 1, 4);\n    }\n\n    function getISOWeeksInISOWeekYear() {\n        return weeksInYear(this.isoWeekYear(), 1, 4);\n    }\n\n    function getWeeksInYear() {\n        var weekInfo = this.localeData()._week;\n        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n    }\n\n    function getWeeksInWeekYear() {\n        var weekInfo = this.localeData()._week;\n        return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);\n    }\n\n    function getSetWeekYearHelper(input, week, weekday, dow, doy) {\n        var weeksTarget;\n        if (input == null) {\n            return weekOfYear(this, dow, doy).year;\n        } else {\n            weeksTarget = weeksInYear(input, dow, doy);\n            if (week > weeksTarget) {\n                week = weeksTarget;\n            }\n            return setWeekAll.call(this, input, week, weekday, dow, doy);\n        }\n    }\n\n    function setWeekAll(weekYear, week, weekday, dow, doy) {\n        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),\n            date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);\n\n        this.year(date.getUTCFullYear());\n        this.month(date.getUTCMonth());\n        this.date(date.getUTCDate());\n        return this;\n    }\n\n    // FORMATTING\n\n    addFormatToken('Q', 0, 'Qo', 'quarter');\n\n    // ALIASES\n\n    addUnitAlias('quarter', 'Q');\n\n    // PRIORITY\n\n    addUnitPriority('quarter', 7);\n\n    // PARSING\n\n    addRegexToken('Q', match1);\n    addParseToken('Q', function (input, array) {\n        array[MONTH] = (toInt(input) - 1) * 3;\n    });\n\n    // MOMENTS\n\n    function getSetQuarter(input) {\n        return input == null\n            ? Math.ceil((this.month() + 1) / 3)\n            : this.month((input - 1) * 3 + (this.month() % 3));\n    }\n\n    // FORMATTING\n\n    addFormatToken('D', ['DD', 2], 'Do', 'date');\n\n    // ALIASES\n\n    addUnitAlias('date', 'D');\n\n    // PRIORITY\n    addUnitPriority('date', 9);\n\n    // PARSING\n\n    addRegexToken('D', match1to2);\n    addRegexToken('DD', match1to2, match2);\n    addRegexToken('Do', function (isStrict, locale) {\n        // TODO: Remove \"ordinalParse\" fallback in next major release.\n        return isStrict\n            ? locale._dayOfMonthOrdinalParse || locale._ordinalParse\n            : locale._dayOfMonthOrdinalParseLenient;\n    });\n\n    addParseToken(['D', 'DD'], DATE);\n    addParseToken('Do', function (input, array) {\n        array[DATE] = toInt(input.match(match1to2)[0]);\n    });\n\n    // MOMENTS\n\n    var getSetDayOfMonth = makeGetSet('Date', true);\n\n    // FORMATTING\n\n    addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n    // ALIASES\n\n    addUnitAlias('dayOfYear', 'DDD');\n\n    // PRIORITY\n    addUnitPriority('dayOfYear', 4);\n\n    // PARSING\n\n    addRegexToken('DDD', match1to3);\n    addRegexToken('DDDD', match3);\n    addParseToken(['DDD', 'DDDD'], function (input, array, config) {\n        config._dayOfYear = toInt(input);\n    });\n\n    // HELPERS\n\n    // MOMENTS\n\n    function getSetDayOfYear(input) {\n        var dayOfYear =\n            Math.round(\n                (this.clone().startOf('day') - this.clone().startOf('year')) / 864e5\n            ) + 1;\n        return input == null ? dayOfYear : this.add(input - dayOfYear, 'd');\n    }\n\n    // FORMATTING\n\n    addFormatToken('m', ['mm', 2], 0, 'minute');\n\n    // ALIASES\n\n    addUnitAlias('minute', 'm');\n\n    // PRIORITY\n\n    addUnitPriority('minute', 14);\n\n    // PARSING\n\n    addRegexToken('m', match1to2);\n    addRegexToken('mm', match1to2, match2);\n    addParseToken(['m', 'mm'], MINUTE);\n\n    // MOMENTS\n\n    var getSetMinute = makeGetSet('Minutes', false);\n\n    // FORMATTING\n\n    addFormatToken('s', ['ss', 2], 0, 'second');\n\n    // ALIASES\n\n    addUnitAlias('second', 's');\n\n    // PRIORITY\n\n    addUnitPriority('second', 15);\n\n    // PARSING\n\n    addRegexToken('s', match1to2);\n    addRegexToken('ss', match1to2, match2);\n    addParseToken(['s', 'ss'], SECOND);\n\n    // MOMENTS\n\n    var getSetSecond = makeGetSet('Seconds', false);\n\n    // FORMATTING\n\n    addFormatToken('S', 0, 0, function () {\n        return ~~(this.millisecond() / 100);\n    });\n\n    addFormatToken(0, ['SS', 2], 0, function () {\n        return ~~(this.millisecond() / 10);\n    });\n\n    addFormatToken(0, ['SSS', 3], 0, 'millisecond');\n    addFormatToken(0, ['SSSS', 4], 0, function () {\n        return this.millisecond() * 10;\n    });\n    addFormatToken(0, ['SSSSS', 5], 0, function () {\n        return this.millisecond() * 100;\n    });\n    addFormatToken(0, ['SSSSSS', 6], 0, function () {\n        return this.millisecond() * 1000;\n    });\n    addFormatToken(0, ['SSSSSSS', 7], 0, function () {\n        return this.millisecond() * 10000;\n    });\n    addFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n        return this.millisecond() * 100000;\n    });\n    addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n        return this.millisecond() * 1000000;\n    });\n\n    // ALIASES\n\n    addUnitAlias('millisecond', 'ms');\n\n    // PRIORITY\n\n    addUnitPriority('millisecond', 16);\n\n    // PARSING\n\n    addRegexToken('S', match1to3, match1);\n    addRegexToken('SS', match1to3, match2);\n    addRegexToken('SSS', match1to3, match3);\n\n    var token, getSetMillisecond;\n    for (token = 'SSSS'; token.length <= 9; token += 'S') {\n        addRegexToken(token, matchUnsigned);\n    }\n\n    function parseMs(input, array) {\n        array[MILLISECOND] = toInt(('0.' + input) * 1000);\n    }\n\n    for (token = 'S'; token.length <= 9; token += 'S') {\n        addParseToken(token, parseMs);\n    }\n\n    getSetMillisecond = makeGetSet('Milliseconds', false);\n\n    // FORMATTING\n\n    addFormatToken('z', 0, 0, 'zoneAbbr');\n    addFormatToken('zz', 0, 0, 'zoneName');\n\n    // MOMENTS\n\n    function getZoneAbbr() {\n        return this._isUTC ? 'UTC' : '';\n    }\n\n    function getZoneName() {\n        return this._isUTC ? 'Coordinated Universal Time' : '';\n    }\n\n    var proto = Moment.prototype;\n\n    proto.add = add;\n    proto.calendar = calendar$1;\n    proto.clone = clone;\n    proto.diff = diff;\n    proto.endOf = endOf;\n    proto.format = format;\n    proto.from = from;\n    proto.fromNow = fromNow;\n    proto.to = to;\n    proto.toNow = toNow;\n    proto.get = stringGet;\n    proto.invalidAt = invalidAt;\n    proto.isAfter = isAfter;\n    proto.isBefore = isBefore;\n    proto.isBetween = isBetween;\n    proto.isSame = isSame;\n    proto.isSameOrAfter = isSameOrAfter;\n    proto.isSameOrBefore = isSameOrBefore;\n    proto.isValid = isValid$2;\n    proto.lang = lang;\n    proto.locale = locale;\n    proto.localeData = localeData;\n    proto.max = prototypeMax;\n    proto.min = prototypeMin;\n    proto.parsingFlags = parsingFlags;\n    proto.set = stringSet;\n    proto.startOf = startOf;\n    proto.subtract = subtract;\n    proto.toArray = toArray;\n    proto.toObject = toObject;\n    proto.toDate = toDate;\n    proto.toISOString = toISOString;\n    proto.inspect = inspect;\n    if (typeof Symbol !== 'undefined' && Symbol.for != null) {\n        proto[Symbol.for('nodejs.util.inspect.custom')] = function () {\n            return 'Moment<' + this.format() + '>';\n        };\n    }\n    proto.toJSON = toJSON;\n    proto.toString = toString;\n    proto.unix = unix;\n    proto.valueOf = valueOf;\n    proto.creationData = creationData;\n    proto.eraName = getEraName;\n    proto.eraNarrow = getEraNarrow;\n    proto.eraAbbr = getEraAbbr;\n    proto.eraYear = getEraYear;\n    proto.year = getSetYear;\n    proto.isLeapYear = getIsLeapYear;\n    proto.weekYear = getSetWeekYear;\n    proto.isoWeekYear = getSetISOWeekYear;\n    proto.quarter = proto.quarters = getSetQuarter;\n    proto.month = getSetMonth;\n    proto.daysInMonth = getDaysInMonth;\n    proto.week = proto.weeks = getSetWeek;\n    proto.isoWeek = proto.isoWeeks = getSetISOWeek;\n    proto.weeksInYear = getWeeksInYear;\n    proto.weeksInWeekYear = getWeeksInWeekYear;\n    proto.isoWeeksInYear = getISOWeeksInYear;\n    proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;\n    proto.date = getSetDayOfMonth;\n    proto.day = proto.days = getSetDayOfWeek;\n    proto.weekday = getSetLocaleDayOfWeek;\n    proto.isoWeekday = getSetISODayOfWeek;\n    proto.dayOfYear = getSetDayOfYear;\n    proto.hour = proto.hours = getSetHour;\n    proto.minute = proto.minutes = getSetMinute;\n    proto.second = proto.seconds = getSetSecond;\n    proto.millisecond = proto.milliseconds = getSetMillisecond;\n    proto.utcOffset = getSetOffset;\n    proto.utc = setOffsetToUTC;\n    proto.local = setOffsetToLocal;\n    proto.parseZone = setOffsetToParsedOffset;\n    proto.hasAlignedHourOffset = hasAlignedHourOffset;\n    proto.isDST = isDaylightSavingTime;\n    proto.isLocal = isLocal;\n    proto.isUtcOffset = isUtcOffset;\n    proto.isUtc = isUtc;\n    proto.isUTC = isUtc;\n    proto.zoneAbbr = getZoneAbbr;\n    proto.zoneName = getZoneName;\n    proto.dates = deprecate(\n        'dates accessor is deprecated. Use date instead.',\n        getSetDayOfMonth\n    );\n    proto.months = deprecate(\n        'months accessor is deprecated. Use month instead',\n        getSetMonth\n    );\n    proto.years = deprecate(\n        'years accessor is deprecated. Use year instead',\n        getSetYear\n    );\n    proto.zone = deprecate(\n        'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',\n        getSetZone\n    );\n    proto.isDSTShifted = deprecate(\n        'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',\n        isDaylightSavingTimeShifted\n    );\n\n    function createUnix(input) {\n        return createLocal(input * 1000);\n    }\n\n    function createInZone() {\n        return createLocal.apply(null, arguments).parseZone();\n    }\n\n    function preParsePostFormat(string) {\n        return string;\n    }\n\n    var proto$1 = Locale.prototype;\n\n    proto$1.calendar = calendar;\n    proto$1.longDateFormat = longDateFormat;\n    proto$1.invalidDate = invalidDate;\n    proto$1.ordinal = ordinal;\n    proto$1.preparse = preParsePostFormat;\n    proto$1.postformat = preParsePostFormat;\n    proto$1.relativeTime = relativeTime;\n    proto$1.pastFuture = pastFuture;\n    proto$1.set = set;\n    proto$1.eras = localeEras;\n    proto$1.erasParse = localeErasParse;\n    proto$1.erasConvertYear = localeErasConvertYear;\n    proto$1.erasAbbrRegex = erasAbbrRegex;\n    proto$1.erasNameRegex = erasNameRegex;\n    proto$1.erasNarrowRegex = erasNarrowRegex;\n\n    proto$1.months = localeMonths;\n    proto$1.monthsShort = localeMonthsShort;\n    proto$1.monthsParse = localeMonthsParse;\n    proto$1.monthsRegex = monthsRegex;\n    proto$1.monthsShortRegex = monthsShortRegex;\n    proto$1.week = localeWeek;\n    proto$1.firstDayOfYear = localeFirstDayOfYear;\n    proto$1.firstDayOfWeek = localeFirstDayOfWeek;\n\n    proto$1.weekdays = localeWeekdays;\n    proto$1.weekdaysMin = localeWeekdaysMin;\n    proto$1.weekdaysShort = localeWeekdaysShort;\n    proto$1.weekdaysParse = localeWeekdaysParse;\n\n    proto$1.weekdaysRegex = weekdaysRegex;\n    proto$1.weekdaysShortRegex = weekdaysShortRegex;\n    proto$1.weekdaysMinRegex = weekdaysMinRegex;\n\n    proto$1.isPM = localeIsPM;\n    proto$1.meridiem = localeMeridiem;\n\n    function get$1(format, index, field, setter) {\n        var locale = getLocale(),\n            utc = createUTC().set(setter, index);\n        return locale[field](utc, format);\n    }\n\n    function listMonthsImpl(format, index, field) {\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n\n        if (index != null) {\n            return get$1(format, index, field, 'month');\n        }\n\n        var i,\n            out = [];\n        for (i = 0; i < 12; i++) {\n            out[i] = get$1(format, i, field, 'month');\n        }\n        return out;\n    }\n\n    // ()\n    // (5)\n    // (fmt, 5)\n    // (fmt)\n    // (true)\n    // (true, 5)\n    // (true, fmt, 5)\n    // (true, fmt)\n    function listWeekdaysImpl(localeSorted, format, index, field) {\n        if (typeof localeSorted === 'boolean') {\n            if (isNumber(format)) {\n                index = format;\n                format = undefined;\n            }\n\n            format = format || '';\n        } else {\n            format = localeSorted;\n            index = format;\n            localeSorted = false;\n\n            if (isNumber(format)) {\n                index = format;\n                format = undefined;\n            }\n\n            format = format || '';\n        }\n\n        var locale = getLocale(),\n            shift = localeSorted ? locale._week.dow : 0,\n            i,\n            out = [];\n\n        if (index != null) {\n            return get$1(format, (index + shift) % 7, field, 'day');\n        }\n\n        for (i = 0; i < 7; i++) {\n            out[i] = get$1(format, (i + shift) % 7, field, 'day');\n        }\n        return out;\n    }\n\n    function listMonths(format, index) {\n        return listMonthsImpl(format, index, 'months');\n    }\n\n    function listMonthsShort(format, index) {\n        return listMonthsImpl(format, index, 'monthsShort');\n    }\n\n    function listWeekdays(localeSorted, format, index) {\n        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n    }\n\n    function listWeekdaysShort(localeSorted, format, index) {\n        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n    }\n\n    function listWeekdaysMin(localeSorted, format, index) {\n        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n    }\n\n    getSetGlobalLocale('en', {\n        eras: [\n            {\n                since: '0001-01-01',\n                until: +Infinity,\n                offset: 1,\n                name: 'Anno Domini',\n                narrow: 'AD',\n                abbr: 'AD',\n            },\n            {\n                since: '0000-12-31',\n                until: -Infinity,\n                offset: 1,\n                name: 'Before Christ',\n                narrow: 'BC',\n                abbr: 'BC',\n            },\n        ],\n        dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n        ordinal: function (number) {\n            var b = number % 10,\n                output =\n                    toInt((number % 100) / 10) === 1\n                        ? 'th'\n                        : b === 1\n                        ? 'st'\n                        : b === 2\n                        ? 'nd'\n                        : b === 3\n                        ? 'rd'\n                        : 'th';\n            return number + output;\n        },\n    });\n\n    // Side effect imports\n\n    hooks.lang = deprecate(\n        'moment.lang is deprecated. Use moment.locale instead.',\n        getSetGlobalLocale\n    );\n    hooks.langData = deprecate(\n        'moment.langData is deprecated. Use moment.localeData instead.',\n        getLocale\n    );\n\n    var mathAbs = Math.abs;\n\n    function abs() {\n        var data = this._data;\n\n        this._milliseconds = mathAbs(this._milliseconds);\n        this._days = mathAbs(this._days);\n        this._months = mathAbs(this._months);\n\n        data.milliseconds = mathAbs(data.milliseconds);\n        data.seconds = mathAbs(data.seconds);\n        data.minutes = mathAbs(data.minutes);\n        data.hours = mathAbs(data.hours);\n        data.months = mathAbs(data.months);\n        data.years = mathAbs(data.years);\n\n        return this;\n    }\n\n    function addSubtract$1(duration, input, value, direction) {\n        var other = createDuration(input, value);\n\n        duration._milliseconds += direction * other._milliseconds;\n        duration._days += direction * other._days;\n        duration._months += direction * other._months;\n\n        return duration._bubble();\n    }\n\n    // supports only 2.0-style add(1, 's') or add(duration)\n    function add$1(input, value) {\n        return addSubtract$1(this, input, value, 1);\n    }\n\n    // supports only 2.0-style subtract(1, 's') or subtract(duration)\n    function subtract$1(input, value) {\n        return addSubtract$1(this, input, value, -1);\n    }\n\n    function absCeil(number) {\n        if (number < 0) {\n            return Math.floor(number);\n        } else {\n            return Math.ceil(number);\n        }\n    }\n\n    function bubble() {\n        var milliseconds = this._milliseconds,\n            days = this._days,\n            months = this._months,\n            data = this._data,\n            seconds,\n            minutes,\n            hours,\n            years,\n            monthsFromDays;\n\n        // if we have a mix of positive and negative values, bubble down first\n        // check: https://github.com/moment/moment/issues/2166\n        if (\n            !(\n                (milliseconds >= 0 && days >= 0 && months >= 0) ||\n                (milliseconds <= 0 && days <= 0 && months <= 0)\n            )\n        ) {\n            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;\n            days = 0;\n            months = 0;\n        }\n\n        // The following code bubbles up values, see the tests for\n        // examples of what that means.\n        data.milliseconds = milliseconds % 1000;\n\n        seconds = absFloor(milliseconds / 1000);\n        data.seconds = seconds % 60;\n\n        minutes = absFloor(seconds / 60);\n        data.minutes = minutes % 60;\n\n        hours = absFloor(minutes / 60);\n        data.hours = hours % 24;\n\n        days += absFloor(hours / 24);\n\n        // convert days to months\n        monthsFromDays = absFloor(daysToMonths(days));\n        months += monthsFromDays;\n        days -= absCeil(monthsToDays(monthsFromDays));\n\n        // 12 months -> 1 year\n        years = absFloor(months / 12);\n        months %= 12;\n\n        data.days = days;\n        data.months = months;\n        data.years = years;\n\n        return this;\n    }\n\n    function daysToMonths(days) {\n        // 400 years have 146097 days (taking into account leap year rules)\n        // 400 years have 12 months === 4800\n        return (days * 4800) / 146097;\n    }\n\n    function monthsToDays(months) {\n        // the reverse of daysToMonths\n        return (months * 146097) / 4800;\n    }\n\n    function as(units) {\n        if (!this.isValid()) {\n            return NaN;\n        }\n        var days,\n            months,\n            milliseconds = this._milliseconds;\n\n        units = normalizeUnits(units);\n\n        if (units === 'month' || units === 'quarter' || units === 'year') {\n            days = this._days + milliseconds / 864e5;\n            months = this._months + daysToMonths(days);\n            switch (units) {\n                case 'month':\n                    return months;\n                case 'quarter':\n                    return months / 3;\n                case 'year':\n                    return months / 12;\n            }\n        } else {\n            // handle milliseconds separately because of floating point math errors (issue #1867)\n            days = this._days + Math.round(monthsToDays(this._months));\n            switch (units) {\n                case 'week':\n                    return days / 7 + milliseconds / 6048e5;\n                case 'day':\n                    return days + milliseconds / 864e5;\n                case 'hour':\n                    return days * 24 + milliseconds / 36e5;\n                case 'minute':\n                    return days * 1440 + milliseconds / 6e4;\n                case 'second':\n                    return days * 86400 + milliseconds / 1000;\n                // Math.floor prevents floating point math errors here\n                case 'millisecond':\n                    return Math.floor(days * 864e5) + milliseconds;\n                default:\n                    throw new Error('Unknown unit ' + units);\n            }\n        }\n    }\n\n    // TODO: Use this.as('ms')?\n    function valueOf$1() {\n        if (!this.isValid()) {\n            return NaN;\n        }\n        return (\n            this._milliseconds +\n            this._days * 864e5 +\n            (this._months % 12) * 2592e6 +\n            toInt(this._months / 12) * 31536e6\n        );\n    }\n\n    function makeAs(alias) {\n        return function () {\n            return this.as(alias);\n        };\n    }\n\n    var asMilliseconds = makeAs('ms'),\n        asSeconds = makeAs('s'),\n        asMinutes = makeAs('m'),\n        asHours = makeAs('h'),\n        asDays = makeAs('d'),\n        asWeeks = makeAs('w'),\n        asMonths = makeAs('M'),\n        asQuarters = makeAs('Q'),\n        asYears = makeAs('y');\n\n    function clone$1() {\n        return createDuration(this);\n    }\n\n    function get$2(units) {\n        units = normalizeUnits(units);\n        return this.isValid() ? this[units + 's']() : NaN;\n    }\n\n    function makeGetter(name) {\n        return function () {\n            return this.isValid() ? this._data[name] : NaN;\n        };\n    }\n\n    var milliseconds = makeGetter('milliseconds'),\n        seconds = makeGetter('seconds'),\n        minutes = makeGetter('minutes'),\n        hours = makeGetter('hours'),\n        days = makeGetter('days'),\n        months = makeGetter('months'),\n        years = makeGetter('years');\n\n    function weeks() {\n        return absFloor(this.days() / 7);\n    }\n\n    var round = Math.round,\n        thresholds = {\n            ss: 44, // a few seconds to seconds\n            s: 45, // seconds to minute\n            m: 45, // minutes to hour\n            h: 22, // hours to day\n            d: 26, // days to month/week\n            w: null, // weeks to month\n            M: 11, // months to year\n        };\n\n    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\n    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n    }\n\n    function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {\n        var duration = createDuration(posNegDuration).abs(),\n            seconds = round(duration.as('s')),\n            minutes = round(duration.as('m')),\n            hours = round(duration.as('h')),\n            days = round(duration.as('d')),\n            months = round(duration.as('M')),\n            weeks = round(duration.as('w')),\n            years = round(duration.as('y')),\n            a =\n                (seconds <= thresholds.ss && ['s', seconds]) ||\n                (seconds < thresholds.s && ['ss', seconds]) ||\n                (minutes <= 1 && ['m']) ||\n                (minutes < thresholds.m && ['mm', minutes]) ||\n                (hours <= 1 && ['h']) ||\n                (hours < thresholds.h && ['hh', hours]) ||\n                (days <= 1 && ['d']) ||\n                (days < thresholds.d && ['dd', days]);\n\n        if (thresholds.w != null) {\n            a =\n                a ||\n                (weeks <= 1 && ['w']) ||\n                (weeks < thresholds.w && ['ww', weeks]);\n        }\n        a = a ||\n            (months <= 1 && ['M']) ||\n            (months < thresholds.M && ['MM', months]) ||\n            (years <= 1 && ['y']) || ['yy', years];\n\n        a[2] = withoutSuffix;\n        a[3] = +posNegDuration > 0;\n        a[4] = locale;\n        return substituteTimeAgo.apply(null, a);\n    }\n\n    // This function allows you to set the rounding function for relative time strings\n    function getSetRelativeTimeRounding(roundingFunction) {\n        if (roundingFunction === undefined) {\n            return round;\n        }\n        if (typeof roundingFunction === 'function') {\n            round = roundingFunction;\n            return true;\n        }\n        return false;\n    }\n\n    // This function allows you to set a threshold for relative time strings\n    function getSetRelativeTimeThreshold(threshold, limit) {\n        if (thresholds[threshold] === undefined) {\n            return false;\n        }\n        if (limit === undefined) {\n            return thresholds[threshold];\n        }\n        thresholds[threshold] = limit;\n        if (threshold === 's') {\n            thresholds.ss = limit - 1;\n        }\n        return true;\n    }\n\n    function humanize(argWithSuffix, argThresholds) {\n        if (!this.isValid()) {\n            return this.localeData().invalidDate();\n        }\n\n        var withSuffix = false,\n            th = thresholds,\n            locale,\n            output;\n\n        if (typeof argWithSuffix === 'object') {\n            argThresholds = argWithSuffix;\n            argWithSuffix = false;\n        }\n        if (typeof argWithSuffix === 'boolean') {\n            withSuffix = argWithSuffix;\n        }\n        if (typeof argThresholds === 'object') {\n            th = Object.assign({}, thresholds, argThresholds);\n            if (argThresholds.s != null && argThresholds.ss == null) {\n                th.ss = argThresholds.s - 1;\n            }\n        }\n\n        locale = this.localeData();\n        output = relativeTime$1(this, !withSuffix, th, locale);\n\n        if (withSuffix) {\n            output = locale.pastFuture(+this, output);\n        }\n\n        return locale.postformat(output);\n    }\n\n    var abs$1 = Math.abs;\n\n    function sign(x) {\n        return (x > 0) - (x < 0) || +x;\n    }\n\n    function toISOString$1() {\n        // for ISO strings we do not use the normal bubbling rules:\n        //  * milliseconds bubble up until they become hours\n        //  * days do not bubble at all\n        //  * months bubble up until they become years\n        // This is because there is no context-free conversion between hours and days\n        // (think of clock changes)\n        // and also not between days and months (28-31 days per month)\n        if (!this.isValid()) {\n            return this.localeData().invalidDate();\n        }\n\n        var seconds = abs$1(this._milliseconds) / 1000,\n            days = abs$1(this._days),\n            months = abs$1(this._months),\n            minutes,\n            hours,\n            years,\n            s,\n            total = this.asSeconds(),\n            totalSign,\n            ymSign,\n            daysSign,\n            hmsSign;\n\n        if (!total) {\n            // this is the same as C#'s (Noda) and python (isodate)...\n            // but not other JS (goog.date)\n            return 'P0D';\n        }\n\n        // 3600 seconds -> 60 minutes -> 1 hour\n        minutes = absFloor(seconds / 60);\n        hours = absFloor(minutes / 60);\n        seconds %= 60;\n        minutes %= 60;\n\n        // 12 months -> 1 year\n        years = absFloor(months / 12);\n        months %= 12;\n\n        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js\n        s = seconds ? seconds.toFixed(3).replace(/\\.?0+$/, '') : '';\n\n        totalSign = total < 0 ? '-' : '';\n        ymSign = sign(this._months) !== sign(total) ? '-' : '';\n        daysSign = sign(this._days) !== sign(total) ? '-' : '';\n        hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';\n\n        return (\n            totalSign +\n            'P' +\n            (years ? ymSign + years + 'Y' : '') +\n            (months ? ymSign + months + 'M' : '') +\n            (days ? daysSign + days + 'D' : '') +\n            (hours || minutes || seconds ? 'T' : '') +\n            (hours ? hmsSign + hours + 'H' : '') +\n            (minutes ? hmsSign + minutes + 'M' : '') +\n            (seconds ? hmsSign + s + 'S' : '')\n        );\n    }\n\n    var proto$2 = Duration.prototype;\n\n    proto$2.isValid = isValid$1;\n    proto$2.abs = abs;\n    proto$2.add = add$1;\n    proto$2.subtract = subtract$1;\n    proto$2.as = as;\n    proto$2.asMilliseconds = asMilliseconds;\n    proto$2.asSeconds = asSeconds;\n    proto$2.asMinutes = asMinutes;\n    proto$2.asHours = asHours;\n    proto$2.asDays = asDays;\n    proto$2.asWeeks = asWeeks;\n    proto$2.asMonths = asMonths;\n    proto$2.asQuarters = asQuarters;\n    proto$2.asYears = asYears;\n    proto$2.valueOf = valueOf$1;\n    proto$2._bubble = bubble;\n    proto$2.clone = clone$1;\n    proto$2.get = get$2;\n    proto$2.milliseconds = milliseconds;\n    proto$2.seconds = seconds;\n    proto$2.minutes = minutes;\n    proto$2.hours = hours;\n    proto$2.days = days;\n    proto$2.weeks = weeks;\n    proto$2.months = months;\n    proto$2.years = years;\n    proto$2.humanize = humanize;\n    proto$2.toISOString = toISOString$1;\n    proto$2.toString = toISOString$1;\n    proto$2.toJSON = toISOString$1;\n    proto$2.locale = locale;\n    proto$2.localeData = localeData;\n\n    proto$2.toIsoString = deprecate(\n        'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',\n        toISOString$1\n    );\n    proto$2.lang = lang;\n\n    // FORMATTING\n\n    addFormatToken('X', 0, 0, 'unix');\n    addFormatToken('x', 0, 0, 'valueOf');\n\n    // PARSING\n\n    addRegexToken('x', matchSigned);\n    addRegexToken('X', matchTimestamp);\n    addParseToken('X', function (input, array, config) {\n        config._d = new Date(parseFloat(input) * 1000);\n    });\n    addParseToken('x', function (input, array, config) {\n        config._d = new Date(toInt(input));\n    });\n\n    //! moment.js\n\n    hooks.version = '2.29.4';\n\n    setHookCallback(createLocal);\n\n    hooks.fn = proto;\n    hooks.min = min;\n    hooks.max = max;\n    hooks.now = now;\n    hooks.utc = createUTC;\n    hooks.unix = createUnix;\n    hooks.months = listMonths;\n    hooks.isDate = isDate;\n    hooks.locale = getSetGlobalLocale;\n    hooks.invalid = createInvalid;\n    hooks.duration = createDuration;\n    hooks.isMoment = isMoment;\n    hooks.weekdays = listWeekdays;\n    hooks.parseZone = createInZone;\n    hooks.localeData = getLocale;\n    hooks.isDuration = isDuration;\n    hooks.monthsShort = listMonthsShort;\n    hooks.weekdaysMin = listWeekdaysMin;\n    hooks.defineLocale = defineLocale;\n    hooks.updateLocale = updateLocale;\n    hooks.locales = listLocales;\n    hooks.weekdaysShort = listWeekdaysShort;\n    hooks.normalizeUnits = normalizeUnits;\n    hooks.relativeTimeRounding = getSetRelativeTimeRounding;\n    hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\n    hooks.calendarFormat = getCalendarFormat;\n    hooks.prototype = proto;\n\n    // currently HTML5 input type only supports 24-hour formats\n    hooks.HTML5_FMT = {\n        DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type=\"datetime-local\" />\n        DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type=\"datetime-local\" step=\"1\" />\n        DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type=\"datetime-local\" step=\"0.001\" />\n        DATE: 'YYYY-MM-DD', // <input type=\"date\" />\n        TIME: 'HH:mm', // <input type=\"time\" />\n        TIME_SECONDS: 'HH:mm:ss', // <input type=\"time\" step=\"1\" />\n        TIME_MS: 'HH:mm:ss.SSS', // <input type=\"time\" step=\"0.001\" />\n        WEEK: 'GGGG-[W]WW', // <input type=\"week\" />\n        MONTH: 'YYYY-MM', // <input type=\"month\" />\n    };\n\n    return hooks;\n\n})));\n","/**\n * Rounds number to given decimal\n * eg. roundNumber(2.34343, 1) => 2.3\n */\nexport var roundNumber = function (num, decimal) {\n    return Number(num.toFixed(decimal));\n};\n/**\n * Checks if value is number, if not it returns default value\n * 1# eg. checkIsNumber(2, 30) => 2\n * 2# eg. checkIsNumber(null, 30) => 30\n */\nexport var checkIsNumber = function (num, defaultValue) {\n    return typeof num === \"number\" ? num : defaultValue;\n};\n","export var handleCallback = function (context, event, callback) {\n    if (callback && typeof callback === \"function\") {\n        callback(context, event);\n    }\n};\n","/* eslint-disable no-plusplus */\n/* eslint-disable no-param-reassign */\n/**\n * Functions should return denominator of the target value, which is the next animation step.\n * t is a value from 0 to 1, reflecting the percentage of animation status.\n */\nvar easeOut = function (t) {\n    return -Math.cos(t * Math.PI) / 2 + 0.5;\n};\n// linear\nvar linear = function (t) {\n    return t;\n};\n// accelerating from zero velocity\nvar easeInQuad = function (t) {\n    return t * t;\n};\n// decelerating to zero velocity\nvar easeOutQuad = function (t) {\n    return t * (2 - t);\n};\n// acceleration until halfway, then deceleration\nvar easeInOutQuad = function (t) {\n    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;\n};\n// accelerating from zero velocity\nvar easeInCubic = function (t) {\n    return t * t * t;\n};\n// decelerating to zero velocity\nvar easeOutCubic = function (t) {\n    return --t * t * t + 1;\n};\n// acceleration until halfway, then deceleration\nvar easeInOutCubic = function (t) {\n    return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;\n};\n// accelerating from zero velocity\nvar easeInQuart = function (t) {\n    return t * t * t * t;\n};\n// decelerating to zero velocity\nvar easeOutQuart = function (t) {\n    return 1 - --t * t * t * t;\n};\n// acceleration until halfway, then deceleration\nvar easeInOutQuart = function (t) {\n    return t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t;\n};\n// accelerating from zero velocity\nvar easeInQuint = function (t) {\n    return t * t * t * t * t;\n};\n// decelerating to zero velocity\nvar easeOutQuint = function (t) {\n    return 1 + --t * t * t * t * t;\n};\n// acceleration until halfway, then deceleration\nvar easeInOutQuint = function (t) {\n    return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t;\n};\nexport var animations = {\n    easeOut: easeOut,\n    linear: linear,\n    easeInQuad: easeInQuad,\n    easeOutQuad: easeOutQuad,\n    easeInOutQuad: easeInOutQuad,\n    easeInCubic: easeInCubic,\n    easeOutCubic: easeOutCubic,\n    easeInOutCubic: easeInOutCubic,\n    easeInQuart: easeInQuart,\n    easeOutQuart: easeOutQuart,\n    easeInOutQuart: easeInOutQuart,\n    easeInQuint: easeInQuint,\n    easeOutQuint: easeOutQuint,\n    easeInOutQuint: easeInOutQuint,\n};\n","/* eslint-disable no-param-reassign */\nimport { animations } from \"./animations.constants\";\nvar handleCancelAnimationFrame = function (animation) {\n    if (typeof animation === \"number\") {\n        cancelAnimationFrame(animation);\n    }\n};\nexport var handleCancelAnimation = function (contextInstance) {\n    if (!contextInstance.mounted)\n        return;\n    handleCancelAnimationFrame(contextInstance.animation);\n    // Clear animation state\n    contextInstance.animate = false;\n    contextInstance.animation = null;\n    contextInstance.velocity = null;\n};\nexport function handleSetupAnimation(contextInstance, animationName, animationTime, callback) {\n    if (!contextInstance.mounted)\n        return;\n    var startTime = new Date().getTime();\n    var lastStep = 1;\n    // if another animation is active\n    handleCancelAnimation(contextInstance);\n    // new animation\n    contextInstance.animation = function () {\n        if (!contextInstance.mounted) {\n            return handleCancelAnimationFrame(contextInstance.animation);\n        }\n        var frameTime = new Date().getTime() - startTime;\n        var animationProgress = frameTime / animationTime;\n        var animationType = animations[animationName];\n        var step = animationType(animationProgress);\n        if (frameTime >= animationTime) {\n            callback(lastStep);\n            contextInstance.animation = null;\n        }\n        else if (contextInstance.animation) {\n            callback(step);\n            requestAnimationFrame(contextInstance.animation);\n        }\n    };\n    requestAnimationFrame(contextInstance.animation);\n}\nfunction isValidTargetState(targetState) {\n    var scale = targetState.scale, positionX = targetState.positionX, positionY = targetState.positionY;\n    if (Number.isNaN(scale) ||\n        Number.isNaN(positionX) ||\n        Number.isNaN(positionY)) {\n        return false;\n    }\n    return true;\n}\nexport function animate(contextInstance, targetState, animationTime, animationName) {\n    var isValid = isValidTargetState(targetState);\n    if (!contextInstance.mounted || !isValid)\n        return;\n    var setTransformState = contextInstance.setTransformState;\n    var _a = contextInstance.transformState, scale = _a.scale, positionX = _a.positionX, positionY = _a.positionY;\n    var scaleDiff = targetState.scale - scale;\n    var positionXDiff = targetState.positionX - positionX;\n    var positionYDiff = targetState.positionY - positionY;\n    if (animationTime === 0) {\n        setTransformState(targetState.scale, targetState.positionX, targetState.positionY);\n    }\n    else {\n        // animation start timestamp\n        handleSetupAnimation(contextInstance, animationName, animationTime, function (step) {\n            var newScale = scale + scaleDiff * step;\n            var newPositionX = positionX + positionXDiff * step;\n            var newPositionY = positionY + positionYDiff * step;\n            setTransformState(newScale, newPositionX, newPositionY);\n        });\n    }\n}\n","/* eslint-disable no-param-reassign */\nimport { roundNumber } from \"../../utils\";\nexport function getComponentsSizes(wrapperComponent, contentComponent, newScale) {\n    var wrapperWidth = wrapperComponent.offsetWidth;\n    var wrapperHeight = wrapperComponent.offsetHeight;\n    var contentWidth = contentComponent.offsetWidth;\n    var contentHeight = contentComponent.offsetHeight;\n    var newContentWidth = contentWidth * newScale;\n    var newContentHeight = contentHeight * newScale;\n    var newDiffWidth = wrapperWidth - newContentWidth;\n    var newDiffHeight = wrapperHeight - newContentHeight;\n    return {\n        wrapperWidth: wrapperWidth,\n        wrapperHeight: wrapperHeight,\n        newContentWidth: newContentWidth,\n        newDiffWidth: newDiffWidth,\n        newContentHeight: newContentHeight,\n        newDiffHeight: newDiffHeight,\n    };\n}\nexport var getBounds = function (wrapperWidth, newContentWidth, diffWidth, wrapperHeight, newContentHeight, diffHeight, centerZoomedOut) {\n    var scaleWidthFactor = wrapperWidth > newContentWidth\n        ? diffWidth * (centerZoomedOut ? 1 : 0.5)\n        : 0;\n    var scaleHeightFactor = wrapperHeight > newContentHeight\n        ? diffHeight * (centerZoomedOut ? 1 : 0.5)\n        : 0;\n    var minPositionX = wrapperWidth - newContentWidth - scaleWidthFactor;\n    var maxPositionX = scaleWidthFactor;\n    var minPositionY = wrapperHeight - newContentHeight - scaleHeightFactor;\n    var maxPositionY = scaleHeightFactor;\n    return { minPositionX: minPositionX, maxPositionX: maxPositionX, minPositionY: minPositionY, maxPositionY: maxPositionY };\n};\nexport var calculateBounds = function (contextInstance, newScale) {\n    var wrapperComponent = contextInstance.wrapperComponent, contentComponent = contextInstance.contentComponent;\n    var centerZoomedOut = contextInstance.setup.centerZoomedOut;\n    if (!wrapperComponent || !contentComponent) {\n        throw new Error(\"Components are not mounted\");\n    }\n    var _a = getComponentsSizes(wrapperComponent, contentComponent, newScale), wrapperWidth = _a.wrapperWidth, wrapperHeight = _a.wrapperHeight, newContentWidth = _a.newContentWidth, newDiffWidth = _a.newDiffWidth, newContentHeight = _a.newContentHeight, newDiffHeight = _a.newDiffHeight;\n    var bounds = getBounds(wrapperWidth, newContentWidth, newDiffWidth, wrapperHeight, newContentHeight, newDiffHeight, Boolean(centerZoomedOut));\n    return bounds;\n};\nexport function clamp(v, min, max) {\n    return Math.max(min, Math.min(v, max));\n}\n// Based on @aholachek ;)\n// https://twitter.com/chpwn/status/285540192096497664\n// iOS constant = 0.55\n// https://medium.com/@nathangitter/building-fluid-interfaces-ios-swift-9732bb934bf5\nfunction rubberband(distance, dimension, constant) {\n    if (dimension === 0 || Math.abs(dimension) === Infinity)\n        return Math.pow(distance, (constant * 5));\n    return (distance * dimension * constant) / (dimension + constant * distance);\n}\nexport function rubberbandIfOutOfBounds(position, min, max, constant) {\n    if (constant === void 0) { constant = 0.15; }\n    if (constant === 0)\n        return clamp(position, min, max);\n    if (position < min)\n        return -rubberband(min - position, max - min, constant) + min;\n    if (position > max)\n        return +rubberband(position - max, max - min, constant) + max;\n    return position;\n}\n/**\n * Keeps value between given bounds, used for limiting view to given boundaries\n * 1# eg. boundLimiter(2, 0, 3, true) => 2\n * 2# eg. boundLimiter(4, 0, 3, true) => 3\n * 3# eg. boundLimiter(-2, 0, 3, true) => 0\n * 4# eg. boundLimiter(10, 0, 3, false) => 10\n */\nexport var boundLimiter = function (value, minBound, maxBound, isActive) {\n    if (!isActive)\n        return roundNumber(value, 2);\n    if (value < minBound)\n        return roundNumber(minBound, 2);\n    if (value > maxBound)\n        return roundNumber(maxBound, 2);\n    return roundNumber(value, 2);\n};\nexport var handleCalculateBounds = function (contextInstance, newScale) {\n    var bounds = calculateBounds(contextInstance, newScale);\n    // Save bounds\n    contextInstance.bounds = bounds;\n    return bounds;\n};\nexport function getMouseBoundedPosition(positionX, positionY, bounds, limitToBounds, paddingValueX, paddingValueY, wrapperComponent) {\n    var minPositionX = bounds.minPositionX, minPositionY = bounds.minPositionY, maxPositionX = bounds.maxPositionX, maxPositionY = bounds.maxPositionY;\n    var paddingX = 0;\n    var paddingY = 0;\n    if (wrapperComponent) {\n        paddingX = paddingValueX;\n        paddingY = paddingValueY;\n    }\n    var x = boundLimiter(positionX, minPositionX - paddingX, maxPositionX + paddingX, limitToBounds);\n    var y = boundLimiter(positionY, minPositionY - paddingY, maxPositionY + paddingY, limitToBounds);\n    return { x: x, y: y };\n}\n","import { getMouseBoundedPosition } from \"../bounds/bounds.utils\";\nexport function handleCalculateZoomPositions(contextInstance, mouseX, mouseY, newScale, bounds, limitToBounds) {\n    var _a = contextInstance.transformState, scale = _a.scale, positionX = _a.positionX, positionY = _a.positionY;\n    var scaleDifference = newScale - scale;\n    if (typeof mouseX !== \"number\" || typeof mouseY !== \"number\") {\n        console.error(\"Mouse X and Y position were not provided!\");\n        return { x: positionX, y: positionY };\n    }\n    var calculatedPositionX = positionX - mouseX * scaleDifference;\n    var calculatedPositionY = positionY - mouseY * scaleDifference;\n    // do not limit to bounds when there is padding animation,\n    // it causes animation strange behaviour\n    var newPositions = getMouseBoundedPosition(calculatedPositionX, calculatedPositionY, bounds, limitToBounds, 0, 0, null);\n    return newPositions;\n}\nexport function checkZoomBounds(zoom, minScale, maxScale, zoomPadding, enablePadding) {\n    var scalePadding = enablePadding ? zoomPadding : 0;\n    var minScaleWithPadding = minScale - scalePadding;\n    if (!Number.isNaN(maxScale) && zoom >= maxScale)\n        return maxScale;\n    if (!Number.isNaN(minScale) && zoom <= minScaleWithPadding)\n        return minScaleWithPadding;\n    return zoom;\n}\n","import { isExcludedNode } from \"../../utils\";\nimport { getMouseBoundedPosition } from \"../bounds/bounds.utils\";\nimport { handleCalculateZoomPositions } from \"../zoom/zoom.utils\";\nexport var isPanningStartAllowed = function (contextInstance, event) {\n    var excluded = contextInstance.setup.panning.excluded;\n    var isInitialized = contextInstance.isInitialized, wrapperComponent = contextInstance.wrapperComponent;\n    var target = event.target;\n    var isWrapperChild = wrapperComponent === null || wrapperComponent === void 0 ? void 0 : wrapperComponent.contains(target);\n    var isAllowed = isInitialized && target && isWrapperChild;\n    if (!isAllowed)\n        return false;\n    var isExcluded = isExcludedNode(target, excluded);\n    if (isExcluded)\n        return false;\n    return true;\n};\nexport var isPanningAllowed = function (contextInstance) {\n    var isInitialized = contextInstance.isInitialized, isPanning = contextInstance.isPanning, setup = contextInstance.setup;\n    var disabled = setup.panning.disabled;\n    var isAllowed = isInitialized && isPanning && !disabled;\n    if (!isAllowed)\n        return false;\n    return true;\n};\nexport var handlePanningSetup = function (contextInstance, event) {\n    var _a = contextInstance.transformState, positionX = _a.positionX, positionY = _a.positionY;\n    contextInstance.isPanning = true;\n    // Panning with mouse\n    var x = event.clientX;\n    var y = event.clientY;\n    contextInstance.startCoords = { x: x - positionX, y: y - positionY };\n};\nexport var handleTouchPanningSetup = function (contextInstance, event) {\n    var touches = event.touches;\n    var _a = contextInstance.transformState, positionX = _a.positionX, positionY = _a.positionY;\n    contextInstance.isPanning = true;\n    // Panning with touch\n    var oneFingerTouch = touches.length === 1;\n    if (oneFingerTouch) {\n        var x = touches[0].clientX;\n        var y = touches[0].clientY;\n        contextInstance.startCoords = { x: x - positionX, y: y - positionY };\n    }\n};\nexport function handlePanToBounds(contextInstance) {\n    var _a = contextInstance.transformState, positionX = _a.positionX, positionY = _a.positionY, scale = _a.scale;\n    var _b = contextInstance.setup, disabled = _b.disabled, limitToBounds = _b.limitToBounds, centerZoomedOut = _b.centerZoomedOut;\n    var wrapperComponent = contextInstance.wrapperComponent;\n    if (disabled || !wrapperComponent || !contextInstance.bounds)\n        return;\n    var _c = contextInstance.bounds, maxPositionX = _c.maxPositionX, minPositionX = _c.minPositionX, maxPositionY = _c.maxPositionY, minPositionY = _c.minPositionY;\n    var xChanged = positionX > maxPositionX || positionX < minPositionX;\n    var yChanged = positionY > maxPositionY || positionY < minPositionY;\n    var mousePosX = positionX > maxPositionX\n        ? wrapperComponent.offsetWidth\n        : contextInstance.setup.minPositionX || 0;\n    var mousePosY = positionY > maxPositionY\n        ? wrapperComponent.offsetHeight\n        : contextInstance.setup.minPositionY || 0;\n    var _d = handleCalculateZoomPositions(contextInstance, mousePosX, mousePosY, scale, contextInstance.bounds, limitToBounds || centerZoomedOut), x = _d.x, y = _d.y;\n    return {\n        scale: scale,\n        positionX: xChanged ? x : positionX,\n        positionY: yChanged ? y : positionY,\n    };\n}\nexport function handlePaddingAnimation(contextInstance, positionX, positionY) {\n    var scale = contextInstance.transformState.scale;\n    var _a = contextInstance.setup.alignmentAnimation, sizeX = _a.sizeX, sizeY = _a.sizeY;\n    if (!sizeX && !sizeY)\n        return;\n    contextInstance.setTransformState(scale, positionX, positionY);\n}\nexport function handleNewPosition(contextInstance, newPositionX, newPositionY, paddingValueX, paddingValueY) {\n    var limitToBounds = contextInstance.setup.limitToBounds;\n    var wrapperComponent = contextInstance.wrapperComponent, bounds = contextInstance.bounds;\n    var _a = contextInstance.transformState, scale = _a.scale, positionX = _a.positionX, positionY = _a.positionY;\n    if (wrapperComponent === null ||\n        bounds === null ||\n        (newPositionX === positionX && newPositionY === positionY)) {\n        return;\n    }\n    var _b = getMouseBoundedPosition(newPositionX, newPositionY, bounds, limitToBounds, paddingValueX, paddingValueY, wrapperComponent), x = _b.x, y = _b.y;\n    contextInstance.setTransformState(scale, x, y);\n}\nexport var getPanningClientPosition = function (contextInstance, clientX, clientY) {\n    var startCoords = contextInstance.startCoords, transformState = contextInstance.transformState;\n    var panning = contextInstance.setup.panning;\n    var lockAxisX = panning.lockAxisX, lockAxisY = panning.lockAxisY;\n    var positionX = transformState.positionX, positionY = transformState.positionY;\n    if (!startCoords) {\n        return { x: positionX, y: positionY };\n    }\n    var mouseX = clientX - startCoords.x;\n    var mouseY = clientY - startCoords.y;\n    var newPositionX = lockAxisX ? positionX : mouseX;\n    var newPositionY = lockAxisY ? positionY : mouseY;\n    return { x: newPositionX, y: newPositionY };\n};\nexport var getPaddingValue = function (contextInstance, size) {\n    var setup = contextInstance.setup, transformState = contextInstance.transformState;\n    var scale = transformState.scale;\n    var minScale = setup.minScale, disablePadding = setup.disablePadding;\n    if (size > 0 && scale >= minScale && !disablePadding) {\n        return size;\n    }\n    return 0;\n};\n","import { boundLimiter } from \"../bounds/bounds.utils\";\nexport var isVelocityCalculationAllowed = function (contextInstance) {\n    var mounted = contextInstance.mounted;\n    var _a = contextInstance.setup, disabled = _a.disabled, velocityAnimation = _a.velocityAnimation;\n    var scale = contextInstance.transformState.scale;\n    var disabledVelocity = velocityAnimation.disabled;\n    var isAllowed = !disabledVelocity || scale > 1 || !disabled || mounted;\n    if (!isAllowed)\n        return false;\n    return true;\n};\nexport var isVelocityAllowed = function (contextInstance) {\n    var mounted = contextInstance.mounted, velocity = contextInstance.velocity, bounds = contextInstance.bounds;\n    var _a = contextInstance.setup, disabled = _a.disabled, velocityAnimation = _a.velocityAnimation;\n    var scale = contextInstance.transformState.scale;\n    var disabledVelocity = velocityAnimation.disabled;\n    var isAllowed = !disabledVelocity || scale > 1 || !disabled || mounted;\n    if (!isAllowed)\n        return false;\n    if (!velocity || !bounds)\n        return false;\n    return true;\n};\nexport function getVelocityMoveTime(contextInstance, velocity) {\n    var velocityAnimation = contextInstance.setup.velocityAnimation;\n    var equalToMove = velocityAnimation.equalToMove, animationTime = velocityAnimation.animationTime, sensitivity = velocityAnimation.sensitivity;\n    if (equalToMove) {\n        return animationTime * velocity * sensitivity;\n    }\n    return animationTime;\n}\nexport function getVelocityPosition(newPosition, startPosition, currentPosition, isLocked, limitToBounds, minPosition, maxPosition, minTarget, maxTarget, step) {\n    if (limitToBounds) {\n        if (startPosition > maxPosition && currentPosition > maxPosition) {\n            var calculatedPosition = maxPosition + (newPosition - maxPosition) * step;\n            if (calculatedPosition > maxTarget)\n                return maxTarget;\n            if (calculatedPosition < maxPosition)\n                return maxPosition;\n            return calculatedPosition;\n        }\n        if (startPosition < minPosition && currentPosition < minPosition) {\n            var calculatedPosition = minPosition + (newPosition - minPosition) * step;\n            if (calculatedPosition < minTarget)\n                return minTarget;\n            if (calculatedPosition > minPosition)\n                return minPosition;\n            return calculatedPosition;\n        }\n    }\n    if (isLocked)\n        return startPosition;\n    return boundLimiter(newPosition, minPosition, maxPosition, limitToBounds);\n}\n","import { animations } from \"../animations/animations.constants\";\nimport { handleSetupAnimation } from \"../animations/animations.utils\";\nimport { getPaddingValue } from \"./panning.utils\";\nimport { getVelocityPosition, getVelocityMoveTime, isVelocityAllowed, isVelocityCalculationAllowed, } from \"./velocity.utils\";\nexport function getSizeMultiplier(wrapperComponent, equalToMove) {\n    var defaultMultiplier = 1;\n    if (equalToMove) {\n        return Math.min(defaultMultiplier, wrapperComponent.offsetWidth / window.innerWidth);\n    }\n    return defaultMultiplier;\n}\nexport function handleCalculateVelocity(contextInstance, position) {\n    var isAllowed = isVelocityCalculationAllowed(contextInstance);\n    if (!isAllowed) {\n        return;\n    }\n    var lastMousePosition = contextInstance.lastMousePosition, velocityTime = contextInstance.velocityTime, setup = contextInstance.setup;\n    var wrapperComponent = contextInstance.wrapperComponent;\n    var equalToMove = setup.velocityAnimation.equalToMove;\n    var now = Date.now();\n    if (lastMousePosition && velocityTime && wrapperComponent) {\n        var sizeMultiplier = getSizeMultiplier(wrapperComponent, equalToMove);\n        var distanceX = position.x - lastMousePosition.x;\n        var distanceY = position.y - lastMousePosition.y;\n        var velocityX = distanceX / sizeMultiplier;\n        var velocityY = distanceY / sizeMultiplier;\n        var interval = now - velocityTime;\n        var speed = distanceX * distanceX + distanceY * distanceY;\n        var velocity = Math.sqrt(speed) / interval;\n        contextInstance.velocity = { velocityX: velocityX, velocityY: velocityY, total: velocity };\n    }\n    contextInstance.lastMousePosition = position;\n    contextInstance.velocityTime = now;\n}\nexport function handleVelocityPanning(contextInstance) {\n    var velocity = contextInstance.velocity, bounds = contextInstance.bounds, setup = contextInstance.setup, wrapperComponent = contextInstance.wrapperComponent;\n    var isAllowed = isVelocityAllowed(contextInstance);\n    if (!isAllowed || !velocity || !bounds || !wrapperComponent) {\n        return;\n    }\n    var velocityX = velocity.velocityX, velocityY = velocity.velocityY, total = velocity.total;\n    var maxPositionX = bounds.maxPositionX, minPositionX = bounds.minPositionX, maxPositionY = bounds.maxPositionY, minPositionY = bounds.minPositionY;\n    var limitToBounds = setup.limitToBounds, alignmentAnimation = setup.alignmentAnimation;\n    var zoomAnimation = setup.zoomAnimation, panning = setup.panning;\n    var lockAxisY = panning.lockAxisY, lockAxisX = panning.lockAxisX;\n    var animationType = zoomAnimation.animationType;\n    var sizeX = alignmentAnimation.sizeX, sizeY = alignmentAnimation.sizeY, velocityAlignmentTime = alignmentAnimation.velocityAlignmentTime;\n    var alignAnimationTime = velocityAlignmentTime;\n    var moveAnimationTime = getVelocityMoveTime(contextInstance, total);\n    var finalAnimationTime = Math.max(moveAnimationTime, alignAnimationTime);\n    var paddingValueX = getPaddingValue(contextInstance, sizeX);\n    var paddingValueY = getPaddingValue(contextInstance, sizeY);\n    var paddingX = (paddingValueX * wrapperComponent.offsetWidth) / 100;\n    var paddingY = (paddingValueY * wrapperComponent.offsetHeight) / 100;\n    var maxTargetX = maxPositionX + paddingX;\n    var minTargetX = minPositionX - paddingX;\n    var maxTargetY = maxPositionY + paddingY;\n    var minTargetY = minPositionY - paddingY;\n    var startState = contextInstance.transformState;\n    var startTime = new Date().getTime();\n    handleSetupAnimation(contextInstance, animationType, finalAnimationTime, function (step) {\n        var _a = contextInstance.transformState, scale = _a.scale, positionX = _a.positionX, positionY = _a.positionY;\n        var frameTime = new Date().getTime() - startTime;\n        var animationProgress = frameTime / alignAnimationTime;\n        var alignAnimation = animations[alignmentAnimation.animationType];\n        var alignStep = 1 - alignAnimation(Math.min(1, animationProgress));\n        var customStep = 1 - step;\n        var newPositionX = positionX + velocityX * customStep;\n        var newPositionY = positionY + velocityY * customStep;\n        var currentPositionX = getVelocityPosition(newPositionX, startState.positionX, positionX, lockAxisX, limitToBounds, minPositionX, maxPositionX, minTargetX, maxTargetX, alignStep);\n        var currentPositionY = getVelocityPosition(newPositionY, startState.positionY, positionY, lockAxisY, limitToBounds, minPositionY, maxPositionY, minTargetY, maxTargetY, alignStep);\n        if (positionX !== newPositionX || positionY !== newPositionY) {\n            contextInstance.setTransformState(scale, currentPositionX, currentPositionY);\n        }\n    });\n}\n","import { animate, handleCancelAnimation } from \"../animations/animations.utils\";\nimport { handleCalculateBounds } from \"../bounds/bounds.utils\";\nimport { getPaddingValue, getPanningClientPosition, handleNewPosition, handlePanningSetup, handlePanToBounds, handleTouchPanningSetup, } from \"./panning.utils\";\nimport { handleVelocityPanning, handleCalculateVelocity, } from \"./velocity.logic\";\nexport function handlePanningStart(contextInstance, event) {\n    var scale = contextInstance.transformState.scale;\n    handleCancelAnimation(contextInstance);\n    handleCalculateBounds(contextInstance, scale);\n    if (window.TouchEvent !== undefined && event instanceof TouchEvent) {\n        handleTouchPanningSetup(contextInstance, event);\n    }\n    else {\n        handlePanningSetup(contextInstance, event);\n    }\n}\nexport function handleAlignToBounds(contextInstance) {\n    var scale = contextInstance.transformState.scale;\n    var _a = contextInstance.setup, minScale = _a.minScale, alignmentAnimation = _a.alignmentAnimation;\n    var disabled = alignmentAnimation.disabled, sizeX = alignmentAnimation.sizeX, sizeY = alignmentAnimation.sizeY, animationTime = alignmentAnimation.animationTime, animationType = alignmentAnimation.animationType;\n    var isDisabled = disabled || scale < minScale || (!sizeX && !sizeY);\n    if (isDisabled)\n        return;\n    var targetState = handlePanToBounds(contextInstance);\n    if (targetState) {\n        animate(contextInstance, targetState, animationTime, animationType);\n    }\n}\nexport function handlePanning(contextInstance, clientX, clientY) {\n    var startCoords = contextInstance.startCoords, setup = contextInstance.setup;\n    var _a = setup.alignmentAnimation, sizeX = _a.sizeX, sizeY = _a.sizeY;\n    if (!startCoords)\n        return;\n    var _b = getPanningClientPosition(contextInstance, clientX, clientY), x = _b.x, y = _b.y;\n    var paddingValueX = getPaddingValue(contextInstance, sizeX);\n    var paddingValueY = getPaddingValue(contextInstance, sizeY);\n    handleCalculateVelocity(contextInstance, { x: x, y: y });\n    handleNewPosition(contextInstance, x, y, paddingValueX, paddingValueY);\n}\nexport function handlePanningEnd(contextInstance) {\n    if (contextInstance.isPanning) {\n        var velocityDisabled = contextInstance.setup.panning.velocityDisabled;\n        var velocity = contextInstance.velocity, wrapperComponent = contextInstance.wrapperComponent, contentComponent = contextInstance.contentComponent;\n        contextInstance.isPanning = false;\n        contextInstance.animate = false;\n        contextInstance.animation = null;\n        var wrapperRect = wrapperComponent === null || wrapperComponent === void 0 ? void 0 : wrapperComponent.getBoundingClientRect();\n        var contentRect = contentComponent === null || contentComponent === void 0 ? void 0 : contentComponent.getBoundingClientRect();\n        var wrapperWidth = (wrapperRect === null || wrapperRect === void 0 ? void 0 : wrapperRect.width) || 0;\n        var wrapperHeight = (wrapperRect === null || wrapperRect === void 0 ? void 0 : wrapperRect.height) || 0;\n        var contentWidth = (contentRect === null || contentRect === void 0 ? void 0 : contentRect.width) || 0;\n        var contentHeight = (contentRect === null || contentRect === void 0 ? void 0 : contentRect.height) || 0;\n        var isZoomed = wrapperWidth < contentWidth || wrapperHeight < contentHeight;\n        var shouldAnimate = !velocityDisabled && velocity && (velocity === null || velocity === void 0 ? void 0 : velocity.total) > 0.1 && isZoomed;\n        if (shouldAnimate) {\n            handleVelocityPanning(contextInstance);\n        }\n        else {\n            handleAlignToBounds(contextInstance);\n        }\n    }\n}\n","import { roundNumber } from \"../../utils\";\nimport { animate } from \"../animations/animations.utils\";\nimport { handleCalculateBounds } from \"../bounds/bounds.utils\";\nimport { handleAlignToBounds } from \"../pan/panning.logic\";\nimport { checkZoomBounds, handleCalculateZoomPositions } from \"./zoom.utils\";\nexport function handleZoomToPoint(contextInstance, scale, mouseX, mouseY) {\n    var _a = contextInstance.setup, minScale = _a.minScale, maxScale = _a.maxScale, limitToBounds = _a.limitToBounds;\n    var newScale = checkZoomBounds(roundNumber(scale, 2), minScale, maxScale, 0, false);\n    var bounds = handleCalculateBounds(contextInstance, newScale);\n    var _b = handleCalculateZoomPositions(contextInstance, mouseX, mouseY, newScale, bounds, limitToBounds), x = _b.x, y = _b.y;\n    return { scale: newScale, positionX: x, positionY: y };\n}\nexport function handleAlignToScaleBounds(contextInstance, mousePositionX, mousePositionY) {\n    var scale = contextInstance.transformState.scale;\n    var wrapperComponent = contextInstance.wrapperComponent;\n    var _a = contextInstance.setup, minScale = _a.minScale, limitToBounds = _a.limitToBounds, zoomAnimation = _a.zoomAnimation;\n    var disabled = zoomAnimation.disabled, animationTime = zoomAnimation.animationTime, animationType = zoomAnimation.animationType;\n    var isDisabled = disabled || scale >= minScale;\n    if (scale >= 1 || limitToBounds) {\n        // fire fit to bounds animation\n        handleAlignToBounds(contextInstance);\n    }\n    if (isDisabled || !wrapperComponent || !contextInstance.mounted)\n        return;\n    var mouseX = mousePositionX || wrapperComponent.offsetWidth / 2;\n    var mouseY = mousePositionY || wrapperComponent.offsetHeight / 2;\n    var targetState = handleZoomToPoint(contextInstance, minScale, mouseX, mouseY);\n    if (targetState) {\n        animate(contextInstance, targetState, animationTime, animationType);\n    }\n}\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.push(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.push(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","export var initialState = {\n    previousScale: 1,\n    scale: 1,\n    positionX: 0,\n    positionY: 0,\n};\nexport var initialSetup = {\n    disabled: false,\n    minPositionX: null,\n    maxPositionX: null,\n    minPositionY: null,\n    maxPositionY: null,\n    minScale: 1,\n    maxScale: 8,\n    limitToBounds: true,\n    centerZoomedOut: false,\n    centerOnInit: false,\n    disablePadding: false,\n    smooth: true,\n    wheel: {\n        step: 0.2,\n        disabled: false,\n        smoothStep: 0.001,\n        wheelDisabled: false,\n        touchPadDisabled: false,\n        activationKeys: [],\n        excluded: [],\n    },\n    panning: {\n        disabled: false,\n        velocityDisabled: false,\n        lockAxisX: false,\n        lockAxisY: false,\n        allowLeftClickPan: true,\n        allowMiddleClickPan: true,\n        allowRightClickPan: true,\n        activationKeys: [],\n        excluded: [],\n    },\n    pinch: {\n        step: 5,\n        disabled: false,\n        excluded: [],\n    },\n    doubleClick: {\n        disabled: false,\n        step: 0.7,\n        mode: \"zoomIn\",\n        animationType: \"easeOut\",\n        animationTime: 200,\n        excluded: [],\n    },\n    zoomAnimation: {\n        disabled: false,\n        size: 0.4,\n        animationTime: 200,\n        animationType: \"easeOut\",\n    },\n    alignmentAnimation: {\n        disabled: false,\n        sizeX: 100,\n        sizeY: 100,\n        animationTime: 200,\n        velocityAlignmentTime: 400,\n        animationType: \"easeOut\",\n    },\n    velocityAnimation: {\n        disabled: false,\n        sensitivity: 1,\n        animationTime: 400,\n        animationType: \"easeOut\",\n        equalToMove: true,\n    },\n};\n","import { __assign, __spreadArray } from \"tslib\";\nimport { initialSetup, initialState } from \"../constants/state.constants\";\nexport var createState = function (props) {\n    var _a, _b, _c, _d;\n    return {\n        previousScale: (_a = props.initialScale) !== null && _a !== void 0 ? _a : initialState.scale,\n        scale: (_b = props.initialScale) !== null && _b !== void 0 ? _b : initialState.scale,\n        positionX: (_c = props.initialPositionX) !== null && _c !== void 0 ? _c : initialState.positionX,\n        positionY: (_d = props.initialPositionY) !== null && _d !== void 0 ? _d : initialState.positionY,\n    };\n};\nexport var createSetup = function (props) {\n    var newSetup = __assign({}, initialSetup);\n    Object.keys(props).forEach(function (key) {\n        var validValue = typeof props[key] !== \"undefined\";\n        var validParameter = typeof initialSetup[key] !== \"undefined\";\n        if (validParameter && validValue) {\n            var dataType = Object.prototype.toString.call(initialSetup[key]);\n            var isObject = dataType === \"[object Object]\";\n            var isArray = dataType === \"[object Array]\";\n            if (isObject) {\n                newSetup[key] = __assign(__assign({}, initialSetup[key]), props[key]);\n            }\n            else if (isArray) {\n                newSetup[key] = __spreadArray(__spreadArray([], initialSetup[key], true), props[key], true);\n            }\n            else {\n                newSetup[key] = props[key];\n            }\n        }\n    });\n    return newSetup;\n};\n","import { handleZoomToPoint } from \"../zoom/zoom.logic\";\nimport { animate } from \"../animations/animations.utils\";\nimport { createState } from \"../../utils/state.utils\";\nimport { checkZoomBounds } from \"../zoom/zoom.utils\";\nimport { roundNumber } from \"../../utils\";\nimport { calculateBounds, getMouseBoundedPosition, } from \"../bounds/bounds.utils\";\nexport var handleCalculateButtonZoom = function (contextInstance, delta, step) {\n    var scale = contextInstance.transformState.scale;\n    var wrapperComponent = contextInstance.wrapperComponent, setup = contextInstance.setup;\n    var maxScale = setup.maxScale, minScale = setup.minScale, zoomAnimation = setup.zoomAnimation, smooth = setup.smooth;\n    var size = zoomAnimation.size;\n    if (!wrapperComponent) {\n        throw new Error(\"Wrapper is not mounted\");\n    }\n    var targetScale = smooth\n        ? scale * Math.exp(delta * step)\n        : scale + delta * step;\n    var newScale = checkZoomBounds(roundNumber(targetScale, 3), minScale, maxScale, size, false);\n    return newScale;\n};\nexport function handleZoomToViewCenter(contextInstance, delta, step, animationTime, animationType) {\n    var wrapperComponent = contextInstance.wrapperComponent;\n    var _a = contextInstance.transformState, scale = _a.scale, positionX = _a.positionX, positionY = _a.positionY;\n    if (!wrapperComponent)\n        return console.error(\"No WrapperComponent found\");\n    var wrapperWidth = wrapperComponent.offsetWidth;\n    var wrapperHeight = wrapperComponent.offsetHeight;\n    var mouseX = (wrapperWidth / 2 - positionX) / scale;\n    var mouseY = (wrapperHeight / 2 - positionY) / scale;\n    var newScale = handleCalculateButtonZoom(contextInstance, delta, step);\n    var targetState = handleZoomToPoint(contextInstance, newScale, mouseX, mouseY);\n    if (!targetState) {\n        return console.error(\"Error during zoom event. New transformation state was not calculated.\");\n    }\n    animate(contextInstance, targetState, animationTime, animationType);\n}\nexport function resetTransformations(contextInstance, animationTime, animationType, onResetTransformation) {\n    var setup = contextInstance.setup, wrapperComponent = contextInstance.wrapperComponent;\n    var limitToBounds = setup.limitToBounds;\n    var initialTransformation = createState(contextInstance.props);\n    var _a = contextInstance.transformState, scale = _a.scale, positionX = _a.positionX, positionY = _a.positionY;\n    if (!wrapperComponent)\n        return;\n    var newBounds = calculateBounds(contextInstance, initialTransformation.scale);\n    var boundedPositions = getMouseBoundedPosition(initialTransformation.positionX, initialTransformation.positionY, newBounds, limitToBounds, 0, 0, wrapperComponent);\n    var newState = {\n        scale: initialTransformation.scale,\n        positionX: boundedPositions.x,\n        positionY: boundedPositions.y,\n    };\n    if (scale === initialTransformation.scale &&\n        positionX === initialTransformation.positionX &&\n        positionY === initialTransformation.positionY) {\n        return;\n    }\n    onResetTransformation === null || onResetTransformation === void 0 ? void 0 : onResetTransformation();\n    animate(contextInstance, newState, animationTime, animationType);\n}\nexport function getOffset(element, wrapper, content, state) {\n    var offset = element.getBoundingClientRect();\n    var wrapperOffset = wrapper.getBoundingClientRect();\n    var contentOffset = content.getBoundingClientRect();\n    var xOff = wrapperOffset.x * state.scale;\n    var yOff = wrapperOffset.y * state.scale;\n    return {\n        x: (offset.x - contentOffset.x + xOff) / state.scale,\n        y: (offset.y - contentOffset.y + yOff) / state.scale,\n    };\n}\nexport function calculateZoomToNode(contextInstance, node, customZoom) {\n    var wrapperComponent = contextInstance.wrapperComponent, contentComponent = contextInstance.contentComponent, transformState = contextInstance.transformState;\n    var _a = contextInstance.setup, limitToBounds = _a.limitToBounds, minScale = _a.minScale, maxScale = _a.maxScale;\n    if (!wrapperComponent || !contentComponent)\n        return transformState;\n    var wrapperRect = wrapperComponent.getBoundingClientRect();\n    var nodeRect = node.getBoundingClientRect();\n    var nodeOffset = getOffset(node, wrapperComponent, contentComponent, transformState);\n    var nodeLeft = nodeOffset.x;\n    var nodeTop = nodeOffset.y;\n    var nodeWidth = nodeRect.width / transformState.scale;\n    var nodeHeight = nodeRect.height / transformState.scale;\n    var scaleX = wrapperComponent.offsetWidth / nodeWidth;\n    var scaleY = wrapperComponent.offsetHeight / nodeHeight;\n    var newScale = checkZoomBounds(customZoom || Math.min(scaleX, scaleY), minScale, maxScale, 0, false);\n    var offsetX = (wrapperRect.width - nodeWidth * newScale) / 2;\n    var offsetY = (wrapperRect.height - nodeHeight * newScale) / 2;\n    var newPositionX = (wrapperRect.left - nodeLeft) * newScale + offsetX;\n    var newPositionY = (wrapperRect.top - nodeTop) * newScale + offsetY;\n    var bounds = calculateBounds(contextInstance, newScale);\n    var _b = getMouseBoundedPosition(newPositionX, newPositionY, bounds, limitToBounds, 0, 0, wrapperComponent), x = _b.x, y = _b.y;\n    return { positionX: x, positionY: y, scale: newScale };\n}\n","import { calculateZoomToNode, handleZoomToViewCenter, resetTransformations, } from \"./handlers.utils\";\nimport { animate, handleCancelAnimation } from \"../animations/animations.utils\";\nimport { getCenterPosition } from \"../../utils\";\nexport var zoomIn = function (contextInstance) {\n    return function (step, animationTime, animationType) {\n        if (step === void 0) { step = 0.5; }\n        if (animationTime === void 0) { animationTime = 300; }\n        if (animationType === void 0) { animationType = \"easeOut\"; }\n        handleZoomToViewCenter(contextInstance, 1, step, animationTime, animationType);\n    };\n};\nexport var zoomOut = function (contextInstance) {\n    return function (step, animationTime, animationType) {\n        if (step === void 0) { step = 0.5; }\n        if (animationTime === void 0) { animationTime = 300; }\n        if (animationType === void 0) { animationType = \"easeOut\"; }\n        handleZoomToViewCenter(contextInstance, -1, step, animationTime, animationType);\n    };\n};\nexport var setTransform = function (contextInstance) {\n    return function (newPositionX, newPositionY, newScale, animationTime, animationType) {\n        if (animationTime === void 0) { animationTime = 300; }\n        if (animationType === void 0) { animationType = \"easeOut\"; }\n        var _a = contextInstance.transformState, positionX = _a.positionX, positionY = _a.positionY, scale = _a.scale;\n        var wrapperComponent = contextInstance.wrapperComponent, contentComponent = contextInstance.contentComponent;\n        var disabled = contextInstance.setup.disabled;\n        if (disabled || !wrapperComponent || !contentComponent)\n            return;\n        var targetState = {\n            positionX: Number.isNaN(newPositionX) ? positionX : newPositionX,\n            positionY: Number.isNaN(newPositionY) ? positionY : newPositionY,\n            scale: Number.isNaN(newScale) ? scale : newScale,\n        };\n        animate(contextInstance, targetState, animationTime, animationType);\n    };\n};\nexport var resetTransform = function (contextInstance) {\n    return function (animationTime, animationType) {\n        if (animationTime === void 0) { animationTime = 200; }\n        if (animationType === void 0) { animationType = \"easeOut\"; }\n        resetTransformations(contextInstance, animationTime, animationType);\n    };\n};\nexport var centerView = function (contextInstance) {\n    return function (scale, animationTime, animationType) {\n        if (animationTime === void 0) { animationTime = 200; }\n        if (animationType === void 0) { animationType = \"easeOut\"; }\n        var transformState = contextInstance.transformState, wrapperComponent = contextInstance.wrapperComponent, contentComponent = contextInstance.contentComponent;\n        if (wrapperComponent && contentComponent) {\n            var targetState = getCenterPosition(scale || transformState.scale, wrapperComponent, contentComponent);\n            animate(contextInstance, targetState, animationTime, animationType);\n        }\n    };\n};\nexport var zoomToElement = function (contextInstance) {\n    return function (node, scale, animationTime, animationType) {\n        if (animationTime === void 0) { animationTime = 600; }\n        if (animationType === void 0) { animationType = \"easeOut\"; }\n        handleCancelAnimation(contextInstance);\n        var wrapperComponent = contextInstance.wrapperComponent;\n        var target = typeof node === \"string\" ? document.getElementById(node) : node;\n        if (wrapperComponent && target && wrapperComponent.contains(target)) {\n            var targetState = calculateZoomToNode(contextInstance, target, scale);\n            animate(contextInstance, targetState, animationTime, animationType);\n        }\n    };\n};\n","import { zoomIn, zoomOut, setTransform, resetTransform, zoomToElement, centerView, } from \"../core/handlers/handlers.logic\";\nexport var getControls = function (contextInstance) {\n    return {\n        instance: contextInstance,\n        zoomIn: zoomIn(contextInstance),\n        zoomOut: zoomOut(contextInstance),\n        setTransform: setTransform(contextInstance),\n        resetTransform: resetTransform(contextInstance),\n        centerView: centerView(contextInstance),\n        zoomToElement: zoomToElement(contextInstance),\n    };\n};\nexport var getState = function (contextInstance) {\n    return {\n        instance: contextInstance,\n        state: contextInstance.transformState,\n    };\n};\nexport var getContext = function (contextInstance) {\n    var ref = {};\n    Object.assign(ref, getState(contextInstance));\n    Object.assign(ref, getControls(contextInstance));\n    return ref;\n};\n","// We want to make event listeners non-passive, and to do so have to check\n// that browsers support EventListenerOptions in the first place.\n// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support\nvar passiveSupported = false;\nexport function makePassiveEventOption() {\n    try {\n        var options = {\n            get passive() {\n                // This function will be called when the browser\n                //   attempts to access the passive property.\n                passiveSupported = true;\n                return false;\n            },\n        };\n        return options;\n    }\n    catch (err) {\n        passiveSupported = false;\n        return passiveSupported;\n    }\n}\n","export var isExcludedNode = function (node, excluded) {\n    var targetTagName = node.tagName.toUpperCase();\n    var isExcludedTag = excluded.find(function (tag) { return tag.toUpperCase() === targetTagName; });\n    if (isExcludedTag)\n        return true;\n    var isExcludedClassName = excluded.find(function (className) {\n        return node.classList.contains(className);\n    });\n    if (isExcludedClassName)\n        return true;\n    return false;\n};\nexport var cancelTimeout = function (timeout) {\n    if (timeout) {\n        clearTimeout(timeout);\n    }\n};\n","export var getTransformStyles = function (x, y, scale) {\n    // Standard translate prevents blurry svg on the safari\n    return \"translate(\".concat(x, \"px, \").concat(y, \"px) scale(\").concat(scale, \")\");\n};\nexport var getMatrixTransformStyles = function (x, y, scale) {\n    // The shorthand for matrix does not work for Safari hence the need to explicitly use matrix3d\n    // Refer to https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/matrix\n    var a = scale;\n    var b = 0;\n    var c = 0;\n    var d = scale;\n    var tx = x;\n    var ty = y;\n    return \"matrix3d(\".concat(a, \", \").concat(b, \", 0, 0, \").concat(c, \", \").concat(d, \", 0, 0, 0, 0, 1, 0, \").concat(tx, \", \").concat(ty, \", 0, 1)\");\n};\nexport var getCenterPosition = function (scale, wrapperComponent, contentComponent) {\n    var contentWidth = contentComponent.offsetWidth * scale;\n    var contentHeight = contentComponent.offsetHeight * scale;\n    var centerPositionX = (wrapperComponent.offsetWidth - contentWidth) / 2;\n    var centerPositionY = (wrapperComponent.offsetHeight - contentHeight) / 2;\n    return {\n        scale: scale,\n        positionX: centerPositionX,\n        positionY: centerPositionY,\n    };\n};\n","import { checkIsNumber, isExcludedNode, roundNumber } from \"../../utils\";\nimport { checkZoomBounds } from \"../zoom/zoom.utils\";\nexport var isWheelAllowed = function (contextInstance, event) {\n    var _a = contextInstance.setup.wheel, disabled = _a.disabled, wheelDisabled = _a.wheelDisabled, touchPadDisabled = _a.touchPadDisabled, excluded = _a.excluded;\n    var isInitialized = contextInstance.isInitialized, isPanning = contextInstance.isPanning;\n    var target = event.target;\n    var isAllowed = isInitialized && !isPanning && !disabled && target;\n    if (!isAllowed)\n        return false;\n    // Event ctrlKey detects if touchpad action is executing wheel or pinch gesture\n    if (wheelDisabled && !event.ctrlKey)\n        return false;\n    if (touchPadDisabled && event.ctrlKey)\n        return false;\n    var isExcluded = isExcludedNode(target, excluded);\n    if (isExcluded)\n        return false;\n    return true;\n};\nexport var getDeltaY = function (event) {\n    if (event) {\n        return event.deltaY < 0 ? 1 : -1;\n    }\n    return 0;\n};\nexport function getDelta(event, customDelta) {\n    var deltaY = getDeltaY(event);\n    var delta = checkIsNumber(customDelta, deltaY);\n    return delta;\n}\nexport function getMousePosition(event, contentComponent, scale) {\n    var contentRect = contentComponent.getBoundingClientRect();\n    var mouseX = 0;\n    var mouseY = 0;\n    if (\"clientX\" in event) {\n        // mouse position x, y over wrapper component\n        mouseX = (event.clientX - contentRect.left) / scale;\n        mouseY = (event.clientY - contentRect.top) / scale;\n    }\n    else {\n        var touch = event.touches[0];\n        mouseX = (touch.clientX - contentRect.left) / scale;\n        mouseY = (touch.clientY - contentRect.top) / scale;\n    }\n    if (Number.isNaN(mouseX) || Number.isNaN(mouseY))\n        console.error(\"No mouse or touch offset found\");\n    return {\n        x: mouseX,\n        y: mouseY,\n    };\n}\nexport var handleCalculateWheelZoom = function (contextInstance, delta, step, disable, getTarget) {\n    var scale = contextInstance.transformState.scale;\n    var wrapperComponent = contextInstance.wrapperComponent, setup = contextInstance.setup;\n    var maxScale = setup.maxScale, minScale = setup.minScale, zoomAnimation = setup.zoomAnimation, disablePadding = setup.disablePadding;\n    var size = zoomAnimation.size, disabled = zoomAnimation.disabled;\n    if (!wrapperComponent) {\n        throw new Error(\"Wrapper is not mounted\");\n    }\n    var targetScale = scale + delta * step;\n    if (getTarget)\n        return targetScale;\n    var paddingEnabled = disable ? false : !disabled;\n    var newScale = checkZoomBounds(roundNumber(targetScale, 3), minScale, maxScale, size, paddingEnabled && !disablePadding);\n    return newScale;\n};\nexport var handleWheelZoomStop = function (contextInstance, event) {\n    var previousWheelEvent = contextInstance.previousWheelEvent;\n    var scale = contextInstance.transformState.scale;\n    var _a = contextInstance.setup, maxScale = _a.maxScale, minScale = _a.minScale;\n    if (!previousWheelEvent)\n        return false;\n    if (scale < maxScale || scale > minScale)\n        return true;\n    if (Math.sign(previousWheelEvent.deltaY) !== Math.sign(event.deltaY))\n        return true;\n    if (previousWheelEvent.deltaY > 0 && previousWheelEvent.deltaY < event.deltaY)\n        return true;\n    if (previousWheelEvent.deltaY < 0 && previousWheelEvent.deltaY > event.deltaY)\n        return true;\n    if (Math.sign(previousWheelEvent.deltaY) !== Math.sign(event.deltaY))\n        return true;\n    return false;\n};\n","import { isExcludedNode, roundNumber } from \"../../utils\";\nimport { checkZoomBounds } from \"../zoom/zoom.utils\";\nexport var isPinchStartAllowed = function (contextInstance, event) {\n    var _a = contextInstance.setup.pinch, disabled = _a.disabled, excluded = _a.excluded;\n    var isInitialized = contextInstance.isInitialized;\n    var target = event.target;\n    var isAllowed = isInitialized && !disabled && target;\n    if (!isAllowed)\n        return false;\n    var isExcluded = isExcludedNode(target, excluded);\n    if (isExcluded)\n        return false;\n    return true;\n};\nexport var isPinchAllowed = function (contextInstance) {\n    var disabled = contextInstance.setup.pinch.disabled;\n    var isInitialized = contextInstance.isInitialized, pinchStartDistance = contextInstance.pinchStartDistance;\n    var isAllowed = isInitialized && !disabled && pinchStartDistance;\n    if (!isAllowed)\n        return false;\n    return true;\n};\nexport var calculateTouchMidPoint = function (event, scale, contentComponent) {\n    var contentRect = contentComponent.getBoundingClientRect();\n    var touches = event.touches;\n    var firstPointX = roundNumber(touches[0].clientX - contentRect.left, 5);\n    var firstPointY = roundNumber(touches[0].clientY - contentRect.top, 5);\n    var secondPointX = roundNumber(touches[1].clientX - contentRect.left, 5);\n    var secondPointY = roundNumber(touches[1].clientY - contentRect.top, 5);\n    return {\n        x: (firstPointX + secondPointX) / 2 / scale,\n        y: (firstPointY + secondPointY) / 2 / scale,\n    };\n};\nexport var getTouchDistance = function (event) {\n    return Math.sqrt(Math.pow((event.touches[0].pageX - event.touches[1].pageX), 2) +\n        Math.pow((event.touches[0].pageY - event.touches[1].pageY), 2));\n};\nexport var calculatePinchZoom = function (contextInstance, currentDistance) {\n    var pinchStartScale = contextInstance.pinchStartScale, pinchStartDistance = contextInstance.pinchStartDistance, setup = contextInstance.setup;\n    var maxScale = setup.maxScale, minScale = setup.minScale, zoomAnimation = setup.zoomAnimation, disablePadding = setup.disablePadding;\n    var size = zoomAnimation.size, disabled = zoomAnimation.disabled;\n    if (!pinchStartScale || pinchStartDistance === null || !currentDistance) {\n        throw new Error(\"Pinch touches distance was not provided\");\n    }\n    if (currentDistance < 0) {\n        return contextInstance.transformState.scale;\n    }\n    var touchProportion = currentDistance / pinchStartDistance;\n    var scaleDifference = touchProportion * pinchStartScale;\n    return checkZoomBounds(roundNumber(scaleDifference, 2), minScale, maxScale, size, !disabled && !disablePadding);\n};\n","import { handleCallback } from \"../../utils/callback.utils\";\nimport { getContext } from \"../../utils/context.utils\";\nimport { cancelTimeout } from \"../../utils/helpers.utils\";\nimport { handleCancelAnimation } from \"../animations/animations.utils\";\nimport { handleCalculateBounds } from \"../bounds/bounds.utils\";\nimport { getDelta, handleCalculateWheelZoom, handleWheelZoomStop, getMousePosition, } from \"./wheel.utils\";\nimport { handleAlignToScaleBounds } from \"../zoom/zoom.logic\";\nimport { handleCalculateZoomPositions } from \"../zoom/zoom.utils\";\nvar wheelStopEventTime = 160;\nvar wheelAnimationTime = 100;\nexport var handleWheelStart = function (contextInstance, event) {\n    var _a = contextInstance.props, onWheelStart = _a.onWheelStart, onZoomStart = _a.onZoomStart;\n    if (!contextInstance.wheelStopEventTimer) {\n        handleCancelAnimation(contextInstance);\n        handleCallback(getContext(contextInstance), event, onWheelStart);\n        handleCallback(getContext(contextInstance), event, onZoomStart);\n    }\n};\nexport var handleWheelZoom = function (contextInstance, event) {\n    var _a = contextInstance.props, onWheel = _a.onWheel, onZoom = _a.onZoom;\n    var contentComponent = contextInstance.contentComponent, setup = contextInstance.setup, transformState = contextInstance.transformState;\n    var scale = transformState.scale;\n    var limitToBounds = setup.limitToBounds, centerZoomedOut = setup.centerZoomedOut, zoomAnimation = setup.zoomAnimation, wheel = setup.wheel, disablePadding = setup.disablePadding, smooth = setup.smooth;\n    var size = zoomAnimation.size, disabled = zoomAnimation.disabled;\n    var step = wheel.step, smoothStep = wheel.smoothStep;\n    if (!contentComponent) {\n        throw new Error(\"Component not mounted\");\n    }\n    event.preventDefault();\n    event.stopPropagation();\n    var delta = getDelta(event, null);\n    var zoomStep = smooth ? smoothStep * Math.abs(event.deltaY) : step;\n    var newScale = handleCalculateWheelZoom(contextInstance, delta, zoomStep, !event.ctrlKey);\n    // if scale not change\n    if (scale === newScale)\n        return;\n    var bounds = handleCalculateBounds(contextInstance, newScale);\n    var mousePosition = getMousePosition(event, contentComponent, scale);\n    var isPaddingDisabled = disabled || size === 0 || centerZoomedOut || disablePadding;\n    var isLimitedToBounds = limitToBounds && isPaddingDisabled;\n    var _b = handleCalculateZoomPositions(contextInstance, mousePosition.x, mousePosition.y, newScale, bounds, isLimitedToBounds), x = _b.x, y = _b.y;\n    contextInstance.previousWheelEvent = event;\n    contextInstance.setTransformState(newScale, x, y);\n    handleCallback(getContext(contextInstance), event, onWheel);\n    handleCallback(getContext(contextInstance), event, onZoom);\n};\nexport var handleWheelStop = function (contextInstance, event) {\n    var _a = contextInstance.props, onWheelStop = _a.onWheelStop, onZoomStop = _a.onZoomStop;\n    // fire animation\n    cancelTimeout(contextInstance.wheelAnimationTimer);\n    contextInstance.wheelAnimationTimer = setTimeout(function () {\n        if (!contextInstance.mounted)\n            return;\n        handleAlignToScaleBounds(contextInstance, event.x, event.y);\n        contextInstance.wheelAnimationTimer = null;\n    }, wheelAnimationTime);\n    // Wheel stop event\n    var hasStoppedZooming = handleWheelZoomStop(contextInstance, event);\n    if (hasStoppedZooming) {\n        cancelTimeout(contextInstance.wheelStopEventTimer);\n        contextInstance.wheelStopEventTimer = setTimeout(function () {\n            if (!contextInstance.mounted)\n                return;\n            contextInstance.wheelStopEventTimer = null;\n            handleCallback(getContext(contextInstance), event, onWheelStop);\n            handleCallback(getContext(contextInstance), event, onZoomStop);\n        }, wheelStopEventTime);\n    }\n};\n","import { handleCancelAnimation } from \"../animations/animations.utils\";\nimport { handleAlignToScaleBounds } from \"../zoom/zoom.logic\";\nimport { calculatePinchZoom, calculateTouchMidPoint, getTouchDistance, } from \"./pinch.utils\";\nimport { handleCalculateBounds } from \"../bounds/bounds.utils\";\nimport { handleCalculateZoomPositions } from \"../zoom/zoom.utils\";\nexport var handlePinchStart = function (contextInstance, event) {\n    var distance = getTouchDistance(event);\n    contextInstance.pinchStartDistance = distance;\n    contextInstance.lastDistance = distance;\n    contextInstance.pinchStartScale = contextInstance.transformState.scale;\n    contextInstance.isPanning = false;\n    handleCancelAnimation(contextInstance);\n};\nexport var handlePinchZoom = function (contextInstance, event) {\n    var contentComponent = contextInstance.contentComponent, pinchStartDistance = contextInstance.pinchStartDistance;\n    var scale = contextInstance.transformState.scale;\n    var _a = contextInstance.setup, limitToBounds = _a.limitToBounds, centerZoomedOut = _a.centerZoomedOut, zoomAnimation = _a.zoomAnimation;\n    var disabled = zoomAnimation.disabled, size = zoomAnimation.size;\n    // if one finger starts from outside of wrapper\n    if (pinchStartDistance === null || !contentComponent)\n        return;\n    var midPoint = calculateTouchMidPoint(event, scale, contentComponent);\n    // if touches goes off of the wrapper element\n    if (!Number.isFinite(midPoint.x) || !Number.isFinite(midPoint.y))\n        return;\n    var currentDistance = getTouchDistance(event);\n    var newScale = calculatePinchZoom(contextInstance, currentDistance);\n    if (newScale === scale)\n        return;\n    var bounds = handleCalculateBounds(contextInstance, newScale);\n    var isPaddingDisabled = disabled || size === 0 || centerZoomedOut;\n    var isLimitedToBounds = limitToBounds && isPaddingDisabled;\n    var _b = handleCalculateZoomPositions(contextInstance, midPoint.x, midPoint.y, newScale, bounds, isLimitedToBounds), x = _b.x, y = _b.y;\n    contextInstance.pinchMidpoint = midPoint;\n    contextInstance.lastDistance = currentDistance;\n    contextInstance.setTransformState(newScale, x, y);\n};\nexport var handlePinchStop = function (contextInstance) {\n    var pinchMidpoint = contextInstance.pinchMidpoint;\n    contextInstance.velocity = null;\n    contextInstance.lastDistance = null;\n    contextInstance.pinchMidpoint = null;\n    contextInstance.pinchStartScale = null;\n    contextInstance.pinchStartDistance = null;\n    handleAlignToScaleBounds(contextInstance, pinchMidpoint === null || pinchMidpoint === void 0 ? void 0 : pinchMidpoint.x, pinchMidpoint === null || pinchMidpoint === void 0 ? void 0 : pinchMidpoint.y);\n};\n","import { animate } from \"../animations/animations.utils\";\nimport { getMousePosition } from \"../wheel/wheel.utils\";\nimport { handleZoomToPoint } from \"../zoom/zoom.logic\";\nimport { cancelTimeout, getContext, handleCallback, isExcludedNode, } from \"../../utils\";\nimport { handleCalculateButtonZoom, resetTransformations, } from \"../handlers/handlers.utils\";\nexport var handleDoubleClickStop = function (contextInstance, event) {\n    var onZoomStop = contextInstance.props.onZoomStop;\n    var animationTime = contextInstance.setup.doubleClick.animationTime;\n    cancelTimeout(contextInstance.doubleClickStopEventTimer);\n    contextInstance.doubleClickStopEventTimer = setTimeout(function () {\n        contextInstance.doubleClickStopEventTimer = null;\n        handleCallback(getContext(contextInstance), event, onZoomStop);\n    }, animationTime);\n};\nexport var handleDoubleClickResetMode = function (contextInstance, event) {\n    var _a = contextInstance.props, onZoomStart = _a.onZoomStart, onZoom = _a.onZoom;\n    var _b = contextInstance.setup.doubleClick, animationTime = _b.animationTime, animationType = _b.animationType;\n    handleCallback(getContext(contextInstance), event, onZoomStart);\n    resetTransformations(contextInstance, animationTime, animationType, function () {\n        return handleCallback(getContext(contextInstance), event, onZoom);\n    });\n    handleDoubleClickStop(contextInstance, event);\n};\nexport function handleDoubleClick(contextInstance, event) {\n    var setup = contextInstance.setup, doubleClickStopEventTimer = contextInstance.doubleClickStopEventTimer, transformState = contextInstance.transformState, contentComponent = contextInstance.contentComponent;\n    var scale = transformState.scale;\n    var _a = contextInstance.props, onZoomStart = _a.onZoomStart, onZoom = _a.onZoom;\n    var _b = setup.doubleClick, disabled = _b.disabled, mode = _b.mode, step = _b.step, animationTime = _b.animationTime, animationType = _b.animationType;\n    if (disabled)\n        return;\n    if (doubleClickStopEventTimer)\n        return;\n    if (mode === \"reset\") {\n        return handleDoubleClickResetMode(contextInstance, event);\n    }\n    if (!contentComponent)\n        return console.error(\"No ContentComponent found\");\n    var delta = mode === \"zoomOut\" ? -1 : 1;\n    var newScale = handleCalculateButtonZoom(contextInstance, delta, step);\n    // stop execution when scale didn't change\n    if (scale === newScale)\n        return;\n    handleCallback(getContext(contextInstance), event, onZoomStart);\n    var mousePosition = getMousePosition(event, contentComponent, scale);\n    var targetState = handleZoomToPoint(contextInstance, newScale, mousePosition.x, mousePosition.y);\n    if (!targetState) {\n        return console.error(\"Error during zoom event. New transformation state was not calculated.\");\n    }\n    handleCallback(getContext(contextInstance), event, onZoom);\n    animate(contextInstance, targetState, animationTime, animationType);\n    handleDoubleClickStop(contextInstance, event);\n}\nexport var isDoubleClickAllowed = function (contextInstance, event) {\n    var isInitialized = contextInstance.isInitialized, setup = contextInstance.setup, wrapperComponent = contextInstance.wrapperComponent;\n    var _a = setup.doubleClick, disabled = _a.disabled, excluded = _a.excluded;\n    var target = event.target;\n    var isWrapperChild = wrapperComponent === null || wrapperComponent === void 0 ? void 0 : wrapperComponent.contains(target);\n    var isAllowed = isInitialized && target && isWrapperChild && !disabled;\n    if (!isAllowed)\n        return false;\n    var isExcluded = isExcludedNode(target, excluded);\n    if (isExcluded)\n        return false;\n    return true;\n};\n","import { getContext, createSetup, createState, handleCallback, getTransformStyles, makePassiveEventOption, getCenterPosition, } from \"../utils\";\nimport { handleCancelAnimation } from \"./animations/animations.utils\";\nimport { isWheelAllowed } from \"./wheel/wheel.utils\";\nimport { isPinchAllowed, isPinchStartAllowed } from \"./pinch/pinch.utils\";\nimport { handleCalculateBounds } from \"./bounds/bounds.utils\";\nimport { handleWheelStart, handleWheelZoom, handleWheelStop, } from \"./wheel/wheel.logic\";\nimport { isPanningAllowed, isPanningStartAllowed } from \"./pan/panning.utils\";\nimport { handlePanning, handlePanningEnd, handlePanningStart, } from \"./pan/panning.logic\";\nimport { handlePinchStart, handlePinchStop, handlePinchZoom, } from \"./pinch/pinch.logic\";\nimport { handleDoubleClick, isDoubleClickAllowed, } from \"./double-click/double-click.logic\";\nvar ZoomPanPinch = /** @class */ (function () {\n    function ZoomPanPinch(props) {\n        var _this = this;\n        this.mounted = true;\n        this.onChangeCallbacks = new Set();\n        this.onInitCallbacks = new Set();\n        // Components\n        this.wrapperComponent = null;\n        this.contentComponent = null;\n        // Initialization\n        this.isInitialized = false;\n        this.bounds = null;\n        // wheel helpers\n        this.previousWheelEvent = null;\n        this.wheelStopEventTimer = null;\n        this.wheelAnimationTimer = null;\n        // panning helpers\n        this.isPanning = false;\n        this.startCoords = null;\n        this.lastTouch = null;\n        // pinch helpers\n        this.distance = null;\n        this.lastDistance = null;\n        this.pinchStartDistance = null;\n        this.pinchStartScale = null;\n        this.pinchMidpoint = null;\n        // double click helpers\n        this.doubleClickStopEventTimer = null;\n        // velocity helpers\n        this.velocity = null;\n        this.velocityTime = null;\n        this.lastMousePosition = null;\n        // animations helpers\n        this.animate = false;\n        this.animation = null;\n        this.maxBounds = null;\n        // key press\n        this.pressedKeys = {};\n        this.mount = function () {\n            _this.initializeWindowEvents();\n        };\n        this.unmount = function () {\n            _this.cleanupWindowEvents();\n        };\n        this.update = function (newProps) {\n            handleCalculateBounds(_this, _this.transformState.scale);\n            _this.setup = createSetup(newProps);\n        };\n        this.initializeWindowEvents = function () {\n            var _a;\n            var passive = makePassiveEventOption();\n            var currentDocument = (_a = _this.wrapperComponent) === null || _a === void 0 ? void 0 : _a.ownerDocument;\n            var currentWindow = currentDocument === null || currentDocument === void 0 ? void 0 : currentDocument.defaultView;\n            // Panning on window to allow panning when mouse is out of component wrapper\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.addEventListener(\"mousedown\", _this.onPanningStart, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.addEventListener(\"mousemove\", _this.onPanning, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.addEventListener(\"mouseup\", _this.onPanningStop, passive);\n            currentDocument === null || currentDocument === void 0 ? void 0 : currentDocument.addEventListener(\"mouseleave\", _this.clearPanning, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.addEventListener(\"keyup\", _this.setKeyUnPressed, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.addEventListener(\"keydown\", _this.setKeyPressed, passive);\n        };\n        this.cleanupWindowEvents = function () {\n            var _a, _b;\n            var passive = makePassiveEventOption();\n            var currentDocument = (_a = _this.wrapperComponent) === null || _a === void 0 ? void 0 : _a.ownerDocument;\n            var currentWindow = currentDocument === null || currentDocument === void 0 ? void 0 : currentDocument.defaultView;\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.removeEventListener(\"mousedown\", _this.onPanningStart, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.removeEventListener(\"mousemove\", _this.onPanning, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.removeEventListener(\"mouseup\", _this.onPanningStop, passive);\n            currentDocument === null || currentDocument === void 0 ? void 0 : currentDocument.removeEventListener(\"mouseleave\", _this.clearPanning, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.removeEventListener(\"keyup\", _this.setKeyUnPressed, passive);\n            currentWindow === null || currentWindow === void 0 ? void 0 : currentWindow.removeEventListener(\"keydown\", _this.setKeyPressed, passive);\n            document.removeEventListener(\"mouseleave\", _this.clearPanning, passive);\n            handleCancelAnimation(_this);\n            (_b = _this.observer) === null || _b === void 0 ? void 0 : _b.disconnect();\n        };\n        this.handleInitializeWrapperEvents = function (wrapper) {\n            // Zooming events on wrapper\n            var passive = makePassiveEventOption();\n            wrapper.addEventListener(\"wheel\", _this.onWheelZoom, passive);\n            wrapper.addEventListener(\"dblclick\", _this.onDoubleClick, passive);\n            wrapper.addEventListener(\"touchstart\", _this.onTouchPanningStart, passive);\n            wrapper.addEventListener(\"touchmove\", _this.onTouchPanning, passive);\n            wrapper.addEventListener(\"touchend\", _this.onTouchPanningStop, passive);\n        };\n        this.handleInitialize = function (contentComponent) {\n            var centerOnInit = _this.setup.centerOnInit;\n            _this.applyTransformation();\n            _this.onInitCallbacks.forEach(function (callback) { return callback(getContext(_this)); });\n            if (centerOnInit) {\n                _this.setCenter();\n                _this.observer = new ResizeObserver(function () {\n                    var _a;\n                    _this.onInitCallbacks.forEach(function (callback) { return callback(getContext(_this)); });\n                    _this.setCenter();\n                    (_a = _this.observer) === null || _a === void 0 ? void 0 : _a.disconnect();\n                });\n                // Start observing the target node for configured mutations\n                _this.observer.observe(contentComponent);\n            }\n        };\n        /// ///////\n        // Zoom\n        /// ///////\n        this.onWheelZoom = function (event) {\n            var disabled = _this.setup.disabled;\n            if (disabled)\n                return;\n            var isAllowed = isWheelAllowed(_this, event);\n            if (!isAllowed)\n                return;\n            var keysPressed = _this.isPressingKeys(_this.setup.wheel.activationKeys);\n            if (!keysPressed)\n                return;\n            handleWheelStart(_this, event);\n            handleWheelZoom(_this, event);\n            handleWheelStop(_this, event);\n        };\n        /// ///////\n        // Pan\n        /// ///////\n        this.onPanningStart = function (event) {\n            var disabled = _this.setup.disabled;\n            var onPanningStart = _this.props.onPanningStart;\n            if (disabled)\n                return;\n            var isAllowed = isPanningStartAllowed(_this, event);\n            if (!isAllowed)\n                return;\n            var keysPressed = _this.isPressingKeys(_this.setup.panning.activationKeys);\n            if (!keysPressed)\n                return;\n            if (event.button === 0 && !_this.setup.panning.allowLeftClickPan)\n                return;\n            if (event.button === 1 && !_this.setup.panning.allowMiddleClickPan)\n                return;\n            if (event.button === 2 && !_this.setup.panning.allowRightClickPan)\n                return;\n            event.preventDefault();\n            event.stopPropagation();\n            handleCancelAnimation(_this);\n            handlePanningStart(_this, event);\n            handleCallback(getContext(_this), event, onPanningStart);\n        };\n        this.onPanning = function (event) {\n            var disabled = _this.setup.disabled;\n            var onPanning = _this.props.onPanning;\n            if (disabled)\n                return;\n            var isAllowed = isPanningAllowed(_this);\n            if (!isAllowed)\n                return;\n            var keysPressed = _this.isPressingKeys(_this.setup.panning.activationKeys);\n            if (!keysPressed)\n                return;\n            event.preventDefault();\n            event.stopPropagation();\n            handlePanning(_this, event.clientX, event.clientY);\n            handleCallback(getContext(_this), event, onPanning);\n        };\n        this.onPanningStop = function (event) {\n            var onPanningStop = _this.props.onPanningStop;\n            if (_this.isPanning) {\n                handlePanningEnd(_this);\n                handleCallback(getContext(_this), event, onPanningStop);\n            }\n        };\n        /// ///////\n        // Pinch\n        /// ///////\n        this.onPinchStart = function (event) {\n            var disabled = _this.setup.disabled;\n            var _a = _this.props, onPinchingStart = _a.onPinchingStart, onZoomStart = _a.onZoomStart;\n            if (disabled)\n                return;\n            var isAllowed = isPinchStartAllowed(_this, event);\n            if (!isAllowed)\n                return;\n            handlePinchStart(_this, event);\n            handleCancelAnimation(_this);\n            handleCallback(getContext(_this), event, onPinchingStart);\n            handleCallback(getContext(_this), event, onZoomStart);\n        };\n        this.onPinch = function (event) {\n            var disabled = _this.setup.disabled;\n            var _a = _this.props, onPinching = _a.onPinching, onZoom = _a.onZoom;\n            if (disabled)\n                return;\n            var isAllowed = isPinchAllowed(_this);\n            if (!isAllowed)\n                return;\n            event.preventDefault();\n            event.stopPropagation();\n            handlePinchZoom(_this, event);\n            handleCallback(getContext(_this), event, onPinching);\n            handleCallback(getContext(_this), event, onZoom);\n        };\n        this.onPinchStop = function (event) {\n            var _a = _this.props, onPinchingStop = _a.onPinchingStop, onZoomStop = _a.onZoomStop;\n            if (_this.pinchStartScale) {\n                handlePinchStop(_this);\n                handleCallback(getContext(_this), event, onPinchingStop);\n                handleCallback(getContext(_this), event, onZoomStop);\n            }\n        };\n        /// ///////\n        // Touch\n        /// ///////\n        this.onTouchPanningStart = function (event) {\n            var disabled = _this.setup.disabled;\n            var onPanningStart = _this.props.onPanningStart;\n            if (disabled)\n                return;\n            var isAllowed = isPanningStartAllowed(_this, event);\n            if (!isAllowed)\n                return;\n            var isDoubleTap = _this.lastTouch && +new Date() - _this.lastTouch < 200;\n            if (isDoubleTap && event.touches.length === 1) {\n                _this.onDoubleClick(event);\n            }\n            else {\n                _this.lastTouch = +new Date();\n                handleCancelAnimation(_this);\n                var touches = event.touches;\n                var isPanningAction = touches.length === 1;\n                var isPinchAction = touches.length === 2;\n                if (isPanningAction) {\n                    handleCancelAnimation(_this);\n                    handlePanningStart(_this, event);\n                    handleCallback(getContext(_this), event, onPanningStart);\n                }\n                if (isPinchAction) {\n                    _this.onPinchStart(event);\n                }\n            }\n        };\n        this.onTouchPanning = function (event) {\n            var disabled = _this.setup.disabled;\n            var onPanning = _this.props.onPanning;\n            if (_this.isPanning && event.touches.length === 1) {\n                if (disabled)\n                    return;\n                var isAllowed = isPanningAllowed(_this);\n                if (!isAllowed)\n                    return;\n                event.preventDefault();\n                event.stopPropagation();\n                var touch = event.touches[0];\n                handlePanning(_this, touch.clientX, touch.clientY);\n                handleCallback(getContext(_this), event, onPanning);\n            }\n            else if (event.touches.length > 1) {\n                _this.onPinch(event);\n            }\n        };\n        this.onTouchPanningStop = function (event) {\n            _this.onPanningStop(event);\n            _this.onPinchStop(event);\n        };\n        /// ///////\n        // Double Click\n        /// ///////\n        this.onDoubleClick = function (event) {\n            var disabled = _this.setup.disabled;\n            if (disabled)\n                return;\n            var isAllowed = isDoubleClickAllowed(_this, event);\n            if (!isAllowed)\n                return;\n            handleDoubleClick(_this, event);\n        };\n        /// ///////\n        // Helpers\n        /// ///////\n        this.clearPanning = function (event) {\n            if (_this.isPanning) {\n                _this.onPanningStop(event);\n            }\n        };\n        this.setKeyPressed = function (e) {\n            _this.pressedKeys[e.key] = true;\n        };\n        this.setKeyUnPressed = function (e) {\n            _this.pressedKeys[e.key] = false;\n        };\n        this.isPressingKeys = function (keys) {\n            if (!keys.length) {\n                return true;\n            }\n            return Boolean(keys.find(function (key) { return _this.pressedKeys[key]; }));\n        };\n        this.setTransformState = function (scale, positionX, positionY) {\n            var onTransformed = _this.props.onTransformed;\n            if (!Number.isNaN(scale) &&\n                !Number.isNaN(positionX) &&\n                !Number.isNaN(positionY)) {\n                if (scale !== _this.transformState.scale) {\n                    _this.transformState.previousScale = _this.transformState.scale;\n                    _this.transformState.scale = scale;\n                }\n                _this.transformState.positionX = positionX;\n                _this.transformState.positionY = positionY;\n                _this.applyTransformation();\n                var ctx_1 = getContext(_this);\n                _this.onChangeCallbacks.forEach(function (callback) { return callback(ctx_1); });\n                handleCallback(ctx_1, { scale: scale, positionX: positionX, positionY: positionY }, onTransformed);\n            }\n            else {\n                console.error(\"Detected NaN set state values\");\n            }\n        };\n        this.setCenter = function () {\n            if (_this.wrapperComponent && _this.contentComponent) {\n                var targetState = getCenterPosition(_this.transformState.scale, _this.wrapperComponent, _this.contentComponent);\n                _this.setTransformState(targetState.scale, targetState.positionX, targetState.positionY);\n            }\n        };\n        this.handleTransformStyles = function (x, y, scale) {\n            if (_this.props.customTransform) {\n                return _this.props.customTransform(x, y, scale);\n            }\n            return getTransformStyles(x, y, scale);\n        };\n        this.applyTransformation = function () {\n            if (!_this.mounted || !_this.contentComponent)\n                return;\n            var _a = _this.transformState, scale = _a.scale, positionX = _a.positionX, positionY = _a.positionY;\n            var transform = _this.handleTransformStyles(positionX, positionY, scale);\n            _this.contentComponent.style.transform = transform;\n        };\n        this.getContext = function () {\n            return getContext(_this);\n        };\n        /**\n         * Hooks\n         */\n        this.onChange = function (callback) {\n            if (!_this.onChangeCallbacks.has(callback)) {\n                _this.onChangeCallbacks.add(callback);\n            }\n            return function () {\n                _this.onChangeCallbacks.delete(callback);\n            };\n        };\n        this.onInit = function (callback) {\n            if (!_this.onInitCallbacks.has(callback)) {\n                _this.onInitCallbacks.add(callback);\n            }\n            return function () {\n                _this.onInitCallbacks.delete(callback);\n            };\n        };\n        /**\n         * Initialization\n         */\n        this.init = function (wrapperComponent, contentComponent) {\n            _this.cleanupWindowEvents();\n            _this.wrapperComponent = wrapperComponent;\n            _this.contentComponent = contentComponent;\n            handleCalculateBounds(_this, _this.transformState.scale);\n            _this.handleInitializeWrapperEvents(wrapperComponent);\n            _this.handleInitialize(contentComponent);\n            _this.initializeWindowEvents();\n            _this.isInitialized = true;\n            var ctx = getContext(_this);\n            handleCallback(ctx, undefined, _this.props.onInit);\n        };\n        this.props = props;\n        this.setup = createSetup(this.props);\n        this.transformState = createState(this.props);\n    }\n    return ZoomPanPinch;\n}());\nexport { ZoomPanPinch };\n","import React, { useEffect, useImperativeHandle, useRef } from \"react\";\nimport { ZoomPanPinch } from \"../../core/instance.core\";\nimport { getControls } from \"../../utils\";\nexport var Context = React.createContext(null);\nvar getContent = function (children, ctx) {\n    if (typeof children === \"function\") {\n        return children(ctx);\n    }\n    return children;\n};\nexport var TransformWrapper = React.forwardRef(function (props, ref) {\n    var instance = useRef(new ZoomPanPinch(props)).current;\n    var content = getContent(props.children, getControls(instance));\n    useImperativeHandle(ref, function () { return getControls(instance); }, [instance]);\n    useEffect(function () {\n        instance.update(props);\n    }, [instance, props]);\n    return React.createElement(Context.Provider, { value: instance }, content);\n});\n","import { __assign } from \"tslib\";\nimport React, { useContext, useEffect, useRef } from \"react\";\nimport { mergeRefs } from \"utils/ref.utils\";\nimport { Context } from \"../transform-wrapper/transform-wrapper\";\nexport var KeepScale = React.forwardRef(function (props, ref) {\n    var localRef = useRef(null);\n    var instance = useContext(Context);\n    useEffect(function () {\n        return instance.onChange(function (ctx) {\n            if (localRef.current) {\n                var positionX = 0;\n                var positionY = 0;\n                localRef.current.style.transform = instance.handleTransformStyles(positionX, positionY, 1 / ctx.instance.transformState.scale);\n            }\n        });\n    }, [instance]);\n    return React.createElement(\"div\", __assign({}, props, { ref: mergeRefs([localRef, ref]) }));\n});\n","export function mergeRefs(refs) {\n    return function (value) {\n        refs.forEach(function (ref) {\n            if (typeof ref === \"function\") {\n                ref(value);\n            }\n            else if (ref != null) {\n                ref.current = value;\n            }\n        });\n    };\n}\n","function styleInject(css, ref) {\n  if ( ref === void 0 ) ref = {};\n  var insertAt = ref.insertAt;\n\n  if (!css || typeof document === 'undefined') { return; }\n\n  var head = document.head || document.getElementsByTagName('head')[0];\n  var style = document.createElement('style');\n  style.type = 'text/css';\n\n  if (insertAt === 'top') {\n    if (head.firstChild) {\n      head.insertBefore(style, head.firstChild);\n    } else {\n      head.appendChild(style);\n    }\n  } else {\n    head.appendChild(style);\n  }\n\n  if (style.styleSheet) {\n    style.styleSheet.cssText = css;\n  } else {\n    style.appendChild(document.createTextNode(css));\n  }\n}\n\nexport default styleInject;\n","import { __assign } from \"tslib\";\n/* eslint-disable react/require-default-props */\nimport React, { useContext, useEffect, useRef } from \"react\";\nimport { Context } from \"../transform-wrapper/transform-wrapper\";\nimport styles from \"./transform-component.module.css\";\nexport var TransformComponent = function (_a) {\n    var children = _a.children, _b = _a.wrapperClass, wrapperClass = _b === void 0 ? \"\" : _b, _c = _a.contentClass, contentClass = _c === void 0 ? \"\" : _c, wrapperStyle = _a.wrapperStyle, contentStyle = _a.contentStyle, _d = _a.wrapperProps, wrapperProps = _d === void 0 ? {} : _d, _e = _a.contentProps, contentProps = _e === void 0 ? {} : _e;\n    var _f = useContext(Context), init = _f.init, cleanupWindowEvents = _f.cleanupWindowEvents;\n    var wrapperRef = useRef(null);\n    var contentRef = useRef(null);\n    useEffect(function () {\n        var wrapper = wrapperRef.current;\n        var content = contentRef.current;\n        if (wrapper !== null && content !== null && init) {\n            init === null || init === void 0 ? void 0 : init(wrapper, content);\n        }\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        return function () {\n            cleanupWindowEvents === null || cleanupWindowEvents === void 0 ? void 0 : cleanupWindowEvents();\n        };\n    }, []);\n    return (React.createElement(\"div\", __assign({}, wrapperProps, { ref: wrapperRef, className: \"react-transform-wrapper \".concat(styles.wrapper, \" \").concat(wrapperClass), style: wrapperStyle }),\n        React.createElement(\"div\", __assign({}, contentProps, { ref: contentRef, className: \"react-transform-component \".concat(styles.content, \" \").concat(contentClass), style: contentStyle }), children)));\n};\n"],"names":["exports","hookCallback","some","hooks","apply","arguments","setHookCallback","callback","isArray","input","Array","Object","prototype","toString","call","isObject","hasOwnProp","a","b","hasOwnProperty","isObjectEmpty","obj","getOwnPropertyNames","length","k","isUndefined","isNumber","isDate","Date","map","arr","fn","i","res","arrLen","push","extend","valueOf","createUTC","format","locale","strict","createLocalOrUTC","utc","defaultParsingFlags","empty","unusedTokens","unusedInput","overflow","charsLeftOver","nullInput","invalidEra","invalidMonth","invalidFormat","userInvalidated","iso","parsedDateParts","era","meridiem","rfc2822","weekdayMismatch","getParsingFlags","m","_pf","isValid","_isValid","flags","parsedParts","isNowValid","isNaN","_d","getTime","invalidWeekday","_strict","undefined","bigHour","isFrozen","createInvalid","NaN","fun","t","this","len","momentProperties","updateInProgress","copyConfig","to","from","prop","val","momentPropertiesLen","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","Moment","config","updateOffset","isMoment","warn","msg","suppressDeprecationWarnings","console","deprecate","firstTime","deprecationHandler","arg","key","args","argLen","slice","join","Error","stack","keys","deprecations","deprecateSimple","name","isFunction","Function","set","_config","_dayOfMonthOrdinalParseLenient","RegExp","_dayOfMonthOrdinalParse","source","_ordinalParse","mergeConfigs","parentConfig","childConfig","Locale","defaultCalendar","sameDay","nextDay","nextWeek","lastDay","lastWeek","sameElse","calendar","mom","now","output","_calendar","zeroFill","number","targetLength","forceSign","absNumber","Math","abs","zerosToFill","pow","max","substr","formattingTokens","localFormattingTokens","formatFunctions","formatTokenFunctions","addFormatToken","token","padded","ordinal","func","localeData","removeFormattingTokens","match","replace","makeFormatFunction","array","formatMoment","expandFormat","invalidDate","replaceLongDateFormatTokens","longDateFormat","lastIndex","test","defaultLongDateFormat","LTS","LT","L","LL","LLL","LLLL","_longDateFormat","formatUpper","toUpperCase","tok","defaultInvalidDate","_invalidDate","defaultOrdinal","defaultDayOfMonthOrdinalParse","_ordinal","defaultRelativeTime","future","past","s","ss","mm","h","hh","d","dd","w","ww","M","MM","y","yy","relativeTime","withoutSuffix","string","isFuture","_relativeTime","pastFuture","diff","aliases","addUnitAlias","unit","shorthand","lowerCase","toLowerCase","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedProp","normalizedInput","priorities","addUnitPriority","priority","getPrioritizedUnits","unitsObj","u","sort","isLeapYear","year","absFloor","ceil","floor","toInt","argumentForCoercion","coercedNumber","value","isFinite","makeGetSet","keepTime","set$1","get","month","date","daysInMonth","stringGet","stringSet","prioritized","prioritizedLen","regexes","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchOffset","matchShortOffset","matchTimestamp","matchWord","addRegexToken","regex","strictRegex","isStrict","getParseRegexForToken","unescapeFormat","regexEscape","matched","p1","p2","p3","p4","tokens","addParseToken","tokenLen","addWeekParseToken","_w","addTimeToArrayFromToken","_a","indexOf","YEAR","MONTH","DATE","HOUR","MINUTE","SECOND","MILLISECOND","WEEK","WEEKDAY","mod","n","x","modMonth","o","monthsShort","months","monthsShortRegex","monthsRegex","monthsParse","defaultLocaleMonths","split","defaultLocaleMonthsShort","MONTHS_IN_FORMAT","defaultMonthsShortRegex","defaultMonthsRegex","localeMonths","_months","isFormat","localeMonthsShort","_monthsShort","handleStrictParse","monthName","ii","llc","toLocaleLowerCase","_monthsParse","_longMonthsParse","_shortMonthsParse","localeMonthsParse","_monthsParseExact","setMonth","dayOfMonth","min","getSetMonth","getDaysInMonth","computeMonthsParse","_monthsShortStrictRegex","_monthsShortRegex","_monthsStrictRegex","_monthsRegex","cmpLenRev","shortPieces","longPieces","mixedPieces","daysInYear","parseTwoDigitYear","parseInt","getSetYear","getIsLeapYear","createDate","ms","getFullYear","setFullYear","createUTCDate","UTC","getUTCFullYear","setUTCFullYear","firstWeekOffset","dow","doy","fwd","getUTCDay","dayOfYearFromWeeks","week","weekday","resYear","resDayOfYear","dayOfYear","weekOfYear","resWeek","weekOffset","weeksInYear","weekOffsetNext","localeWeek","_week","defaultLocaleWeek","localeFirstDayOfWeek","localeFirstDayOfYear","getSetWeek","add","getSetISOWeek","parseWeekday","weekdaysParse","parseIsoWeekday","shiftWeekdays","ws","concat","weekdaysMin","weekdaysShort","weekdays","weekdaysMinRegex","weekdaysShortRegex","weekdaysRegex","defaultLocaleWeekdays","defaultLocaleWeekdaysShort","defaultLocaleWeekdaysMin","defaultWeekdaysRegex","defaultWeekdaysShortRegex","defaultWeekdaysMinRegex","localeWeekdays","_weekdays","day","localeWeekdaysShort","_weekdaysShort","localeWeekdaysMin","_weekdaysMin","handleStrictParse$1","weekdayName","_weekdaysParse","_shortWeekdaysParse","_minWeekdaysParse","localeWeekdaysParse","_weekdaysParseExact","_fullWeekdaysParse","getSetDayOfWeek","getDay","getSetLocaleDayOfWeek","getSetISODayOfWeek","computeWeekdaysParse","_weekdaysStrictRegex","_weekdaysRegex","_weekdaysShortStrictRegex","_weekdaysShortRegex","_weekdaysMinStrictRegex","_weekdaysMinRegex","minp","shortp","longp","minPieces","hFormat","hours","kFormat","lowercase","minutes","matchMeridiem","_meridiemParse","localeIsPM","charAt","seconds","kInput","_isPm","isPM","_meridiem","pos","pos1","pos2","defaultLocaleMeridiemParse","getSetHour","localeMeridiem","isLower","globalLocale","baseConfig","dayOfMonthOrdinalParse","meridiemParse","locales","localeFamilies","commonPrefix","arr1","arr2","minl","normalizeLocale","chooseLocale","names","j","next","loadLocale","isLocaleNameSane","oldLocale","module","_abbr","aliasedRequire","getSetGlobalLocale","e","values","data","getLocale","defineLocale","abbr","parentLocale","forEach","updateLocale","tmpLocale","listLocales","checkOverflow","_overflowDayOfYear","_overflowWeeks","_overflowWeekday","extendedIsoRegex","basicIsoRegex","tzRegex","isoDates","isoTimes","aspNetJsonRegex","obsOffsets","UT","GMT","EDT","EST","CDT","CST","MDT","MST","PDT","PST","configFromISO","l","allowTime","dateFormat","timeFormat","tzFormat","exec","isoDatesLen","isoTimesLen","configFromStringAndFormat","extractFromRFC2822Strings","yearStr","monthStr","dayStr","hourStr","minuteStr","secondStr","result","untruncateYear","preprocessRFC2822","checkWeekday","weekdayStr","parsedInput","calculateOffset","obsOffset","militaryOffset","numOffset","hm","configFromRFC2822","parsedArray","setUTCMinutes","getUTCMinutes","configFromString","createFromInputFallback","defaults","c","currentDateArray","nowValue","_useUTC","getUTCMonth","getUTCDate","getMonth","getDate","configFromArray","currentDate","expectedWeekday","yearToUse","dayOfYearFromWeekInfo","_dayOfYear","_nextDay","weekYear","temp","weekdayOverflow","curWeek","GG","W","E","createLocal","gg","ISO_8601","RFC_2822","skipped","stringLength","totalParsedInputLength","meridiemFixWrap","erasConvertYear","hour","isPm","meridiemHour","configFromStringAndArray","tempConfig","bestMoment","scoreToBeat","currentScore","validFormatFound","bestFormatIsValid","configfLen","score","configFromObject","dayOrDate","minute","second","millisecond","createFromConfig","prepareConfig","preparse","configFromInput","isUTC","prototypeMin","other","prototypeMax","pickBy","moments","ordering","isDurationValid","unitHasDecimal","orderLen","parseFloat","isValid$1","createInvalid$1","createDuration","Duration","duration","years","quarters","quarter","weeks","isoWeek","days","milliseconds","_milliseconds","_days","_data","_bubble","isDuration","absRound","round","compareArrays","array1","array2","dontConvert","lengthDiff","diffs","offset","separator","utcOffset","sign","offsetFromString","chunkOffset","matcher","parts","matches","cloneWithOffset","model","clone","setTime","local","getDateOffset","getTimezoneOffset","getSetOffset","keepLocalTime","keepMinutes","localAdjust","_changeInProgress","addSubtract","getSetZone","setOffsetToUTC","setOffsetToLocal","subtract","setOffsetToParsedOffset","tZone","hasAlignedHourOffset","isDaylightSavingTime","isDaylightSavingTimeShifted","_isDSTShifted","toArray","isLocal","isUtcOffset","isUtc","aspNetRegex","isoRegex","ret","diffRes","parseIso","momentsDifference","inp","positiveMomentsDifference","base","isAfter","isBefore","createAdder","direction","period","tmp","isAdding","invalid","isString","String","isMomentInput","isNumberOrStringArray","isMomentInputObject","property","objectTest","propertyTest","properties","propertyLen","arrayTest","dataTypeTest","filter","item","isCalendarSpec","getCalendarFormat","myMoment","calendar$1","time","formats","sod","startOf","calendarFormat","localInput","endOf","isBetween","inclusivity","localFrom","localTo","isSame","inputMs","isSameOrAfter","isSameOrBefore","asFloat","that","zoneDelta","monthDiff","wholeMonthDiff","anchor","toISOString","keepOffset","toDate","inspect","prefix","datetime","suffix","zone","inputString","defaultFormatUtc","defaultFormat","postformat","humanize","fromNow","toNow","newLocaleData","lang","MS_PER_SECOND","MS_PER_MINUTE","MS_PER_HOUR","MS_PER_400_YEARS","mod$1","dividend","divisor","localStartOfDate","utcStartOfDate","startOfDate","isoWeekday","unix","toObject","toJSON","isValid$2","parsingFlags","invalidAt","creationData","localeEras","eras","_eras","since","until","localeErasParse","eraName","narrow","localeErasConvertYear","dir","getEraName","getEraNarrow","getEraAbbr","getEraYear","erasNameRegex","computeErasParse","_erasNameRegex","_erasRegex","erasAbbrRegex","_erasAbbrRegex","erasNarrowRegex","_erasNarrowRegex","matchEraAbbr","matchEraName","matchEraNarrow","matchEraYearOrdinal","_eraYearOrdinalRegex","abbrPieces","namePieces","narrowPieces","addWeekYearFormatToken","getter","getSetWeekYear","getSetWeekYearHelper","getSetISOWeekYear","getISOWeeksInYear","getISOWeeksInISOWeekYear","isoWeekYear","getWeeksInYear","weekInfo","getWeeksInWeekYear","weeksTarget","setWeekAll","dayOfYearData","getSetQuarter","erasParse","eraYearOrdinalParse","getSetDayOfMonth","getSetDayOfYear","getSetMinute","getSetMillisecond","getSetSecond","parseMs","getZoneAbbr","getZoneName","proto","createUnix","createInZone","parseZone","preParsePostFormat","Symbol","for","eraNarrow","eraAbbr","eraYear","isoWeeks","weeksInWeekYear","isoWeeksInYear","isoWeeksInISOWeekYear","isDST","zoneAbbr","zoneName","dates","isDSTShifted","proto$1","get$1","index","field","setter","listMonthsImpl","out","listWeekdaysImpl","localeSorted","shift","listMonths","listMonthsShort","listWeekdays","listWeekdaysShort","listWeekdaysMin","firstDayOfYear","firstDayOfWeek","langData","mathAbs","addSubtract$1","add$1","subtract$1","absCeil","bubble","monthsFromDays","monthsToDays","daysToMonths","as","valueOf$1","makeAs","alias","asMilliseconds","asSeconds","asMinutes","asHours","asDays","asWeeks","asMonths","asQuarters","asYears","clone$1","get$2","makeGetter","thresholds","substituteTimeAgo","relativeTime$1","posNegDuration","getSetRelativeTimeRounding","roundingFunction","getSetRelativeTimeThreshold","threshold","limit","argWithSuffix","argThresholds","withSuffix","th","assign","abs$1","toISOString$1","totalSign","ymSign","daysSign","hmsSign","total","toFixed","proto$2","toIsoString","version","relativeTimeRounding","relativeTimeThreshold","HTML5_FMT","DATETIME_LOCAL","DATETIME_LOCAL_SECONDS","DATETIME_LOCAL_MS","TIME","TIME_SECONDS","TIME_MS","factory","roundNumber","num","decimal","Number","handleCallback","context","event","animations","easeOut","cos","PI","linear","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","handleCancelAnimationFrame","animation","cancelAnimationFrame","handleCancelAnimation","contextInstance","mounted","animate","velocity","handleSetupAnimation","animationName","animationTime","startTime","frameTime","step","animationType","requestAnimationFrame","targetState","scale","positionX","positionY","isValidTargetState","setTransformState","transformState","scaleDiff","positionXDiff","positionYDiff","calculateBounds","newScale","wrapperComponent","contentComponent","centerZoomedOut","setup","wrapperWidth","offsetWidth","wrapperHeight","offsetHeight","newContentWidth","newContentHeight","newDiffWidth","newDiffHeight","getComponentsSizes","bounds","diffWidth","diffHeight","scaleWidthFactor","scaleHeightFactor","minPositionX","maxPositionX","minPositionY","maxPositionY","getBounds","Boolean","boundLimiter","minBound","maxBound","isActive","handleCalculateBounds","getMouseBoundedPosition","limitToBounds","paddingValueX","paddingValueY","paddingX","paddingY","handleCalculateZoomPositions","mouseX","mouseY","scaleDifference","error","checkZoomBounds","zoom","minScale","maxScale","zoomPadding","enablePadding","minScaleWithPadding","isPanningStartAllowed","excluded","panning","isInitialized","target","isWrapperChild","contains","isExcludedNode","isPanningAllowed","isPanning","disabled","getPaddingValue","size","disablePadding","getVelocityPosition","newPosition","startPosition","currentPosition","isLocked","minPosition","maxPosition","minTarget","maxTarget","calculatedPosition","handleCalculateVelocity","position","isAllowed","velocityAnimation","isVelocityCalculationAllowed","lastMousePosition","velocityTime","equalToMove","sizeMultiplier","window","innerWidth","getSizeMultiplier","distanceX","distanceY","velocityX","velocityY","interval","speed","sqrt","handlePanningStart","TouchEvent","touches","clientX","clientY","startCoords","handleTouchPanningSetup","handlePanningSetup","handleAlignToBounds","alignmentAnimation","sizeX","sizeY","_b","_c","xChanged","yChanged","handlePanToBounds","handlePanning","lockAxisX","lockAxisY","getPanningClientPosition","newPositionX","newPositionY","handleNewPosition","handlePanningEnd","velocityDisabled","wrapperRect","getBoundingClientRect","contentRect","width","height","contentWidth","contentHeight","isZoomed","isVelocityAllowed","zoomAnimation","alignAnimationTime","velocityAlignmentTime","moveAnimationTime","sensitivity","getVelocityMoveTime","finalAnimationTime","maxTargetX","minTargetX","maxTargetY","minTargetY","startState","animationProgress","alignStep","alignAnimation","customStep","currentPositionX","currentPositionY","handleVelocityPanning","handleZoomToPoint","handleAlignToScaleBounds","mousePositionX","mousePositionY","isDisabled","__assign","p","__spreadArray","pack","ar","initialState","initialSetup","centerOnInit","smooth","wheel","smoothStep","wheelDisabled","touchPadDisabled","activationKeys","allowLeftClickPan","allowMiddleClickPan","allowRightClickPan","pinch","doubleClick","mode","createState","props","previousScale","initialScale","initialPositionX","initialPositionY","createSetup","newSetup","validValue","dataType","handleCalculateButtonZoom","delta","targetScale","exp","handleZoomToViewCenter","resetTransformations","onResetTransformation","initialTransformation","newBounds","boundedPositions","newState","zoomIn","zoomOut","setTransform","resetTransform","centerView","getCenterPosition","zoomToElement","node","document","getElementById","customZoom","nodeRect","nodeOffset","element","wrapper","content","state","wrapperOffset","contentOffset","xOff","yOff","getOffset","nodeLeft","nodeTop","nodeWidth","nodeHeight","scaleX","scaleY","offsetX","offsetY","left","top","calculateZoomToNode","getControls","instance","getState","getContext","ref","makePassiveEventOption","passive","err","targetTagName","tagName","find","tag","className","classList","cancelTimeout","timeout","clearTimeout","getMousePosition","touch","getTouchDistance","pageX","pageY","handleWheelZoom","onWheel","onZoom","preventDefault","stopPropagation","customDelta","defaultValue","deltaY","getDeltaY","getDelta","disable","getTarget","paddingEnabled","handleCalculateWheelZoom","ctrlKey","mousePosition","isLimitedToBounds","previousWheelEvent","handleWheelStop","onWheelStop","onZoomStop","wheelAnimationTimer","setTimeout","hasStoppedZooming","handleWheelZoomStop","wheelStopEventTimer","handlePinchZoom","pinchStartDistance","midPoint","firstPointX","firstPointY","calculateTouchMidPoint","currentDistance","pinchStartScale","calculatePinchZoom","pinchMidpoint","lastDistance","handleDoubleClickStop","doubleClickStopEventTimer","handleDoubleClick","onZoomStart","handleDoubleClickResetMode","ZoomPanPinch","_this","onChangeCallbacks","Set","onInitCallbacks","lastTouch","distance","maxBounds","pressedKeys","mount","initializeWindowEvents","unmount","cleanupWindowEvents","update","newProps","currentDocument","ownerDocument","currentWindow","defaultView","addEventListener","onPanningStart","onPanning","onPanningStop","clearPanning","setKeyUnPressed","setKeyPressed","removeEventListener","observer","disconnect","handleInitializeWrapperEvents","onWheelZoom","onDoubleClick","onTouchPanningStart","onTouchPanning","onTouchPanningStop","handleInitialize","applyTransformation","setCenter","ResizeObserver","observe","isWheelAllowed","isPressingKeys","onWheelStart","handleWheelStart","button","onPinchStart","onPinchingStart","isPinchStartAllowed","handlePinchStart","onPinch","onPinching","isPinchAllowed","onPinchStop","onPinchingStop","handlePinchStop","isPanningAction","isPinchAction","isDoubleClickAllowed","onTransformed","ctx_1","handleTransformStyles","customTransform","getTransformStyles","transform","style","onChange","has","delete","onInit","init","ctx","Context","React","TransformWrapper","children","useRef","current","useImperativeHandle","useEffect","Provider","refs","localRef","useContext","css","insertAt","head","getElementsByTagName","createElement","type","firstChild","insertBefore","appendChild","styleSheet","cssText","createTextNode","TransformComponent","wrapperClass","contentClass","wrapperStyle","contentStyle","wrapperProps","_e","contentProps","wrapperRef","contentRef","styles"],"sourceRoot":""}