{"version":3,"sources":["webpack:///./node_modules/string-convert/camel2hyphen.js","webpack:///./node_modules/shallowequal/index.js","webpack:///./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:///./node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/shallow-equal/arrays/index.js","webpack:///./node_modules/raf/index.js"],"names":["camel2hyphen","str","replace","match","toLowerCase","module","exports","objA","objB","compare","compareContext","ret","call","keysA","Object","keys","keysB","length","bHasOwnProperty","prototype","hasOwnProperty","bind","idx","key","valueA","valueB","MapShim","Map","getIndex","arr","result","some","entry","index","class_1","this","__entries__","defineProperty","get","enumerable","configurable","set","value","push","delete","entries","splice","has","clear","forEach","callback","ctx","_i","_a","isBrowser","window","document","global$1","global","Math","self","Function","requestAnimationFrame$1","requestAnimationFrame","setTimeout","Date","now","trailingTimeout","throttle","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","REFRESH_DELAY","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","addObserver","observer","indexOf","connect_","removeObserver","observers","disconnect_","changesDetected","updateObservers_","activeObservers","filter","gatherActive","hasActive","broadcastActive","addEventListener","observe","attributes","childList","characterData","subtree","removeEventListener","disconnect","_b","propertyName","isReflowProperty","getInstance","instance_","defineConfigurable","target","props","writable","getWindowOf","ownerGlobal","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","parseFloat","getBordersSize","styles","positions","arguments","reduce","size","position","getPaddings","paddings","positions_1","getSVGContentRect","bbox","getBBox","width","height","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","horizPad","left","right","vertPad","top","bottom","boxSizing","round","isDocumentElement","vertScrollbar","horizScrollbar","abs","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","documentElement","getContentRect","createReadOnlyRect","x","y","Constr","DOMRectReadOnly","rect","create","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","isActive","broadcastRect","ResizeObserverEntry","rectInit","contentRect","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","TypeError","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","_this","observation","map","WeakMap","ResizeObserver","method","apply","runtime","undefined","Op","hasOwn","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","obj","err","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","makeInvokeMethod","tryCatch","fn","arg","type","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","resolve","reject","record","__await","then","unwrapped","error","previousPromise","enqueue","callInvokeWithMethodAndArg","state","Error","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","done","info","resultName","next","nextLoc","pushTryEntry","locs","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","i","constructor","displayName","isGeneratorFunction","genFun","ctor","name","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","toString","object","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootEntry","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","shallowEqualArrays","arrA","arrB","len","root","vendors","suffix","raf","caf","last","id","queue","frameDuration","_now","max","cp","cancelled","e","cancel","polyfill","cancelAnimationFrame"],"mappings":"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","file":"js/chunk-vendors~678f84af.0bfaed8f.js","sourcesContent":["var camel2hyphen = function (str) {\n  return str\n          .replace(/[A-Z]/g, function (match) {\n            return '-' + match.toLowerCase();\n          })\n          .toLowerCase();\n};\n\nmodule.exports = camel2hyphen;","//\n\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\n  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\n\n  if (ret !== void 0) {\n    return !!ret;\n  }\n\n  if (objA === objB) {\n    return true;\n  }\n\n  if (typeof objA !== \"object\" || !objA || typeof objB !== \"object\" || !objB) {\n    return false;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\n\n  // Test for A's keys different from B.\n  for (var idx = 0; idx < keysA.length; idx++) {\n    var key = keysA[idx];\n\n    if (!bHasOwnProperty(key)) {\n      return false;\n    }\n\n    var valueA = objA[key];\n    var valueB = objB[key];\n\n    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\n\n    if (ret === false || (ret === void 0 && valueA !== valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","'use strict';\n\nfunction shallowEqualArrays(arrA, arrB) {\n  if (arrA === arrB) {\n    return true;\n  }\n\n  if (!arrA || !arrB) {\n    return false;\n  }\n\n  var len = arrA.length;\n\n  if (arrB.length !== len) {\n    return false;\n  }\n\n  for (var i = 0; i < len; i++) {\n    if (arrA[i] !== arrB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = shallowEqualArrays;\n","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n"],"sourceRoot":""}