{"version":3,"sources":["../node_modules/react/index.js","../node_modules/react-router-dom/esm/react-router-dom.js","../node_modules/react-transition-group/esm/Transition.js","../node_modules/react-transition-group/esm/ReplaceTransition.js","../node_modules/react-transition-group/esm/SwitchTransition.js","../node_modules/react-transition-group/esm/index.js","../node_modules/react-transition-group/esm/TransitionGroupContext.js","../node_modules/react-transition-group/esm/config.js","../node_modules/react-transition-group/esm/utils/ChildMapping.js","../node_modules/react-transition-group/esm/TransitionGroup.js","../node_modules/react-virtualized/dist/es/vendor/detectElementResize.js","../node_modules/react-redux/es/components/Context.js","../node_modules/react-redux/es/utils/batch.js","../node_modules/react-redux/es/utils/Subscription.js","../node_modules/react-redux/es/components/Provider.js","../node_modules/react-redux/es/utils/useIsomorphicLayoutEffect.js","../node_modules/react-redux/es/components/connectAdvanced.js","../node_modules/react-redux/es/utils/shallowEqual.js","../node_modules/react-redux/es/connect/wrapMapToProps.js","../node_modules/react-redux/es/connect/mapDispatchToProps.js","../node_modules/react-redux/es/connect/mapStateToProps.js","../node_modules/react-redux/es/connect/mergeProps.js","../node_modules/react-redux/es/connect/selectorFactory.js","../node_modules/react-redux/es/connect/connect.js","../node_modules/react-redux/es/hooks/useSelector.js","../node_modules/react-redux/es/index.js","../node_modules/react-transition-group/esm/CSSTransition.js","../node_modules/react-router/node_modules/path-to-regexp/index.js","../node_modules/react-window-infinite-loader/dist/index.esm.js","../node_modules/react-window/dist/index.esm.js","../node_modules/react/cjs/react.production.min.js","../node_modules/react-router/node_modules/isarray/index.js","../node_modules/react-virtualized/dist/es/Grid/utils/calculateSizeAndPositionDataAndUpdateScrollOffset.js","../node_modules/react-virtualized/dist/es/Grid/utils/CellSizeAndPositionManager.js","../node_modules/react-virtualized/dist/es/Grid/utils/maxElementSize.js","../node_modules/react-virtualized/dist/es/Grid/utils/ScalingCellSizeAndPositionManager.js","../node_modules/react-virtualized/dist/es/utils/createCallbackMemoizer.js","../node_modules/react-virtualized/dist/es/Grid/defaultOverscanIndicesGetter.js","../node_modules/react-virtualized/dist/es/Grid/utils/updateScrollIndexHelper.js","../node_modules/react-virtualized/dist/es/Grid/defaultCellRangeRenderer.js","../node_modules/react-virtualized/dist/es/utils/animationFrame.js","../node_modules/react-virtualized/dist/es/Grid/Grid.js","../node_modules/react-virtualized/dist/es/utils/requestAnimationTimeout.js","../node_modules/react-virtualized/dist/es/Grid/accessibilityOverscanIndicesGetter.js","../node_modules/react-virtualized/dist/es/ArrowKeyStepper/types.js","../node_modules/react-virtualized/dist/es/ArrowKeyStepper/ArrowKeyStepper.js","../node_modules/react-virtualized/dist/es/AutoSizer/AutoSizer.js","../node_modules/react-virtualized/dist/es/CellMeasurer/CellMeasurer.js","../node_modules/react-virtualized/dist/es/CellMeasurer/CellMeasurerCache.js","../node_modules/react-virtualized/dist/es/Collection/CollectionView.js","../node_modules/react-virtualized/dist/es/Collection/Section.js","../node_modules/react-virtualized/dist/es/Collection/SectionManager.js","../node_modules/react-virtualized/dist/es/utils/getUpdatedOffsetForIndex.js","../node_modules/react-virtualized/dist/es/Collection/Collection.js","../node_modules/react-virtualized/dist/es/Collection/utils/calculateSizeAndPositionData.js","../node_modules/react-virtualized/dist/es/Collection/index.js","../node_modules/react-virtualized/dist/es/ColumnSizer/ColumnSizer.js","../node_modules/react-virtualized/dist/es/ColumnSizer/index.js","../node_modules/react-virtualized/dist/es/InfiniteLoader/InfiniteLoader.js","../node_modules/react-virtualized/dist/es/InfiniteLoader/index.js","../node_modules/react-virtualized/dist/es/List/List.js","../node_modules/react-virtualized/dist/es/vendor/binarySearchBounds.js","../node_modules/react-virtualized/dist/es/vendor/intervalTree.js","../node_modules/react-virtualized/dist/es/Masonry/PositionCache.js","../node_modules/react-virtualized/dist/es/Masonry/Masonry.js","../node_modules/react-virtualized/dist/es/Masonry/createCellPositioner.js","../node_modules/react-virtualized/dist/es/Masonry/index.js","../node_modules/react-virtualized/dist/es/MultiGrid/CellMeasurerCacheDecorator.js","../node_modules/react-virtualized/dist/es/MultiGrid/MultiGrid.js","../node_modules/react-virtualized/dist/es/ScrollSync/ScrollSync.js","../node_modules/react-virtualized/dist/es/Table/createMultiSort.js","../node_modules/react-virtualized/dist/es/Table/defaultCellDataGetter.js","../node_modules/react-virtualized/dist/es/Table/defaultCellRenderer.js","../node_modules/react-virtualized/dist/es/Table/defaultHeaderRowRenderer.js","../node_modules/react-virtualized/dist/es/Table/SortDirection.js","../node_modules/react-virtualized/dist/es/Table/SortIndicator.js","../node_modules/react-virtualized/dist/es/Table/defaultHeaderRenderer.js","../node_modules/react-virtualized/dist/es/Table/defaultRowRenderer.js","../node_modules/react-virtualized/dist/es/Table/Column.js","../node_modules/react-virtualized/dist/es/Table/Table.js","../node_modules/react-virtualized/dist/es/Table/index.js","../node_modules/react-virtualized/dist/es/WindowScroller/utils/onScroll.js","../node_modules/react-virtualized/dist/es/WindowScroller/utils/dimensions.js","../node_modules/react-virtualized/dist/es/WindowScroller/WindowScroller.js","../node_modules/react-virtualized/dist/es/index.js","../node_modules/react-router/esm/react-router.js"],"names":["module","exports","Component","resolveToLocation","to","currentLocation","normalizeToLocation","forwardRefShim","C","forwardRef","LinkAnchor","_ref","forwardedRef","innerRef","navigate","_onClick","onClick","rest","target","props","event","ex","preventDefault","defaultPrevented","button","metaKey","altKey","ctrlKey","shiftKey","isModifiedEvent","ref","createElement","Link","_ref2","_ref2$component","component","replace","Consumer","context","history","location","href","createHref","push","forwardRefShim$1","forwardRef$1","_ref$ariaCurrent","ariaCurrent","_ref$activeClassName","activeClassName","activeStyle","classNameProp","className","exact","isActiveProp","isActive","locationProp","sensitive","strict","styleProp","style","toLocation","path","pathname","escapedPath","match","_len","arguments","length","classnames","Array","_key","filter","i","join","joinClassnames","ENTERING","ENTERED","EXITING","Transition","_React$Component","_this","call","this","initialStatus","appear","isMounting","enter","appearStatus","in","unmountOnExit","mountOnEnter","state","status","nextCallback","getDerivedStateFromProps","prevState","_proto","prototype","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","exit","timeout","undefined","mounting","performEnter","performExit","setState","_this2","appearing","nodeRef","findDOMNode","maybeNode","maybeAppearing","timeouts","enterTimeout","disabled","safeSetState","onEntered","onEnter","onEntering","onTransitionEnd","_this3","onExit","onExiting","onExited","cancel","nextState","callback","setNextCallback","_this4","active","handler","node","current","doesNotHaveTimeoutOrListener","addEndListener","_ref3","maybeNextCallback","setTimeout","render","_this$props","children","childProps","Provider","value","cloneElement","Children","only","noop","contextType","propTypes","defaultProps","UNMOUNTED","EXITED","ReplaceTransition","_args","apply","concat","handleEnter","_len2","args","_key2","handleLifecycle","handleEntering","_len3","_key3","handleEntered","_len4","_key4","handleExit","_len5","_key5","handleExiting","_len6","_key6","handleExited","_len7","_key7","idx","originalArgs","_child$props","child","toArray","inProp","_React$Children$toArr","first","second","TransitionGroup","key","_leaveRenders","_enterRenders","modes","callHook","element","name","cb","_element$props","leaveRenders","changeState","enterRenders","_ref4","SwitchTransition","appeared","mode","oldChildren","newChildren","isValidElement","_this$state","data","TransitionGroupContext","createContext","getChildMapping","mapFn","result","Object","create","map","c","forEach","mapper","getProp","prop","getNextChildMapping","nextProps","prevChildMapping","nextChildMapping","prev","next","getValueForKey","nextKeysPending","pendingKeys","prevKey","childMapping","nextKey","pendingNextKey","mergeChildMappings","keys","hasPrev","hasNext","prevChild","isLeaving","bind","values","obj","k","contextValue","firstRender","mounted","currentChildMapping","childFactory","createDetectElementResize","nonce","hostWindow","_window","attachEvent","window","self","global","document","requestFrame","raf","requestAnimationFrame","mozRequestAnimationFrame","webkitRequestAnimationFrame","fn","cancelFrame","cancelAnimationFrame","mozCancelAnimationFrame","webkitCancelAnimationFrame","clearTimeout","id","resetTriggers","triggers","__resizeTriggers__","expand","firstElementChild","contract","lastElementChild","expandChild","scrollLeft","scrollWidth","scrollTop","scrollHeight","width","offsetWidth","height","offsetHeight","scrollListener","e","indexOf","__resizeRAF__","__resizeLast__","checkTriggers","__resizeListeners__","animation","keyframeprefix","animationstartevent","domPrefixes","split","startEvents","elm","animationName","toLowerCase","animationKeyframes","animationStyle","addResizeListener","doc","ownerDocument","elementStyle","getComputedStyle","position","getElementById","css","head","getElementsByTagName","type","setAttribute","styleSheet","cssText","appendChild","createTextNode","createStyles","innerHTML","addEventListener","__animationListener__","removeResizeListener","detachEvent","splice","removeEventListener","removeChild","ReactReduxContext","nullListeners","notify","createListenerCollection","batch","last","clear","listener","get","listeners","subscribe","isSubscribed","Subscription","store","parentSub","unsubscribe","handleChangeWrapper","addNestedSub","trySubscribe","notifyNestedSubs","onStateChange","Boolean","tryUnsubscribe","subscription","previousState","getState","Context","useIsomorphicLayoutEffect","EMPTY_ARRAY","NO_SUBSCRIPTION_ARRAY","storeStateUpdatesReducer","action","updateCount","payload","useIsomorphicLayoutEffectWithArgs","effectFunc","effectArgs","dependencies","captureWrapperProps","lastWrapperProps","lastChildProps","renderIsScheduled","wrapperProps","actualChildProps","childPropsFromStoreUpdate","subscribeUpdates","shouldHandleStateChanges","childPropsSelector","forceComponentUpdateDispatch","didUnsubscribe","lastThrownError","checkForUpdates","newChildProps","error","latestStoreState","initStateUpdates","connectAdvanced","selectorFactory","_ref2$getDisplayName","getDisplayName","_ref2$methodName","methodName","_ref2$renderCountProp","renderCountProp","_ref2$shouldHandleSta","_ref2$storeKey","storeKey","_ref2$forwardRef","withRef","_ref2$context","connectOptions","WrappedComponent","wrappedComponentName","displayName","selectorFactoryOptions","pure","usePureOnlyMemo","ConnectFunction","_useMemo","reactReduxForwardedRef","propsContext","ContextToUse","didStoreComeFromProps","dispatch","createChildSelector","_useMemo2","overriddenContextValue","_useReducer","previousStateUpdateResult","renderedWrappedComponent","Connect","memo","forwarded","is","x","y","shallowEqual","objA","objB","keysA","keysB","hasOwnProperty","wrapMapToPropsConstant","getConstant","options","constant","constantSelector","dependsOnOwnProps","getDependsOnOwnProps","mapToProps","wrapMapToPropsFunc","proxy","stateOrDispatch","ownProps","mapDispatchToProps","mapStateToProps","defaultMergeProps","stateProps","dispatchProps","mergeProps","mergedProps","areMergedPropsEqual","hasRunOnce","nextMergedProps","wrapMergePropsFunc","impureFinalPropsSelectorFactory","pureFinalPropsSelectorFactory","areStatesEqual","areOwnPropsEqual","areStatePropsEqual","hasRunAtLeastOnce","handleSubsequentCalls","nextOwnProps","propsChanged","stateChanged","nextStateProps","statePropsChanged","handleNewState","finalPropsSelectorFactory","initMapStateToProps","initMapDispatchToProps","initMergeProps","arg","factories","Error","strictEqual","a","b","createConnect","_temp","_ref$connectHOC","connectHOC","_ref$mapStateToPropsF","mapStateToPropsFactories","_ref$mapDispatchToPro","mapDispatchToPropsFactories","_ref$mergePropsFactor","mergePropsFactories","_ref$selectorFactory","_ref3$pure","_ref3$areStatesEqual","_ref3$areOwnPropsEqua","_ref3$areStatePropsEq","_ref3$areMergedPropsE","extraOptions","newBatch","removeClass","classes","CSSTransition","appliedClasses","_this$resolveArgument","resolveArguments","removeClasses","addClass","_this$resolveArgument2","_this$resolveArgument3","getClassNames","classNames","isStringClassNames","baseClassName","doneClassName","phase","_addClass","_this$appliedClasses$","base","done","isarray","pathToRegexp","parse","compile","str","tokensToFunction","tokensToRegExp","PATH_REGEXP","RegExp","res","tokens","index","defaultDelimiter","delimiter","exec","m","escaped","offset","slice","prefix","capture","group","modifier","asterisk","partial","repeat","optional","pattern","escapeGroup","escapeString","substr","encodeURIComponentPretty","encodeURI","charCodeAt","toString","toUpperCase","matches","flags","opts","encode","pretty","encodeURIComponent","token","segment","TypeError","JSON","stringify","j","test","attachKeys","re","end","route","endsWithDelimiter","groups","source","regexpToRegexp","parts","arrayToRegexp","stringToRegexp","classCallCheck","instance","Constructor","createClass","defineProperties","descriptor","enumerable","configurable","writable","defineProperty","protoProps","staticProps","possibleConstructorReturn","ReferenceError","slicedToArray","arr","isArray","Symbol","iterator","_arr","_n","_d","_e","_s","_i","err","sliceIterator","InfiniteLoader","_PureComponent","__proto__","getPrototypeOf","_lastRenderedStartIndex","_lastRenderedStopIndex","_memoizedUnloadedRanges","_onItemsRendered","visibleStartIndex","visibleStopIndex","_ensureRowsLoaded","_setRef","listRef","_listRef","subClass","superClass","constructor","setPrototypeOf","inherits","autoReload","onItemsRendered","startIndex","stopIndex","_props","isItemLoaded","itemCount","_props$minimumBatchSi","minimumBatchSize","_props$threshold","threshold","unloadedRanges","rangeStartIndex","rangeStopIndex","_index","potentialStopIndex","Math","min","max","_index2","firstRange","_index3","scanForUnloadedRanges","some","_loadUnloadedRanges","loadMoreItems","loadMoreRows","_ref5","_ref6","promise","then","lastRenderedStartIndex","lastRenderedStopIndex","isRangeVisible","resetAfterIndex","_getItemStyleCache","forceUpdate","now","performance","Date","cancelTimeout","timeoutID","requestTimeout","delay","start","tick","cachedRTLResult","getRTLOffsetType","recalculate","outerDiv","outerStyle","overflow","direction","innerDiv","innerStyle","body","defaultItemKey$1","createListComponent","_class","getItemOffset","getEstimatedTotalSize","getItemSize","getOffsetForIndexAndAlignment","getStartIndexForOffset","getStopIndexForStartIndex","initInstanceProps","shouldResetStyleCacheOnItemSizeChange","validateProps","List","_instanceProps","_outerRef","_resetIsScrollingTimeoutId","isScrolling","scrollDirection","scrollOffset","initialScrollOffset","scrollUpdateWasRequested","_callOnItemsRendered","overscanStartIndex","overscanStopIndex","_callOnScroll","onScroll","_getItemStyle","itemSize","layout","itemStyleCache","_style","_offset","size","isHorizontal","top","_","__","___","_onScrollHorizontal","_event$currentTarget","currentTarget","clientWidth","_resetIsScrollingDebounced","_onScrollVertical","_event$currentTarget2","clientHeight","_outerRefSetter","outerRef","_resetIsScrolling","validateSharedProps$1","scrollTo","scrollToItem","align","_this$props2","_callPropsCallbacks","_this$props3","_this$props4","innerElementType","innerTagName","itemData","_this$props4$itemKey","itemKey","outerElementType","outerTagName","useIsScrolling","_this$_getRangeToRend","_getRangeToRender","items","estimatedTotalSize","WebkitOverflowScrolling","willChange","pointerEvents","_this$_getRangeToRend2","_overscanStartIndex","_overscanStopIndex","_visibleStartIndex","_visibleStopIndex","_this$state2","_scrollDirection","_scrollOffset","_scrollUpdateWasRequested","_this$props5","overscanCount","_this$state3","overscanBackward","overscanForward","FixedSizeList","lastItemOffset","maxOffset","minOffset","middleOffset","round","ceil","floor","numVisibleItems","_ref7","l","n","p","Fragment","StrictMode","Profiler","q","r","t","Suspense","u","v","for","w","z","A","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","B","refs","updater","D","E","isReactComponent","F","isPureReactComponent","G","H","I","__self","__source","J","d","h","g","f","$$typeof","_owner","L","M","N","escape","O","K","P","Q","_status","_result","default","R","S","T","ReactCurrentDispatcher","ReactCurrentBatchConfig","transition","ReactCurrentOwner","IsSomeRendererActing","assign","count","PureComponent","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","_calculateChangedBits","_currentValue","_currentValue2","_threadCount","_context","createFactory","createRef","lazy","_payload","_init","compare","useCallback","useContext","useDebugValue","useEffect","useImperativeHandle","useLayoutEffect","useMemo","useReducer","useRef","useState","version","calculateSizeAndPositionDataAndUpdateScrollOffset","cellCount","cellSize","computeMetadataCallback","computeMetadataCallbackProps","nextCellsCount","nextCellSize","nextScrollToIndex","scrollToIndex","updateScrollOffsetForScrollToIndex","CellSizeAndPositionManager","cellSizeGetter","estimatedCellSize","_cellSizeGetter","_cellCount","_estimatedCellSize","_lastMeasuredIndex","lastMeasuredCellSizeAndPosition","getSizeAndPositionOfLastMeasuredCell","isNaN","_cellSizeAndPositionData","_lastBatchedIndex","_ref3$align","containerSize","currentOffset","targetIndex","idealOffset","datum","getSizeAndPositionOfCell","totalSize","getTotalSize","params","_findNearestCell","stop","high","low","middle","interval","_binarySearch","lastMeasuredIndex","_exponentialSearch","getMaxElementSize","chrome","ScalingCellSizeAndPositionManager","_ref$maxScrollSize","maxScrollSize","_cellSizeAndPositionManager","_maxScrollSize","configure","getCellCount","getEstimatedCellSize","getLastMeasuredIndex","safeTotalSize","offsetPercentage","_getOffsetPercentage","_safeOffsetToOffset","getUpdatedOffsetForIndex","_offsetToSafeOffset","getVisibleCellRange","resetCell","createCallbackMemoizer","requireAllKeys","cachedIndices","indices","allInitialized","every","indexChanged","cachedValue","defaultOverscanIndicesGetter","overscanCellsCount","updateScrollIndexHelper","cellSizeAndPositionManager","previousCellsCount","previousCellSize","previousScrollToAlignment","previousScrollToIndex","previousSize","scrollToAlignment","sizeJustIncreasedFromZero","updateScrollIndexCallback","hasScrollToIndex","defaultCellRangeRenderer","cellCache","cellRenderer","columnSizeAndPositionManager","columnStartIndex","columnStopIndex","deferredMeasurementCache","horizontalOffsetAdjustment","isScrollingOptOut","parent","rowSizeAndPositionManager","rowStartIndex","rowStopIndex","styleCache","verticalOffsetAdjustment","visibleColumnIndices","visibleRowIndices","renderedCells","areOffsetsAdjusted","canCacheStyle","rowIndex","rowDatum","columnIndex","columnDatum","isVisible","has","left","cellRendererParams","renderedCell","win","request","oRequestAnimationFrame","msRequestAnimationFrame","oCancelAnimationFrame","msCancelAnimationFrame","caf","frame","Promise","resolve","ownKeys","object","enumerableOnly","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread","getOwnPropertyDescriptors","SCROLL_POSITION_CHANGE_REASONS","_React$PureComponent","Grid","_disablePointerEventsTimeoutId","needToResetStyleCache","onSectionRendered","_onGridRenderedMemoizer","columnOverscanStartIndex","_columnStartIndex","columnOverscanStopIndex","_columnStopIndex","_renderedColumnStartIndex","_renderedColumnStopIndex","rowOverscanStartIndex","_rowStartIndex","rowOverscanStopIndex","_rowStopIndex","_renderedRowStartIndex","_renderedRowStopIndex","_scrollingContainer","handleScrollEvent","columnCount","_wrapSizeGetter","columnWidth","_getEstimatedColumnSize","rowCount","rowHeight","_getEstimatedRowSize","instanceProps","prevColumnWidth","prevRowHeight","prevColumnCount","prevRowCount","prevIsScrolling","prevScrollToColumn","scrollToColumn","prevScrollToRow","scrollToRow","scrollbarSize","scrollbarSizeMeasured","scrollDirectionHorizontal","scrollDirectionVertical","scrollPositionChangeReason","_initialScrollTop","_getCalculatedScrollTop","_initialScrollLeft","_getCalculatedScrollLeft","_ref$alignment","alignment","_ref$columnIndex","_ref$rowIndex","offsetProps","_ref2$scrollLeft","scrollLeftParam","_ref2$scrollTop","scrollTopParam","_debounceScrollEnded","autoHeight","autoWidth","totalRowsHeight","totalColumnsWidth","newState","_invokeOnScrollMemoizer","_deferredInvalidateColumnIndex","_deferredInvalidateRowIndex","_ref4$columnIndex","_ref4$rowIndex","_recomputeScrollLeftFlag","_recomputeScrollTopFlag","_styleCache","_cellCache","_updateScrollLeftForScrollToColumn","_updateScrollTopForScrollToRow","getScrollbarSize","_handleInvalidatedGridSize","stateUpdate","_getScrollToPositionStateUpdate","sizeIsBiggerThanZero","_invokeOnGridRenderedHelper","_maybeCallOnScrollbarPresenceChange","columnOrRowCountJustIncreasedFromZero","_this$props6","autoContainerWidth","containerProps","containerRole","containerStyle","noContentRenderer","role","tabIndex","_isScrolling","gridStyle","boxSizing","_resetStyleCache","_calculateChildrenToRender","verticalScrollBarSize","horizontalScrollBarSize","_horizontalScrollBarSize","_verticalScrollBarSize","_scrollbarPresenceChanged","overflowX","overflowY","childrenToDisplay","_childrenToDisplay","showNoContentRenderer","_setScrollingContainerRef","_onScroll","maxWidth","maxHeight","cellRangeRenderer","overscanColumnCount","overscanIndicesGetter","overscanRowCount","getOffsetAdjustment","overscanColumnIndices","overscanRowIndices","hasFixedHeight","hasFixedWidth","scrollingResetTimeInterval","_debounceScrollEndedCallback","recomputeGridSize","_onScrollMemoizer","_this3$props","onScrollbarPresenceChange","horizontal","vertical","_ref8","_getScrollLeftForScrollToColumnStateUpdate","_getScrollTopForScrollToRowStateUpdate","maybeStateA","maybeStateB","estimatedColumnSize","estimatedRowSize","_ref9","finalColumn","scrollBarSize","calculatedScrollLeft","finalRow","calculatedScrollTop","ArrowKeyStepper","_getPrototypeOf2","_this$_getScrollState","_getScrollState","scrollToColumnPrevious","scrollToRowPrevious","_this$_getScrollState2","_updateScrollState","_this$_getScrollState3","onKeyDown","_onKeyDown","_onSectionRendered","isControlled","onScrollToChange","AutoSizer","defaultHeight","defaultWidth","disableHeight","disableWidth","onResize","_parentNode","paddingLeft","parseInt","paddingRight","paddingTop","paddingBottom","newHeight","newWidth","autoSizer","_autoSizer","parentNode","defaultView","HTMLElement","_detectElementResize","_onResize","childParams","CellMeasurer","cache","_this$props$columnInd","_this$props$rowIndex","_this$_getCellMeasure","_getCellMeasurements","getHeight","getWidth","set","Element","console","warn","_child","_maybeMeasureCell","measure","_measure","registerChild","_registerChild","styleWidth","styleHeight","_this$props2$columnIn","_this$props2$rowIndex","_this$_getCellMeasure2","invalidateCellSizeAfterRender","CellMeasurerCache","_keyMapper","_columnWidthCache","_defaultWidth","_rowHeightCache","_defaultHeight","fixedHeight","fixedWidth","keyMapper","minHeight","minWidth","_hasFixedHeight","_hasFixedWidth","_minHeight","_minWidth","defaultKeyMapper","_cellHeightCache","_cellWidthCache","_updateCachedColumnAndRowSizes","_rowCount","_columnCount","columnKey","rowKey","CollectionView","cellLayoutManager","_onSectionRenderedMemoizer","getLastRenderedIndices","scrollToCell","scrollPosition","getScrollPositionForCell","cellIndex","_setScrollPosition","_enablePointerEventsAfterDelay","isScrollingChange","_scrollbarSize","_cellLayoutManager$ge","totalHeight","totalWidth","cancelable","_scrollbarSizeMeasured","_calculateSizeAndPositionDataOnNextUpdate","_updateScrollPositionForScrollToCell","_invokeOnSectionRenderedHelper","_cellLayoutManager$ge2","horizontalOverscanSize","verticalOverscanSize","_lastRenderedCellCount","_lastRenderedCellLayoutManager","calculateSizeAndPositionData","_cellLayoutManager$ge3","right","bottom","cellRenderers","collectionStyle","Section","_indexMap","_indices","SectionManager","sectionSize","_sectionSize","_cellMetadata","_sections","getSections","section","getCellIndices","sectionXStart","sectionXStop","sectionYStart","sectionYStop","sections","sectionX","sectionY","cellMetadatum","addCellIndex","_ref$align","cellOffset","Collection","_lastRenderedCellIndices","_isScrollingChange","_setCollectionViewRef","_collectionView","recomputeCellSizesAndPositions","cellSizeAndPositionGetter","cellMetadata","sectionManager","registerCell","_sectionManager","_height","_width","cellGroupRenderer","getCellMetadata","cellRendererProps","ColumnSizer","columnMaxWidth","columnMinWidth","_registeredChild","safeColumnMinWidth","safeColumnMaxWidth","adjustedWidth","getColumnWidth","_loadMoreRowsMemoizer","_onRowsRendered","_doStuff","onRowsRendered","unloadedRange","currentIndex","recomputeSize","recomputeRowHeights","forceUpdateReactVirtualizedComponent","isRowLoaded","firstUnloadedRange","squashedUnloadedRanges","registeredChild","rowRenderer","widthDescriptor","getOffsetForCell","measureAllCells","_ref6$columnIndex","_ref6$rowIndex","scrollToPosition","noRowsRenderer","_cellRenderer","ge","_GEP","_GEA","gt","_GTP","_GTA","lt","_LTP","_LTA","le","_LEP","_LEA","eq","_EQP","_EQA","IntervalTreeNode","mid","leftPoints","rightPoints","proto","copy","rebuild","intervals","ntree","createIntervalTree","rebuildWithInterval","rebuildWithoutInterval","reportLeftRange","hi","reportRightRange","lo","reportRange","compareNumbers","compareBegin","compareEnd","pts","sort","leftIntervals","rightIntervals","centerIntervals","s","IntervalTree","root","insert","weight","remove","queryPoint","queryInterval","tproto","PositionCache","defaultCellHeight","unmeasuredCellCount","tallestColumnSize","renderCallback","_intervalTree","_leftMap","columnSizeMap","_columnSizeMap","columnHeight","Masonry","eventScrollTop","_getEstimatedTotalHeight","_debounceResetIsScrolling","_positionCache","_invalidateOnUpdateStartIndex","_invalidateOnUpdateStopIndex","_populatePositionCache","_checkInvalidateOnUpdate","_invokeOnScrollCallback","_invokeOnCellsRenderedCallback","_debounceResetIsScrollingId","cellMeasurerCache","overscanByPixels","rowDirection","estimateTotalHeight","shortestColumnSize","measuredCellCount","range","batchSize","_startIndex","_stopIndex","_debounceResetIsScrollingCallback","estimatedColumnCount","_onScrollMemoized","_startIndexMemoized","_stopIndexMemoized","onCellsRendered","cellPositioner","_cellPositioner","setPosition","createCellPositioner","columnHeights","_ref$spacer","spacer","initOrResetDerivedValues","reset","CellMeasurerCacheDecorator","_cellMeasurerCache","_columnIndexOffset","_rowIndexOffset","_params$columnIndexOf","columnIndexOffset","_params$rowIndexOffse","rowIndexOffset","clearAll","MultiGrid","showHorizontalScrollbar","showVerticalScrollbar","_bottomLeftGrid","_bottomRightGrid","fixedRowCount","fixedColumnCount","scrollInfo","_topLeftGrid","_topRightGrid","_fixedColumnCount","_fixedRowCount","_maybeCalculateCachedStyles","_deferredMeasurementCacheBottomLeftGrid","_deferredMeasurementCacheBottomRightGrid","_deferredMeasurementCacheTopRightGrid","_ref7$columnIndex","_ref7$rowIndex","_ref8$columnIndex","_ref8$rowIndex","adjustedColumnIndex","adjustedRowIndex","_leftGridWidth","_topGridHeight","_this$props7","_this$props8","_prepareForRender","_this$state4","_containerOuterStyle","_containerTopStyle","_renderTopLeftGrid","_renderTopRightGrid","_containerBottomStyle","_renderBottomLeftGrid","_renderBottomRightGrid","_getTopGridHeight","leftGridWidth","_getLeftGridWidth","topGridHeight","resetAll","_this$props9","enableFixedColumnScroll","enableFixedRowScroll","styleBottomLeftGrid","styleBottomRightGrid","styleTopLeftGrid","styleTopRightGrid","sizeChange","_lastRenderedHeight","_lastRenderedWidth","leftSizeChange","_lastRenderedColumnWidth","_lastRenderedFixedColumnCount","topSizeChange","_lastRenderedFixedRowCount","_lastRenderedRowHeight","_lastRenderedStyle","_lastRenderedStyleBottomLeftGrid","_bottomLeftGridStyle","_lastRenderedStyleBottomRightGrid","_bottomRightGridStyle","_lastRenderedStyleTopLeftGrid","_topLeftGridStyle","_lastRenderedStyleTopRightGrid","_topRightGridStyle","hideBottomLeftGridScrollbar","additionalRowCount","_getBottomGridHeight","gridWidth","bottomLeftGrid","_cellRendererBottomLeftGrid","classNameBottomLeftGrid","_onScrollTop","_bottomLeftGridRef","_rowHeightBottomGrid","_cellRendererBottomRightGrid","classNameBottomRightGrid","_columnWidthRightGrid","_onScrollbarPresenceChange","_bottomRightGridRef","_getRightGridWidth","classNameTopLeftGrid","_topLeftGridRef","hideTopRightGridScrollbar","_this$state5","additionalColumnCount","additionalHeight","gridHeight","topRightGrid","_cellRendererTopRightGrid","classNameTopRightGrid","_onScrollLeft","_topRightGridRef","ScrollSync","createMultiSort","sortCallback","defaultSortBy","_ref$defaultSortDirec","defaultSortDirection","sortBy","sortDirection","dataKey","defaultCellDataGetter","rowData","defaultCellRenderer","cellData","String","defaultHeaderRowRenderer","columns","ASC","DESC","SortIndicator","viewBox","fill","defaultHeaderRenderer","label","showSortIndicator","title","defaultRowRenderer","onRowClick","onRowDoubleClick","onRowMouseOut","onRowMouseOver","onRowRightClick","a11yProps","onDoubleClick","onMouseOut","onMouseOver","onContextMenu","Column","cellDataGetter","flexGrow","flexShrink","headerRenderer","Table","scrollbarWidth","_createColumn","_createRow","_ref3$columnIndex","_ref3$rowIndex","_Grid","_setScrollbarWidth","disableHeader","gridClassName","headerHeight","headerRowRenderer","rowClassName","rowStyle","availableRowsHeight","rowClass","rowStyleObject","_cachedColumnStyles","column","flexStyles","_getFlexStyleForColumn","_getHeaderColumns","onColumnClick","_column$props","columnData","headerOnClick","headerOnKeyDown","headerTabIndex","headerAriaSort","headerAriaLabel","headerClassName","headerStyle","onHeaderClick","_column$props2","disableSort","sortEnabled","ReactVirtualized__Table__sortableHeaderColumn","renderedHeader","newSortDirection","rowGetter","flattenedStyle","_getRowHeight","customStyle","flexValue","flex","msFlex","WebkitFlex","_createHeader","getScrollbarWidth","mountedInstances","originalBodyPointerEvents","disablePointerEventsTimeoutId","enablePointerEventsIfDisabled","enablePointerEventsAfterDelayCallback","__resetIsScrolling","onScrollWindow","maximumTimeout","enablePointerEventsAfterDelay","scrollElement","__handleWindowScrollEvent","registerScrollListener","unregisterScrollListener","isWindow","getBoundingBox","getBoundingClientRect","getDimensions","innerHeight","innerWidth","serverHeight","serverWidth","getPositionOffset","container","documentElement","containerElement","elementRect","containerRect","getScrollOffset","_elementRect","_containerRect","scrollY","scrollX","getWindow","WindowScroller","updatePosition","_positionFromTop","_isMounted","_positionFromLeft","thisNode","dimensions","_registerResizeListener","prevScrollElement","_unregisterResizeListener","onChildScroll","_onChildScroll","historyContext","createNamedContext","createNamedContext$1","Router","_pendingLocation","staticContext","unlisten","listen","computeRootMatch","url","isExact","cache$1","cacheCount$1","matchPath","_options","_options$exact","_options$strict","_options$sensitive","reduce","matched","_compilePath","cacheKey","pathCache","regexp","compilePath$1","Route","context$1","computedMatch","addLeadingSlash","charAt","stripBasename","basename","createURL","staticHandler","Switch","from","useHistory","useLocation","useParams"],"mappings":"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","file":"static/js/defaultVendors~main~f734b0c6.dce806af.chunk.js","sourcesContent":["'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","import { Router, __RouterContext, matchPath } from 'react-router';\nexport { MemoryRouter, Prompt, Redirect, Route, Router, StaticRouter, Switch, generatePath, matchPath, useHistory, useLocation, useParams, useRouteMatch, withRouter } from 'react-router';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport React from 'react';\nimport { createBrowserHistory, createHashHistory, createLocation } from 'history';\nimport PropTypes from 'prop-types';\nimport warning from 'tiny-warning';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport invariant from 'tiny-invariant';\n\n/**\n * The public API for a <Router> that uses HTML5 history.\n */\n\nvar BrowserRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(BrowserRouter, _React$Component);\n\n  function BrowserRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createBrowserHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = BrowserRouter.prototype;\n\n  _proto.render = function render() {\n    return React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return BrowserRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  BrowserRouter.propTypes = {\n    basename: PropTypes.string,\n    children: PropTypes.node,\n    forceRefresh: PropTypes.bool,\n    getUserConfirmation: PropTypes.func,\n    keyLength: PropTypes.number\n  };\n\n  BrowserRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<BrowserRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { BrowserRouter as Router }`.\") : void 0;\n  };\n}\n\n/**\n * The public API for a <Router> that uses window.location.hash.\n */\n\nvar HashRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(HashRouter, _React$Component);\n\n  function HashRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createHashHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = HashRouter.prototype;\n\n  _proto.render = function render() {\n    return React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return HashRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  HashRouter.propTypes = {\n    basename: PropTypes.string,\n    children: PropTypes.node,\n    getUserConfirmation: PropTypes.func,\n    hashType: PropTypes.oneOf([\"hashbang\", \"noslash\", \"slash\"])\n  };\n\n  HashRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<HashRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { HashRouter as Router }`.\") : void 0;\n  };\n}\n\nvar resolveToLocation = function resolveToLocation(to, currentLocation) {\n  return typeof to === \"function\" ? to(currentLocation) : to;\n};\nvar normalizeToLocation = function normalizeToLocation(to, currentLocation) {\n  return typeof to === \"string\" ? createLocation(to, null, null, currentLocation) : to;\n};\n\nvar forwardRefShim = function forwardRefShim(C) {\n  return C;\n};\n\nvar forwardRef = React.forwardRef;\n\nif (typeof forwardRef === \"undefined\") {\n  forwardRef = forwardRefShim;\n}\n\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nvar LinkAnchor = forwardRef(function (_ref, forwardedRef) {\n  var innerRef = _ref.innerRef,\n      navigate = _ref.navigate,\n      _onClick = _ref.onClick,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"innerRef\", \"navigate\", \"onClick\"]);\n\n  var target = rest.target;\n\n  var props = _extends({}, rest, {\n    onClick: function onClick(event) {\n      try {\n        if (_onClick) _onClick(event);\n      } catch (ex) {\n        event.preventDefault();\n        throw ex;\n      }\n\n      if (!event.defaultPrevented && // onClick prevented default\n      event.button === 0 && ( // ignore everything but left clicks\n      !target || target === \"_self\") && // let browser handle \"target=_blank\" etc.\n      !isModifiedEvent(event) // ignore clicks with modifier keys\n      ) {\n          event.preventDefault();\n          navigate();\n        }\n    }\n  }); // React 15 compat\n\n\n  if (forwardRefShim !== forwardRef) {\n    props.ref = forwardedRef || innerRef;\n  } else {\n    props.ref = innerRef;\n  }\n  /* eslint-disable-next-line jsx-a11y/anchor-has-content */\n\n\n  return React.createElement(\"a\", props);\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  LinkAnchor.displayName = \"LinkAnchor\";\n}\n/**\n * The public API for rendering a history-aware <a>.\n */\n\n\nvar Link = forwardRef(function (_ref2, forwardedRef) {\n  var _ref2$component = _ref2.component,\n      component = _ref2$component === void 0 ? LinkAnchor : _ref2$component,\n      replace = _ref2.replace,\n      to = _ref2.to,\n      innerRef = _ref2.innerRef,\n      rest = _objectWithoutPropertiesLoose(_ref2, [\"component\", \"replace\", \"to\", \"innerRef\"]);\n\n  return React.createElement(__RouterContext.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Link> outside a <Router>\") : invariant(false) : void 0;\n    var history = context.history;\n    var location = normalizeToLocation(resolveToLocation(to, context.location), context.location);\n    var href = location ? history.createHref(location) : \"\";\n\n    var props = _extends({}, rest, {\n      href: href,\n      navigate: function navigate() {\n        var location = resolveToLocation(to, context.location);\n        var method = replace ? history.replace : history.push;\n        method(location);\n      }\n    }); // React 15 compat\n\n\n    if (forwardRefShim !== forwardRef) {\n      props.ref = forwardedRef || innerRef;\n    } else {\n      props.innerRef = innerRef;\n    }\n\n    return React.createElement(component, props);\n  });\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  var toType = PropTypes.oneOfType([PropTypes.string, PropTypes.object, PropTypes.func]);\n  var refType = PropTypes.oneOfType([PropTypes.string, PropTypes.func, PropTypes.shape({\n    current: PropTypes.any\n  })]);\n  Link.displayName = \"Link\";\n  Link.propTypes = {\n    innerRef: refType,\n    onClick: PropTypes.func,\n    replace: PropTypes.bool,\n    target: PropTypes.string,\n    to: toType.isRequired\n  };\n}\n\nvar forwardRefShim$1 = function forwardRefShim(C) {\n  return C;\n};\n\nvar forwardRef$1 = React.forwardRef;\n\nif (typeof forwardRef$1 === \"undefined\") {\n  forwardRef$1 = forwardRefShim$1;\n}\n\nfunction joinClassnames() {\n  for (var _len = arguments.length, classnames = new Array(_len), _key = 0; _key < _len; _key++) {\n    classnames[_key] = arguments[_key];\n  }\n\n  return classnames.filter(function (i) {\n    return i;\n  }).join(\" \");\n}\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\n\n\nvar NavLink = forwardRef$1(function (_ref, forwardedRef) {\n  var _ref$ariaCurrent = _ref[\"aria-current\"],\n      ariaCurrent = _ref$ariaCurrent === void 0 ? \"page\" : _ref$ariaCurrent,\n      _ref$activeClassName = _ref.activeClassName,\n      activeClassName = _ref$activeClassName === void 0 ? \"active\" : _ref$activeClassName,\n      activeStyle = _ref.activeStyle,\n      classNameProp = _ref.className,\n      exact = _ref.exact,\n      isActiveProp = _ref.isActive,\n      locationProp = _ref.location,\n      sensitive = _ref.sensitive,\n      strict = _ref.strict,\n      styleProp = _ref.style,\n      to = _ref.to,\n      innerRef = _ref.innerRef,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"aria-current\", \"activeClassName\", \"activeStyle\", \"className\", \"exact\", \"isActive\", \"location\", \"sensitive\", \"strict\", \"style\", \"to\", \"innerRef\"]);\n\n  return React.createElement(__RouterContext.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <NavLink> outside a <Router>\") : invariant(false) : void 0;\n    var currentLocation = locationProp || context.location;\n    var toLocation = normalizeToLocation(resolveToLocation(to, currentLocation), currentLocation);\n    var path = toLocation.pathname; // Regex taken from: https://github.com/pillarjs/path-to-regexp/blob/master/index.js#L202\n\n    var escapedPath = path && path.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, \"\\\\$1\");\n    var match = escapedPath ? matchPath(currentLocation.pathname, {\n      path: escapedPath,\n      exact: exact,\n      sensitive: sensitive,\n      strict: strict\n    }) : null;\n    var isActive = !!(isActiveProp ? isActiveProp(match, currentLocation) : match);\n    var className = isActive ? joinClassnames(classNameProp, activeClassName) : classNameProp;\n    var style = isActive ? _extends({}, styleProp, {}, activeStyle) : styleProp;\n\n    var props = _extends({\n      \"aria-current\": isActive && ariaCurrent || null,\n      className: className,\n      style: style,\n      to: toLocation\n    }, rest); // React 15 compat\n\n\n    if (forwardRefShim$1 !== forwardRef$1) {\n      props.ref = forwardedRef || innerRef;\n    } else {\n      props.innerRef = innerRef;\n    }\n\n    return React.createElement(Link, props);\n  });\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n  var ariaCurrentType = PropTypes.oneOf([\"page\", \"step\", \"location\", \"date\", \"time\", \"true\"]);\n  NavLink.propTypes = _extends({}, Link.propTypes, {\n    \"aria-current\": ariaCurrentType,\n    activeClassName: PropTypes.string,\n    activeStyle: PropTypes.object,\n    className: PropTypes.string,\n    exact: PropTypes.bool,\n    isActive: PropTypes.func,\n    location: PropTypes.object,\n    sensitive: PropTypes.bool,\n    strict: PropTypes.bool,\n    style: PropTypes.object\n  });\n}\n\nexport { BrowserRouter, HashRouter, Link, NavLink };\n//# sourceMappingURL=react-router-dom.js.map\n","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n\n  function Transition(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n\n  var _proto = Transition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n\n    this.updateStatus(false, nextStatus);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n\n      if (nextStatus === ENTERING) {\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n        maybeNode = _ref2[0],\n        maybeAppearing = _ref2[1];\n\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n\n    var active = true;\n\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n\n    return this.nextCallback;\n  };\n\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n          maybeNode = _ref3[0],\n          maybeNextCallback = _ref3[1];\n\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n\n  _proto.render = function render() {\n    var status = this.state.status;\n\n    if (status === UNMOUNTED) {\n      return null;\n    }\n\n    var _this$props = this.props,\n        children = _this$props.children,\n        _in = _this$props.in,\n        _mountOnEnter = _this$props.mountOnEnter,\n        _unmountOnExit = _this$props.unmountOnExit,\n        _appear = _this$props.appear,\n        _enter = _this$props.enter,\n        _exit = _this$props.exit,\n        _timeout = _this$props.timeout,\n        _addEndListener = _this$props.addEndListener,\n        _onEnter = _this$props.onEnter,\n        _onEntering = _this$props.onEntering,\n        _onEntered = _this$props.onEntered,\n        _onExit = _this$props.onExit,\n        _onExiting = _this$props.onExiting,\n        _onExited = _this$props.onExited,\n        _nodeRef = _this$props.nodeRef,\n        childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n\n    return (\n      /*#__PURE__*/\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n\n  return Transition;\n}(React.Component);\n\nTransition.contextType = TransitionGroupContext;\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * A React reference to DOM element that need to transition:\n   * https://stackoverflow.com/a/51127130/4671932\n   *\n   *   - When `nodeRef` prop is used, `node` is not passed to callback functions\n   *      (e.g. `onEnter`) because user already has direct access to the node.\n   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new\n   *     `nodeRef` need to be provided to `Transition` with changed `key` prop\n   *     (see\n   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).\n   */\n  nodeRef: PropTypes.shape({\n    current: typeof Element === 'undefined' ? PropTypes.any : PropTypes.instanceOf(Element)\n  }),\n\n  /**\n   * A `function` child can be used instead of a React element. This function is\n   * called with the current transition status (`'entering'`, `'entered'`,\n   * `'exiting'`, `'exited'`), which can be used to apply context\n   * specific props to a component.\n   *\n   * ```jsx\n   * <Transition in={this.state.in} timeout={150}>\n   *   {state => (\n   *     <MyComponent className={`fade fade-${state}`} />\n   *   )}\n   * </Transition>\n   * ```\n   */\n  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n  /**\n   * Show the component; triggers the enter or exit states\n   */\n  in: PropTypes.bool,\n\n  /**\n   * By default the child component is mounted immediately along with\n   * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n   * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n   */\n  mountOnEnter: PropTypes.bool,\n\n  /**\n   * By default the child component stays mounted after it reaches the `'exited'` state.\n   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n   */\n  unmountOnExit: PropTypes.bool,\n\n  /**\n   * By default the child component does not perform the enter transition when\n   * it first mounts, regardless of the value of `in`. If you want this\n   * behavior, set both `appear` and `in` to `true`.\n   *\n   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop\n   * > only adds an additional enter transition. However, in the\n   * > `<CSSTransition>` component that first enter transition does result in\n   * > additional `.appear-*` classes, that way you can choose to style it\n   * > differently.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * Enable or disable enter transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * Enable or disable exit transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * The duration of the transition, in milliseconds.\n   * Required unless `addEndListener` is provided.\n   *\n   * You may specify a single timeout for all transitions:\n   *\n   * ```jsx\n   * timeout={500}\n   * ```\n   *\n   * or individually:\n   *\n   * ```jsx\n   * timeout={{\n   *  appear: 500,\n   *  enter: 300,\n   *  exit: 500,\n   * }}\n   * ```\n   *\n   * - `appear` defaults to the value of `enter`\n   * - `enter` defaults to `0`\n   * - `exit` defaults to `0`\n   *\n   * @type {number | { enter?: number, exit?: number, appear?: number }}\n   */\n  timeout: function timeout(props) {\n    var pt = timeoutsShape;\n    if (!props.addEndListener) pt = pt.isRequired;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return pt.apply(void 0, [props].concat(args));\n  },\n\n  /**\n   * Add a custom transition end trigger. Called with the transitioning\n   * DOM node and a `done` callback. Allows for more fine grained transition end\n   * logic. Timeouts are still used as a fallback if provided.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * ```jsx\n   * addEndListener={(node, done) => {\n   *   // use the css transitionend event to mark the finish of a transition\n   *   node.addEventListener('transitionend', done, false);\n   * }}\n   * ```\n   */\n  addEndListener: PropTypes.func,\n\n  /**\n   * Callback fired before the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entering\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * Callback fired after the \"entered\" status is applied. An extra parameter\n   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool) -> void\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * Callback fired before the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exiting\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * Callback fired after the \"exited\" status is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement) -> void\n   */\n  onExited: PropTypes.func\n} : {}; // Name the function so it is clearer in the documentation\n\nfunction noop() {}\n\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport TransitionGroup from './TransitionGroup';\n/**\n * The `<ReplaceTransition>` component is a specialized `Transition` component\n * that animates between two children.\n *\n * ```jsx\n * <ReplaceTransition in>\n *   <Fade><div>I appear first</div></Fade>\n *   <Fade><div>I replace the above</div></Fade>\n * </ReplaceTransition>\n * ```\n */\n\nvar ReplaceTransition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(ReplaceTransition, _React$Component);\n\n  function ReplaceTransition() {\n    var _this;\n\n    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {\n      _args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;\n\n    _this.handleEnter = function () {\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n\n      return _this.handleLifecycle('onEnter', 0, args);\n    };\n\n    _this.handleEntering = function () {\n      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n        args[_key3] = arguments[_key3];\n      }\n\n      return _this.handleLifecycle('onEntering', 0, args);\n    };\n\n    _this.handleEntered = function () {\n      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n        args[_key4] = arguments[_key4];\n      }\n\n      return _this.handleLifecycle('onEntered', 0, args);\n    };\n\n    _this.handleExit = function () {\n      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n        args[_key5] = arguments[_key5];\n      }\n\n      return _this.handleLifecycle('onExit', 1, args);\n    };\n\n    _this.handleExiting = function () {\n      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n        args[_key6] = arguments[_key6];\n      }\n\n      return _this.handleLifecycle('onExiting', 1, args);\n    };\n\n    _this.handleExited = function () {\n      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {\n        args[_key7] = arguments[_key7];\n      }\n\n      return _this.handleLifecycle('onExited', 1, args);\n    };\n\n    return _this;\n  }\n\n  var _proto = ReplaceTransition.prototype;\n\n  _proto.handleLifecycle = function handleLifecycle(handler, idx, originalArgs) {\n    var _child$props;\n\n    var children = this.props.children;\n    var child = React.Children.toArray(children)[idx];\n    if (child.props[handler]) (_child$props = child.props)[handler].apply(_child$props, originalArgs);\n\n    if (this.props[handler]) {\n      var maybeNode = child.props.nodeRef ? undefined : ReactDOM.findDOMNode(this);\n      this.props[handler](maybeNode);\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        children = _this$props.children,\n        inProp = _this$props.in,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\"]);\n\n    var _React$Children$toArr = React.Children.toArray(children),\n        first = _React$Children$toArr[0],\n        second = _React$Children$toArr[1];\n\n    delete props.onEnter;\n    delete props.onEntering;\n    delete props.onEntered;\n    delete props.onExit;\n    delete props.onExiting;\n    delete props.onExited;\n    return /*#__PURE__*/React.createElement(TransitionGroup, props, inProp ? React.cloneElement(first, {\n      key: 'first',\n      onEnter: this.handleEnter,\n      onEntering: this.handleEntering,\n      onEntered: this.handleEntered\n    }) : React.cloneElement(second, {\n      key: 'second',\n      onEnter: this.handleExit,\n      onEntering: this.handleExiting,\n      onEntered: this.handleExited\n    }));\n  };\n\n  return ReplaceTransition;\n}(React.Component);\n\nReplaceTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  in: PropTypes.bool.isRequired,\n  children: function children(props, propName) {\n    if (React.Children.count(props[propName]) !== 2) return new Error(\"\\\"\" + propName + \"\\\" must be exactly two transition components.\");\n    return null;\n  }\n} : {};\nexport default ReplaceTransition;","import _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\n\nvar _leaveRenders, _enterRenders;\n\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport { ENTERED, ENTERING, EXITING } from './Transition';\nimport TransitionGroupContext from './TransitionGroupContext';\n\nfunction areChildrenDifferent(oldChildren, newChildren) {\n  if (oldChildren === newChildren) return false;\n\n  if (React.isValidElement(oldChildren) && React.isValidElement(newChildren) && oldChildren.key != null && oldChildren.key === newChildren.key) {\n    return false;\n  }\n\n  return true;\n}\n/**\n * Enum of modes for SwitchTransition component\n * @enum { string }\n */\n\n\nexport var modes = {\n  out: 'out-in',\n  in: 'in-out'\n};\n\nvar callHook = function callHook(element, name, cb) {\n  return function () {\n    var _element$props;\n\n    element.props[name] && (_element$props = element.props)[name].apply(_element$props, arguments);\n    cb();\n  };\n};\n\nvar leaveRenders = (_leaveRenders = {}, _leaveRenders[modes.out] = function (_ref) {\n  var current = _ref.current,\n      changeState = _ref.changeState;\n  return React.cloneElement(current, {\n    in: false,\n    onExited: callHook(current, 'onExited', function () {\n      changeState(ENTERING, null);\n    })\n  });\n}, _leaveRenders[modes.in] = function (_ref2) {\n  var current = _ref2.current,\n      changeState = _ref2.changeState,\n      children = _ref2.children;\n  return [current, React.cloneElement(children, {\n    in: true,\n    onEntered: callHook(children, 'onEntered', function () {\n      changeState(ENTERING);\n    })\n  })];\n}, _leaveRenders);\nvar enterRenders = (_enterRenders = {}, _enterRenders[modes.out] = function (_ref3) {\n  var children = _ref3.children,\n      changeState = _ref3.changeState;\n  return React.cloneElement(children, {\n    in: true,\n    onEntered: callHook(children, 'onEntered', function () {\n      changeState(ENTERED, React.cloneElement(children, {\n        in: true\n      }));\n    })\n  });\n}, _enterRenders[modes.in] = function (_ref4) {\n  var current = _ref4.current,\n      children = _ref4.children,\n      changeState = _ref4.changeState;\n  return [React.cloneElement(current, {\n    in: false,\n    onExited: callHook(current, 'onExited', function () {\n      changeState(ENTERED, React.cloneElement(children, {\n        in: true\n      }));\n    })\n  }), React.cloneElement(children, {\n    in: true\n  })];\n}, _enterRenders);\n/**\n * A transition component inspired by the [vue transition modes](https://vuejs.org/v2/guide/transitions.html#Transition-Modes).\n * You can use it when you want to control the render between state transitions.\n * Based on the selected mode and the child's key which is the `Transition` or `CSSTransition` component, the `SwitchTransition` makes a consistent transition between them.\n *\n * If the `out-in` mode is selected, the `SwitchTransition` waits until the old child leaves and then inserts a new child.\n * If the `in-out` mode is selected, the `SwitchTransition` inserts a new child first, waits for the new child to enter and then removes the old child.\n *\n * **Note**: If you want the animation to happen simultaneously\n * (that is, to have the old child removed and a new child inserted **at the same time**),\n * you should use\n * [`TransitionGroup`](https://reactcommunity.org/react-transition-group/transition-group)\n * instead.\n *\n * ```jsx\n * function App() {\n *  const [state, setState] = useState(false);\n *  return (\n *    <SwitchTransition>\n *      <CSSTransition\n *        key={state ? \"Goodbye, world!\" : \"Hello, world!\"}\n *        addEndListener={(node, done) => node.addEventListener(\"transitionend\", done, false)}\n *        classNames='fade'\n *      >\n *        <button onClick={() => setState(state => !state)}>\n *          {state ? \"Goodbye, world!\" : \"Hello, world!\"}\n *        </button>\n *      </CSSTransition>\n *    </SwitchTransition>\n *  );\n * }\n * ```\n *\n * ```css\n * .fade-enter{\n *    opacity: 0;\n * }\n * .fade-exit{\n *    opacity: 1;\n * }\n * .fade-enter-active{\n *    opacity: 1;\n * }\n * .fade-exit-active{\n *    opacity: 0;\n * }\n * .fade-enter-active,\n * .fade-exit-active{\n *    transition: opacity 500ms;\n * }\n * ```\n */\n\nvar SwitchTransition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(SwitchTransition, _React$Component);\n\n  function SwitchTransition() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.state = {\n      status: ENTERED,\n      current: null\n    };\n    _this.appeared = false;\n\n    _this.changeState = function (status, current) {\n      if (current === void 0) {\n        current = _this.state.current;\n      }\n\n      _this.setState({\n        status: status,\n        current: current\n      });\n    };\n\n    return _this;\n  }\n\n  var _proto = SwitchTransition.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.appeared = true;\n  };\n\n  SwitchTransition.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {\n    if (props.children == null) {\n      return {\n        current: null\n      };\n    }\n\n    if (state.status === ENTERING && props.mode === modes.in) {\n      return {\n        status: ENTERING\n      };\n    }\n\n    if (state.current && areChildrenDifferent(state.current, props.children)) {\n      return {\n        status: EXITING\n      };\n    }\n\n    return {\n      current: React.cloneElement(props.children, {\n        in: true\n      })\n    };\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        children = _this$props.children,\n        mode = _this$props.mode,\n        _this$state = this.state,\n        status = _this$state.status,\n        current = _this$state.current;\n    var data = {\n      children: children,\n      current: current,\n      changeState: this.changeState,\n      status: status\n    };\n    var component;\n\n    switch (status) {\n      case ENTERING:\n        component = enterRenders[mode](data);\n        break;\n\n      case EXITING:\n        component = leaveRenders[mode](data);\n        break;\n\n      case ENTERED:\n        component = current;\n    }\n\n    return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n      value: {\n        isMounting: !this.appeared\n      }\n    }, component);\n  };\n\n  return SwitchTransition;\n}(React.Component);\n\nSwitchTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Transition modes.\n   * `out-in`: Current element transitions out first, then when complete, the new element transitions in.\n   * `in-out`: New element transitions in first, then when complete, the current element transitions out.\n   *\n   * @type {'out-in'|'in-out'}\n   */\n  mode: PropTypes.oneOf([modes.in, modes.out]),\n\n  /**\n   * Any `Transition` or `CSSTransition` component.\n   */\n  children: PropTypes.oneOfType([PropTypes.element.isRequired])\n} : {};\nSwitchTransition.defaultProps = {\n  mode: modes.out\n};\nexport default SwitchTransition;","export { default as CSSTransition } from './CSSTransition';\nexport { default as ReplaceTransition } from './ReplaceTransition';\nexport { default as SwitchTransition } from './SwitchTransition';\nexport { default as TransitionGroup } from './TransitionGroup';\nexport { default as Transition } from './Transition';\nexport { default as config } from './config';","import React from 'react';\nexport default React.createContext(null);","export default {\n  disabled: false\n};","import { Children, cloneElement, isValidElement } from 'react';\n/**\n * Given `this.props.children`, return an object mapping key to child.\n *\n * @param {*} children `this.props.children`\n * @return {object} Mapping of key to child\n */\n\nexport function getChildMapping(children, mapFn) {\n  var mapper = function mapper(child) {\n    return mapFn && isValidElement(child) ? mapFn(child) : child;\n  };\n\n  var result = Object.create(null);\n  if (children) Children.map(children, function (c) {\n    return c;\n  }).forEach(function (child) {\n    // run the map function here instead so that the key is the computed one\n    result[child.key] = mapper(child);\n  });\n  return result;\n}\n/**\n * When you're adding or removing children some may be added or removed in the\n * same render pass. We want to show *both* since we want to simultaneously\n * animate elements in and out. This function takes a previous set of keys\n * and a new set of keys and merges them with its best guess of the correct\n * ordering. In the future we may expose some of the utilities in\n * ReactMultiChild to make this easy, but for now React itself does not\n * directly have this concept of the union of prevChildren and nextChildren\n * so we implement it here.\n *\n * @param {object} prev prev children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @param {object} next next children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @return {object} a key set that contains all keys in `prev` and all keys\n * in `next` in a reasonable order.\n */\n\nexport function mergeChildMappings(prev, next) {\n  prev = prev || {};\n  next = next || {};\n\n  function getValueForKey(key) {\n    return key in next ? next[key] : prev[key];\n  } // For each key of `next`, the list of keys to insert before that key in\n  // the combined list\n\n\n  var nextKeysPending = Object.create(null);\n  var pendingKeys = [];\n\n  for (var prevKey in prev) {\n    if (prevKey in next) {\n      if (pendingKeys.length) {\n        nextKeysPending[prevKey] = pendingKeys;\n        pendingKeys = [];\n      }\n    } else {\n      pendingKeys.push(prevKey);\n    }\n  }\n\n  var i;\n  var childMapping = {};\n\n  for (var nextKey in next) {\n    if (nextKeysPending[nextKey]) {\n      for (i = 0; i < nextKeysPending[nextKey].length; i++) {\n        var pendingNextKey = nextKeysPending[nextKey][i];\n        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);\n      }\n    }\n\n    childMapping[nextKey] = getValueForKey(nextKey);\n  } // Finally, add the keys which didn't appear before any key in `next`\n\n\n  for (i = 0; i < pendingKeys.length; i++) {\n    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);\n  }\n\n  return childMapping;\n}\n\nfunction getProp(child, prop, props) {\n  return props[prop] != null ? props[prop] : child.props[prop];\n}\n\nexport function getInitialChildMapping(props, onExited) {\n  return getChildMapping(props.children, function (child) {\n    return cloneElement(child, {\n      onExited: onExited.bind(null, child),\n      in: true,\n      appear: getProp(child, 'appear', props),\n      enter: getProp(child, 'enter', props),\n      exit: getProp(child, 'exit', props)\n    });\n  });\n}\nexport function getNextChildMapping(nextProps, prevChildMapping, onExited) {\n  var nextChildMapping = getChildMapping(nextProps.children);\n  var children = mergeChildMappings(prevChildMapping, nextChildMapping);\n  Object.keys(children).forEach(function (key) {\n    var child = children[key];\n    if (!isValidElement(child)) return;\n    var hasPrev = (key in prevChildMapping);\n    var hasNext = (key in nextChildMapping);\n    var prevChild = prevChildMapping[key];\n    var isLeaving = isValidElement(prevChild) && !prevChild.props.in; // item is new (entering)\n\n    if (hasNext && (!hasPrev || isLeaving)) {\n      // console.log('entering', key)\n      children[key] = cloneElement(child, {\n        onExited: onExited.bind(null, child),\n        in: true,\n        exit: getProp(child, 'exit', nextProps),\n        enter: getProp(child, 'enter', nextProps)\n      });\n    } else if (!hasNext && hasPrev && !isLeaving) {\n      // item is old (exiting)\n      // console.log('leaving', key)\n      children[key] = cloneElement(child, {\n        in: false\n      });\n    } else if (hasNext && hasPrev && isValidElement(prevChild)) {\n      // item hasn't changed transition states\n      // copy over the last transition props;\n      // console.log('unchanged', key)\n      children[key] = cloneElement(child, {\n        onExited: onExited.bind(null, child),\n        in: prevChild.props.in,\n        exit: getProp(child, 'exit', nextProps),\n        enter: getProp(child, 'enter', nextProps)\n      });\n    }\n  });\n  return children;\n}","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport React from 'react';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { getChildMapping, getInitialChildMapping, getNextChildMapping } from './utils/ChildMapping';\n\nvar values = Object.values || function (obj) {\n  return Object.keys(obj).map(function (k) {\n    return obj[k];\n  });\n};\n\nvar defaultProps = {\n  component: 'div',\n  childFactory: function childFactory(child) {\n    return child;\n  }\n};\n/**\n * The `<TransitionGroup>` component manages a set of transition components\n * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition\n * components, `<TransitionGroup>` is a state machine for managing the mounting\n * and unmounting of components over time.\n *\n * Consider the example below. As items are removed or added to the TodoList the\n * `in` prop is toggled automatically by the `<TransitionGroup>`.\n *\n * Note that `<TransitionGroup>`  does not define any animation behavior!\n * Exactly _how_ a list item animates is up to the individual transition\n * component. This means you can mix and match animations across different list\n * items.\n */\n\nvar TransitionGroup = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(TransitionGroup, _React$Component);\n\n  function TransitionGroup(props, context) {\n    var _this;\n\n    _this = _React$Component.call(this, props, context) || this;\n\n    var handleExited = _this.handleExited.bind(_assertThisInitialized(_this)); // Initial children should all be entering, dependent on appear\n\n\n    _this.state = {\n      contextValue: {\n        isMounting: true\n      },\n      handleExited: handleExited,\n      firstRender: true\n    };\n    return _this;\n  }\n\n  var _proto = TransitionGroup.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.mounted = true;\n    this.setState({\n      contextValue: {\n        isMounting: false\n      }\n    });\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.mounted = false;\n  };\n\n  TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {\n    var prevChildMapping = _ref.children,\n        handleExited = _ref.handleExited,\n        firstRender = _ref.firstRender;\n    return {\n      children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),\n      firstRender: false\n    };\n  } // node is `undefined` when user provided `nodeRef` prop\n  ;\n\n  _proto.handleExited = function handleExited(child, node) {\n    var currentChildMapping = getChildMapping(this.props.children);\n    if (child.key in currentChildMapping) return;\n\n    if (child.props.onExited) {\n      child.props.onExited(node);\n    }\n\n    if (this.mounted) {\n      this.setState(function (state) {\n        var children = _extends({}, state.children);\n\n        delete children[child.key];\n        return {\n          children: children\n        };\n      });\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        Component = _this$props.component,\n        childFactory = _this$props.childFactory,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"component\", \"childFactory\"]);\n\n    var contextValue = this.state.contextValue;\n    var children = values(this.state.children).map(childFactory);\n    delete props.appear;\n    delete props.enter;\n    delete props.exit;\n\n    if (Component === null) {\n      return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n        value: contextValue\n      }, children);\n    }\n\n    return /*#__PURE__*/React.createElement(TransitionGroupContext.Provider, {\n      value: contextValue\n    }, /*#__PURE__*/React.createElement(Component, props, children));\n  };\n\n  return TransitionGroup;\n}(React.Component);\n\nTransitionGroup.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * `<TransitionGroup>` renders a `<div>` by default. You can change this\n   * behavior by providing a `component` prop.\n   * If you use React v16+ and would like to avoid a wrapping `<div>` element\n   * you can pass in `component={null}`. This is useful if the wrapping div\n   * borks your css styles.\n   */\n  component: PropTypes.any,\n\n  /**\n   * A set of `<Transition>` components, that are toggled `in` and out as they\n   * leave. the `<TransitionGroup>` will inject specific transition props, so\n   * remember to spread them through if you are wrapping the `<Transition>` as\n   * with our `<Fade>` example.\n   *\n   * While this component is meant for multiple `Transition` or `CSSTransition`\n   * children, sometimes you may want to have a single transition child with\n   * content that you want to be transitioned out and in when you change it\n   * (e.g. routes, images etc.) In that case you can change the `key` prop of\n   * the transition child as you change its content, this will cause\n   * `TransitionGroup` to transition the child out and back in.\n   */\n  children: PropTypes.node,\n\n  /**\n   * A convenience prop that enables or disables appear animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  appear: PropTypes.bool,\n\n  /**\n   * A convenience prop that enables or disables enter animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  enter: PropTypes.bool,\n\n  /**\n   * A convenience prop that enables or disables exit animations\n   * for all children. Note that specifying this will override any defaults set\n   * on individual children Transitions.\n   */\n  exit: PropTypes.bool,\n\n  /**\n   * You may need to apply reactive updates to a child as it is exiting.\n   * This is generally done by using `cloneElement` however in the case of an exiting\n   * child the element has already been removed and not accessible to the consumer.\n   *\n   * If you do need to update a child as it leaves you can provide a `childFactory`\n   * to wrap every child, even the ones that are leaving.\n   *\n   * @type Function(child: ReactElement) -> ReactElement\n   */\n  childFactory: PropTypes.func\n} : {};\nTransitionGroup.defaultProps = defaultProps;\nexport default TransitionGroup;","/**\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 * 5) Added support for injecting custom window object\n **/\nexport default function createDetectElementResize(nonce, hostWindow) {\n  // Check `document` and `window` in case of server-side rendering\n  var _window;\n\n  if (typeof hostWindow !== 'undefined') {\n    _window = hostWindow;\n  } else if (typeof window !== 'undefined') {\n    _window = window;\n  } else if (typeof self !== 'undefined') {\n    _window = self;\n  } else {\n    _window = global;\n  }\n\n  var attachEvent = typeof _window.document !== 'undefined' && _window.document.attachEvent;\n\n  if (!attachEvent) {\n    var requestFrame = function () {\n      var raf = _window.requestAnimationFrame || _window.mozRequestAnimationFrame || _window.webkitRequestAnimationFrame || function (fn) {\n        return _window.setTimeout(fn, 20);\n      };\n\n      return function (fn) {\n        return raf(fn);\n      };\n    }();\n\n    var cancelFrame = function () {\n      var cancel = _window.cancelAnimationFrame || _window.mozCancelAnimationFrame || _window.webkitCancelAnimationFrame || _window.clearTimeout;\n      return function (id) {\n        return cancel(id);\n      };\n    }();\n\n    var resetTriggers = function resetTriggers(element) {\n      var triggers = element.__resizeTriggers__,\n          expand = triggers.firstElementChild,\n          contract = triggers.lastElementChild,\n          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\n    var checkTriggers = function checkTriggers(element) {\n      return element.offsetWidth != element.__resizeLast__.width || element.offsetHeight != element.__resizeLast__.height;\n    };\n\n    var scrollListener = function scrollListener(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) {\n        return;\n      }\n\n      var element = this;\n      resetTriggers(this);\n\n      if (this.__resizeRAF__) {\n        cancelFrame(this.__resizeRAF__);\n      }\n\n      this.__resizeRAF__ = requestFrame(function () {\n        if (checkTriggers(element)) {\n          element.__resizeLast__.width = element.offsetWidth;\n          element.__resizeLast__.height = element.offsetHeight;\n\n          element.__resizeListeners__.forEach(function (fn) {\n            fn.call(element, e);\n          });\n        }\n      });\n    };\n    /* Detect CSS Animations support to detect element display/re-attach */\n\n\n    var animation = false,\n        keyframeprefix = '',\n        animationstartevent = 'animationstart',\n        domPrefixes = 'Webkit Moz O ms'.split(' '),\n        startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '),\n        pfx = '';\n    {\n      var elm = _window.document.createElement('fakeelement');\n\n      if (elm.style.animationName !== undefined) {\n        animation = true;\n      }\n\n      if (animation === false) {\n        for (var i = 0; i < domPrefixes.length; i++) {\n          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    }\n    var animationName = 'resizeanim';\n    var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } ';\n    var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; ';\n  }\n\n  var createStyles = function createStyles(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      var 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%; }',\n          head = doc.head || doc.getElementsByTagName('head')[0],\n          style = doc.createElement('style');\n      style.id = 'detectElementResize';\n      style.type = 'text/css';\n\n      if (nonce != null) {\n        style.setAttribute('nonce', nonce);\n      }\n\n      if (style.styleSheet) {\n        style.styleSheet.cssText = css;\n      } else {\n        style.appendChild(doc.createTextNode(css));\n      }\n\n      head.appendChild(style);\n    }\n  };\n\n  var addResizeListener = function addResizeListener(element, fn) {\n    if (attachEvent) {\n      element.attachEvent('onresize', fn);\n    } else {\n      if (!element.__resizeTriggers__) {\n        var doc = element.ownerDocument;\n\n        var elementStyle = _window.getComputedStyle(element);\n\n        if (elementStyle && elementStyle.position == 'static') {\n          element.style.position = 'relative';\n        }\n\n        createStyles(doc);\n        element.__resizeLast__ = {};\n        element.__resizeListeners__ = [];\n        (element.__resizeTriggers__ = doc.createElement('div')).className = 'resize-triggers';\n        element.__resizeTriggers__.innerHTML = '<div class=\"expand-trigger\"><div></div></div>' + '<div class=\"contract-trigger\"></div>';\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 */\n\n        if (animationstartevent) {\n          element.__resizeTriggers__.__animationListener__ = function animationListener(e) {\n            if (e.animationName == animationName) {\n              resetTriggers(element);\n            }\n          };\n\n          element.__resizeTriggers__.addEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);\n        }\n      }\n\n      element.__resizeListeners__.push(fn);\n    }\n  };\n\n  var removeResizeListener = function removeResizeListener(element, fn) {\n    if (attachEvent) {\n      element.detachEvent('onresize', fn);\n    } else {\n      element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);\n\n      if (!element.__resizeListeners__.length) {\n        element.removeEventListener('scroll', scrollListener, true);\n\n        if (element.__resizeTriggers__.__animationListener__) {\n          element.__resizeTriggers__.removeEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);\n\n          element.__resizeTriggers__.__animationListener__ = null;\n        }\n\n        try {\n          element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);\n        } catch (e) {// Preact compat; see developit/preact-compat/issues/228\n        }\n      }\n    }\n  };\n\n  return {\n    addResizeListener: addResizeListener,\n    removeResizeListener: removeResizeListener\n  };\n}","import React from 'react';\nexport var ReactReduxContext =\n/*#__PURE__*/\nReact.createContext(null);\n\nif (process.env.NODE_ENV !== 'production') {\n  ReactReduxContext.displayName = 'ReactRedux';\n}\n\nexport default ReactReduxContext;","// Default to a dummy \"batch\" implementation that just runs the callback\nfunction defaultNoopBatch(callback) {\n  callback();\n}\n\nvar batch = defaultNoopBatch; // Allow injecting another batching function later\n\nexport var setBatch = function setBatch(newBatch) {\n  return batch = newBatch;\n}; // Supply a getter just to skip dealing with ESM bindings\n\nexport var getBatch = function getBatch() {\n  return batch;\n};","import { getBatch } from './batch'; // encapsulates the subscription logic for connecting a component to the redux store, as\n// well as nesting subscriptions of descendant components, so that we can ensure the\n// ancestor components re-render before descendants\n\nvar nullListeners = {\n  notify: function notify() {}\n};\n\nfunction createListenerCollection() {\n  var batch = getBatch();\n  var first = null;\n  var last = null;\n  return {\n    clear: function clear() {\n      first = null;\n      last = null;\n    },\n    notify: function notify() {\n      batch(function () {\n        var listener = first;\n\n        while (listener) {\n          listener.callback();\n          listener = listener.next;\n        }\n      });\n    },\n    get: function get() {\n      var listeners = [];\n      var listener = first;\n\n      while (listener) {\n        listeners.push(listener);\n        listener = listener.next;\n      }\n\n      return listeners;\n    },\n    subscribe: function subscribe(callback) {\n      var isSubscribed = true;\n      var listener = last = {\n        callback: callback,\n        next: null,\n        prev: last\n      };\n\n      if (listener.prev) {\n        listener.prev.next = listener;\n      } else {\n        first = listener;\n      }\n\n      return function unsubscribe() {\n        if (!isSubscribed || first === null) return;\n        isSubscribed = false;\n\n        if (listener.next) {\n          listener.next.prev = listener.prev;\n        } else {\n          last = listener.prev;\n        }\n\n        if (listener.prev) {\n          listener.prev.next = listener.next;\n        } else {\n          first = listener.next;\n        }\n      };\n    }\n  };\n}\n\nvar Subscription =\n/*#__PURE__*/\nfunction () {\n  function Subscription(store, parentSub) {\n    this.store = store;\n    this.parentSub = parentSub;\n    this.unsubscribe = null;\n    this.listeners = nullListeners;\n    this.handleChangeWrapper = this.handleChangeWrapper.bind(this);\n  }\n\n  var _proto = Subscription.prototype;\n\n  _proto.addNestedSub = function addNestedSub(listener) {\n    this.trySubscribe();\n    return this.listeners.subscribe(listener);\n  };\n\n  _proto.notifyNestedSubs = function notifyNestedSubs() {\n    this.listeners.notify();\n  };\n\n  _proto.handleChangeWrapper = function handleChangeWrapper() {\n    if (this.onStateChange) {\n      this.onStateChange();\n    }\n  };\n\n  _proto.isSubscribed = function isSubscribed() {\n    return Boolean(this.unsubscribe);\n  };\n\n  _proto.trySubscribe = function trySubscribe() {\n    if (!this.unsubscribe) {\n      this.unsubscribe = this.parentSub ? this.parentSub.addNestedSub(this.handleChangeWrapper) : this.store.subscribe(this.handleChangeWrapper);\n      this.listeners = createListenerCollection();\n    }\n  };\n\n  _proto.tryUnsubscribe = function tryUnsubscribe() {\n    if (this.unsubscribe) {\n      this.unsubscribe();\n      this.unsubscribe = null;\n      this.listeners.clear();\n      this.listeners = nullListeners;\n    }\n  };\n\n  return Subscription;\n}();\n\nexport { Subscription as default };","import React, { useMemo, useEffect } from 'react';\nimport PropTypes from 'prop-types';\nimport { ReactReduxContext } from './Context';\nimport Subscription from '../utils/Subscription';\n\nfunction Provider(_ref) {\n  var store = _ref.store,\n      context = _ref.context,\n      children = _ref.children;\n  var contextValue = useMemo(function () {\n    var subscription = new Subscription(store);\n    subscription.onStateChange = subscription.notifyNestedSubs;\n    return {\n      store: store,\n      subscription: subscription\n    };\n  }, [store]);\n  var previousState = useMemo(function () {\n    return store.getState();\n  }, [store]);\n  useEffect(function () {\n    var subscription = contextValue.subscription;\n    subscription.trySubscribe();\n\n    if (previousState !== store.getState()) {\n      subscription.notifyNestedSubs();\n    }\n\n    return function () {\n      subscription.tryUnsubscribe();\n      subscription.onStateChange = null;\n    };\n  }, [contextValue, previousState]);\n  var Context = context || ReactReduxContext;\n  return React.createElement(Context.Provider, {\n    value: contextValue\n  }, children);\n}\n\nif (process.env.NODE_ENV !== 'production') {\n  Provider.propTypes = {\n    store: PropTypes.shape({\n      subscribe: PropTypes.func.isRequired,\n      dispatch: PropTypes.func.isRequired,\n      getState: PropTypes.func.isRequired\n    }),\n    context: PropTypes.object,\n    children: PropTypes.any\n  };\n}\n\nexport default Provider;","import { useEffect, useLayoutEffect } from 'react'; // React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser. We need useLayoutEffect to ensure the store\n// subscription callback always has the selector from the latest render commit\n// available, otherwise a store update may happen between render and the effect,\n// which may cause missed updates; we also must ensure the store subscription\n// is created synchronously, otherwise a store update may occur before the\n// subscription is created and an inconsistent state may be observed\n\nexport var useIsomorphicLayoutEffect = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined' ? useLayoutEffect : useEffect;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport hoistStatics from 'hoist-non-react-statics';\nimport React, { useContext, useMemo, useRef, useReducer } from 'react';\nimport { isValidElementType, isContextConsumer } from 'react-is';\nimport Subscription from '../utils/Subscription';\nimport { useIsomorphicLayoutEffect } from '../utils/useIsomorphicLayoutEffect';\nimport { ReactReduxContext } from './Context'; // Define some constant arrays just to avoid re-creating these\n\nvar EMPTY_ARRAY = [];\nvar NO_SUBSCRIPTION_ARRAY = [null, null];\n\nvar stringifyComponent = function stringifyComponent(Comp) {\n  try {\n    return JSON.stringify(Comp);\n  } catch (err) {\n    return String(Comp);\n  }\n};\n\nfunction storeStateUpdatesReducer(state, action) {\n  var updateCount = state[1];\n  return [action.payload, updateCount + 1];\n}\n\nfunction useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) {\n  useIsomorphicLayoutEffect(function () {\n    return effectFunc.apply(void 0, effectArgs);\n  }, dependencies);\n}\n\nfunction captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, actualChildProps, childPropsFromStoreUpdate, notifyNestedSubs) {\n  // We want to capture the wrapper props and child props we used for later comparisons\n  lastWrapperProps.current = wrapperProps;\n  lastChildProps.current = actualChildProps;\n  renderIsScheduled.current = false; // If the render was from a store update, clear out that reference and cascade the subscriber update\n\n  if (childPropsFromStoreUpdate.current) {\n    childPropsFromStoreUpdate.current = null;\n    notifyNestedSubs();\n  }\n}\n\nfunction subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, childPropsFromStoreUpdate, notifyNestedSubs, forceComponentUpdateDispatch) {\n  // If we're not subscribed to the store, nothing to do here\n  if (!shouldHandleStateChanges) return; // Capture values for checking if and when this component unmounts\n\n  var didUnsubscribe = false;\n  var lastThrownError = null; // We'll run this callback every time a store subscription update propagates to this component\n\n  var checkForUpdates = function checkForUpdates() {\n    if (didUnsubscribe) {\n      // Don't run stale listeners.\n      // Redux doesn't guarantee unsubscriptions happen until next dispatch.\n      return;\n    }\n\n    var latestStoreState = store.getState();\n    var newChildProps, error;\n\n    try {\n      // Actually run the selector with the most recent store state and wrapper props\n      // to determine what the child props should be\n      newChildProps = childPropsSelector(latestStoreState, lastWrapperProps.current);\n    } catch (e) {\n      error = e;\n      lastThrownError = e;\n    }\n\n    if (!error) {\n      lastThrownError = null;\n    } // If the child props haven't changed, nothing to do here - cascade the subscription update\n\n\n    if (newChildProps === lastChildProps.current) {\n      if (!renderIsScheduled.current) {\n        notifyNestedSubs();\n      }\n    } else {\n      // Save references to the new child props.  Note that we track the \"child props from store update\"\n      // as a ref instead of a useState/useReducer because we need a way to determine if that value has\n      // been processed.  If this went into useState/useReducer, we couldn't clear out the value without\n      // forcing another re-render, which we don't want.\n      lastChildProps.current = newChildProps;\n      childPropsFromStoreUpdate.current = newChildProps;\n      renderIsScheduled.current = true; // If the child props _did_ change (or we caught an error), this wrapper component needs to re-render\n\n      forceComponentUpdateDispatch({\n        type: 'STORE_UPDATED',\n        payload: {\n          error: error\n        }\n      });\n    }\n  }; // Actually subscribe to the nearest connected ancestor (or store)\n\n\n  subscription.onStateChange = checkForUpdates;\n  subscription.trySubscribe(); // Pull data from the store after first render in case the store has\n  // changed since we began.\n\n  checkForUpdates();\n\n  var unsubscribeWrapper = function unsubscribeWrapper() {\n    didUnsubscribe = true;\n    subscription.tryUnsubscribe();\n    subscription.onStateChange = null;\n\n    if (lastThrownError) {\n      // It's possible that we caught an error due to a bad mapState function, but the\n      // parent re-rendered without this component and we're about to unmount.\n      // This shouldn't happen as long as we do top-down subscriptions correctly, but\n      // if we ever do those wrong, this throw will surface the error in our tests.\n      // In that case, throw the error from here so it doesn't get lost.\n      throw lastThrownError;\n    }\n  };\n\n  return unsubscribeWrapper;\n}\n\nvar initStateUpdates = function initStateUpdates() {\n  return [null, 0];\n};\n\nexport default function connectAdvanced(\n/*\r\n  selectorFactory is a func that is responsible for returning the selector function used to\r\n  compute new props from state, props, and dispatch. For example:\r\n      export default connectAdvanced((dispatch, options) => (state, props) => ({\r\n      thing: state.things[props.thingId],\r\n      saveThing: fields => dispatch(actionCreators.saveThing(props.thingId, fields)),\r\n    }))(YourComponent)\r\n    Access to dispatch is provided to the factory so selectorFactories can bind actionCreators\r\n  outside of their selector as an optimization. Options passed to connectAdvanced are passed to\r\n  the selectorFactory, along with displayName and WrappedComponent, as the second argument.\r\n    Note that selectorFactory is responsible for all caching/memoization of inbound and outbound\r\n  props. Do not use connectAdvanced directly without memoizing results between calls to your\r\n  selector, otherwise the Connect component will re-render on every state or props change.\r\n*/\nselectorFactory, // options object:\n_ref) {\n  if (_ref === void 0) {\n    _ref = {};\n  }\n\n  var _ref2 = _ref,\n      _ref2$getDisplayName = _ref2.getDisplayName,\n      getDisplayName = _ref2$getDisplayName === void 0 ? function (name) {\n    return \"ConnectAdvanced(\" + name + \")\";\n  } : _ref2$getDisplayName,\n      _ref2$methodName = _ref2.methodName,\n      methodName = _ref2$methodName === void 0 ? 'connectAdvanced' : _ref2$methodName,\n      _ref2$renderCountProp = _ref2.renderCountProp,\n      renderCountProp = _ref2$renderCountProp === void 0 ? undefined : _ref2$renderCountProp,\n      _ref2$shouldHandleSta = _ref2.shouldHandleStateChanges,\n      shouldHandleStateChanges = _ref2$shouldHandleSta === void 0 ? true : _ref2$shouldHandleSta,\n      _ref2$storeKey = _ref2.storeKey,\n      storeKey = _ref2$storeKey === void 0 ? 'store' : _ref2$storeKey,\n      _ref2$withRef = _ref2.withRef,\n      withRef = _ref2$withRef === void 0 ? false : _ref2$withRef,\n      _ref2$forwardRef = _ref2.forwardRef,\n      forwardRef = _ref2$forwardRef === void 0 ? false : _ref2$forwardRef,\n      _ref2$context = _ref2.context,\n      context = _ref2$context === void 0 ? ReactReduxContext : _ref2$context,\n      connectOptions = _objectWithoutPropertiesLoose(_ref2, [\"getDisplayName\", \"methodName\", \"renderCountProp\", \"shouldHandleStateChanges\", \"storeKey\", \"withRef\", \"forwardRef\", \"context\"]);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (renderCountProp !== undefined) {\n      throw new Error(\"renderCountProp is removed. render counting is built into the latest React Dev Tools profiling extension\");\n    }\n\n    if (withRef) {\n      throw new Error('withRef is removed. To access the wrapped instance, use a ref on the connected component');\n    }\n\n    var customStoreWarningMessage = 'To use a custom Redux store for specific components, create a custom React context with ' + \"React.createContext(), and pass the context object to React Redux's Provider and specific components\" + ' like: <Provider context={MyContext}><ConnectedComponent context={MyContext} /></Provider>. ' + 'You may also pass a {context : MyContext} option to connect';\n\n    if (storeKey !== 'store') {\n      throw new Error('storeKey has been removed and does not do anything. ' + customStoreWarningMessage);\n    }\n  }\n\n  var Context = context;\n  return function wrapWithConnect(WrappedComponent) {\n    if (process.env.NODE_ENV !== 'production' && !isValidElementType(WrappedComponent)) {\n      throw new Error(\"You must pass a component to the function returned by \" + (methodName + \". Instead received \" + stringifyComponent(WrappedComponent)));\n    }\n\n    var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';\n    var displayName = getDisplayName(wrappedComponentName);\n\n    var selectorFactoryOptions = _extends({}, connectOptions, {\n      getDisplayName: getDisplayName,\n      methodName: methodName,\n      renderCountProp: renderCountProp,\n      shouldHandleStateChanges: shouldHandleStateChanges,\n      storeKey: storeKey,\n      displayName: displayName,\n      wrappedComponentName: wrappedComponentName,\n      WrappedComponent: WrappedComponent\n    });\n\n    var pure = connectOptions.pure;\n\n    function createChildSelector(store) {\n      return selectorFactory(store.dispatch, selectorFactoryOptions);\n    } // If we aren't running in \"pure\" mode, we don't want to memoize values.\n    // To avoid conditionally calling hooks, we fall back to a tiny wrapper\n    // that just executes the given callback immediately.\n\n\n    var usePureOnlyMemo = pure ? useMemo : function (callback) {\n      return callback();\n    };\n\n    function ConnectFunction(props) {\n      var _useMemo = useMemo(function () {\n        // Distinguish between actual \"data\" props that were passed to the wrapper component,\n        // and values needed to control behavior (forwarded refs, alternate context instances).\n        // To maintain the wrapperProps object reference, memoize this destructuring.\n        var reactReduxForwardedRef = props.reactReduxForwardedRef,\n            wrapperProps = _objectWithoutPropertiesLoose(props, [\"reactReduxForwardedRef\"]);\n\n        return [props.context, reactReduxForwardedRef, wrapperProps];\n      }, [props]),\n          propsContext = _useMemo[0],\n          reactReduxForwardedRef = _useMemo[1],\n          wrapperProps = _useMemo[2];\n\n      var ContextToUse = useMemo(function () {\n        // Users may optionally pass in a custom context instance to use instead of our ReactReduxContext.\n        // Memoize the check that determines which context instance we should use.\n        return propsContext && propsContext.Consumer && isContextConsumer(React.createElement(propsContext.Consumer, null)) ? propsContext : Context;\n      }, [propsContext, Context]); // Retrieve the store and ancestor subscription via context, if available\n\n      var contextValue = useContext(ContextToUse); // The store _must_ exist as either a prop or in context.\n      // We'll check to see if it _looks_ like a Redux store first.\n      // This allows us to pass through a `store` prop that is just a plain value.\n\n      var didStoreComeFromProps = Boolean(props.store) && Boolean(props.store.getState) && Boolean(props.store.dispatch);\n      var didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store);\n\n      if (process.env.NODE_ENV !== 'production' && !didStoreComeFromProps && !didStoreComeFromContext) {\n        throw new Error(\"Could not find \\\"store\\\" in the context of \" + (\"\\\"\" + displayName + \"\\\". Either wrap the root component in a <Provider>, \") + \"or pass a custom React context provider to <Provider> and the corresponding \" + (\"React context consumer to \" + displayName + \" in connect options.\"));\n      } // Based on the previous check, one of these must be true\n\n\n      var store = didStoreComeFromProps ? props.store : contextValue.store;\n      var childPropsSelector = useMemo(function () {\n        // The child props selector needs the store reference as an input.\n        // Re-create this selector whenever the store changes.\n        return createChildSelector(store);\n      }, [store]);\n\n      var _useMemo2 = useMemo(function () {\n        if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY; // This Subscription's source should match where store came from: props vs. context. A component\n        // connected to the store via props shouldn't use subscription from context, or vice versa.\n\n        var subscription = new Subscription(store, didStoreComeFromProps ? null : contextValue.subscription); // `notifyNestedSubs` is duplicated to handle the case where the component is unmounted in\n        // the middle of the notification loop, where `subscription` will then be null. This can\n        // probably be avoided if Subscription's listeners logic is changed to not call listeners\n        // that have been unsubscribed in the  middle of the notification loop.\n\n        var notifyNestedSubs = subscription.notifyNestedSubs.bind(subscription);\n        return [subscription, notifyNestedSubs];\n      }, [store, didStoreComeFromProps, contextValue]),\n          subscription = _useMemo2[0],\n          notifyNestedSubs = _useMemo2[1]; // Determine what {store, subscription} value should be put into nested context, if necessary,\n      // and memoize that value to avoid unnecessary context updates.\n\n\n      var overriddenContextValue = useMemo(function () {\n        if (didStoreComeFromProps) {\n          // This component is directly subscribed to a store from props.\n          // We don't want descendants reading from this store - pass down whatever\n          // the existing context value is from the nearest connected ancestor.\n          return contextValue;\n        } // Otherwise, put this component's subscription instance into context, so that\n        // connected descendants won't update until after this component is done\n\n\n        return _extends({}, contextValue, {\n          subscription: subscription\n        });\n      }, [didStoreComeFromProps, contextValue, subscription]); // We need to force this wrapper component to re-render whenever a Redux store update\n      // causes a change to the calculated child component props (or we caught an error in mapState)\n\n      var _useReducer = useReducer(storeStateUpdatesReducer, EMPTY_ARRAY, initStateUpdates),\n          _useReducer$ = _useReducer[0],\n          previousStateUpdateResult = _useReducer$[0],\n          forceComponentUpdateDispatch = _useReducer[1]; // Propagate any mapState/mapDispatch errors upwards\n\n\n      if (previousStateUpdateResult && previousStateUpdateResult.error) {\n        throw previousStateUpdateResult.error;\n      } // Set up refs to coordinate values between the subscription effect and the render logic\n\n\n      var lastChildProps = useRef();\n      var lastWrapperProps = useRef(wrapperProps);\n      var childPropsFromStoreUpdate = useRef();\n      var renderIsScheduled = useRef(false);\n      var actualChildProps = usePureOnlyMemo(function () {\n        // Tricky logic here:\n        // - This render may have been triggered by a Redux store update that produced new child props\n        // - However, we may have gotten new wrapper props after that\n        // If we have new child props, and the same wrapper props, we know we should use the new child props as-is.\n        // But, if we have new wrapper props, those might change the child props, so we have to recalculate things.\n        // So, we'll use the child props from store update only if the wrapper props are the same as last time.\n        if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) {\n          return childPropsFromStoreUpdate.current;\n        } // TODO We're reading the store directly in render() here. Bad idea?\n        // This will likely cause Bad Things (TM) to happen in Concurrent Mode.\n        // Note that we do this because on renders _not_ caused by store updates, we need the latest store state\n        // to determine what the child props should be.\n\n\n        return childPropsSelector(store.getState(), wrapperProps);\n      }, [store, previousStateUpdateResult, wrapperProps]); // We need this to execute synchronously every time we re-render. However, React warns\n      // about useLayoutEffect in SSR, so we try to detect environment and fall back to\n      // just useEffect instead to avoid the warning, since neither will run anyway.\n\n      useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, actualChildProps, childPropsFromStoreUpdate, notifyNestedSubs]); // Our re-subscribe logic only runs when the store/subscription setup changes\n\n      useIsomorphicLayoutEffectWithArgs(subscribeUpdates, [shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, childPropsFromStoreUpdate, notifyNestedSubs, forceComponentUpdateDispatch], [store, subscription, childPropsSelector]); // Now that all that's done, we can finally try to actually render the child component.\n      // We memoize the elements for the rendered child component as an optimization.\n\n      var renderedWrappedComponent = useMemo(function () {\n        return React.createElement(WrappedComponent, _extends({}, actualChildProps, {\n          ref: reactReduxForwardedRef\n        }));\n      }, [reactReduxForwardedRef, WrappedComponent, actualChildProps]); // If React sees the exact same element reference as last time, it bails out of re-rendering\n      // that child, same as if it was wrapped in React.memo() or returned false from shouldComponentUpdate.\n\n      var renderedChild = useMemo(function () {\n        if (shouldHandleStateChanges) {\n          // If this component is subscribed to store updates, we need to pass its own\n          // subscription instance down to our descendants. That means rendering the same\n          // Context instance, and putting a different value into the context.\n          return React.createElement(ContextToUse.Provider, {\n            value: overriddenContextValue\n          }, renderedWrappedComponent);\n        }\n\n        return renderedWrappedComponent;\n      }, [ContextToUse, renderedWrappedComponent, overriddenContextValue]);\n      return renderedChild;\n    } // If we're in \"pure\" mode, ensure our wrapper component only re-renders when incoming props have changed.\n\n\n    var Connect = pure ? React.memo(ConnectFunction) : ConnectFunction;\n    Connect.WrappedComponent = WrappedComponent;\n    Connect.displayName = displayName;\n\n    if (forwardRef) {\n      var forwarded = React.forwardRef(function forwardConnectRef(props, ref) {\n        return React.createElement(Connect, _extends({}, props, {\n          reactReduxForwardedRef: ref\n        }));\n      });\n      forwarded.displayName = displayName;\n      forwarded.WrappedComponent = WrappedComponent;\n      return hoistStatics(forwarded, WrappedComponent);\n    }\n\n    return hoistStatics(Connect, WrappedComponent);\n  };\n}","function is(x, y) {\n  if (x === y) {\n    return x !== 0 || y !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\n\nexport default function shallowEqual(objA, objB) {\n  if (is(objA, objB)) return true;\n\n  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {\n    return false;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n  if (keysA.length !== keysB.length) return false;\n\n  for (var i = 0; i < keysA.length; i++) {\n    if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {\n      return false;\n    }\n  }\n\n  return true;\n}","import verifyPlainObject from '../utils/verifyPlainObject';\nexport function wrapMapToPropsConstant(getConstant) {\n  return function initConstantSelector(dispatch, options) {\n    var constant = getConstant(dispatch, options);\n\n    function constantSelector() {\n      return constant;\n    }\n\n    constantSelector.dependsOnOwnProps = false;\n    return constantSelector;\n  };\n} // dependsOnOwnProps is used by createMapToPropsProxy to determine whether to pass props as args\n// to the mapToProps function being wrapped. It is also used by makePurePropsSelector to determine\n// whether mapToProps needs to be invoked when props have changed.\n//\n// A length of one signals that mapToProps does not depend on props from the parent component.\n// A length of zero is assumed to mean mapToProps is getting args via arguments or ...args and\n// therefore not reporting its length accurately..\n\nexport function getDependsOnOwnProps(mapToProps) {\n  return mapToProps.dependsOnOwnProps !== null && mapToProps.dependsOnOwnProps !== undefined ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;\n} // Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,\n// this function wraps mapToProps in a proxy function which does several things:\n//\n//  * Detects whether the mapToProps function being called depends on props, which\n//    is used by selectorFactory to decide if it should reinvoke on props changes.\n//\n//  * On first call, handles mapToProps if returns another function, and treats that\n//    new function as the true mapToProps for subsequent calls.\n//\n//  * On first call, verifies the first result is a plain object, in order to warn\n//    the developer that their mapToProps function is not returning a valid result.\n//\n\nexport function wrapMapToPropsFunc(mapToProps, methodName) {\n  return function initProxySelector(dispatch, _ref) {\n    var displayName = _ref.displayName;\n\n    var proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {\n      return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch);\n    }; // allow detectFactoryAndVerify to get ownProps\n\n\n    proxy.dependsOnOwnProps = true;\n\n    proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {\n      proxy.mapToProps = mapToProps;\n      proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);\n      var props = proxy(stateOrDispatch, ownProps);\n\n      if (typeof props === 'function') {\n        proxy.mapToProps = props;\n        proxy.dependsOnOwnProps = getDependsOnOwnProps(props);\n        props = proxy(stateOrDispatch, ownProps);\n      }\n\n      if (process.env.NODE_ENV !== 'production') verifyPlainObject(props, displayName, methodName);\n      return props;\n    };\n\n    return proxy;\n  };\n}","import { bindActionCreators } from 'redux';\nimport { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps';\nexport function whenMapDispatchToPropsIsFunction(mapDispatchToProps) {\n  return typeof mapDispatchToProps === 'function' ? wrapMapToPropsFunc(mapDispatchToProps, 'mapDispatchToProps') : undefined;\n}\nexport function whenMapDispatchToPropsIsMissing(mapDispatchToProps) {\n  return !mapDispatchToProps ? wrapMapToPropsConstant(function (dispatch) {\n    return {\n      dispatch: dispatch\n    };\n  }) : undefined;\n}\nexport function whenMapDispatchToPropsIsObject(mapDispatchToProps) {\n  return mapDispatchToProps && typeof mapDispatchToProps === 'object' ? wrapMapToPropsConstant(function (dispatch) {\n    return bindActionCreators(mapDispatchToProps, dispatch);\n  }) : undefined;\n}\nexport default [whenMapDispatchToPropsIsFunction, whenMapDispatchToPropsIsMissing, whenMapDispatchToPropsIsObject];","import { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps';\nexport function whenMapStateToPropsIsFunction(mapStateToProps) {\n  return typeof mapStateToProps === 'function' ? wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps') : undefined;\n}\nexport function whenMapStateToPropsIsMissing(mapStateToProps) {\n  return !mapStateToProps ? wrapMapToPropsConstant(function () {\n    return {};\n  }) : undefined;\n}\nexport default [whenMapStateToPropsIsFunction, whenMapStateToPropsIsMissing];","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport verifyPlainObject from '../utils/verifyPlainObject';\nexport function defaultMergeProps(stateProps, dispatchProps, ownProps) {\n  return _extends({}, ownProps, {}, stateProps, {}, dispatchProps);\n}\nexport function wrapMergePropsFunc(mergeProps) {\n  return function initMergePropsProxy(dispatch, _ref) {\n    var displayName = _ref.displayName,\n        pure = _ref.pure,\n        areMergedPropsEqual = _ref.areMergedPropsEqual;\n    var hasRunOnce = false;\n    var mergedProps;\n    return function mergePropsProxy(stateProps, dispatchProps, ownProps) {\n      var nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n\n      if (hasRunOnce) {\n        if (!pure || !areMergedPropsEqual(nextMergedProps, mergedProps)) mergedProps = nextMergedProps;\n      } else {\n        hasRunOnce = true;\n        mergedProps = nextMergedProps;\n        if (process.env.NODE_ENV !== 'production') verifyPlainObject(mergedProps, displayName, 'mergeProps');\n      }\n\n      return mergedProps;\n    };\n  };\n}\nexport function whenMergePropsIsFunction(mergeProps) {\n  return typeof mergeProps === 'function' ? wrapMergePropsFunc(mergeProps) : undefined;\n}\nexport function whenMergePropsIsOmitted(mergeProps) {\n  return !mergeProps ? function () {\n    return defaultMergeProps;\n  } : undefined;\n}\nexport default [whenMergePropsIsFunction, whenMergePropsIsOmitted];","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport verifySubselectors from './verifySubselectors';\nexport function impureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch) {\n  return function impureFinalPropsSelector(state, ownProps) {\n    return mergeProps(mapStateToProps(state, ownProps), mapDispatchToProps(dispatch, ownProps), ownProps);\n  };\n}\nexport function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, _ref) {\n  var areStatesEqual = _ref.areStatesEqual,\n      areOwnPropsEqual = _ref.areOwnPropsEqual,\n      areStatePropsEqual = _ref.areStatePropsEqual;\n  var hasRunAtLeastOnce = false;\n  var state;\n  var ownProps;\n  var stateProps;\n  var dispatchProps;\n  var mergedProps;\n\n  function handleFirstCall(firstState, firstOwnProps) {\n    state = firstState;\n    ownProps = firstOwnProps;\n    stateProps = mapStateToProps(state, ownProps);\n    dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    hasRunAtLeastOnce = true;\n    return mergedProps;\n  }\n\n  function handleNewPropsAndNewState() {\n    stateProps = mapStateToProps(state, ownProps);\n    if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n\n  function handleNewProps() {\n    if (mapStateToProps.dependsOnOwnProps) stateProps = mapStateToProps(state, ownProps);\n    if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n\n  function handleNewState() {\n    var nextStateProps = mapStateToProps(state, ownProps);\n    var statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);\n    stateProps = nextStateProps;\n    if (statePropsChanged) mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n\n  function handleSubsequentCalls(nextState, nextOwnProps) {\n    var propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);\n    var stateChanged = !areStatesEqual(nextState, state);\n    state = nextState;\n    ownProps = nextOwnProps;\n    if (propsChanged && stateChanged) return handleNewPropsAndNewState();\n    if (propsChanged) return handleNewProps();\n    if (stateChanged) return handleNewState();\n    return mergedProps;\n  }\n\n  return function pureFinalPropsSelector(nextState, nextOwnProps) {\n    return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) : handleFirstCall(nextState, nextOwnProps);\n  };\n} // TODO: Add more comments\n// If pure is true, the selector returned by selectorFactory will memoize its results,\n// allowing connectAdvanced's shouldComponentUpdate to return false if final\n// props have not changed. If false, the selector will always return a new\n// object and shouldComponentUpdate will always return true.\n\nexport default function finalPropsSelectorFactory(dispatch, _ref2) {\n  var initMapStateToProps = _ref2.initMapStateToProps,\n      initMapDispatchToProps = _ref2.initMapDispatchToProps,\n      initMergeProps = _ref2.initMergeProps,\n      options = _objectWithoutPropertiesLoose(_ref2, [\"initMapStateToProps\", \"initMapDispatchToProps\", \"initMergeProps\"]);\n\n  var mapStateToProps = initMapStateToProps(dispatch, options);\n  var mapDispatchToProps = initMapDispatchToProps(dispatch, options);\n  var mergeProps = initMergeProps(dispatch, options);\n\n  if (process.env.NODE_ENV !== 'production') {\n    verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, options.displayName);\n  }\n\n  var selectorFactory = options.pure ? pureFinalPropsSelectorFactory : impureFinalPropsSelectorFactory;\n  return selectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport connectAdvanced from '../components/connectAdvanced';\nimport shallowEqual from '../utils/shallowEqual';\nimport defaultMapDispatchToPropsFactories from './mapDispatchToProps';\nimport defaultMapStateToPropsFactories from './mapStateToProps';\nimport defaultMergePropsFactories from './mergeProps';\nimport defaultSelectorFactory from './selectorFactory';\n/*\r\n  connect is a facade over connectAdvanced. It turns its args into a compatible\r\n  selectorFactory, which has the signature:\r\n\r\n    (dispatch, options) => (nextState, nextOwnProps) => nextFinalProps\r\n  \r\n  connect passes its args to connectAdvanced as options, which will in turn pass them to\r\n  selectorFactory each time a Connect component instance is instantiated or hot reloaded.\r\n\r\n  selectorFactory returns a final props selector from its mapStateToProps,\r\n  mapStateToPropsFactories, mapDispatchToProps, mapDispatchToPropsFactories, mergeProps,\r\n  mergePropsFactories, and pure args.\r\n\r\n  The resulting final props selector is called by the Connect component instance whenever\r\n  it receives new props or store state.\r\n */\n\nfunction match(arg, factories, name) {\n  for (var i = factories.length - 1; i >= 0; i--) {\n    var result = factories[i](arg);\n    if (result) return result;\n  }\n\n  return function (dispatch, options) {\n    throw new Error(\"Invalid value of type \" + typeof arg + \" for \" + name + \" argument when connecting component \" + options.wrappedComponentName + \".\");\n  };\n}\n\nfunction strictEqual(a, b) {\n  return a === b;\n} // createConnect with default args builds the 'official' connect behavior. Calling it with\n// different options opens up some testing and extensibility scenarios\n\n\nexport function createConnect(_temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      _ref$connectHOC = _ref.connectHOC,\n      connectHOC = _ref$connectHOC === void 0 ? connectAdvanced : _ref$connectHOC,\n      _ref$mapStateToPropsF = _ref.mapStateToPropsFactories,\n      mapStateToPropsFactories = _ref$mapStateToPropsF === void 0 ? defaultMapStateToPropsFactories : _ref$mapStateToPropsF,\n      _ref$mapDispatchToPro = _ref.mapDispatchToPropsFactories,\n      mapDispatchToPropsFactories = _ref$mapDispatchToPro === void 0 ? defaultMapDispatchToPropsFactories : _ref$mapDispatchToPro,\n      _ref$mergePropsFactor = _ref.mergePropsFactories,\n      mergePropsFactories = _ref$mergePropsFactor === void 0 ? defaultMergePropsFactories : _ref$mergePropsFactor,\n      _ref$selectorFactory = _ref.selectorFactory,\n      selectorFactory = _ref$selectorFactory === void 0 ? defaultSelectorFactory : _ref$selectorFactory;\n\n  return function connect(mapStateToProps, mapDispatchToProps, mergeProps, _ref2) {\n    if (_ref2 === void 0) {\n      _ref2 = {};\n    }\n\n    var _ref3 = _ref2,\n        _ref3$pure = _ref3.pure,\n        pure = _ref3$pure === void 0 ? true : _ref3$pure,\n        _ref3$areStatesEqual = _ref3.areStatesEqual,\n        areStatesEqual = _ref3$areStatesEqual === void 0 ? strictEqual : _ref3$areStatesEqual,\n        _ref3$areOwnPropsEqua = _ref3.areOwnPropsEqual,\n        areOwnPropsEqual = _ref3$areOwnPropsEqua === void 0 ? shallowEqual : _ref3$areOwnPropsEqua,\n        _ref3$areStatePropsEq = _ref3.areStatePropsEqual,\n        areStatePropsEqual = _ref3$areStatePropsEq === void 0 ? shallowEqual : _ref3$areStatePropsEq,\n        _ref3$areMergedPropsE = _ref3.areMergedPropsEqual,\n        areMergedPropsEqual = _ref3$areMergedPropsE === void 0 ? shallowEqual : _ref3$areMergedPropsE,\n        extraOptions = _objectWithoutPropertiesLoose(_ref3, [\"pure\", \"areStatesEqual\", \"areOwnPropsEqual\", \"areStatePropsEqual\", \"areMergedPropsEqual\"]);\n\n    var initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories, 'mapStateToProps');\n    var initMapDispatchToProps = match(mapDispatchToProps, mapDispatchToPropsFactories, 'mapDispatchToProps');\n    var initMergeProps = match(mergeProps, mergePropsFactories, 'mergeProps');\n    return connectHOC(selectorFactory, _extends({\n      // used in error messages\n      methodName: 'connect',\n      // used to compute Connect's displayName from the wrapped component's displayName.\n      getDisplayName: function getDisplayName(name) {\n        return \"Connect(\" + name + \")\";\n      },\n      // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes\n      shouldHandleStateChanges: Boolean(mapStateToProps),\n      // passed through to selectorFactory\n      initMapStateToProps: initMapStateToProps,\n      initMapDispatchToProps: initMapDispatchToProps,\n      initMergeProps: initMergeProps,\n      pure: pure,\n      areStatesEqual: areStatesEqual,\n      areOwnPropsEqual: areOwnPropsEqual,\n      areStatePropsEqual: areStatePropsEqual,\n      areMergedPropsEqual: areMergedPropsEqual\n    }, extraOptions));\n  };\n}\nexport default\n/*#__PURE__*/\ncreateConnect();","import { useReducer, useRef, useMemo, useContext, useDebugValue } from 'react';\nimport { useReduxContext as useDefaultReduxContext } from './useReduxContext';\nimport Subscription from '../utils/Subscription';\nimport { useIsomorphicLayoutEffect } from '../utils/useIsomorphicLayoutEffect';\nimport { ReactReduxContext } from '../components/Context';\n\nvar refEquality = function refEquality(a, b) {\n  return a === b;\n};\n\nfunction useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub) {\n  var _useReducer = useReducer(function (s) {\n    return s + 1;\n  }, 0),\n      forceRender = _useReducer[1];\n\n  var subscription = useMemo(function () {\n    return new Subscription(store, contextSub);\n  }, [store, contextSub]);\n  var latestSubscriptionCallbackError = useRef();\n  var latestSelector = useRef();\n  var latestStoreState = useRef();\n  var latestSelectedState = useRef();\n  var storeState = store.getState();\n  var selectedState;\n\n  try {\n    if (selector !== latestSelector.current || storeState !== latestStoreState.current || latestSubscriptionCallbackError.current) {\n      selectedState = selector(storeState);\n    } else {\n      selectedState = latestSelectedState.current;\n    }\n  } catch (err) {\n    if (latestSubscriptionCallbackError.current) {\n      err.message += \"\\nThe error may be correlated with this previous error:\\n\" + latestSubscriptionCallbackError.current.stack + \"\\n\\n\";\n    }\n\n    throw err;\n  }\n\n  useIsomorphicLayoutEffect(function () {\n    latestSelector.current = selector;\n    latestStoreState.current = storeState;\n    latestSelectedState.current = selectedState;\n    latestSubscriptionCallbackError.current = undefined;\n  });\n  useIsomorphicLayoutEffect(function () {\n    function checkForUpdates() {\n      try {\n        var newSelectedState = latestSelector.current(store.getState());\n\n        if (equalityFn(newSelectedState, latestSelectedState.current)) {\n          return;\n        }\n\n        latestSelectedState.current = newSelectedState;\n      } catch (err) {\n        // we ignore all errors here, since when the component\n        // is re-rendered, the selectors are called again, and\n        // will throw again, if neither props nor store state\n        // changed\n        latestSubscriptionCallbackError.current = err;\n      }\n\n      forceRender();\n    }\n\n    subscription.onStateChange = checkForUpdates;\n    subscription.trySubscribe();\n    checkForUpdates();\n    return function () {\n      return subscription.tryUnsubscribe();\n    };\n  }, [store, subscription]);\n  return selectedState;\n}\n/**\r\n * Hook factory, which creates a `useSelector` hook bound to a given context.\r\n *\r\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\r\n * @returns {Function} A `useSelector` hook bound to the specified context.\r\n */\n\n\nexport function createSelectorHook(context) {\n  if (context === void 0) {\n    context = ReactReduxContext;\n  }\n\n  var useReduxContext = context === ReactReduxContext ? useDefaultReduxContext : function () {\n    return useContext(context);\n  };\n  return function useSelector(selector, equalityFn) {\n    if (equalityFn === void 0) {\n      equalityFn = refEquality;\n    }\n\n    if (process.env.NODE_ENV !== 'production' && !selector) {\n      throw new Error(\"You must pass a selector to useSelector\");\n    }\n\n    var _useReduxContext = useReduxContext(),\n        store = _useReduxContext.store,\n        contextSub = _useReduxContext.subscription;\n\n    var selectedState = useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub);\n    useDebugValue(selectedState);\n    return selectedState;\n  };\n}\n/**\r\n * A hook to access the redux store's state. This hook takes a selector function\r\n * as an argument. The selector is called with the store state.\r\n *\r\n * This hook takes an optional equality comparison function as the second parameter\r\n * that allows you to customize the way the selected state is compared to determine\r\n * whether the component needs to be re-rendered.\r\n *\r\n * @param {Function} selector the selector function\r\n * @param {Function=} equalityFn the function that will be used to determine equality\r\n *\r\n * @returns {any} the selected state\r\n *\r\n * @example\r\n *\r\n * import React from 'react'\r\n * import { useSelector } from 'react-redux'\r\n *\r\n * export const CounterComponent = () => {\r\n *   const counter = useSelector(state => state.counter)\r\n *   return <div>{counter}</div>\r\n * }\r\n */\n\nexport var useSelector =\n/*#__PURE__*/\ncreateSelectorHook();","import Provider from './components/Provider';\nimport connectAdvanced from './components/connectAdvanced';\nimport { ReactReduxContext } from './components/Context';\nimport connect from './connect/connect';\nimport { useDispatch, createDispatchHook } from './hooks/useDispatch';\nimport { useSelector, createSelectorHook } from './hooks/useSelector';\nimport { useStore, createStoreHook } from './hooks/useStore';\nimport { setBatch } from './utils/batch';\nimport { unstable_batchedUpdates as batch } from './utils/reactBatchedUpdates';\nimport shallowEqual from './utils/shallowEqual';\nsetBatch(batch);\nexport { Provider, connectAdvanced, ReactReduxContext, connect, batch, useDispatch, createDispatchHook, useSelector, createSelectorHook, useStore, createStoreHook, shallowEqual };","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport PropTypes from 'prop-types';\nimport addOneClass from 'dom-helpers/addClass';\nimport removeOneClass from 'dom-helpers/removeClass';\nimport React from 'react';\nimport Transition from './Transition';\nimport { classNamesShape } from './utils/PropTypes';\n\nvar _addClass = function addClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return addOneClass(node, c);\n  });\n};\n\nvar removeClass = function removeClass(node, classes) {\n  return node && classes && classes.split(' ').forEach(function (c) {\n    return removeOneClass(node, c);\n  });\n};\n/**\n * A transition component inspired by the excellent\n * [ng-animate](https://docs.angularjs.org/api/ngAnimate) library, you should\n * use it if you're using CSS transitions or animations. It's built upon the\n * [`Transition`](https://reactcommunity.org/react-transition-group/transition)\n * component, so it inherits all of its props.\n *\n * `CSSTransition` applies a pair of class names during the `appear`, `enter`,\n * and `exit` states of the transition. The first class is applied and then a\n * second `*-active` class in order to activate the CSS transition. After the\n * transition, matching `*-done` class names are applied to persist the\n * transition state.\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <CSSTransition in={inProp} timeout={200} classNames=\"my-node\">\n *         <div>\n *           {\"I'll receive my-node-* classes\"}\n *         </div>\n *       </CSSTransition>\n *       <button type=\"button\" onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the `in` prop is set to `true`, the child component will first receive\n * the class `example-enter`, then the `example-enter-active` will be added in\n * the next tick. `CSSTransition` [forces a\n * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)\n * between before adding the `example-enter-active`. This is an important trick\n * because it allows us to transition between `example-enter` and\n * `example-enter-active` even though they were added immediately one after\n * another. Most notably, this is what makes it possible for us to animate\n * _appearance_.\n *\n * ```css\n * .my-node-enter {\n *   opacity: 0;\n * }\n * .my-node-enter-active {\n *   opacity: 1;\n *   transition: opacity 200ms;\n * }\n * .my-node-exit {\n *   opacity: 1;\n * }\n * .my-node-exit-active {\n *   opacity: 0;\n *   transition: opacity 200ms;\n * }\n * ```\n *\n * `*-active` classes represent which styles you want to animate **to**, so it's\n * important to add `transition` declaration only to them, otherwise transitions\n * might not behave as intended! This might not be obvious when the transitions\n * are symmetrical, i.e. when `*-enter-active` is the same as `*-exit`, like in\n * the example above (minus `transition`), but it becomes apparent in more\n * complex transitions.\n *\n * **Note**: If you're using the\n * [`appear`](http://reactcommunity.org/react-transition-group/transition#Transition-prop-appear)\n * prop, make sure to define styles for `.appear-*` classes as well.\n */\n\n\nvar CSSTransition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(CSSTransition, _React$Component);\n\n  function CSSTransition() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.appliedClasses = {\n      appear: {},\n      enter: {},\n      exit: {}\n    };\n\n    _this.onEnter = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument[0],\n          appearing = _this$resolveArgument[1];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, appearing ? 'appear' : 'enter', 'base');\n\n      if (_this.props.onEnter) {\n        _this.props.onEnter(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntering = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument2 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument2[0],\n          appearing = _this$resolveArgument2[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.addClass(node, type, 'active');\n\n      if (_this.props.onEntering) {\n        _this.props.onEntering(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onEntered = function (maybeNode, maybeAppearing) {\n      var _this$resolveArgument3 = _this.resolveArguments(maybeNode, maybeAppearing),\n          node = _this$resolveArgument3[0],\n          appearing = _this$resolveArgument3[1];\n\n      var type = appearing ? 'appear' : 'enter';\n\n      _this.removeClasses(node, type);\n\n      _this.addClass(node, type, 'done');\n\n      if (_this.props.onEntered) {\n        _this.props.onEntered(maybeNode, maybeAppearing);\n      }\n    };\n\n    _this.onExit = function (maybeNode) {\n      var _this$resolveArgument4 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument4[0];\n\n      _this.removeClasses(node, 'appear');\n\n      _this.removeClasses(node, 'enter');\n\n      _this.addClass(node, 'exit', 'base');\n\n      if (_this.props.onExit) {\n        _this.props.onExit(maybeNode);\n      }\n    };\n\n    _this.onExiting = function (maybeNode) {\n      var _this$resolveArgument5 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument5[0];\n\n      _this.addClass(node, 'exit', 'active');\n\n      if (_this.props.onExiting) {\n        _this.props.onExiting(maybeNode);\n      }\n    };\n\n    _this.onExited = function (maybeNode) {\n      var _this$resolveArgument6 = _this.resolveArguments(maybeNode),\n          node = _this$resolveArgument6[0];\n\n      _this.removeClasses(node, 'exit');\n\n      _this.addClass(node, 'exit', 'done');\n\n      if (_this.props.onExited) {\n        _this.props.onExited(maybeNode);\n      }\n    };\n\n    _this.resolveArguments = function (maybeNode, maybeAppearing) {\n      return _this.props.nodeRef ? [_this.props.nodeRef.current, maybeNode] // here `maybeNode` is actually `appearing`\n      : [maybeNode, maybeAppearing];\n    };\n\n    _this.getClassNames = function (type) {\n      var classNames = _this.props.classNames;\n      var isStringClassNames = typeof classNames === 'string';\n      var prefix = isStringClassNames && classNames ? classNames + \"-\" : '';\n      var baseClassName = isStringClassNames ? \"\" + prefix + type : classNames[type];\n      var activeClassName = isStringClassNames ? baseClassName + \"-active\" : classNames[type + \"Active\"];\n      var doneClassName = isStringClassNames ? baseClassName + \"-done\" : classNames[type + \"Done\"];\n      return {\n        baseClassName: baseClassName,\n        activeClassName: activeClassName,\n        doneClassName: doneClassName\n      };\n    };\n\n    return _this;\n  }\n\n  var _proto = CSSTransition.prototype;\n\n  _proto.addClass = function addClass(node, type, phase) {\n    var className = this.getClassNames(type)[phase + \"ClassName\"];\n\n    var _this$getClassNames = this.getClassNames('enter'),\n        doneClassName = _this$getClassNames.doneClassName;\n\n    if (type === 'appear' && phase === 'done' && doneClassName) {\n      className += \" \" + doneClassName;\n    } // This is for to force a repaint,\n    // which is necessary in order to transition styles when adding a class name.\n\n\n    if (phase === 'active') {\n      /* eslint-disable no-unused-expressions */\n      node && node.scrollTop;\n    }\n\n    if (className) {\n      this.appliedClasses[type][phase] = className;\n\n      _addClass(node, className);\n    }\n  };\n\n  _proto.removeClasses = function removeClasses(node, type) {\n    var _this$appliedClasses$ = this.appliedClasses[type],\n        baseClassName = _this$appliedClasses$.base,\n        activeClassName = _this$appliedClasses$.active,\n        doneClassName = _this$appliedClasses$.done;\n    this.appliedClasses[type] = {};\n\n    if (baseClassName) {\n      removeClass(node, baseClassName);\n    }\n\n    if (activeClassName) {\n      removeClass(node, activeClassName);\n    }\n\n    if (doneClassName) {\n      removeClass(node, doneClassName);\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        _ = _this$props.classNames,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"classNames\"]);\n\n    return /*#__PURE__*/React.createElement(Transition, _extends({}, props, {\n      onEnter: this.onEnter,\n      onEntered: this.onEntered,\n      onEntering: this.onEntering,\n      onExit: this.onExit,\n      onExiting: this.onExiting,\n      onExited: this.onExited\n    }));\n  };\n\n  return CSSTransition;\n}(React.Component);\n\nCSSTransition.defaultProps = {\n  classNames: ''\n};\nCSSTransition.propTypes = process.env.NODE_ENV !== \"production\" ? _extends({}, Transition.propTypes, {\n  /**\n   * The animation classNames applied to the component as it appears, enters,\n   * exits or has finished the transition. A single name can be provided, which\n   * will be suffixed for each stage, e.g. `classNames=\"fade\"` applies:\n   *\n   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`\n   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`\n   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`\n   *\n   * A few details to note about how these classes are applied:\n   *\n   * 1. They are _joined_ with the ones that are already defined on the child\n   *    component, so if you want to add some base styles, you can use\n   *    `className` without worrying that it will be overridden.\n   *\n   * 2. If the transition component mounts with `in={false}`, no classes are\n   *    applied yet. You might be expecting `*-exit-done`, but if you think\n   *    about it, a component cannot finish exiting if it hasn't entered yet.\n   *\n   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This\n   *    allows you to define different behavior for when appearing is done and\n   *    when regular entering is done, using selectors like\n   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply\n   *    an epic entrance animation when element first appears in the DOM using\n   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can\n   *    simply use `fade-enter-done` for defining both cases.\n   *\n   * Each individual classNames can also be specified independently like:\n   *\n   * ```js\n   * classNames={{\n   *  appear: 'my-appear',\n   *  appearActive: 'my-active-appear',\n   *  appearDone: 'my-done-appear',\n   *  enter: 'my-enter',\n   *  enterActive: 'my-active-enter',\n   *  enterDone: 'my-done-enter',\n   *  exit: 'my-exit',\n   *  exitActive: 'my-active-exit',\n   *  exitDone: 'my-done-exit',\n   * }}\n   * ```\n   *\n   * If you want to set these classes using CSS Modules:\n   *\n   * ```js\n   * import styles from './styles.css';\n   * ```\n   *\n   * you might want to use camelCase in your CSS file, that way could simply\n   * spread them instead of listing them one by one:\n   *\n   * ```js\n   * classNames={{ ...styles }}\n   * ```\n   *\n   * @type {string | {\n   *  appear?: string,\n   *  appearActive?: string,\n   *  appearDone?: string,\n   *  enter?: string,\n   *  enterActive?: string,\n   *  enterDone?: string,\n   *  exit?: string,\n   *  exitActive?: string,\n   *  exitDone?: string,\n   * }}\n   */\n  classNames: classNamesShape,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter-active' or\n   * 'appear-active' class is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'enter' or\n   * 'appear' classes are **removed** and the `done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed.\n   *\n   * @type Function(node: HtmlElement, isAppearing: bool)\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' class is\n   * applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * A `<Transition>` callback fired immediately after the 'exit' classes\n   * are **removed** and the `exit-done` class is added to the DOM node.\n   *\n   * **Note**: when `nodeRef` prop is passed, `node` is not passed\n   *\n   * @type Function(node: HtmlElement)\n   */\n  onExited: PropTypes.func\n}) : {};\nexport default CSSTransition;","var isarray = require('isarray')\n\n/**\n * Expose `pathToRegexp`.\n */\nmodule.exports = pathToRegexp\nmodule.exports.parse = parse\nmodule.exports.compile = compile\nmodule.exports.tokensToFunction = tokensToFunction\nmodule.exports.tokensToRegExp = tokensToRegExp\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g')\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = []\n  var key = 0\n  var index = 0\n  var path = ''\n  var defaultDelimiter = options && options.delimiter || '/'\n  var res\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0]\n    var escaped = res[1]\n    var offset = res.index\n    path += str.slice(index, offset)\n    index = offset + m.length\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1]\n      continue\n    }\n\n    var next = str[index]\n    var prefix = res[2]\n    var name = res[3]\n    var capture = res[4]\n    var group = res[5]\n    var modifier = res[6]\n    var asterisk = res[7]\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path)\n      path = ''\n    }\n\n    var partial = prefix != null && next != null && next !== prefix\n    var repeat = modifier === '+' || modifier === '*'\n    var optional = modifier === '?' || modifier === '*'\n    var delimiter = res[2] || defaultDelimiter\n    var pattern = capture || group\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    })\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index)\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path)\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options), options)\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens, options) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length)\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options))\n    }\n  }\n\n  return function (obj, opts) {\n    var path = ''\n    var data = obj || {}\n    var options = opts || {}\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i]\n\n      if (typeof token === 'string') {\n        path += token\n\n        continue\n      }\n\n      var value = data[token.name]\n      var segment\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j])\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value)\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options && options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g)\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      })\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = []\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source)\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options))\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  var strict = options.strict\n  var end = options.end !== false\n  var route = ''\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i]\n\n    if (typeof token === 'string') {\n      route += escapeString(token)\n    } else {\n      var prefix = escapeString(token.prefix)\n      var capture = '(?:' + token.pattern + ')'\n\n      keys.push(token)\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*'\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?'\n        } else {\n          capture = prefix + '(' + capture + ')?'\n        }\n      } else {\n        capture = prefix + '(' + capture + ')'\n      }\n\n      route += capture\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/')\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?'\n  }\n\n  if (end) {\n    route += '$'\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)'\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n","import { PureComponent } from 'react';\n\nfunction isInteger(value) {\n  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;\n}\n\nfunction isRangeVisible(_ref) {\n  var lastRenderedStartIndex = _ref.lastRenderedStartIndex,\n      lastRenderedStopIndex = _ref.lastRenderedStopIndex,\n      startIndex = _ref.startIndex,\n      stopIndex = _ref.stopIndex;\n\n  return !(startIndex > lastRenderedStopIndex || stopIndex < lastRenderedStartIndex);\n}\n\nfunction scanForUnloadedRanges(_ref) {\n  var isItemLoaded = _ref.isItemLoaded,\n      itemCount = _ref.itemCount,\n      minimumBatchSize = _ref.minimumBatchSize,\n      startIndex = _ref.startIndex,\n      stopIndex = _ref.stopIndex;\n\n  var unloadedRanges = [];\n\n  var rangeStartIndex = null;\n  var rangeStopIndex = null;\n\n  for (var _index = startIndex; _index <= stopIndex; _index++) {\n    var loaded = isItemLoaded(_index);\n\n    if (!loaded) {\n      rangeStopIndex = _index;\n      if (rangeStartIndex === null) {\n        rangeStartIndex = _index;\n      }\n    } else if (rangeStopIndex !== null) {\n      unloadedRanges.push([rangeStartIndex, rangeStopIndex]);\n\n      rangeStartIndex = rangeStopIndex = null;\n    }\n  }\n\n  // If :rangeStopIndex is not null it means we haven't ran out of unloaded rows.\n  // Scan forward to try filling our :minimumBatchSize.\n  if (rangeStopIndex !== null) {\n    var potentialStopIndex = Math.min(Math.max(rangeStopIndex, rangeStartIndex + minimumBatchSize - 1), itemCount - 1);\n\n    for (var _index2 = rangeStopIndex + 1; _index2 <= potentialStopIndex; _index2++) {\n      if (!isItemLoaded(_index2)) {\n        rangeStopIndex = _index2;\n      } else {\n        break;\n      }\n    }\n\n    unloadedRanges.push([rangeStartIndex, rangeStopIndex]);\n  }\n\n  // Check to see if our first range ended prematurely.\n  // In this case we should scan backwards to try filling our :minimumBatchSize.\n  if (unloadedRanges.length) {\n    var firstRange = unloadedRanges[0];\n\n    while (firstRange[1] - firstRange[0] + 1 < minimumBatchSize && firstRange[0] > 0) {\n      var _index3 = firstRange[0] - 1;\n\n      if (!isItemLoaded(_index3)) {\n        firstRange[0] = _index3;\n      } else {\n        break;\n      }\n    }\n  }\n\n  return unloadedRanges;\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar inherits = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar possibleConstructorReturn = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\nvar slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\n\nvar InfiniteLoader = function (_PureComponent) {\n  inherits(InfiniteLoader, _PureComponent);\n\n  function InfiniteLoader() {\n    var _ref;\n\n    var _temp, _this, _ret;\n\n    classCallCheck(this, InfiniteLoader);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = possibleConstructorReturn(this, (_ref = InfiniteLoader.__proto__ || Object.getPrototypeOf(InfiniteLoader)).call.apply(_ref, [this].concat(args))), _this), _this._lastRenderedStartIndex = -1, _this._lastRenderedStopIndex = -1, _this._memoizedUnloadedRanges = [], _this._onItemsRendered = function (_ref2) {\n      var visibleStartIndex = _ref2.visibleStartIndex,\n          visibleStopIndex = _ref2.visibleStopIndex;\n\n      if (process.env.NODE_ENV !== 'production') {\n        if (!isInteger(visibleStartIndex) || !isInteger(visibleStopIndex)) {\n          console.warn('Invalid onItemsRendered signature; please refer to InfiniteLoader documentation.');\n        }\n\n        if (typeof _this.props.loadMoreRows === 'function') {\n          console.warn('InfiniteLoader \"loadMoreRows\" prop has been renamed to \"loadMoreItems\".');\n        }\n      }\n\n      _this._lastRenderedStartIndex = visibleStartIndex;\n      _this._lastRenderedStopIndex = visibleStopIndex;\n\n      _this._ensureRowsLoaded(visibleStartIndex, visibleStopIndex);\n    }, _this._setRef = function (listRef) {\n      _this._listRef = listRef;\n    }, _temp), possibleConstructorReturn(_this, _ret);\n  }\n\n  createClass(InfiniteLoader, [{\n    key: 'resetloadMoreItemsCache',\n    value: function resetloadMoreItemsCache() {\n      var autoReload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n      this._memoizedUnloadedRanges = [];\n\n      if (autoReload) {\n        this._ensureRowsLoaded(this._lastRenderedStartIndex, this._lastRenderedStopIndex);\n      }\n    }\n  }, {\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      if (process.env.NODE_ENV !== 'production') {\n        if (this._listRef == null) {\n          console.warn('Invalid list ref; please refer to InfiniteLoader documentation.');\n        }\n      }\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var children = this.props.children;\n\n\n      return children({\n        onItemsRendered: this._onItemsRendered,\n        ref: this._setRef\n      });\n    }\n  }, {\n    key: '_ensureRowsLoaded',\n    value: function _ensureRowsLoaded(startIndex, stopIndex) {\n      var _props = this.props,\n          isItemLoaded = _props.isItemLoaded,\n          itemCount = _props.itemCount,\n          _props$minimumBatchSi = _props.minimumBatchSize,\n          minimumBatchSize = _props$minimumBatchSi === undefined ? 10 : _props$minimumBatchSi,\n          _props$threshold = _props.threshold,\n          threshold = _props$threshold === undefined ? 15 : _props$threshold;\n\n\n      var unloadedRanges = scanForUnloadedRanges({\n        isItemLoaded: isItemLoaded,\n        itemCount: itemCount,\n        minimumBatchSize: minimumBatchSize,\n        startIndex: Math.max(0, startIndex - threshold),\n        stopIndex: Math.min(itemCount - 1, stopIndex + threshold)\n      });\n\n      // Avoid calling load-rows unless range has changed.\n      // This shouldn't be strictly necsesary, but is maybe nice to do.\n      if (this._memoizedUnloadedRanges.length !== unloadedRanges.length || this._memoizedUnloadedRanges.some(function (_ref3, index) {\n        var _ref4 = slicedToArray(_ref3, 2),\n            startIndex = _ref4[0],\n            stopIndex = _ref4[1];\n\n        return unloadedRanges[index][0] !== startIndex || unloadedRanges[index][1] !== stopIndex;\n      })) {\n        this._memoizedUnloadedRanges = unloadedRanges;\n        this._loadUnloadedRanges(unloadedRanges);\n      }\n    }\n  }, {\n    key: '_loadUnloadedRanges',\n    value: function _loadUnloadedRanges(unloadedRanges) {\n      var _this2 = this;\n\n      // loadMoreRows was renamed to loadMoreItems in v1.0.3; will be removed in v2.0\n      var loadMoreItems = this.props.loadMoreItems || this.props.loadMoreRows;\n\n      unloadedRanges.forEach(function (_ref5) {\n        var _ref6 = slicedToArray(_ref5, 2),\n            startIndex = _ref6[0],\n            stopIndex = _ref6[1];\n\n        var promise = loadMoreItems(startIndex, stopIndex);\n        if (promise != null) {\n          promise.then(function () {\n            // Refresh the visible rows if any of them have just been loaded.\n            // Otherwise they will remain in their unloaded visual state.\n            if (isRangeVisible({\n              lastRenderedStartIndex: _this2._lastRenderedStartIndex,\n              lastRenderedStopIndex: _this2._lastRenderedStopIndex,\n              startIndex: startIndex,\n              stopIndex: stopIndex\n            })) {\n              // Handle an unmount while promises are still in flight.\n              if (_this2._listRef == null) {\n                return;\n              }\n\n              // Resize cached row sizes for VariableSizeList,\n              // otherwise just re-render the list.\n              if (typeof _this2._listRef.resetAfterIndex === 'function') {\n                _this2._listRef.resetAfterIndex(startIndex, true);\n              } else {\n                // HACK reset temporarily cached item styles to force PureComponent to re-render.\n                // This is pretty gross, but I'm okay with it for now.\n                // Don't judge me.\n                if (typeof _this2._listRef._getItemStyleCache === 'function') {\n                  _this2._listRef._getItemStyleCache(-1);\n                }\n                _this2._listRef.forceUpdate();\n              }\n            }\n          });\n        }\n      });\n    }\n  }]);\n  return InfiniteLoader;\n}(PureComponent);\n\nexport default InfiniteLoader;\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';\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 =\n    /*#__PURE__*/\n    new WeakSet();\n    devWarningsOverscanRowsColumnsCount =\n    /*#__PURE__*/\n    new WeakSet();\n    devWarningsTagName =\n    /*#__PURE__*/\n    new WeakSet();\n  }\n}\n\nfunction createGridComponent(_ref2) {\n  var _class, _temp;\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 _temp = _class =\n  /*#__PURE__*/\n  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(_assertThisInitialized(_this)));\n      _this._resetIsScrollingTimeoutId = null;\n      _this._outerRef = void 0;\n      _this.state = {\n        instance: _assertThisInitialized(_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 _style;\n\n          itemStyleCache[key] = style = (_style = {\n            position: 'absolute'\n          }, _style[direction === 'rtl' ? 'right' : 'left'] = getColumnOffset(_this.props, columnIndex, _this._instanceProps), _style.top = getRowOffset(_this.props, rowIndex, _this._instanceProps), _style.height = getRowHeight(_this.props, rowIndex, _this._instanceProps), _style.width = getColumnWidth(_this.props, columnIndex, _this._instanceProps), _style);\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  }, _temp;\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 =\n/*#__PURE__*/\ncreateGridComponent({\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 =\n    /*#__PURE__*/\n    new WeakSet();\n    devWarningsTagName$1 =\n    /*#__PURE__*/\n    new WeakSet();\n  }\n}\n\nfunction createListComponent(_ref) {\n  var _class, _temp;\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 _temp = _class =\n  /*#__PURE__*/\n  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(_assertThisInitialized(_this)));\n      _this._outerRef = void 0;\n      _this._resetIsScrollingTimeoutId = null;\n      _this.state = {\n        instance: _assertThisInitialized(_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 _style;\n\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          itemStyleCache[index] = style = (_style = {\n            position: 'absolute'\n          }, _style[direction === 'rtl' ? 'right' : 'left'] = isHorizontal ? _offset : 0, _style.top = !isHorizontal ? _offset : 0, _style.height = !isHorizontal ? size : '100%', _style.width = isHorizontal ? size : '100%', _style);\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  }, _temp;\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 =\n/*#__PURE__*/\ncreateListComponent({\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 =\n/*#__PURE__*/\ncreateGridComponent({\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 =\n/*#__PURE__*/\ncreateListComponent({\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\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, [\"style\"]);\n\n  var nextStyle = nextProps.style,\n      nextRest = _objectWithoutPropertiesLoose(nextProps, [\"style\"]);\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 { VariableSizeGrid, VariableSizeList, FixedSizeGrid, FixedSizeList, areEqual, shouldComponentUpdate };\n//# sourceMappingURL=index.esm.js.map\n","/** @license React v17.0.0\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var l=require(\"object-assign\"),n=60103,p=60106;exports.Fragment=60107;exports.StrictMode=60108;exports.Profiler=60114;var q=60109,r=60110,t=60112;exports.Suspense=60113;var u=60115,v=60116;\nif(\"function\"===typeof Symbol&&Symbol.for){var w=Symbol.for;n=w(\"react.element\");p=w(\"react.portal\");exports.Fragment=w(\"react.fragment\");exports.StrictMode=w(\"react.strict_mode\");exports.Profiler=w(\"react.profiler\");q=w(\"react.provider\");r=w(\"react.context\");t=w(\"react.forward_ref\");exports.Suspense=w(\"react.suspense\");u=w(\"react.memo\");v=w(\"react.lazy\")}var x=\"function\"===typeof Symbol&&Symbol.iterator;\nfunction y(a){if(null===a||\"object\"!==typeof a)return null;a=x&&a[x]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}function z(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}\nvar A={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},B={};function C(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A}C.prototype.isReactComponent={};C.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(z(85));this.updater.enqueueSetState(this,a,b,\"setState\")};C.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};\nfunction D(){}D.prototype=C.prototype;function E(a,b,c){this.props=a;this.context=b;this.refs=B;this.updater=c||A}var F=E.prototype=new D;F.constructor=E;l(F,C.prototype);F.isPureReactComponent=!0;var G={current:null},H=Object.prototype.hasOwnProperty,I={key:!0,ref:!0,__self:!0,__source:!0};\nfunction J(a,b,c){var e,d={},k=null,h=null;if(null!=b)for(e in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=\"\"+b.key),b)H.call(b,e)&&!I.hasOwnProperty(e)&&(d[e]=b[e]);var g=arguments.length-2;if(1===g)d.children=c;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];d.children=f}if(a&&a.defaultProps)for(e in g=a.defaultProps,g)void 0===d[e]&&(d[e]=g[e]);return{$$typeof:n,type:a,key:k,ref:h,props:d,_owner:G.current}}\nfunction K(a,b){return{$$typeof:n,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function L(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===n}function escape(a){var b={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+a.replace(/[=:]/g,function(a){return b[a]})}var M=/\\/+/g;function N(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(\"\"+a.key):b.toString(36)}\nfunction O(a,b,c,e,d){var k=typeof a;if(\"undefined\"===k||\"boolean\"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case \"string\":case \"number\":h=!0;break;case \"object\":switch(a.$$typeof){case n:case p:h=!0}}if(h)return h=a,d=d(h),a=\"\"===e?\".\"+N(h,0):e,Array.isArray(d)?(c=\"\",null!=a&&(c=a.replace(M,\"$&/\")+\"/\"),O(d,b,c,\"\",function(a){return a})):null!=d&&(L(d)&&(d=K(d,c+(!d.key||h&&h.key===d.key?\"\":(\"\"+d.key).replace(M,\"$&/\")+\"/\")+a)),b.push(d)),1;h=0;e=\"\"===e?\".\":e+\":\";if(Array.isArray(a))for(var g=\n0;g<a.length;g++){k=a[g];var f=e+N(k,g);h+=O(k,b,c,f,d)}else if(f=y(a),\"function\"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=e+N(k,g++),h+=O(k,b,c,f,d);else if(\"object\"===k)throw b=\"\"+a,Error(z(31,\"[object Object]\"===b?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":b));return h}function P(a,b,c){if(null==a)return a;var e=[],d=0;O(a,e,\"\",\"\",function(a){return b.call(c,a,d++)});return e}\nfunction Q(a){if(-1===a._status){var b=a._result;b=b();a._status=0;a._result=b;b.then(function(b){0===a._status&&(b=b.default,a._status=1,a._result=b)},function(b){0===a._status&&(a._status=2,a._result=b)})}if(1===a._status)return a._result;throw a._result;}var R={current:null};function S(){var a=R.current;if(null===a)throw Error(z(321));return a}var T={ReactCurrentDispatcher:R,ReactCurrentBatchConfig:{transition:0},ReactCurrentOwner:G,IsSomeRendererActing:{current:!1},assign:l};\nexports.Children={map:P,forEach:function(a,b,c){P(a,function(){b.apply(this,arguments)},c)},count:function(a){var b=0;P(a,function(){b++});return b},toArray:function(a){return P(a,function(a){return a})||[]},only:function(a){if(!L(a))throw Error(z(143));return a}};exports.Component=C;exports.PureComponent=E;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=T;\nexports.cloneElement=function(a,b,c){if(null===a||void 0===a)throw Error(z(267,a));var e=l({},a.props),d=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=G.current);void 0!==b.key&&(d=\"\"+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)H.call(b,f)&&!I.hasOwnProperty(f)&&(e[f]=void 0===b[f]&&void 0!==g?g[f]:b[f])}var f=arguments.length-2;if(1===f)e.children=c;else if(1<f){g=Array(f);for(var m=0;m<f;m++)g[m]=arguments[m+2];e.children=g}return{$$typeof:n,type:a.type,\nkey:d,ref:k,props:e,_owner:h}};exports.createContext=function(a,b){void 0===b&&(b=null);a={$$typeof:r,_calculateChangedBits:b,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null};a.Provider={$$typeof:q,_context:a};return a.Consumer=a};exports.createElement=J;exports.createFactory=function(a){var b=J.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};exports.forwardRef=function(a){return{$$typeof:t,render:a}};exports.isValidElement=L;\nexports.lazy=function(a){return{$$typeof:v,_payload:{_status:-1,_result:a},_init:Q}};exports.memo=function(a,b){return{$$typeof:u,type:a,compare:void 0===b?null:b}};exports.useCallback=function(a,b){return S().useCallback(a,b)};exports.useContext=function(a,b){return S().useContext(a,b)};exports.useDebugValue=function(){};exports.useEffect=function(a,b){return S().useEffect(a,b)};exports.useImperativeHandle=function(a,b,c){return S().useImperativeHandle(a,b,c)};\nexports.useLayoutEffect=function(a,b){return S().useLayoutEffect(a,b)};exports.useMemo=function(a,b){return S().useMemo(a,b)};exports.useReducer=function(a,b,c){return S().useReducer(a,b,c)};exports.useRef=function(a){return S().useRef(a)};exports.useState=function(a){return S().useState(a)};exports.version=\"17.0.0\";\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n","/**\n * Helper method that determines when to recalculate row or column metadata.\n */\nexport default function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref) {\n  var cellCount = _ref.cellCount,\n      cellSize = _ref.cellSize,\n      computeMetadataCallback = _ref.computeMetadataCallback,\n      computeMetadataCallbackProps = _ref.computeMetadataCallbackProps,\n      nextCellsCount = _ref.nextCellsCount,\n      nextCellSize = _ref.nextCellSize,\n      nextScrollToIndex = _ref.nextScrollToIndex,\n      scrollToIndex = _ref.scrollToIndex,\n      updateScrollOffsetForScrollToIndex = _ref.updateScrollOffsetForScrollToIndex;\n\n  // Don't compare cell sizes if they are functions because inline functions would cause infinite loops.\n  // In that event users should use the manual recompute methods to inform of changes.\n  if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) {\n    computeMetadataCallback(computeMetadataCallbackProps); // Updated cell metadata may have hidden the previous scrolled-to item.\n    // In this case we should also update the scrollTop to ensure it stays visible.\n\n    if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) {\n      updateScrollOffsetForScrollToIndex();\n    }\n  }\n}","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\n/**\n * Just-in-time calculates and caches size and position information for a collection of cells.\n */\nvar CellSizeAndPositionManager =\n/*#__PURE__*/\nfunction () {\n  // Cache of size and position data for cells, mapped by cell index.\n  // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex\n  // Measurements for cells up to this index can be trusted; cells afterward should be estimated.\n  // Used in deferred mode to track which cells have been queued for measurement.\n  function CellSizeAndPositionManager(_ref) {\n    var cellCount = _ref.cellCount,\n        cellSizeGetter = _ref.cellSizeGetter,\n        estimatedCellSize = _ref.estimatedCellSize;\n\n    _classCallCheck(this, CellSizeAndPositionManager);\n\n    _defineProperty(this, \"_cellSizeAndPositionData\", {});\n\n    _defineProperty(this, \"_lastMeasuredIndex\", -1);\n\n    _defineProperty(this, \"_lastBatchedIndex\", -1);\n\n    _defineProperty(this, \"_cellCount\", void 0);\n\n    _defineProperty(this, \"_cellSizeGetter\", void 0);\n\n    _defineProperty(this, \"_estimatedCellSize\", void 0);\n\n    this._cellSizeGetter = cellSizeGetter;\n    this._cellCount = cellCount;\n    this._estimatedCellSize = estimatedCellSize;\n  }\n\n  _createClass(CellSizeAndPositionManager, [{\n    key: \"areOffsetsAdjusted\",\n    value: function areOffsetsAdjusted() {\n      return false;\n    }\n  }, {\n    key: \"configure\",\n    value: function configure(_ref2) {\n      var cellCount = _ref2.cellCount,\n          estimatedCellSize = _ref2.estimatedCellSize,\n          cellSizeGetter = _ref2.cellSizeGetter;\n      this._cellCount = cellCount;\n      this._estimatedCellSize = estimatedCellSize;\n      this._cellSizeGetter = cellSizeGetter;\n    }\n  }, {\n    key: \"getCellCount\",\n    value: function getCellCount() {\n      return this._cellCount;\n    }\n  }, {\n    key: \"getEstimatedCellSize\",\n    value: function getEstimatedCellSize() {\n      return this._estimatedCellSize;\n    }\n  }, {\n    key: \"getLastMeasuredIndex\",\n    value: function getLastMeasuredIndex() {\n      return this._lastMeasuredIndex;\n    }\n  }, {\n    key: \"getOffsetAdjustment\",\n    value: function getOffsetAdjustment() {\n      return 0;\n    }\n    /**\n     * This method returns the size and position for the cell at the specified index.\n     * It just-in-time calculates (or used cached values) for cells leading up to the index.\n     */\n\n  }, {\n    key: \"getSizeAndPositionOfCell\",\n    value: function getSizeAndPositionOfCell(index) {\n      if (index < 0 || index >= this._cellCount) {\n        throw Error(\"Requested index \".concat(index, \" is outside of range 0..\").concat(this._cellCount));\n      }\n\n      if (index > this._lastMeasuredIndex) {\n        var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n        var offset = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;\n\n        for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {\n          var size = this._cellSizeGetter({\n            index: i\n          }); // undefined or NaN probably means a logic error in the size getter.\n          // null means we're using CellMeasurer and haven't yet measured a given index.\n\n\n          if (size === undefined || isNaN(size)) {\n            throw Error(\"Invalid size returned for cell \".concat(i, \" of value \").concat(size));\n          } else if (size === null) {\n            this._cellSizeAndPositionData[i] = {\n              offset: offset,\n              size: 0\n            };\n            this._lastBatchedIndex = index;\n          } else {\n            this._cellSizeAndPositionData[i] = {\n              offset: offset,\n              size: size\n            };\n            offset += size;\n            this._lastMeasuredIndex = index;\n          }\n        }\n      }\n\n      return this._cellSizeAndPositionData[index];\n    }\n  }, {\n    key: \"getSizeAndPositionOfLastMeasuredCell\",\n    value: function getSizeAndPositionOfLastMeasuredCell() {\n      return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : {\n        offset: 0,\n        size: 0\n      };\n    }\n    /**\n     * Total size of all cells being measured.\n     * This value will be completely estimated initially.\n     * As cells are measured, the estimate will be updated.\n     */\n\n  }, {\n    key: \"getTotalSize\",\n    value: function getTotalSize() {\n      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n      var totalSizeOfMeasuredCells = lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;\n      var numUnmeasuredCells = this._cellCount - this._lastMeasuredIndex - 1;\n      var totalSizeOfUnmeasuredCells = numUnmeasuredCells * this._estimatedCellSize;\n      return totalSizeOfMeasuredCells + totalSizeOfUnmeasuredCells;\n    }\n    /**\n     * Determines a new offset that ensures a certain cell is visible, given the current offset.\n     * If the cell is already visible then the current offset will be returned.\n     * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.\n     *\n     * @param align Desired alignment within container; one of \"auto\" (default), \"start\", or \"end\"\n     * @param containerSize Size (width or height) of the container viewport\n     * @param currentOffset Container's current (x or y) offset\n     * @param totalSize Total size (width or height) of all cells\n     * @return Offset to use to ensure the specified cell is visible\n     */\n\n  }, {\n    key: \"getUpdatedOffsetForIndex\",\n    value: function getUpdatedOffsetForIndex(_ref3) {\n      var _ref3$align = _ref3.align,\n          align = _ref3$align === void 0 ? 'auto' : _ref3$align,\n          containerSize = _ref3.containerSize,\n          currentOffset = _ref3.currentOffset,\n          targetIndex = _ref3.targetIndex;\n\n      if (containerSize <= 0) {\n        return 0;\n      }\n\n      var datum = this.getSizeAndPositionOfCell(targetIndex);\n      var maxOffset = datum.offset;\n      var minOffset = maxOffset - containerSize + datum.size;\n      var idealOffset;\n\n      switch (align) {\n        case 'start':\n          idealOffset = maxOffset;\n          break;\n\n        case 'end':\n          idealOffset = minOffset;\n          break;\n\n        case 'center':\n          idealOffset = maxOffset - (containerSize - datum.size) / 2;\n          break;\n\n        default:\n          idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset));\n          break;\n      }\n\n      var totalSize = this.getTotalSize();\n      return Math.max(0, Math.min(totalSize - containerSize, idealOffset));\n    }\n  }, {\n    key: \"getVisibleCellRange\",\n    value: function getVisibleCellRange(params) {\n      var containerSize = params.containerSize,\n          offset = params.offset;\n      var totalSize = this.getTotalSize();\n\n      if (totalSize === 0) {\n        return {};\n      }\n\n      var maxOffset = offset + containerSize;\n\n      var start = this._findNearestCell(offset);\n\n      var datum = this.getSizeAndPositionOfCell(start);\n      offset = datum.offset + datum.size;\n      var stop = start;\n\n      while (offset < maxOffset && stop < this._cellCount - 1) {\n        stop++;\n        offset += this.getSizeAndPositionOfCell(stop).size;\n      }\n\n      return {\n        start: start,\n        stop: stop\n      };\n    }\n    /**\n     * Clear all cached values for cells after the specified index.\n     * This method should be called for any cell that has changed its size.\n     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called.\n     */\n\n  }, {\n    key: \"resetCell\",\n    value: function resetCell(index) {\n      this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);\n    }\n  }, {\n    key: \"_binarySearch\",\n    value: function _binarySearch(high, low, offset) {\n      while (low <= high) {\n        var middle = low + Math.floor((high - low) / 2);\n        var currentOffset = this.getSizeAndPositionOfCell(middle).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  }, {\n    key: \"_exponentialSearch\",\n    value: function _exponentialSearch(index, offset) {\n      var interval = 1;\n\n      while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {\n        index += interval;\n        interval *= 2;\n      }\n\n      return this._binarySearch(Math.min(index, this._cellCount - 1), Math.floor(index / 2), offset);\n    }\n    /**\n     * Searches for the cell (index) nearest the specified offset.\n     *\n     * If no exact match is found the next lowest cell index will be returned.\n     * This allows partially visible cells (with offsets just before/above the fold) to be visible.\n     */\n\n  }, {\n    key: \"_findNearestCell\",\n    value: function _findNearestCell(offset) {\n      if (isNaN(offset)) {\n        throw Error(\"Invalid offset \".concat(offset, \" specified\"));\n      } // Our search algorithms find the nearest match at or below the specified offset.\n      // So make sure the offset is at least 0 or no match will be found.\n\n\n      offset = Math.max(0, offset);\n      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();\n      var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);\n\n      if (lastMeasuredCellSizeAndPosition.offset >= offset) {\n        // If we've already measured cells within this range just use a binary search as it's faster.\n        return this._binarySearch(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 cells as a binary search would.\n        // The overall complexity for this approach is O(log n).\n        return this._exponentialSearch(lastMeasuredIndex, offset);\n      }\n    }\n  }]);\n\n  return CellSizeAndPositionManager;\n}();\n\nexport { CellSizeAndPositionManager as default };\nimport { bpfrpt_proptype_Alignment } from \"../types\";\nimport { bpfrpt_proptype_CellSizeGetter } from \"../types\";\nimport { bpfrpt_proptype_VisibleCellRange } from \"../types\";","var DEFAULT_MAX_ELEMENT_SIZE = 1500000;\nvar CHROME_MAX_ELEMENT_SIZE = 1.67771e7;\n\nvar isBrowser = function isBrowser() {\n  return typeof window !== 'undefined';\n};\n\nvar isChrome = function isChrome() {\n  return !!window.chrome;\n};\n\nexport var getMaxElementSize = function getMaxElementSize() {\n  if (isBrowser()) {\n    if (isChrome()) {\n      return CHROME_MAX_ELEMENT_SIZE;\n    }\n  }\n\n  return DEFAULT_MAX_ELEMENT_SIZE;\n};","import _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport CellSizeAndPositionManager from './CellSizeAndPositionManager';\nimport { getMaxElementSize } from './maxElementSize.js';\n\n/**\n * Extends CellSizeAndPositionManager and adds scaling behavior for lists that are too large to fit within a browser's native limits.\n */\nvar ScalingCellSizeAndPositionManager =\n/*#__PURE__*/\nfunction () {\n  function ScalingCellSizeAndPositionManager(_ref) {\n    var _ref$maxScrollSize = _ref.maxScrollSize,\n        maxScrollSize = _ref$maxScrollSize === void 0 ? getMaxElementSize() : _ref$maxScrollSize,\n        params = _objectWithoutProperties(_ref, [\"maxScrollSize\"]);\n\n    _classCallCheck(this, ScalingCellSizeAndPositionManager);\n\n    _defineProperty(this, \"_cellSizeAndPositionManager\", void 0);\n\n    _defineProperty(this, \"_maxScrollSize\", void 0);\n\n    // Favor composition over inheritance to simplify IE10 support\n    this._cellSizeAndPositionManager = new CellSizeAndPositionManager(params);\n    this._maxScrollSize = maxScrollSize;\n  }\n\n  _createClass(ScalingCellSizeAndPositionManager, [{\n    key: \"areOffsetsAdjusted\",\n    value: function areOffsetsAdjusted() {\n      return this._cellSizeAndPositionManager.getTotalSize() > this._maxScrollSize;\n    }\n  }, {\n    key: \"configure\",\n    value: function configure(params) {\n      this._cellSizeAndPositionManager.configure(params);\n    }\n  }, {\n    key: \"getCellCount\",\n    value: function getCellCount() {\n      return this._cellSizeAndPositionManager.getCellCount();\n    }\n  }, {\n    key: \"getEstimatedCellSize\",\n    value: function getEstimatedCellSize() {\n      return this._cellSizeAndPositionManager.getEstimatedCellSize();\n    }\n  }, {\n    key: \"getLastMeasuredIndex\",\n    value: function getLastMeasuredIndex() {\n      return this._cellSizeAndPositionManager.getLastMeasuredIndex();\n    }\n    /**\n     * Number of pixels a cell at the given position (offset) should be shifted in order to fit within the scaled container.\n     * The offset passed to this function is scaled (safe) as well.\n     */\n\n  }, {\n    key: \"getOffsetAdjustment\",\n    value: function getOffsetAdjustment(_ref2) {\n      var containerSize = _ref2.containerSize,\n          offset = _ref2.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n\n      var safeTotalSize = this.getTotalSize();\n\n      var offsetPercentage = this._getOffsetPercentage({\n        containerSize: containerSize,\n        offset: offset,\n        totalSize: safeTotalSize\n      });\n\n      return Math.round(offsetPercentage * (safeTotalSize - totalSize));\n    }\n  }, {\n    key: \"getSizeAndPositionOfCell\",\n    value: function getSizeAndPositionOfCell(index) {\n      return this._cellSizeAndPositionManager.getSizeAndPositionOfCell(index);\n    }\n  }, {\n    key: \"getSizeAndPositionOfLastMeasuredCell\",\n    value: function getSizeAndPositionOfLastMeasuredCell() {\n      return this._cellSizeAndPositionManager.getSizeAndPositionOfLastMeasuredCell();\n    }\n    /** See CellSizeAndPositionManager#getTotalSize */\n\n  }, {\n    key: \"getTotalSize\",\n    value: function getTotalSize() {\n      return Math.min(this._maxScrollSize, this._cellSizeAndPositionManager.getTotalSize());\n    }\n    /** See CellSizeAndPositionManager#getUpdatedOffsetForIndex */\n\n  }, {\n    key: \"getUpdatedOffsetForIndex\",\n    value: function getUpdatedOffsetForIndex(_ref3) {\n      var _ref3$align = _ref3.align,\n          align = _ref3$align === void 0 ? 'auto' : _ref3$align,\n          containerSize = _ref3.containerSize,\n          currentOffset = _ref3.currentOffset,\n          targetIndex = _ref3.targetIndex;\n      currentOffset = this._safeOffsetToOffset({\n        containerSize: containerSize,\n        offset: currentOffset\n      });\n\n      var offset = this._cellSizeAndPositionManager.getUpdatedOffsetForIndex({\n        align: align,\n        containerSize: containerSize,\n        currentOffset: currentOffset,\n        targetIndex: targetIndex\n      });\n\n      return this._offsetToSafeOffset({\n        containerSize: containerSize,\n        offset: offset\n      });\n    }\n    /** See CellSizeAndPositionManager#getVisibleCellRange */\n\n  }, {\n    key: \"getVisibleCellRange\",\n    value: function getVisibleCellRange(_ref4) {\n      var containerSize = _ref4.containerSize,\n          offset = _ref4.offset;\n      offset = this._safeOffsetToOffset({\n        containerSize: containerSize,\n        offset: offset\n      });\n      return this._cellSizeAndPositionManager.getVisibleCellRange({\n        containerSize: containerSize,\n        offset: offset\n      });\n    }\n  }, {\n    key: \"resetCell\",\n    value: function resetCell(index) {\n      this._cellSizeAndPositionManager.resetCell(index);\n    }\n  }, {\n    key: \"_getOffsetPercentage\",\n    value: function _getOffsetPercentage(_ref5) {\n      var containerSize = _ref5.containerSize,\n          offset = _ref5.offset,\n          totalSize = _ref5.totalSize;\n      return totalSize <= containerSize ? 0 : offset / (totalSize - containerSize);\n    }\n  }, {\n    key: \"_offsetToSafeOffset\",\n    value: function _offsetToSafeOffset(_ref6) {\n      var containerSize = _ref6.containerSize,\n          offset = _ref6.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n\n      var safeTotalSize = this.getTotalSize();\n\n      if (totalSize === safeTotalSize) {\n        return offset;\n      } else {\n        var offsetPercentage = this._getOffsetPercentage({\n          containerSize: containerSize,\n          offset: offset,\n          totalSize: totalSize\n        });\n\n        return Math.round(offsetPercentage * (safeTotalSize - containerSize));\n      }\n    }\n  }, {\n    key: \"_safeOffsetToOffset\",\n    value: function _safeOffsetToOffset(_ref7) {\n      var containerSize = _ref7.containerSize,\n          offset = _ref7.offset;\n\n      var totalSize = this._cellSizeAndPositionManager.getTotalSize();\n\n      var safeTotalSize = this.getTotalSize();\n\n      if (totalSize === safeTotalSize) {\n        return offset;\n      } else {\n        var offsetPercentage = this._getOffsetPercentage({\n          containerSize: containerSize,\n          offset: offset,\n          totalSize: safeTotalSize\n        });\n\n        return Math.round(offsetPercentage * (totalSize - containerSize));\n      }\n    }\n  }]);\n\n  return ScalingCellSizeAndPositionManager;\n}();\n\nexport { ScalingCellSizeAndPositionManager as default };\nimport { bpfrpt_proptype_Alignment } from \"../types\";\nimport { bpfrpt_proptype_CellSizeGetter } from \"../types\";\nimport { bpfrpt_proptype_VisibleCellRange } from \"../types\";","/**\n * Helper utility that updates the specified callback whenever any of the specified indices have changed.\n */\nexport default function createCallbackMemoizer() {\n  var requireAllKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n  var cachedIndices = {};\n  return function (_ref) {\n    var callback = _ref.callback,\n        indices = _ref.indices;\n    var keys = Object.keys(indices);\n    var allInitialized = !requireAllKeys || keys.every(function (key) {\n      var value = indices[key];\n      return Array.isArray(value) ? value.length > 0 : value >= 0;\n    });\n    var indexChanged = keys.length !== Object.keys(cachedIndices).length || keys.some(function (key) {\n      var cachedValue = cachedIndices[key];\n      var value = indices[key];\n      return Array.isArray(value) ? cachedValue.join(',') !== value.join(',') : cachedValue !== value;\n    });\n    cachedIndices = indices;\n\n    if (allInitialized && indexChanged) {\n      callback(indices);\n    }\n  };\n}","export var SCROLL_DIRECTION_BACKWARD = -1;\nexport var SCROLL_DIRECTION_FORWARD = 1;\nexport var SCROLL_DIRECTION_HORIZONTAL = 'horizontal';\nexport var SCROLL_DIRECTION_VERTICAL = 'vertical';\n/**\n * Calculates the number of cells to overscan before and after a specified range.\n * This function ensures that overscanning doesn't exceed the available cells.\n */\n\nexport default function defaultOverscanIndicesGetter(_ref) {\n  var cellCount = _ref.cellCount,\n      overscanCellsCount = _ref.overscanCellsCount,\n      scrollDirection = _ref.scrollDirection,\n      startIndex = _ref.startIndex,\n      stopIndex = _ref.stopIndex;\n\n  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {\n    return {\n      overscanStartIndex: Math.max(0, startIndex),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)\n    };\n  } else {\n    return {\n      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex)\n    };\n  }\n}\nimport { bpfrpt_proptype_OverscanIndicesGetterParams } from \"./types\";\nimport { bpfrpt_proptype_OverscanIndices } from \"./types\";","import ScalingCellSizeAndPositionManager from './ScalingCellSizeAndPositionManager.js';\n/**\n * Helper function that determines when to update scroll offsets to ensure that a scroll-to-index remains visible.\n * This function also ensures that the scroll ofset isn't past the last column/row of cells.\n */\n\nexport default function updateScrollIndexHelper(_ref) {\n  var cellSize = _ref.cellSize,\n      cellSizeAndPositionManager = _ref.cellSizeAndPositionManager,\n      previousCellsCount = _ref.previousCellsCount,\n      previousCellSize = _ref.previousCellSize,\n      previousScrollToAlignment = _ref.previousScrollToAlignment,\n      previousScrollToIndex = _ref.previousScrollToIndex,\n      previousSize = _ref.previousSize,\n      scrollOffset = _ref.scrollOffset,\n      scrollToAlignment = _ref.scrollToAlignment,\n      scrollToIndex = _ref.scrollToIndex,\n      size = _ref.size,\n      sizeJustIncreasedFromZero = _ref.sizeJustIncreasedFromZero,\n      updateScrollIndexCallback = _ref.updateScrollIndexCallback;\n  var cellCount = cellSizeAndPositionManager.getCellCount();\n  var hasScrollToIndex = scrollToIndex >= 0 && scrollToIndex < cellCount;\n  var sizeHasChanged = size !== previousSize || sizeJustIncreasedFromZero || !previousCellSize || typeof cellSize === 'number' && cellSize !== previousCellSize; // If we have a new scroll target OR if height/row-height has changed,\n  // We should ensure that the scroll target is visible.\n\n  if (hasScrollToIndex && (sizeHasChanged || scrollToAlignment !== previousScrollToAlignment || scrollToIndex !== previousScrollToIndex)) {\n    updateScrollIndexCallback(scrollToIndex); // If we don't have a selected item but list size or number of children have decreased,\n    // Make sure we aren't scrolled too far past the current content.\n  } else if (!hasScrollToIndex && cellCount > 0 && (size < previousSize || cellCount < previousCellsCount)) {\n    // We need to ensure that the current scroll offset is still within the collection's range.\n    // To do this, we don't need to measure everything; CellMeasurer would perform poorly.\n    // Just check to make sure we're still okay.\n    // Only adjust the scroll position if we've scrolled below the last set of rows.\n    if (scrollOffset > cellSizeAndPositionManager.getTotalSize() - size) {\n      updateScrollIndexCallback(cellCount - 1);\n    }\n  }\n}\nimport { bpfrpt_proptype_Alignment } from \"../types\";\nimport { bpfrpt_proptype_CellSize } from \"../types\";","/**\n * Default implementation of cellRangeRenderer used by Grid.\n * This renderer supports cell-caching while the user is scrolling.\n */\nexport default function defaultCellRangeRenderer(_ref) {\n  var cellCache = _ref.cellCache,\n      cellRenderer = _ref.cellRenderer,\n      columnSizeAndPositionManager = _ref.columnSizeAndPositionManager,\n      columnStartIndex = _ref.columnStartIndex,\n      columnStopIndex = _ref.columnStopIndex,\n      deferredMeasurementCache = _ref.deferredMeasurementCache,\n      horizontalOffsetAdjustment = _ref.horizontalOffsetAdjustment,\n      isScrolling = _ref.isScrolling,\n      isScrollingOptOut = _ref.isScrollingOptOut,\n      parent = _ref.parent,\n      rowSizeAndPositionManager = _ref.rowSizeAndPositionManager,\n      rowStartIndex = _ref.rowStartIndex,\n      rowStopIndex = _ref.rowStopIndex,\n      styleCache = _ref.styleCache,\n      verticalOffsetAdjustment = _ref.verticalOffsetAdjustment,\n      visibleColumnIndices = _ref.visibleColumnIndices,\n      visibleRowIndices = _ref.visibleRowIndices;\n  var renderedCells = []; // Browsers have native size limits for elements (eg Chrome 33M pixels, IE 1.5M pixes).\n  // User cannot scroll beyond these size limitations.\n  // In order to work around this, ScalingCellSizeAndPositionManager compresses offsets.\n  // We should never cache styles for compressed offsets though as this can lead to bugs.\n  // See issue #576 for more.\n\n  var areOffsetsAdjusted = columnSizeAndPositionManager.areOffsetsAdjusted() || rowSizeAndPositionManager.areOffsetsAdjusted();\n  var canCacheStyle = !isScrolling && !areOffsetsAdjusted;\n\n  for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {\n    var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex);\n\n    for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {\n      var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex);\n      var isVisible = columnIndex >= visibleColumnIndices.start && columnIndex <= visibleColumnIndices.stop && rowIndex >= visibleRowIndices.start && rowIndex <= visibleRowIndices.stop;\n      var key = \"\".concat(rowIndex, \"-\").concat(columnIndex);\n      var style = void 0; // Cache style objects so shallow-compare doesn't re-render unnecessarily.\n\n      if (canCacheStyle && styleCache[key]) {\n        style = styleCache[key];\n      } else {\n        // In deferred mode, cells will be initially rendered before we know their size.\n        // Don't interfere with CellMeasurer's measurements by setting an invalid size.\n        if (deferredMeasurementCache && !deferredMeasurementCache.has(rowIndex, columnIndex)) {\n          // Position not-yet-measured cells at top/left 0,0,\n          // And give them width/height of 'auto' so they can grow larger than the parent Grid if necessary.\n          // Positioning them further to the right/bottom influences their measured size.\n          style = {\n            height: 'auto',\n            left: 0,\n            position: 'absolute',\n            top: 0,\n            width: 'auto'\n          };\n        } else {\n          style = {\n            height: rowDatum.size,\n            left: columnDatum.offset + horizontalOffsetAdjustment,\n            position: 'absolute',\n            top: rowDatum.offset + verticalOffsetAdjustment,\n            width: columnDatum.size\n          };\n          styleCache[key] = style;\n        }\n      }\n\n      var cellRendererParams = {\n        columnIndex: columnIndex,\n        isScrolling: isScrolling,\n        isVisible: isVisible,\n        key: key,\n        parent: parent,\n        rowIndex: rowIndex,\n        style: style\n      };\n      var renderedCell = void 0; // Avoid re-creating cells while scrolling.\n      // This can lead to the same cell being created many times and can cause performance issues for \"heavy\" cells.\n      // If a scroll is in progress- cache and reuse cells.\n      // This cache will be thrown away once scrolling completes.\n      // However if we are scaling scroll positions and sizes, we should also avoid caching.\n      // This is because the offset changes slightly as scroll position changes and caching leads to stale values.\n      // For more info refer to issue #395\n      //\n      // If isScrollingOptOut is specified, we always cache cells.\n      // For more info refer to issue #1028\n\n      if ((isScrollingOptOut || isScrolling) && !horizontalOffsetAdjustment && !verticalOffsetAdjustment) {\n        if (!cellCache[key]) {\n          cellCache[key] = cellRenderer(cellRendererParams);\n        }\n\n        renderedCell = cellCache[key]; // If the user is no longer scrolling, don't cache cells.\n        // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint.\n      } else {\n        renderedCell = cellRenderer(cellRendererParams);\n      }\n\n      if (renderedCell == null || renderedCell === false) {\n        continue;\n      }\n\n      if (process.env.NODE_ENV !== 'production') {\n        warnAboutMissingStyle(parent, renderedCell);\n      }\n\n      renderedCells.push(renderedCell);\n    }\n  }\n\n  return renderedCells;\n}\n\nfunction warnAboutMissingStyle(parent, renderedCell) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (renderedCell) {\n      // If the direct child is a CellMeasurer, then we should check its child\n      // See issue #611\n      if (renderedCell.type && renderedCell.type.__internalCellMeasurerFlag) {\n        renderedCell = renderedCell.props.children;\n      }\n\n      if (renderedCell && renderedCell.props && renderedCell.props.style === undefined && parent.__warnedAboutMissingStyle !== true) {\n        parent.__warnedAboutMissingStyle = true;\n        console.warn('Rendered cell should include style property for positioning.');\n      }\n    }\n  }\n}\n\nimport { bpfrpt_proptype_CellRangeRendererParams } from \"./types\";","// Properly handle server-side rendering.\nvar win;\n\nif (typeof window !== 'undefined') {\n  win = window;\n} else if (typeof self !== 'undefined') {\n  win = self;\n} else {\n  win = {};\n} // requestAnimationFrame() shim by Paul Irish\n// http://paulirish.com/2011/requestanimationframe-for-smart-animating/\n\n\nvar request = win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || win.oRequestAnimationFrame || win.msRequestAnimationFrame || function (callback) {\n  return win.setTimeout(callback, 1000 / 60);\n};\n\nvar cancel = win.cancelAnimationFrame || win.webkitCancelAnimationFrame || win.mozCancelAnimationFrame || win.oCancelAnimationFrame || win.msCancelAnimationFrame || function (id) {\n  win.clearTimeout(id);\n};\n\nexport var raf = request;\nexport var caf = cancel;","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport clsx from 'clsx';\nimport calculateSizeAndPositionDataAndUpdateScrollOffset from './utils/calculateSizeAndPositionDataAndUpdateScrollOffset';\nimport ScalingCellSizeAndPositionManager from './utils/ScalingCellSizeAndPositionManager';\nimport createCallbackMemoizer from '../utils/createCallbackMemoizer';\nimport defaultOverscanIndicesGetter, { SCROLL_DIRECTION_BACKWARD, SCROLL_DIRECTION_FORWARD } from './defaultOverscanIndicesGetter';\nimport updateScrollIndexHelper from './utils/updateScrollIndexHelper';\nimport defaultCellRangeRenderer from './defaultCellRangeRenderer';\nimport scrollbarSize from 'dom-helpers/scrollbarSize';\nimport { polyfill } from 'react-lifecycles-compat';\nimport { requestAnimationTimeout, cancelAnimationTimeout } from '../utils/requestAnimationTimeout';\n/**\n * Specifies the number of milliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\n\nexport var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;\n/**\n * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.\n * This prevents Grid from interrupting mouse-wheel animations (see issue #2).\n */\n\nvar SCROLL_POSITION_CHANGE_REASONS = {\n  OBSERVED: 'observed',\n  REQUESTED: 'requested'\n};\n\nvar renderNull = function renderNull() {\n  return null;\n};\n\n/**\n * Renders tabular data with virtualization along the vertical and horizontal axes.\n * Row heights and column widths must be known ahead of time and specified as properties.\n */\nvar Grid = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Grid, _React$PureComponent);\n\n  // Invokes onSectionRendered callback only when start/stop row or column indices change\n  function Grid(props) {\n    var _this;\n\n    _classCallCheck(this, Grid);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Grid).call(this, props));\n\n    _defineProperty(_assertThisInitialized(_this), \"_onGridRenderedMemoizer\", createCallbackMemoizer());\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollMemoizer\", createCallbackMemoizer(false));\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateColumnIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateRowIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_recomputeScrollLeftFlag\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_recomputeScrollTopFlag\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_horizontalScrollBarSize\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_verticalScrollBarSize\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_scrollbarPresenceChanged\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_scrollingContainer\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_childrenToDisplay\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStartIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStopIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStartIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStopIndex\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedColumnStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedColumnStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedRowStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_renderedRowStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_initialScrollTop\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_initialScrollLeft\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_disablePointerEventsTimeoutId\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_styleCache\", {});\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellCache\", {});\n\n    _defineProperty(_assertThisInitialized(_this), \"_debounceScrollEndedCallback\", function () {\n      _this._disablePointerEventsTimeoutId = null; // isScrolling is used to determine if we reset styleCache\n\n      _this.setState({\n        isScrolling: false,\n        needToResetStyleCache: false\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_invokeOnGridRenderedHelper\", function () {\n      var onSectionRendered = _this.props.onSectionRendered;\n\n      _this._onGridRenderedMemoizer({\n        callback: onSectionRendered,\n        indices: {\n          columnOverscanStartIndex: _this._columnStartIndex,\n          columnOverscanStopIndex: _this._columnStopIndex,\n          columnStartIndex: _this._renderedColumnStartIndex,\n          columnStopIndex: _this._renderedColumnStopIndex,\n          rowOverscanStartIndex: _this._rowStartIndex,\n          rowOverscanStopIndex: _this._rowStopIndex,\n          rowStartIndex: _this._renderedRowStartIndex,\n          rowStopIndex: _this._renderedRowStopIndex\n        }\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setScrollingContainerRef\", function (ref) {\n      _this._scrollingContainer = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (event) {\n      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.\n      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.\n      // See issue #404 for more information.\n      if (event.target === _this._scrollingContainer) {\n        _this.handleScrollEvent(event.target);\n      }\n    });\n\n    var columnSizeAndPositionManager = new ScalingCellSizeAndPositionManager({\n      cellCount: props.columnCount,\n      cellSizeGetter: function cellSizeGetter(params) {\n        return Grid._wrapSizeGetter(props.columnWidth)(params);\n      },\n      estimatedCellSize: Grid._getEstimatedColumnSize(props)\n    });\n    var rowSizeAndPositionManager = new ScalingCellSizeAndPositionManager({\n      cellCount: props.rowCount,\n      cellSizeGetter: function cellSizeGetter(params) {\n        return Grid._wrapSizeGetter(props.rowHeight)(params);\n      },\n      estimatedCellSize: Grid._getEstimatedRowSize(props)\n    });\n    _this.state = {\n      instanceProps: {\n        columnSizeAndPositionManager: columnSizeAndPositionManager,\n        rowSizeAndPositionManager: rowSizeAndPositionManager,\n        prevColumnWidth: props.columnWidth,\n        prevRowHeight: props.rowHeight,\n        prevColumnCount: props.columnCount,\n        prevRowCount: props.rowCount,\n        prevIsScrolling: props.isScrolling === true,\n        prevScrollToColumn: props.scrollToColumn,\n        prevScrollToRow: props.scrollToRow,\n        scrollbarSize: 0,\n        scrollbarSizeMeasured: false\n      },\n      isScrolling: false,\n      scrollDirectionHorizontal: SCROLL_DIRECTION_FORWARD,\n      scrollDirectionVertical: SCROLL_DIRECTION_FORWARD,\n      scrollLeft: 0,\n      scrollTop: 0,\n      scrollPositionChangeReason: null,\n      needToResetStyleCache: false\n    };\n\n    if (props.scrollToRow > 0) {\n      _this._initialScrollTop = _this._getCalculatedScrollTop(props, _this.state);\n    }\n\n    if (props.scrollToColumn > 0) {\n      _this._initialScrollLeft = _this._getCalculatedScrollLeft(props, _this.state);\n    }\n\n    return _this;\n  }\n  /**\n   * Gets offsets for a given cell and alignment.\n   */\n\n\n  _createClass(Grid, [{\n    key: \"getOffsetForCell\",\n    value: function getOffsetForCell() {\n      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref$alignment = _ref.alignment,\n          alignment = _ref$alignment === void 0 ? this.props.scrollToAlignment : _ref$alignment,\n          _ref$columnIndex = _ref.columnIndex,\n          columnIndex = _ref$columnIndex === void 0 ? this.props.scrollToColumn : _ref$columnIndex,\n          _ref$rowIndex = _ref.rowIndex,\n          rowIndex = _ref$rowIndex === void 0 ? this.props.scrollToRow : _ref$rowIndex;\n\n      var offsetProps = _objectSpread({}, this.props, {\n        scrollToAlignment: alignment,\n        scrollToColumn: columnIndex,\n        scrollToRow: rowIndex\n      });\n\n      return {\n        scrollLeft: this._getCalculatedScrollLeft(offsetProps),\n        scrollTop: this._getCalculatedScrollTop(offsetProps)\n      };\n    }\n    /**\n     * Gets estimated total rows' height.\n     */\n\n  }, {\n    key: \"getTotalRowsHeight\",\n    value: function getTotalRowsHeight() {\n      return this.state.instanceProps.rowSizeAndPositionManager.getTotalSize();\n    }\n    /**\n     * Gets estimated total columns' width.\n     */\n\n  }, {\n    key: \"getTotalColumnsWidth\",\n    value: function getTotalColumnsWidth() {\n      return this.state.instanceProps.columnSizeAndPositionManager.getTotalSize();\n    }\n    /**\n     * This method handles a scroll event originating from an external scroll control.\n     * It's an advanced method and should probably not be used unless you're implementing a custom scroll-bar solution.\n     */\n\n  }, {\n    key: \"handleScrollEvent\",\n    value: function handleScrollEvent(_ref2) {\n      var _ref2$scrollLeft = _ref2.scrollLeft,\n          scrollLeftParam = _ref2$scrollLeft === void 0 ? 0 : _ref2$scrollLeft,\n          _ref2$scrollTop = _ref2.scrollTop,\n          scrollTopParam = _ref2$scrollTop === void 0 ? 0 : _ref2$scrollTop;\n\n      // On iOS, we can arrive at negative offsets by swiping past the start.\n      // To prevent flicker here, we make playing in the negative offset zone cause nothing to happen.\n      if (scrollTopParam < 0) {\n        return;\n      } // Prevent pointer events from interrupting a smooth scroll\n\n\n      this._debounceScrollEnded();\n\n      var _this$props = this.props,\n          autoHeight = _this$props.autoHeight,\n          autoWidth = _this$props.autoWidth,\n          height = _this$props.height,\n          width = _this$props.width;\n      var instanceProps = this.state.instanceProps; // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scroll offsets never exceed their bounds.\n\n      var scrollbarSize = instanceProps.scrollbarSize;\n      var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();\n      var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n      var scrollLeft = Math.min(Math.max(0, totalColumnsWidth - width + scrollbarSize), scrollLeftParam);\n      var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), scrollTopParam); // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n\n      if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) {\n        // Track scrolling direction so we can more efficiently overscan rows to reduce empty space around the edges while scrolling.\n        // Don't change direction for an axis unless scroll offset has changed.\n        var scrollDirectionHorizontal = scrollLeft !== this.state.scrollLeft ? scrollLeft > this.state.scrollLeft ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD : this.state.scrollDirectionHorizontal;\n        var scrollDirectionVertical = scrollTop !== this.state.scrollTop ? scrollTop > this.state.scrollTop ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD : this.state.scrollDirectionVertical;\n        var newState = {\n          isScrolling: true,\n          scrollDirectionHorizontal: scrollDirectionHorizontal,\n          scrollDirectionVertical: scrollDirectionVertical,\n          scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.OBSERVED\n        };\n\n        if (!autoHeight) {\n          newState.scrollTop = scrollTop;\n        }\n\n        if (!autoWidth) {\n          newState.scrollLeft = scrollLeft;\n        }\n\n        newState.needToResetStyleCache = false;\n        this.setState(newState);\n      }\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        totalColumnsWidth: totalColumnsWidth,\n        totalRowsHeight: totalRowsHeight\n      });\n    }\n    /**\n     * Invalidate Grid size and recompute visible cells.\n     * This is a deferred wrapper for recomputeGridSize().\n     * It sets a flag to be evaluated on cDM/cDU to avoid unnecessary renders.\n     * This method is intended for advanced use-cases like CellMeasurer.\n     */\n    // @TODO (bvaughn) Add automated test coverage for this.\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref3) {\n      var columnIndex = _ref3.columnIndex,\n          rowIndex = _ref3.rowIndex;\n      this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;\n      this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;\n    }\n    /**\n     * Pre-measure all columns and rows in a Grid.\n     * Typically cells are only measured as needed and estimated sizes are used for cells that have not yet been measured.\n     * This method ensures that the next call to getTotalSize() returns an exact size (as opposed to just an estimated one).\n     */\n\n  }, {\n    key: \"measureAllCells\",\n    value: function measureAllCells() {\n      var _this$props2 = this.props,\n          columnCount = _this$props2.columnCount,\n          rowCount = _this$props2.rowCount;\n      var instanceProps = this.state.instanceProps;\n      instanceProps.columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1);\n      instanceProps.rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1);\n    }\n    /**\n     * Forced recompute of row heights and column widths.\n     * This function should be called if dynamic column or row sizes have changed but nothing else has.\n     * Since Grid only receives :columnCount and :rowCount it has no way of detecting when the underlying data changes.\n     */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref4$columnIndex = _ref4.columnIndex,\n          columnIndex = _ref4$columnIndex === void 0 ? 0 : _ref4$columnIndex,\n          _ref4$rowIndex = _ref4.rowIndex,\n          rowIndex = _ref4$rowIndex === void 0 ? 0 : _ref4$rowIndex;\n\n      var _this$props3 = this.props,\n          scrollToColumn = _this$props3.scrollToColumn,\n          scrollToRow = _this$props3.scrollToRow;\n      var instanceProps = this.state.instanceProps;\n      instanceProps.columnSizeAndPositionManager.resetCell(columnIndex);\n      instanceProps.rowSizeAndPositionManager.resetCell(rowIndex); // Cell sizes may be determined by a function property.\n      // In this case the cDU handler can't know if they changed.\n      // Store this flag to let the next cDU pass know it needs to recompute the scroll offset.\n\n      this._recomputeScrollLeftFlag = scrollToColumn >= 0 && (this.state.scrollDirectionHorizontal === SCROLL_DIRECTION_FORWARD ? columnIndex <= scrollToColumn : columnIndex >= scrollToColumn);\n      this._recomputeScrollTopFlag = scrollToRow >= 0 && (this.state.scrollDirectionVertical === SCROLL_DIRECTION_FORWARD ? rowIndex <= scrollToRow : rowIndex >= scrollToRow); // Clear cell cache in case we are scrolling;\n      // Invalid row heights likely mean invalid cached content as well.\n\n      this._styleCache = {};\n      this._cellCache = {};\n      this.forceUpdate();\n    }\n    /**\n     * Ensure column and row are visible.\n     */\n\n  }, {\n    key: \"scrollToCell\",\n    value: function scrollToCell(_ref5) {\n      var columnIndex = _ref5.columnIndex,\n          rowIndex = _ref5.rowIndex;\n      var columnCount = this.props.columnCount;\n      var props = this.props; // Don't adjust scroll offset for single-column grids (eg List, Table).\n      // This can cause a funky scroll offset because of the vertical scrollbar width.\n\n      if (columnCount > 1 && columnIndex !== undefined) {\n        this._updateScrollLeftForScrollToColumn(_objectSpread({}, props, {\n          scrollToColumn: columnIndex\n        }));\n      }\n\n      if (rowIndex !== undefined) {\n        this._updateScrollTopForScrollToRow(_objectSpread({}, props, {\n          scrollToRow: rowIndex\n        }));\n      }\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var _this$props4 = this.props,\n          getScrollbarSize = _this$props4.getScrollbarSize,\n          height = _this$props4.height,\n          scrollLeft = _this$props4.scrollLeft,\n          scrollToColumn = _this$props4.scrollToColumn,\n          scrollTop = _this$props4.scrollTop,\n          scrollToRow = _this$props4.scrollToRow,\n          width = _this$props4.width;\n      var instanceProps = this.state.instanceProps; // Reset initial offsets to be ignored in browser\n\n      this._initialScrollTop = 0;\n      this._initialScrollLeft = 0; // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.\n      // We must do this at the start of the method as we may calculate and update scroll position below.\n\n      this._handleInvalidatedGridSize(); // If this component was first rendered server-side, scrollbar size will be undefined.\n      // In that event we need to remeasure.\n\n\n      if (!instanceProps.scrollbarSizeMeasured) {\n        this.setState(function (prevState) {\n          var stateUpdate = _objectSpread({}, prevState, {\n            needToResetStyleCache: false\n          });\n\n          stateUpdate.instanceProps.scrollbarSize = getScrollbarSize();\n          stateUpdate.instanceProps.scrollbarSizeMeasured = true;\n          return stateUpdate;\n        });\n      }\n\n      if (typeof scrollLeft === 'number' && scrollLeft >= 0 || typeof scrollTop === 'number' && scrollTop >= 0) {\n        var stateUpdate = Grid._getScrollToPositionStateUpdate({\n          prevState: this.state,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n\n        if (stateUpdate) {\n          stateUpdate.needToResetStyleCache = false;\n          this.setState(stateUpdate);\n        }\n      } // refs don't work in `react-test-renderer`\n\n\n      if (this._scrollingContainer) {\n        // setting the ref's scrollLeft and scrollTop.\n        // Somehow in MultiGrid the main grid doesn't trigger a update on mount.\n        if (this._scrollingContainer.scrollLeft !== this.state.scrollLeft) {\n          this._scrollingContainer.scrollLeft = this.state.scrollLeft;\n        }\n\n        if (this._scrollingContainer.scrollTop !== this.state.scrollTop) {\n          this._scrollingContainer.scrollTop = this.state.scrollTop;\n        }\n      } // Don't update scroll offset if the size is 0; we don't render any cells in this case.\n      // Setting a state may cause us to later thing we've updated the offce when we haven't.\n\n\n      var sizeIsBiggerThanZero = height > 0 && width > 0;\n\n      if (scrollToColumn >= 0 && sizeIsBiggerThanZero) {\n        this._updateScrollLeftForScrollToColumn();\n      }\n\n      if (scrollToRow >= 0 && sizeIsBiggerThanZero) {\n        this._updateScrollTopForScrollToRow();\n      } // Update onRowsRendered callback\n\n\n      this._invokeOnGridRenderedHelper(); // Initialize onScroll callback\n\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft || 0,\n        scrollTop: scrollTop || 0,\n        totalColumnsWidth: instanceProps.columnSizeAndPositionManager.getTotalSize(),\n        totalRowsHeight: instanceProps.rowSizeAndPositionManager.getTotalSize()\n      });\n\n      this._maybeCallOnScrollbarPresenceChange();\n    }\n    /**\n     * @private\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) New scroll-to-cell props have been set\n     */\n\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this2 = this;\n\n      var _this$props5 = this.props,\n          autoHeight = _this$props5.autoHeight,\n          autoWidth = _this$props5.autoWidth,\n          columnCount = _this$props5.columnCount,\n          height = _this$props5.height,\n          rowCount = _this$props5.rowCount,\n          scrollToAlignment = _this$props5.scrollToAlignment,\n          scrollToColumn = _this$props5.scrollToColumn,\n          scrollToRow = _this$props5.scrollToRow,\n          width = _this$props5.width;\n      var _this$state = this.state,\n          scrollLeft = _this$state.scrollLeft,\n          scrollPositionChangeReason = _this$state.scrollPositionChangeReason,\n          scrollTop = _this$state.scrollTop,\n          instanceProps = _this$state.instanceProps; // If cell sizes have been invalidated (eg we are using CellMeasurer) then reset cached positions.\n      // We must do this at the start of the method as we may calculate and update scroll position below.\n\n      this._handleInvalidatedGridSize(); // Handle edge case where column or row count has only just increased over 0.\n      // In this case we may have to restore a previously-specified scroll offset.\n      // For more info see bvaughn/react-virtualized/issues/218\n\n\n      var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0; // Make sure requested changes to :scrollLeft or :scrollTop get applied.\n      // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,\n      // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread).\n      // So we only set these when we require an adjustment of the scroll position.\n      // See issue #2 for more information.\n\n      if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {\n        // @TRICKY :autoHeight and :autoWidth properties instructs Grid to leave :scrollTop and :scrollLeft management to an external HOC (eg WindowScroller).\n        // In this case we should avoid checking scrollingContainer.scrollTop and scrollingContainer.scrollLeft since it forces layout/flow.\n        if (!autoWidth && scrollLeft >= 0 && (scrollLeft !== this._scrollingContainer.scrollLeft || columnOrRowCountJustIncreasedFromZero)) {\n          this._scrollingContainer.scrollLeft = scrollLeft;\n        }\n\n        if (!autoHeight && scrollTop >= 0 && (scrollTop !== this._scrollingContainer.scrollTop || columnOrRowCountJustIncreasedFromZero)) {\n          this._scrollingContainer.scrollTop = scrollTop;\n        }\n      } // Special case where the previous size was 0:\n      // In this case we don't show any windowed cells at all.\n      // So we should always recalculate offset afterwards.\n\n\n      var sizeJustIncreasedFromZero = (prevProps.width === 0 || prevProps.height === 0) && height > 0 && width > 0; // Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it\n      // @TODO Do we also need this check or can the one in componentWillUpdate() suffice?\n\n      if (this._recomputeScrollLeftFlag) {\n        this._recomputeScrollLeftFlag = false;\n\n        this._updateScrollLeftForScrollToColumn(this.props);\n      } else {\n        updateScrollIndexHelper({\n          cellSizeAndPositionManager: instanceProps.columnSizeAndPositionManager,\n          previousCellsCount: prevProps.columnCount,\n          previousCellSize: prevProps.columnWidth,\n          previousScrollToAlignment: prevProps.scrollToAlignment,\n          previousScrollToIndex: prevProps.scrollToColumn,\n          previousSize: prevProps.width,\n          scrollOffset: scrollLeft,\n          scrollToAlignment: scrollToAlignment,\n          scrollToIndex: scrollToColumn,\n          size: width,\n          sizeJustIncreasedFromZero: sizeJustIncreasedFromZero,\n          updateScrollIndexCallback: function updateScrollIndexCallback() {\n            return _this2._updateScrollLeftForScrollToColumn(_this2.props);\n          }\n        });\n      }\n\n      if (this._recomputeScrollTopFlag) {\n        this._recomputeScrollTopFlag = false;\n\n        this._updateScrollTopForScrollToRow(this.props);\n      } else {\n        updateScrollIndexHelper({\n          cellSizeAndPositionManager: instanceProps.rowSizeAndPositionManager,\n          previousCellsCount: prevProps.rowCount,\n          previousCellSize: prevProps.rowHeight,\n          previousScrollToAlignment: prevProps.scrollToAlignment,\n          previousScrollToIndex: prevProps.scrollToRow,\n          previousSize: prevProps.height,\n          scrollOffset: scrollTop,\n          scrollToAlignment: scrollToAlignment,\n          scrollToIndex: scrollToRow,\n          size: height,\n          sizeJustIncreasedFromZero: sizeJustIncreasedFromZero,\n          updateScrollIndexCallback: function updateScrollIndexCallback() {\n            return _this2._updateScrollTopForScrollToRow(_this2.props);\n          }\n        });\n      } // Update onRowsRendered callback if start/stop indices have changed\n\n\n      this._invokeOnGridRenderedHelper(); // Changes to :scrollLeft or :scrollTop should also notify :onScroll listeners\n\n\n      if (scrollLeft !== prevState.scrollLeft || scrollTop !== prevState.scrollTop) {\n        var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();\n        var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n\n        this._invokeOnScrollMemoizer({\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          totalColumnsWidth: totalColumnsWidth,\n          totalRowsHeight: totalRowsHeight\n        });\n      }\n\n      this._maybeCallOnScrollbarPresenceChange();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._disablePointerEventsTimeoutId) {\n        cancelAnimationTimeout(this._disablePointerEventsTimeoutId);\n      }\n    }\n    /**\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) Empty content (0 rows or columns)\n     * 2) New scroll props overriding the current state\n     * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid\n     */\n\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props6 = this.props,\n          autoContainerWidth = _this$props6.autoContainerWidth,\n          autoHeight = _this$props6.autoHeight,\n          autoWidth = _this$props6.autoWidth,\n          className = _this$props6.className,\n          containerProps = _this$props6.containerProps,\n          containerRole = _this$props6.containerRole,\n          containerStyle = _this$props6.containerStyle,\n          height = _this$props6.height,\n          id = _this$props6.id,\n          noContentRenderer = _this$props6.noContentRenderer,\n          role = _this$props6.role,\n          style = _this$props6.style,\n          tabIndex = _this$props6.tabIndex,\n          width = _this$props6.width;\n      var _this$state2 = this.state,\n          instanceProps = _this$state2.instanceProps,\n          needToResetStyleCache = _this$state2.needToResetStyleCache;\n\n      var isScrolling = this._isScrolling();\n\n      var gridStyle = {\n        boxSizing: 'border-box',\n        direction: 'ltr',\n        height: autoHeight ? 'auto' : height,\n        position: 'relative',\n        width: autoWidth ? 'auto' : width,\n        WebkitOverflowScrolling: 'touch',\n        willChange: 'transform'\n      };\n\n      if (needToResetStyleCache) {\n        this._styleCache = {};\n      } // calculate _styleCache here\n      // if state.isScrolling (not from _isScrolling) then reset\n\n\n      if (!this.state.isScrolling) {\n        this._resetStyleCache();\n      } // calculate children to render here\n\n\n      this._calculateChildrenToRender(this.props, this.state);\n\n      var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n      var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize(); // Force browser to hide scrollbars when we know they aren't necessary.\n      // Otherwise once scrollbars appear they may not disappear again.\n      // For more info see issue #116\n\n      var verticalScrollBarSize = totalRowsHeight > height ? instanceProps.scrollbarSize : 0;\n      var horizontalScrollBarSize = totalColumnsWidth > width ? instanceProps.scrollbarSize : 0;\n\n      if (horizontalScrollBarSize !== this._horizontalScrollBarSize || verticalScrollBarSize !== this._verticalScrollBarSize) {\n        this._horizontalScrollBarSize = horizontalScrollBarSize;\n        this._verticalScrollBarSize = verticalScrollBarSize;\n        this._scrollbarPresenceChanged = true;\n      } // Also explicitly init styles to 'auto' if scrollbars are required.\n      // This works around an obscure edge case where external CSS styles have not yet been loaded,\n      // But an initial scroll index of offset is set as an external prop.\n      // Without this style, Grid would render the correct range of cells but would NOT update its internal offset.\n      // This was originally reported via clauderic/react-infinite-calendar/issues/23\n\n\n      gridStyle.overflowX = totalColumnsWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto';\n      gridStyle.overflowY = totalRowsHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto';\n      var childrenToDisplay = this._childrenToDisplay;\n      var showNoContentRenderer = childrenToDisplay.length === 0 && height > 0 && width > 0;\n      return React.createElement(\"div\", _extends({\n        ref: this._setScrollingContainerRef\n      }, containerProps, {\n        \"aria-label\": this.props['aria-label'],\n        \"aria-readonly\": this.props['aria-readonly'],\n        className: clsx('ReactVirtualized__Grid', className),\n        id: id,\n        onScroll: this._onScroll,\n        role: role,\n        style: _objectSpread({}, gridStyle, {}, style),\n        tabIndex: tabIndex\n      }), childrenToDisplay.length > 0 && React.createElement(\"div\", {\n        className: \"ReactVirtualized__Grid__innerScrollContainer\",\n        role: containerRole,\n        style: _objectSpread({\n          width: autoContainerWidth ? 'auto' : totalColumnsWidth,\n          height: totalRowsHeight,\n          maxWidth: totalColumnsWidth,\n          maxHeight: totalRowsHeight,\n          overflow: 'hidden',\n          pointerEvents: isScrolling ? 'none' : '',\n          position: 'relative'\n        }, containerStyle)\n      }, childrenToDisplay), showNoContentRenderer && noContentRenderer());\n    }\n    /* ---------------------------- Helper methods ---------------------------- */\n\n  }, {\n    key: \"_calculateChildrenToRender\",\n    value: function _calculateChildrenToRender() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      var cellRenderer = props.cellRenderer,\n          cellRangeRenderer = props.cellRangeRenderer,\n          columnCount = props.columnCount,\n          deferredMeasurementCache = props.deferredMeasurementCache,\n          height = props.height,\n          overscanColumnCount = props.overscanColumnCount,\n          overscanIndicesGetter = props.overscanIndicesGetter,\n          overscanRowCount = props.overscanRowCount,\n          rowCount = props.rowCount,\n          width = props.width,\n          isScrollingOptOut = props.isScrollingOptOut;\n      var scrollDirectionHorizontal = state.scrollDirectionHorizontal,\n          scrollDirectionVertical = state.scrollDirectionVertical,\n          instanceProps = state.instanceProps;\n      var scrollTop = this._initialScrollTop > 0 ? this._initialScrollTop : state.scrollTop;\n      var scrollLeft = this._initialScrollLeft > 0 ? this._initialScrollLeft : state.scrollLeft;\n\n      var isScrolling = this._isScrolling(props, state);\n\n      this._childrenToDisplay = []; // Render only enough columns and rows to cover the visible area of the grid.\n\n      if (height > 0 && width > 0) {\n        var visibleColumnIndices = instanceProps.columnSizeAndPositionManager.getVisibleCellRange({\n          containerSize: width,\n          offset: scrollLeft\n        });\n        var visibleRowIndices = instanceProps.rowSizeAndPositionManager.getVisibleCellRange({\n          containerSize: height,\n          offset: scrollTop\n        });\n        var horizontalOffsetAdjustment = instanceProps.columnSizeAndPositionManager.getOffsetAdjustment({\n          containerSize: width,\n          offset: scrollLeft\n        });\n        var verticalOffsetAdjustment = instanceProps.rowSizeAndPositionManager.getOffsetAdjustment({\n          containerSize: height,\n          offset: scrollTop\n        }); // Store for _invokeOnGridRenderedHelper()\n\n        this._renderedColumnStartIndex = visibleColumnIndices.start;\n        this._renderedColumnStopIndex = visibleColumnIndices.stop;\n        this._renderedRowStartIndex = visibleRowIndices.start;\n        this._renderedRowStopIndex = visibleRowIndices.stop;\n        var overscanColumnIndices = overscanIndicesGetter({\n          direction: 'horizontal',\n          cellCount: columnCount,\n          overscanCellsCount: overscanColumnCount,\n          scrollDirection: scrollDirectionHorizontal,\n          startIndex: typeof visibleColumnIndices.start === 'number' ? visibleColumnIndices.start : 0,\n          stopIndex: typeof visibleColumnIndices.stop === 'number' ? visibleColumnIndices.stop : -1\n        });\n        var overscanRowIndices = overscanIndicesGetter({\n          direction: 'vertical',\n          cellCount: rowCount,\n          overscanCellsCount: overscanRowCount,\n          scrollDirection: scrollDirectionVertical,\n          startIndex: typeof visibleRowIndices.start === 'number' ? visibleRowIndices.start : 0,\n          stopIndex: typeof visibleRowIndices.stop === 'number' ? visibleRowIndices.stop : -1\n        }); // Store for _invokeOnGridRenderedHelper()\n\n        var columnStartIndex = overscanColumnIndices.overscanStartIndex;\n        var columnStopIndex = overscanColumnIndices.overscanStopIndex;\n        var rowStartIndex = overscanRowIndices.overscanStartIndex;\n        var rowStopIndex = overscanRowIndices.overscanStopIndex; // Advanced use-cases (eg CellMeasurer) require batched measurements to determine accurate sizes.\n\n        if (deferredMeasurementCache) {\n          // If rows have a dynamic height, scan the rows we are about to render.\n          // If any have not yet been measured, then we need to render all columns initially,\n          // Because the height of the row is equal to the tallest cell within that row,\n          // (And so we can't know the height without measuring all column-cells first).\n          if (!deferredMeasurementCache.hasFixedHeight()) {\n            for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {\n              if (!deferredMeasurementCache.has(rowIndex, 0)) {\n                columnStartIndex = 0;\n                columnStopIndex = columnCount - 1;\n                break;\n              }\n            }\n          } // If columns have a dynamic width, scan the columns we are about to render.\n          // If any have not yet been measured, then we need to render all rows initially,\n          // Because the width of the column is equal to the widest cell within that column,\n          // (And so we can't know the width without measuring all row-cells first).\n\n\n          if (!deferredMeasurementCache.hasFixedWidth()) {\n            for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {\n              if (!deferredMeasurementCache.has(0, columnIndex)) {\n                rowStartIndex = 0;\n                rowStopIndex = rowCount - 1;\n                break;\n              }\n            }\n          }\n        }\n\n        this._childrenToDisplay = cellRangeRenderer({\n          cellCache: this._cellCache,\n          cellRenderer: cellRenderer,\n          columnSizeAndPositionManager: instanceProps.columnSizeAndPositionManager,\n          columnStartIndex: columnStartIndex,\n          columnStopIndex: columnStopIndex,\n          deferredMeasurementCache: deferredMeasurementCache,\n          horizontalOffsetAdjustment: horizontalOffsetAdjustment,\n          isScrolling: isScrolling,\n          isScrollingOptOut: isScrollingOptOut,\n          parent: this,\n          rowSizeAndPositionManager: instanceProps.rowSizeAndPositionManager,\n          rowStartIndex: rowStartIndex,\n          rowStopIndex: rowStopIndex,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          styleCache: this._styleCache,\n          verticalOffsetAdjustment: verticalOffsetAdjustment,\n          visibleColumnIndices: visibleColumnIndices,\n          visibleRowIndices: visibleRowIndices\n        }); // update the indices\n\n        this._columnStartIndex = columnStartIndex;\n        this._columnStopIndex = columnStopIndex;\n        this._rowStartIndex = rowStartIndex;\n        this._rowStopIndex = rowStopIndex;\n      }\n    }\n    /**\n     * Sets an :isScrolling flag for a small window of time.\n     * This flag is used to disable pointer events on the scrollable portion of the Grid.\n     * This prevents jerky/stuttery mouse-wheel scrolling.\n     */\n\n  }, {\n    key: \"_debounceScrollEnded\",\n    value: function _debounceScrollEnded() {\n      var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval;\n\n      if (this._disablePointerEventsTimeoutId) {\n        cancelAnimationTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      this._disablePointerEventsTimeoutId = requestAnimationTimeout(this._debounceScrollEndedCallback, scrollingResetTimeInterval);\n    }\n  }, {\n    key: \"_handleInvalidatedGridSize\",\n\n    /**\n     * Check for batched CellMeasurer size invalidations.\n     * This will occur the first time one or more previously unmeasured cells are rendered.\n     */\n    value: function _handleInvalidatedGridSize() {\n      if (typeof this._deferredInvalidateColumnIndex === 'number' && typeof this._deferredInvalidateRowIndex === 'number') {\n        var columnIndex = this._deferredInvalidateColumnIndex;\n        var rowIndex = this._deferredInvalidateRowIndex;\n        this._deferredInvalidateColumnIndex = null;\n        this._deferredInvalidateRowIndex = null;\n        this.recomputeGridSize({\n          columnIndex: columnIndex,\n          rowIndex: rowIndex\n        });\n      }\n    }\n  }, {\n    key: \"_invokeOnScrollMemoizer\",\n    value: function _invokeOnScrollMemoizer(_ref6) {\n      var _this3 = this;\n\n      var scrollLeft = _ref6.scrollLeft,\n          scrollTop = _ref6.scrollTop,\n          totalColumnsWidth = _ref6.totalColumnsWidth,\n          totalRowsHeight = _ref6.totalRowsHeight;\n\n      this._onScrollMemoizer({\n        callback: function callback(_ref7) {\n          var scrollLeft = _ref7.scrollLeft,\n              scrollTop = _ref7.scrollTop;\n          var _this3$props = _this3.props,\n              height = _this3$props.height,\n              onScroll = _this3$props.onScroll,\n              width = _this3$props.width;\n          onScroll({\n            clientHeight: height,\n            clientWidth: width,\n            scrollHeight: totalRowsHeight,\n            scrollLeft: scrollLeft,\n            scrollTop: scrollTop,\n            scrollWidth: totalColumnsWidth\n          });\n        },\n        indices: {\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        }\n      });\n    }\n  }, {\n    key: \"_isScrolling\",\n    value: function _isScrolling() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      // If isScrolling is defined in props, use it to override the value in state\n      // This is a performance optimization for WindowScroller + Grid\n      return Object.hasOwnProperty.call(props, 'isScrolling') ? Boolean(props.isScrolling) : Boolean(state.isScrolling);\n    }\n  }, {\n    key: \"_maybeCallOnScrollbarPresenceChange\",\n    value: function _maybeCallOnScrollbarPresenceChange() {\n      if (this._scrollbarPresenceChanged) {\n        var onScrollbarPresenceChange = this.props.onScrollbarPresenceChange;\n        this._scrollbarPresenceChanged = false;\n        onScrollbarPresenceChange({\n          horizontal: this._horizontalScrollBarSize > 0,\n          size: this.state.instanceProps.scrollbarSize,\n          vertical: this._verticalScrollBarSize > 0\n        });\n      }\n    }\n  }, {\n    key: \"scrollToPosition\",\n\n    /**\n     * Scroll to the specified offset(s).\n     * Useful for animating position changes.\n     */\n    value: function scrollToPosition(_ref8) {\n      var scrollLeft = _ref8.scrollLeft,\n          scrollTop = _ref8.scrollTop;\n\n      var stateUpdate = Grid._getScrollToPositionStateUpdate({\n        prevState: this.state,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop\n      });\n\n      if (stateUpdate) {\n        stateUpdate.needToResetStyleCache = false;\n        this.setState(stateUpdate);\n      }\n    }\n  }, {\n    key: \"_getCalculatedScrollLeft\",\n    value: function _getCalculatedScrollLeft() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      return Grid._getCalculatedScrollLeft(props, state);\n    }\n  }, {\n    key: \"_updateScrollLeftForScrollToColumn\",\n    value: function _updateScrollLeftForScrollToColumn() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n\n      var stateUpdate = Grid._getScrollLeftForScrollToColumnStateUpdate(props, state);\n\n      if (stateUpdate) {\n        stateUpdate.needToResetStyleCache = false;\n        this.setState(stateUpdate);\n      }\n    }\n  }, {\n    key: \"_getCalculatedScrollTop\",\n    value: function _getCalculatedScrollTop() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n      return Grid._getCalculatedScrollTop(props, state);\n    }\n  }, {\n    key: \"_resetStyleCache\",\n    value: function _resetStyleCache() {\n      var styleCache = this._styleCache;\n      var cellCache = this._cellCache;\n      var isScrollingOptOut = this.props.isScrollingOptOut; // Reset cell and style caches once scrolling stops.\n      // This makes Grid simpler to use (since cells commonly change).\n      // And it keeps the caches from growing too large.\n      // Performance is most sensitive when a user is scrolling.\n      // Don't clear visible cells from cellCache if isScrollingOptOut is specified.\n      // This keeps the cellCache to a resonable size.\n\n      this._cellCache = {};\n      this._styleCache = {}; // Copy over the visible cell styles so avoid unnecessary re-render.\n\n      for (var rowIndex = this._rowStartIndex; rowIndex <= this._rowStopIndex; rowIndex++) {\n        for (var columnIndex = this._columnStartIndex; columnIndex <= this._columnStopIndex; columnIndex++) {\n          var key = \"\".concat(rowIndex, \"-\").concat(columnIndex);\n          this._styleCache[key] = styleCache[key];\n\n          if (isScrollingOptOut) {\n            this._cellCache[key] = cellCache[key];\n          }\n        }\n      }\n    }\n  }, {\n    key: \"_updateScrollTopForScrollToRow\",\n    value: function _updateScrollTopForScrollToRow() {\n      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;\n      var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state;\n\n      var stateUpdate = Grid._getScrollTopForScrollToRowStateUpdate(props, state);\n\n      if (stateUpdate) {\n        stateUpdate.needToResetStyleCache = false;\n        this.setState(stateUpdate);\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      var newState = {};\n\n      if (nextProps.columnCount === 0 && prevState.scrollLeft !== 0 || nextProps.rowCount === 0 && prevState.scrollTop !== 0) {\n        newState.scrollLeft = 0;\n        newState.scrollTop = 0; // only use scroll{Left,Top} from props if scrollTo{Column,Row} isn't specified\n        // scrollTo{Column,Row} should override scroll{Left,Top}\n      } else if (nextProps.scrollLeft !== prevState.scrollLeft && nextProps.scrollToColumn < 0 || nextProps.scrollTop !== prevState.scrollTop && nextProps.scrollToRow < 0) {\n        Object.assign(newState, Grid._getScrollToPositionStateUpdate({\n          prevState: prevState,\n          scrollLeft: nextProps.scrollLeft,\n          scrollTop: nextProps.scrollTop\n        }));\n      }\n\n      var instanceProps = prevState.instanceProps; // Initially we should not clearStyleCache\n\n      newState.needToResetStyleCache = false;\n\n      if (nextProps.columnWidth !== instanceProps.prevColumnWidth || nextProps.rowHeight !== instanceProps.prevRowHeight) {\n        // Reset cache. set it to {} in render\n        newState.needToResetStyleCache = true;\n      }\n\n      instanceProps.columnSizeAndPositionManager.configure({\n        cellCount: nextProps.columnCount,\n        estimatedCellSize: Grid._getEstimatedColumnSize(nextProps),\n        cellSizeGetter: Grid._wrapSizeGetter(nextProps.columnWidth)\n      });\n      instanceProps.rowSizeAndPositionManager.configure({\n        cellCount: nextProps.rowCount,\n        estimatedCellSize: Grid._getEstimatedRowSize(nextProps),\n        cellSizeGetter: Grid._wrapSizeGetter(nextProps.rowHeight)\n      });\n\n      if (instanceProps.prevColumnCount === 0 || instanceProps.prevRowCount === 0) {\n        instanceProps.prevColumnCount = 0;\n        instanceProps.prevRowCount = 0;\n      } // If scrolling is controlled outside this component, clear cache when scrolling stops\n\n\n      if (nextProps.autoHeight && nextProps.isScrolling === false && instanceProps.prevIsScrolling === true) {\n        Object.assign(newState, {\n          isScrolling: false\n        });\n      }\n\n      var maybeStateA;\n      var maybeStateB;\n      calculateSizeAndPositionDataAndUpdateScrollOffset({\n        cellCount: instanceProps.prevColumnCount,\n        cellSize: typeof instanceProps.prevColumnWidth === 'number' ? instanceProps.prevColumnWidth : null,\n        computeMetadataCallback: function computeMetadataCallback() {\n          return instanceProps.columnSizeAndPositionManager.resetCell(0);\n        },\n        computeMetadataCallbackProps: nextProps,\n        nextCellsCount: nextProps.columnCount,\n        nextCellSize: typeof nextProps.columnWidth === 'number' ? nextProps.columnWidth : null,\n        nextScrollToIndex: nextProps.scrollToColumn,\n        scrollToIndex: instanceProps.prevScrollToColumn,\n        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {\n          maybeStateA = Grid._getScrollLeftForScrollToColumnStateUpdate(nextProps, prevState);\n        }\n      });\n      calculateSizeAndPositionDataAndUpdateScrollOffset({\n        cellCount: instanceProps.prevRowCount,\n        cellSize: typeof instanceProps.prevRowHeight === 'number' ? instanceProps.prevRowHeight : null,\n        computeMetadataCallback: function computeMetadataCallback() {\n          return instanceProps.rowSizeAndPositionManager.resetCell(0);\n        },\n        computeMetadataCallbackProps: nextProps,\n        nextCellsCount: nextProps.rowCount,\n        nextCellSize: typeof nextProps.rowHeight === 'number' ? nextProps.rowHeight : null,\n        nextScrollToIndex: nextProps.scrollToRow,\n        scrollToIndex: instanceProps.prevScrollToRow,\n        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {\n          maybeStateB = Grid._getScrollTopForScrollToRowStateUpdate(nextProps, prevState);\n        }\n      });\n      instanceProps.prevColumnCount = nextProps.columnCount;\n      instanceProps.prevColumnWidth = nextProps.columnWidth;\n      instanceProps.prevIsScrolling = nextProps.isScrolling === true;\n      instanceProps.prevRowCount = nextProps.rowCount;\n      instanceProps.prevRowHeight = nextProps.rowHeight;\n      instanceProps.prevScrollToColumn = nextProps.scrollToColumn;\n      instanceProps.prevScrollToRow = nextProps.scrollToRow; // getting scrollBarSize (moved from componentWillMount)\n\n      instanceProps.scrollbarSize = nextProps.getScrollbarSize();\n\n      if (instanceProps.scrollbarSize === undefined) {\n        instanceProps.scrollbarSizeMeasured = false;\n        instanceProps.scrollbarSize = 0;\n      } else {\n        instanceProps.scrollbarSizeMeasured = true;\n      }\n\n      newState.instanceProps = instanceProps;\n      return _objectSpread({}, newState, {}, maybeStateA, {}, maybeStateB);\n    }\n  }, {\n    key: \"_getEstimatedColumnSize\",\n    value: function _getEstimatedColumnSize(props) {\n      return typeof props.columnWidth === 'number' ? props.columnWidth : props.estimatedColumnSize;\n    }\n  }, {\n    key: \"_getEstimatedRowSize\",\n    value: function _getEstimatedRowSize(props) {\n      return typeof props.rowHeight === 'number' ? props.rowHeight : props.estimatedRowSize;\n    }\n  }, {\n    key: \"_getScrollToPositionStateUpdate\",\n\n    /**\n     * Get the updated state after scrolling to\n     * scrollLeft and scrollTop\n     */\n    value: function _getScrollToPositionStateUpdate(_ref9) {\n      var prevState = _ref9.prevState,\n          scrollLeft = _ref9.scrollLeft,\n          scrollTop = _ref9.scrollTop;\n      var newState = {\n        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n      };\n\n      if (typeof scrollLeft === 'number' && scrollLeft >= 0) {\n        newState.scrollDirectionHorizontal = scrollLeft > prevState.scrollLeft ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD;\n        newState.scrollLeft = scrollLeft;\n      }\n\n      if (typeof scrollTop === 'number' && scrollTop >= 0) {\n        newState.scrollDirectionVertical = scrollTop > prevState.scrollTop ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_BACKWARD;\n        newState.scrollTop = scrollTop;\n      }\n\n      if (typeof scrollLeft === 'number' && scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft || typeof scrollTop === 'number' && scrollTop >= 0 && scrollTop !== prevState.scrollTop) {\n        return newState;\n      }\n\n      return {};\n    }\n  }, {\n    key: \"_wrapSizeGetter\",\n    value: function _wrapSizeGetter(value) {\n      return typeof value === 'function' ? value : function () {\n        return value;\n      };\n    }\n  }, {\n    key: \"_getCalculatedScrollLeft\",\n    value: function _getCalculatedScrollLeft(nextProps, prevState) {\n      var columnCount = nextProps.columnCount,\n          height = nextProps.height,\n          scrollToAlignment = nextProps.scrollToAlignment,\n          scrollToColumn = nextProps.scrollToColumn,\n          width = nextProps.width;\n      var scrollLeft = prevState.scrollLeft,\n          instanceProps = prevState.instanceProps;\n\n      if (columnCount > 0) {\n        var finalColumn = columnCount - 1;\n        var targetIndex = scrollToColumn < 0 ? finalColumn : Math.min(finalColumn, scrollToColumn);\n        var totalRowsHeight = instanceProps.rowSizeAndPositionManager.getTotalSize();\n        var scrollBarSize = instanceProps.scrollbarSizeMeasured && totalRowsHeight > height ? instanceProps.scrollbarSize : 0;\n        return instanceProps.columnSizeAndPositionManager.getUpdatedOffsetForIndex({\n          align: scrollToAlignment,\n          containerSize: width - scrollBarSize,\n          currentOffset: scrollLeft,\n          targetIndex: targetIndex\n        });\n      }\n\n      return 0;\n    }\n  }, {\n    key: \"_getScrollLeftForScrollToColumnStateUpdate\",\n    value: function _getScrollLeftForScrollToColumnStateUpdate(nextProps, prevState) {\n      var scrollLeft = prevState.scrollLeft;\n\n      var calculatedScrollLeft = Grid._getCalculatedScrollLeft(nextProps, prevState);\n\n      if (typeof calculatedScrollLeft === 'number' && calculatedScrollLeft >= 0 && scrollLeft !== calculatedScrollLeft) {\n        return Grid._getScrollToPositionStateUpdate({\n          prevState: prevState,\n          scrollLeft: calculatedScrollLeft,\n          scrollTop: -1\n        });\n      }\n\n      return {};\n    }\n  }, {\n    key: \"_getCalculatedScrollTop\",\n    value: function _getCalculatedScrollTop(nextProps, prevState) {\n      var height = nextProps.height,\n          rowCount = nextProps.rowCount,\n          scrollToAlignment = nextProps.scrollToAlignment,\n          scrollToRow = nextProps.scrollToRow,\n          width = nextProps.width;\n      var scrollTop = prevState.scrollTop,\n          instanceProps = prevState.instanceProps;\n\n      if (rowCount > 0) {\n        var finalRow = rowCount - 1;\n        var targetIndex = scrollToRow < 0 ? finalRow : Math.min(finalRow, scrollToRow);\n        var totalColumnsWidth = instanceProps.columnSizeAndPositionManager.getTotalSize();\n        var scrollBarSize = instanceProps.scrollbarSizeMeasured && totalColumnsWidth > width ? instanceProps.scrollbarSize : 0;\n        return instanceProps.rowSizeAndPositionManager.getUpdatedOffsetForIndex({\n          align: scrollToAlignment,\n          containerSize: height - scrollBarSize,\n          currentOffset: scrollTop,\n          targetIndex: targetIndex\n        });\n      }\n\n      return 0;\n    }\n  }, {\n    key: \"_getScrollTopForScrollToRowStateUpdate\",\n    value: function _getScrollTopForScrollToRowStateUpdate(nextProps, prevState) {\n      var scrollTop = prevState.scrollTop;\n\n      var calculatedScrollTop = Grid._getCalculatedScrollTop(nextProps, prevState);\n\n      if (typeof calculatedScrollTop === 'number' && calculatedScrollTop >= 0 && scrollTop !== calculatedScrollTop) {\n        return Grid._getScrollToPositionStateUpdate({\n          prevState: prevState,\n          scrollLeft: -1,\n          scrollTop: calculatedScrollTop\n        });\n      }\n\n      return {};\n    }\n  }]);\n\n  return Grid;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"aria-label\": PropTypes.string.isRequired,\n  \"aria-readonly\": PropTypes.bool,\n\n  /**\n   * Set the width of the inner scrollable container to 'auto'.\n   * This is useful for single-column Grids to ensure that the column doesn't extend below a vertical scrollbar.\n   */\n  \"autoContainerWidth\": PropTypes.bool.isRequired,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height of rows can stretch the window.\n   * Intended for use with WindowScroller\n   */\n  \"autoHeight\": PropTypes.bool.isRequired,\n\n  /**\n   * Removes fixed width from the scrollingContainer so that the total width of rows can stretch the window.\n   * Intended for use with WindowScroller\n   */\n  \"autoWidth\": PropTypes.bool.isRequired,\n\n  /** Responsible for rendering a cell given an row and column index.  */\n  \"cellRenderer\": function cellRenderer() {\n    return (typeof bpfrpt_proptype_CellRenderer === \"function\" ? bpfrpt_proptype_CellRenderer.isRequired ? bpfrpt_proptype_CellRenderer.isRequired : bpfrpt_proptype_CellRenderer : PropTypes.shape(bpfrpt_proptype_CellRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Responsible for rendering a group of cells given their index ranges.  */\n  \"cellRangeRenderer\": function cellRangeRenderer() {\n    return (typeof bpfrpt_proptype_CellRangeRenderer === \"function\" ? bpfrpt_proptype_CellRangeRenderer.isRequired ? bpfrpt_proptype_CellRangeRenderer.isRequired : bpfrpt_proptype_CellRangeRenderer : PropTypes.shape(bpfrpt_proptype_CellRangeRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Optional custom CSS class name to attach to root Grid element.  */\n  \"className\": PropTypes.string,\n\n  /** Number of columns in grid.  */\n  \"columnCount\": PropTypes.number.isRequired,\n\n  /** Either a fixed column width (number) or a function that returns the width of a column given its index.  */\n  \"columnWidth\": function columnWidth() {\n    return (typeof bpfrpt_proptype_CellSize === \"function\" ? bpfrpt_proptype_CellSize.isRequired ? bpfrpt_proptype_CellSize.isRequired : bpfrpt_proptype_CellSize : PropTypes.shape(bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Unfiltered props for the Grid container. */\n  \"containerProps\": PropTypes.object,\n\n  /** ARIA role for the cell-container.  */\n  \"containerRole\": PropTypes.string.isRequired,\n\n  /** Optional inline style applied to inner cell-container */\n  \"containerStyle\": PropTypes.object.isRequired,\n\n  /**\n   * If CellMeasurer is used to measure this Grid's children, this should be a pointer to its CellMeasurerCache.\n   * A shared CellMeasurerCache reference enables Grid and CellMeasurer to share measurement data.\n   */\n  \"deferredMeasurementCache\": PropTypes.object,\n\n  /**\n   * Used to estimate the total width of a Grid before all of its columns have actually been measured.\n   * The estimated total width is adjusted as columns are rendered.\n   */\n  \"estimatedColumnSize\": PropTypes.number.isRequired,\n\n  /**\n   * Used to estimate the total height of a Grid before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  \"estimatedRowSize\": PropTypes.number.isRequired,\n\n  /** Exposed for testing purposes only.  */\n  \"getScrollbarSize\": PropTypes.func.isRequired,\n\n  /** Height of Grid; this property determines the number of visible (vs virtualized) rows.  */\n  \"height\": PropTypes.number.isRequired,\n\n  /** Optional custom id to attach to root Grid element.  */\n  \"id\": PropTypes.string,\n\n  /**\n   * Override internal is-scrolling state tracking.\n   * This property is primarily intended for use with the WindowScroller component.\n   */\n  \"isScrolling\": PropTypes.bool,\n\n  /**\n   * Opt-out of isScrolling param passed to cellRangeRenderer.\n   * To avoid the extra render when scroll stops.\n   */\n  \"isScrollingOptOut\": PropTypes.bool.isRequired,\n\n  /** Optional renderer to be used in place of rows when either :rowCount or :columnCount is 0.  */\n  \"noContentRenderer\": function noContentRenderer() {\n    return (typeof bpfrpt_proptype_NoContentRenderer === \"function\" ? bpfrpt_proptype_NoContentRenderer.isRequired ? bpfrpt_proptype_NoContentRenderer.isRequired : bpfrpt_proptype_NoContentRenderer : PropTypes.shape(bpfrpt_proptype_NoContentRenderer).isRequired).apply(this, arguments);\n  },\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   */\n  \"onScroll\": PropTypes.func.isRequired,\n\n  /**\n   * Called whenever a horizontal or vertical scrollbar is added or removed.\n   * This prop is not intended for end-user use;\n   * It is used by MultiGrid to support fixed-row/fixed-column scroll syncing.\n   */\n  \"onScrollbarPresenceChange\": PropTypes.func.isRequired,\n\n  /** Callback invoked with information about the section of the Grid that was just rendered.  */\n  \"onSectionRendered\": PropTypes.func.isRequired,\n\n  /**\n   * Number of columns to render before/after the visible section of the grid.\n   * These columns can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.\n   */\n  \"overscanColumnCount\": PropTypes.number.isRequired,\n\n  /**\n   * Calculates the number of cells to overscan before and after a specified range.\n   * This function ensures that overscanning doesn't exceed the available cells.\n   */\n  \"overscanIndicesGetter\": function overscanIndicesGetter() {\n    return (typeof bpfrpt_proptype_OverscanIndicesGetter === \"function\" ? bpfrpt_proptype_OverscanIndicesGetter.isRequired ? bpfrpt_proptype_OverscanIndicesGetter.isRequired : bpfrpt_proptype_OverscanIndicesGetter : PropTypes.shape(bpfrpt_proptype_OverscanIndicesGetter).isRequired).apply(this, arguments);\n  },\n\n  /**\n   * Number of rows to render above/below the visible section of the grid.\n   * These rows can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.\n   */\n  \"overscanRowCount\": PropTypes.number.isRequired,\n\n  /** ARIA role for the grid element.  */\n  \"role\": PropTypes.string.isRequired,\n\n  /**\n   * Either a fixed row height (number) or a function that returns the height of a row given its index.\n   * Should implement the following interface: ({ index: number }): number\n   */\n  \"rowHeight\": function rowHeight() {\n    return (typeof bpfrpt_proptype_CellSize === \"function\" ? bpfrpt_proptype_CellSize.isRequired ? bpfrpt_proptype_CellSize.isRequired : bpfrpt_proptype_CellSize : PropTypes.shape(bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Number of rows in grid.  */\n  \"rowCount\": PropTypes.number.isRequired,\n\n  /** Wait this amount of time after the last scroll event before resetting Grid `pointer-events`. */\n  \"scrollingResetTimeInterval\": PropTypes.number.isRequired,\n\n  /** Horizontal offset. */\n  \"scrollLeft\": PropTypes.number,\n\n  /**\n   * Controls scroll-to-cell behavior of the Grid.\n   * The default (\"auto\") scrolls the least amount possible to ensure that the specified cell is fully visible.\n   * Use \"start\" to align cells to the top/left of the Grid and \"end\" to align bottom/right.\n   */\n  \"scrollToAlignment\": function scrollToAlignment() {\n    return (typeof bpfrpt_proptype_Alignment === \"function\" ? bpfrpt_proptype_Alignment.isRequired ? bpfrpt_proptype_Alignment.isRequired : bpfrpt_proptype_Alignment : PropTypes.shape(bpfrpt_proptype_Alignment).isRequired).apply(this, arguments);\n  },\n\n  /** Column index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToColumn\": PropTypes.number.isRequired,\n\n  /** Vertical offset. */\n  \"scrollTop\": PropTypes.number,\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToRow\": PropTypes.number.isRequired,\n\n  /** Optional inline style */\n  \"style\": PropTypes.object.isRequired,\n\n  /** Tab index for focus */\n  \"tabIndex\": PropTypes.number,\n\n  /** Width of Grid; this property determines the number of visible (vs virtualized) columns.  */\n  \"width\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(Grid, \"defaultProps\", {\n  'aria-label': 'grid',\n  'aria-readonly': true,\n  autoContainerWidth: false,\n  autoHeight: false,\n  autoWidth: false,\n  cellRangeRenderer: defaultCellRangeRenderer,\n  containerRole: 'rowgroup',\n  containerStyle: {},\n  estimatedColumnSize: 100,\n  estimatedRowSize: 30,\n  getScrollbarSize: scrollbarSize,\n  noContentRenderer: renderNull,\n  onScroll: function onScroll() {},\n  onScrollbarPresenceChange: function onScrollbarPresenceChange() {},\n  onSectionRendered: function onSectionRendered() {},\n  overscanColumnCount: 0,\n  overscanIndicesGetter: defaultOverscanIndicesGetter,\n  overscanRowCount: 10,\n  role: 'grid',\n  scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL,\n  scrollToAlignment: 'auto',\n  scrollToColumn: -1,\n  scrollToRow: -1,\n  style: {},\n  tabIndex: 0,\n  isScrollingOptOut: false\n});\n\npolyfill(Grid);\nexport default Grid;\nimport { bpfrpt_proptype_CellRenderer } from \"./types\";\nimport { bpfrpt_proptype_CellRangeRenderer } from \"./types\";\nimport { bpfrpt_proptype_CellPosition } from \"./types\";\nimport { bpfrpt_proptype_CellSize } from \"./types\";\nimport { bpfrpt_proptype_CellSizeGetter } from \"./types\";\nimport { bpfrpt_proptype_NoContentRenderer } from \"./types\";\nimport { bpfrpt_proptype_Scroll } from \"./types\";\nimport { bpfrpt_proptype_ScrollbarPresenceChange } from \"./types\";\nimport { bpfrpt_proptype_RenderedSection } from \"./types\";\nimport { bpfrpt_proptype_OverscanIndicesGetter } from \"./types\";\nimport { bpfrpt_proptype_Alignment } from \"./types\";\nimport { bpfrpt_proptype_CellCache } from \"./types\";\nimport { bpfrpt_proptype_StyleCache } from \"./types\";\nimport { bpfrpt_proptype_AnimationTimeoutId } from \"../utils/requestAnimationTimeout\";\nimport PropTypes from \"prop-types\";","import { caf, raf } from './animationFrame';\nvar bpfrpt_proptype_AnimationTimeoutId = process.env.NODE_ENV === 'production' ? null : {\n  \"id\": PropTypes.number.isRequired\n};\nexport var cancelAnimationTimeout = function cancelAnimationTimeout(frame) {\n  return caf(frame.id);\n};\n/**\n * Recursively calls requestAnimationFrame until a specified delay has been met or exceeded.\n * When the delay time has been reached the function you're timing out will be called.\n *\n * Credit: Joe Lambert (https://gist.github.com/joelambert/1002116#file-requesttimeout-js)\n */\n\nexport var requestAnimationTimeout = function requestAnimationTimeout(callback, delay) {\n  var start; // wait for end of processing current event handler, because event handler may be long\n\n  Promise.resolve().then(function () {\n    start = Date.now();\n  });\n\n  var timeout = function timeout() {\n    if (Date.now() - start >= delay) {\n      callback.call();\n    } else {\n      frame.id = raf(timeout);\n    }\n  };\n\n  var frame = {\n    id: raf(timeout)\n  };\n  return frame;\n};\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_AnimationTimeoutId };","export var SCROLL_DIRECTION_BACKWARD = -1;\nexport var SCROLL_DIRECTION_FORWARD = 1;\nexport var SCROLL_DIRECTION_HORIZONTAL = 'horizontal';\nexport var SCROLL_DIRECTION_VERTICAL = 'vertical';\n/**\n * Calculates the number of cells to overscan before and after a specified range.\n * This function ensures that overscanning doesn't exceed the available cells.\n */\n\nexport default function defaultOverscanIndicesGetter(_ref) {\n  var cellCount = _ref.cellCount,\n      overscanCellsCount = _ref.overscanCellsCount,\n      scrollDirection = _ref.scrollDirection,\n      startIndex = _ref.startIndex,\n      stopIndex = _ref.stopIndex;\n  // Make sure we render at least 1 cell extra before and after (except near boundaries)\n  // This is necessary in order to support keyboard navigation (TAB/SHIFT+TAB) in some cases\n  // For more info see issues #625\n  overscanCellsCount = Math.max(1, overscanCellsCount);\n\n  if (scrollDirection === SCROLL_DIRECTION_FORWARD) {\n    return {\n      overscanStartIndex: Math.max(0, startIndex - 1),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)\n    };\n  } else {\n    return {\n      overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),\n      overscanStopIndex: Math.min(cellCount - 1, stopIndex + 1)\n    };\n  }\n}\nimport { bpfrpt_proptype_OverscanIndicesGetterParams } from \"./types\";\nimport { bpfrpt_proptype_OverscanIndices } from \"./types\";","var bpfrpt_proptype_ScrollIndices = process.env.NODE_ENV === 'production' ? null : {\n  \"scrollToColumn\": PropTypes.number.isRequired,\n  \"scrollToRow\": PropTypes.number.isRequired\n};\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_ScrollIndices };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\n/**\n * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time.\n */\n\nvar ArrowKeyStepper = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(ArrowKeyStepper, _React$PureComponent);\n\n  function ArrowKeyStepper() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, ArrowKeyStepper);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ArrowKeyStepper)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      scrollToColumn: 0,\n      scrollToRow: 0,\n      instanceProps: {\n        prevScrollToColumn: 0,\n        prevScrollToRow: 0\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStartIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowStopIndex\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_onKeyDown\", function (event) {\n      var _this$props = _this.props,\n          columnCount = _this$props.columnCount,\n          disabled = _this$props.disabled,\n          mode = _this$props.mode,\n          rowCount = _this$props.rowCount;\n\n      if (disabled) {\n        return;\n      }\n\n      var _this$_getScrollState = _this._getScrollState(),\n          scrollToColumnPrevious = _this$_getScrollState.scrollToColumn,\n          scrollToRowPrevious = _this$_getScrollState.scrollToRow;\n\n      var _this$_getScrollState2 = _this._getScrollState(),\n          scrollToColumn = _this$_getScrollState2.scrollToColumn,\n          scrollToRow = _this$_getScrollState2.scrollToRow; // The above cases all prevent default event event behavior.\n      // This is to keep the grid from scrolling after the snap-to update.\n\n\n      switch (event.key) {\n        case 'ArrowDown':\n          scrollToRow = mode === 'cells' ? Math.min(scrollToRow + 1, rowCount - 1) : Math.min(_this._rowStopIndex + 1, rowCount - 1);\n          break;\n\n        case 'ArrowLeft':\n          scrollToColumn = mode === 'cells' ? Math.max(scrollToColumn - 1, 0) : Math.max(_this._columnStartIndex - 1, 0);\n          break;\n\n        case 'ArrowRight':\n          scrollToColumn = mode === 'cells' ? Math.min(scrollToColumn + 1, columnCount - 1) : Math.min(_this._columnStopIndex + 1, columnCount - 1);\n          break;\n\n        case 'ArrowUp':\n          scrollToRow = mode === 'cells' ? Math.max(scrollToRow - 1, 0) : Math.max(_this._rowStartIndex - 1, 0);\n          break;\n      }\n\n      if (scrollToColumn !== scrollToColumnPrevious || scrollToRow !== scrollToRowPrevious) {\n        event.preventDefault();\n\n        _this._updateScrollState({\n          scrollToColumn: scrollToColumn,\n          scrollToRow: scrollToRow\n        });\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onSectionRendered\", function (_ref) {\n      var columnStartIndex = _ref.columnStartIndex,\n          columnStopIndex = _ref.columnStopIndex,\n          rowStartIndex = _ref.rowStartIndex,\n          rowStopIndex = _ref.rowStopIndex;\n      _this._columnStartIndex = columnStartIndex;\n      _this._columnStopIndex = columnStopIndex;\n      _this._rowStartIndex = rowStartIndex;\n      _this._rowStopIndex = rowStopIndex;\n    });\n\n    return _this;\n  }\n\n  _createClass(ArrowKeyStepper, [{\n    key: \"setScrollIndexes\",\n    value: function setScrollIndexes(_ref2) {\n      var scrollToColumn = _ref2.scrollToColumn,\n          scrollToRow = _ref2.scrollToRow;\n      this.setState({\n        scrollToRow: scrollToRow,\n        scrollToColumn: scrollToColumn\n      });\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props2 = this.props,\n          className = _this$props2.className,\n          children = _this$props2.children;\n\n      var _this$_getScrollState3 = this._getScrollState(),\n          scrollToColumn = _this$_getScrollState3.scrollToColumn,\n          scrollToRow = _this$_getScrollState3.scrollToRow;\n\n      return React.createElement(\"div\", {\n        className: className,\n        onKeyDown: this._onKeyDown\n      }, children({\n        onSectionRendered: this._onSectionRendered,\n        scrollToColumn: scrollToColumn,\n        scrollToRow: scrollToRow\n      }));\n    }\n  }, {\n    key: \"_getScrollState\",\n    value: function _getScrollState() {\n      return this.props.isControlled ? this.props : this.state;\n    }\n  }, {\n    key: \"_updateScrollState\",\n    value: function _updateScrollState(_ref3) {\n      var scrollToColumn = _ref3.scrollToColumn,\n          scrollToRow = _ref3.scrollToRow;\n      var _this$props3 = this.props,\n          isControlled = _this$props3.isControlled,\n          onScrollToChange = _this$props3.onScrollToChange;\n\n      if (typeof onScrollToChange === 'function') {\n        onScrollToChange({\n          scrollToColumn: scrollToColumn,\n          scrollToRow: scrollToRow\n        });\n      }\n\n      if (!isControlled) {\n        this.setState({\n          scrollToColumn: scrollToColumn,\n          scrollToRow: scrollToRow\n        });\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.isControlled) {\n        return {};\n      }\n\n      if (nextProps.scrollToColumn !== prevState.instanceProps.prevScrollToColumn || nextProps.scrollToRow !== prevState.instanceProps.prevScrollToRow) {\n        return _objectSpread({}, prevState, {\n          scrollToColumn: nextProps.scrollToColumn,\n          scrollToRow: nextProps.scrollToRow,\n          instanceProps: {\n            prevScrollToColumn: nextProps.scrollToColumn,\n            prevScrollToRow: nextProps.scrollToRow\n          }\n        });\n      }\n\n      return {};\n    }\n  }]);\n\n  return ArrowKeyStepper;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"children\": PropTypes.func.isRequired,\n  \"className\": PropTypes.string,\n  \"columnCount\": PropTypes.number.isRequired,\n  \"disabled\": PropTypes.bool.isRequired,\n  \"isControlled\": PropTypes.bool.isRequired,\n  \"mode\": PropTypes.oneOf([\"cells\", \"edges\"]).isRequired,\n  \"onScrollToChange\": PropTypes.func,\n  \"rowCount\": PropTypes.number.isRequired,\n  \"scrollToColumn\": PropTypes.number.isRequired,\n  \"scrollToRow\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(ArrowKeyStepper, \"defaultProps\", {\n  disabled: false,\n  isControlled: false,\n  mode: 'edges',\n  scrollToColumn: 0,\n  scrollToRow: 0\n});\n\npolyfill(ArrowKeyStepper);\nexport default ArrowKeyStepper;\nimport { bpfrpt_proptype_RenderedSection } from \"../Grid\";\nimport { bpfrpt_proptype_ScrollIndices } from \"./types\";\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport createDetectElementResize from '../vendor/detectElementResize';\nvar AutoSizer = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inherits(AutoSizer, _React$Component);\n\n  function AutoSizer() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, AutoSizer);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AutoSizer)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      height: _this.props.defaultHeight || 0,\n      width: _this.props.defaultWidth || 0\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_parentNode\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_autoSizer\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_window\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_detectElementResize\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_onResize\", function () {\n      var _this$props = _this.props,\n          disableHeight = _this$props.disableHeight,\n          disableWidth = _this$props.disableWidth,\n          onResize = _this$props.onResize;\n\n      if (_this._parentNode) {\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        var height = _this._parentNode.offsetHeight || 0;\n        var width = _this._parentNode.offsetWidth || 0;\n        var win = _this._window || window;\n        var style = win.getComputedStyle(_this._parentNode) || {};\n        var paddingLeft = parseInt(style.paddingLeft, 10) || 0;\n        var paddingRight = parseInt(style.paddingRight, 10) || 0;\n        var paddingTop = parseInt(style.paddingTop, 10) || 0;\n        var paddingBottom = parseInt(style.paddingBottom, 10) || 0;\n        var newHeight = height - paddingTop - paddingBottom;\n        var newWidth = width - paddingLeft - paddingRight;\n\n        if (!disableHeight && _this.state.height !== newHeight || !disableWidth && _this.state.width !== newWidth) {\n          _this.setState({\n            height: height - paddingTop - paddingBottom,\n            width: width - paddingLeft - paddingRight\n          });\n\n          onResize({\n            height: height,\n            width: width\n          });\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setRef\", function (autoSizer) {\n      _this._autoSizer = autoSizer;\n    });\n\n    return _this;\n  }\n\n  _createClass(AutoSizer, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var nonce = this.props.nonce;\n\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        this._window = this._autoSizer.parentNode.ownerDocument.defaultView; // Defer requiring resize handler in order to support server-side rendering.\n        // See issue #41\n\n        this._detectElementResize = createDetectElementResize(nonce, this._window);\n\n        this._detectElementResize.addResizeListener(this._parentNode, this._onResize);\n\n        this._onResize();\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._detectElementResize && this._parentNode) {\n        this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props2 = this.props,\n          children = _this$props2.children,\n          className = _this$props2.className,\n          disableHeight = _this$props2.disableHeight,\n          disableWidth = _this$props2.disableWidth,\n          style = _this$props2.style;\n      var _this$state = this.state,\n          height = _this$state.height,\n          width = _this$state.width; // 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\n      var outerStyle = {\n        overflow: 'visible'\n      };\n      var childParams = {};\n\n      if (!disableHeight) {\n        outerStyle.height = 0;\n        childParams.height = height;\n      }\n\n      if (!disableWidth) {\n        outerStyle.width = 0;\n        childParams.width = width;\n      }\n      /**\n       * TODO: Avoid rendering children before the initial measurements have been collected.\n       * At best this would just be wasting cycles.\n       * Add this check into version 10 though as it could break too many ref callbacks in version 9.\n       * Note that if default width/height props were provided this would still work with SSR.\n      if (\n        height !== 0 &&\n        width !== 0\n      ) {\n        child = children({ height, width })\n      }\n      */\n\n\n      return React.createElement(\"div\", {\n        className: className,\n        ref: this._setRef,\n        style: _objectSpread({}, outerStyle, {}, style)\n      }, children(childParams));\n    }\n  }]);\n\n  return AutoSizer;\n}(React.Component), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  /** Function responsible for rendering children.*/\n  \"children\": PropTypes.func.isRequired,\n\n  /** Optional custom CSS class name to attach to root AutoSizer element.  */\n  \"className\": PropTypes.string,\n\n  /** Default height to use for initial render; useful for SSR */\n  \"defaultHeight\": PropTypes.number,\n\n  /** Default width to use for initial render; useful for SSR */\n  \"defaultWidth\": PropTypes.number,\n\n  /** Disable dynamic :height property */\n  \"disableHeight\": PropTypes.bool.isRequired,\n\n  /** Disable dynamic :width property */\n  \"disableWidth\": PropTypes.bool.isRequired,\n\n  /** Nonce of the inlined stylesheet for Content Security Policy */\n  \"nonce\": PropTypes.string,\n\n  /** Callback to be invoked on-resize */\n  \"onResize\": PropTypes.func.isRequired,\n\n  /** Optional inline style */\n  \"style\": PropTypes.object\n}), _temp);\n\n_defineProperty(AutoSizer, \"defaultProps\", {\n  onResize: function onResize() {},\n  disableHeight: false,\n  disableWidth: false,\n  style: {}\n});\n\nexport { AutoSizer as default };\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nimport * as React from 'react';\nimport { findDOMNode } from 'react-dom';\n\n/**\n * Wraps a cell and measures its rendered content.\n * Measurements are stored in a per-cell cache.\n * Cached-content is not be re-measured.\n */\nvar CellMeasurer = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(CellMeasurer, _React$PureComponent);\n\n  function CellMeasurer() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, CellMeasurer);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CellMeasurer)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"_child\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_measure\", function () {\n      var _this$props = _this.props,\n          cache = _this$props.cache,\n          _this$props$columnInd = _this$props.columnIndex,\n          columnIndex = _this$props$columnInd === void 0 ? 0 : _this$props$columnInd,\n          parent = _this$props.parent,\n          _this$props$rowIndex = _this$props.rowIndex,\n          rowIndex = _this$props$rowIndex === void 0 ? _this.props.index || 0 : _this$props$rowIndex;\n\n      var _this$_getCellMeasure = _this._getCellMeasurements(),\n          height = _this$_getCellMeasure.height,\n          width = _this$_getCellMeasure.width;\n\n      if (height !== cache.getHeight(rowIndex, columnIndex) || width !== cache.getWidth(rowIndex, columnIndex)) {\n        cache.set(rowIndex, columnIndex, width, height);\n\n        if (parent && typeof parent.recomputeGridSize === 'function') {\n          parent.recomputeGridSize({\n            columnIndex: columnIndex,\n            rowIndex: rowIndex\n          });\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_registerChild\", function (element) {\n      if (element && !(element instanceof Element)) {\n        console.warn('CellMeasurer registerChild expects to be passed Element or null');\n      }\n\n      _this._child = element;\n\n      if (element) {\n        _this._maybeMeasureCell();\n      }\n    });\n\n    return _this;\n  }\n\n  _createClass(CellMeasurer, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._maybeMeasureCell();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate() {\n      this._maybeMeasureCell();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      return typeof children === 'function' ? children({\n        measure: this._measure,\n        registerChild: this._registerChild\n      }) : children;\n    }\n  }, {\n    key: \"_getCellMeasurements\",\n    value: function _getCellMeasurements() {\n      var cache = this.props.cache;\n      var node = this._child || findDOMNode(this); // TODO Check for a bad combination of fixedWidth and missing numeric width or vice versa with height\n\n      if (node && node.ownerDocument && node.ownerDocument.defaultView && node instanceof node.ownerDocument.defaultView.HTMLElement) {\n        var styleWidth = node.style.width;\n        var styleHeight = node.style.height; // If we are re-measuring a cell that has already been measured,\n        // It will have a hard-coded width/height from the previous measurement.\n        // The fact that we are measuring indicates this measurement is probably stale,\n        // So explicitly clear it out (eg set to \"auto\") so we can recalculate.\n        // See issue #593 for more info.\n        // Even if we are measuring initially- if we're inside of a MultiGrid component,\n        // Explicitly clear width/height before measuring to avoid being tainted by another Grid.\n        // eg top/left Grid renders before bottom/right Grid\n        // Since the CellMeasurerCache is shared between them this taints derived cell size values.\n\n        if (!cache.hasFixedWidth()) {\n          node.style.width = 'auto';\n        }\n\n        if (!cache.hasFixedHeight()) {\n          node.style.height = 'auto';\n        }\n\n        var height = Math.ceil(node.offsetHeight);\n        var width = Math.ceil(node.offsetWidth); // Reset after measuring to avoid breaking styles; see #660\n\n        if (styleWidth) {\n          node.style.width = styleWidth;\n        }\n\n        if (styleHeight) {\n          node.style.height = styleHeight;\n        }\n\n        return {\n          height: height,\n          width: width\n        };\n      } else {\n        return {\n          height: 0,\n          width: 0\n        };\n      }\n    }\n  }, {\n    key: \"_maybeMeasureCell\",\n    value: function _maybeMeasureCell() {\n      var _this$props2 = this.props,\n          cache = _this$props2.cache,\n          _this$props2$columnIn = _this$props2.columnIndex,\n          columnIndex = _this$props2$columnIn === void 0 ? 0 : _this$props2$columnIn,\n          parent = _this$props2.parent,\n          _this$props2$rowIndex = _this$props2.rowIndex,\n          rowIndex = _this$props2$rowIndex === void 0 ? this.props.index || 0 : _this$props2$rowIndex;\n\n      if (!cache.has(rowIndex, columnIndex)) {\n        var _this$_getCellMeasure2 = this._getCellMeasurements(),\n            height = _this$_getCellMeasure2.height,\n            width = _this$_getCellMeasure2.width;\n\n        cache.set(rowIndex, columnIndex, width, height); // If size has changed, let Grid know to re-render.\n\n        if (parent && typeof parent.invalidateCellSizeAfterRender === 'function') {\n          parent.invalidateCellSizeAfterRender({\n            columnIndex: columnIndex,\n            rowIndex: rowIndex\n          });\n        }\n      }\n    }\n  }]);\n\n  return CellMeasurer;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"cache\": function cache() {\n    return (typeof bpfrpt_proptype_CellMeasureCache === \"function\" ? bpfrpt_proptype_CellMeasureCache.isRequired ? bpfrpt_proptype_CellMeasureCache.isRequired : bpfrpt_proptype_CellMeasureCache : PropTypes.shape(bpfrpt_proptype_CellMeasureCache).isRequired).apply(this, arguments);\n  },\n  \"children\": PropTypes.oneOfType([PropTypes.func, PropTypes.node]).isRequired,\n  \"columnIndex\": PropTypes.number,\n  \"index\": PropTypes.number,\n  \"parent\": PropTypes.shape({\n    invalidateCellSizeAfterRender: PropTypes.func,\n    recomputeGridSize: PropTypes.func\n  }).isRequired,\n  \"rowIndex\": PropTypes.number\n}), _temp); // Used for DEV mode warning check\n\n_defineProperty(CellMeasurer, \"__internalCellMeasurerFlag\", false);\n\nexport { CellMeasurer as default };\n\nif (process.env.NODE_ENV !== 'production') {\n  CellMeasurer.__internalCellMeasurerFlag = true;\n}\n\nimport { bpfrpt_proptype_CellMeasureCache } from \"./types\";\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nexport var DEFAULT_HEIGHT = 30;\nexport var DEFAULT_WIDTH = 100; // Enables more intelligent mapping of a given column and row index to an item ID.\n// This prevents a cell cache from being invalidated when its parent collection is modified.\n\n/**\n * Caches measurements for a given cell.\n */\nvar CellMeasurerCache =\n/*#__PURE__*/\nfunction () {\n  function CellMeasurerCache() {\n    var _this = this;\n\n    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, CellMeasurerCache);\n\n    _defineProperty(this, \"_cellHeightCache\", {});\n\n    _defineProperty(this, \"_cellWidthCache\", {});\n\n    _defineProperty(this, \"_columnWidthCache\", {});\n\n    _defineProperty(this, \"_rowHeightCache\", {});\n\n    _defineProperty(this, \"_defaultHeight\", void 0);\n\n    _defineProperty(this, \"_defaultWidth\", void 0);\n\n    _defineProperty(this, \"_minHeight\", void 0);\n\n    _defineProperty(this, \"_minWidth\", void 0);\n\n    _defineProperty(this, \"_keyMapper\", void 0);\n\n    _defineProperty(this, \"_hasFixedHeight\", void 0);\n\n    _defineProperty(this, \"_hasFixedWidth\", void 0);\n\n    _defineProperty(this, \"_columnCount\", 0);\n\n    _defineProperty(this, \"_rowCount\", 0);\n\n    _defineProperty(this, \"columnWidth\", function (_ref) {\n      var index = _ref.index;\n\n      var key = _this._keyMapper(0, index);\n\n      return _this._columnWidthCache[key] !== undefined ? _this._columnWidthCache[key] : _this._defaultWidth;\n    });\n\n    _defineProperty(this, \"rowHeight\", function (_ref2) {\n      var index = _ref2.index;\n\n      var key = _this._keyMapper(index, 0);\n\n      return _this._rowHeightCache[key] !== undefined ? _this._rowHeightCache[key] : _this._defaultHeight;\n    });\n\n    var defaultHeight = params.defaultHeight,\n        defaultWidth = params.defaultWidth,\n        fixedHeight = params.fixedHeight,\n        fixedWidth = params.fixedWidth,\n        keyMapper = params.keyMapper,\n        minHeight = params.minHeight,\n        minWidth = params.minWidth;\n    this._hasFixedHeight = fixedHeight === true;\n    this._hasFixedWidth = fixedWidth === true;\n    this._minHeight = minHeight || 0;\n    this._minWidth = minWidth || 0;\n    this._keyMapper = keyMapper || defaultKeyMapper;\n    this._defaultHeight = Math.max(this._minHeight, typeof defaultHeight === 'number' ? defaultHeight : DEFAULT_HEIGHT);\n    this._defaultWidth = Math.max(this._minWidth, typeof defaultWidth === 'number' ? defaultWidth : DEFAULT_WIDTH);\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (this._hasFixedHeight === false && this._hasFixedWidth === false) {\n        console.warn(\"CellMeasurerCache should only measure a cell's width or height. \" + 'You have configured CellMeasurerCache to measure both. ' + 'This will result in poor performance.');\n      }\n\n      if (this._hasFixedHeight === false && this._defaultHeight === 0) {\n        console.warn('Fixed height CellMeasurerCache should specify a :defaultHeight greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');\n      }\n\n      if (this._hasFixedWidth === false && this._defaultWidth === 0) {\n        console.warn('Fixed width CellMeasurerCache should specify a :defaultWidth greater than 0. ' + 'Failing to do so will lead to unnecessary layout and poor performance.');\n      }\n    }\n  }\n\n  _createClass(CellMeasurerCache, [{\n    key: \"clear\",\n    value: function clear(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      var key = this._keyMapper(rowIndex, columnIndex);\n\n      delete this._cellHeightCache[key];\n      delete this._cellWidthCache[key];\n\n      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);\n    }\n  }, {\n    key: \"clearAll\",\n    value: function clearAll() {\n      this._cellHeightCache = {};\n      this._cellWidthCache = {};\n      this._columnWidthCache = {};\n      this._rowHeightCache = {};\n      this._rowCount = 0;\n      this._columnCount = 0;\n    }\n  }, {\n    key: \"hasFixedHeight\",\n    value: function hasFixedHeight() {\n      return this._hasFixedHeight;\n    }\n  }, {\n    key: \"hasFixedWidth\",\n    value: function hasFixedWidth() {\n      return this._hasFixedWidth;\n    }\n  }, {\n    key: \"getHeight\",\n    value: function getHeight(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      if (this._hasFixedHeight) {\n        return this._defaultHeight;\n      } else {\n        var _key = this._keyMapper(rowIndex, columnIndex);\n\n        return this._cellHeightCache[_key] !== undefined ? Math.max(this._minHeight, this._cellHeightCache[_key]) : this._defaultHeight;\n      }\n    }\n  }, {\n    key: \"getWidth\",\n    value: function getWidth(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      if (this._hasFixedWidth) {\n        return this._defaultWidth;\n      } else {\n        var _key2 = this._keyMapper(rowIndex, columnIndex);\n\n        return this._cellWidthCache[_key2] !== undefined ? Math.max(this._minWidth, this._cellWidthCache[_key2]) : this._defaultWidth;\n      }\n    }\n  }, {\n    key: \"has\",\n    value: function has(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      var key = this._keyMapper(rowIndex, columnIndex);\n\n      return this._cellHeightCache[key] !== undefined;\n    }\n  }, {\n    key: \"set\",\n    value: function set(rowIndex, columnIndex, width, height) {\n      var key = this._keyMapper(rowIndex, columnIndex);\n\n      if (columnIndex >= this._columnCount) {\n        this._columnCount = columnIndex + 1;\n      }\n\n      if (rowIndex >= this._rowCount) {\n        this._rowCount = rowIndex + 1;\n      } // Size is cached per cell so we don't have to re-measure if cells are re-ordered.\n\n\n      this._cellHeightCache[key] = height;\n      this._cellWidthCache[key] = width;\n\n      this._updateCachedColumnAndRowSizes(rowIndex, columnIndex);\n    }\n  }, {\n    key: \"_updateCachedColumnAndRowSizes\",\n    value: function _updateCachedColumnAndRowSizes(rowIndex, columnIndex) {\n      // :columnWidth and :rowHeight are derived based on all cells in a column/row.\n      // Pre-cache these derived values for faster lookup later.\n      // Reads are expected to occur more frequently than writes in this case.\n      // Only update non-fixed dimensions though to avoid doing unnecessary work.\n      if (!this._hasFixedWidth) {\n        var columnWidth = 0;\n\n        for (var i = 0; i < this._rowCount; i++) {\n          columnWidth = Math.max(columnWidth, this.getWidth(i, columnIndex));\n        }\n\n        var columnKey = this._keyMapper(0, columnIndex);\n\n        this._columnWidthCache[columnKey] = columnWidth;\n      }\n\n      if (!this._hasFixedHeight) {\n        var rowHeight = 0;\n\n        for (var _i = 0; _i < this._columnCount; _i++) {\n          rowHeight = Math.max(rowHeight, this.getHeight(rowIndex, _i));\n        }\n\n        var rowKey = this._keyMapper(rowIndex, 0);\n\n        this._rowHeightCache[rowKey] = rowHeight;\n      }\n    }\n  }, {\n    key: \"defaultHeight\",\n    get: function get() {\n      return this._defaultHeight;\n    }\n  }, {\n    key: \"defaultWidth\",\n    get: function get() {\n      return this._defaultWidth;\n    }\n  }]);\n\n  return CellMeasurerCache;\n}();\n\nexport { CellMeasurerCache as default };\n\nfunction defaultKeyMapper(rowIndex, columnIndex) {\n  return \"\".concat(rowIndex, \"-\").concat(columnIndex);\n}\n\nimport { bpfrpt_proptype_CellMeasureCache } from \"./types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport clsx from 'clsx';\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\nimport createCallbackMemoizer from '../utils/createCallbackMemoizer';\nimport getScrollbarSize from 'dom-helpers/scrollbarSize'; // @TODO Merge Collection and CollectionView\n\n/**\n * Specifies the number of milliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\n\nvar IS_SCROLLING_TIMEOUT = 150;\n/**\n * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.\n * This prevents Grid from interrupting mouse-wheel animations (see issue #2).\n */\n\nvar SCROLL_POSITION_CHANGE_REASONS = {\n  OBSERVED: 'observed',\n  REQUESTED: 'requested'\n};\n/**\n * Monitors changes in properties (eg. cellCount) and state (eg. scroll offsets) to determine when rendering needs to occur.\n * This component does not render any visible content itself; it defers to the specified :cellLayoutManager.\n */\n\nvar CollectionView =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(CollectionView, _React$PureComponent);\n\n  // Invokes callbacks only when their values have changed.\n  function CollectionView() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, CollectionView);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CollectionView)).call.apply(_getPrototypeOf2, [this].concat(args))); // If this component is being rendered server-side, getScrollbarSize() will return undefined.\n    // We handle this case in componentDidMount()\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      isScrolling: false,\n      scrollLeft: 0,\n      scrollTop: 0\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_calculateSizeAndPositionDataOnNextUpdate\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_onSectionRenderedMemoizer\", createCallbackMemoizer());\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollMemoizer\", createCallbackMemoizer(false));\n\n    _defineProperty(_assertThisInitialized(_this), \"_invokeOnSectionRenderedHelper\", function () {\n      var _this$props = _this.props,\n          cellLayoutManager = _this$props.cellLayoutManager,\n          onSectionRendered = _this$props.onSectionRendered;\n\n      _this._onSectionRenderedMemoizer({\n        callback: onSectionRendered,\n        indices: {\n          indices: cellLayoutManager.getLastRenderedIndices()\n        }\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setScrollingContainerRef\", function (ref) {\n      _this._scrollingContainer = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_updateScrollPositionForScrollToCell\", function () {\n      var _this$props2 = _this.props,\n          cellLayoutManager = _this$props2.cellLayoutManager,\n          height = _this$props2.height,\n          scrollToAlignment = _this$props2.scrollToAlignment,\n          scrollToCell = _this$props2.scrollToCell,\n          width = _this$props2.width;\n      var _this$state = _this.state,\n          scrollLeft = _this$state.scrollLeft,\n          scrollTop = _this$state.scrollTop;\n\n      if (scrollToCell >= 0) {\n        var scrollPosition = cellLayoutManager.getScrollPositionForCell({\n          align: scrollToAlignment,\n          cellIndex: scrollToCell,\n          height: height,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          width: width\n        });\n\n        if (scrollPosition.scrollLeft !== scrollLeft || scrollPosition.scrollTop !== scrollTop) {\n          _this._setScrollPosition(scrollPosition);\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (event) {\n      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.\n      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.\n      // See issue #404 for more information.\n      if (event.target !== _this._scrollingContainer) {\n        return;\n      } // Prevent pointer events from interrupting a smooth scroll\n\n\n      _this._enablePointerEventsAfterDelay(); // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height.\n\n\n      var _this$props3 = _this.props,\n          cellLayoutManager = _this$props3.cellLayoutManager,\n          height = _this$props3.height,\n          isScrollingChange = _this$props3.isScrollingChange,\n          width = _this$props3.width;\n      var scrollbarSize = _this._scrollbarSize;\n\n      var _cellLayoutManager$ge = cellLayoutManager.getTotalSize(),\n          totalHeight = _cellLayoutManager$ge.height,\n          totalWidth = _cellLayoutManager$ge.width;\n\n      var scrollLeft = Math.max(0, Math.min(totalWidth - width + scrollbarSize, event.target.scrollLeft));\n      var scrollTop = Math.max(0, Math.min(totalHeight - height + scrollbarSize, event.target.scrollTop)); // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n\n      if (_this.state.scrollLeft !== scrollLeft || _this.state.scrollTop !== scrollTop) {\n        // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set.\n        // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling).\n        // All things considered, this seems to be the best current work around that I'm aware of.\n        // For more information see https://github.com/bvaughn/react-virtualized/pull/124\n        var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED; // Synchronously set :isScrolling the first time (since _setNextState will reschedule its animation frame each time it's called)\n\n        if (!_this.state.isScrolling) {\n          isScrollingChange(true);\n        }\n\n        _this.setState({\n          isScrolling: true,\n          scrollLeft: scrollLeft,\n          scrollPositionChangeReason: scrollPositionChangeReason,\n          scrollTop: scrollTop\n        });\n      }\n\n      _this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        totalWidth: totalWidth,\n        totalHeight: totalHeight\n      });\n    });\n\n    _this._scrollbarSize = getScrollbarSize();\n\n    if (_this._scrollbarSize === undefined) {\n      _this._scrollbarSizeMeasured = false;\n      _this._scrollbarSize = 0;\n    } else {\n      _this._scrollbarSizeMeasured = true;\n    }\n\n    return _this;\n  }\n  /**\n   * Forced recompute of cell sizes and positions.\n   * This function should be called if cell sizes have changed but nothing else has.\n   * Since cell positions are calculated by callbacks, the collection view has no way of detecting when the underlying data has changed.\n   */\n\n\n  _createClass(CollectionView, [{\n    key: \"recomputeCellSizesAndPositions\",\n    value: function recomputeCellSizesAndPositions() {\n      this._calculateSizeAndPositionDataOnNextUpdate = true;\n      this.forceUpdate();\n    }\n    /* ---------------------------- Component lifecycle methods ---------------------------- */\n\n    /**\n     * @private\n     * This method updates scrollLeft/scrollTop in state for the following conditions:\n     * 1) Empty content (0 rows or columns)\n     * 2) New scroll props overriding the current state\n     * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid\n     */\n\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var _this$props4 = this.props,\n          cellLayoutManager = _this$props4.cellLayoutManager,\n          scrollLeft = _this$props4.scrollLeft,\n          scrollToCell = _this$props4.scrollToCell,\n          scrollTop = _this$props4.scrollTop; // If this component was first rendered server-side, scrollbar size will be undefined.\n      // In that event we need to remeasure.\n\n      if (!this._scrollbarSizeMeasured) {\n        this._scrollbarSize = getScrollbarSize();\n        this._scrollbarSizeMeasured = true;\n        this.setState({});\n      }\n\n      if (scrollToCell >= 0) {\n        this._updateScrollPositionForScrollToCell();\n      } else if (scrollLeft >= 0 || scrollTop >= 0) {\n        this._setScrollPosition({\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n      } // Update onSectionRendered callback.\n\n\n      this._invokeOnSectionRenderedHelper();\n\n      var _cellLayoutManager$ge2 = cellLayoutManager.getTotalSize(),\n          totalHeight = _cellLayoutManager$ge2.height,\n          totalWidth = _cellLayoutManager$ge2.width; // Initialize onScroll callback.\n\n\n      this._invokeOnScrollMemoizer({\n        scrollLeft: scrollLeft || 0,\n        scrollTop: scrollTop || 0,\n        totalHeight: totalHeight,\n        totalWidth: totalWidth\n      });\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this$props5 = this.props,\n          height = _this$props5.height,\n          scrollToAlignment = _this$props5.scrollToAlignment,\n          scrollToCell = _this$props5.scrollToCell,\n          width = _this$props5.width;\n      var _this$state2 = this.state,\n          scrollLeft = _this$state2.scrollLeft,\n          scrollPositionChangeReason = _this$state2.scrollPositionChangeReason,\n          scrollTop = _this$state2.scrollTop; // Make sure requested changes to :scrollLeft or :scrollTop get applied.\n      // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,\n      // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread).\n      // So we only set these when we require an adjustment of the scroll position.\n      // See issue #2 for more information.\n\n      if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {\n        if (scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft) {\n          this._scrollingContainer.scrollLeft = scrollLeft;\n        }\n\n        if (scrollTop >= 0 && scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop) {\n          this._scrollingContainer.scrollTop = scrollTop;\n        }\n      } // Update scroll offsets if the current :scrollToCell values requires it\n\n\n      if (height !== prevProps.height || scrollToAlignment !== prevProps.scrollToAlignment || scrollToCell !== prevProps.scrollToCell || width !== prevProps.width) {\n        this._updateScrollPositionForScrollToCell();\n      } // Update onRowsRendered callback if start/stop indices have changed\n\n\n      this._invokeOnSectionRenderedHelper();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props6 = this.props,\n          autoHeight = _this$props6.autoHeight,\n          cellCount = _this$props6.cellCount,\n          cellLayoutManager = _this$props6.cellLayoutManager,\n          className = _this$props6.className,\n          height = _this$props6.height,\n          horizontalOverscanSize = _this$props6.horizontalOverscanSize,\n          id = _this$props6.id,\n          noContentRenderer = _this$props6.noContentRenderer,\n          style = _this$props6.style,\n          verticalOverscanSize = _this$props6.verticalOverscanSize,\n          width = _this$props6.width;\n      var _this$state3 = this.state,\n          isScrolling = _this$state3.isScrolling,\n          scrollLeft = _this$state3.scrollLeft,\n          scrollTop = _this$state3.scrollTop; // Memoization reset\n\n      if (this._lastRenderedCellCount !== cellCount || this._lastRenderedCellLayoutManager !== cellLayoutManager || this._calculateSizeAndPositionDataOnNextUpdate) {\n        this._lastRenderedCellCount = cellCount;\n        this._lastRenderedCellLayoutManager = cellLayoutManager;\n        this._calculateSizeAndPositionDataOnNextUpdate = false;\n        cellLayoutManager.calculateSizeAndPositionData();\n      }\n\n      var _cellLayoutManager$ge3 = cellLayoutManager.getTotalSize(),\n          totalHeight = _cellLayoutManager$ge3.height,\n          totalWidth = _cellLayoutManager$ge3.width; // Safely expand the rendered area by the specified overscan amount\n\n\n      var left = Math.max(0, scrollLeft - horizontalOverscanSize);\n      var top = Math.max(0, scrollTop - verticalOverscanSize);\n      var right = Math.min(totalWidth, scrollLeft + width + horizontalOverscanSize);\n      var bottom = Math.min(totalHeight, scrollTop + height + verticalOverscanSize);\n      var childrenToDisplay = height > 0 && width > 0 ? cellLayoutManager.cellRenderers({\n        height: bottom - top,\n        isScrolling: isScrolling,\n        width: right - left,\n        x: left,\n        y: top\n      }) : [];\n      var collectionStyle = {\n        boxSizing: 'border-box',\n        direction: 'ltr',\n        height: autoHeight ? 'auto' : height,\n        position: 'relative',\n        WebkitOverflowScrolling: 'touch',\n        width: width,\n        willChange: 'transform'\n      }; // Force browser to hide scrollbars when we know they aren't necessary.\n      // Otherwise once scrollbars appear they may not disappear again.\n      // For more info see issue #116\n\n      var verticalScrollBarSize = totalHeight > height ? this._scrollbarSize : 0;\n      var horizontalScrollBarSize = totalWidth > width ? this._scrollbarSize : 0; // Also explicitly init styles to 'auto' if scrollbars are required.\n      // This works around an obscure edge case where external CSS styles have not yet been loaded,\n      // But an initial scroll index of offset is set as an external prop.\n      // Without this style, Grid would render the correct range of cells but would NOT update its internal offset.\n      // This was originally reported via clauderic/react-infinite-calendar/issues/23\n\n      collectionStyle.overflowX = totalWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto';\n      collectionStyle.overflowY = totalHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto';\n      return React.createElement(\"div\", {\n        ref: this._setScrollingContainerRef,\n        \"aria-label\": this.props['aria-label'],\n        className: clsx('ReactVirtualized__Collection', className),\n        id: id,\n        onScroll: this._onScroll,\n        role: \"grid\",\n        style: _objectSpread({}, collectionStyle, {}, style),\n        tabIndex: 0\n      }, cellCount > 0 && React.createElement(\"div\", {\n        className: \"ReactVirtualized__Collection__innerScrollContainer\",\n        style: {\n          height: totalHeight,\n          maxHeight: totalHeight,\n          maxWidth: totalWidth,\n          overflow: 'hidden',\n          pointerEvents: isScrolling ? 'none' : '',\n          width: totalWidth\n        }\n      }, childrenToDisplay), cellCount === 0 && noContentRenderer());\n    }\n    /* ---------------------------- Helper methods ---------------------------- */\n\n    /**\n     * Sets an :isScrolling flag for a small window of time.\n     * This flag is used to disable pointer events on the scrollable portion of the Collection.\n     * This prevents jerky/stuttery mouse-wheel scrolling.\n     */\n\n  }, {\n    key: \"_enablePointerEventsAfterDelay\",\n    value: function _enablePointerEventsAfterDelay() {\n      var _this2 = this;\n\n      if (this._disablePointerEventsTimeoutId) {\n        clearTimeout(this._disablePointerEventsTimeoutId);\n      }\n\n      this._disablePointerEventsTimeoutId = setTimeout(function () {\n        var isScrollingChange = _this2.props.isScrollingChange;\n        isScrollingChange(false);\n        _this2._disablePointerEventsTimeoutId = null;\n\n        _this2.setState({\n          isScrolling: false\n        });\n      }, IS_SCROLLING_TIMEOUT);\n    }\n  }, {\n    key: \"_invokeOnScrollMemoizer\",\n    value: function _invokeOnScrollMemoizer(_ref) {\n      var _this3 = this;\n\n      var scrollLeft = _ref.scrollLeft,\n          scrollTop = _ref.scrollTop,\n          totalHeight = _ref.totalHeight,\n          totalWidth = _ref.totalWidth;\n\n      this._onScrollMemoizer({\n        callback: function callback(_ref2) {\n          var scrollLeft = _ref2.scrollLeft,\n              scrollTop = _ref2.scrollTop;\n          var _this3$props = _this3.props,\n              height = _this3$props.height,\n              onScroll = _this3$props.onScroll,\n              width = _this3$props.width;\n          onScroll({\n            clientHeight: height,\n            clientWidth: width,\n            scrollHeight: totalHeight,\n            scrollLeft: scrollLeft,\n            scrollTop: scrollTop,\n            scrollWidth: totalWidth\n          });\n        },\n        indices: {\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        }\n      });\n    }\n  }, {\n    key: \"_setScrollPosition\",\n    value: function _setScrollPosition(_ref3) {\n      var scrollLeft = _ref3.scrollLeft,\n          scrollTop = _ref3.scrollTop;\n      var newState = {\n        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n      };\n\n      if (scrollLeft >= 0) {\n        newState.scrollLeft = scrollLeft;\n      }\n\n      if (scrollTop >= 0) {\n        newState.scrollTop = scrollTop;\n      }\n\n      if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) {\n        this.setState(newState);\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.cellCount === 0 && (prevState.scrollLeft !== 0 || prevState.scrollTop !== 0)) {\n        return {\n          scrollLeft: 0,\n          scrollTop: 0,\n          scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n        };\n      } else if (nextProps.scrollLeft !== prevState.scrollLeft || nextProps.scrollTop !== prevState.scrollTop) {\n        return {\n          scrollLeft: nextProps.scrollLeft != null ? nextProps.scrollLeft : prevState.scrollLeft,\n          scrollTop: nextProps.scrollTop != null ? nextProps.scrollTop : prevState.scrollTop,\n          scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return CollectionView;\n}(React.PureComponent);\n\n_defineProperty(CollectionView, \"defaultProps\", {\n  'aria-label': 'grid',\n  horizontalOverscanSize: 0,\n  noContentRenderer: function noContentRenderer() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  onSectionRendered: function onSectionRendered() {\n    return null;\n  },\n  scrollToAlignment: 'auto',\n  scrollToCell: -1,\n  style: {},\n  verticalOverscanSize: 0\n});\n\nCollectionView.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  'aria-label': PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: PropTypes.bool,\n\n  /**\n   * Number of cells in collection.\n   */\n  cellCount: PropTypes.number.isRequired,\n\n  /**\n   * Calculates cell sizes and positions and manages rendering the appropriate cells given a specified window.\n   */\n  cellLayoutManager: PropTypes.object.isRequired,\n\n  /**\n   * Optional custom CSS class name to attach to root Collection element.\n   */\n  className: PropTypes.string,\n\n  /**\n   * Height of Collection; this property determines the number of visible (vs virtualized) rows.\n   */\n  height: PropTypes.number.isRequired,\n\n  /**\n   * Optional custom id to attach to root Collection element.\n   */\n  id: PropTypes.string,\n\n  /**\n   * Enables the `Collection` to horiontally \"overscan\" its content similar to how `Grid` does.\n   * This can reduce flicker around the edges when a user scrolls quickly.\n   */\n  horizontalOverscanSize: PropTypes.number.isRequired,\n  isScrollingChange: PropTypes.func,\n\n  /**\n   * Optional renderer to be used in place of rows when either :rowCount or :cellCount is 0.\n   */\n  noContentRenderer: PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void\n   */\n  onScroll: PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked with information about the section of the Collection that was just rendered.\n   * This callback is passed a named :indices parameter which is an Array of the most recently rendered section indices.\n   */\n  onSectionRendered: PropTypes.func.isRequired,\n\n  /**\n   * Horizontal offset.\n   */\n  scrollLeft: PropTypes.number,\n\n  /**\n   * Controls scroll-to-cell behavior of the Grid.\n   * The default (\"auto\") scrolls the least amount possible to ensure that the specified cell is fully visible.\n   * Use \"start\" to align cells to the top/left of the Grid and \"end\" to align bottom/right.\n   */\n  scrollToAlignment: PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /**\n   * Cell index to ensure visible (by forcefully scrolling if necessary).\n   */\n  scrollToCell: PropTypes.number.isRequired,\n\n  /**\n   * Vertical offset.\n   */\n  scrollTop: PropTypes.number,\n\n  /**\n   * Optional custom inline style to attach to root Collection element.\n   */\n  style: PropTypes.object,\n\n  /**\n   * Enables the `Collection` to vertically \"overscan\" its content similar to how `Grid` does.\n   * This can reduce flicker around the edges when a user scrolls quickly.\n   */\n  verticalOverscanSize: PropTypes.number.isRequired,\n\n  /**\n   * Width of Collection; this property determines the number of visible (vs virtualized) columns.\n   */\n  width: PropTypes.number.isRequired\n} : {};\npolyfill(CollectionView);\nexport default CollectionView;","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\n\n/**\n * A section of the Window.\n * Window Sections are used to group nearby cells.\n * This enables us to more quickly determine which cells to display in a given region of the Window.\n * Sections have a fixed size and contain 0 to many cells (tracked by their indices).\n */\nvar Section =\n/*#__PURE__*/\nfunction () {\n  function Section(_ref) {\n    var height = _ref.height,\n        width = _ref.width,\n        x = _ref.x,\n        y = _ref.y;\n\n    _classCallCheck(this, Section);\n\n    this.height = height;\n    this.width = width;\n    this.x = x;\n    this.y = y;\n    this._indexMap = {};\n    this._indices = [];\n  }\n  /** Add a cell to this section. */\n\n\n  _createClass(Section, [{\n    key: \"addCellIndex\",\n    value: function addCellIndex(_ref2) {\n      var index = _ref2.index;\n\n      if (!this._indexMap[index]) {\n        this._indexMap[index] = true;\n\n        this._indices.push(index);\n      }\n    }\n    /** Get all cell indices that have been added to this section. */\n\n  }, {\n    key: \"getCellIndices\",\n    value: function getCellIndices() {\n      return this._indices;\n    }\n    /** Intended for debugger/test purposes only */\n\n  }, {\n    key: \"toString\",\n    value: function toString() {\n      return \"\".concat(this.x, \",\").concat(this.y, \" \").concat(this.width, \"x\").concat(this.height);\n    }\n  }]);\n\n  return Section;\n}();\n\nexport { Section as default };\nimport { bpfrpt_proptype_Index } from \"./types\";\nimport { bpfrpt_proptype_SizeAndPositionInfo } from \"./types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\n\n/**\n * Window Sections are used to group nearby cells.\n * This enables us to more quickly determine which cells to display in a given region of the Window.\n * \n */\nimport Section from './Section';\nvar SECTION_SIZE = 100;\n\n/**\n * Contains 0 to many Sections.\n * Grows (and adds Sections) dynamically as cells are registered.\n * Automatically adds cells to the appropriate Section(s).\n */\nvar SectionManager =\n/*#__PURE__*/\nfunction () {\n  function SectionManager() {\n    var sectionSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SECTION_SIZE;\n\n    _classCallCheck(this, SectionManager);\n\n    this._sectionSize = sectionSize;\n    this._cellMetadata = [];\n    this._sections = {};\n  }\n  /**\n   * Gets all cell indices contained in the specified region.\n   * A region may encompass 1 or more Sections.\n   */\n\n\n  _createClass(SectionManager, [{\n    key: \"getCellIndices\",\n    value: function getCellIndices(_ref) {\n      var height = _ref.height,\n          width = _ref.width,\n          x = _ref.x,\n          y = _ref.y;\n      var indices = {};\n      this.getSections({\n        height: height,\n        width: width,\n        x: x,\n        y: y\n      }).forEach(function (section) {\n        return section.getCellIndices().forEach(function (index) {\n          indices[index] = index;\n        });\n      }); // Object keys are strings; this function returns numbers\n\n      return Object.keys(indices).map(function (index) {\n        return indices[index];\n      });\n    }\n    /** Get size and position information for the cell specified. */\n\n  }, {\n    key: \"getCellMetadata\",\n    value: function getCellMetadata(_ref2) {\n      var index = _ref2.index;\n      return this._cellMetadata[index];\n    }\n    /** Get all Sections overlapping the specified region. */\n\n  }, {\n    key: \"getSections\",\n    value: function getSections(_ref3) {\n      var height = _ref3.height,\n          width = _ref3.width,\n          x = _ref3.x,\n          y = _ref3.y;\n      var sectionXStart = Math.floor(x / this._sectionSize);\n      var sectionXStop = Math.floor((x + width - 1) / this._sectionSize);\n      var sectionYStart = Math.floor(y / this._sectionSize);\n      var sectionYStop = Math.floor((y + height - 1) / this._sectionSize);\n      var sections = [];\n\n      for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {\n        for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {\n          var key = \"\".concat(sectionX, \".\").concat(sectionY);\n\n          if (!this._sections[key]) {\n            this._sections[key] = new Section({\n              height: this._sectionSize,\n              width: this._sectionSize,\n              x: sectionX * this._sectionSize,\n              y: sectionY * this._sectionSize\n            });\n          }\n\n          sections.push(this._sections[key]);\n        }\n      }\n\n      return sections;\n    }\n    /** Total number of Sections based on the currently registered cells. */\n\n  }, {\n    key: \"getTotalSectionCount\",\n    value: function getTotalSectionCount() {\n      return Object.keys(this._sections).length;\n    }\n    /** Intended for debugger/test purposes only */\n\n  }, {\n    key: \"toString\",\n    value: function toString() {\n      var _this = this;\n\n      return Object.keys(this._sections).map(function (index) {\n        return _this._sections[index].toString();\n      });\n    }\n    /** Adds a cell to the appropriate Sections and registers it metadata for later retrievable. */\n\n  }, {\n    key: \"registerCell\",\n    value: function registerCell(_ref4) {\n      var cellMetadatum = _ref4.cellMetadatum,\n          index = _ref4.index;\n      this._cellMetadata[index] = cellMetadatum;\n      this.getSections(cellMetadatum).forEach(function (section) {\n        return section.addCellIndex({\n          index: index\n        });\n      });\n    }\n  }]);\n\n  return SectionManager;\n}();\n\nexport { SectionManager as default };\nimport { bpfrpt_proptype_Index } from \"./types\";\nimport { bpfrpt_proptype_SizeAndPositionInfo } from \"./types\";","/**\n * Determines a new offset that ensures a certain cell is visible, given the current offset.\n * If the cell is already visible then the current offset will be returned.\n * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.\n *\n * @param align Desired alignment within container; one of \"auto\" (default), \"start\", or \"end\"\n * @param cellOffset Offset (x or y) position for cell\n * @param cellSize Size (width or height) of cell\n * @param containerSize Total size (width or height) of the container\n * @param currentOffset Container's current (x or y) offset\n * @return Offset to use to ensure the specified cell is visible\n */\nexport default function getUpdatedOffsetForIndex(_ref) {\n  var _ref$align = _ref.align,\n      align = _ref$align === void 0 ? 'auto' : _ref$align,\n      cellOffset = _ref.cellOffset,\n      cellSize = _ref.cellSize,\n      containerSize = _ref.containerSize,\n      currentOffset = _ref.currentOffset;\n  var maxOffset = cellOffset;\n  var minOffset = maxOffset - containerSize + cellSize;\n\n  switch (align) {\n    case 'start':\n      return maxOffset;\n\n    case 'end':\n      return minOffset;\n\n    case 'center':\n      return maxOffset - (containerSize - cellSize) / 2;\n\n    default:\n      return Math.max(minOffset, Math.min(maxOffset, currentOffset));\n  }\n}","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport CollectionView from './CollectionView';\nimport _calculateSizeAndPositionData from './utils/calculateSizeAndPositionData';\nimport getUpdatedOffsetForIndex from '../utils/getUpdatedOffsetForIndex';\n\n/**\n * Renders scattered or non-linear data.\n * Unlike Grid, which renders checkerboard data, Collection can render arbitrarily positioned- even overlapping- data.\n */\nvar Collection =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Collection, _React$PureComponent);\n\n  function Collection(props, context) {\n    var _this;\n\n    _classCallCheck(this, Collection);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Collection).call(this, props, context));\n    _this._cellMetadata = [];\n    _this._lastRenderedCellIndices = []; // Cell cache during scroll (for performance)\n\n    _this._cellCache = [];\n    _this._isScrollingChange = _this._isScrollingChange.bind(_assertThisInitialized(_this));\n    _this._setCollectionViewRef = _this._setCollectionViewRef.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(Collection, [{\n    key: \"forceUpdate\",\n    value: function forceUpdate() {\n      if (this._collectionView !== undefined) {\n        this._collectionView.forceUpdate();\n      }\n    }\n    /** See Collection#recomputeCellSizesAndPositions */\n\n  }, {\n    key: \"recomputeCellSizesAndPositions\",\n    value: function recomputeCellSizesAndPositions() {\n      this._cellCache = [];\n\n      this._collectionView.recomputeCellSizesAndPositions();\n    }\n    /** React lifecycle methods */\n\n  }, {\n    key: \"render\",\n    value: function render() {\n      var props = _extends({}, this.props);\n\n      return React.createElement(CollectionView, _extends({\n        cellLayoutManager: this,\n        isScrollingChange: this._isScrollingChange,\n        ref: this._setCollectionViewRef\n      }, props));\n    }\n    /** CellLayoutManager interface */\n\n  }, {\n    key: \"calculateSizeAndPositionData\",\n    value: function calculateSizeAndPositionData() {\n      var _this$props = this.props,\n          cellCount = _this$props.cellCount,\n          cellSizeAndPositionGetter = _this$props.cellSizeAndPositionGetter,\n          sectionSize = _this$props.sectionSize;\n\n      var data = _calculateSizeAndPositionData({\n        cellCount: cellCount,\n        cellSizeAndPositionGetter: cellSizeAndPositionGetter,\n        sectionSize: sectionSize\n      });\n\n      this._cellMetadata = data.cellMetadata;\n      this._sectionManager = data.sectionManager;\n      this._height = data.height;\n      this._width = data.width;\n    }\n    /**\n     * Returns the most recently rendered set of cell indices.\n     */\n\n  }, {\n    key: \"getLastRenderedIndices\",\n    value: function getLastRenderedIndices() {\n      return this._lastRenderedCellIndices;\n    }\n    /**\n     * Calculates the minimum amount of change from the current scroll position to ensure the specified cell is (fully) visible.\n     */\n\n  }, {\n    key: \"getScrollPositionForCell\",\n    value: function getScrollPositionForCell(_ref) {\n      var align = _ref.align,\n          cellIndex = _ref.cellIndex,\n          height = _ref.height,\n          scrollLeft = _ref.scrollLeft,\n          scrollTop = _ref.scrollTop,\n          width = _ref.width;\n      var cellCount = this.props.cellCount;\n\n      if (cellIndex >= 0 && cellIndex < cellCount) {\n        var cellMetadata = this._cellMetadata[cellIndex];\n        scrollLeft = getUpdatedOffsetForIndex({\n          align: align,\n          cellOffset: cellMetadata.x,\n          cellSize: cellMetadata.width,\n          containerSize: width,\n          currentOffset: scrollLeft,\n          targetIndex: cellIndex\n        });\n        scrollTop = getUpdatedOffsetForIndex({\n          align: align,\n          cellOffset: cellMetadata.y,\n          cellSize: cellMetadata.height,\n          containerSize: height,\n          currentOffset: scrollTop,\n          targetIndex: cellIndex\n        });\n      }\n\n      return {\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop\n      };\n    }\n  }, {\n    key: \"getTotalSize\",\n    value: function getTotalSize() {\n      return {\n        height: this._height,\n        width: this._width\n      };\n    }\n  }, {\n    key: \"cellRenderers\",\n    value: function cellRenderers(_ref2) {\n      var _this2 = this;\n\n      var height = _ref2.height,\n          isScrolling = _ref2.isScrolling,\n          width = _ref2.width,\n          x = _ref2.x,\n          y = _ref2.y;\n      var _this$props2 = this.props,\n          cellGroupRenderer = _this$props2.cellGroupRenderer,\n          cellRenderer = _this$props2.cellRenderer; // Store for later calls to getLastRenderedIndices()\n\n      this._lastRenderedCellIndices = this._sectionManager.getCellIndices({\n        height: height,\n        width: width,\n        x: x,\n        y: y\n      });\n      return cellGroupRenderer({\n        cellCache: this._cellCache,\n        cellRenderer: cellRenderer,\n        cellSizeAndPositionGetter: function cellSizeAndPositionGetter(_ref3) {\n          var index = _ref3.index;\n          return _this2._sectionManager.getCellMetadata({\n            index: index\n          });\n        },\n        indices: this._lastRenderedCellIndices,\n        isScrolling: isScrolling\n      });\n    }\n  }, {\n    key: \"_isScrollingChange\",\n    value: function _isScrollingChange(isScrolling) {\n      if (!isScrolling) {\n        this._cellCache = [];\n      }\n    }\n  }, {\n    key: \"_setCollectionViewRef\",\n    value: function _setCollectionViewRef(ref) {\n      this._collectionView = ref;\n    }\n  }]);\n\n  return Collection;\n}(React.PureComponent);\n\n_defineProperty(Collection, \"defaultProps\", {\n  'aria-label': 'grid',\n  cellGroupRenderer: defaultCellGroupRenderer\n});\n\nexport { Collection as default };\nCollection.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  'aria-label': PropTypes.string,\n\n  /**\n   * Number of cells in Collection.\n   */\n  cellCount: PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a group of cells given their indices.\n   * Should implement the following interface: ({\n   *   cellSizeAndPositionGetter:Function,\n   *   indices: Array<number>,\n   *   cellRenderer: Function\n   * }): Array<PropTypes.node>\n   */\n  cellGroupRenderer: PropTypes.func.isRequired,\n\n  /**\n   * Responsible for rendering a cell given an row and column index.\n   * Should implement the following interface: ({ index: number, key: string, style: object }): PropTypes.element\n   */\n  cellRenderer: PropTypes.func.isRequired,\n\n  /**\n   * Callback responsible for returning size and offset/position information for a given cell (index).\n   * ({ index: number }): { height: number, width: number, x: number, y: number }\n   */\n  cellSizeAndPositionGetter: PropTypes.func.isRequired,\n\n  /**\n   * Optionally override the size of the sections a Collection's cells are split into.\n   */\n  sectionSize: PropTypes.number\n} : {};\n\nfunction defaultCellGroupRenderer(_ref4) {\n  var cellCache = _ref4.cellCache,\n      cellRenderer = _ref4.cellRenderer,\n      cellSizeAndPositionGetter = _ref4.cellSizeAndPositionGetter,\n      indices = _ref4.indices,\n      isScrolling = _ref4.isScrolling;\n  return indices.map(function (index) {\n    var cellMetadata = cellSizeAndPositionGetter({\n      index: index\n    });\n    var cellRendererProps = {\n      index: index,\n      isScrolling: isScrolling,\n      key: index,\n      style: {\n        height: cellMetadata.height,\n        left: cellMetadata.x,\n        position: 'absolute',\n        top: cellMetadata.y,\n        width: cellMetadata.width\n      }\n    }; // Avoid re-creating cells while scrolling.\n    // This can lead to the same cell being created many times and can cause performance issues for \"heavy\" cells.\n    // If a scroll is in progress- cache and reuse cells.\n    // This cache will be thrown away once scrolling complets.\n\n    if (isScrolling) {\n      if (!(index in cellCache)) {\n        cellCache[index] = cellRenderer(cellRendererProps);\n      }\n\n      return cellCache[index];\n    } else {\n      return cellRenderer(cellRendererProps);\n    }\n  }).filter(function (renderedCell) {\n    return !!renderedCell;\n  });\n}\n\nimport { bpfrpt_proptype_ScrollPosition } from \"./types\";\nimport { bpfrpt_proptype_SizeInfo } from \"./types\";","import SectionManager from '../SectionManager';\nexport default function calculateSizeAndPositionData(_ref) {\n  var cellCount = _ref.cellCount,\n      cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter,\n      sectionSize = _ref.sectionSize;\n  var cellMetadata = [];\n  var sectionManager = new SectionManager(sectionSize);\n  var height = 0;\n  var width = 0;\n\n  for (var index = 0; index < cellCount; index++) {\n    var cellMetadatum = cellSizeAndPositionGetter({\n      index: index\n    });\n\n    if (cellMetadatum.height == null || isNaN(cellMetadatum.height) || cellMetadatum.width == null || isNaN(cellMetadatum.width) || cellMetadatum.x == null || isNaN(cellMetadatum.x) || cellMetadatum.y == null || isNaN(cellMetadatum.y)) {\n      throw Error(\"Invalid metadata returned for cell \".concat(index, \":\\n        x:\").concat(cellMetadatum.x, \", y:\").concat(cellMetadatum.y, \", width:\").concat(cellMetadatum.width, \", height:\").concat(cellMetadatum.height));\n    }\n\n    height = Math.max(height, cellMetadatum.y + cellMetadatum.height);\n    width = Math.max(width, cellMetadatum.x + cellMetadatum.width);\n    cellMetadata[index] = cellMetadatum;\n    sectionManager.registerCell({\n      cellMetadatum: cellMetadatum,\n      index: index\n    });\n  }\n\n  return {\n    cellMetadata: cellMetadata,\n    height: height,\n    sectionManager: sectionManager,\n    width: width\n  };\n}","import Collection from './Collection';\nexport default Collection;\nexport { Collection };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\n/**\n * High-order component that auto-calculates column-widths for `Grid` cells.\n */\n\nvar ColumnSizer =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(ColumnSizer, _React$PureComponent);\n\n  function ColumnSizer(props, context) {\n    var _this;\n\n    _classCallCheck(this, ColumnSizer);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(ColumnSizer).call(this, props, context));\n    _this._registerChild = _this._registerChild.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(ColumnSizer, [{\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      var _this$props = this.props,\n          columnMaxWidth = _this$props.columnMaxWidth,\n          columnMinWidth = _this$props.columnMinWidth,\n          columnCount = _this$props.columnCount,\n          width = _this$props.width;\n\n      if (columnMaxWidth !== prevProps.columnMaxWidth || columnMinWidth !== prevProps.columnMinWidth || columnCount !== prevProps.columnCount || width !== prevProps.width) {\n        if (this._registeredChild) {\n          this._registeredChild.recomputeGridSize();\n        }\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props2 = this.props,\n          children = _this$props2.children,\n          columnMaxWidth = _this$props2.columnMaxWidth,\n          columnMinWidth = _this$props2.columnMinWidth,\n          columnCount = _this$props2.columnCount,\n          width = _this$props2.width;\n      var safeColumnMinWidth = columnMinWidth || 1;\n      var safeColumnMaxWidth = columnMaxWidth ? Math.min(columnMaxWidth, width) : width;\n      var columnWidth = width / columnCount;\n      columnWidth = Math.max(safeColumnMinWidth, columnWidth);\n      columnWidth = Math.min(safeColumnMaxWidth, columnWidth);\n      columnWidth = Math.floor(columnWidth);\n      var adjustedWidth = Math.min(width, columnWidth * columnCount);\n      return children({\n        adjustedWidth: adjustedWidth,\n        columnWidth: columnWidth,\n        getColumnWidth: function getColumnWidth() {\n          return columnWidth;\n        },\n        registerChild: this._registerChild\n      });\n    }\n  }, {\n    key: \"_registerChild\",\n    value: function _registerChild(child) {\n      if (child && typeof child.recomputeGridSize !== 'function') {\n        throw Error('Unexpected child type registered; only Grid/MultiGrid children are supported.');\n      }\n\n      this._registeredChild = child;\n\n      if (this._registeredChild) {\n        this._registeredChild.recomputeGridSize();\n      }\n    }\n  }]);\n\n  return ColumnSizer;\n}(React.PureComponent);\n\nexport { ColumnSizer as default };\nColumnSizer.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Function responsible for rendering a virtualized Grid.\n   * This function should implement the following signature:\n   * ({ adjustedWidth, getColumnWidth, registerChild }) => PropTypes.element\n   *\n   * The specified :getColumnWidth function should be passed to the Grid's :columnWidth property.\n   * The :registerChild should be passed to the Grid's :ref property.\n   * The :adjustedWidth property is optional; it reflects the lesser of the overall width or the width of all columns.\n   */\n  children: PropTypes.func.isRequired,\n\n  /** Optional maximum allowed column width */\n  columnMaxWidth: PropTypes.number,\n\n  /** Optional minimum allowed column width */\n  columnMinWidth: PropTypes.number,\n\n  /** Number of columns in Grid or Table child */\n  columnCount: PropTypes.number.isRequired,\n\n  /** Width of Grid or Table child */\n  width: PropTypes.number.isRequired\n} : {};","import ColumnSizer from './ColumnSizer';\nexport default ColumnSizer;\nexport { ColumnSizer };","import _toConsumableArray from \"@babel/runtime/helpers/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport createCallbackMemoizer from '../utils/createCallbackMemoizer';\n/**\n * Higher-order component that manages lazy-loading for \"infinite\" data.\n * This component decorates a virtual component and just-in-time prefetches rows as a user scrolls.\n * It is intended as a convenience component; fork it if you'd like finer-grained control over data-loading.\n */\n\nvar InfiniteLoader =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(InfiniteLoader, _React$PureComponent);\n\n  function InfiniteLoader(props, context) {\n    var _this;\n\n    _classCallCheck(this, InfiniteLoader);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(InfiniteLoader).call(this, props, context));\n    _this._loadMoreRowsMemoizer = createCallbackMemoizer();\n    _this._onRowsRendered = _this._onRowsRendered.bind(_assertThisInitialized(_this));\n    _this._registerChild = _this._registerChild.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(InfiniteLoader, [{\n    key: \"resetLoadMoreRowsCache\",\n    value: function resetLoadMoreRowsCache(autoReload) {\n      this._loadMoreRowsMemoizer = createCallbackMemoizer();\n\n      if (autoReload) {\n        this._doStuff(this._lastRenderedStartIndex, this._lastRenderedStopIndex);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      return children({\n        onRowsRendered: this._onRowsRendered,\n        registerChild: this._registerChild\n      });\n    }\n  }, {\n    key: \"_loadUnloadedRanges\",\n    value: function _loadUnloadedRanges(unloadedRanges) {\n      var _this2 = this;\n\n      var loadMoreRows = this.props.loadMoreRows;\n      unloadedRanges.forEach(function (unloadedRange) {\n        var promise = loadMoreRows(unloadedRange);\n\n        if (promise) {\n          promise.then(function () {\n            // Refresh the visible rows if any of them have just been loaded.\n            // Otherwise they will remain in their unloaded visual state.\n            if (isRangeVisible({\n              lastRenderedStartIndex: _this2._lastRenderedStartIndex,\n              lastRenderedStopIndex: _this2._lastRenderedStopIndex,\n              startIndex: unloadedRange.startIndex,\n              stopIndex: unloadedRange.stopIndex\n            })) {\n              if (_this2._registeredChild) {\n                forceUpdateReactVirtualizedComponent(_this2._registeredChild, _this2._lastRenderedStartIndex);\n              }\n            }\n          });\n        }\n      });\n    }\n  }, {\n    key: \"_onRowsRendered\",\n    value: function _onRowsRendered(_ref) {\n      var startIndex = _ref.startIndex,\n          stopIndex = _ref.stopIndex;\n      this._lastRenderedStartIndex = startIndex;\n      this._lastRenderedStopIndex = stopIndex;\n\n      this._doStuff(startIndex, stopIndex);\n    }\n  }, {\n    key: \"_doStuff\",\n    value: function _doStuff(startIndex, stopIndex) {\n      var _ref2,\n          _this3 = this;\n\n      var _this$props = this.props,\n          isRowLoaded = _this$props.isRowLoaded,\n          minimumBatchSize = _this$props.minimumBatchSize,\n          rowCount = _this$props.rowCount,\n          threshold = _this$props.threshold;\n      var unloadedRanges = scanForUnloadedRanges({\n        isRowLoaded: isRowLoaded,\n        minimumBatchSize: minimumBatchSize,\n        rowCount: rowCount,\n        startIndex: Math.max(0, startIndex - threshold),\n        stopIndex: Math.min(rowCount - 1, stopIndex + threshold)\n      }); // For memoize comparison\n\n      var squashedUnloadedRanges = (_ref2 = []).concat.apply(_ref2, _toConsumableArray(unloadedRanges.map(function (_ref3) {\n        var startIndex = _ref3.startIndex,\n            stopIndex = _ref3.stopIndex;\n        return [startIndex, stopIndex];\n      })));\n\n      this._loadMoreRowsMemoizer({\n        callback: function callback() {\n          _this3._loadUnloadedRanges(unloadedRanges);\n        },\n        indices: {\n          squashedUnloadedRanges: squashedUnloadedRanges\n        }\n      });\n    }\n  }, {\n    key: \"_registerChild\",\n    value: function _registerChild(registeredChild) {\n      this._registeredChild = registeredChild;\n    }\n  }]);\n\n  return InfiniteLoader;\n}(React.PureComponent);\n/**\n * Determines if the specified start/stop range is visible based on the most recently rendered range.\n */\n\n\n_defineProperty(InfiniteLoader, \"defaultProps\", {\n  minimumBatchSize: 10,\n  rowCount: 0,\n  threshold: 15\n});\n\nexport { InfiniteLoader as default };\nInfiniteLoader.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Function responsible for rendering a virtualized component.\n   * This function should implement the following signature:\n   * ({ onRowsRendered, registerChild }) => PropTypes.element\n   *\n   * The specified :onRowsRendered function should be passed through to the child's :onRowsRendered property.\n   * The :registerChild callback should be set as the virtualized component's :ref.\n   */\n  children: PropTypes.func.isRequired,\n\n  /**\n   * Function responsible for tracking the loaded state of each row.\n   * It should implement the following signature: ({ index: number }): boolean\n   */\n  isRowLoaded: PropTypes.func.isRequired,\n\n  /**\n   * Callback to be invoked when more rows must be loaded.\n   * It should implement the following signature: ({ startIndex, stopIndex }): Promise\n   * The returned Promise should be resolved once row data has finished loading.\n   * It will be used to determine when to refresh the list with the newly-loaded data.\n   * This callback may be called multiple times in reaction to a single scroll event.\n   */\n  loadMoreRows: PropTypes.func.isRequired,\n\n  /**\n   * Minimum number of rows to be loaded at a time.\n   * This property can be used to batch requests to reduce HTTP requests.\n   */\n  minimumBatchSize: PropTypes.number.isRequired,\n\n  /**\n   * Number of rows in list; can be arbitrary high number if actual number is unknown.\n   */\n  rowCount: PropTypes.number.isRequired,\n\n  /**\n   * Threshold at which to pre-fetch data.\n   * A threshold X means that data will start loading when a user scrolls within X rows.\n   * This value defaults to 15.\n   */\n  threshold: PropTypes.number.isRequired\n} : {};\nexport function isRangeVisible(_ref4) {\n  var lastRenderedStartIndex = _ref4.lastRenderedStartIndex,\n      lastRenderedStopIndex = _ref4.lastRenderedStopIndex,\n      startIndex = _ref4.startIndex,\n      stopIndex = _ref4.stopIndex;\n  return !(startIndex > lastRenderedStopIndex || stopIndex < lastRenderedStartIndex);\n}\n/**\n * Returns all of the ranges within a larger range that contain unloaded rows.\n */\n\nexport function scanForUnloadedRanges(_ref5) {\n  var isRowLoaded = _ref5.isRowLoaded,\n      minimumBatchSize = _ref5.minimumBatchSize,\n      rowCount = _ref5.rowCount,\n      startIndex = _ref5.startIndex,\n      stopIndex = _ref5.stopIndex;\n  var unloadedRanges = [];\n  var rangeStartIndex = null;\n  var rangeStopIndex = null;\n\n  for (var index = startIndex; index <= stopIndex; index++) {\n    var loaded = isRowLoaded({\n      index: index\n    });\n\n    if (!loaded) {\n      rangeStopIndex = index;\n\n      if (rangeStartIndex === null) {\n        rangeStartIndex = index;\n      }\n    } else if (rangeStopIndex !== null) {\n      unloadedRanges.push({\n        startIndex: rangeStartIndex,\n        stopIndex: rangeStopIndex\n      });\n      rangeStartIndex = rangeStopIndex = null;\n    }\n  } // If :rangeStopIndex is not null it means we haven't ran out of unloaded rows.\n  // Scan forward to try filling our :minimumBatchSize.\n\n\n  if (rangeStopIndex !== null) {\n    var potentialStopIndex = Math.min(Math.max(rangeStopIndex, rangeStartIndex + minimumBatchSize - 1), rowCount - 1);\n\n    for (var _index = rangeStopIndex + 1; _index <= potentialStopIndex; _index++) {\n      if (!isRowLoaded({\n        index: _index\n      })) {\n        rangeStopIndex = _index;\n      } else {\n        break;\n      }\n    }\n\n    unloadedRanges.push({\n      startIndex: rangeStartIndex,\n      stopIndex: rangeStopIndex\n    });\n  } // Check to see if our first range ended prematurely.\n  // In this case we should scan backwards to try filling our :minimumBatchSize.\n\n\n  if (unloadedRanges.length) {\n    var firstUnloadedRange = unloadedRanges[0];\n\n    while (firstUnloadedRange.stopIndex - firstUnloadedRange.startIndex + 1 < minimumBatchSize && firstUnloadedRange.startIndex > 0) {\n      var _index2 = firstUnloadedRange.startIndex - 1;\n\n      if (!isRowLoaded({\n        index: _index2\n      })) {\n        firstUnloadedRange.startIndex = _index2;\n      } else {\n        break;\n      }\n    }\n  }\n\n  return unloadedRanges;\n}\n/**\n * Since RV components use shallowCompare we need to force a render (even though props haven't changed).\n * However InfiniteLoader may wrap a Grid or it may wrap a Table or List.\n * In the first case the built-in React forceUpdate() method is sufficient to force a re-render,\n * But in the latter cases we need to use the RV-specific forceUpdateGrid() method.\n * Else the inner Grid will not be re-rendered and visuals may be stale.\n *\n * Additionally, while a Grid is scrolling the cells can be cached,\n * So it's important to invalidate that cache by recalculating sizes\n * before forcing a rerender.\n */\n\nexport function forceUpdateReactVirtualizedComponent(component) {\n  var currentIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var recomputeSize = typeof component.recomputeGridSize === 'function' ? component.recomputeGridSize : component.recomputeRowHeights;\n\n  if (recomputeSize) {\n    recomputeSize.call(component, currentIndex);\n  } else {\n    component.forceUpdate();\n  }\n}","import InfiniteLoader from './InfiniteLoader';\nexport default InfiniteLoader;\nexport { InfiniteLoader };","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nimport Grid, { accessibilityOverscanIndicesGetter } from '../Grid';\nimport * as React from 'react';\nimport clsx from 'clsx';\n/**\n * It is inefficient to create and manage a large list of DOM elements within a scrolling container\n * if only a few of those elements are visible. The primary purpose of this component is to improve\n * performance by only rendering the DOM nodes that a user is able to see based on their current\n * scroll position.\n *\n * This component renders a virtualized list of elements with either fixed or dynamic heights.\n */\n\nvar List = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(List, _React$PureComponent);\n\n  function List() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, List);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(List)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"Grid\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRenderer\", function (_ref) {\n      var parent = _ref.parent,\n          rowIndex = _ref.rowIndex,\n          style = _ref.style,\n          isScrolling = _ref.isScrolling,\n          isVisible = _ref.isVisible,\n          key = _ref.key;\n      var rowRenderer = _this.props.rowRenderer; // TRICKY The style object is sometimes cached by Grid.\n      // This prevents new style objects from bypassing shallowCompare().\n      // However as of React 16, style props are auto-frozen (at least in dev mode)\n      // Check to make sure we can still modify the style before proceeding.\n      // https://github.com/facebook/react/commit/977357765b44af8ff0cfea327866861073095c12#commitcomment-20648713\n\n      var widthDescriptor = Object.getOwnPropertyDescriptor(style, 'width');\n\n      if (widthDescriptor && widthDescriptor.writable) {\n        // By default, List cells should be 100% width.\n        // This prevents them from flowing under a scrollbar (if present).\n        style.width = '100%';\n      }\n\n      return rowRenderer({\n        index: rowIndex,\n        style: style,\n        isScrolling: isScrolling,\n        isVisible: isVisible,\n        key: key,\n        parent: parent\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setRef\", function (ref) {\n      _this.Grid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (_ref2) {\n      var clientHeight = _ref2.clientHeight,\n          scrollHeight = _ref2.scrollHeight,\n          scrollTop = _ref2.scrollTop;\n      var onScroll = _this.props.onScroll;\n      onScroll({\n        clientHeight: clientHeight,\n        scrollHeight: scrollHeight,\n        scrollTop: scrollTop\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onSectionRendered\", function (_ref3) {\n      var rowOverscanStartIndex = _ref3.rowOverscanStartIndex,\n          rowOverscanStopIndex = _ref3.rowOverscanStopIndex,\n          rowStartIndex = _ref3.rowStartIndex,\n          rowStopIndex = _ref3.rowStopIndex;\n      var onRowsRendered = _this.props.onRowsRendered;\n      onRowsRendered({\n        overscanStartIndex: rowOverscanStartIndex,\n        overscanStopIndex: rowOverscanStopIndex,\n        startIndex: rowStartIndex,\n        stopIndex: rowStopIndex\n      });\n    });\n\n    return _this;\n  }\n\n  _createClass(List, [{\n    key: \"forceUpdateGrid\",\n    value: function forceUpdateGrid() {\n      if (this.Grid) {\n        this.Grid.forceUpdate();\n      }\n    }\n    /** See Grid#getOffsetForCell */\n\n  }, {\n    key: \"getOffsetForRow\",\n    value: function getOffsetForRow(_ref4) {\n      var alignment = _ref4.alignment,\n          index = _ref4.index;\n\n      if (this.Grid) {\n        var _this$Grid$getOffsetF = this.Grid.getOffsetForCell({\n          alignment: alignment,\n          rowIndex: index,\n          columnIndex: 0\n        }),\n            scrollTop = _this$Grid$getOffsetF.scrollTop;\n\n        return scrollTop;\n      }\n\n      return 0;\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref5) {\n      var columnIndex = _ref5.columnIndex,\n          rowIndex = _ref5.rowIndex;\n\n      if (this.Grid) {\n        this.Grid.invalidateCellSizeAfterRender({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: \"measureAllRows\",\n    value: function measureAllRows() {\n      if (this.Grid) {\n        this.Grid.measureAllCells();\n      }\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref6$columnIndex = _ref6.columnIndex,\n          columnIndex = _ref6$columnIndex === void 0 ? 0 : _ref6$columnIndex,\n          _ref6$rowIndex = _ref6.rowIndex,\n          rowIndex = _ref6$rowIndex === void 0 ? 0 : _ref6$rowIndex;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: \"recomputeRowHeights\",\n    value: function recomputeRowHeights() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: index,\n          columnIndex: 0\n        });\n      }\n    }\n    /** See Grid#scrollToPosition */\n\n  }, {\n    key: \"scrollToPosition\",\n    value: function scrollToPosition() {\n      var scrollTop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToPosition({\n          scrollTop: scrollTop\n        });\n      }\n    }\n    /** See Grid#scrollToCell */\n\n  }, {\n    key: \"scrollToRow\",\n    value: function scrollToRow() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToCell({\n          columnIndex: 0,\n          rowIndex: index\n        });\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props = this.props,\n          className = _this$props.className,\n          noRowsRenderer = _this$props.noRowsRenderer,\n          scrollToIndex = _this$props.scrollToIndex,\n          width = _this$props.width;\n      var classNames = clsx('ReactVirtualized__List', className);\n      return React.createElement(Grid, _extends({}, this.props, {\n        autoContainerWidth: true,\n        cellRenderer: this._cellRenderer,\n        className: classNames,\n        columnWidth: width,\n        columnCount: 1,\n        noContentRenderer: noRowsRenderer,\n        onScroll: this._onScroll,\n        onSectionRendered: this._onSectionRendered,\n        ref: this._setRef,\n        scrollToRow: scrollToIndex\n      }));\n    }\n  }]);\n\n  return List;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"aria-label\": PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  \"autoHeight\": PropTypes.bool.isRequired,\n\n  /** Optional CSS class name */\n  \"className\": PropTypes.string,\n\n  /**\n   * Used to estimate the total height of a List before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  \"estimatedRowSize\": PropTypes.number.isRequired,\n\n  /** Height constraint for list (determines how many actual rows are rendered) */\n  \"height\": PropTypes.number.isRequired,\n\n  /** Optional renderer to be used in place of rows when rowCount is 0 */\n  \"noRowsRenderer\": function noRowsRenderer() {\n    return (typeof bpfrpt_proptype_NoContentRenderer === \"function\" ? bpfrpt_proptype_NoContentRenderer.isRequired ? bpfrpt_proptype_NoContentRenderer.isRequired : bpfrpt_proptype_NoContentRenderer : PropTypes.shape(bpfrpt_proptype_NoContentRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Callback invoked with information about the slice of rows that were just rendered.  */\n  \"onRowsRendered\": PropTypes.func.isRequired,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   */\n  \"onScroll\": PropTypes.func.isRequired,\n\n  /** See Grid#overscanIndicesGetter */\n  \"overscanIndicesGetter\": function overscanIndicesGetter() {\n    return (typeof bpfrpt_proptype_OverscanIndicesGetter === \"function\" ? bpfrpt_proptype_OverscanIndicesGetter.isRequired ? bpfrpt_proptype_OverscanIndicesGetter.isRequired : bpfrpt_proptype_OverscanIndicesGetter : PropTypes.shape(bpfrpt_proptype_OverscanIndicesGetter).isRequired).apply(this, arguments);\n  },\n\n  /**\n   * Number of rows to render above/below the visible bounds of the list.\n   * These rows can help for smoother scrolling on touch devices.\n   */\n  \"overscanRowCount\": PropTypes.number.isRequired,\n\n  /** Either a fixed row height (number) or a function that returns the height of a row given its index.  */\n  \"rowHeight\": function rowHeight() {\n    return (typeof bpfrpt_proptype_CellSize === \"function\" ? bpfrpt_proptype_CellSize.isRequired ? bpfrpt_proptype_CellSize.isRequired : bpfrpt_proptype_CellSize : PropTypes.shape(bpfrpt_proptype_CellSize).isRequired).apply(this, arguments);\n  },\n\n  /** Responsible for rendering a row given an index; ({ index: number }): node */\n  \"rowRenderer\": function rowRenderer() {\n    return (typeof bpfrpt_proptype_RowRenderer === \"function\" ? bpfrpt_proptype_RowRenderer.isRequired ? bpfrpt_proptype_RowRenderer.isRequired : bpfrpt_proptype_RowRenderer : PropTypes.shape(bpfrpt_proptype_RowRenderer).isRequired).apply(this, arguments);\n  },\n\n  /** Number of rows in list. */\n  \"rowCount\": PropTypes.number.isRequired,\n\n  /** See Grid#scrollToAlignment */\n  \"scrollToAlignment\": function scrollToAlignment() {\n    return (typeof bpfrpt_proptype_Alignment === \"function\" ? bpfrpt_proptype_Alignment.isRequired ? bpfrpt_proptype_Alignment.isRequired : bpfrpt_proptype_Alignment : PropTypes.shape(bpfrpt_proptype_Alignment).isRequired).apply(this, arguments);\n  },\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  \"scrollToIndex\": PropTypes.number.isRequired,\n\n  /** Vertical offset. */\n  \"scrollTop\": PropTypes.number,\n\n  /** Optional inline style */\n  \"style\": PropTypes.object.isRequired,\n\n  /** Tab index for focus */\n  \"tabIndex\": PropTypes.number,\n\n  /** Width of list */\n  \"width\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(List, \"defaultProps\", {\n  autoHeight: false,\n  estimatedRowSize: 30,\n  onScroll: function onScroll() {},\n  noRowsRenderer: function noRowsRenderer() {\n    return null;\n  },\n  onRowsRendered: function onRowsRendered() {},\n  overscanIndicesGetter: accessibilityOverscanIndicesGetter,\n  overscanRowCount: 10,\n  scrollToAlignment: 'auto',\n  scrollToIndex: -1,\n  style: {}\n});\n\nexport { List as default };\nimport { bpfrpt_proptype_NoContentRenderer } from \"../Grid\";\nimport { bpfrpt_proptype_Alignment } from \"../Grid\";\nimport { bpfrpt_proptype_CellSize } from \"../Grid\";\nimport { bpfrpt_proptype_CellPosition } from \"../Grid\";\nimport { bpfrpt_proptype_OverscanIndicesGetter } from \"../Grid\";\nimport { bpfrpt_proptype_RenderedSection } from \"../Grid\";\nimport { bpfrpt_proptype_CellRendererParams } from \"../Grid\";\nimport { bpfrpt_proptype_Scroll as bpfrpt_proptype_GridScroll } from \"../Grid\";\nimport { bpfrpt_proptype_RowRenderer } from \"./types\";\nimport { bpfrpt_proptype_RenderedRows } from \"./types\";\nimport { bpfrpt_proptype_Scroll } from \"./types\";\nimport PropTypes from \"prop-types\";","/**\n * Binary Search Bounds\n * https://github.com/mikolalysenko/binary-search-bounds\n * Mikola Lysenko\n *\n * Inlined because of Content Security Policy issue caused by the use of `new Function(...)` syntax.\n * Issue reported here: https://github.com/mikolalysenko/binary-search-bounds/issues/5\n **/\nfunction _GEA(a, l, h, y) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x >= y) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _GEP(a, l, h, y, c) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) >= 0) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchGE(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _GEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _GEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _GTA(a, l, h, y) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x > y) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _GTP(a, l, h, y, c) {\n  var i = h + 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) > 0) {\n      i = m;\n      h = m - 1;\n    } else {\n      l = m + 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchGT(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _GTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _GTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _LTA(a, l, h, y) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x < y) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _LTP(a, l, h, y, c) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) < 0) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchLT(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _LTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _LTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _LEA(a, l, h, y) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x <= y) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction _LEP(a, l, h, y, c) {\n  var i = l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (c(x, y) <= 0) {\n      i = m;\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return i;\n}\n\nfunction dispatchBsearchLE(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _LEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _LEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nfunction _EQA(a, l, h, y) {\n  l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n\n    if (x === y) {\n      return m;\n    } else if (x <= y) {\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return -1;\n}\n\nfunction _EQP(a, l, h, y, c) {\n  l - 1;\n\n  while (l <= h) {\n    var m = l + h >>> 1,\n        x = a[m];\n    var p = c(x, y);\n\n    if (p === 0) {\n      return m;\n    } else if (p <= 0) {\n      l = m + 1;\n    } else {\n      h = m - 1;\n    }\n  }\n\n  return -1;\n}\n\nfunction dispatchBsearchEQ(a, y, c, l, h) {\n  if (typeof c === 'function') {\n    return _EQP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);\n  } else {\n    return _EQA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);\n  }\n}\n\nexport default {\n  ge: dispatchBsearchGE,\n  gt: dispatchBsearchGT,\n  lt: dispatchBsearchLT,\n  le: dispatchBsearchLE,\n  eq: dispatchBsearchEQ\n};","/**\n * Binary Search Bounds\n * https://github.com/mikolalysenko/interval-tree-1d\n * Mikola Lysenko\n *\n * Inlined because of Content Security Policy issue caused by the use of `new Function(...)` syntax in an upstream dependency.\n * Issue reported here: https://github.com/mikolalysenko/binary-search-bounds/issues/5\n **/\nimport bounds from './binarySearchBounds';\nvar NOT_FOUND = 0;\nvar SUCCESS = 1;\nvar EMPTY = 2;\n\nfunction IntervalTreeNode(mid, left, right, leftPoints, rightPoints) {\n  this.mid = mid;\n  this.left = left;\n  this.right = right;\n  this.leftPoints = leftPoints;\n  this.rightPoints = rightPoints;\n  this.count = (left ? left.count : 0) + (right ? right.count : 0) + leftPoints.length;\n}\n\nvar proto = IntervalTreeNode.prototype;\n\nfunction copy(a, b) {\n  a.mid = b.mid;\n  a.left = b.left;\n  a.right = b.right;\n  a.leftPoints = b.leftPoints;\n  a.rightPoints = b.rightPoints;\n  a.count = b.count;\n}\n\nfunction rebuild(node, intervals) {\n  var ntree = createIntervalTree(intervals);\n  node.mid = ntree.mid;\n  node.left = ntree.left;\n  node.right = ntree.right;\n  node.leftPoints = ntree.leftPoints;\n  node.rightPoints = ntree.rightPoints;\n  node.count = ntree.count;\n}\n\nfunction rebuildWithInterval(node, interval) {\n  var intervals = node.intervals([]);\n  intervals.push(interval);\n  rebuild(node, intervals);\n}\n\nfunction rebuildWithoutInterval(node, interval) {\n  var intervals = node.intervals([]);\n  var idx = intervals.indexOf(interval);\n\n  if (idx < 0) {\n    return NOT_FOUND;\n  }\n\n  intervals.splice(idx, 1);\n  rebuild(node, intervals);\n  return SUCCESS;\n}\n\nproto.intervals = function (result) {\n  result.push.apply(result, this.leftPoints);\n\n  if (this.left) {\n    this.left.intervals(result);\n  }\n\n  if (this.right) {\n    this.right.intervals(result);\n  }\n\n  return result;\n};\n\nproto.insert = function (interval) {\n  var weight = this.count - this.leftPoints.length;\n  this.count += 1;\n\n  if (interval[1] < this.mid) {\n    if (this.left) {\n      if (4 * (this.left.count + 1) > 3 * (weight + 1)) {\n        rebuildWithInterval(this, interval);\n      } else {\n        this.left.insert(interval);\n      }\n    } else {\n      this.left = createIntervalTree([interval]);\n    }\n  } else if (interval[0] > this.mid) {\n    if (this.right) {\n      if (4 * (this.right.count + 1) > 3 * (weight + 1)) {\n        rebuildWithInterval(this, interval);\n      } else {\n        this.right.insert(interval);\n      }\n    } else {\n      this.right = createIntervalTree([interval]);\n    }\n  } else {\n    var l = bounds.ge(this.leftPoints, interval, compareBegin);\n    var r = bounds.ge(this.rightPoints, interval, compareEnd);\n    this.leftPoints.splice(l, 0, interval);\n    this.rightPoints.splice(r, 0, interval);\n  }\n};\n\nproto.remove = function (interval) {\n  var weight = this.count - this.leftPoints;\n\n  if (interval[1] < this.mid) {\n    if (!this.left) {\n      return NOT_FOUND;\n    }\n\n    var rw = this.right ? this.right.count : 0;\n\n    if (4 * rw > 3 * (weight - 1)) {\n      return rebuildWithoutInterval(this, interval);\n    }\n\n    var r = this.left.remove(interval);\n\n    if (r === EMPTY) {\n      this.left = null;\n      this.count -= 1;\n      return SUCCESS;\n    } else if (r === SUCCESS) {\n      this.count -= 1;\n    }\n\n    return r;\n  } else if (interval[0] > this.mid) {\n    if (!this.right) {\n      return NOT_FOUND;\n    }\n\n    var lw = this.left ? this.left.count : 0;\n\n    if (4 * lw > 3 * (weight - 1)) {\n      return rebuildWithoutInterval(this, interval);\n    }\n\n    var r = this.right.remove(interval);\n\n    if (r === EMPTY) {\n      this.right = null;\n      this.count -= 1;\n      return SUCCESS;\n    } else if (r === SUCCESS) {\n      this.count -= 1;\n    }\n\n    return r;\n  } else {\n    if (this.count === 1) {\n      if (this.leftPoints[0] === interval) {\n        return EMPTY;\n      } else {\n        return NOT_FOUND;\n      }\n    }\n\n    if (this.leftPoints.length === 1 && this.leftPoints[0] === interval) {\n      if (this.left && this.right) {\n        var p = this;\n        var n = this.left;\n\n        while (n.right) {\n          p = n;\n          n = n.right;\n        }\n\n        if (p === this) {\n          n.right = this.right;\n        } else {\n          var l = this.left;\n          var r = this.right;\n          p.count -= n.count;\n          p.right = n.left;\n          n.left = l;\n          n.right = r;\n        }\n\n        copy(this, n);\n        this.count = (this.left ? this.left.count : 0) + (this.right ? this.right.count : 0) + this.leftPoints.length;\n      } else if (this.left) {\n        copy(this, this.left);\n      } else {\n        copy(this, this.right);\n      }\n\n      return SUCCESS;\n    }\n\n    for (var l = bounds.ge(this.leftPoints, interval, compareBegin); l < this.leftPoints.length; ++l) {\n      if (this.leftPoints[l][0] !== interval[0]) {\n        break;\n      }\n\n      if (this.leftPoints[l] === interval) {\n        this.count -= 1;\n        this.leftPoints.splice(l, 1);\n\n        for (var r = bounds.ge(this.rightPoints, interval, compareEnd); r < this.rightPoints.length; ++r) {\n          if (this.rightPoints[r][1] !== interval[1]) {\n            break;\n          } else if (this.rightPoints[r] === interval) {\n            this.rightPoints.splice(r, 1);\n            return SUCCESS;\n          }\n        }\n      }\n    }\n\n    return NOT_FOUND;\n  }\n};\n\nfunction reportLeftRange(arr, hi, cb) {\n  for (var i = 0; i < arr.length && arr[i][0] <= hi; ++i) {\n    var r = cb(arr[i]);\n\n    if (r) {\n      return r;\n    }\n  }\n}\n\nfunction reportRightRange(arr, lo, cb) {\n  for (var i = arr.length - 1; i >= 0 && arr[i][1] >= lo; --i) {\n    var r = cb(arr[i]);\n\n    if (r) {\n      return r;\n    }\n  }\n}\n\nfunction reportRange(arr, cb) {\n  for (var i = 0; i < arr.length; ++i) {\n    var r = cb(arr[i]);\n\n    if (r) {\n      return r;\n    }\n  }\n}\n\nproto.queryPoint = function (x, cb) {\n  if (x < this.mid) {\n    if (this.left) {\n      var r = this.left.queryPoint(x, cb);\n\n      if (r) {\n        return r;\n      }\n    }\n\n    return reportLeftRange(this.leftPoints, x, cb);\n  } else if (x > this.mid) {\n    if (this.right) {\n      var r = this.right.queryPoint(x, cb);\n\n      if (r) {\n        return r;\n      }\n    }\n\n    return reportRightRange(this.rightPoints, x, cb);\n  } else {\n    return reportRange(this.leftPoints, cb);\n  }\n};\n\nproto.queryInterval = function (lo, hi, cb) {\n  if (lo < this.mid && this.left) {\n    var r = this.left.queryInterval(lo, hi, cb);\n\n    if (r) {\n      return r;\n    }\n  }\n\n  if (hi > this.mid && this.right) {\n    var r = this.right.queryInterval(lo, hi, cb);\n\n    if (r) {\n      return r;\n    }\n  }\n\n  if (hi < this.mid) {\n    return reportLeftRange(this.leftPoints, hi, cb);\n  } else if (lo > this.mid) {\n    return reportRightRange(this.rightPoints, lo, cb);\n  } else {\n    return reportRange(this.leftPoints, cb);\n  }\n};\n\nfunction compareNumbers(a, b) {\n  return a - b;\n}\n\nfunction compareBegin(a, b) {\n  var d = a[0] - b[0];\n\n  if (d) {\n    return d;\n  }\n\n  return a[1] - b[1];\n}\n\nfunction compareEnd(a, b) {\n  var d = a[1] - b[1];\n\n  if (d) {\n    return d;\n  }\n\n  return a[0] - b[0];\n}\n\nfunction createIntervalTree(intervals) {\n  if (intervals.length === 0) {\n    return null;\n  }\n\n  var pts = [];\n\n  for (var i = 0; i < intervals.length; ++i) {\n    pts.push(intervals[i][0], intervals[i][1]);\n  }\n\n  pts.sort(compareNumbers);\n  var mid = pts[pts.length >> 1];\n  var leftIntervals = [];\n  var rightIntervals = [];\n  var centerIntervals = [];\n\n  for (var i = 0; i < intervals.length; ++i) {\n    var s = intervals[i];\n\n    if (s[1] < mid) {\n      leftIntervals.push(s);\n    } else if (mid < s[0]) {\n      rightIntervals.push(s);\n    } else {\n      centerIntervals.push(s);\n    }\n  } //Split center intervals\n\n\n  var leftPoints = centerIntervals;\n  var rightPoints = centerIntervals.slice();\n  leftPoints.sort(compareBegin);\n  rightPoints.sort(compareEnd);\n  return new IntervalTreeNode(mid, createIntervalTree(leftIntervals), createIntervalTree(rightIntervals), leftPoints, rightPoints);\n} //User friendly wrapper that makes it possible to support empty trees\n\n\nfunction IntervalTree(root) {\n  this.root = root;\n}\n\nvar tproto = IntervalTree.prototype;\n\ntproto.insert = function (interval) {\n  if (this.root) {\n    this.root.insert(interval);\n  } else {\n    this.root = new IntervalTreeNode(interval[0], null, null, [interval], [interval]);\n  }\n};\n\ntproto.remove = function (interval) {\n  if (this.root) {\n    var r = this.root.remove(interval);\n\n    if (r === EMPTY) {\n      this.root = null;\n    }\n\n    return r !== NOT_FOUND;\n  }\n\n  return false;\n};\n\ntproto.queryPoint = function (p, cb) {\n  if (this.root) {\n    return this.root.queryPoint(p, cb);\n  }\n};\n\ntproto.queryInterval = function (lo, hi, cb) {\n  if (lo <= hi && this.root) {\n    return this.root.queryInterval(lo, hi, cb);\n  }\n};\n\nObject.defineProperty(tproto, 'count', {\n  get: function get() {\n    if (this.root) {\n      return this.root.count;\n    }\n\n    return 0;\n  }\n});\nObject.defineProperty(tproto, 'intervals', {\n  get: function get() {\n    if (this.root) {\n      return this.root.intervals([]);\n    }\n\n    return [];\n  }\n});\nexport default function createWrapper(intervals) {\n  if (!intervals || intervals.length === 0) {\n    return new IntervalTree(null);\n  }\n\n  return new IntervalTree(createIntervalTree(intervals));\n}","import _slicedToArray from \"@babel/runtime/helpers/slicedToArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport createIntervalTree from '../vendor/intervalTree';\n\n// Position cache requirements:\n//   O(log(n)) lookup of cells to render for a given viewport size\n//   O(1) lookup of shortest measured column (so we know when to enter phase 1)\nvar PositionCache =\n/*#__PURE__*/\nfunction () {\n  function PositionCache() {\n    _classCallCheck(this, PositionCache);\n\n    _defineProperty(this, \"_columnSizeMap\", {});\n\n    _defineProperty(this, \"_intervalTree\", createIntervalTree());\n\n    _defineProperty(this, \"_leftMap\", {});\n  }\n\n  _createClass(PositionCache, [{\n    key: \"estimateTotalHeight\",\n    value: function estimateTotalHeight(cellCount, columnCount, defaultCellHeight) {\n      var unmeasuredCellCount = cellCount - this.count;\n      return this.tallestColumnSize + Math.ceil(unmeasuredCellCount / columnCount) * defaultCellHeight;\n    } // Render all cells visible within the viewport range defined.\n\n  }, {\n    key: \"range\",\n    value: function range(scrollTop, clientHeight, renderCallback) {\n      var _this = this;\n\n      this._intervalTree.queryInterval(scrollTop, scrollTop + clientHeight, function (_ref) {\n        var _ref2 = _slicedToArray(_ref, 3),\n            top = _ref2[0],\n            _ = _ref2[1],\n            index = _ref2[2];\n\n        return renderCallback(index, _this._leftMap[index], top);\n      });\n    }\n  }, {\n    key: \"setPosition\",\n    value: function setPosition(index, left, top, height) {\n      this._intervalTree.insert([top, top + height, index]);\n\n      this._leftMap[index] = left;\n      var columnSizeMap = this._columnSizeMap;\n      var columnHeight = columnSizeMap[left];\n\n      if (columnHeight === undefined) {\n        columnSizeMap[left] = top + height;\n      } else {\n        columnSizeMap[left] = Math.max(columnHeight, top + height);\n      }\n    }\n  }, {\n    key: \"count\",\n    get: function get() {\n      return this._intervalTree.count;\n    }\n  }, {\n    key: \"shortestColumnSize\",\n    get: function get() {\n      var columnSizeMap = this._columnSizeMap;\n      var size = 0;\n\n      for (var i in columnSizeMap) {\n        var height = columnSizeMap[i];\n        size = size === 0 ? height : Math.min(size, height);\n      }\n\n      return size;\n    }\n  }, {\n    key: \"tallestColumnSize\",\n    get: function get() {\n      var columnSizeMap = this._columnSizeMap;\n      var size = 0;\n\n      for (var i in columnSizeMap) {\n        var height = columnSizeMap[i];\n        size = Math.max(size, height);\n      }\n\n      return size;\n    }\n  }]);\n\n  return PositionCache;\n}();\n\nexport { PositionCache as default };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport clsx from 'clsx';\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\nimport PositionCache from './PositionCache';\nimport { requestAnimationTimeout, cancelAnimationTimeout } from '../utils/requestAnimationTimeout';\nvar emptyObject = {};\n/**\n * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\n\nexport var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;\n/**\n * This component efficiently displays arbitrarily positioned cells using windowing techniques.\n * Cell position is determined by an injected `cellPositioner` property.\n * Windowing is vertical; this component does not support horizontal scrolling.\n *\n * Rendering occurs in two phases:\n * 1) First pass uses estimated cell sizes (provided by the cache) to determine how many cells to measure in a batch.\n *    Batch size is chosen using a fast, naive layout algorithm that stacks images in order until the viewport has been filled.\n *    After measurement is complete (componentDidMount or componentDidUpdate) this component evaluates positioned cells\n *    in order to determine if another measurement pass is required (eg if actual cell sizes were less than estimated sizes).\n *    All measurements are permanently cached (keyed by `keyMapper`) for performance purposes.\n * 2) Second pass uses the external `cellPositioner` to layout cells.\n *    At this time the positioner has access to cached size measurements for all cells.\n *    The positions it returns are cached by Masonry for fast access later.\n *    Phase one is repeated if the user scrolls beyond the current layout's bounds.\n *    If the layout is invalidated due to eg a resize, cached positions can be cleared using `recomputeCellPositions()`.\n *\n * Animation constraints:\n *   Simple animations are supported (eg translate/slide into place on initial reveal).\n *   More complex animations are not (eg flying from one position to another on resize).\n *\n * Layout constraints:\n *   This component supports multi-column layout.\n *   The height of each item may vary.\n *   The width of each item must not exceed the width of the column it is \"in\".\n *   The left position of all items within a column must align.\n *   (Items may not span multiple columns.)\n */\n\nvar Masonry = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Masonry, _React$PureComponent);\n\n  function Masonry() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, Masonry);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Masonry)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      isScrolling: false,\n      scrollTop: 0\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_debounceResetIsScrollingId\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_invalidateOnUpdateStartIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_invalidateOnUpdateStopIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_positionCache\", new PositionCache());\n\n    _defineProperty(_assertThisInitialized(_this), \"_startIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_startIndexMemoized\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_stopIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_stopIndexMemoized\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_debounceResetIsScrollingCallback\", function () {\n      _this.setState({\n        isScrolling: false\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_setScrollingContainerRef\", function (ref) {\n      _this._scrollingContainer = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (event) {\n      var height = _this.props.height;\n      var eventScrollTop = event.currentTarget.scrollTop; // When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,\n      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.\n      // This causes a series of rapid renders that is slow for long lists.\n      // We can avoid that by doing some simple bounds checking to ensure that scroll offsets never exceed their bounds.\n\n      var scrollTop = Math.min(Math.max(0, _this._getEstimatedTotalHeight() - height), eventScrollTop); // On iOS, we can arrive at negative offsets by swiping past the start or end.\n      // Avoid re-rendering in this case as it can cause problems; see #532 for more.\n\n      if (eventScrollTop !== scrollTop) {\n        return;\n      } // Prevent pointer events from interrupting a smooth scroll\n\n\n      _this._debounceResetIsScrolling(); // Certain devices (like Apple touchpad) rapid-fire duplicate events.\n      // Don't force a re-render if this is the case.\n      // The mouse may move faster then the animation frame does.\n      // Use requestAnimationFrame to avoid over-updating.\n\n\n      if (_this.state.scrollTop !== scrollTop) {\n        _this.setState({\n          isScrolling: true,\n          scrollTop: scrollTop\n        });\n      }\n    });\n\n    return _this;\n  }\n\n  _createClass(Masonry, [{\n    key: \"clearCellPositions\",\n    value: function clearCellPositions() {\n      this._positionCache = new PositionCache();\n      this.forceUpdate();\n    } // HACK This method signature was intended for Grid\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref) {\n      var index = _ref.rowIndex;\n\n      if (this._invalidateOnUpdateStartIndex === null) {\n        this._invalidateOnUpdateStartIndex = index;\n        this._invalidateOnUpdateStopIndex = index;\n      } else {\n        this._invalidateOnUpdateStartIndex = Math.min(this._invalidateOnUpdateStartIndex, index);\n        this._invalidateOnUpdateStopIndex = Math.max(this._invalidateOnUpdateStopIndex, index);\n      }\n    }\n  }, {\n    key: \"recomputeCellPositions\",\n    value: function recomputeCellPositions() {\n      var stopIndex = this._positionCache.count - 1;\n      this._positionCache = new PositionCache();\n\n      this._populatePositionCache(0, stopIndex);\n\n      this.forceUpdate();\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._checkInvalidateOnUpdate();\n\n      this._invokeOnScrollCallback();\n\n      this._invokeOnCellsRenderedCallback();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      this._checkInvalidateOnUpdate();\n\n      this._invokeOnScrollCallback();\n\n      this._invokeOnCellsRenderedCallback();\n\n      if (this.props.scrollTop !== prevProps.scrollTop) {\n        this._debounceResetIsScrolling();\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this._debounceResetIsScrollingId) {\n        cancelAnimationTimeout(this._debounceResetIsScrollingId);\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this2 = this;\n\n      var _this$props = this.props,\n          autoHeight = _this$props.autoHeight,\n          cellCount = _this$props.cellCount,\n          cellMeasurerCache = _this$props.cellMeasurerCache,\n          cellRenderer = _this$props.cellRenderer,\n          className = _this$props.className,\n          height = _this$props.height,\n          id = _this$props.id,\n          keyMapper = _this$props.keyMapper,\n          overscanByPixels = _this$props.overscanByPixels,\n          role = _this$props.role,\n          style = _this$props.style,\n          tabIndex = _this$props.tabIndex,\n          width = _this$props.width,\n          rowDirection = _this$props.rowDirection;\n      var _this$state = this.state,\n          isScrolling = _this$state.isScrolling,\n          scrollTop = _this$state.scrollTop;\n      var children = [];\n\n      var estimateTotalHeight = this._getEstimatedTotalHeight();\n\n      var shortestColumnSize = this._positionCache.shortestColumnSize;\n      var measuredCellCount = this._positionCache.count;\n      var startIndex = 0;\n      var stopIndex;\n\n      this._positionCache.range(Math.max(0, scrollTop - overscanByPixels), height + overscanByPixels * 2, function (index, left, top) {\n        var _style;\n\n        if (typeof stopIndex === 'undefined') {\n          startIndex = index;\n          stopIndex = index;\n        } else {\n          startIndex = Math.min(startIndex, index);\n          stopIndex = Math.max(stopIndex, index);\n        }\n\n        children.push(cellRenderer({\n          index: index,\n          isScrolling: isScrolling,\n          key: keyMapper(index),\n          parent: _this2,\n          style: (_style = {\n            height: cellMeasurerCache.getHeight(index)\n          }, _defineProperty(_style, rowDirection === 'ltr' ? 'left' : 'right', left), _defineProperty(_style, \"position\", 'absolute'), _defineProperty(_style, \"top\", top), _defineProperty(_style, \"width\", cellMeasurerCache.getWidth(index)), _style)\n        }));\n      }); // We need to measure additional cells for this layout\n\n\n      if (shortestColumnSize < scrollTop + height + overscanByPixels && measuredCellCount < cellCount) {\n        var batchSize = Math.min(cellCount - measuredCellCount, Math.ceil((scrollTop + height + overscanByPixels - shortestColumnSize) / cellMeasurerCache.defaultHeight * width / cellMeasurerCache.defaultWidth));\n\n        for (var _index = measuredCellCount; _index < measuredCellCount + batchSize; _index++) {\n          stopIndex = _index;\n          children.push(cellRenderer({\n            index: _index,\n            isScrolling: isScrolling,\n            key: keyMapper(_index),\n            parent: this,\n            style: {\n              width: cellMeasurerCache.getWidth(_index)\n            }\n          }));\n        }\n      }\n\n      this._startIndex = startIndex;\n      this._stopIndex = stopIndex;\n      return React.createElement(\"div\", {\n        ref: this._setScrollingContainerRef,\n        \"aria-label\": this.props['aria-label'],\n        className: clsx('ReactVirtualized__Masonry', className),\n        id: id,\n        onScroll: this._onScroll,\n        role: role,\n        style: _objectSpread({\n          boxSizing: 'border-box',\n          direction: 'ltr',\n          height: autoHeight ? 'auto' : height,\n          overflowX: 'hidden',\n          overflowY: estimateTotalHeight < height ? 'hidden' : 'auto',\n          position: 'relative',\n          width: width,\n          WebkitOverflowScrolling: 'touch',\n          willChange: 'transform'\n        }, style),\n        tabIndex: tabIndex\n      }, React.createElement(\"div\", {\n        className: \"ReactVirtualized__Masonry__innerScrollContainer\",\n        style: {\n          width: '100%',\n          height: estimateTotalHeight,\n          maxWidth: '100%',\n          maxHeight: estimateTotalHeight,\n          overflow: 'hidden',\n          pointerEvents: isScrolling ? 'none' : '',\n          position: 'relative'\n        }\n      }, children));\n    }\n  }, {\n    key: \"_checkInvalidateOnUpdate\",\n    value: function _checkInvalidateOnUpdate() {\n      if (typeof this._invalidateOnUpdateStartIndex === 'number') {\n        var startIndex = this._invalidateOnUpdateStartIndex;\n        var stopIndex = this._invalidateOnUpdateStopIndex;\n        this._invalidateOnUpdateStartIndex = null;\n        this._invalidateOnUpdateStopIndex = null; // Query external layout logic for position of newly-measured cells\n\n        this._populatePositionCache(startIndex, stopIndex);\n\n        this.forceUpdate();\n      }\n    }\n  }, {\n    key: \"_debounceResetIsScrolling\",\n    value: function _debounceResetIsScrolling() {\n      var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval;\n\n      if (this._debounceResetIsScrollingId) {\n        cancelAnimationTimeout(this._debounceResetIsScrollingId);\n      }\n\n      this._debounceResetIsScrollingId = requestAnimationTimeout(this._debounceResetIsScrollingCallback, scrollingResetTimeInterval);\n    }\n  }, {\n    key: \"_getEstimatedTotalHeight\",\n    value: function _getEstimatedTotalHeight() {\n      var _this$props2 = this.props,\n          cellCount = _this$props2.cellCount,\n          cellMeasurerCache = _this$props2.cellMeasurerCache,\n          width = _this$props2.width;\n      var estimatedColumnCount = Math.max(1, Math.floor(width / cellMeasurerCache.defaultWidth));\n      return this._positionCache.estimateTotalHeight(cellCount, estimatedColumnCount, cellMeasurerCache.defaultHeight);\n    }\n  }, {\n    key: \"_invokeOnScrollCallback\",\n    value: function _invokeOnScrollCallback() {\n      var _this$props3 = this.props,\n          height = _this$props3.height,\n          onScroll = _this$props3.onScroll;\n      var scrollTop = this.state.scrollTop;\n\n      if (this._onScrollMemoized !== scrollTop) {\n        onScroll({\n          clientHeight: height,\n          scrollHeight: this._getEstimatedTotalHeight(),\n          scrollTop: scrollTop\n        });\n        this._onScrollMemoized = scrollTop;\n      }\n    }\n  }, {\n    key: \"_invokeOnCellsRenderedCallback\",\n    value: function _invokeOnCellsRenderedCallback() {\n      if (this._startIndexMemoized !== this._startIndex || this._stopIndexMemoized !== this._stopIndex) {\n        var onCellsRendered = this.props.onCellsRendered;\n        onCellsRendered({\n          startIndex: this._startIndex,\n          stopIndex: this._stopIndex\n        });\n        this._startIndexMemoized = this._startIndex;\n        this._stopIndexMemoized = this._stopIndex;\n      }\n    }\n  }, {\n    key: \"_populatePositionCache\",\n    value: function _populatePositionCache(startIndex, stopIndex) {\n      var _this$props4 = this.props,\n          cellMeasurerCache = _this$props4.cellMeasurerCache,\n          cellPositioner = _this$props4.cellPositioner;\n\n      for (var _index2 = startIndex; _index2 <= stopIndex; _index2++) {\n        var _cellPositioner = cellPositioner(_index2),\n            left = _cellPositioner.left,\n            top = _cellPositioner.top;\n\n        this._positionCache.setPosition(_index2, left, top, cellMeasurerCache.getHeight(_index2));\n      }\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.scrollTop !== undefined && prevState.scrollTop !== nextProps.scrollTop) {\n        return {\n          isScrolling: true,\n          scrollTop: nextProps.scrollTop\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return Masonry;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  \"autoHeight\": PropTypes.bool.isRequired,\n  \"cellCount\": PropTypes.number.isRequired,\n  \"cellMeasurerCache\": function cellMeasurerCache() {\n    return (typeof CellMeasurerCache === \"function\" ? PropTypes.instanceOf(CellMeasurerCache).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"cellPositioner\": function cellPositioner() {\n    return (typeof Positioner === \"function\" ? PropTypes.instanceOf(Positioner).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"cellRenderer\": function cellRenderer() {\n    return (typeof CellRenderer === \"function\" ? PropTypes.instanceOf(CellRenderer).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"className\": PropTypes.string,\n  \"height\": PropTypes.number.isRequired,\n  \"id\": PropTypes.string,\n  \"keyMapper\": function keyMapper() {\n    return (typeof KeyMapper === \"function\" ? PropTypes.instanceOf(KeyMapper).isRequired : PropTypes.any.isRequired).apply(this, arguments);\n  },\n  \"onCellsRendered\": function onCellsRendered() {\n    return (typeof OnCellsRenderedCallback === \"function\" ? PropTypes.instanceOf(OnCellsRenderedCallback) : PropTypes.any).apply(this, arguments);\n  },\n  \"onScroll\": function onScroll() {\n    return (typeof OnScrollCallback === \"function\" ? PropTypes.instanceOf(OnScrollCallback) : PropTypes.any).apply(this, arguments);\n  },\n  \"overscanByPixels\": PropTypes.number.isRequired,\n  \"role\": PropTypes.string.isRequired,\n  \"scrollingResetTimeInterval\": PropTypes.number.isRequired,\n  \"style\": function style(props, propName, componentName) {\n    if (!Object.prototype.hasOwnProperty.call(props, propName)) {\n      throw new Error(\"Prop `\".concat(propName, \"` has type 'any' or 'mixed', but was not provided to `\").concat(componentName, \"`. Pass undefined or any other value.\"));\n    }\n  },\n  \"tabIndex\": PropTypes.number.isRequired,\n  \"width\": PropTypes.number.isRequired,\n  \"rowDirection\": PropTypes.string.isRequired,\n  \"scrollTop\": PropTypes.number\n}), _temp);\n\n_defineProperty(Masonry, \"defaultProps\", {\n  autoHeight: false,\n  keyMapper: identity,\n  onCellsRendered: noop,\n  onScroll: noop,\n  overscanByPixels: 20,\n  role: 'grid',\n  scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL,\n  style: emptyObject,\n  tabIndex: 0,\n  rowDirection: 'ltr'\n});\n\nfunction identity(value) {\n  return value;\n}\n\nfunction noop() {}\n\nvar bpfrpt_proptype_CellMeasurerCache = process.env.NODE_ENV === 'production' ? null : {\n  \"defaultHeight\": PropTypes.number.isRequired,\n  \"defaultWidth\": PropTypes.number.isRequired,\n  \"getHeight\": PropTypes.func.isRequired,\n  \"getWidth\": PropTypes.func.isRequired\n};\npolyfill(Masonry);\nexport default Masonry;\nvar bpfrpt_proptype_Positioner = process.env.NODE_ENV === 'production' ? null : PropTypes.func;\nimport { bpfrpt_proptype_AnimationTimeoutId } from \"../utils/requestAnimationTimeout\";\nimport PropTypes from \"prop-types\";\nexport { bpfrpt_proptype_CellMeasurerCache };\nexport { bpfrpt_proptype_Positioner };","export default function createCellPositioner(_ref) {\n  var cellMeasurerCache = _ref.cellMeasurerCache,\n      columnCount = _ref.columnCount,\n      columnWidth = _ref.columnWidth,\n      _ref$spacer = _ref.spacer,\n      spacer = _ref$spacer === void 0 ? 0 : _ref$spacer;\n  var columnHeights;\n  initOrResetDerivedValues();\n\n  function cellPositioner(index) {\n    // Find the shortest column and use it.\n    var columnIndex = 0;\n\n    for (var i = 1; i < columnHeights.length; i++) {\n      if (columnHeights[i] < columnHeights[columnIndex]) {\n        columnIndex = i;\n      }\n    }\n\n    var left = columnIndex * (columnWidth + spacer);\n    var top = columnHeights[columnIndex] || 0;\n    columnHeights[columnIndex] = top + cellMeasurerCache.getHeight(index) + spacer;\n    return {\n      left: left,\n      top: top\n    };\n  }\n\n  function initOrResetDerivedValues() {\n    // Track the height of each column.\n    // Layout algorithm below always inserts into the shortest column.\n    columnHeights = [];\n\n    for (var i = 0; i < columnCount; i++) {\n      columnHeights[i] = 0;\n    }\n  }\n\n  function reset(params) {\n    columnCount = params.columnCount;\n    columnWidth = params.columnWidth;\n    spacer = params.spacer;\n    initOrResetDerivedValues();\n  }\n\n  cellPositioner.reset = reset;\n  return cellPositioner;\n}\nimport { bpfrpt_proptype_CellMeasurerCache } from \"./Masonry\";\nimport { bpfrpt_proptype_Positioner } from \"./Masonry\";","import createCellPositioner from './createCellPositioner';\nimport Masonry from './Masonry';\nexport default Masonry;\nexport { createCellPositioner, Masonry };","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport { CellMeasurerCache } from '../CellMeasurer';\n\n/**\n * Caches measurements for a given cell.\n */\nvar CellMeasurerCacheDecorator =\n/*#__PURE__*/\nfunction () {\n  function CellMeasurerCacheDecorator() {\n    var _this = this;\n\n    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, CellMeasurerCacheDecorator);\n\n    _defineProperty(this, \"_cellMeasurerCache\", void 0);\n\n    _defineProperty(this, \"_columnIndexOffset\", void 0);\n\n    _defineProperty(this, \"_rowIndexOffset\", void 0);\n\n    _defineProperty(this, \"columnWidth\", function (_ref) {\n      var index = _ref.index;\n\n      _this._cellMeasurerCache.columnWidth({\n        index: index + _this._columnIndexOffset\n      });\n    });\n\n    _defineProperty(this, \"rowHeight\", function (_ref2) {\n      var index = _ref2.index;\n\n      _this._cellMeasurerCache.rowHeight({\n        index: index + _this._rowIndexOffset\n      });\n    });\n\n    var cellMeasurerCache = params.cellMeasurerCache,\n        _params$columnIndexOf = params.columnIndexOffset,\n        columnIndexOffset = _params$columnIndexOf === void 0 ? 0 : _params$columnIndexOf,\n        _params$rowIndexOffse = params.rowIndexOffset,\n        rowIndexOffset = _params$rowIndexOffse === void 0 ? 0 : _params$rowIndexOffse;\n    this._cellMeasurerCache = cellMeasurerCache;\n    this._columnIndexOffset = columnIndexOffset;\n    this._rowIndexOffset = rowIndexOffset;\n  }\n\n  _createClass(CellMeasurerCacheDecorator, [{\n    key: \"clear\",\n    value: function clear(rowIndex, columnIndex) {\n      this._cellMeasurerCache.clear(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"clearAll\",\n    value: function clearAll() {\n      this._cellMeasurerCache.clearAll();\n    }\n  }, {\n    key: \"hasFixedHeight\",\n    value: function hasFixedHeight() {\n      return this._cellMeasurerCache.hasFixedHeight();\n    }\n  }, {\n    key: \"hasFixedWidth\",\n    value: function hasFixedWidth() {\n      return this._cellMeasurerCache.hasFixedWidth();\n    }\n  }, {\n    key: \"getHeight\",\n    value: function getHeight(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      return this._cellMeasurerCache.getHeight(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"getWidth\",\n    value: function getWidth(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      return this._cellMeasurerCache.getWidth(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"has\",\n    value: function has(rowIndex) {\n      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      return this._cellMeasurerCache.has(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset);\n    }\n  }, {\n    key: \"set\",\n    value: function set(rowIndex, columnIndex, width, height) {\n      this._cellMeasurerCache.set(rowIndex + this._rowIndexOffset, columnIndex + this._columnIndexOffset, width, height);\n    }\n  }, {\n    key: \"defaultHeight\",\n    get: function get() {\n      return this._cellMeasurerCache.defaultHeight;\n    }\n  }, {\n    key: \"defaultWidth\",\n    get: function get() {\n      return this._cellMeasurerCache.defaultWidth;\n    }\n  }]);\n\n  return CellMeasurerCacheDecorator;\n}();\n\nexport { CellMeasurerCacheDecorator as default };","import _extends from \"@babel/runtime/helpers/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport { polyfill } from 'react-lifecycles-compat';\nimport CellMeasurerCacheDecorator from './CellMeasurerCacheDecorator';\nimport Grid from '../Grid';\nvar SCROLLBAR_SIZE_BUFFER = 20;\n/**\n * Renders 1, 2, or 4 Grids depending on configuration.\n * A main (body) Grid will always be rendered.\n * Optionally, 1-2 Grids for sticky header rows will also be rendered.\n * If no sticky columns, only 1 sticky header Grid will be rendered.\n * If sticky columns, 2 sticky header Grids will be rendered.\n */\n\nvar MultiGrid =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(MultiGrid, _React$PureComponent);\n\n  function MultiGrid(props, context) {\n    var _this;\n\n    _classCallCheck(this, MultiGrid);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(MultiGrid).call(this, props, context));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      scrollLeft: 0,\n      scrollTop: 0,\n      scrollbarSize: 0,\n      showHorizontalScrollbar: false,\n      showVerticalScrollbar: false\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateColumnIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_deferredInvalidateRowIndex\", null);\n\n    _defineProperty(_assertThisInitialized(_this), \"_bottomLeftGridRef\", function (ref) {\n      _this._bottomLeftGrid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_bottomRightGridRef\", function (ref) {\n      _this._bottomRightGrid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRendererBottomLeftGrid\", function (_ref) {\n      var rowIndex = _ref.rowIndex,\n          rest = _objectWithoutProperties(_ref, [\"rowIndex\"]);\n\n      var _this$props = _this.props,\n          cellRenderer = _this$props.cellRenderer,\n          fixedRowCount = _this$props.fixedRowCount,\n          rowCount = _this$props.rowCount;\n\n      if (rowIndex === rowCount - fixedRowCount) {\n        return React.createElement(\"div\", {\n          key: rest.key,\n          style: _objectSpread({}, rest.style, {\n            height: SCROLLBAR_SIZE_BUFFER\n          })\n        });\n      } else {\n        return cellRenderer(_objectSpread({}, rest, {\n          parent: _assertThisInitialized(_this),\n          rowIndex: rowIndex + fixedRowCount\n        }));\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRendererBottomRightGrid\", function (_ref2) {\n      var columnIndex = _ref2.columnIndex,\n          rowIndex = _ref2.rowIndex,\n          rest = _objectWithoutProperties(_ref2, [\"columnIndex\", \"rowIndex\"]);\n\n      var _this$props2 = _this.props,\n          cellRenderer = _this$props2.cellRenderer,\n          fixedColumnCount = _this$props2.fixedColumnCount,\n          fixedRowCount = _this$props2.fixedRowCount;\n      return cellRenderer(_objectSpread({}, rest, {\n        columnIndex: columnIndex + fixedColumnCount,\n        parent: _assertThisInitialized(_this),\n        rowIndex: rowIndex + fixedRowCount\n      }));\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_cellRendererTopRightGrid\", function (_ref3) {\n      var columnIndex = _ref3.columnIndex,\n          rest = _objectWithoutProperties(_ref3, [\"columnIndex\"]);\n\n      var _this$props3 = _this.props,\n          cellRenderer = _this$props3.cellRenderer,\n          columnCount = _this$props3.columnCount,\n          fixedColumnCount = _this$props3.fixedColumnCount;\n\n      if (columnIndex === columnCount - fixedColumnCount) {\n        return React.createElement(\"div\", {\n          key: rest.key,\n          style: _objectSpread({}, rest.style, {\n            width: SCROLLBAR_SIZE_BUFFER\n          })\n        });\n      } else {\n        return cellRenderer(_objectSpread({}, rest, {\n          columnIndex: columnIndex + fixedColumnCount,\n          parent: _assertThisInitialized(_this)\n        }));\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_columnWidthRightGrid\", function (_ref4) {\n      var index = _ref4.index;\n      var _this$props4 = _this.props,\n          columnCount = _this$props4.columnCount,\n          fixedColumnCount = _this$props4.fixedColumnCount,\n          columnWidth = _this$props4.columnWidth;\n      var _this$state = _this.state,\n          scrollbarSize = _this$state.scrollbarSize,\n          showHorizontalScrollbar = _this$state.showHorizontalScrollbar; // An extra cell is added to the count\n      // This gives the smaller Grid extra room for offset,\n      // In case the main (bottom right) Grid has a scrollbar\n      // If no scrollbar, the extra space is overflow:hidden anyway\n\n      if (showHorizontalScrollbar && index === columnCount - fixedColumnCount) {\n        return scrollbarSize;\n      }\n\n      return typeof columnWidth === 'function' ? columnWidth({\n        index: index + fixedColumnCount\n      }) : columnWidth;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScroll\", function (scrollInfo) {\n      var scrollLeft = scrollInfo.scrollLeft,\n          scrollTop = scrollInfo.scrollTop;\n\n      _this.setState({\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop\n      });\n\n      var onScroll = _this.props.onScroll;\n\n      if (onScroll) {\n        onScroll(scrollInfo);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollbarPresenceChange\", function (_ref5) {\n      var horizontal = _ref5.horizontal,\n          size = _ref5.size,\n          vertical = _ref5.vertical;\n      var _this$state2 = _this.state,\n          showHorizontalScrollbar = _this$state2.showHorizontalScrollbar,\n          showVerticalScrollbar = _this$state2.showVerticalScrollbar;\n\n      if (horizontal !== showHorizontalScrollbar || vertical !== showVerticalScrollbar) {\n        _this.setState({\n          scrollbarSize: size,\n          showHorizontalScrollbar: horizontal,\n          showVerticalScrollbar: vertical\n        });\n\n        var onScrollbarPresenceChange = _this.props.onScrollbarPresenceChange;\n\n        if (typeof onScrollbarPresenceChange === 'function') {\n          onScrollbarPresenceChange({\n            horizontal: horizontal,\n            size: size,\n            vertical: vertical\n          });\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollLeft\", function (scrollInfo) {\n      var scrollLeft = scrollInfo.scrollLeft;\n\n      _this._onScroll({\n        scrollLeft: scrollLeft,\n        scrollTop: _this.state.scrollTop\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onScrollTop\", function (scrollInfo) {\n      var scrollTop = scrollInfo.scrollTop;\n\n      _this._onScroll({\n        scrollTop: scrollTop,\n        scrollLeft: _this.state.scrollLeft\n      });\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_rowHeightBottomGrid\", function (_ref6) {\n      var index = _ref6.index;\n      var _this$props5 = _this.props,\n          fixedRowCount = _this$props5.fixedRowCount,\n          rowCount = _this$props5.rowCount,\n          rowHeight = _this$props5.rowHeight;\n      var _this$state3 = _this.state,\n          scrollbarSize = _this$state3.scrollbarSize,\n          showVerticalScrollbar = _this$state3.showVerticalScrollbar; // An extra cell is added to the count\n      // This gives the smaller Grid extra room for offset,\n      // In case the main (bottom right) Grid has a scrollbar\n      // If no scrollbar, the extra space is overflow:hidden anyway\n\n      if (showVerticalScrollbar && index === rowCount - fixedRowCount) {\n        return scrollbarSize;\n      }\n\n      return typeof rowHeight === 'function' ? rowHeight({\n        index: index + fixedRowCount\n      }) : rowHeight;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_topLeftGridRef\", function (ref) {\n      _this._topLeftGrid = ref;\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_topRightGridRef\", function (ref) {\n      _this._topRightGrid = ref;\n    });\n\n    var deferredMeasurementCache = props.deferredMeasurementCache,\n        _fixedColumnCount = props.fixedColumnCount,\n        _fixedRowCount = props.fixedRowCount;\n\n    _this._maybeCalculateCachedStyles(true);\n\n    if (deferredMeasurementCache) {\n      _this._deferredMeasurementCacheBottomLeftGrid = _fixedRowCount > 0 ? new CellMeasurerCacheDecorator({\n        cellMeasurerCache: deferredMeasurementCache,\n        columnIndexOffset: 0,\n        rowIndexOffset: _fixedRowCount\n      }) : deferredMeasurementCache;\n      _this._deferredMeasurementCacheBottomRightGrid = _fixedColumnCount > 0 || _fixedRowCount > 0 ? new CellMeasurerCacheDecorator({\n        cellMeasurerCache: deferredMeasurementCache,\n        columnIndexOffset: _fixedColumnCount,\n        rowIndexOffset: _fixedRowCount\n      }) : deferredMeasurementCache;\n      _this._deferredMeasurementCacheTopRightGrid = _fixedColumnCount > 0 ? new CellMeasurerCacheDecorator({\n        cellMeasurerCache: deferredMeasurementCache,\n        columnIndexOffset: _fixedColumnCount,\n        rowIndexOffset: 0\n      }) : deferredMeasurementCache;\n    }\n\n    return _this;\n  }\n\n  _createClass(MultiGrid, [{\n    key: \"forceUpdateGrids\",\n    value: function forceUpdateGrids() {\n      this._bottomLeftGrid && this._bottomLeftGrid.forceUpdate();\n      this._bottomRightGrid && this._bottomRightGrid.forceUpdate();\n      this._topLeftGrid && this._topLeftGrid.forceUpdate();\n      this._topRightGrid && this._topRightGrid.forceUpdate();\n    }\n    /** See Grid#invalidateCellSizeAfterRender */\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender() {\n      var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref7$columnIndex = _ref7.columnIndex,\n          columnIndex = _ref7$columnIndex === void 0 ? 0 : _ref7$columnIndex,\n          _ref7$rowIndex = _ref7.rowIndex,\n          rowIndex = _ref7$rowIndex === void 0 ? 0 : _ref7$rowIndex;\n\n      this._deferredInvalidateColumnIndex = typeof this._deferredInvalidateColumnIndex === 'number' ? Math.min(this._deferredInvalidateColumnIndex, columnIndex) : columnIndex;\n      this._deferredInvalidateRowIndex = typeof this._deferredInvalidateRowIndex === 'number' ? Math.min(this._deferredInvalidateRowIndex, rowIndex) : rowIndex;\n    }\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: \"measureAllCells\",\n    value: function measureAllCells() {\n      this._bottomLeftGrid && this._bottomLeftGrid.measureAllCells();\n      this._bottomRightGrid && this._bottomRightGrid.measureAllCells();\n      this._topLeftGrid && this._topLeftGrid.measureAllCells();\n      this._topRightGrid && this._topRightGrid.measureAllCells();\n    }\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref8$columnIndex = _ref8.columnIndex,\n          columnIndex = _ref8$columnIndex === void 0 ? 0 : _ref8$columnIndex,\n          _ref8$rowIndex = _ref8.rowIndex,\n          rowIndex = _ref8$rowIndex === void 0 ? 0 : _ref8$rowIndex;\n\n      var _this$props6 = this.props,\n          fixedColumnCount = _this$props6.fixedColumnCount,\n          fixedRowCount = _this$props6.fixedRowCount;\n      var adjustedColumnIndex = Math.max(0, columnIndex - fixedColumnCount);\n      var adjustedRowIndex = Math.max(0, rowIndex - fixedRowCount);\n      this._bottomLeftGrid && this._bottomLeftGrid.recomputeGridSize({\n        columnIndex: columnIndex,\n        rowIndex: adjustedRowIndex\n      });\n      this._bottomRightGrid && this._bottomRightGrid.recomputeGridSize({\n        columnIndex: adjustedColumnIndex,\n        rowIndex: adjustedRowIndex\n      });\n      this._topLeftGrid && this._topLeftGrid.recomputeGridSize({\n        columnIndex: columnIndex,\n        rowIndex: rowIndex\n      });\n      this._topRightGrid && this._topRightGrid.recomputeGridSize({\n        columnIndex: adjustedColumnIndex,\n        rowIndex: rowIndex\n      });\n      this._leftGridWidth = null;\n      this._topGridHeight = null;\n\n      this._maybeCalculateCachedStyles(true);\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var _this$props7 = this.props,\n          scrollLeft = _this$props7.scrollLeft,\n          scrollTop = _this$props7.scrollTop;\n\n      if (scrollLeft > 0 || scrollTop > 0) {\n        var newState = {};\n\n        if (scrollLeft > 0) {\n          newState.scrollLeft = scrollLeft;\n        }\n\n        if (scrollTop > 0) {\n          newState.scrollTop = scrollTop;\n        }\n\n        this.setState(newState);\n      }\n\n      this._handleInvalidatedGridSize();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate() {\n      this._handleInvalidatedGridSize();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this$props8 = this.props,\n          onScroll = _this$props8.onScroll,\n          onSectionRendered = _this$props8.onSectionRendered,\n          onScrollbarPresenceChange = _this$props8.onScrollbarPresenceChange,\n          scrollLeftProp = _this$props8.scrollLeft,\n          scrollToColumn = _this$props8.scrollToColumn,\n          scrollTopProp = _this$props8.scrollTop,\n          scrollToRow = _this$props8.scrollToRow,\n          rest = _objectWithoutProperties(_this$props8, [\"onScroll\", \"onSectionRendered\", \"onScrollbarPresenceChange\", \"scrollLeft\", \"scrollToColumn\", \"scrollTop\", \"scrollToRow\"]);\n\n      this._prepareForRender(); // Don't render any of our Grids if there are no cells.\n      // This mirrors what Grid does,\n      // And prevents us from recording inaccurage measurements when used with CellMeasurer.\n\n\n      if (this.props.width === 0 || this.props.height === 0) {\n        return null;\n      } // scrollTop and scrollLeft props are explicitly filtered out and ignored\n\n\n      var _this$state4 = this.state,\n          scrollLeft = _this$state4.scrollLeft,\n          scrollTop = _this$state4.scrollTop;\n      return React.createElement(\"div\", {\n        style: this._containerOuterStyle\n      }, React.createElement(\"div\", {\n        style: this._containerTopStyle\n      }, this._renderTopLeftGrid(rest), this._renderTopRightGrid(_objectSpread({}, rest, {\n        onScroll: onScroll,\n        scrollLeft: scrollLeft\n      }))), React.createElement(\"div\", {\n        style: this._containerBottomStyle\n      }, this._renderBottomLeftGrid(_objectSpread({}, rest, {\n        onScroll: onScroll,\n        scrollTop: scrollTop\n      })), this._renderBottomRightGrid(_objectSpread({}, rest, {\n        onScroll: onScroll,\n        onSectionRendered: onSectionRendered,\n        scrollLeft: scrollLeft,\n        scrollToColumn: scrollToColumn,\n        scrollToRow: scrollToRow,\n        scrollTop: scrollTop\n      }))));\n    }\n  }, {\n    key: \"_getBottomGridHeight\",\n    value: function _getBottomGridHeight(props) {\n      var height = props.height;\n\n      var topGridHeight = this._getTopGridHeight(props);\n\n      return height - topGridHeight;\n    }\n  }, {\n    key: \"_getLeftGridWidth\",\n    value: function _getLeftGridWidth(props) {\n      var fixedColumnCount = props.fixedColumnCount,\n          columnWidth = props.columnWidth;\n\n      if (this._leftGridWidth == null) {\n        if (typeof columnWidth === 'function') {\n          var leftGridWidth = 0;\n\n          for (var index = 0; index < fixedColumnCount; index++) {\n            leftGridWidth += columnWidth({\n              index: index\n            });\n          }\n\n          this._leftGridWidth = leftGridWidth;\n        } else {\n          this._leftGridWidth = columnWidth * fixedColumnCount;\n        }\n      }\n\n      return this._leftGridWidth;\n    }\n  }, {\n    key: \"_getRightGridWidth\",\n    value: function _getRightGridWidth(props) {\n      var width = props.width;\n\n      var leftGridWidth = this._getLeftGridWidth(props);\n\n      return width - leftGridWidth;\n    }\n  }, {\n    key: \"_getTopGridHeight\",\n    value: function _getTopGridHeight(props) {\n      var fixedRowCount = props.fixedRowCount,\n          rowHeight = props.rowHeight;\n\n      if (this._topGridHeight == null) {\n        if (typeof rowHeight === 'function') {\n          var topGridHeight = 0;\n\n          for (var index = 0; index < fixedRowCount; index++) {\n            topGridHeight += rowHeight({\n              index: index\n            });\n          }\n\n          this._topGridHeight = topGridHeight;\n        } else {\n          this._topGridHeight = rowHeight * fixedRowCount;\n        }\n      }\n\n      return this._topGridHeight;\n    }\n  }, {\n    key: \"_handleInvalidatedGridSize\",\n    value: function _handleInvalidatedGridSize() {\n      if (typeof this._deferredInvalidateColumnIndex === 'number') {\n        var columnIndex = this._deferredInvalidateColumnIndex;\n        var rowIndex = this._deferredInvalidateRowIndex;\n        this._deferredInvalidateColumnIndex = null;\n        this._deferredInvalidateRowIndex = null;\n        this.recomputeGridSize({\n          columnIndex: columnIndex,\n          rowIndex: rowIndex\n        });\n        this.forceUpdate();\n      }\n    }\n    /**\n     * Avoid recreating inline styles each render; this bypasses Grid's shallowCompare.\n     * This method recalculates styles only when specific props change.\n     */\n\n  }, {\n    key: \"_maybeCalculateCachedStyles\",\n    value: function _maybeCalculateCachedStyles(resetAll) {\n      var _this$props9 = this.props,\n          columnWidth = _this$props9.columnWidth,\n          enableFixedColumnScroll = _this$props9.enableFixedColumnScroll,\n          enableFixedRowScroll = _this$props9.enableFixedRowScroll,\n          height = _this$props9.height,\n          fixedColumnCount = _this$props9.fixedColumnCount,\n          fixedRowCount = _this$props9.fixedRowCount,\n          rowHeight = _this$props9.rowHeight,\n          style = _this$props9.style,\n          styleBottomLeftGrid = _this$props9.styleBottomLeftGrid,\n          styleBottomRightGrid = _this$props9.styleBottomRightGrid,\n          styleTopLeftGrid = _this$props9.styleTopLeftGrid,\n          styleTopRightGrid = _this$props9.styleTopRightGrid,\n          width = _this$props9.width;\n      var sizeChange = resetAll || height !== this._lastRenderedHeight || width !== this._lastRenderedWidth;\n      var leftSizeChange = resetAll || columnWidth !== this._lastRenderedColumnWidth || fixedColumnCount !== this._lastRenderedFixedColumnCount;\n      var topSizeChange = resetAll || fixedRowCount !== this._lastRenderedFixedRowCount || rowHeight !== this._lastRenderedRowHeight;\n\n      if (resetAll || sizeChange || style !== this._lastRenderedStyle) {\n        this._containerOuterStyle = _objectSpread({\n          height: height,\n          overflow: 'visible',\n          // Let :focus outline show through\n          width: width\n        }, style);\n      }\n\n      if (resetAll || sizeChange || topSizeChange) {\n        this._containerTopStyle = {\n          height: this._getTopGridHeight(this.props),\n          position: 'relative',\n          width: width\n        };\n        this._containerBottomStyle = {\n          height: height - this._getTopGridHeight(this.props),\n          overflow: 'visible',\n          // Let :focus outline show through\n          position: 'relative',\n          width: width\n        };\n      }\n\n      if (resetAll || styleBottomLeftGrid !== this._lastRenderedStyleBottomLeftGrid) {\n        this._bottomLeftGridStyle = _objectSpread({\n          left: 0,\n          overflowX: 'hidden',\n          overflowY: enableFixedColumnScroll ? 'auto' : 'hidden',\n          position: 'absolute'\n        }, styleBottomLeftGrid);\n      }\n\n      if (resetAll || leftSizeChange || styleBottomRightGrid !== this._lastRenderedStyleBottomRightGrid) {\n        this._bottomRightGridStyle = _objectSpread({\n          left: this._getLeftGridWidth(this.props),\n          position: 'absolute'\n        }, styleBottomRightGrid);\n      }\n\n      if (resetAll || styleTopLeftGrid !== this._lastRenderedStyleTopLeftGrid) {\n        this._topLeftGridStyle = _objectSpread({\n          left: 0,\n          overflowX: 'hidden',\n          overflowY: 'hidden',\n          position: 'absolute',\n          top: 0\n        }, styleTopLeftGrid);\n      }\n\n      if (resetAll || leftSizeChange || styleTopRightGrid !== this._lastRenderedStyleTopRightGrid) {\n        this._topRightGridStyle = _objectSpread({\n          left: this._getLeftGridWidth(this.props),\n          overflowX: enableFixedRowScroll ? 'auto' : 'hidden',\n          overflowY: 'hidden',\n          position: 'absolute',\n          top: 0\n        }, styleTopRightGrid);\n      }\n\n      this._lastRenderedColumnWidth = columnWidth;\n      this._lastRenderedFixedColumnCount = fixedColumnCount;\n      this._lastRenderedFixedRowCount = fixedRowCount;\n      this._lastRenderedHeight = height;\n      this._lastRenderedRowHeight = rowHeight;\n      this._lastRenderedStyle = style;\n      this._lastRenderedStyleBottomLeftGrid = styleBottomLeftGrid;\n      this._lastRenderedStyleBottomRightGrid = styleBottomRightGrid;\n      this._lastRenderedStyleTopLeftGrid = styleTopLeftGrid;\n      this._lastRenderedStyleTopRightGrid = styleTopRightGrid;\n      this._lastRenderedWidth = width;\n    }\n  }, {\n    key: \"_prepareForRender\",\n    value: function _prepareForRender() {\n      if (this._lastRenderedColumnWidth !== this.props.columnWidth || this._lastRenderedFixedColumnCount !== this.props.fixedColumnCount) {\n        this._leftGridWidth = null;\n      }\n\n      if (this._lastRenderedFixedRowCount !== this.props.fixedRowCount || this._lastRenderedRowHeight !== this.props.rowHeight) {\n        this._topGridHeight = null;\n      }\n\n      this._maybeCalculateCachedStyles();\n\n      this._lastRenderedColumnWidth = this.props.columnWidth;\n      this._lastRenderedFixedColumnCount = this.props.fixedColumnCount;\n      this._lastRenderedFixedRowCount = this.props.fixedRowCount;\n      this._lastRenderedRowHeight = this.props.rowHeight;\n    }\n  }, {\n    key: \"_renderBottomLeftGrid\",\n    value: function _renderBottomLeftGrid(props) {\n      var enableFixedColumnScroll = props.enableFixedColumnScroll,\n          fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount,\n          rowCount = props.rowCount,\n          hideBottomLeftGridScrollbar = props.hideBottomLeftGridScrollbar;\n      var showVerticalScrollbar = this.state.showVerticalScrollbar;\n\n      if (!fixedColumnCount) {\n        return null;\n      }\n\n      var additionalRowCount = showVerticalScrollbar ? 1 : 0,\n          height = this._getBottomGridHeight(props),\n          width = this._getLeftGridWidth(props),\n          scrollbarSize = this.state.showVerticalScrollbar ? this.state.scrollbarSize : 0,\n          gridWidth = hideBottomLeftGridScrollbar ? width + scrollbarSize : width;\n\n      var bottomLeftGrid = React.createElement(Grid, _extends({}, props, {\n        cellRenderer: this._cellRendererBottomLeftGrid,\n        className: this.props.classNameBottomLeftGrid,\n        columnCount: fixedColumnCount,\n        deferredMeasurementCache: this._deferredMeasurementCacheBottomLeftGrid,\n        height: height,\n        onScroll: enableFixedColumnScroll ? this._onScrollTop : undefined,\n        ref: this._bottomLeftGridRef,\n        rowCount: Math.max(0, rowCount - fixedRowCount) + additionalRowCount,\n        rowHeight: this._rowHeightBottomGrid,\n        style: this._bottomLeftGridStyle,\n        tabIndex: null,\n        width: gridWidth\n      }));\n\n      if (hideBottomLeftGridScrollbar) {\n        return React.createElement(\"div\", {\n          className: \"BottomLeftGrid_ScrollWrapper\",\n          style: _objectSpread({}, this._bottomLeftGridStyle, {\n            height: height,\n            width: width,\n            overflowY: 'hidden'\n          })\n        }, bottomLeftGrid);\n      }\n\n      return bottomLeftGrid;\n    }\n  }, {\n    key: \"_renderBottomRightGrid\",\n    value: function _renderBottomRightGrid(props) {\n      var columnCount = props.columnCount,\n          fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount,\n          rowCount = props.rowCount,\n          scrollToColumn = props.scrollToColumn,\n          scrollToRow = props.scrollToRow;\n      return React.createElement(Grid, _extends({}, props, {\n        cellRenderer: this._cellRendererBottomRightGrid,\n        className: this.props.classNameBottomRightGrid,\n        columnCount: Math.max(0, columnCount - fixedColumnCount),\n        columnWidth: this._columnWidthRightGrid,\n        deferredMeasurementCache: this._deferredMeasurementCacheBottomRightGrid,\n        height: this._getBottomGridHeight(props),\n        onScroll: this._onScroll,\n        onScrollbarPresenceChange: this._onScrollbarPresenceChange,\n        ref: this._bottomRightGridRef,\n        rowCount: Math.max(0, rowCount - fixedRowCount),\n        rowHeight: this._rowHeightBottomGrid,\n        scrollToColumn: scrollToColumn - fixedColumnCount,\n        scrollToRow: scrollToRow - fixedRowCount,\n        style: this._bottomRightGridStyle,\n        width: this._getRightGridWidth(props)\n      }));\n    }\n  }, {\n    key: \"_renderTopLeftGrid\",\n    value: function _renderTopLeftGrid(props) {\n      var fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount;\n\n      if (!fixedColumnCount || !fixedRowCount) {\n        return null;\n      }\n\n      return React.createElement(Grid, _extends({}, props, {\n        className: this.props.classNameTopLeftGrid,\n        columnCount: fixedColumnCount,\n        height: this._getTopGridHeight(props),\n        ref: this._topLeftGridRef,\n        rowCount: fixedRowCount,\n        style: this._topLeftGridStyle,\n        tabIndex: null,\n        width: this._getLeftGridWidth(props)\n      }));\n    }\n  }, {\n    key: \"_renderTopRightGrid\",\n    value: function _renderTopRightGrid(props) {\n      var columnCount = props.columnCount,\n          enableFixedRowScroll = props.enableFixedRowScroll,\n          fixedColumnCount = props.fixedColumnCount,\n          fixedRowCount = props.fixedRowCount,\n          scrollLeft = props.scrollLeft,\n          hideTopRightGridScrollbar = props.hideTopRightGridScrollbar;\n      var _this$state5 = this.state,\n          showHorizontalScrollbar = _this$state5.showHorizontalScrollbar,\n          scrollbarSize = _this$state5.scrollbarSize;\n\n      if (!fixedRowCount) {\n        return null;\n      }\n\n      var additionalColumnCount = showHorizontalScrollbar ? 1 : 0,\n          height = this._getTopGridHeight(props),\n          width = this._getRightGridWidth(props),\n          additionalHeight = showHorizontalScrollbar ? scrollbarSize : 0;\n\n      var gridHeight = height,\n          style = this._topRightGridStyle;\n\n      if (hideTopRightGridScrollbar) {\n        gridHeight = height + additionalHeight;\n        style = _objectSpread({}, this._topRightGridStyle, {\n          left: 0\n        });\n      }\n\n      var topRightGrid = React.createElement(Grid, _extends({}, props, {\n        cellRenderer: this._cellRendererTopRightGrid,\n        className: this.props.classNameTopRightGrid,\n        columnCount: Math.max(0, columnCount - fixedColumnCount) + additionalColumnCount,\n        columnWidth: this._columnWidthRightGrid,\n        deferredMeasurementCache: this._deferredMeasurementCacheTopRightGrid,\n        height: gridHeight,\n        onScroll: enableFixedRowScroll ? this._onScrollLeft : undefined,\n        ref: this._topRightGridRef,\n        rowCount: fixedRowCount,\n        scrollLeft: scrollLeft,\n        style: style,\n        tabIndex: null,\n        width: width\n      }));\n\n      if (hideTopRightGridScrollbar) {\n        return React.createElement(\"div\", {\n          className: \"TopRightGrid_ScrollWrapper\",\n          style: _objectSpread({}, this._topRightGridStyle, {\n            height: height,\n            width: width,\n            overflowX: 'hidden'\n          })\n        }, topRightGrid);\n      }\n\n      return topRightGrid;\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(nextProps, prevState) {\n      if (nextProps.scrollLeft !== prevState.scrollLeft || nextProps.scrollTop !== prevState.scrollTop) {\n        return {\n          scrollLeft: nextProps.scrollLeft != null && nextProps.scrollLeft >= 0 ? nextProps.scrollLeft : prevState.scrollLeft,\n          scrollTop: nextProps.scrollTop != null && nextProps.scrollTop >= 0 ? nextProps.scrollTop : prevState.scrollTop\n        };\n      }\n\n      return null;\n    }\n  }]);\n\n  return MultiGrid;\n}(React.PureComponent);\n\n_defineProperty(MultiGrid, \"defaultProps\", {\n  classNameBottomLeftGrid: '',\n  classNameBottomRightGrid: '',\n  classNameTopLeftGrid: '',\n  classNameTopRightGrid: '',\n  enableFixedColumnScroll: false,\n  enableFixedRowScroll: false,\n  fixedColumnCount: 0,\n  fixedRowCount: 0,\n  scrollToColumn: -1,\n  scrollToRow: -1,\n  style: {},\n  styleBottomLeftGrid: {},\n  styleBottomRightGrid: {},\n  styleTopLeftGrid: {},\n  styleTopRightGrid: {},\n  hideTopRightGridScrollbar: false,\n  hideBottomLeftGridScrollbar: false\n});\n\nMultiGrid.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  classNameBottomLeftGrid: PropTypes.string.isRequired,\n  classNameBottomRightGrid: PropTypes.string.isRequired,\n  classNameTopLeftGrid: PropTypes.string.isRequired,\n  classNameTopRightGrid: PropTypes.string.isRequired,\n  enableFixedColumnScroll: PropTypes.bool.isRequired,\n  enableFixedRowScroll: PropTypes.bool.isRequired,\n  fixedColumnCount: PropTypes.number.isRequired,\n  fixedRowCount: PropTypes.number.isRequired,\n  onScrollbarPresenceChange: PropTypes.func,\n  style: PropTypes.object.isRequired,\n  styleBottomLeftGrid: PropTypes.object.isRequired,\n  styleBottomRightGrid: PropTypes.object.isRequired,\n  styleTopLeftGrid: PropTypes.object.isRequired,\n  styleTopRightGrid: PropTypes.object.isRequired,\n  hideTopRightGridScrollbar: PropTypes.bool,\n  hideBottomLeftGridScrollbar: PropTypes.bool\n} : {};\npolyfill(MultiGrid);\nexport default MultiGrid;","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\n/**\n * HOC that simplifies the process of synchronizing scrolling between two or more virtualized components.\n */\n\nvar ScrollSync =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(ScrollSync, _React$PureComponent);\n\n  function ScrollSync(props, context) {\n    var _this;\n\n    _classCallCheck(this, ScrollSync);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(ScrollSync).call(this, props, context));\n    _this.state = {\n      clientHeight: 0,\n      clientWidth: 0,\n      scrollHeight: 0,\n      scrollLeft: 0,\n      scrollTop: 0,\n      scrollWidth: 0\n    };\n    _this._onScroll = _this._onScroll.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(ScrollSync, [{\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      var _this$state = this.state,\n          clientHeight = _this$state.clientHeight,\n          clientWidth = _this$state.clientWidth,\n          scrollHeight = _this$state.scrollHeight,\n          scrollLeft = _this$state.scrollLeft,\n          scrollTop = _this$state.scrollTop,\n          scrollWidth = _this$state.scrollWidth;\n      return children({\n        clientHeight: clientHeight,\n        clientWidth: clientWidth,\n        onScroll: this._onScroll,\n        scrollHeight: scrollHeight,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        scrollWidth: scrollWidth\n      });\n    }\n  }, {\n    key: \"_onScroll\",\n    value: function _onScroll(_ref) {\n      var clientHeight = _ref.clientHeight,\n          clientWidth = _ref.clientWidth,\n          scrollHeight = _ref.scrollHeight,\n          scrollLeft = _ref.scrollLeft,\n          scrollTop = _ref.scrollTop,\n          scrollWidth = _ref.scrollWidth;\n      this.setState({\n        clientHeight: clientHeight,\n        clientWidth: clientWidth,\n        scrollHeight: scrollHeight,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        scrollWidth: scrollWidth\n      });\n    }\n  }]);\n\n  return ScrollSync;\n}(React.PureComponent);\n\nexport { ScrollSync as default };\nScrollSync.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /**\n   * Function responsible for rendering 2 or more virtualized components.\n   * This function should implement the following signature:\n   * ({ onScroll, scrollLeft, scrollTop }) => PropTypes.element\n   */\n  children: PropTypes.func.isRequired\n} : {};","export default function createMultiSort(sortCallback) {\n  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      defaultSortBy = _ref.defaultSortBy,\n      _ref$defaultSortDirec = _ref.defaultSortDirection,\n      defaultSortDirection = _ref$defaultSortDirec === void 0 ? {} : _ref$defaultSortDirec;\n\n  if (!sortCallback) {\n    throw Error(\"Required parameter \\\"sortCallback\\\" not specified\");\n  }\n\n  var sortBy = defaultSortBy || [];\n  var sortDirection = {};\n  sortBy.forEach(function (dataKey) {\n    sortDirection[dataKey] = defaultSortDirection[dataKey] !== undefined ? defaultSortDirection[dataKey] : 'ASC';\n  });\n\n  function sort(_ref2) {\n    var defaultSortDirection = _ref2.defaultSortDirection,\n        event = _ref2.event,\n        dataKey = _ref2.sortBy;\n\n    if (event.shiftKey) {\n      // Shift + click appends a column to existing criteria\n      if (sortDirection[dataKey] !== undefined) {\n        sortDirection[dataKey] = sortDirection[dataKey] === 'ASC' ? 'DESC' : 'ASC';\n      } else {\n        sortDirection[dataKey] = defaultSortDirection;\n        sortBy.push(dataKey);\n      }\n    } else if (event.ctrlKey || event.metaKey) {\n      // Control + click removes column from sort (if pressent)\n      var index = sortBy.indexOf(dataKey);\n\n      if (index >= 0) {\n        sortBy.splice(index, 1);\n        delete sortDirection[dataKey];\n      }\n    } else {\n      // Clear sortBy array of all non-selected keys\n      sortBy.length = 0;\n      sortBy.push(dataKey); // Clear sortDirection object of all non-selected keys\n\n      var sortDirectionKeys = Object.keys(sortDirection);\n      sortDirectionKeys.forEach(function (key) {\n        if (key !== dataKey) delete sortDirection[key];\n      }); // If key is already selected, reverse sort direction.\n      // Else, set sort direction to default direction.\n\n      if (sortDirection[dataKey] !== undefined) {\n        sortDirection[dataKey] = sortDirection[dataKey] === 'ASC' ? 'DESC' : 'ASC';\n      } else {\n        sortDirection[dataKey] = defaultSortDirection;\n      }\n    } // Notify application code\n\n\n    sortCallback({\n      sortBy: sortBy,\n      sortDirection: sortDirection\n    });\n  }\n\n  return {\n    sort: sort,\n    sortBy: sortBy,\n    sortDirection: sortDirection\n  };\n}","/**\n * Default accessor for returning a cell value for a given attribute.\n * This function expects to operate on either a vanilla Object or an Immutable Map.\n * You should override the column's cellDataGetter if your data is some other type of object.\n */\nexport default function defaultCellDataGetter(_ref) {\n  var dataKey = _ref.dataKey,\n      rowData = _ref.rowData;\n\n  if (typeof rowData.get === 'function') {\n    return rowData.get(dataKey);\n  } else {\n    return rowData[dataKey];\n  }\n}\nimport { bpfrpt_proptype_CellDataGetterParams } from \"./types\";","/**\n * Default cell renderer that displays an attribute as a simple string\n * You should override the column's cellRenderer if your data is some other type of object.\n */\nexport default function defaultCellRenderer(_ref) {\n  var cellData = _ref.cellData;\n\n  if (cellData == null) {\n    return '';\n  } else {\n    return String(cellData);\n  }\n}\nimport { bpfrpt_proptype_CellRendererParams } from \"./types\";","import * as React from 'react';\nexport default function defaultHeaderRowRenderer(_ref) {\n  var className = _ref.className,\n      columns = _ref.columns,\n      style = _ref.style;\n  return React.createElement(\"div\", {\n    className: className,\n    role: \"row\",\n    style: style\n  }, columns);\n}\ndefaultHeaderRowRenderer.propTypes = process.env.NODE_ENV === 'production' ? null : bpfrpt_proptype_HeaderRowRendererParams === PropTypes.any ? {} : bpfrpt_proptype_HeaderRowRendererParams;\nimport { bpfrpt_proptype_HeaderRowRendererParams } from \"./types\";\nimport PropTypes from \"prop-types\";","var SortDirection = {\n  /**\n   * Sort items in ascending order.\n   * This means arranging from the lowest value to the highest (e.g. a-z, 0-9).\n   */\n  ASC: 'ASC',\n\n  /**\n   * Sort items in descending order.\n   * This means arranging from the highest value to the lowest (e.g. z-a, 9-0).\n   */\n  DESC: 'DESC'\n};\nexport default SortDirection;","import clsx from 'clsx';\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport SortDirection from './SortDirection';\n/**\n * Displayed beside a header to indicate that a Table is currently sorted by this column.\n */\n\nexport default function SortIndicator(_ref) {\n  var sortDirection = _ref.sortDirection;\n  var classNames = clsx('ReactVirtualized__Table__sortableHeaderIcon', {\n    'ReactVirtualized__Table__sortableHeaderIcon--ASC': sortDirection === SortDirection.ASC,\n    'ReactVirtualized__Table__sortableHeaderIcon--DESC': sortDirection === SortDirection.DESC\n  });\n  return React.createElement(\"svg\", {\n    className: classNames,\n    width: 18,\n    height: 18,\n    viewBox: \"0 0 24 24\"\n  }, sortDirection === SortDirection.ASC ? React.createElement(\"path\", {\n    d: \"M7 14l5-5 5 5z\"\n  }) : React.createElement(\"path\", {\n    d: \"M7 10l5 5 5-5z\"\n  }), React.createElement(\"path\", {\n    d: \"M0 0h24v24H0z\",\n    fill: \"none\"\n  }));\n}\nSortIndicator.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  sortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC])\n} : {};","import * as React from 'react';\nimport SortIndicator from './SortIndicator';\n\n/**\n * Default table header renderer.\n */\nexport default function defaultHeaderRenderer(_ref) {\n  var dataKey = _ref.dataKey,\n      label = _ref.label,\n      sortBy = _ref.sortBy,\n      sortDirection = _ref.sortDirection;\n  var showSortIndicator = sortBy === dataKey;\n  var children = [React.createElement(\"span\", {\n    className: \"ReactVirtualized__Table__headerTruncatedText\",\n    key: \"label\",\n    title: typeof label === 'string' ? label : null\n  }, label)];\n\n  if (showSortIndicator) {\n    children.push(React.createElement(SortIndicator, {\n      key: \"SortIndicator\",\n      sortDirection: sortDirection\n    }));\n  }\n\n  return children;\n}\ndefaultHeaderRenderer.propTypes = process.env.NODE_ENV === 'production' ? null : bpfrpt_proptype_HeaderRendererParams === PropTypes.any ? {} : bpfrpt_proptype_HeaderRendererParams;\nimport { bpfrpt_proptype_HeaderRendererParams } from \"./types\";\nimport PropTypes from \"prop-types\";","import _extends from \"@babel/runtime/helpers/extends\";\nimport * as React from 'react';\n\n/**\n * Default row renderer for Table.\n */\nexport default function defaultRowRenderer(_ref) {\n  var className = _ref.className,\n      columns = _ref.columns,\n      index = _ref.index,\n      key = _ref.key,\n      onRowClick = _ref.onRowClick,\n      onRowDoubleClick = _ref.onRowDoubleClick,\n      onRowMouseOut = _ref.onRowMouseOut,\n      onRowMouseOver = _ref.onRowMouseOver,\n      onRowRightClick = _ref.onRowRightClick,\n      rowData = _ref.rowData,\n      style = _ref.style;\n  var a11yProps = {\n    'aria-rowindex': index + 1\n  };\n\n  if (onRowClick || onRowDoubleClick || onRowMouseOut || onRowMouseOver || onRowRightClick) {\n    a11yProps['aria-label'] = 'row';\n    a11yProps.tabIndex = 0;\n\n    if (onRowClick) {\n      a11yProps.onClick = function (event) {\n        return onRowClick({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowDoubleClick) {\n      a11yProps.onDoubleClick = function (event) {\n        return onRowDoubleClick({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowMouseOut) {\n      a11yProps.onMouseOut = function (event) {\n        return onRowMouseOut({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowMouseOver) {\n      a11yProps.onMouseOver = function (event) {\n        return onRowMouseOver({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n\n    if (onRowRightClick) {\n      a11yProps.onContextMenu = function (event) {\n        return onRowRightClick({\n          event: event,\n          index: index,\n          rowData: rowData\n        });\n      };\n    }\n  }\n\n  return React.createElement(\"div\", _extends({}, a11yProps, {\n    className: className,\n    key: key,\n    role: \"row\",\n    style: style\n  }), columns);\n}\ndefaultRowRenderer.propTypes = process.env.NODE_ENV === 'production' ? null : bpfrpt_proptype_RowRendererParams === PropTypes.any ? {} : bpfrpt_proptype_RowRendererParams;\nimport { bpfrpt_proptype_RowRendererParams } from \"./types\";\nimport PropTypes from \"prop-types\";","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport defaultHeaderRenderer from './defaultHeaderRenderer';\nimport defaultCellRenderer from './defaultCellRenderer';\nimport defaultCellDataGetter from './defaultCellDataGetter';\nimport SortDirection from './SortDirection';\n/**\n * Describes the header and cell contents of a table column.\n */\n\nvar Column =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inherits(Column, _React$Component);\n\n  function Column() {\n    _classCallCheck(this, Column);\n\n    return _possibleConstructorReturn(this, _getPrototypeOf(Column).apply(this, arguments));\n  }\n\n  return Column;\n}(React.Component);\n\n_defineProperty(Column, \"defaultProps\", {\n  cellDataGetter: defaultCellDataGetter,\n  cellRenderer: defaultCellRenderer,\n  defaultSortDirection: SortDirection.ASC,\n  flexGrow: 0,\n  flexShrink: 1,\n  headerRenderer: defaultHeaderRenderer,\n  style: {}\n});\n\nexport { Column as default };\nColumn.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /** Optional aria-label value to set on the column header */\n  'aria-label': PropTypes.string,\n\n  /**\n   * Callback responsible for returning a cell's data, given its :dataKey\n   * ({ columnData: any, dataKey: string, rowData: any }): any\n   */\n  cellDataGetter: PropTypes.func,\n\n  /**\n   * Callback responsible for rendering a cell's contents.\n   * ({ cellData: any, columnData: any, dataKey: string, rowData: any, rowIndex: number }): node\n   */\n  cellRenderer: PropTypes.func,\n\n  /** Optional CSS class to apply to cell */\n  className: PropTypes.string,\n\n  /** Optional additional data passed to this column's :cellDataGetter */\n  columnData: PropTypes.object,\n\n  /** Uniquely identifies the row-data attribute corresponding to this cell */\n  dataKey: PropTypes.any.isRequired,\n\n  /** Optional direction to be used when clicked the first time */\n  defaultSortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC]),\n\n  /** If sort is enabled for the table at large, disable it for this column */\n  disableSort: PropTypes.bool,\n\n  /** Flex grow style; defaults to 0 */\n  flexGrow: PropTypes.number,\n\n  /** Flex shrink style; defaults to 1 */\n  flexShrink: PropTypes.number,\n\n  /** Optional CSS class to apply to this column's header */\n  headerClassName: PropTypes.string,\n\n  /**\n   * Optional callback responsible for rendering a column header contents.\n   * ({ columnData: object, dataKey: string, disableSort: boolean, label: node, sortBy: string, sortDirection: string }): PropTypes.node\n   */\n  headerRenderer: PropTypes.func.isRequired,\n\n  /** Optional inline style to apply to this column's header */\n  headerStyle: PropTypes.object,\n\n  /** Optional id to set on the column header */\n  id: PropTypes.string,\n\n  /** Header label for this column */\n  label: PropTypes.node,\n\n  /** Maximum width of column; this property will only be used if :flexGrow is > 0. */\n  maxWidth: PropTypes.number,\n\n  /** Minimum width of column. */\n  minWidth: PropTypes.number,\n\n  /** Optional inline style to apply to cell */\n  style: PropTypes.object,\n\n  /** Flex basis (width) for this column; This value can grow or shrink based on :flexGrow and :flexShrink properties. */\n  width: PropTypes.number.isRequired\n} : {};","import _extends from \"@babel/runtime/helpers/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport clsx from 'clsx';\nimport Column from './Column';\nimport PropTypes from 'prop-types';\nimport * as React from 'react';\nimport { findDOMNode } from 'react-dom';\nimport Grid, { accessibilityOverscanIndicesGetter } from '../Grid';\nimport defaultRowRenderer from './defaultRowRenderer';\nimport defaultHeaderRowRenderer from './defaultHeaderRowRenderer';\nimport SortDirection from './SortDirection';\n/**\n * Table component with fixed headers and virtualized rows for improved performance with large data sets.\n * This component expects explicit width, height, and padding parameters.\n */\n\nvar Table =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(Table, _React$PureComponent);\n\n  function Table(props) {\n    var _this;\n\n    _classCallCheck(this, Table);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Table).call(this, props));\n    _this.state = {\n      scrollbarWidth: 0\n    };\n    _this._createColumn = _this._createColumn.bind(_assertThisInitialized(_this));\n    _this._createRow = _this._createRow.bind(_assertThisInitialized(_this));\n    _this._onScroll = _this._onScroll.bind(_assertThisInitialized(_this));\n    _this._onSectionRendered = _this._onSectionRendered.bind(_assertThisInitialized(_this));\n    _this._setRef = _this._setRef.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(Table, [{\n    key: \"forceUpdateGrid\",\n    value: function forceUpdateGrid() {\n      if (this.Grid) {\n        this.Grid.forceUpdate();\n      }\n    }\n    /** See Grid#getOffsetForCell */\n\n  }, {\n    key: \"getOffsetForRow\",\n    value: function getOffsetForRow(_ref) {\n      var alignment = _ref.alignment,\n          index = _ref.index;\n\n      if (this.Grid) {\n        var _this$Grid$getOffsetF = this.Grid.getOffsetForCell({\n          alignment: alignment,\n          rowIndex: index\n        }),\n            scrollTop = _this$Grid$getOffsetF.scrollTop;\n\n        return scrollTop;\n      }\n\n      return 0;\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"invalidateCellSizeAfterRender\",\n    value: function invalidateCellSizeAfterRender(_ref2) {\n      var columnIndex = _ref2.columnIndex,\n          rowIndex = _ref2.rowIndex;\n\n      if (this.Grid) {\n        this.Grid.invalidateCellSizeAfterRender({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#measureAllCells */\n\n  }, {\n    key: \"measureAllRows\",\n    value: function measureAllRows() {\n      if (this.Grid) {\n        this.Grid.measureAllCells();\n      }\n    }\n    /** CellMeasurer compatibility */\n\n  }, {\n    key: \"recomputeGridSize\",\n    value: function recomputeGridSize() {\n      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref3$columnIndex = _ref3.columnIndex,\n          columnIndex = _ref3$columnIndex === void 0 ? 0 : _ref3$columnIndex,\n          _ref3$rowIndex = _ref3.rowIndex,\n          rowIndex = _ref3$rowIndex === void 0 ? 0 : _ref3$rowIndex;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: rowIndex,\n          columnIndex: columnIndex\n        });\n      }\n    }\n    /** See Grid#recomputeGridSize */\n\n  }, {\n    key: \"recomputeRowHeights\",\n    value: function recomputeRowHeights() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.recomputeGridSize({\n          rowIndex: index\n        });\n      }\n    }\n    /** See Grid#scrollToPosition */\n\n  }, {\n    key: \"scrollToPosition\",\n    value: function scrollToPosition() {\n      var scrollTop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToPosition({\n          scrollTop: scrollTop\n        });\n      }\n    }\n    /** See Grid#scrollToCell */\n\n  }, {\n    key: \"scrollToRow\",\n    value: function scrollToRow() {\n      var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n      if (this.Grid) {\n        this.Grid.scrollToCell({\n          columnIndex: 0,\n          rowIndex: index\n        });\n      }\n    }\n  }, {\n    key: \"getScrollbarWidth\",\n    value: function getScrollbarWidth() {\n      if (this.Grid) {\n        var _Grid = findDOMNode(this.Grid);\n\n        var clientWidth = _Grid.clientWidth || 0;\n        var offsetWidth = _Grid.offsetWidth || 0;\n        return offsetWidth - clientWidth;\n      }\n\n      return 0;\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._setScrollbarWidth();\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate() {\n      this._setScrollbarWidth();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this2 = this;\n\n      var _this$props = this.props,\n          children = _this$props.children,\n          className = _this$props.className,\n          disableHeader = _this$props.disableHeader,\n          gridClassName = _this$props.gridClassName,\n          gridStyle = _this$props.gridStyle,\n          headerHeight = _this$props.headerHeight,\n          headerRowRenderer = _this$props.headerRowRenderer,\n          height = _this$props.height,\n          id = _this$props.id,\n          noRowsRenderer = _this$props.noRowsRenderer,\n          rowClassName = _this$props.rowClassName,\n          rowStyle = _this$props.rowStyle,\n          scrollToIndex = _this$props.scrollToIndex,\n          style = _this$props.style,\n          width = _this$props.width;\n      var scrollbarWidth = this.state.scrollbarWidth;\n      var availableRowsHeight = disableHeader ? height : height - headerHeight;\n      var rowClass = typeof rowClassName === 'function' ? rowClassName({\n        index: -1\n      }) : rowClassName;\n      var rowStyleObject = typeof rowStyle === 'function' ? rowStyle({\n        index: -1\n      }) : rowStyle; // Precompute and cache column styles before rendering rows and columns to speed things up\n\n      this._cachedColumnStyles = [];\n      React.Children.toArray(children).forEach(function (column, index) {\n        var flexStyles = _this2._getFlexStyleForColumn(column, column.props.style);\n\n        _this2._cachedColumnStyles[index] = _objectSpread({\n          overflow: 'hidden'\n        }, flexStyles);\n      }); // Note that we specify :rowCount, :scrollbarWidth, :sortBy, and :sortDirection as properties on Grid even though these have nothing to do with Grid.\n      // This is done because Grid is a pure component and won't update unless its properties or state has changed.\n      // Any property that should trigger a re-render of Grid then is specified here to avoid a stale display.\n\n      return React.createElement(\"div\", {\n        \"aria-label\": this.props['aria-label'],\n        \"aria-labelledby\": this.props['aria-labelledby'],\n        \"aria-colcount\": React.Children.toArray(children).length,\n        \"aria-rowcount\": this.props.rowCount,\n        className: clsx('ReactVirtualized__Table', className),\n        id: id,\n        role: \"grid\",\n        style: style\n      }, !disableHeader && headerRowRenderer({\n        className: clsx('ReactVirtualized__Table__headerRow', rowClass),\n        columns: this._getHeaderColumns(),\n        style: _objectSpread({\n          height: headerHeight,\n          overflow: 'hidden',\n          paddingRight: scrollbarWidth,\n          width: width\n        }, rowStyleObject)\n      }), React.createElement(Grid, _extends({}, this.props, {\n        \"aria-readonly\": null,\n        autoContainerWidth: true,\n        className: clsx('ReactVirtualized__Table__Grid', gridClassName),\n        cellRenderer: this._createRow,\n        columnWidth: width,\n        columnCount: 1,\n        height: availableRowsHeight,\n        id: undefined,\n        noContentRenderer: noRowsRenderer,\n        onScroll: this._onScroll,\n        onSectionRendered: this._onSectionRendered,\n        ref: this._setRef,\n        role: \"rowgroup\",\n        scrollbarWidth: scrollbarWidth,\n        scrollToRow: scrollToIndex,\n        style: _objectSpread({}, gridStyle, {\n          overflowX: 'hidden'\n        })\n      })));\n    }\n  }, {\n    key: \"_createColumn\",\n    value: function _createColumn(_ref4) {\n      var column = _ref4.column,\n          columnIndex = _ref4.columnIndex,\n          isScrolling = _ref4.isScrolling,\n          parent = _ref4.parent,\n          rowData = _ref4.rowData,\n          rowIndex = _ref4.rowIndex;\n      var onColumnClick = this.props.onColumnClick;\n      var _column$props = column.props,\n          cellDataGetter = _column$props.cellDataGetter,\n          cellRenderer = _column$props.cellRenderer,\n          className = _column$props.className,\n          columnData = _column$props.columnData,\n          dataKey = _column$props.dataKey,\n          id = _column$props.id;\n      var cellData = cellDataGetter({\n        columnData: columnData,\n        dataKey: dataKey,\n        rowData: rowData\n      });\n      var renderedCell = cellRenderer({\n        cellData: cellData,\n        columnData: columnData,\n        columnIndex: columnIndex,\n        dataKey: dataKey,\n        isScrolling: isScrolling,\n        parent: parent,\n        rowData: rowData,\n        rowIndex: rowIndex\n      });\n\n      var onClick = function onClick(event) {\n        onColumnClick && onColumnClick({\n          columnData: columnData,\n          dataKey: dataKey,\n          event: event\n        });\n      };\n\n      var style = this._cachedColumnStyles[columnIndex];\n      var title = typeof renderedCell === 'string' ? renderedCell : null; // Avoid using object-spread syntax with multiple objects here,\n      // Since it results in an extra method call to 'babel-runtime/helpers/extends'\n      // See PR https://github.com/bvaughn/react-virtualized/pull/942\n\n      return React.createElement(\"div\", {\n        \"aria-colindex\": columnIndex + 1,\n        \"aria-describedby\": id,\n        className: clsx('ReactVirtualized__Table__rowColumn', className),\n        key: 'Row' + rowIndex + '-' + 'Col' + columnIndex,\n        onClick: onClick,\n        role: \"gridcell\",\n        style: style,\n        title: title\n      }, renderedCell);\n    }\n  }, {\n    key: \"_createHeader\",\n    value: function _createHeader(_ref5) {\n      var column = _ref5.column,\n          index = _ref5.index;\n      var _this$props2 = this.props,\n          headerClassName = _this$props2.headerClassName,\n          headerStyle = _this$props2.headerStyle,\n          onHeaderClick = _this$props2.onHeaderClick,\n          sort = _this$props2.sort,\n          sortBy = _this$props2.sortBy,\n          sortDirection = _this$props2.sortDirection;\n      var _column$props2 = column.props,\n          columnData = _column$props2.columnData,\n          dataKey = _column$props2.dataKey,\n          defaultSortDirection = _column$props2.defaultSortDirection,\n          disableSort = _column$props2.disableSort,\n          headerRenderer = _column$props2.headerRenderer,\n          id = _column$props2.id,\n          label = _column$props2.label;\n      var sortEnabled = !disableSort && sort;\n      var classNames = clsx('ReactVirtualized__Table__headerColumn', headerClassName, column.props.headerClassName, {\n        ReactVirtualized__Table__sortableHeaderColumn: sortEnabled\n      });\n\n      var style = this._getFlexStyleForColumn(column, _objectSpread({}, headerStyle, {}, column.props.headerStyle));\n\n      var renderedHeader = headerRenderer({\n        columnData: columnData,\n        dataKey: dataKey,\n        disableSort: disableSort,\n        label: label,\n        sortBy: sortBy,\n        sortDirection: sortDirection\n      });\n      var headerOnClick, headerOnKeyDown, headerTabIndex, headerAriaSort, headerAriaLabel;\n\n      if (sortEnabled || onHeaderClick) {\n        // If this is a sortable header, clicking it should update the table data's sorting.\n        var isFirstTimeSort = sortBy !== dataKey; // If this is the firstTime sort of this column, use the column default sort order.\n        // Otherwise, invert the direction of the sort.\n\n        var newSortDirection = isFirstTimeSort ? defaultSortDirection : sortDirection === SortDirection.DESC ? SortDirection.ASC : SortDirection.DESC;\n\n        var onClick = function onClick(event) {\n          sortEnabled && sort({\n            defaultSortDirection: defaultSortDirection,\n            event: event,\n            sortBy: dataKey,\n            sortDirection: newSortDirection\n          });\n          onHeaderClick && onHeaderClick({\n            columnData: columnData,\n            dataKey: dataKey,\n            event: event\n          });\n        };\n\n        var onKeyDown = function onKeyDown(event) {\n          if (event.key === 'Enter' || event.key === ' ') {\n            onClick(event);\n          }\n        };\n\n        headerAriaLabel = column.props['aria-label'] || label || dataKey;\n        headerAriaSort = 'none';\n        headerTabIndex = 0;\n        headerOnClick = onClick;\n        headerOnKeyDown = onKeyDown;\n      }\n\n      if (sortBy === dataKey) {\n        headerAriaSort = sortDirection === SortDirection.ASC ? 'ascending' : 'descending';\n      } // Avoid using object-spread syntax with multiple objects here,\n      // Since it results in an extra method call to 'babel-runtime/helpers/extends'\n      // See PR https://github.com/bvaughn/react-virtualized/pull/942\n\n\n      return React.createElement(\"div\", {\n        \"aria-label\": headerAriaLabel,\n        \"aria-sort\": headerAriaSort,\n        className: classNames,\n        id: id,\n        key: 'Header-Col' + index,\n        onClick: headerOnClick,\n        onKeyDown: headerOnKeyDown,\n        role: \"columnheader\",\n        style: style,\n        tabIndex: headerTabIndex\n      }, renderedHeader);\n    }\n  }, {\n    key: \"_createRow\",\n    value: function _createRow(_ref6) {\n      var _this3 = this;\n\n      var index = _ref6.rowIndex,\n          isScrolling = _ref6.isScrolling,\n          key = _ref6.key,\n          parent = _ref6.parent,\n          style = _ref6.style;\n      var _this$props3 = this.props,\n          children = _this$props3.children,\n          onRowClick = _this$props3.onRowClick,\n          onRowDoubleClick = _this$props3.onRowDoubleClick,\n          onRowRightClick = _this$props3.onRowRightClick,\n          onRowMouseOver = _this$props3.onRowMouseOver,\n          onRowMouseOut = _this$props3.onRowMouseOut,\n          rowClassName = _this$props3.rowClassName,\n          rowGetter = _this$props3.rowGetter,\n          rowRenderer = _this$props3.rowRenderer,\n          rowStyle = _this$props3.rowStyle;\n      var scrollbarWidth = this.state.scrollbarWidth;\n      var rowClass = typeof rowClassName === 'function' ? rowClassName({\n        index: index\n      }) : rowClassName;\n      var rowStyleObject = typeof rowStyle === 'function' ? rowStyle({\n        index: index\n      }) : rowStyle;\n      var rowData = rowGetter({\n        index: index\n      });\n      var columns = React.Children.toArray(children).map(function (column, columnIndex) {\n        return _this3._createColumn({\n          column: column,\n          columnIndex: columnIndex,\n          isScrolling: isScrolling,\n          parent: parent,\n          rowData: rowData,\n          rowIndex: index,\n          scrollbarWidth: scrollbarWidth\n        });\n      });\n      var className = clsx('ReactVirtualized__Table__row', rowClass);\n\n      var flattenedStyle = _objectSpread({}, style, {\n        height: this._getRowHeight(index),\n        overflow: 'hidden',\n        paddingRight: scrollbarWidth\n      }, rowStyleObject);\n\n      return rowRenderer({\n        className: className,\n        columns: columns,\n        index: index,\n        isScrolling: isScrolling,\n        key: key,\n        onRowClick: onRowClick,\n        onRowDoubleClick: onRowDoubleClick,\n        onRowRightClick: onRowRightClick,\n        onRowMouseOver: onRowMouseOver,\n        onRowMouseOut: onRowMouseOut,\n        rowData: rowData,\n        style: flattenedStyle\n      });\n    }\n    /**\n     * Determines the flex-shrink, flex-grow, and width values for a cell (header or column).\n     */\n\n  }, {\n    key: \"_getFlexStyleForColumn\",\n    value: function _getFlexStyleForColumn(column) {\n      var customStyle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      var flexValue = \"\".concat(column.props.flexGrow, \" \").concat(column.props.flexShrink, \" \").concat(column.props.width, \"px\");\n\n      var style = _objectSpread({}, customStyle, {\n        flex: flexValue,\n        msFlex: flexValue,\n        WebkitFlex: flexValue\n      });\n\n      if (column.props.maxWidth) {\n        style.maxWidth = column.props.maxWidth;\n      }\n\n      if (column.props.minWidth) {\n        style.minWidth = column.props.minWidth;\n      }\n\n      return style;\n    }\n  }, {\n    key: \"_getHeaderColumns\",\n    value: function _getHeaderColumns() {\n      var _this4 = this;\n\n      var _this$props4 = this.props,\n          children = _this$props4.children,\n          disableHeader = _this$props4.disableHeader;\n      var items = disableHeader ? [] : React.Children.toArray(children);\n      return items.map(function (column, index) {\n        return _this4._createHeader({\n          column: column,\n          index: index\n        });\n      });\n    }\n  }, {\n    key: \"_getRowHeight\",\n    value: function _getRowHeight(rowIndex) {\n      var rowHeight = this.props.rowHeight;\n      return typeof rowHeight === 'function' ? rowHeight({\n        index: rowIndex\n      }) : rowHeight;\n    }\n  }, {\n    key: \"_onScroll\",\n    value: function _onScroll(_ref7) {\n      var clientHeight = _ref7.clientHeight,\n          scrollHeight = _ref7.scrollHeight,\n          scrollTop = _ref7.scrollTop;\n      var onScroll = this.props.onScroll;\n      onScroll({\n        clientHeight: clientHeight,\n        scrollHeight: scrollHeight,\n        scrollTop: scrollTop\n      });\n    }\n  }, {\n    key: \"_onSectionRendered\",\n    value: function _onSectionRendered(_ref8) {\n      var rowOverscanStartIndex = _ref8.rowOverscanStartIndex,\n          rowOverscanStopIndex = _ref8.rowOverscanStopIndex,\n          rowStartIndex = _ref8.rowStartIndex,\n          rowStopIndex = _ref8.rowStopIndex;\n      var onRowsRendered = this.props.onRowsRendered;\n      onRowsRendered({\n        overscanStartIndex: rowOverscanStartIndex,\n        overscanStopIndex: rowOverscanStopIndex,\n        startIndex: rowStartIndex,\n        stopIndex: rowStopIndex\n      });\n    }\n  }, {\n    key: \"_setRef\",\n    value: function _setRef(ref) {\n      this.Grid = ref;\n    }\n  }, {\n    key: \"_setScrollbarWidth\",\n    value: function _setScrollbarWidth() {\n      var scrollbarWidth = this.getScrollbarWidth();\n      this.setState({\n        scrollbarWidth: scrollbarWidth\n      });\n    }\n  }]);\n\n  return Table;\n}(React.PureComponent);\n\n_defineProperty(Table, \"defaultProps\", {\n  disableHeader: false,\n  estimatedRowSize: 30,\n  headerHeight: 0,\n  headerStyle: {},\n  noRowsRenderer: function noRowsRenderer() {\n    return null;\n  },\n  onRowsRendered: function onRowsRendered() {\n    return null;\n  },\n  onScroll: function onScroll() {\n    return null;\n  },\n  overscanIndicesGetter: accessibilityOverscanIndicesGetter,\n  overscanRowCount: 10,\n  rowRenderer: defaultRowRenderer,\n  headerRowRenderer: defaultHeaderRowRenderer,\n  rowStyle: {},\n  scrollToAlignment: 'auto',\n  scrollToIndex: -1,\n  style: {}\n});\n\nexport { Table as default };\nTable.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  /** This is just set on the grid top element. */\n  'aria-label': PropTypes.string,\n\n  /** This is just set on the grid top element. */\n  'aria-labelledby': PropTypes.string,\n\n  /**\n   * Removes fixed height from the scrollingContainer so that the total height\n   * of rows can stretch the window. Intended for use with WindowScroller\n   */\n  autoHeight: PropTypes.bool,\n\n  /** One or more Columns describing the data displayed in this row */\n  children: function children(props) {\n    var children = React.Children.toArray(props.children);\n\n    for (var i = 0; i < children.length; i++) {\n      var childType = children[i].type;\n\n      if (childType !== Column && !(childType.prototype instanceof Column)) {\n        return new Error('Table only accepts children of type Column');\n      }\n    }\n  },\n\n  /** Optional CSS class name */\n  className: PropTypes.string,\n\n  /** Disable rendering the header at all */\n  disableHeader: PropTypes.bool,\n\n  /**\n   * Used to estimate the total height of a Table before all of its rows have actually been measured.\n   * The estimated total height is adjusted as rows are rendered.\n   */\n  estimatedRowSize: PropTypes.number.isRequired,\n\n  /** Optional custom CSS class name to attach to inner Grid element. */\n  gridClassName: PropTypes.string,\n\n  /** Optional inline style to attach to inner Grid element. */\n  gridStyle: PropTypes.object,\n\n  /** Optional CSS class to apply to all column headers */\n  headerClassName: PropTypes.string,\n\n  /** Fixed height of header row */\n  headerHeight: PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a table row given an array of columns:\n   * Should implement the following interface: ({\n   *   className: string,\n   *   columns: any[],\n   *   style: any\n   * }): PropTypes.node\n   */\n  headerRowRenderer: PropTypes.func,\n\n  /** Optional custom inline style to attach to table header columns. */\n  headerStyle: PropTypes.object,\n\n  /** Fixed/available height for out DOM element */\n  height: PropTypes.number.isRequired,\n\n  /** Optional id */\n  id: PropTypes.string,\n\n  /** Optional renderer to be used in place of table body rows when rowCount is 0 */\n  noRowsRenderer: PropTypes.func,\n\n  /**\n   * Optional callback when a column is clicked.\n   * ({ columnData: any, dataKey: string }): void\n   */\n  onColumnClick: PropTypes.func,\n\n  /**\n   * Optional callback when a column's header is clicked.\n   * ({ columnData: any, dataKey: string }): void\n   */\n  onHeaderClick: PropTypes.func,\n\n  /**\n   * Callback invoked when a user clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowClick: PropTypes.func,\n\n  /**\n   * Callback invoked when a user double-clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowDoubleClick: PropTypes.func,\n\n  /**\n   * Callback invoked when the mouse leaves a table row.\n   * ({ index: number }): void\n   */\n  onRowMouseOut: PropTypes.func,\n\n  /**\n   * Callback invoked when a user moves the mouse over a table row.\n   * ({ index: number }): void\n   */\n  onRowMouseOver: PropTypes.func,\n\n  /**\n   * Callback invoked when a user right-clicks on a table row.\n   * ({ index: number }): void\n   */\n  onRowRightClick: PropTypes.func,\n\n  /**\n   * Callback invoked with information about the slice of rows that were just rendered.\n   * ({ startIndex, stopIndex }): void\n   */\n  onRowsRendered: PropTypes.func,\n\n  /**\n   * Callback invoked whenever the scroll offset changes within the inner scrollable region.\n   * This callback can be used to sync scrolling between lists, tables, or grids.\n   * ({ clientHeight, scrollHeight, scrollTop }): void\n   */\n  onScroll: PropTypes.func.isRequired,\n\n  /** See Grid#overscanIndicesGetter */\n  overscanIndicesGetter: PropTypes.func.isRequired,\n\n  /**\n   * Number of rows to render above/below the visible bounds of the list.\n   * These rows can help for smoother scrolling on touch devices.\n   */\n  overscanRowCount: PropTypes.number.isRequired,\n\n  /**\n   * Optional CSS class to apply to all table rows (including the header row).\n   * This property can be a CSS class name (string) or a function that returns a class name.\n   * If a function is provided its signature should be: ({ index: number }): string\n   */\n  rowClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),\n\n  /**\n   * Callback responsible for returning a data row given an index.\n   * ({ index: number }): any\n   */\n  rowGetter: PropTypes.func.isRequired,\n\n  /**\n   * Either a fixed row height (number) or a function that returns the height of a row given its index.\n   * ({ index: number }): number\n   */\n  rowHeight: PropTypes.oneOfType([PropTypes.number, PropTypes.func]).isRequired,\n\n  /** Number of rows in table. */\n  rowCount: PropTypes.number.isRequired,\n\n  /**\n   * Responsible for rendering a table row given an array of columns:\n   * Should implement the following interface: ({\n   *   className: string,\n   *   columns: Array,\n   *   index: number,\n   *   isScrolling: boolean,\n   *   onRowClick: ?Function,\n   *   onRowDoubleClick: ?Function,\n   *   onRowMouseOver: ?Function,\n   *   onRowMouseOut: ?Function,\n   *   rowData: any,\n   *   style: any\n   * }): PropTypes.node\n   */\n  rowRenderer: PropTypes.func,\n\n  /** Optional custom inline style to attach to table rows. */\n  rowStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]).isRequired,\n\n  /** See Grid#scrollToAlignment */\n  scrollToAlignment: PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,\n\n  /** Row index to ensure visible (by forcefully scrolling if necessary) */\n  scrollToIndex: PropTypes.number.isRequired,\n\n  /** Vertical offset. */\n  scrollTop: PropTypes.number,\n\n  /**\n   * Sort function to be called if a sortable header is clicked.\n   * Should implement the following interface: ({\n   *   defaultSortDirection: 'ASC' | 'DESC',\n   *   event: MouseEvent,\n   *   sortBy: string,\n   *   sortDirection: SortDirection\n   * }): void\n   */\n  sort: PropTypes.func,\n\n  /** Table data is currently sorted by this :dataKey (if it is sorted at all) */\n  sortBy: PropTypes.string,\n\n  /** Table data is currently sorted in this direction (if it is sorted at all) */\n  sortDirection: PropTypes.oneOf([SortDirection.ASC, SortDirection.DESC]),\n\n  /** Optional inline style */\n  style: PropTypes.object,\n\n  /** Tab index for focus */\n  tabIndex: PropTypes.number,\n\n  /** Width of list */\n  width: PropTypes.number.isRequired\n} : {};\nimport { bpfrpt_proptype_CellPosition } from \"../Grid\";","import createMultiSort from './createMultiSort';\nimport defaultCellDataGetter from './defaultCellDataGetter';\nimport defaultCellRenderer from './defaultCellRenderer';\nimport defaultHeaderRowRenderer from './defaultHeaderRowRenderer.js';\nimport defaultHeaderRenderer from './defaultHeaderRenderer';\nimport defaultRowRenderer from './defaultRowRenderer';\nimport Column from './Column';\nimport SortDirection from './SortDirection';\nimport SortIndicator from './SortIndicator';\nimport Table from './Table';\nexport default Table;\nexport { createMultiSort, defaultCellDataGetter, defaultCellRenderer, defaultHeaderRowRenderer, defaultHeaderRenderer, defaultRowRenderer, Column, SortDirection, SortIndicator, Table };","import { requestAnimationTimeout, cancelAnimationTimeout } from '../../utils/requestAnimationTimeout';\nvar mountedInstances = [];\nvar originalBodyPointerEvents = null;\nvar disablePointerEventsTimeoutId = null;\n\nfunction enablePointerEventsIfDisabled() {\n  if (disablePointerEventsTimeoutId) {\n    disablePointerEventsTimeoutId = null;\n\n    if (document.body && originalBodyPointerEvents != null) {\n      document.body.style.pointerEvents = originalBodyPointerEvents;\n    }\n\n    originalBodyPointerEvents = null;\n  }\n}\n\nfunction enablePointerEventsAfterDelayCallback() {\n  enablePointerEventsIfDisabled();\n  mountedInstances.forEach(function (instance) {\n    return instance.__resetIsScrolling();\n  });\n}\n\nfunction enablePointerEventsAfterDelay() {\n  if (disablePointerEventsTimeoutId) {\n    cancelAnimationTimeout(disablePointerEventsTimeoutId);\n  }\n\n  var maximumTimeout = 0;\n  mountedInstances.forEach(function (instance) {\n    maximumTimeout = Math.max(maximumTimeout, instance.props.scrollingResetTimeInterval);\n  });\n  disablePointerEventsTimeoutId = requestAnimationTimeout(enablePointerEventsAfterDelayCallback, maximumTimeout);\n}\n\nfunction onScrollWindow(event) {\n  if (event.currentTarget === window && originalBodyPointerEvents == null && document.body) {\n    originalBodyPointerEvents = document.body.style.pointerEvents;\n    document.body.style.pointerEvents = 'none';\n  }\n\n  enablePointerEventsAfterDelay();\n  mountedInstances.forEach(function (instance) {\n    if (instance.props.scrollElement === event.currentTarget) {\n      instance.__handleWindowScrollEvent();\n    }\n  });\n}\n\nexport function registerScrollListener(component, element) {\n  if (!mountedInstances.some(function (instance) {\n    return instance.props.scrollElement === element;\n  })) {\n    element.addEventListener('scroll', onScrollWindow);\n  }\n\n  mountedInstances.push(component);\n}\nexport function unregisterScrollListener(component, element) {\n  mountedInstances = mountedInstances.filter(function (instance) {\n    return instance !== component;\n  });\n\n  if (!mountedInstances.length) {\n    element.removeEventListener('scroll', onScrollWindow);\n\n    if (disablePointerEventsTimeoutId) {\n      cancelAnimationTimeout(disablePointerEventsTimeoutId);\n      enablePointerEventsIfDisabled();\n    }\n  }\n}\nimport { bpfrpt_proptype_WindowScroller } from \"../WindowScroller.js\";","/**\n * Gets the dimensions of the element, accounting for API differences between\n * `window` and other DOM elements.\n */\n// TODO Move this into WindowScroller and import from there\nvar isWindow = function isWindow(element) {\n  return element === window;\n};\n\nvar getBoundingBox = function getBoundingBox(element) {\n  return element.getBoundingClientRect();\n};\n\nexport function getDimensions(scrollElement, props) {\n  if (!scrollElement) {\n    return {\n      height: props.serverHeight,\n      width: props.serverWidth\n    };\n  } else if (isWindow(scrollElement)) {\n    var _window = window,\n        innerHeight = _window.innerHeight,\n        innerWidth = _window.innerWidth;\n    return {\n      height: typeof innerHeight === 'number' ? innerHeight : 0,\n      width: typeof innerWidth === 'number' ? innerWidth : 0\n    };\n  } else {\n    return getBoundingBox(scrollElement);\n  }\n}\n/**\n * Gets the vertical and horizontal position of an element within its scroll container.\n * Elements that have been “scrolled past” return negative values.\n * Handles edge-case where a user is navigating back (history) from an already-scrolled page.\n * In this case the body’s top or left position will be a negative number and this element’s top or left will be increased (by that amount).\n */\n\nexport function getPositionOffset(element, container) {\n  if (isWindow(container) && document.documentElement) {\n    var containerElement = document.documentElement;\n    var elementRect = getBoundingBox(element);\n    var containerRect = getBoundingBox(containerElement);\n    return {\n      top: elementRect.top - containerRect.top,\n      left: elementRect.left - containerRect.left\n    };\n  } else {\n    var scrollOffset = getScrollOffset(container);\n\n    var _elementRect = getBoundingBox(element);\n\n    var _containerRect = getBoundingBox(container);\n\n    return {\n      top: _elementRect.top + scrollOffset.top - _containerRect.top,\n      left: _elementRect.left + scrollOffset.left - _containerRect.left\n    };\n  }\n}\n/**\n * Gets the vertical and horizontal scroll amount of the element, accounting for IE compatibility\n * and API differences between `window` and other DOM elements.\n */\n\nexport function getScrollOffset(element) {\n  if (isWindow(element) && document.documentElement) {\n    return {\n      top: 'scrollY' in window ? window.scrollY : document.documentElement.scrollTop,\n      left: 'scrollX' in window ? window.scrollX : document.documentElement.scrollLeft\n    };\n  } else {\n    return {\n      top: element.scrollTop,\n      left: element.scrollLeft\n    };\n  }\n}","import _classCallCheck from \"@babel/runtime/helpers/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/createClass\";\nimport _possibleConstructorReturn from \"@babel/runtime/helpers/possibleConstructorReturn\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/getPrototypeOf\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/inherits\";\nimport _defineProperty from \"@babel/runtime/helpers/defineProperty\";\n\nvar _class, _temp;\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { registerScrollListener, unregisterScrollListener } from './utils/onScroll';\nimport { getDimensions, getPositionOffset, getScrollOffset } from './utils/dimensions';\nimport createDetectElementResize from '../vendor/detectElementResize';\n\n/**\n * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.\n * This improves performance and makes scrolling smoother.\n */\nexport var IS_SCROLLING_TIMEOUT = 150;\n\nvar getWindow = function getWindow() {\n  return typeof window !== 'undefined' ? window : undefined;\n};\n\nvar WindowScroller = (_temp = _class =\n/*#__PURE__*/\nfunction (_React$PureComponent) {\n  _inherits(WindowScroller, _React$PureComponent);\n\n  function WindowScroller() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, WindowScroller);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WindowScroller)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"_window\", getWindow());\n\n    _defineProperty(_assertThisInitialized(_this), \"_isMounted\", false);\n\n    _defineProperty(_assertThisInitialized(_this), \"_positionFromTop\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_positionFromLeft\", 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_detectElementResize\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"_child\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", _objectSpread({}, getDimensions(_this.props.scrollElement, _this.props), {\n      isScrolling: false,\n      scrollLeft: 0,\n      scrollTop: 0\n    }));\n\n    _defineProperty(_assertThisInitialized(_this), \"_registerChild\", function (element) {\n      if (element && !(element instanceof Element)) {\n        console.warn('WindowScroller registerChild expects to be passed Element or null');\n      }\n\n      _this._child = element;\n\n      _this.updatePosition();\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onChildScroll\", function (_ref) {\n      var scrollTop = _ref.scrollTop;\n\n      if (_this.state.scrollTop === scrollTop) {\n        return;\n      }\n\n      var scrollElement = _this.props.scrollElement;\n\n      if (scrollElement) {\n        if (typeof scrollElement.scrollTo === 'function') {\n          scrollElement.scrollTo(0, scrollTop + _this._positionFromTop);\n        } else {\n          scrollElement.scrollTop = scrollTop + _this._positionFromTop;\n        }\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_registerResizeListener\", function (element) {\n      if (element === window) {\n        window.addEventListener('resize', _this._onResize, false);\n      } else {\n        _this._detectElementResize.addResizeListener(element, _this._onResize);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_unregisterResizeListener\", function (element) {\n      if (element === window) {\n        window.removeEventListener('resize', _this._onResize, false);\n      } else if (element) {\n        _this._detectElementResize.removeResizeListener(element, _this._onResize);\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_onResize\", function () {\n      _this.updatePosition();\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"__handleWindowScrollEvent\", function () {\n      if (!_this._isMounted) {\n        return;\n      }\n\n      var onScroll = _this.props.onScroll;\n      var scrollElement = _this.props.scrollElement;\n\n      if (scrollElement) {\n        var scrollOffset = getScrollOffset(scrollElement);\n        var scrollLeft = Math.max(0, scrollOffset.left - _this._positionFromLeft);\n        var scrollTop = Math.max(0, scrollOffset.top - _this._positionFromTop);\n\n        _this.setState({\n          isScrolling: true,\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n\n        onScroll({\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop\n        });\n      }\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"__resetIsScrolling\", function () {\n      _this.setState({\n        isScrolling: false\n      });\n    });\n\n    return _this;\n  }\n\n  _createClass(WindowScroller, [{\n    key: \"updatePosition\",\n    value: function updatePosition() {\n      var scrollElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props.scrollElement;\n      var onResize = this.props.onResize;\n      var _this$state = this.state,\n          height = _this$state.height,\n          width = _this$state.width;\n      var thisNode = this._child || ReactDOM.findDOMNode(this);\n\n      if (thisNode instanceof Element && scrollElement) {\n        var offset = getPositionOffset(thisNode, scrollElement);\n        this._positionFromTop = offset.top;\n        this._positionFromLeft = offset.left;\n      }\n\n      var dimensions = getDimensions(scrollElement, this.props);\n\n      if (height !== dimensions.height || width !== dimensions.width) {\n        this.setState({\n          height: dimensions.height,\n          width: dimensions.width\n        });\n        onResize({\n          height: dimensions.height,\n          width: dimensions.width\n        });\n      }\n    }\n  }, {\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      var scrollElement = this.props.scrollElement;\n      this._detectElementResize = createDetectElementResize();\n      this.updatePosition(scrollElement);\n\n      if (scrollElement) {\n        registerScrollListener(this, scrollElement);\n\n        this._registerResizeListener(scrollElement);\n      }\n\n      this._isMounted = true;\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var scrollElement = this.props.scrollElement;\n      var prevScrollElement = prevProps.scrollElement;\n\n      if (prevScrollElement !== scrollElement && prevScrollElement != null && scrollElement != null) {\n        this.updatePosition(scrollElement);\n        unregisterScrollListener(this, prevScrollElement);\n        registerScrollListener(this, scrollElement);\n\n        this._unregisterResizeListener(prevScrollElement);\n\n        this._registerResizeListener(scrollElement);\n      }\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      var scrollElement = this.props.scrollElement;\n\n      if (scrollElement) {\n        unregisterScrollListener(this, scrollElement);\n\n        this._unregisterResizeListener(scrollElement);\n      }\n\n      this._isMounted = false;\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var children = this.props.children;\n      var _this$state2 = this.state,\n          isScrolling = _this$state2.isScrolling,\n          scrollTop = _this$state2.scrollTop,\n          scrollLeft = _this$state2.scrollLeft,\n          height = _this$state2.height,\n          width = _this$state2.width;\n      return children({\n        onChildScroll: this._onChildScroll,\n        registerChild: this._registerChild,\n        height: height,\n        isScrolling: isScrolling,\n        scrollLeft: scrollLeft,\n        scrollTop: scrollTop,\n        width: width\n      });\n    }\n  }]);\n\n  return WindowScroller;\n}(React.PureComponent), _defineProperty(_class, \"propTypes\", process.env.NODE_ENV === 'production' ? null : {\n  /**\n   * Function responsible for rendering children.\n   * This function should implement the following signature:\n   * ({ height, isScrolling, scrollLeft, scrollTop, width }) => PropTypes.element\n   */\n  \"children\": PropTypes.func.isRequired,\n\n  /** Callback to be invoked on-resize: ({ height, width }) */\n  \"onResize\": PropTypes.func.isRequired,\n\n  /** Callback to be invoked on-scroll: ({ scrollLeft, scrollTop }) */\n  \"onScroll\": PropTypes.func.isRequired,\n\n  /** Element to attach scroll event listeners. Defaults to window. */\n  \"scrollElement\": PropTypes.oneOfType([PropTypes.any, function () {\n    return (typeof Element === \"function\" ? PropTypes.instanceOf(Element) : PropTypes.any).apply(this, arguments);\n  }]),\n\n  /**\n   * Wait this amount of time after the last scroll event before resetting child `pointer-events`.\n   */\n  \"scrollingResetTimeInterval\": PropTypes.number.isRequired,\n\n  /** Height used for server-side rendering */\n  \"serverHeight\": PropTypes.number.isRequired,\n\n  /** Width used for server-side rendering */\n  \"serverWidth\": PropTypes.number.isRequired\n}), _temp);\n\n_defineProperty(WindowScroller, \"defaultProps\", {\n  onResize: function onResize() {},\n  onScroll: function onScroll() {},\n  scrollingResetTimeInterval: IS_SCROLLING_TIMEOUT,\n  scrollElement: getWindow(),\n  serverHeight: 0,\n  serverWidth: 0\n});\n\nexport { WindowScroller as default };\nimport PropTypes from \"prop-types\";","export { ArrowKeyStepper } from './ArrowKeyStepper';\nexport { AutoSizer } from './AutoSizer';\nexport { CellMeasurer, CellMeasurerCache } from './CellMeasurer';\nexport { Collection } from './Collection';\nexport { ColumnSizer } from './ColumnSizer';\nexport { accessibilityOverscanIndicesGetter, defaultCellRangeRenderer, defaultOverscanIndicesGetter, Grid } from './Grid';\nexport { InfiniteLoader } from './InfiniteLoader';\nexport { List } from './List';\nexport { createCellPositioner as createMasonryCellPositioner, Masonry } from './Masonry';\nexport { MultiGrid } from './MultiGrid';\nexport { ScrollSync } from './ScrollSync';\nexport { createMultiSort as createTableMultiSort, defaultCellDataGetter as defaultTableCellDataGetter, defaultCellRenderer as defaultTableCellRenderer, defaultHeaderRenderer as defaultTableHeaderRenderer, defaultHeaderRowRenderer as defaultTableHeaderRowRenderer, defaultRowRenderer as defaultTableRowRenderer, Table, Column, SortDirection, SortIndicator } from './Table';\nexport { WindowScroller } from './WindowScroller';","import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport { createMemoryHistory, createLocation, locationsAreEqual, createPath } from 'history';\nimport warning from 'tiny-warning';\nimport createContext from 'mini-create-react-context';\nimport invariant from 'tiny-invariant';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport pathToRegexp from 'path-to-regexp';\nimport { isValidElementType } from 'react-is';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport hoistStatics from 'hoist-non-react-statics';\n\n// TODO: Replace with React.createContext once we can assume React 16+\n\nvar createNamedContext = function createNamedContext(name) {\n  var context = createContext();\n  context.displayName = name;\n  return context;\n};\n\nvar historyContext =\n/*#__PURE__*/\ncreateNamedContext(\"Router-History\");\n\n// TODO: Replace with React.createContext once we can assume React 16+\n\nvar createNamedContext$1 = function createNamedContext(name) {\n  var context = createContext();\n  context.displayName = name;\n  return context;\n};\n\nvar context =\n/*#__PURE__*/\ncreateNamedContext$1(\"Router\");\n\n/**\n * The public API for putting history on context.\n */\n\nvar Router =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Router, _React$Component);\n\n  Router.computeRootMatch = function computeRootMatch(pathname) {\n    return {\n      path: \"/\",\n      url: \"/\",\n      params: {},\n      isExact: pathname === \"/\"\n    };\n  };\n\n  function Router(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n    _this.state = {\n      location: props.history.location\n    }; // This is a bit of a hack. We have to start listening for location\n    // changes here in the constructor in case there are any <Redirect>s\n    // on the initial render. If there are, they will replace/push when\n    // they mount and since cDM fires in children before parents, we may\n    // get a new location before the <Router> is mounted.\n\n    _this._isMounted = false;\n    _this._pendingLocation = null;\n\n    if (!props.staticContext) {\n      _this.unlisten = props.history.listen(function (location) {\n        if (_this._isMounted) {\n          _this.setState({\n            location: location\n          });\n        } else {\n          _this._pendingLocation = location;\n        }\n      });\n    }\n\n    return _this;\n  }\n\n  var _proto = Router.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this._isMounted = true;\n\n    if (this._pendingLocation) {\n      this.setState({\n        location: this._pendingLocation\n      });\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    if (this.unlisten) this.unlisten();\n  };\n\n  _proto.render = function render() {\n    return React.createElement(context.Provider, {\n      value: {\n        history: this.props.history,\n        location: this.state.location,\n        match: Router.computeRootMatch(this.state.location.pathname),\n        staticContext: this.props.staticContext\n      }\n    }, React.createElement(historyContext.Provider, {\n      children: this.props.children || null,\n      value: this.props.history\n    }));\n  };\n\n  return Router;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  Router.propTypes = {\n    children: PropTypes.node,\n    history: PropTypes.object.isRequired,\n    staticContext: PropTypes.object\n  };\n\n  Router.prototype.componentDidUpdate = function (prevProps) {\n    process.env.NODE_ENV !== \"production\" ? warning(prevProps.history === this.props.history, \"You cannot change <Router history>\") : void 0;\n  };\n}\n\n/**\n * The public API for a <Router> that stores location in memory.\n */\n\nvar MemoryRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(MemoryRouter, _React$Component);\n\n  function MemoryRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createMemoryHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = MemoryRouter.prototype;\n\n  _proto.render = function render() {\n    return React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return MemoryRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  MemoryRouter.propTypes = {\n    initialEntries: PropTypes.array,\n    initialIndex: PropTypes.number,\n    getUserConfirmation: PropTypes.func,\n    keyLength: PropTypes.number,\n    children: PropTypes.node\n  };\n\n  MemoryRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<MemoryRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { MemoryRouter as Router }`.\") : void 0;\n  };\n}\n\nvar Lifecycle =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Lifecycle, _React$Component);\n\n  function Lifecycle() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Lifecycle.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    if (this.props.onMount) this.props.onMount.call(this, this);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (this.props.onUpdate) this.props.onUpdate.call(this, this, prevProps);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    if (this.props.onUnmount) this.props.onUnmount.call(this, this);\n  };\n\n  _proto.render = function render() {\n    return null;\n  };\n\n  return Lifecycle;\n}(React.Component);\n\n/**\n * The public API for prompting the user before navigating away from a screen.\n */\n\nfunction Prompt(_ref) {\n  var message = _ref.message,\n      _ref$when = _ref.when,\n      when = _ref$when === void 0 ? true : _ref$when;\n  return React.createElement(context.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Prompt> outside a <Router>\") : invariant(false) : void 0;\n    if (!when || context.staticContext) return null;\n    var method = context.history.block;\n    return React.createElement(Lifecycle, {\n      onMount: function onMount(self) {\n        self.release = method(message);\n      },\n      onUpdate: function onUpdate(self, prevProps) {\n        if (prevProps.message !== message) {\n          self.release();\n          self.release = method(message);\n        }\n      },\n      onUnmount: function onUnmount(self) {\n        self.release();\n      },\n      message: message\n    });\n  });\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  var messageType = PropTypes.oneOfType([PropTypes.func, PropTypes.string]);\n  Prompt.propTypes = {\n    when: PropTypes.bool,\n    message: messageType.isRequired\n  };\n}\n\nvar cache = {};\nvar cacheLimit = 10000;\nvar cacheCount = 0;\n\nfunction compilePath(path) {\n  if (cache[path]) return cache[path];\n  var generator = pathToRegexp.compile(path);\n\n  if (cacheCount < cacheLimit) {\n    cache[path] = generator;\n    cacheCount++;\n  }\n\n  return generator;\n}\n/**\n * Public API for generating a URL pathname from a path and parameters.\n */\n\n\nfunction generatePath(path, params) {\n  if (path === void 0) {\n    path = \"/\";\n  }\n\n  if (params === void 0) {\n    params = {};\n  }\n\n  return path === \"/\" ? path : compilePath(path)(params, {\n    pretty: true\n  });\n}\n\n/**\n * The public API for navigating programmatically with a component.\n */\n\nfunction Redirect(_ref) {\n  var computedMatch = _ref.computedMatch,\n      to = _ref.to,\n      _ref$push = _ref.push,\n      push = _ref$push === void 0 ? false : _ref$push;\n  return React.createElement(context.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Redirect> outside a <Router>\") : invariant(false) : void 0;\n    var history = context.history,\n        staticContext = context.staticContext;\n    var method = push ? history.push : history.replace;\n    var location = createLocation(computedMatch ? typeof to === \"string\" ? generatePath(to, computedMatch.params) : _extends({}, to, {\n      pathname: generatePath(to.pathname, computedMatch.params)\n    }) : to); // When rendering in a static context,\n    // set the new location immediately.\n\n    if (staticContext) {\n      method(location);\n      return null;\n    }\n\n    return React.createElement(Lifecycle, {\n      onMount: function onMount() {\n        method(location);\n      },\n      onUpdate: function onUpdate(self, prevProps) {\n        var prevLocation = createLocation(prevProps.to);\n\n        if (!locationsAreEqual(prevLocation, _extends({}, location, {\n          key: prevLocation.key\n        }))) {\n          method(location);\n        }\n      },\n      to: to\n    });\n  });\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  Redirect.propTypes = {\n    push: PropTypes.bool,\n    from: PropTypes.string,\n    to: PropTypes.oneOfType([PropTypes.string, PropTypes.object]).isRequired\n  };\n}\n\nvar cache$1 = {};\nvar cacheLimit$1 = 10000;\nvar cacheCount$1 = 0;\n\nfunction compilePath$1(path, options) {\n  var cacheKey = \"\" + options.end + options.strict + options.sensitive;\n  var pathCache = cache$1[cacheKey] || (cache$1[cacheKey] = {});\n  if (pathCache[path]) return pathCache[path];\n  var keys = [];\n  var regexp = pathToRegexp(path, keys, options);\n  var result = {\n    regexp: regexp,\n    keys: keys\n  };\n\n  if (cacheCount$1 < cacheLimit$1) {\n    pathCache[path] = result;\n    cacheCount$1++;\n  }\n\n  return result;\n}\n/**\n * Public API for matching a URL pathname to a path.\n */\n\n\nfunction matchPath(pathname, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  if (typeof options === \"string\" || Array.isArray(options)) {\n    options = {\n      path: options\n    };\n  }\n\n  var _options = options,\n      path = _options.path,\n      _options$exact = _options.exact,\n      exact = _options$exact === void 0 ? false : _options$exact,\n      _options$strict = _options.strict,\n      strict = _options$strict === void 0 ? false : _options$strict,\n      _options$sensitive = _options.sensitive,\n      sensitive = _options$sensitive === void 0 ? false : _options$sensitive;\n  var paths = [].concat(path);\n  return paths.reduce(function (matched, path) {\n    if (!path && path !== \"\") return null;\n    if (matched) return matched;\n\n    var _compilePath = compilePath$1(path, {\n      end: exact,\n      strict: strict,\n      sensitive: sensitive\n    }),\n        regexp = _compilePath.regexp,\n        keys = _compilePath.keys;\n\n    var match = regexp.exec(pathname);\n    if (!match) return null;\n    var url = match[0],\n        values = match.slice(1);\n    var isExact = pathname === url;\n    if (exact && !isExact) return null;\n    return {\n      path: path,\n      // the path used to match\n      url: path === \"/\" && url === \"\" ? \"/\" : url,\n      // the matched portion of the URL\n      isExact: isExact,\n      // whether or not we matched exactly\n      params: keys.reduce(function (memo, key, index) {\n        memo[key.name] = values[index];\n        return memo;\n      }, {})\n    };\n  }, null);\n}\n\nfunction isEmptyChildren(children) {\n  return React.Children.count(children) === 0;\n}\n\nfunction evalChildrenDev(children, props, path) {\n  var value = children(props);\n  process.env.NODE_ENV !== \"production\" ? warning(value !== undefined, \"You returned `undefined` from the `children` function of \" + (\"<Route\" + (path ? \" path=\\\"\" + path + \"\\\"\" : \"\") + \">, but you \") + \"should have returned a React element or `null`\") : void 0;\n  return value || null;\n}\n/**\n * The public API for matching a single path and rendering.\n */\n\n\nvar Route =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Route, _React$Component);\n\n  function Route() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Route.prototype;\n\n  _proto.render = function render() {\n    var _this = this;\n\n    return React.createElement(context.Consumer, null, function (context$1) {\n      !context$1 ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Route> outside a <Router>\") : invariant(false) : void 0;\n      var location = _this.props.location || context$1.location;\n      var match = _this.props.computedMatch ? _this.props.computedMatch // <Switch> already computed the match for us\n      : _this.props.path ? matchPath(location.pathname, _this.props) : context$1.match;\n\n      var props = _extends({}, context$1, {\n        location: location,\n        match: match\n      });\n\n      var _this$props = _this.props,\n          children = _this$props.children,\n          component = _this$props.component,\n          render = _this$props.render; // Preact uses an empty array as children by\n      // default, so use null if that's the case.\n\n      if (Array.isArray(children) && children.length === 0) {\n        children = null;\n      }\n\n      return React.createElement(context.Provider, {\n        value: props\n      }, props.match ? children ? typeof children === \"function\" ? process.env.NODE_ENV !== \"production\" ? evalChildrenDev(children, props, _this.props.path) : children(props) : children : component ? React.createElement(component, props) : render ? render(props) : null : typeof children === \"function\" ? process.env.NODE_ENV !== \"production\" ? evalChildrenDev(children, props, _this.props.path) : children(props) : null);\n    });\n  };\n\n  return Route;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  Route.propTypes = {\n    children: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),\n    component: function component(props, propName) {\n      if (props[propName] && !isValidElementType(props[propName])) {\n        return new Error(\"Invalid prop 'component' supplied to 'Route': the prop is not a valid React component\");\n      }\n    },\n    exact: PropTypes.bool,\n    location: PropTypes.object,\n    path: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),\n    render: PropTypes.func,\n    sensitive: PropTypes.bool,\n    strict: PropTypes.bool\n  };\n\n  Route.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.children && !isEmptyChildren(this.props.children) && this.props.component), \"You should not use <Route component> and <Route children> in the same route; <Route component> will be ignored\") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.children && !isEmptyChildren(this.props.children) && this.props.render), \"You should not use <Route render> and <Route children> in the same route; <Route render> will be ignored\") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.component && this.props.render), \"You should not use <Route component> and <Route render> in the same route; <Route render> will be ignored\") : void 0;\n  };\n\n  Route.prototype.componentDidUpdate = function (prevProps) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.location && !prevProps.location), '<Route> elements should not change from uncontrolled to controlled (or vice versa). You initially used no \"location\" prop and then provided one on a subsequent render.') : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(!this.props.location && prevProps.location), '<Route> elements should not change from controlled to uncontrolled (or vice versa). You provided a \"location\" prop initially but omitted it on a subsequent render.') : void 0;\n  };\n}\n\nfunction addLeadingSlash(path) {\n  return path.charAt(0) === \"/\" ? path : \"/\" + path;\n}\n\nfunction addBasename(basename, location) {\n  if (!basename) return location;\n  return _extends({}, location, {\n    pathname: addLeadingSlash(basename) + location.pathname\n  });\n}\n\nfunction stripBasename(basename, location) {\n  if (!basename) return location;\n  var base = addLeadingSlash(basename);\n  if (location.pathname.indexOf(base) !== 0) return location;\n  return _extends({}, location, {\n    pathname: location.pathname.substr(base.length)\n  });\n}\n\nfunction createURL(location) {\n  return typeof location === \"string\" ? location : createPath(location);\n}\n\nfunction staticHandler(methodName) {\n  return function () {\n     process.env.NODE_ENV !== \"production\" ? invariant(false, \"You cannot %s with <StaticRouter>\", methodName) : invariant(false) ;\n  };\n}\n\nfunction noop() {}\n/**\n * The public top-level API for a \"static\" <Router>, so-called because it\n * can't actually change the current location. Instead, it just records\n * location changes in a context object. Useful mainly in testing and\n * server-rendering scenarios.\n */\n\n\nvar StaticRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(StaticRouter, _React$Component);\n\n  function StaticRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n\n    _this.handlePush = function (location) {\n      return _this.navigateTo(location, \"PUSH\");\n    };\n\n    _this.handleReplace = function (location) {\n      return _this.navigateTo(location, \"REPLACE\");\n    };\n\n    _this.handleListen = function () {\n      return noop;\n    };\n\n    _this.handleBlock = function () {\n      return noop;\n    };\n\n    return _this;\n  }\n\n  var _proto = StaticRouter.prototype;\n\n  _proto.navigateTo = function navigateTo(location, action) {\n    var _this$props = this.props,\n        _this$props$basename = _this$props.basename,\n        basename = _this$props$basename === void 0 ? \"\" : _this$props$basename,\n        _this$props$context = _this$props.context,\n        context = _this$props$context === void 0 ? {} : _this$props$context;\n    context.action = action;\n    context.location = addBasename(basename, createLocation(location));\n    context.url = createURL(context.location);\n  };\n\n  _proto.render = function render() {\n    var _this$props2 = this.props,\n        _this$props2$basename = _this$props2.basename,\n        basename = _this$props2$basename === void 0 ? \"\" : _this$props2$basename,\n        _this$props2$context = _this$props2.context,\n        context = _this$props2$context === void 0 ? {} : _this$props2$context,\n        _this$props2$location = _this$props2.location,\n        location = _this$props2$location === void 0 ? \"/\" : _this$props2$location,\n        rest = _objectWithoutPropertiesLoose(_this$props2, [\"basename\", \"context\", \"location\"]);\n\n    var history = {\n      createHref: function createHref(path) {\n        return addLeadingSlash(basename + createURL(path));\n      },\n      action: \"POP\",\n      location: stripBasename(basename, createLocation(location)),\n      push: this.handlePush,\n      replace: this.handleReplace,\n      go: staticHandler(\"go\"),\n      goBack: staticHandler(\"goBack\"),\n      goForward: staticHandler(\"goForward\"),\n      listen: this.handleListen,\n      block: this.handleBlock\n    };\n    return React.createElement(Router, _extends({}, rest, {\n      history: history,\n      staticContext: context\n    }));\n  };\n\n  return StaticRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  StaticRouter.propTypes = {\n    basename: PropTypes.string,\n    context: PropTypes.object,\n    location: PropTypes.oneOfType([PropTypes.string, PropTypes.object])\n  };\n\n  StaticRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<StaticRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { StaticRouter as Router }`.\") : void 0;\n  };\n}\n\n/**\n * The public API for rendering the first <Route> that matches.\n */\n\nvar Switch =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Switch, _React$Component);\n\n  function Switch() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Switch.prototype;\n\n  _proto.render = function render() {\n    var _this = this;\n\n    return React.createElement(context.Consumer, null, function (context) {\n      !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Switch> outside a <Router>\") : invariant(false) : void 0;\n      var location = _this.props.location || context.location;\n      var element, match; // We use React.Children.forEach instead of React.Children.toArray().find()\n      // here because toArray adds keys to all child elements and we do not want\n      // to trigger an unmount/remount for two <Route>s that render the same\n      // component at different URLs.\n\n      React.Children.forEach(_this.props.children, function (child) {\n        if (match == null && React.isValidElement(child)) {\n          element = child;\n          var path = child.props.path || child.props.from;\n          match = path ? matchPath(location.pathname, _extends({}, child.props, {\n            path: path\n          })) : context.match;\n        }\n      });\n      return match ? React.cloneElement(element, {\n        location: location,\n        computedMatch: match\n      }) : null;\n    });\n  };\n\n  return Switch;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  Switch.propTypes = {\n    children: PropTypes.node,\n    location: PropTypes.object\n  };\n\n  Switch.prototype.componentDidUpdate = function (prevProps) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.location && !prevProps.location), '<Switch> elements should not change from uncontrolled to controlled (or vice versa). You initially used no \"location\" prop and then provided one on a subsequent render.') : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(!this.props.location && prevProps.location), '<Switch> elements should not change from controlled to uncontrolled (or vice versa). You provided a \"location\" prop initially but omitted it on a subsequent render.') : void 0;\n  };\n}\n\n/**\n * A public higher-order component to access the imperative API\n */\n\nfunction withRouter(Component) {\n  var displayName = \"withRouter(\" + (Component.displayName || Component.name) + \")\";\n\n  var C = function C(props) {\n    var wrappedComponentRef = props.wrappedComponentRef,\n        remainingProps = _objectWithoutPropertiesLoose(props, [\"wrappedComponentRef\"]);\n\n    return React.createElement(context.Consumer, null, function (context) {\n      !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <\" + displayName + \" /> outside a <Router>\") : invariant(false) : void 0;\n      return React.createElement(Component, _extends({}, remainingProps, context, {\n        ref: wrappedComponentRef\n      }));\n    });\n  };\n\n  C.displayName = displayName;\n  C.WrappedComponent = Component;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    C.propTypes = {\n      wrappedComponentRef: PropTypes.oneOfType([PropTypes.string, PropTypes.func, PropTypes.object])\n    };\n  }\n\n  return hoistStatics(C, Component);\n}\n\nvar useContext = React.useContext;\nfunction useHistory() {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useHistory()\") : invariant(false) : void 0;\n  }\n\n  return useContext(historyContext);\n}\nfunction useLocation() {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useLocation()\") : invariant(false) : void 0;\n  }\n\n  return useContext(context).location;\n}\nfunction useParams() {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useParams()\") : invariant(false) : void 0;\n  }\n\n  var match = useContext(context).match;\n  return match ? match.params : {};\n}\nfunction useRouteMatch(path) {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useRouteMatch()\") : invariant(false) : void 0;\n  }\n\n  var location = useLocation();\n  var match = useContext(context).match;\n  return path ? matchPath(location.pathname, path) : match;\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  if (typeof window !== \"undefined\") {\n    var global = window;\n    var key = \"__react_router_build__\";\n    var buildNames = {\n      cjs: \"CommonJS\",\n      esm: \"ES modules\",\n      umd: \"UMD\"\n    };\n\n    if (global[key] && global[key] !== \"esm\") {\n      var initialBuildName = buildNames[global[key]];\n      var secondaryBuildName = buildNames[\"esm\"]; // TODO: Add link to article that explains in detail how to avoid\n      // loading 2 different builds.\n\n      throw new Error(\"You are loading the \" + secondaryBuildName + \" build of React Router \" + (\"on a page that is already running the \" + initialBuildName + \" \") + \"build, so things won't work right.\");\n    }\n\n    global[key] = \"esm\";\n  }\n}\n\nexport { MemoryRouter, Prompt, Redirect, Route, Router, StaticRouter, Switch, historyContext as __HistoryContext, context as __RouterContext, generatePath, matchPath, useHistory, useLocation, useParams, useRouteMatch, withRouter };\n//# sourceMappingURL=react-router.js.map\n"],"sourceRoot":""}