{"version":3,"sources":["webpack:///./node_modules/react-virtualized-auto-sizer/dist/react-virtualized-auto-sizer.module.js","webpack:///./node_modules/memoize-one/dist/memoize-one.esm.js","webpack:///./node_modules/react-window/dist/index.esm.js"],"names":["$3e40d2fd7fdb47d2$exports","$parcel$global","globalThis","self","window","global","$3e40d2fd7fdb47d2$var$windowObject","$3e40d2fd7fdb47d2$var$cancelFrame","$3e40d2fd7fdb47d2$var$requestFrame","$3e40d2fd7fdb47d2$var$clearTimeoutFn","clearTimeout","$3e40d2fd7fdb47d2$var$setTimeoutFn","setTimeout","$3e40d2fd7fdb47d2$var$cancelAnimationFrameFn","cancelAnimationFrame","mozCancelAnimationFrame","webkitCancelAnimationFrame","$3e40d2fd7fdb47d2$var$requestAnimationFrameFn","requestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","$6e2bb92d9db3b0c8$var$_defineProperty","obj","key","value","arg","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","String","Number","$6e2bb92d9db3b0c8$var$_toPrimitive","$6e2bb92d9db3b0c8$var$_toPropertyKey","Object","defineProperty","enumerable","configurable","writable","callback","animationFrameID","timeoutID","createDetectElementResize","nonce","animationKeyframes","animationName","animationStartEvent","animationStyle","checkTriggers","resetTriggers","scrollListener","attachEvent","document","element","triggers","__resizeTriggers__","expand","firstElementChild","contract","lastElementChild","expandChild","scrollLeft","scrollWidth","scrollTop","scrollHeight","style","width","offsetWidth","height","offsetHeight","__resizeLast__","e","target","className","indexOf","this","__resizeRAF__","__resizeListeners__","forEach","fn","animation","keyframeprefix","domPrefixes","split","startEvents","pfx","elm","createElement","i","length","toLowerCase","addResizeListener","doc","ownerDocument","elementStyle","getComputedStyle","position","getElementById","css","head","getElementsByTagName","id","type","setAttribute","styleSheet","cssText","appendChild","createTextNode","createStyles","expandTrigger","contractTrigger","addEventListener","__animationListener__","push","removeResizeListener","detachEvent","splice","removeEventListener","removeChild","$6e2bb92d9db3b0c8$export$9d94f4ee1d930ff","constructor","args","super","props","defaultHeight","scaledHeight","scaledWidth","defaultWidth","disableHeight","disableWidth","onResize","_parentNode","_style$paddingLeft","_style$paddingRight","_style$paddingTop","_style$paddingBottom","paddingLeft","parseInt","paddingRight","paddingTop","paddingBottom","rect","getBoundingClientRect","state","setState","autoSizer","_autoSizer","componentDidMount","parentNode","defaultView","HTMLElement","ResizeObserver","_resizeObserver","_onResize","observe","_detectElementResize","componentWillUnmount","disconnect","render","children","tagName","rest","outerStyle","overflow","childParams","bailoutOnChildren","ref","_setRef","$149c1bd638913645$export$2e2bcd8739ae039","safeIsNaN","isNaN","areInputsEqual","newInputs","lastInputs","first","second","resultFn","isEqual","lastThis","lastResult","lastArgs","calledOnce","newArgs","_i","arguments","apply","now","performance","Date","cancelTimeout","requestTimeout","delay","start","tick","cachedRTLResult","getRTLOffsetType","recalculate","outerDiv","direction","innerDiv","innerStyle","body","defaultItemKey$1","index","data","createListComponent","_ref","_class","getItemOffset","getEstimatedTotalSize","getItemSize","getOffsetForIndexAndAlignment","getStartIndexForOffset","getStopIndexForStartIndex","initInstanceProps","shouldResetStyleCacheOnItemSizeChange","validateProps","_PureComponent","List","_this","_instanceProps","_outerRef","_resetIsScrollingTimeoutId","instance","isScrolling","scrollDirection","scrollOffset","initialScrollOffset","scrollUpdateWasRequested","_callOnItemsRendered","overscanStartIndex","overscanStopIndex","visibleStartIndex","visibleStopIndex","onItemsRendered","_callOnScroll","onScroll","_getItemStyle","_this$props","itemSize","layout","itemStyleCache","_getItemStyleCache","hasOwnProperty","_offset","size","isHorizontal","isRtl","offsetHorizontal","left","right","top","_","__","___","_onScrollHorizontal","event","_event$currentTarget","currentTarget","clientWidth","prevState","Math","max","min","_resetIsScrollingDebounced","_onScrollVertical","_event$currentTarget2","clientHeight","_outerRefSetter","outerRef","current","_resetIsScrolling","getDerivedStateFromProps","nextProps","validateSharedProps$1","_proto","prototype","scrollTo","scrollToItem","align","itemCount","_this$props2","_callPropsCallbacks","componentDidUpdate","_this$props3","_this$state","_this$props4","innerRef","innerElementType","innerTagName","itemData","_this$props4$itemKey","itemKey","outerElementType","outerTagName","useIsScrolling","_this$_getRangeToRend","_getRangeToRender","startIndex","stopIndex","items","_index","estimatedTotalSize","WebkitOverflowScrolling","willChange","pointerEvents","_this$_getRangeToRend2","_overscanStartIndex","_overscanStopIndex","_visibleStartIndex","_visibleStopIndex","_this$state2","_scrollDirection","_scrollOffset","_scrollUpdateWasRequested","_this$props5","overscanCount","_this$state3","overscanBackward","overscanForward","defaultProps","_ref2","_ref3","FixedSizeList","_ref4","lastItemOffset","maxOffset","minOffset","middleOffset","round","ceil","floor","_ref5","offset","_ref6","numVisibleItems","_ref7"],"mappings":"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","file":"script/chunks/chunk.7.f38d5116e2.js","sourcesContent":["import {createElement as $hgUW1$createElement, Component as $hgUW1$Component} from \"react\";\n\nvar $parcel$global =\ntypeof globalThis !== 'undefined'\n  ? globalThis\n  : typeof self !== 'undefined'\n  ? self\n  : typeof window !== 'undefined'\n  ? window\n  : typeof global !== 'undefined'\n  ? global\n  : {};\n\nvar $3e40d2fd7fdb47d2$exports = {};\n/**\n * Detect Element Resize.\n * https://github.com/sdecima/javascript-detect-element-resize\n * Sebastian Decima\n *\n * Forked from version 0.5.3; includes the following modifications:\n * 1) Guard against unsafe 'window' and 'document' references (to support SSR).\n * 2) Defer initialization code via a top-level function wrapper (to support SSR).\n * 3) Avoid unnecessary reflows by not measuring size for scroll events bubbling from children.\n * 4) Add nonce for style element.\n **/ // Check `document` and `window` in case of server-side rendering\nlet $3e40d2fd7fdb47d2$var$windowObject;\nif (typeof window !== \"undefined\") $3e40d2fd7fdb47d2$var$windowObject = window;\nelse if (typeof self !== \"undefined\") // eslint-disable-next-line no-restricted-globals\n$3e40d2fd7fdb47d2$var$windowObject = self;\nelse $3e40d2fd7fdb47d2$var$windowObject = $parcel$global;\nlet $3e40d2fd7fdb47d2$var$cancelFrame = null;\nlet $3e40d2fd7fdb47d2$var$requestFrame = null;\nconst $3e40d2fd7fdb47d2$var$TIMEOUT_DURATION = 20;\nconst $3e40d2fd7fdb47d2$var$clearTimeoutFn = $3e40d2fd7fdb47d2$var$windowObject.clearTimeout;\nconst $3e40d2fd7fdb47d2$var$setTimeoutFn = $3e40d2fd7fdb47d2$var$windowObject.setTimeout;\nconst $3e40d2fd7fdb47d2$var$cancelAnimationFrameFn = $3e40d2fd7fdb47d2$var$windowObject.cancelAnimationFrame || $3e40d2fd7fdb47d2$var$windowObject.mozCancelAnimationFrame || $3e40d2fd7fdb47d2$var$windowObject.webkitCancelAnimationFrame;\nconst $3e40d2fd7fdb47d2$var$requestAnimationFrameFn = $3e40d2fd7fdb47d2$var$windowObject.requestAnimationFrame || $3e40d2fd7fdb47d2$var$windowObject.mozRequestAnimationFrame || $3e40d2fd7fdb47d2$var$windowObject.webkitRequestAnimationFrame;\nif ($3e40d2fd7fdb47d2$var$cancelAnimationFrameFn == null || $3e40d2fd7fdb47d2$var$requestAnimationFrameFn == null) {\n    // For environments that don't support animation frame,\n    // fallback to a setTimeout based approach.\n    $3e40d2fd7fdb47d2$var$cancelFrame = $3e40d2fd7fdb47d2$var$clearTimeoutFn;\n    $3e40d2fd7fdb47d2$var$requestFrame = function requestAnimationFrameViaSetTimeout(callback) {\n        return $3e40d2fd7fdb47d2$var$setTimeoutFn(callback, $3e40d2fd7fdb47d2$var$TIMEOUT_DURATION);\n    };\n} else {\n    // Counter intuitively, environments that support animation frames can be trickier.\n    // Chrome's \"Throttle non-visible cross-origin iframes\" flag can prevent rAFs from being called.\n    // In this case, we should fallback to a setTimeout() implementation.\n    $3e40d2fd7fdb47d2$var$cancelFrame = function cancelFrame([animationFrameID, timeoutID]) {\n        $3e40d2fd7fdb47d2$var$cancelAnimationFrameFn(animationFrameID);\n        $3e40d2fd7fdb47d2$var$clearTimeoutFn(timeoutID);\n    };\n    $3e40d2fd7fdb47d2$var$requestFrame = function requestAnimationFrameWithSetTimeoutFallback(callback) {\n        const animationFrameID = $3e40d2fd7fdb47d2$var$requestAnimationFrameFn(function animationFrameCallback() {\n            $3e40d2fd7fdb47d2$var$clearTimeoutFn(timeoutID);\n            callback();\n        });\n        const timeoutID = $3e40d2fd7fdb47d2$var$setTimeoutFn(function timeoutCallback() {\n            $3e40d2fd7fdb47d2$var$cancelAnimationFrameFn(animationFrameID);\n            callback();\n        }, $3e40d2fd7fdb47d2$var$TIMEOUT_DURATION);\n        return [\n            animationFrameID,\n            timeoutID\n        ];\n    };\n}\nfunction $3e40d2fd7fdb47d2$var$createDetectElementResize(nonce) {\n    let animationKeyframes;\n    let animationName;\n    let animationStartEvent;\n    let animationStyle;\n    let checkTriggers;\n    let resetTriggers;\n    let scrollListener;\n    const attachEvent = typeof document !== \"undefined\" && document.attachEvent;\n    if (!attachEvent) {\n        resetTriggers = function(element) {\n            const triggers = element.__resizeTriggers__, expand = triggers.firstElementChild, contract = triggers.lastElementChild, expandChild = expand.firstElementChild;\n            contract.scrollLeft = contract.scrollWidth;\n            contract.scrollTop = contract.scrollHeight;\n            expandChild.style.width = expand.offsetWidth + 1 + \"px\";\n            expandChild.style.height = expand.offsetHeight + 1 + \"px\";\n            expand.scrollLeft = expand.scrollWidth;\n            expand.scrollTop = expand.scrollHeight;\n        };\n        checkTriggers = function(element) {\n            return element.offsetWidth !== element.__resizeLast__.width || element.offsetHeight !== element.__resizeLast__.height;\n        };\n        scrollListener = function(e) {\n            // Don't measure (which forces) reflow for scrolls that happen inside of children!\n            if (e.target.className && typeof e.target.className.indexOf === \"function\" && e.target.className.indexOf(\"contract-trigger\") < 0 && e.target.className.indexOf(\"expand-trigger\") < 0) return;\n            const element = this;\n            resetTriggers(this);\n            if (this.__resizeRAF__) $3e40d2fd7fdb47d2$var$cancelFrame(this.__resizeRAF__);\n            this.__resizeRAF__ = $3e40d2fd7fdb47d2$var$requestFrame(function animationFrame() {\n                if (checkTriggers(element)) {\n                    element.__resizeLast__.width = element.offsetWidth;\n                    element.__resizeLast__.height = element.offsetHeight;\n                    element.__resizeListeners__.forEach(function forEachResizeListener(fn) {\n                        fn.call(element, e);\n                    });\n                }\n            });\n        };\n        /* Detect CSS Animations support to detect element display/re-attach */ let animation = false;\n        let keyframeprefix = \"\";\n        animationStartEvent = \"animationstart\";\n        const domPrefixes = \"Webkit Moz O ms\".split(\" \");\n        let startEvents = \"webkitAnimationStart animationstart oAnimationStart MSAnimationStart\".split(\" \");\n        let pfx = \"\";\n        {\n            const elm = document.createElement(\"fakeelement\");\n            if (elm.style.animationName !== undefined) animation = true;\n            if (animation === false) {\n                for(let i = 0; i < domPrefixes.length; i++)if (elm.style[domPrefixes[i] + \"AnimationName\"] !== undefined) {\n                    pfx = domPrefixes[i];\n                    keyframeprefix = \"-\" + pfx.toLowerCase() + \"-\";\n                    animationStartEvent = startEvents[i];\n                    animation = true;\n                    break;\n                }\n            }\n        }\n        animationName = \"resizeanim\";\n        animationKeyframes = \"@\" + keyframeprefix + \"keyframes \" + animationName + \" { from { opacity: 0; } to { opacity: 0; } } \";\n        animationStyle = keyframeprefix + \"animation: 1ms \" + animationName + \"; \";\n    }\n    const createStyles = function(doc) {\n        if (!doc.getElementById(\"detectElementResize\")) {\n            //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360\n            const css = (animationKeyframes ? animationKeyframes : \"\") + \".resize-triggers { \" + (animationStyle ? animationStyle : \"\") + \"visibility: hidden; opacity: 0; } \" + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: \" \"; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; z-index: -1; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }', head = doc.head || doc.getElementsByTagName(\"head\")[0], style = doc.createElement(\"style\");\n            style.id = \"detectElementResize\";\n            style.type = \"text/css\";\n            if (nonce != null) style.setAttribute(\"nonce\", nonce);\n            if (style.styleSheet) style.styleSheet.cssText = css;\n            else style.appendChild(doc.createTextNode(css));\n            head.appendChild(style);\n        }\n    };\n    const addResizeListener = function(element, fn) {\n        if (attachEvent) element.attachEvent(\"onresize\", fn);\n        else {\n            if (!element.__resizeTriggers__) {\n                const doc = element.ownerDocument;\n                const elementStyle = $3e40d2fd7fdb47d2$var$windowObject.getComputedStyle(element);\n                if (elementStyle && elementStyle.position === \"static\") element.style.position = \"relative\";\n                createStyles(doc);\n                element.__resizeLast__ = {};\n                element.__resizeListeners__ = [];\n                (element.__resizeTriggers__ = doc.createElement(\"div\")).className = \"resize-triggers\";\n                const expandTrigger = doc.createElement(\"div\");\n                expandTrigger.className = \"expand-trigger\";\n                expandTrigger.appendChild(doc.createElement(\"div\"));\n                const contractTrigger = doc.createElement(\"div\");\n                contractTrigger.className = \"contract-trigger\";\n                element.__resizeTriggers__.appendChild(expandTrigger);\n                element.__resizeTriggers__.appendChild(contractTrigger);\n                element.appendChild(element.__resizeTriggers__);\n                resetTriggers(element);\n                element.addEventListener(\"scroll\", scrollListener, true);\n                /* Listen for a css animation to detect element display/re-attach */ if (animationStartEvent) {\n                    element.__resizeTriggers__.__animationListener__ = function animationListener(e) {\n                        if (e.animationName === animationName) resetTriggers(element);\n                    };\n                    element.__resizeTriggers__.addEventListener(animationStartEvent, element.__resizeTriggers__.__animationListener__);\n                }\n            }\n            element.__resizeListeners__.push(fn);\n        }\n    };\n    const removeResizeListener = function(element, fn) {\n        if (attachEvent) element.detachEvent(\"onresize\", fn);\n        else {\n            element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);\n            if (!element.__resizeListeners__.length) {\n                element.removeEventListener(\"scroll\", scrollListener, true);\n                if (element.__resizeTriggers__.__animationListener__) {\n                    element.__resizeTriggers__.removeEventListener(animationStartEvent, element.__resizeTriggers__.__animationListener__);\n                    element.__resizeTriggers__.__animationListener__ = null;\n                }\n                try {\n                    element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);\n                } catch (e) {\n                // Preact compat; see developit/preact-compat/issues/228\n                }\n            }\n        }\n    };\n    return {\n        addResizeListener: addResizeListener,\n        removeResizeListener: removeResizeListener\n    };\n}\n$3e40d2fd7fdb47d2$exports = {\n    createDetectElementResize: $3e40d2fd7fdb47d2$var$createDetectElementResize\n};\n\n\nfunction $6e2bb92d9db3b0c8$var$_defineProperty(obj, key, value) {\n    key = $6e2bb92d9db3b0c8$var$_toPropertyKey(key);\n    if (key in obj) Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n    });\n    else obj[key] = value;\n    return obj;\n}\nfunction $6e2bb92d9db3b0c8$var$_toPropertyKey(arg) {\n    var key = $6e2bb92d9db3b0c8$var$_toPrimitive(arg, \"string\");\n    return typeof key === \"symbol\" ? key : String(key);\n}\nfunction $6e2bb92d9db3b0c8$var$_toPrimitive(input, hint) {\n    if (typeof input !== \"object\" || input === null) return input;\n    var prim = input[Symbol.toPrimitive];\n    if (prim !== undefined) {\n        var res = prim.call(input, hint || \"default\");\n        if (typeof res !== \"object\") return res;\n        throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n    }\n    return (hint === \"string\" ? String : Number)(input);\n}\nclass $6e2bb92d9db3b0c8$export$9d94f4ee1d930ff extends (0, $hgUW1$Component) {\n    constructor(...args){\n        super(...args);\n        $6e2bb92d9db3b0c8$var$_defineProperty(this, \"state\", {\n            height: this.props.defaultHeight || 0,\n            scaledHeight: this.props.defaultHeight || 0,\n            scaledWidth: this.props.defaultWidth || 0,\n            width: this.props.defaultWidth || 0\n        });\n        $6e2bb92d9db3b0c8$var$_defineProperty(this, \"_autoSizer\", null);\n        $6e2bb92d9db3b0c8$var$_defineProperty(this, \"_detectElementResize\", null);\n        $6e2bb92d9db3b0c8$var$_defineProperty(this, \"_parentNode\", null);\n        $6e2bb92d9db3b0c8$var$_defineProperty(this, \"_resizeObserver\", null);\n        $6e2bb92d9db3b0c8$var$_defineProperty(this, \"_onResize\", ()=>{\n            const { disableHeight: disableHeight , disableWidth: disableWidth , onResize: onResize  } = this.props;\n            if (this._parentNode) {\n                var _style$paddingLeft, _style$paddingRight, _style$paddingTop, _style$paddingBottom;\n                // Guard against AutoSizer component being removed from the DOM immediately after being added.\n                // This can result in invalid style values which can result in NaN values if we don't handle them.\n                // See issue #150 for more context.\n                const style = window.getComputedStyle(this._parentNode) || {};\n                const paddingLeft = parseInt((_style$paddingLeft = style.paddingLeft) !== null && _style$paddingLeft !== void 0 ? _style$paddingLeft : \"0\", 10);\n                const paddingRight = parseInt((_style$paddingRight = style.paddingRight) !== null && _style$paddingRight !== void 0 ? _style$paddingRight : \"0\", 10);\n                const paddingTop = parseInt((_style$paddingTop = style.paddingTop) !== null && _style$paddingTop !== void 0 ? _style$paddingTop : \"0\", 10);\n                const paddingBottom = parseInt((_style$paddingBottom = style.paddingBottom) !== null && _style$paddingBottom !== void 0 ? _style$paddingBottom : \"0\", 10);\n                const rect = this._parentNode.getBoundingClientRect();\n                const scaledHeight = rect.height - paddingTop - paddingBottom;\n                const scaledWidth = rect.width - paddingLeft - paddingRight;\n                const height = this._parentNode.offsetHeight - paddingTop - paddingBottom;\n                const width = this._parentNode.offsetWidth - paddingLeft - paddingRight;\n                if (!disableHeight && (this.state.height !== height || this.state.scaledHeight !== scaledHeight) || !disableWidth && (this.state.width !== width || this.state.scaledWidth !== scaledWidth)) {\n                    this.setState({\n                        height: height,\n                        width: width,\n                        scaledHeight: scaledHeight,\n                        scaledWidth: scaledWidth\n                    });\n                    if (typeof onResize === \"function\") onResize({\n                        height: height,\n                        scaledHeight: scaledHeight,\n                        scaledWidth: scaledWidth,\n                        width: width\n                    });\n                }\n            }\n        });\n        $6e2bb92d9db3b0c8$var$_defineProperty(this, \"_setRef\", (autoSizer)=>{\n            this._autoSizer = autoSizer;\n        });\n    }\n    componentDidMount() {\n        const { nonce: nonce  } = this.props;\n        if (this._autoSizer && this._autoSizer.parentNode && this._autoSizer.parentNode.ownerDocument && this._autoSizer.parentNode.ownerDocument.defaultView && this._autoSizer.parentNode instanceof this._autoSizer.parentNode.ownerDocument.defaultView.HTMLElement) {\n            // Delay access of parentNode until mount.\n            // This handles edge-cases where the component has already been unmounted before its ref has been set,\n            // As well as libraries like react-lite which have a slightly different lifecycle.\n            this._parentNode = this._autoSizer.parentNode;\n            // Defer requiring resize handler in order to support server-side rendering.\n            // See issue #41\n            if (this._parentNode != null) {\n                if (typeof ResizeObserver !== \"undefined\") {\n                    this._resizeObserver = new ResizeObserver(()=>{\n                        // Guard against \"ResizeObserver loop limit exceeded\" error;\n                        // could be triggered if the state update causes the ResizeObserver handler to run long.\n                        // See https://github.com/bvaughn/react-virtualized-auto-sizer/issues/55\n                        setTimeout(this._onResize, 0);\n                    });\n                    this._resizeObserver.observe(this._parentNode);\n                } else {\n                    this._detectElementResize = (0, $3e40d2fd7fdb47d2$exports.createDetectElementResize)(nonce);\n                    this._detectElementResize.addResizeListener(this._parentNode, this._onResize);\n                }\n                this._onResize();\n            }\n        }\n    }\n    componentWillUnmount() {\n        if (this._parentNode) {\n            if (this._detectElementResize) this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);\n            if (this._resizeObserver) {\n                this._resizeObserver.observe(this._parentNode);\n                this._resizeObserver.disconnect();\n            }\n        }\n    }\n    render() {\n        const { children: children , defaultHeight: defaultHeight , defaultWidth: defaultWidth , disableHeight: disableHeight , disableWidth: disableWidth , nonce: nonce , onResize: onResize , style: style , tagName: tagName = \"div\" , ...rest } = this.props;\n        const { height: height , scaledHeight: scaledHeight , scaledWidth: scaledWidth , width: width  } = this.state;\n        // Outer div should not force width/height since that may prevent containers from shrinking.\n        // Inner component should overflow and use calculated width/height.\n        // See issue #68 for more information.\n        const outerStyle = {\n            overflow: \"visible\"\n        };\n        const childParams = {};\n        // Avoid rendering children before the initial measurements have been collected.\n        // At best this would just be wasting cycles.\n        let bailoutOnChildren = false;\n        if (!disableHeight) {\n            if (height === 0) bailoutOnChildren = true;\n            outerStyle.height = 0;\n            childParams.height = height;\n            childParams.scaledHeight = scaledHeight;\n        }\n        if (!disableWidth) {\n            if (width === 0) bailoutOnChildren = true;\n            outerStyle.width = 0;\n            childParams.width = width;\n            childParams.scaledWidth = scaledWidth;\n        }\n        return (0, $hgUW1$createElement)(tagName, {\n            ref: this._setRef,\n            style: {\n                ...outerStyle,\n                ...style\n            },\n            ...rest\n        }, !bailoutOnChildren && children(childParams));\n    }\n}\n$6e2bb92d9db3b0c8$var$_defineProperty($6e2bb92d9db3b0c8$export$9d94f4ee1d930ff, \"defaultProps\", {\n    onResize: ()=>{},\n    disableHeight: false,\n    disableWidth: false,\n    style: {}\n});\n\n\nvar $149c1bd638913645$export$2e2bcd8739ae039 = (0, $6e2bb92d9db3b0c8$export$9d94f4ee1d930ff);\n\n\nexport {$149c1bd638913645$export$2e2bcd8739ae039 as default};\n//# sourceMappingURL=react-virtualized-auto-sizer.module.js.map\n","var safeIsNaN = Number.isNaN ||\n    function ponyfill(value) {\n        return typeof value === 'number' && value !== value;\n    };\nfunction isEqual(first, second) {\n    if (first === second) {\n        return true;\n    }\n    if (safeIsNaN(first) && safeIsNaN(second)) {\n        return true;\n    }\n    return false;\n}\nfunction areInputsEqual(newInputs, lastInputs) {\n    if (newInputs.length !== lastInputs.length) {\n        return false;\n    }\n    for (var i = 0; i < newInputs.length; i++) {\n        if (!isEqual(newInputs[i], lastInputs[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n    if (isEqual === void 0) { isEqual = areInputsEqual; }\n    var lastThis;\n    var lastArgs = [];\n    var lastResult;\n    var calledOnce = false;\n    function memoized() {\n        var newArgs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            newArgs[_i] = arguments[_i];\n        }\n        if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {\n            return lastResult;\n        }\n        lastResult = resultFn.apply(this, newArgs);\n        calledOnce = true;\n        lastThis = this;\n        lastArgs = newArgs;\n        return lastResult;\n    }\n    return memoized;\n}\n\nexport default memoizeOne;\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport memoizeOne from 'memoize-one';\nimport { createElement, PureComponent } from 'react';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\n\n// Animation frame based implementation of setTimeout.\n// Inspired by Joe Lambert, https://gist.github.com/joelambert/1002116#file-requesttimeout-js\nvar hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';\nvar now = hasNativePerformanceNow ? function () {\n  return performance.now();\n} : function () {\n  return Date.now();\n};\nfunction cancelTimeout(timeoutID) {\n  cancelAnimationFrame(timeoutID.id);\n}\nfunction requestTimeout(callback, delay) {\n  var start = now();\n\n  function tick() {\n    if (now() - start >= delay) {\n      callback.call(null);\n    } else {\n      timeoutID.id = requestAnimationFrame(tick);\n    }\n  }\n\n  var timeoutID = {\n    id: requestAnimationFrame(tick)\n  };\n  return timeoutID;\n}\n\nvar size = -1; // This utility copied from \"dom-helpers\" package.\n\nfunction getScrollbarSize(recalculate) {\n  if (recalculate === void 0) {\n    recalculate = false;\n  }\n\n  if (size === -1 || recalculate) {\n    var div = document.createElement('div');\n    var style = div.style;\n    style.width = '50px';\n    style.height = '50px';\n    style.overflow = 'scroll';\n    document.body.appendChild(div);\n    size = div.offsetWidth - div.clientWidth;\n    document.body.removeChild(div);\n  }\n\n  return size;\n}\nvar cachedRTLResult = null; // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n// Chrome does not seem to adhere; its scrollLeft values are positive (measured relative to the left).\n// Safari's elastic bounce makes detecting this even more complicated wrt potential false positives.\n// The safest way to check this is to intentionally set a negative offset,\n// and then verify that the subsequent \"scroll\" event matches the negative offset.\n// If it does not match, then we can assume a non-standard RTL scroll implementation.\n\nfunction getRTLOffsetType(recalculate) {\n  if (recalculate === void 0) {\n    recalculate = false;\n  }\n\n  if (cachedRTLResult === null || recalculate) {\n    var outerDiv = document.createElement('div');\n    var outerStyle = outerDiv.style;\n    outerStyle.width = '50px';\n    outerStyle.height = '50px';\n    outerStyle.overflow = 'scroll';\n    outerStyle.direction = 'rtl';\n    var innerDiv = document.createElement('div');\n    var innerStyle = innerDiv.style;\n    innerStyle.width = '100px';\n    innerStyle.height = '100px';\n    outerDiv.appendChild(innerDiv);\n    document.body.appendChild(outerDiv);\n\n    if (outerDiv.scrollLeft > 0) {\n      cachedRTLResult = 'positive-descending';\n    } else {\n      outerDiv.scrollLeft = 1;\n\n      if (outerDiv.scrollLeft === 0) {\n        cachedRTLResult = 'negative';\n      } else {\n        cachedRTLResult = 'positive-ascending';\n      }\n    }\n\n    document.body.removeChild(outerDiv);\n    return cachedRTLResult;\n  }\n\n  return cachedRTLResult;\n}\n\nvar IS_SCROLLING_DEBOUNCE_INTERVAL = 150;\n\nvar defaultItemKey = function defaultItemKey(_ref) {\n  var columnIndex = _ref.columnIndex,\n      data = _ref.data,\n      rowIndex = _ref.rowIndex;\n  return rowIndex + \":\" + columnIndex;\n}; // In DEV mode, this Set helps us only log a warning once per component instance.\n// This avoids spamming the console every time a render happens.\n\n\nvar devWarningsOverscanCount = null;\nvar devWarningsOverscanRowsColumnsCount = null;\nvar devWarningsTagName = null;\n\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof window !== 'undefined' && typeof window.WeakSet !== 'undefined') {\n    devWarningsOverscanCount = /*#__PURE__*/new WeakSet();\n    devWarningsOverscanRowsColumnsCount = /*#__PURE__*/new WeakSet();\n    devWarningsTagName = /*#__PURE__*/new WeakSet();\n  }\n}\n\nfunction createGridComponent(_ref2) {\n  var _class;\n\n  var getColumnOffset = _ref2.getColumnOffset,\n      getColumnStartIndexForOffset = _ref2.getColumnStartIndexForOffset,\n      getColumnStopIndexForStartIndex = _ref2.getColumnStopIndexForStartIndex,\n      getColumnWidth = _ref2.getColumnWidth,\n      getEstimatedTotalHeight = _ref2.getEstimatedTotalHeight,\n      getEstimatedTotalWidth = _ref2.getEstimatedTotalWidth,\n      getOffsetForColumnAndAlignment = _ref2.getOffsetForColumnAndAlignment,\n      getOffsetForRowAndAlignment = _ref2.getOffsetForRowAndAlignment,\n      getRowHeight = _ref2.getRowHeight,\n      getRowOffset = _ref2.getRowOffset,\n      getRowStartIndexForOffset = _ref2.getRowStartIndexForOffset,\n      getRowStopIndexForStartIndex = _ref2.getRowStopIndexForStartIndex,\n      initInstanceProps = _ref2.initInstanceProps,\n      shouldResetStyleCacheOnItemSizeChange = _ref2.shouldResetStyleCacheOnItemSizeChange,\n      validateProps = _ref2.validateProps;\n  return _class = /*#__PURE__*/function (_PureComponent) {\n    _inheritsLoose(Grid, _PureComponent);\n\n    // Always use explicit constructor for React components.\n    // It produces less code after transpilation. (#26)\n    // eslint-disable-next-line no-useless-constructor\n    function Grid(props) {\n      var _this;\n\n      _this = _PureComponent.call(this, props) || this;\n      _this._instanceProps = initInstanceProps(_this.props, _assertThisInitialized(_this));\n      _this._resetIsScrollingTimeoutId = null;\n      _this._outerRef = void 0;\n      _this.state = {\n        instance: _assertThisInitialized(_this),\n        isScrolling: false,\n        horizontalScrollDirection: 'forward',\n        scrollLeft: typeof _this.props.initialScrollLeft === 'number' ? _this.props.initialScrollLeft : 0,\n        scrollTop: typeof _this.props.initialScrollTop === 'number' ? _this.props.initialScrollTop : 0,\n        scrollUpdateWasRequested: false,\n        verticalScrollDirection: 'forward'\n      };\n      _this._callOnItemsRendered = void 0;\n      _this._callOnItemsRendered = memoizeOne(function (overscanColumnStartIndex, overscanColumnStopIndex, overscanRowStartIndex, overscanRowStopIndex, visibleColumnStartIndex, visibleColumnStopIndex, visibleRowStartIndex, visibleRowStopIndex) {\n        return _this.props.onItemsRendered({\n          overscanColumnStartIndex: overscanColumnStartIndex,\n          overscanColumnStopIndex: overscanColumnStopIndex,\n          overscanRowStartIndex: overscanRowStartIndex,\n          overscanRowStopIndex: overscanRowStopIndex,\n          visibleColumnStartIndex: visibleColumnStartIndex,\n          visibleColumnStopIndex: visibleColumnStopIndex,\n          visibleRowStartIndex: visibleRowStartIndex,\n          visibleRowStopIndex: visibleRowStopIndex\n        });\n      });\n      _this._callOnScroll = void 0;\n      _this._callOnScroll = memoizeOne(function (scrollLeft, scrollTop, horizontalScrollDirection, verticalScrollDirection, scrollUpdateWasRequested) {\n        return _this.props.onScroll({\n          horizontalScrollDirection: horizontalScrollDirection,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          verticalScrollDirection: verticalScrollDirection,\n          scrollUpdateWasRequested: scrollUpdateWasRequested\n        });\n      });\n      _this._getItemStyle = void 0;\n\n      _this._getItemStyle = function (rowIndex, columnIndex) {\n        var _this$props = _this.props,\n            columnWidth = _this$props.columnWidth,\n            direction = _this$props.direction,\n            rowHeight = _this$props.rowHeight;\n\n        var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && columnWidth, shouldResetStyleCacheOnItemSizeChange && direction, shouldResetStyleCacheOnItemSizeChange && rowHeight);\n\n        var key = rowIndex + \":\" + columnIndex;\n        var style;\n\n        if (itemStyleCache.hasOwnProperty(key)) {\n          style = itemStyleCache[key];\n        } else {\n          var _offset = getColumnOffset(_this.props, columnIndex, _this._instanceProps);\n\n          var isRtl = direction === 'rtl';\n          itemStyleCache[key] = style = {\n            position: 'absolute',\n            left: isRtl ? undefined : _offset,\n            right: isRtl ? _offset : undefined,\n            top: getRowOffset(_this.props, rowIndex, _this._instanceProps),\n            height: getRowHeight(_this.props, rowIndex, _this._instanceProps),\n            width: getColumnWidth(_this.props, columnIndex, _this._instanceProps)\n          };\n        }\n\n        return style;\n      };\n\n      _this._getItemStyleCache = void 0;\n      _this._getItemStyleCache = memoizeOne(function (_, __, ___) {\n        return {};\n      });\n\n      _this._onScroll = function (event) {\n        var _event$currentTarget = event.currentTarget,\n            clientHeight = _event$currentTarget.clientHeight,\n            clientWidth = _event$currentTarget.clientWidth,\n            scrollLeft = _event$currentTarget.scrollLeft,\n            scrollTop = _event$currentTarget.scrollTop,\n            scrollHeight = _event$currentTarget.scrollHeight,\n            scrollWidth = _event$currentTarget.scrollWidth;\n\n        _this.setState(function (prevState) {\n          if (prevState.scrollLeft === scrollLeft && prevState.scrollTop === scrollTop) {\n            // Scroll position may have been updated by cDM/cDU,\n            // In which case we don't need to trigger another render,\n            // And we don't want to update state.isScrolling.\n            return null;\n          }\n\n          var direction = _this.props.direction; // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n          // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n          // It's also easier for this component if we convert offsets to the same format as they would be in for ltr.\n          // So the simplest solution is to determine which browser behavior we're dealing with, and convert based on it.\n\n          var calculatedScrollLeft = scrollLeft;\n\n          if (direction === 'rtl') {\n            switch (getRTLOffsetType()) {\n              case 'negative':\n                calculatedScrollLeft = -scrollLeft;\n                break;\n\n              case 'positive-descending':\n                calculatedScrollLeft = scrollWidth - clientWidth - scrollLeft;\n                break;\n            }\n          } // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n\n\n          calculatedScrollLeft = Math.max(0, Math.min(calculatedScrollLeft, scrollWidth - clientWidth));\n          var calculatedScrollTop = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));\n          return {\n            isScrolling: true,\n            horizontalScrollDirection: prevState.scrollLeft < scrollLeft ? 'forward' : 'backward',\n            scrollLeft: calculatedScrollLeft,\n            scrollTop: calculatedScrollTop,\n            verticalScrollDirection: prevState.scrollTop < scrollTop ? 'forward' : 'backward',\n            scrollUpdateWasRequested: false\n          };\n        }, _this._resetIsScrollingDebounced);\n      };\n\n      _this._outerRefSetter = function (ref) {\n        var outerRef = _this.props.outerRef;\n        _this._outerRef = ref;\n\n        if (typeof outerRef === 'function') {\n          outerRef(ref);\n        } else if (outerRef != null && typeof outerRef === 'object' && outerRef.hasOwnProperty('current')) {\n          outerRef.current = ref;\n        }\n      };\n\n      _this._resetIsScrollingDebounced = function () {\n        if (_this._resetIsScrollingTimeoutId !== null) {\n          cancelTimeout(_this._resetIsScrollingTimeoutId);\n        }\n\n        _this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL);\n      };\n\n      _this._resetIsScrolling = function () {\n        _this._resetIsScrollingTimeoutId = null;\n\n        _this.setState({\n          isScrolling: false\n        }, function () {\n          // Clear style cache after state update has been committed.\n          // This way we don't break pure sCU for items that don't use isScrolling param.\n          _this._getItemStyleCache(-1);\n        });\n      };\n\n      return _this;\n    }\n\n    Grid.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n      validateSharedProps(nextProps, prevState);\n      validateProps(nextProps);\n      return null;\n    };\n\n    var _proto = Grid.prototype;\n\n    _proto.scrollTo = function scrollTo(_ref3) {\n      var scrollLeft = _ref3.scrollLeft,\n          scrollTop = _ref3.scrollTop;\n\n      if (scrollLeft !== undefined) {\n        scrollLeft = Math.max(0, scrollLeft);\n      }\n\n      if (scrollTop !== undefined) {\n        scrollTop = Math.max(0, scrollTop);\n      }\n\n      this.setState(function (prevState) {\n        if (scrollLeft === undefined) {\n          scrollLeft = prevState.scrollLeft;\n        }\n\n        if (scrollTop === undefined) {\n          scrollTop = prevState.scrollTop;\n        }\n\n        if (prevState.scrollLeft === scrollLeft && prevState.scrollTop === scrollTop) {\n          return null;\n        }\n\n        return {\n          horizontalScrollDirection: prevState.scrollLeft < scrollLeft ? 'forward' : 'backward',\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          scrollUpdateWasRequested: true,\n          verticalScrollDirection: prevState.scrollTop < scrollTop ? 'forward' : 'backward'\n        };\n      }, this._resetIsScrollingDebounced);\n    };\n\n    _proto.scrollToItem = function scrollToItem(_ref4) {\n      var _ref4$align = _ref4.align,\n          align = _ref4$align === void 0 ? 'auto' : _ref4$align,\n          columnIndex = _ref4.columnIndex,\n          rowIndex = _ref4.rowIndex;\n      var _this$props2 = this.props,\n          columnCount = _this$props2.columnCount,\n          height = _this$props2.height,\n          rowCount = _this$props2.rowCount,\n          width = _this$props2.width;\n      var _this$state = this.state,\n          scrollLeft = _this$state.scrollLeft,\n          scrollTop = _this$state.scrollTop;\n      var scrollbarSize = getScrollbarSize();\n\n      if (columnIndex !== undefined) {\n        columnIndex = Math.max(0, Math.min(columnIndex, columnCount - 1));\n      }\n\n      if (rowIndex !== undefined) {\n        rowIndex = Math.max(0, Math.min(rowIndex, rowCount - 1));\n      }\n\n      var estimatedTotalHeight = getEstimatedTotalHeight(this.props, this._instanceProps);\n      var estimatedTotalWidth = getEstimatedTotalWidth(this.props, this._instanceProps); // The scrollbar size should be considered when scrolling an item into view,\n      // to ensure it's fully visible.\n      // But we only need to account for its size when it's actually visible.\n\n      var horizontalScrollbarSize = estimatedTotalWidth > width ? scrollbarSize : 0;\n      var verticalScrollbarSize = estimatedTotalHeight > height ? scrollbarSize : 0;\n      this.scrollTo({\n        scrollLeft: columnIndex !== undefined ? getOffsetForColumnAndAlignment(this.props, columnIndex, align, scrollLeft, this._instanceProps, verticalScrollbarSize) : scrollLeft,\n        scrollTop: rowIndex !== undefined ? getOffsetForRowAndAlignment(this.props, rowIndex, align, scrollTop, this._instanceProps, horizontalScrollbarSize) : scrollTop\n      });\n    };\n\n    _proto.componentDidMount = function componentDidMount() {\n      var _this$props3 = this.props,\n          initialScrollLeft = _this$props3.initialScrollLeft,\n          initialScrollTop = _this$props3.initialScrollTop;\n\n      if (this._outerRef != null) {\n        var outerRef = this._outerRef;\n\n        if (typeof initialScrollLeft === 'number') {\n          outerRef.scrollLeft = initialScrollLeft;\n        }\n\n        if (typeof initialScrollTop === 'number') {\n          outerRef.scrollTop = initialScrollTop;\n        }\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentDidUpdate = function componentDidUpdate() {\n      var direction = this.props.direction;\n      var _this$state2 = this.state,\n          scrollLeft = _this$state2.scrollLeft,\n          scrollTop = _this$state2.scrollTop,\n          scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;\n\n      if (scrollUpdateWasRequested && this._outerRef != null) {\n        // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n        // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n        // So we need to determine which browser behavior we're dealing with, and mimic it.\n        var outerRef = this._outerRef;\n\n        if (direction === 'rtl') {\n          switch (getRTLOffsetType()) {\n            case 'negative':\n              outerRef.scrollLeft = -scrollLeft;\n              break;\n\n            case 'positive-ascending':\n              outerRef.scrollLeft = scrollLeft;\n              break;\n\n            default:\n              var clientWidth = outerRef.clientWidth,\n                  scrollWidth = outerRef.scrollWidth;\n              outerRef.scrollLeft = scrollWidth - clientWidth - scrollLeft;\n              break;\n          }\n        } else {\n          outerRef.scrollLeft = Math.max(0, scrollLeft);\n        }\n\n        outerRef.scrollTop = Math.max(0, scrollTop);\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentWillUnmount = function componentWillUnmount() {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n    };\n\n    _proto.render = function render() {\n      var _this$props4 = this.props,\n          children = _this$props4.children,\n          className = _this$props4.className,\n          columnCount = _this$props4.columnCount,\n          direction = _this$props4.direction,\n          height = _this$props4.height,\n          innerRef = _this$props4.innerRef,\n          innerElementType = _this$props4.innerElementType,\n          innerTagName = _this$props4.innerTagName,\n          itemData = _this$props4.itemData,\n          _this$props4$itemKey = _this$props4.itemKey,\n          itemKey = _this$props4$itemKey === void 0 ? defaultItemKey : _this$props4$itemKey,\n          outerElementType = _this$props4.outerElementType,\n          outerTagName = _this$props4.outerTagName,\n          rowCount = _this$props4.rowCount,\n          style = _this$props4.style,\n          useIsScrolling = _this$props4.useIsScrolling,\n          width = _this$props4.width;\n      var isScrolling = this.state.isScrolling;\n\n      var _this$_getHorizontalR = this._getHorizontalRangeToRender(),\n          columnStartIndex = _this$_getHorizontalR[0],\n          columnStopIndex = _this$_getHorizontalR[1];\n\n      var _this$_getVerticalRan = this._getVerticalRangeToRender(),\n          rowStartIndex = _this$_getVerticalRan[0],\n          rowStopIndex = _this$_getVerticalRan[1];\n\n      var items = [];\n\n      if (columnCount > 0 && rowCount) {\n        for (var _rowIndex = rowStartIndex; _rowIndex <= rowStopIndex; _rowIndex++) {\n          for (var _columnIndex = columnStartIndex; _columnIndex <= columnStopIndex; _columnIndex++) {\n            items.push(createElement(children, {\n              columnIndex: _columnIndex,\n              data: itemData,\n              isScrolling: useIsScrolling ? isScrolling : undefined,\n              key: itemKey({\n                columnIndex: _columnIndex,\n                data: itemData,\n                rowIndex: _rowIndex\n              }),\n              rowIndex: _rowIndex,\n              style: this._getItemStyle(_rowIndex, _columnIndex)\n            }));\n          }\n        }\n      } // Read this value AFTER items have been created,\n      // So their actual sizes (if variable) are taken into consideration.\n\n\n      var estimatedTotalHeight = getEstimatedTotalHeight(this.props, this._instanceProps);\n      var estimatedTotalWidth = getEstimatedTotalWidth(this.props, this._instanceProps);\n      return createElement(outerElementType || outerTagName || 'div', {\n        className: className,\n        onScroll: this._onScroll,\n        ref: this._outerRefSetter,\n        style: _extends({\n          position: 'relative',\n          height: height,\n          width: width,\n          overflow: 'auto',\n          WebkitOverflowScrolling: 'touch',\n          willChange: 'transform',\n          direction: direction\n        }, style)\n      }, createElement(innerElementType || innerTagName || 'div', {\n        children: items,\n        ref: innerRef,\n        style: {\n          height: estimatedTotalHeight,\n          pointerEvents: isScrolling ? 'none' : undefined,\n          width: estimatedTotalWidth\n        }\n      }));\n    };\n\n    _proto._callPropsCallbacks = function _callPropsCallbacks() {\n      var _this$props5 = this.props,\n          columnCount = _this$props5.columnCount,\n          onItemsRendered = _this$props5.onItemsRendered,\n          onScroll = _this$props5.onScroll,\n          rowCount = _this$props5.rowCount;\n\n      if (typeof onItemsRendered === 'function') {\n        if (columnCount > 0 && rowCount > 0) {\n          var _this$_getHorizontalR2 = this._getHorizontalRangeToRender(),\n              _overscanColumnStartIndex = _this$_getHorizontalR2[0],\n              _overscanColumnStopIndex = _this$_getHorizontalR2[1],\n              _visibleColumnStartIndex = _this$_getHorizontalR2[2],\n              _visibleColumnStopIndex = _this$_getHorizontalR2[3];\n\n          var _this$_getVerticalRan2 = this._getVerticalRangeToRender(),\n              _overscanRowStartIndex = _this$_getVerticalRan2[0],\n              _overscanRowStopIndex = _this$_getVerticalRan2[1],\n              _visibleRowStartIndex = _this$_getVerticalRan2[2],\n              _visibleRowStopIndex = _this$_getVerticalRan2[3];\n\n          this._callOnItemsRendered(_overscanColumnStartIndex, _overscanColumnStopIndex, _overscanRowStartIndex, _overscanRowStopIndex, _visibleColumnStartIndex, _visibleColumnStopIndex, _visibleRowStartIndex, _visibleRowStopIndex);\n        }\n      }\n\n      if (typeof onScroll === 'function') {\n        var _this$state3 = this.state,\n            _horizontalScrollDirection = _this$state3.horizontalScrollDirection,\n            _scrollLeft = _this$state3.scrollLeft,\n            _scrollTop = _this$state3.scrollTop,\n            _scrollUpdateWasRequested = _this$state3.scrollUpdateWasRequested,\n            _verticalScrollDirection = _this$state3.verticalScrollDirection;\n\n        this._callOnScroll(_scrollLeft, _scrollTop, _horizontalScrollDirection, _verticalScrollDirection, _scrollUpdateWasRequested);\n      }\n    } // Lazily create and cache item styles while scrolling,\n    // So that pure component sCU will prevent re-renders.\n    // We maintain this cache, and pass a style prop rather than index,\n    // So that List can clear cached styles and force item re-render if necessary.\n    ;\n\n    _proto._getHorizontalRangeToRender = function _getHorizontalRangeToRender() {\n      var _this$props6 = this.props,\n          columnCount = _this$props6.columnCount,\n          overscanColumnCount = _this$props6.overscanColumnCount,\n          overscanColumnsCount = _this$props6.overscanColumnsCount,\n          overscanCount = _this$props6.overscanCount,\n          rowCount = _this$props6.rowCount;\n      var _this$state4 = this.state,\n          horizontalScrollDirection = _this$state4.horizontalScrollDirection,\n          isScrolling = _this$state4.isScrolling,\n          scrollLeft = _this$state4.scrollLeft;\n      var overscanCountResolved = overscanColumnCount || overscanColumnsCount || overscanCount || 1;\n\n      if (columnCount === 0 || rowCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      var startIndex = getColumnStartIndexForOffset(this.props, scrollLeft, this._instanceProps);\n      var stopIndex = getColumnStopIndexForStartIndex(this.props, startIndex, scrollLeft, this._instanceProps); // Overscan by one item in each direction so that tab/focus works.\n      // If there isn't at least one extra item, tab loops back around.\n\n      var overscanBackward = !isScrolling || horizontalScrollDirection === 'backward' ? Math.max(1, overscanCountResolved) : 1;\n      var overscanForward = !isScrolling || horizontalScrollDirection === 'forward' ? Math.max(1, overscanCountResolved) : 1;\n      return [Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(columnCount - 1, stopIndex + overscanForward)), startIndex, stopIndex];\n    };\n\n    _proto._getVerticalRangeToRender = function _getVerticalRangeToRender() {\n      var _this$props7 = this.props,\n          columnCount = _this$props7.columnCount,\n          overscanCount = _this$props7.overscanCount,\n          overscanRowCount = _this$props7.overscanRowCount,\n          overscanRowsCount = _this$props7.overscanRowsCount,\n          rowCount = _this$props7.rowCount;\n      var _this$state5 = this.state,\n          isScrolling = _this$state5.isScrolling,\n          verticalScrollDirection = _this$state5.verticalScrollDirection,\n          scrollTop = _this$state5.scrollTop;\n      var overscanCountResolved = overscanRowCount || overscanRowsCount || overscanCount || 1;\n\n      if (columnCount === 0 || rowCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      var startIndex = getRowStartIndexForOffset(this.props, scrollTop, this._instanceProps);\n      var stopIndex = getRowStopIndexForStartIndex(this.props, startIndex, scrollTop, this._instanceProps); // Overscan by one item in each direction so that tab/focus works.\n      // If there isn't at least one extra item, tab loops back around.\n\n      var overscanBackward = !isScrolling || verticalScrollDirection === 'backward' ? Math.max(1, overscanCountResolved) : 1;\n      var overscanForward = !isScrolling || verticalScrollDirection === 'forward' ? Math.max(1, overscanCountResolved) : 1;\n      return [Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(rowCount - 1, stopIndex + overscanForward)), startIndex, stopIndex];\n    };\n\n    return Grid;\n  }(PureComponent), _class.defaultProps = {\n    direction: 'ltr',\n    itemData: undefined,\n    useIsScrolling: false\n  }, _class;\n}\n\nvar validateSharedProps = function validateSharedProps(_ref5, _ref6) {\n  var children = _ref5.children,\n      direction = _ref5.direction,\n      height = _ref5.height,\n      innerTagName = _ref5.innerTagName,\n      outerTagName = _ref5.outerTagName,\n      overscanColumnsCount = _ref5.overscanColumnsCount,\n      overscanCount = _ref5.overscanCount,\n      overscanRowsCount = _ref5.overscanRowsCount,\n      width = _ref5.width;\n  var instance = _ref6.instance;\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof overscanCount === 'number') {\n      if (devWarningsOverscanCount && !devWarningsOverscanCount.has(instance)) {\n        devWarningsOverscanCount.add(instance);\n        console.warn('The overscanCount prop has been deprecated. ' + 'Please use the overscanColumnCount and overscanRowCount props instead.');\n      }\n    }\n\n    if (typeof overscanColumnsCount === 'number' || typeof overscanRowsCount === 'number') {\n      if (devWarningsOverscanRowsColumnsCount && !devWarningsOverscanRowsColumnsCount.has(instance)) {\n        devWarningsOverscanRowsColumnsCount.add(instance);\n        console.warn('The overscanColumnsCount and overscanRowsCount props have been deprecated. ' + 'Please use the overscanColumnCount and overscanRowCount props instead.');\n      }\n    }\n\n    if (innerTagName != null || outerTagName != null) {\n      if (devWarningsTagName && !devWarningsTagName.has(instance)) {\n        devWarningsTagName.add(instance);\n        console.warn('The innerTagName and outerTagName props have been deprecated. ' + 'Please use the innerElementType and outerElementType props instead.');\n      }\n    }\n\n    if (children == null) {\n      throw Error('An invalid \"children\" prop has been specified. ' + 'Value should be a React component. ' + (\"\\\"\" + (children === null ? 'null' : typeof children) + \"\\\" was specified.\"));\n    }\n\n    switch (direction) {\n      case 'ltr':\n      case 'rtl':\n        // Valid values\n        break;\n\n      default:\n        throw Error('An invalid \"direction\" prop has been specified. ' + 'Value should be either \"ltr\" or \"rtl\". ' + (\"\\\"\" + direction + \"\\\" was specified.\"));\n    }\n\n    if (typeof width !== 'number') {\n      throw Error('An invalid \"width\" prop has been specified. ' + 'Grids must specify a number for width. ' + (\"\\\"\" + (width === null ? 'null' : typeof width) + \"\\\" was specified.\"));\n    }\n\n    if (typeof height !== 'number') {\n      throw Error('An invalid \"height\" prop has been specified. ' + 'Grids must specify a number for height. ' + (\"\\\"\" + (height === null ? 'null' : typeof height) + \"\\\" was specified.\"));\n    }\n  }\n};\n\nvar DEFAULT_ESTIMATED_ITEM_SIZE = 50;\n\nvar getEstimatedTotalHeight = function getEstimatedTotalHeight(_ref, _ref2) {\n  var rowCount = _ref.rowCount;\n  var rowMetadataMap = _ref2.rowMetadataMap,\n      estimatedRowHeight = _ref2.estimatedRowHeight,\n      lastMeasuredRowIndex = _ref2.lastMeasuredRowIndex;\n  var totalSizeOfMeasuredRows = 0; // Edge case check for when the number of items decreases while a scroll is in progress.\n  // https://github.com/bvaughn/react-window/pull/138\n\n  if (lastMeasuredRowIndex >= rowCount) {\n    lastMeasuredRowIndex = rowCount - 1;\n  }\n\n  if (lastMeasuredRowIndex >= 0) {\n    var itemMetadata = rowMetadataMap[lastMeasuredRowIndex];\n    totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;\n  }\n\n  var numUnmeasuredItems = rowCount - lastMeasuredRowIndex - 1;\n  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedRowHeight;\n  return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;\n};\n\nvar getEstimatedTotalWidth = function getEstimatedTotalWidth(_ref3, _ref4) {\n  var columnCount = _ref3.columnCount;\n  var columnMetadataMap = _ref4.columnMetadataMap,\n      estimatedColumnWidth = _ref4.estimatedColumnWidth,\n      lastMeasuredColumnIndex = _ref4.lastMeasuredColumnIndex;\n  var totalSizeOfMeasuredRows = 0; // Edge case check for when the number of items decreases while a scroll is in progress.\n  // https://github.com/bvaughn/react-window/pull/138\n\n  if (lastMeasuredColumnIndex >= columnCount) {\n    lastMeasuredColumnIndex = columnCount - 1;\n  }\n\n  if (lastMeasuredColumnIndex >= 0) {\n    var itemMetadata = columnMetadataMap[lastMeasuredColumnIndex];\n    totalSizeOfMeasuredRows = itemMetadata.offset + itemMetadata.size;\n  }\n\n  var numUnmeasuredItems = columnCount - lastMeasuredColumnIndex - 1;\n  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedColumnWidth;\n  return totalSizeOfMeasuredRows + totalSizeOfUnmeasuredItems;\n};\n\nvar getItemMetadata = function getItemMetadata(itemType, props, index, instanceProps) {\n  var itemMetadataMap, itemSize, lastMeasuredIndex;\n\n  if (itemType === 'column') {\n    itemMetadataMap = instanceProps.columnMetadataMap;\n    itemSize = props.columnWidth;\n    lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;\n  } else {\n    itemMetadataMap = instanceProps.rowMetadataMap;\n    itemSize = props.rowHeight;\n    lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;\n  }\n\n  if (index > lastMeasuredIndex) {\n    var offset = 0;\n\n    if (lastMeasuredIndex >= 0) {\n      var itemMetadata = itemMetadataMap[lastMeasuredIndex];\n      offset = itemMetadata.offset + itemMetadata.size;\n    }\n\n    for (var i = lastMeasuredIndex + 1; i <= index; i++) {\n      var size = itemSize(i);\n      itemMetadataMap[i] = {\n        offset: offset,\n        size: size\n      };\n      offset += size;\n    }\n\n    if (itemType === 'column') {\n      instanceProps.lastMeasuredColumnIndex = index;\n    } else {\n      instanceProps.lastMeasuredRowIndex = index;\n    }\n  }\n\n  return itemMetadataMap[index];\n};\n\nvar findNearestItem = function findNearestItem(itemType, props, instanceProps, offset) {\n  var itemMetadataMap, lastMeasuredIndex;\n\n  if (itemType === 'column') {\n    itemMetadataMap = instanceProps.columnMetadataMap;\n    lastMeasuredIndex = instanceProps.lastMeasuredColumnIndex;\n  } else {\n    itemMetadataMap = instanceProps.rowMetadataMap;\n    lastMeasuredIndex = instanceProps.lastMeasuredRowIndex;\n  }\n\n  var lastMeasuredItemOffset = lastMeasuredIndex > 0 ? itemMetadataMap[lastMeasuredIndex].offset : 0;\n\n  if (lastMeasuredItemOffset >= offset) {\n    // If we've already measured items within this range just use a binary search as it's faster.\n    return findNearestItemBinarySearch(itemType, props, instanceProps, lastMeasuredIndex, 0, offset);\n  } else {\n    // If we haven't yet measured this high, fallback to an exponential search with an inner binary search.\n    // The exponential search avoids pre-computing sizes for the full set of items as a binary search would.\n    // The overall complexity for this approach is O(log n).\n    return findNearestItemExponentialSearch(itemType, props, instanceProps, Math.max(0, lastMeasuredIndex), offset);\n  }\n};\n\nvar findNearestItemBinarySearch = function findNearestItemBinarySearch(itemType, props, instanceProps, high, low, offset) {\n  while (low <= high) {\n    var middle = low + Math.floor((high - low) / 2);\n    var currentOffset = getItemMetadata(itemType, props, middle, instanceProps).offset;\n\n    if (currentOffset === offset) {\n      return middle;\n    } else if (currentOffset < offset) {\n      low = middle + 1;\n    } else if (currentOffset > offset) {\n      high = middle - 1;\n    }\n  }\n\n  if (low > 0) {\n    return low - 1;\n  } else {\n    return 0;\n  }\n};\n\nvar findNearestItemExponentialSearch = function findNearestItemExponentialSearch(itemType, props, instanceProps, index, offset) {\n  var itemCount = itemType === 'column' ? props.columnCount : props.rowCount;\n  var interval = 1;\n\n  while (index < itemCount && getItemMetadata(itemType, props, index, instanceProps).offset < offset) {\n    index += interval;\n    interval *= 2;\n  }\n\n  return findNearestItemBinarySearch(itemType, props, instanceProps, Math.min(index, itemCount - 1), Math.floor(index / 2), offset);\n};\n\nvar getOffsetForIndexAndAlignment = function getOffsetForIndexAndAlignment(itemType, props, index, align, scrollOffset, instanceProps, scrollbarSize) {\n  var size = itemType === 'column' ? props.width : props.height;\n  var itemMetadata = getItemMetadata(itemType, props, index, instanceProps); // Get estimated total size after ItemMetadata is computed,\n  // To ensure it reflects actual measurements instead of just estimates.\n\n  var estimatedTotalSize = itemType === 'column' ? getEstimatedTotalWidth(props, instanceProps) : getEstimatedTotalHeight(props, instanceProps);\n  var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, itemMetadata.offset));\n  var minOffset = Math.max(0, itemMetadata.offset - size + scrollbarSize + itemMetadata.size);\n\n  if (align === 'smart') {\n    if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {\n      align = 'auto';\n    } else {\n      align = 'center';\n    }\n  }\n\n  switch (align) {\n    case 'start':\n      return maxOffset;\n\n    case 'end':\n      return minOffset;\n\n    case 'center':\n      return Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n    case 'auto':\n    default:\n      if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {\n        return scrollOffset;\n      } else if (minOffset > maxOffset) {\n        // Because we only take into account the scrollbar size when calculating minOffset\n        // this value can be larger than maxOffset when at the end of the list\n        return minOffset;\n      } else if (scrollOffset < minOffset) {\n        return minOffset;\n      } else {\n        return maxOffset;\n      }\n\n  }\n};\n\nvar VariableSizeGrid = /*#__PURE__*/createGridComponent({\n  getColumnOffset: function getColumnOffset(props, index, instanceProps) {\n    return getItemMetadata('column', props, index, instanceProps).offset;\n  },\n  getColumnStartIndexForOffset: function getColumnStartIndexForOffset(props, scrollLeft, instanceProps) {\n    return findNearestItem('column', props, instanceProps, scrollLeft);\n  },\n  getColumnStopIndexForStartIndex: function getColumnStopIndexForStartIndex(props, startIndex, scrollLeft, instanceProps) {\n    var columnCount = props.columnCount,\n        width = props.width;\n    var itemMetadata = getItemMetadata('column', props, startIndex, instanceProps);\n    var maxOffset = scrollLeft + width;\n    var offset = itemMetadata.offset + itemMetadata.size;\n    var stopIndex = startIndex;\n\n    while (stopIndex < columnCount - 1 && offset < maxOffset) {\n      stopIndex++;\n      offset += getItemMetadata('column', props, stopIndex, instanceProps).size;\n    }\n\n    return stopIndex;\n  },\n  getColumnWidth: function getColumnWidth(props, index, instanceProps) {\n    return instanceProps.columnMetadataMap[index].size;\n  },\n  getEstimatedTotalHeight: getEstimatedTotalHeight,\n  getEstimatedTotalWidth: getEstimatedTotalWidth,\n  getOffsetForColumnAndAlignment: function getOffsetForColumnAndAlignment(props, index, align, scrollOffset, instanceProps, scrollbarSize) {\n    return getOffsetForIndexAndAlignment('column', props, index, align, scrollOffset, instanceProps, scrollbarSize);\n  },\n  getOffsetForRowAndAlignment: function getOffsetForRowAndAlignment(props, index, align, scrollOffset, instanceProps, scrollbarSize) {\n    return getOffsetForIndexAndAlignment('row', props, index, align, scrollOffset, instanceProps, scrollbarSize);\n  },\n  getRowOffset: function getRowOffset(props, index, instanceProps) {\n    return getItemMetadata('row', props, index, instanceProps).offset;\n  },\n  getRowHeight: function getRowHeight(props, index, instanceProps) {\n    return instanceProps.rowMetadataMap[index].size;\n  },\n  getRowStartIndexForOffset: function getRowStartIndexForOffset(props, scrollTop, instanceProps) {\n    return findNearestItem('row', props, instanceProps, scrollTop);\n  },\n  getRowStopIndexForStartIndex: function getRowStopIndexForStartIndex(props, startIndex, scrollTop, instanceProps) {\n    var rowCount = props.rowCount,\n        height = props.height;\n    var itemMetadata = getItemMetadata('row', props, startIndex, instanceProps);\n    var maxOffset = scrollTop + height;\n    var offset = itemMetadata.offset + itemMetadata.size;\n    var stopIndex = startIndex;\n\n    while (stopIndex < rowCount - 1 && offset < maxOffset) {\n      stopIndex++;\n      offset += getItemMetadata('row', props, stopIndex, instanceProps).size;\n    }\n\n    return stopIndex;\n  },\n  initInstanceProps: function initInstanceProps(props, instance) {\n    var _ref5 = props,\n        estimatedColumnWidth = _ref5.estimatedColumnWidth,\n        estimatedRowHeight = _ref5.estimatedRowHeight;\n    var instanceProps = {\n      columnMetadataMap: {},\n      estimatedColumnWidth: estimatedColumnWidth || DEFAULT_ESTIMATED_ITEM_SIZE,\n      estimatedRowHeight: estimatedRowHeight || DEFAULT_ESTIMATED_ITEM_SIZE,\n      lastMeasuredColumnIndex: -1,\n      lastMeasuredRowIndex: -1,\n      rowMetadataMap: {}\n    };\n\n    instance.resetAfterColumnIndex = function (columnIndex, shouldForceUpdate) {\n      if (shouldForceUpdate === void 0) {\n        shouldForceUpdate = true;\n      }\n\n      instance.resetAfterIndices({\n        columnIndex: columnIndex,\n        shouldForceUpdate: shouldForceUpdate\n      });\n    };\n\n    instance.resetAfterRowIndex = function (rowIndex, shouldForceUpdate) {\n      if (shouldForceUpdate === void 0) {\n        shouldForceUpdate = true;\n      }\n\n      instance.resetAfterIndices({\n        rowIndex: rowIndex,\n        shouldForceUpdate: shouldForceUpdate\n      });\n    };\n\n    instance.resetAfterIndices = function (_ref6) {\n      var columnIndex = _ref6.columnIndex,\n          rowIndex = _ref6.rowIndex,\n          _ref6$shouldForceUpda = _ref6.shouldForceUpdate,\n          shouldForceUpdate = _ref6$shouldForceUpda === void 0 ? true : _ref6$shouldForceUpda;\n\n      if (typeof columnIndex === 'number') {\n        instanceProps.lastMeasuredColumnIndex = Math.min(instanceProps.lastMeasuredColumnIndex, columnIndex - 1);\n      }\n\n      if (typeof rowIndex === 'number') {\n        instanceProps.lastMeasuredRowIndex = Math.min(instanceProps.lastMeasuredRowIndex, rowIndex - 1);\n      } // We could potentially optimize further by only evicting styles after this index,\n      // But since styles are only cached while scrolling is in progress-\n      // It seems an unnecessary optimization.\n      // It's unlikely that resetAfterIndex() will be called while a user is scrolling.\n\n\n      instance._getItemStyleCache(-1);\n\n      if (shouldForceUpdate) {\n        instance.forceUpdate();\n      }\n    };\n\n    return instanceProps;\n  },\n  shouldResetStyleCacheOnItemSizeChange: false,\n  validateProps: function validateProps(_ref7) {\n    var columnWidth = _ref7.columnWidth,\n        rowHeight = _ref7.rowHeight;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof columnWidth !== 'function') {\n        throw Error('An invalid \"columnWidth\" prop has been specified. ' + 'Value should be a function. ' + (\"\\\"\" + (columnWidth === null ? 'null' : typeof columnWidth) + \"\\\" was specified.\"));\n      } else if (typeof rowHeight !== 'function') {\n        throw Error('An invalid \"rowHeight\" prop has been specified. ' + 'Value should be a function. ' + (\"\\\"\" + (rowHeight === null ? 'null' : typeof rowHeight) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\nvar IS_SCROLLING_DEBOUNCE_INTERVAL$1 = 150;\n\nvar defaultItemKey$1 = function defaultItemKey(index, data) {\n  return index;\n}; // In DEV mode, this Set helps us only log a warning once per component instance.\n// This avoids spamming the console every time a render happens.\n\n\nvar devWarningsDirection = null;\nvar devWarningsTagName$1 = null;\n\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof window !== 'undefined' && typeof window.WeakSet !== 'undefined') {\n    devWarningsDirection = /*#__PURE__*/new WeakSet();\n    devWarningsTagName$1 = /*#__PURE__*/new WeakSet();\n  }\n}\n\nfunction createListComponent(_ref) {\n  var _class;\n\n  var getItemOffset = _ref.getItemOffset,\n      getEstimatedTotalSize = _ref.getEstimatedTotalSize,\n      getItemSize = _ref.getItemSize,\n      getOffsetForIndexAndAlignment = _ref.getOffsetForIndexAndAlignment,\n      getStartIndexForOffset = _ref.getStartIndexForOffset,\n      getStopIndexForStartIndex = _ref.getStopIndexForStartIndex,\n      initInstanceProps = _ref.initInstanceProps,\n      shouldResetStyleCacheOnItemSizeChange = _ref.shouldResetStyleCacheOnItemSizeChange,\n      validateProps = _ref.validateProps;\n  return _class = /*#__PURE__*/function (_PureComponent) {\n    _inheritsLoose(List, _PureComponent);\n\n    // Always use explicit constructor for React components.\n    // It produces less code after transpilation. (#26)\n    // eslint-disable-next-line no-useless-constructor\n    function List(props) {\n      var _this;\n\n      _this = _PureComponent.call(this, props) || this;\n      _this._instanceProps = initInstanceProps(_this.props, _assertThisInitialized(_this));\n      _this._outerRef = void 0;\n      _this._resetIsScrollingTimeoutId = null;\n      _this.state = {\n        instance: _assertThisInitialized(_this),\n        isScrolling: false,\n        scrollDirection: 'forward',\n        scrollOffset: typeof _this.props.initialScrollOffset === 'number' ? _this.props.initialScrollOffset : 0,\n        scrollUpdateWasRequested: false\n      };\n      _this._callOnItemsRendered = void 0;\n      _this._callOnItemsRendered = memoizeOne(function (overscanStartIndex, overscanStopIndex, visibleStartIndex, visibleStopIndex) {\n        return _this.props.onItemsRendered({\n          overscanStartIndex: overscanStartIndex,\n          overscanStopIndex: overscanStopIndex,\n          visibleStartIndex: visibleStartIndex,\n          visibleStopIndex: visibleStopIndex\n        });\n      });\n      _this._callOnScroll = void 0;\n      _this._callOnScroll = memoizeOne(function (scrollDirection, scrollOffset, scrollUpdateWasRequested) {\n        return _this.props.onScroll({\n          scrollDirection: scrollDirection,\n          scrollOffset: scrollOffset,\n          scrollUpdateWasRequested: scrollUpdateWasRequested\n        });\n      });\n      _this._getItemStyle = void 0;\n\n      _this._getItemStyle = function (index) {\n        var _this$props = _this.props,\n            direction = _this$props.direction,\n            itemSize = _this$props.itemSize,\n            layout = _this$props.layout;\n\n        var itemStyleCache = _this._getItemStyleCache(shouldResetStyleCacheOnItemSizeChange && itemSize, shouldResetStyleCacheOnItemSizeChange && layout, shouldResetStyleCacheOnItemSizeChange && direction);\n\n        var style;\n\n        if (itemStyleCache.hasOwnProperty(index)) {\n          style = itemStyleCache[index];\n        } else {\n          var _offset = getItemOffset(_this.props, index, _this._instanceProps);\n\n          var size = getItemSize(_this.props, index, _this._instanceProps); // TODO Deprecate direction \"horizontal\"\n\n          var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n          var isRtl = direction === 'rtl';\n          var offsetHorizontal = isHorizontal ? _offset : 0;\n          itemStyleCache[index] = style = {\n            position: 'absolute',\n            left: isRtl ? undefined : offsetHorizontal,\n            right: isRtl ? offsetHorizontal : undefined,\n            top: !isHorizontal ? _offset : 0,\n            height: !isHorizontal ? size : '100%',\n            width: isHorizontal ? size : '100%'\n          };\n        }\n\n        return style;\n      };\n\n      _this._getItemStyleCache = void 0;\n      _this._getItemStyleCache = memoizeOne(function (_, __, ___) {\n        return {};\n      });\n\n      _this._onScrollHorizontal = function (event) {\n        var _event$currentTarget = event.currentTarget,\n            clientWidth = _event$currentTarget.clientWidth,\n            scrollLeft = _event$currentTarget.scrollLeft,\n            scrollWidth = _event$currentTarget.scrollWidth;\n\n        _this.setState(function (prevState) {\n          if (prevState.scrollOffset === scrollLeft) {\n            // Scroll position may have been updated by cDM/cDU,\n            // In which case we don't need to trigger another render,\n            // And we don't want to update state.isScrolling.\n            return null;\n          }\n\n          var direction = _this.props.direction;\n          var scrollOffset = scrollLeft;\n\n          if (direction === 'rtl') {\n            // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n            // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n            // It's also easier for this component if we convert offsets to the same format as they would be in for ltr.\n            // So the simplest solution is to determine which browser behavior we're dealing with, and convert based on it.\n            switch (getRTLOffsetType()) {\n              case 'negative':\n                scrollOffset = -scrollLeft;\n                break;\n\n              case 'positive-descending':\n                scrollOffset = scrollWidth - clientWidth - scrollLeft;\n                break;\n            }\n          } // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n\n\n          scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));\n          return {\n            isScrolling: true,\n            scrollDirection: prevState.scrollOffset < scrollLeft ? 'forward' : 'backward',\n            scrollOffset: scrollOffset,\n            scrollUpdateWasRequested: false\n          };\n        }, _this._resetIsScrollingDebounced);\n      };\n\n      _this._onScrollVertical = function (event) {\n        var _event$currentTarget2 = event.currentTarget,\n            clientHeight = _event$currentTarget2.clientHeight,\n            scrollHeight = _event$currentTarget2.scrollHeight,\n            scrollTop = _event$currentTarget2.scrollTop;\n\n        _this.setState(function (prevState) {\n          if (prevState.scrollOffset === scrollTop) {\n            // Scroll position may have been updated by cDM/cDU,\n            // In which case we don't need to trigger another render,\n            // And we don't want to update state.isScrolling.\n            return null;\n          } // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n\n\n          var scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));\n          return {\n            isScrolling: true,\n            scrollDirection: prevState.scrollOffset < scrollOffset ? 'forward' : 'backward',\n            scrollOffset: scrollOffset,\n            scrollUpdateWasRequested: false\n          };\n        }, _this._resetIsScrollingDebounced);\n      };\n\n      _this._outerRefSetter = function (ref) {\n        var outerRef = _this.props.outerRef;\n        _this._outerRef = ref;\n\n        if (typeof outerRef === 'function') {\n          outerRef(ref);\n        } else if (outerRef != null && typeof outerRef === 'object' && outerRef.hasOwnProperty('current')) {\n          outerRef.current = ref;\n        }\n      };\n\n      _this._resetIsScrollingDebounced = function () {\n        if (_this._resetIsScrollingTimeoutId !== null) {\n          cancelTimeout(_this._resetIsScrollingTimeoutId);\n        }\n\n        _this._resetIsScrollingTimeoutId = requestTimeout(_this._resetIsScrolling, IS_SCROLLING_DEBOUNCE_INTERVAL$1);\n      };\n\n      _this._resetIsScrolling = function () {\n        _this._resetIsScrollingTimeoutId = null;\n\n        _this.setState({\n          isScrolling: false\n        }, function () {\n          // Clear style cache after state update has been committed.\n          // This way we don't break pure sCU for items that don't use isScrolling param.\n          _this._getItemStyleCache(-1, null);\n        });\n      };\n\n      return _this;\n    }\n\n    List.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n      validateSharedProps$1(nextProps, prevState);\n      validateProps(nextProps);\n      return null;\n    };\n\n    var _proto = List.prototype;\n\n    _proto.scrollTo = function scrollTo(scrollOffset) {\n      scrollOffset = Math.max(0, scrollOffset);\n      this.setState(function (prevState) {\n        if (prevState.scrollOffset === scrollOffset) {\n          return null;\n        }\n\n        return {\n          scrollDirection: prevState.scrollOffset < scrollOffset ? 'forward' : 'backward',\n          scrollOffset: scrollOffset,\n          scrollUpdateWasRequested: true\n        };\n      }, this._resetIsScrollingDebounced);\n    };\n\n    _proto.scrollToItem = function scrollToItem(index, align) {\n      if (align === void 0) {\n        align = 'auto';\n      }\n\n      var itemCount = this.props.itemCount;\n      var scrollOffset = this.state.scrollOffset;\n      index = Math.max(0, Math.min(index, itemCount - 1));\n      this.scrollTo(getOffsetForIndexAndAlignment(this.props, index, align, scrollOffset, this._instanceProps));\n    };\n\n    _proto.componentDidMount = function componentDidMount() {\n      var _this$props2 = this.props,\n          direction = _this$props2.direction,\n          initialScrollOffset = _this$props2.initialScrollOffset,\n          layout = _this$props2.layout;\n\n      if (typeof initialScrollOffset === 'number' && this._outerRef != null) {\n        var outerRef = this._outerRef; // TODO Deprecate direction \"horizontal\"\n\n        if (direction === 'horizontal' || layout === 'horizontal') {\n          outerRef.scrollLeft = initialScrollOffset;\n        } else {\n          outerRef.scrollTop = initialScrollOffset;\n        }\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentDidUpdate = function componentDidUpdate() {\n      var _this$props3 = this.props,\n          direction = _this$props3.direction,\n          layout = _this$props3.layout;\n      var _this$state = this.state,\n          scrollOffset = _this$state.scrollOffset,\n          scrollUpdateWasRequested = _this$state.scrollUpdateWasRequested;\n\n      if (scrollUpdateWasRequested && this._outerRef != null) {\n        var outerRef = this._outerRef; // TODO Deprecate direction \"horizontal\"\n\n        if (direction === 'horizontal' || layout === 'horizontal') {\n          if (direction === 'rtl') {\n            // TRICKY According to the spec, scrollLeft should be negative for RTL aligned elements.\n            // This is not the case for all browsers though (e.g. Chrome reports values as positive, measured relative to the left).\n            // So we need to determine which browser behavior we're dealing with, and mimic it.\n            switch (getRTLOffsetType()) {\n              case 'negative':\n                outerRef.scrollLeft = -scrollOffset;\n                break;\n\n              case 'positive-ascending':\n                outerRef.scrollLeft = scrollOffset;\n                break;\n\n              default:\n                var clientWidth = outerRef.clientWidth,\n                    scrollWidth = outerRef.scrollWidth;\n                outerRef.scrollLeft = scrollWidth - clientWidth - scrollOffset;\n                break;\n            }\n          } else {\n            outerRef.scrollLeft = scrollOffset;\n          }\n        } else {\n          outerRef.scrollTop = scrollOffset;\n        }\n      }\n\n      this._callPropsCallbacks();\n    };\n\n    _proto.componentWillUnmount = function componentWillUnmount() {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n    };\n\n    _proto.render = function render() {\n      var _this$props4 = this.props,\n          children = _this$props4.children,\n          className = _this$props4.className,\n          direction = _this$props4.direction,\n          height = _this$props4.height,\n          innerRef = _this$props4.innerRef,\n          innerElementType = _this$props4.innerElementType,\n          innerTagName = _this$props4.innerTagName,\n          itemCount = _this$props4.itemCount,\n          itemData = _this$props4.itemData,\n          _this$props4$itemKey = _this$props4.itemKey,\n          itemKey = _this$props4$itemKey === void 0 ? defaultItemKey$1 : _this$props4$itemKey,\n          layout = _this$props4.layout,\n          outerElementType = _this$props4.outerElementType,\n          outerTagName = _this$props4.outerTagName,\n          style = _this$props4.style,\n          useIsScrolling = _this$props4.useIsScrolling,\n          width = _this$props4.width;\n      var isScrolling = this.state.isScrolling; // TODO Deprecate direction \"horizontal\"\n\n      var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n      var onScroll = isHorizontal ? this._onScrollHorizontal : this._onScrollVertical;\n\n      var _this$_getRangeToRend = this._getRangeToRender(),\n          startIndex = _this$_getRangeToRend[0],\n          stopIndex = _this$_getRangeToRend[1];\n\n      var items = [];\n\n      if (itemCount > 0) {\n        for (var _index = startIndex; _index <= stopIndex; _index++) {\n          items.push(createElement(children, {\n            data: itemData,\n            key: itemKey(_index, itemData),\n            index: _index,\n            isScrolling: useIsScrolling ? isScrolling : undefined,\n            style: this._getItemStyle(_index)\n          }));\n        }\n      } // Read this value AFTER items have been created,\n      // So their actual sizes (if variable) are taken into consideration.\n\n\n      var estimatedTotalSize = getEstimatedTotalSize(this.props, this._instanceProps);\n      return createElement(outerElementType || outerTagName || 'div', {\n        className: className,\n        onScroll: onScroll,\n        ref: this._outerRefSetter,\n        style: _extends({\n          position: 'relative',\n          height: height,\n          width: width,\n          overflow: 'auto',\n          WebkitOverflowScrolling: 'touch',\n          willChange: 'transform',\n          direction: direction\n        }, style)\n      }, createElement(innerElementType || innerTagName || 'div', {\n        children: items,\n        ref: innerRef,\n        style: {\n          height: isHorizontal ? '100%' : estimatedTotalSize,\n          pointerEvents: isScrolling ? 'none' : undefined,\n          width: isHorizontal ? estimatedTotalSize : '100%'\n        }\n      }));\n    };\n\n    _proto._callPropsCallbacks = function _callPropsCallbacks() {\n      if (typeof this.props.onItemsRendered === 'function') {\n        var itemCount = this.props.itemCount;\n\n        if (itemCount > 0) {\n          var _this$_getRangeToRend2 = this._getRangeToRender(),\n              _overscanStartIndex = _this$_getRangeToRend2[0],\n              _overscanStopIndex = _this$_getRangeToRend2[1],\n              _visibleStartIndex = _this$_getRangeToRend2[2],\n              _visibleStopIndex = _this$_getRangeToRend2[3];\n\n          this._callOnItemsRendered(_overscanStartIndex, _overscanStopIndex, _visibleStartIndex, _visibleStopIndex);\n        }\n      }\n\n      if (typeof this.props.onScroll === 'function') {\n        var _this$state2 = this.state,\n            _scrollDirection = _this$state2.scrollDirection,\n            _scrollOffset = _this$state2.scrollOffset,\n            _scrollUpdateWasRequested = _this$state2.scrollUpdateWasRequested;\n\n        this._callOnScroll(_scrollDirection, _scrollOffset, _scrollUpdateWasRequested);\n      }\n    } // Lazily create and cache item styles while scrolling,\n    // So that pure component sCU will prevent re-renders.\n    // We maintain this cache, and pass a style prop rather than index,\n    // So that List can clear cached styles and force item re-render if necessary.\n    ;\n\n    _proto._getRangeToRender = function _getRangeToRender() {\n      var _this$props5 = this.props,\n          itemCount = _this$props5.itemCount,\n          overscanCount = _this$props5.overscanCount;\n      var _this$state3 = this.state,\n          isScrolling = _this$state3.isScrolling,\n          scrollDirection = _this$state3.scrollDirection,\n          scrollOffset = _this$state3.scrollOffset;\n\n      if (itemCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      var startIndex = getStartIndexForOffset(this.props, scrollOffset, this._instanceProps);\n      var stopIndex = getStopIndexForStartIndex(this.props, startIndex, scrollOffset, this._instanceProps); // Overscan by one item in each direction so that tab/focus works.\n      // If there isn't at least one extra item, tab loops back around.\n\n      var overscanBackward = !isScrolling || scrollDirection === 'backward' ? Math.max(1, overscanCount) : 1;\n      var overscanForward = !isScrolling || scrollDirection === 'forward' ? Math.max(1, overscanCount) : 1;\n      return [Math.max(0, startIndex - overscanBackward), Math.max(0, Math.min(itemCount - 1, stopIndex + overscanForward)), startIndex, stopIndex];\n    };\n\n    return List;\n  }(PureComponent), _class.defaultProps = {\n    direction: 'ltr',\n    itemData: undefined,\n    layout: 'vertical',\n    overscanCount: 2,\n    useIsScrolling: false\n  }, _class;\n} // NOTE: I considered further wrapping individual items with a pure ListItem component.\n// This would avoid ever calling the render function for the same index more than once,\n// But it would also add the overhead of a lot of components/fibers.\n// I assume people already do this (render function returning a class component),\n// So my doing it would just unnecessarily double the wrappers.\n\nvar validateSharedProps$1 = function validateSharedProps(_ref2, _ref3) {\n  var children = _ref2.children,\n      direction = _ref2.direction,\n      height = _ref2.height,\n      layout = _ref2.layout,\n      innerTagName = _ref2.innerTagName,\n      outerTagName = _ref2.outerTagName,\n      width = _ref2.width;\n  var instance = _ref3.instance;\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (innerTagName != null || outerTagName != null) {\n      if (devWarningsTagName$1 && !devWarningsTagName$1.has(instance)) {\n        devWarningsTagName$1.add(instance);\n        console.warn('The innerTagName and outerTagName props have been deprecated. ' + 'Please use the innerElementType and outerElementType props instead.');\n      }\n    } // TODO Deprecate direction \"horizontal\"\n\n\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n\n    switch (direction) {\n      case 'horizontal':\n      case 'vertical':\n        if (devWarningsDirection && !devWarningsDirection.has(instance)) {\n          devWarningsDirection.add(instance);\n          console.warn('The direction prop should be either \"ltr\" (default) or \"rtl\". ' + 'Please use the layout prop to specify \"vertical\" (default) or \"horizontal\" orientation.');\n        }\n\n        break;\n\n      case 'ltr':\n      case 'rtl':\n        // Valid values\n        break;\n\n      default:\n        throw Error('An invalid \"direction\" prop has been specified. ' + 'Value should be either \"ltr\" or \"rtl\". ' + (\"\\\"\" + direction + \"\\\" was specified.\"));\n    }\n\n    switch (layout) {\n      case 'horizontal':\n      case 'vertical':\n        // Valid values\n        break;\n\n      default:\n        throw Error('An invalid \"layout\" prop has been specified. ' + 'Value should be either \"horizontal\" or \"vertical\". ' + (\"\\\"\" + layout + \"\\\" was specified.\"));\n    }\n\n    if (children == null) {\n      throw Error('An invalid \"children\" prop has been specified. ' + 'Value should be a React component. ' + (\"\\\"\" + (children === null ? 'null' : typeof children) + \"\\\" was specified.\"));\n    }\n\n    if (isHorizontal && typeof width !== 'number') {\n      throw Error('An invalid \"width\" prop has been specified. ' + 'Horizontal lists must specify a number for width. ' + (\"\\\"\" + (width === null ? 'null' : typeof width) + \"\\\" was specified.\"));\n    } else if (!isHorizontal && typeof height !== 'number') {\n      throw Error('An invalid \"height\" prop has been specified. ' + 'Vertical lists must specify a number for height. ' + (\"\\\"\" + (height === null ? 'null' : typeof height) + \"\\\" was specified.\"));\n    }\n  }\n};\n\nvar DEFAULT_ESTIMATED_ITEM_SIZE$1 = 50;\n\nvar getItemMetadata$1 = function getItemMetadata(props, index, instanceProps) {\n  var _ref = props,\n      itemSize = _ref.itemSize;\n  var itemMetadataMap = instanceProps.itemMetadataMap,\n      lastMeasuredIndex = instanceProps.lastMeasuredIndex;\n\n  if (index > lastMeasuredIndex) {\n    var offset = 0;\n\n    if (lastMeasuredIndex >= 0) {\n      var itemMetadata = itemMetadataMap[lastMeasuredIndex];\n      offset = itemMetadata.offset + itemMetadata.size;\n    }\n\n    for (var i = lastMeasuredIndex + 1; i <= index; i++) {\n      var size = itemSize(i);\n      itemMetadataMap[i] = {\n        offset: offset,\n        size: size\n      };\n      offset += size;\n    }\n\n    instanceProps.lastMeasuredIndex = index;\n  }\n\n  return itemMetadataMap[index];\n};\n\nvar findNearestItem$1 = function findNearestItem(props, instanceProps, offset) {\n  var itemMetadataMap = instanceProps.itemMetadataMap,\n      lastMeasuredIndex = instanceProps.lastMeasuredIndex;\n  var lastMeasuredItemOffset = lastMeasuredIndex > 0 ? itemMetadataMap[lastMeasuredIndex].offset : 0;\n\n  if (lastMeasuredItemOffset >= offset) {\n    // If we've already measured items within this range just use a binary search as it's faster.\n    return findNearestItemBinarySearch$1(props, instanceProps, lastMeasuredIndex, 0, offset);\n  } else {\n    // If we haven't yet measured this high, fallback to an exponential search with an inner binary search.\n    // The exponential search avoids pre-computing sizes for the full set of items as a binary search would.\n    // The overall complexity for this approach is O(log n).\n    return findNearestItemExponentialSearch$1(props, instanceProps, Math.max(0, lastMeasuredIndex), offset);\n  }\n};\n\nvar findNearestItemBinarySearch$1 = function findNearestItemBinarySearch(props, instanceProps, high, low, offset) {\n  while (low <= high) {\n    var middle = low + Math.floor((high - low) / 2);\n    var currentOffset = getItemMetadata$1(props, middle, instanceProps).offset;\n\n    if (currentOffset === offset) {\n      return middle;\n    } else if (currentOffset < offset) {\n      low = middle + 1;\n    } else if (currentOffset > offset) {\n      high = middle - 1;\n    }\n  }\n\n  if (low > 0) {\n    return low - 1;\n  } else {\n    return 0;\n  }\n};\n\nvar findNearestItemExponentialSearch$1 = function findNearestItemExponentialSearch(props, instanceProps, index, offset) {\n  var itemCount = props.itemCount;\n  var interval = 1;\n\n  while (index < itemCount && getItemMetadata$1(props, index, instanceProps).offset < offset) {\n    index += interval;\n    interval *= 2;\n  }\n\n  return findNearestItemBinarySearch$1(props, instanceProps, Math.min(index, itemCount - 1), Math.floor(index / 2), offset);\n};\n\nvar getEstimatedTotalSize = function getEstimatedTotalSize(_ref2, _ref3) {\n  var itemCount = _ref2.itemCount;\n  var itemMetadataMap = _ref3.itemMetadataMap,\n      estimatedItemSize = _ref3.estimatedItemSize,\n      lastMeasuredIndex = _ref3.lastMeasuredIndex;\n  var totalSizeOfMeasuredItems = 0; // Edge case check for when the number of items decreases while a scroll is in progress.\n  // https://github.com/bvaughn/react-window/pull/138\n\n  if (lastMeasuredIndex >= itemCount) {\n    lastMeasuredIndex = itemCount - 1;\n  }\n\n  if (lastMeasuredIndex >= 0) {\n    var itemMetadata = itemMetadataMap[lastMeasuredIndex];\n    totalSizeOfMeasuredItems = itemMetadata.offset + itemMetadata.size;\n  }\n\n  var numUnmeasuredItems = itemCount - lastMeasuredIndex - 1;\n  var totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;\n  return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;\n};\n\nvar VariableSizeList = /*#__PURE__*/createListComponent({\n  getItemOffset: function getItemOffset(props, index, instanceProps) {\n    return getItemMetadata$1(props, index, instanceProps).offset;\n  },\n  getItemSize: function getItemSize(props, index, instanceProps) {\n    return instanceProps.itemMetadataMap[index].size;\n  },\n  getEstimatedTotalSize: getEstimatedTotalSize,\n  getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment(props, index, align, scrollOffset, instanceProps) {\n    var direction = props.direction,\n        height = props.height,\n        layout = props.layout,\n        width = props.width; // TODO Deprecate direction \"horizontal\"\n\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var size = isHorizontal ? width : height;\n    var itemMetadata = getItemMetadata$1(props, index, instanceProps); // Get estimated total size after ItemMetadata is computed,\n    // To ensure it reflects actual measurements instead of just estimates.\n\n    var estimatedTotalSize = getEstimatedTotalSize(props, instanceProps);\n    var maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, itemMetadata.offset));\n    var minOffset = Math.max(0, itemMetadata.offset - size + itemMetadata.size);\n\n    if (align === 'smart') {\n      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        return Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n      case 'auto':\n      default:\n        if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {\n          return scrollOffset;\n        } else if (scrollOffset < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getStartIndexForOffset: function getStartIndexForOffset(props, offset, instanceProps) {\n    return findNearestItem$1(props, instanceProps, offset);\n  },\n  getStopIndexForStartIndex: function getStopIndexForStartIndex(props, startIndex, scrollOffset, instanceProps) {\n    var direction = props.direction,\n        height = props.height,\n        itemCount = props.itemCount,\n        layout = props.layout,\n        width = props.width; // TODO Deprecate direction \"horizontal\"\n\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var size = isHorizontal ? width : height;\n    var itemMetadata = getItemMetadata$1(props, startIndex, instanceProps);\n    var maxOffset = scrollOffset + size;\n    var offset = itemMetadata.offset + itemMetadata.size;\n    var stopIndex = startIndex;\n\n    while (stopIndex < itemCount - 1 && offset < maxOffset) {\n      stopIndex++;\n      offset += getItemMetadata$1(props, stopIndex, instanceProps).size;\n    }\n\n    return stopIndex;\n  },\n  initInstanceProps: function initInstanceProps(props, instance) {\n    var _ref4 = props,\n        estimatedItemSize = _ref4.estimatedItemSize;\n    var instanceProps = {\n      itemMetadataMap: {},\n      estimatedItemSize: estimatedItemSize || DEFAULT_ESTIMATED_ITEM_SIZE$1,\n      lastMeasuredIndex: -1\n    };\n\n    instance.resetAfterIndex = function (index, shouldForceUpdate) {\n      if (shouldForceUpdate === void 0) {\n        shouldForceUpdate = true;\n      }\n\n      instanceProps.lastMeasuredIndex = Math.min(instanceProps.lastMeasuredIndex, index - 1); // We could potentially optimize further by only evicting styles after this index,\n      // But since styles are only cached while scrolling is in progress-\n      // It seems an unnecessary optimization.\n      // It's unlikely that resetAfterIndex() will be called while a user is scrolling.\n\n      instance._getItemStyleCache(-1);\n\n      if (shouldForceUpdate) {\n        instance.forceUpdate();\n      }\n    };\n\n    return instanceProps;\n  },\n  shouldResetStyleCacheOnItemSizeChange: false,\n  validateProps: function validateProps(_ref5) {\n    var itemSize = _ref5.itemSize;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof itemSize !== 'function') {\n        throw Error('An invalid \"itemSize\" prop has been specified. ' + 'Value should be a function. ' + (\"\\\"\" + (itemSize === null ? 'null' : typeof itemSize) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\nvar FixedSizeGrid = /*#__PURE__*/createGridComponent({\n  getColumnOffset: function getColumnOffset(_ref, index) {\n    var columnWidth = _ref.columnWidth;\n    return index * columnWidth;\n  },\n  getColumnWidth: function getColumnWidth(_ref2, index) {\n    var columnWidth = _ref2.columnWidth;\n    return columnWidth;\n  },\n  getRowOffset: function getRowOffset(_ref3, index) {\n    var rowHeight = _ref3.rowHeight;\n    return index * rowHeight;\n  },\n  getRowHeight: function getRowHeight(_ref4, index) {\n    var rowHeight = _ref4.rowHeight;\n    return rowHeight;\n  },\n  getEstimatedTotalHeight: function getEstimatedTotalHeight(_ref5) {\n    var rowCount = _ref5.rowCount,\n        rowHeight = _ref5.rowHeight;\n    return rowHeight * rowCount;\n  },\n  getEstimatedTotalWidth: function getEstimatedTotalWidth(_ref6) {\n    var columnCount = _ref6.columnCount,\n        columnWidth = _ref6.columnWidth;\n    return columnWidth * columnCount;\n  },\n  getOffsetForColumnAndAlignment: function getOffsetForColumnAndAlignment(_ref7, columnIndex, align, scrollLeft, instanceProps, scrollbarSize) {\n    var columnCount = _ref7.columnCount,\n        columnWidth = _ref7.columnWidth,\n        width = _ref7.width;\n    var lastColumnOffset = Math.max(0, columnCount * columnWidth - width);\n    var maxOffset = Math.min(lastColumnOffset, columnIndex * columnWidth);\n    var minOffset = Math.max(0, columnIndex * columnWidth - width + scrollbarSize + columnWidth);\n\n    if (align === 'smart') {\n      if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        // \"Centered\" offset is usually the average of the min and max.\n        // But near the edges of the list, this doesn't hold true.\n        var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n        if (middleOffset < Math.ceil(width / 2)) {\n          return 0; // near the beginning\n        } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {\n          return lastColumnOffset; // near the end\n        } else {\n          return middleOffset;\n        }\n\n      case 'auto':\n      default:\n        if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {\n          return scrollLeft;\n        } else if (minOffset > maxOffset) {\n          // Because we only take into account the scrollbar size when calculating minOffset\n          // this value can be larger than maxOffset when at the end of the list\n          return minOffset;\n        } else if (scrollLeft < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getOffsetForRowAndAlignment: function getOffsetForRowAndAlignment(_ref8, rowIndex, align, scrollTop, instanceProps, scrollbarSize) {\n    var rowHeight = _ref8.rowHeight,\n        height = _ref8.height,\n        rowCount = _ref8.rowCount;\n    var lastRowOffset = Math.max(0, rowCount * rowHeight - height);\n    var maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);\n    var minOffset = Math.max(0, rowIndex * rowHeight - height + scrollbarSize + rowHeight);\n\n    if (align === 'smart') {\n      if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        // \"Centered\" offset is usually the average of the min and max.\n        // But near the edges of the list, this doesn't hold true.\n        var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n        if (middleOffset < Math.ceil(height / 2)) {\n          return 0; // near the beginning\n        } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {\n          return lastRowOffset; // near the end\n        } else {\n          return middleOffset;\n        }\n\n      case 'auto':\n      default:\n        if (scrollTop >= minOffset && scrollTop <= maxOffset) {\n          return scrollTop;\n        } else if (minOffset > maxOffset) {\n          // Because we only take into account the scrollbar size when calculating minOffset\n          // this value can be larger than maxOffset when at the end of the list\n          return minOffset;\n        } else if (scrollTop < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getColumnStartIndexForOffset: function getColumnStartIndexForOffset(_ref9, scrollLeft) {\n    var columnWidth = _ref9.columnWidth,\n        columnCount = _ref9.columnCount;\n    return Math.max(0, Math.min(columnCount - 1, Math.floor(scrollLeft / columnWidth)));\n  },\n  getColumnStopIndexForStartIndex: function getColumnStopIndexForStartIndex(_ref10, startIndex, scrollLeft) {\n    var columnWidth = _ref10.columnWidth,\n        columnCount = _ref10.columnCount,\n        width = _ref10.width;\n    var left = startIndex * columnWidth;\n    var numVisibleColumns = Math.ceil((width + scrollLeft - left) / columnWidth);\n    return Math.max(0, Math.min(columnCount - 1, startIndex + numVisibleColumns - 1 // -1 is because stop index is inclusive\n    ));\n  },\n  getRowStartIndexForOffset: function getRowStartIndexForOffset(_ref11, scrollTop) {\n    var rowHeight = _ref11.rowHeight,\n        rowCount = _ref11.rowCount;\n    return Math.max(0, Math.min(rowCount - 1, Math.floor(scrollTop / rowHeight)));\n  },\n  getRowStopIndexForStartIndex: function getRowStopIndexForStartIndex(_ref12, startIndex, scrollTop) {\n    var rowHeight = _ref12.rowHeight,\n        rowCount = _ref12.rowCount,\n        height = _ref12.height;\n    var top = startIndex * rowHeight;\n    var numVisibleRows = Math.ceil((height + scrollTop - top) / rowHeight);\n    return Math.max(0, Math.min(rowCount - 1, startIndex + numVisibleRows - 1 // -1 is because stop index is inclusive\n    ));\n  },\n  initInstanceProps: function initInstanceProps(props) {// Noop\n  },\n  shouldResetStyleCacheOnItemSizeChange: true,\n  validateProps: function validateProps(_ref13) {\n    var columnWidth = _ref13.columnWidth,\n        rowHeight = _ref13.rowHeight;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof columnWidth !== 'number') {\n        throw Error('An invalid \"columnWidth\" prop has been specified. ' + 'Value should be a number. ' + (\"\\\"\" + (columnWidth === null ? 'null' : typeof columnWidth) + \"\\\" was specified.\"));\n      }\n\n      if (typeof rowHeight !== 'number') {\n        throw Error('An invalid \"rowHeight\" prop has been specified. ' + 'Value should be a number. ' + (\"\\\"\" + (rowHeight === null ? 'null' : typeof rowHeight) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\nvar FixedSizeList = /*#__PURE__*/createListComponent({\n  getItemOffset: function getItemOffset(_ref, index) {\n    var itemSize = _ref.itemSize;\n    return index * itemSize;\n  },\n  getItemSize: function getItemSize(_ref2, index) {\n    var itemSize = _ref2.itemSize;\n    return itemSize;\n  },\n  getEstimatedTotalSize: function getEstimatedTotalSize(_ref3) {\n    var itemCount = _ref3.itemCount,\n        itemSize = _ref3.itemSize;\n    return itemSize * itemCount;\n  },\n  getOffsetForIndexAndAlignment: function getOffsetForIndexAndAlignment(_ref4, index, align, scrollOffset) {\n    var direction = _ref4.direction,\n        height = _ref4.height,\n        itemCount = _ref4.itemCount,\n        itemSize = _ref4.itemSize,\n        layout = _ref4.layout,\n        width = _ref4.width;\n    // TODO Deprecate direction \"horizontal\"\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var size = isHorizontal ? width : height;\n    var lastItemOffset = Math.max(0, itemCount * itemSize - size);\n    var maxOffset = Math.min(lastItemOffset, index * itemSize);\n    var minOffset = Math.max(0, index * itemSize - size + itemSize);\n\n    if (align === 'smart') {\n      if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n\n      case 'end':\n        return minOffset;\n\n      case 'center':\n        {\n          // \"Centered\" offset is usually the average of the min and max.\n          // But near the edges of the list, this doesn't hold true.\n          var middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);\n\n          if (middleOffset < Math.ceil(size / 2)) {\n            return 0; // near the beginning\n          } else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {\n            return lastItemOffset; // near the end\n          } else {\n            return middleOffset;\n          }\n        }\n\n      case 'auto':\n      default:\n        if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {\n          return scrollOffset;\n        } else if (scrollOffset < minOffset) {\n          return minOffset;\n        } else {\n          return maxOffset;\n        }\n\n    }\n  },\n  getStartIndexForOffset: function getStartIndexForOffset(_ref5, offset) {\n    var itemCount = _ref5.itemCount,\n        itemSize = _ref5.itemSize;\n    return Math.max(0, Math.min(itemCount - 1, Math.floor(offset / itemSize)));\n  },\n  getStopIndexForStartIndex: function getStopIndexForStartIndex(_ref6, startIndex, scrollOffset) {\n    var direction = _ref6.direction,\n        height = _ref6.height,\n        itemCount = _ref6.itemCount,\n        itemSize = _ref6.itemSize,\n        layout = _ref6.layout,\n        width = _ref6.width;\n    // TODO Deprecate direction \"horizontal\"\n    var isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    var offset = startIndex * itemSize;\n    var size = isHorizontal ? width : height;\n    var numVisibleItems = Math.ceil((size + scrollOffset - offset) / itemSize);\n    return Math.max(0, Math.min(itemCount - 1, startIndex + numVisibleItems - 1 // -1 is because stop index is inclusive\n    ));\n  },\n  initInstanceProps: function initInstanceProps(props) {// Noop\n  },\n  shouldResetStyleCacheOnItemSizeChange: true,\n  validateProps: function validateProps(_ref7) {\n    var itemSize = _ref7.itemSize;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof itemSize !== 'number') {\n        throw Error('An invalid \"itemSize\" prop has been specified. ' + 'Value should be a number. ' + (\"\\\"\" + (itemSize === null ? 'null' : typeof itemSize) + \"\\\" was specified.\"));\n      }\n    }\n  }\n});\n\n// Pulled from react-compat\n// https://github.com/developit/preact-compat/blob/7c5de00e7c85e2ffd011bf3af02899b63f699d3a/src/index.js#L349\nfunction shallowDiffers(prev, next) {\n  for (var attribute in prev) {\n    if (!(attribute in next)) {\n      return true;\n    }\n  }\n\n  for (var _attribute in next) {\n    if (prev[_attribute] !== next[_attribute]) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nvar _excluded = [\"style\"],\n    _excluded2 = [\"style\"];\n// It knows to compare individual style props and ignore the wrapper object.\n// See https://reactjs.org/docs/react-api.html#reactmemo\n\nfunction areEqual(prevProps, nextProps) {\n  var prevStyle = prevProps.style,\n      prevRest = _objectWithoutPropertiesLoose(prevProps, _excluded);\n\n  var nextStyle = nextProps.style,\n      nextRest = _objectWithoutPropertiesLoose(nextProps, _excluded2);\n\n  return !shallowDiffers(prevStyle, nextStyle) && !shallowDiffers(prevRest, nextRest);\n}\n\n// It knows to compare individual style props and ignore the wrapper object.\n// See https://reactjs.org/docs/react-component.html#shouldcomponentupdate\n\nfunction shouldComponentUpdate(nextProps, nextState) {\n  return !areEqual(this.props, nextProps) || shallowDiffers(this.state, nextState);\n}\n\nexport { FixedSizeGrid, FixedSizeList, VariableSizeGrid, VariableSizeList, areEqual, shouldComponentUpdate };\n//# sourceMappingURL=index.esm.js.map\n"],"sourceRoot":""}