{"version":3,"sources":["../../src/timer.js","../../src/domHelpers.js","../../src/createGridComponent.js","../../src/createListComponent.js","../../src/VariableSizeList.js","../node_modules/react/cjs/react.production.min.js","../node_modules/react/cjs/react-jsx-runtime.production.min.js"],"names":["now","performance","Date","cancelTimeout","timeoutID","cancelAnimationFrame","id","requestTimeout","callback","delay","start","requestAnimationFrame","tick","call","cachedRTLResult","getRTLOffsetType","recalculate","outerDiv","document","createElement","outerStyle","style","width","height","overflow","direction","innerDiv","innerStyle","appendChild","body","scrollLeft","removeChild","defaultItemKey$1","index","data","createListComponent","_ref","getItemOffset","getEstimatedTotalSize","getItemSize","getOffsetForIndexAndAlignment","getStartIndexForOffset","getStopIndexForStartIndex","initInstanceProps","shouldResetStyleCacheOnItemSizeChange","validateProps","props","_instanceProps","_this","_assertThisInitialized","_outerRef","_resetIsScrollingTimeoutId","state","instance","isScrolling","scrollDirection","scrollOffset","initialScrollOffset","scrollUpdateWasRequested","_callOnItemsRendered","memoizeOne","overscanStartIndex","overscanStopIndex","visibleStartIndex","visibleStopIndex","onItemsRendered","_callOnScroll","onScroll","_getItemStyle","_this$props","itemSize","layout","itemStyleCache","_getItemStyleCache","hasOwnProperty","_offset","size","isHorizontal","isRtl","offsetHorizontal","position","left","undefined","right","top","_","__","___","_onScrollHorizontal","event","currentTarget","clientWidth","_event$currentTarget","scrollWidth","setState","prevState","Math","max","min","_resetIsScrollingDebounced","_onScrollVertical","clientHeight","_event$currentTarget2","scrollHeight","scrollTop","_outerRefSetter","ref","outerRef","current","_resetIsScrolling","getDerivedStateFromProps","nextProps","validateSharedProps$1","scrollTo","this","scrollToItem","align","itemCount","componentDidMount","_this$props2","_callPropsCallbacks","componentDidUpdate","_this$props3","_this$state","componentWillUnmount","render","children","_this$props4","className","innerRef","innerElementType","innerTagName","itemData","itemKey","_this$props4$itemKey","outerElementType","outerTagName","useIsScrolling","_getRangeToRender","startIndex","_this$_getRangeToRend","stopIndex","items","_index","push","key","estimatedTotalSize","_extends","WebkitOverflowScrolling","willChange","pointerEvents","_overscanStartIndex","_this$_getRangeToRend2","_overscanStopIndex","_visibleStartIndex","_visibleStopIndex","_scrollDirection","_this$state2","_scrollOffset","_scrollUpdateWasRequested","_this$props5","overscanCount","_this$state3","overscanBackward","overscanForward","PureComponent","_class","defaultProps","_temp","_ref2","_ref3","getItemMetadata$1","instanceProps","itemMetadataMap","lastMeasuredIndex","offset","itemMetadata","i","findNearestItemBinarySearch$1","high","low","middle","floor","currentOffset","findNearestItemExponentialSearch$1","interval","estimatedItemSize","totalSizeOfMeasuredItems","VariableSizeList","maxOffset","minOffset","round","findNearestItem$1","resetAfterIndex","shouldForceUpdate","forceUpdate","_ref5","l","require","n","p","exports","Fragment","StrictMode","Profiler","q","r","t","Suspense","u","v","Symbol","for","w","x","iterator","z","a","b","c","arguments","length","encodeURIComponent","A","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","B","C","context","refs","updater","D","E","prototype","isReactComponent","Error","F","constructor","isPureReactComponent","G","H","Object","I","__self","__source","J","e","d","k","h","g","f","Array","m","$$typeof","type","_owner","L","M","N","replace","escape","toString","O","isArray","K","y","next","done","value","keys","join","P","Q","_status","_result","then","default","R","S","T","ReactCurrentDispatcher","ReactCurrentBatchConfig","transition","ReactCurrentOwner","IsSomeRendererActing","assign","Children","map","forEach","apply","count","toArray","only","Component","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","cloneElement","createContext","_calculateChangedBits","_currentValue","_currentValue2","_threadCount","Provider","Consumer","_context","createFactory","bind","createRef","forwardRef","isValidElement","lazy","_payload","_init","memo","compare","useCallback","useContext","useDebugValue","useEffect","useImperativeHandle","useLayoutEffect","useMemo","useReducer","useRef","useState","version","jsx","jsxs"],"mappings":"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","file":"static/js/main~f734b0c6.f981e3ff.chunk.js","sourcesContent":["// @flow\n\n// Animation frame based implementation of setTimeout.\n// Inspired by Joe Lambert, https://gist.github.com/joelambert/1002116#file-requesttimeout-js\n\nconst hasNativePerformanceNow =\n  typeof performance === 'object' && typeof performance.now === 'function';\n\nconst now = hasNativePerformanceNow\n  ? () => performance.now()\n  : () => Date.now();\n\nexport type TimeoutID = {|\n  id: AnimationFrameID,\n|};\n\nexport function cancelTimeout(timeoutID: TimeoutID) {\n  cancelAnimationFrame(timeoutID.id);\n}\n\nexport function requestTimeout(callback: Function, delay: number): TimeoutID {\n  const 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  const timeoutID: TimeoutID = {\n    id: requestAnimationFrame(tick),\n  };\n\n  return timeoutID;\n}\n","// @flow\n\nlet size: number = -1;\n\n// This utility copied from \"dom-helpers\" package.\nexport function getScrollbarSize(recalculate?: boolean = false): number {\n  if (size === -1 || recalculate) {\n    const div = document.createElement('div');\n    const style = div.style;\n    style.width = '50px';\n    style.height = '50px';\n    style.overflow = 'scroll';\n\n    ((document.body: any): HTMLBodyElement).appendChild(div);\n\n    size = div.offsetWidth - div.clientWidth;\n\n    ((document.body: any): HTMLBodyElement).removeChild(div);\n  }\n\n  return size;\n}\n\nexport type RTLOffsetType =\n  | 'negative'\n  | 'positive-descending'\n  | 'positive-ascending';\n\nlet cachedRTLResult: RTLOffsetType | null = null;\n\n// 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.\nexport function getRTLOffsetType(recalculate?: boolean = false): RTLOffsetType {\n  if (cachedRTLResult === null || recalculate) {\n    const outerDiv = document.createElement('div');\n    const outerStyle = outerDiv.style;\n    outerStyle.width = '50px';\n    outerStyle.height = '50px';\n    outerStyle.overflow = 'scroll';\n    outerStyle.direction = 'rtl';\n\n    const innerDiv = document.createElement('div');\n    const innerStyle = innerDiv.style;\n    innerStyle.width = '100px';\n    innerStyle.height = '100px';\n\n    outerDiv.appendChild(innerDiv);\n\n    ((document.body: any): HTMLBodyElement).appendChild(outerDiv);\n\n    if (outerDiv.scrollLeft > 0) {\n      cachedRTLResult = 'positive-descending';\n    } else {\n      outerDiv.scrollLeft = 1;\n      if (outerDiv.scrollLeft === 0) {\n        cachedRTLResult = 'negative';\n      } else {\n        cachedRTLResult = 'positive-ascending';\n      }\n    }\n\n    ((document.body: any): HTMLBodyElement).removeChild(outerDiv);\n\n    return cachedRTLResult;\n  }\n\n  return cachedRTLResult;\n}\n","// @flow\n\nimport memoizeOne from 'memoize-one';\nimport { createElement, PureComponent } from 'react';\nimport { cancelTimeout, requestTimeout } from './timer';\nimport { getScrollbarSize, getRTLOffsetType } from './domHelpers';\n\nimport type { TimeoutID } from './timer';\n\ntype Direction = 'ltr' | 'rtl';\nexport type ScrollToAlign = 'auto' | 'smart' | 'center' | 'start' | 'end';\n\ntype itemSize = number | ((index: number) => number);\n\ntype RenderComponentProps<T> = {|\n  columnIndex: number,\n  data: T,\n  isScrolling?: boolean,\n  rowIndex: number,\n  style: Object,\n|};\nexport type RenderComponent<T> = React$ComponentType<\n  $Shape<RenderComponentProps<T>>\n>;\n\ntype ScrollDirection = 'forward' | 'backward';\n\ntype OnItemsRenderedCallback = ({\n  overscanColumnStartIndex: number,\n  overscanColumnStopIndex: number,\n  overscanRowStartIndex: number,\n  overscanRowStopIndex: number,\n  visibleColumnStartIndex: number,\n  visibleColumnStopIndex: number,\n  visibleRowStartIndex: number,\n  visibleRowStopIndex: number,\n}) => void;\ntype OnScrollCallback = ({\n  horizontalScrollDirection: ScrollDirection,\n  scrollLeft: number,\n  scrollTop: number,\n  scrollUpdateWasRequested: boolean,\n  verticalScrollDirection: ScrollDirection,\n}) => void;\n\ntype ScrollEvent = SyntheticEvent<HTMLDivElement>;\ntype ItemStyleCache = { [key: string]: Object };\n\ntype OuterProps = {|\n  children: React$Node,\n  className: string | void,\n  onScroll: ScrollEvent => void,\n  style: {\n    [string]: mixed,\n  },\n|};\n\ntype InnerProps = {|\n  children: React$Node,\n  style: {\n    [string]: mixed,\n  },\n|};\n\nexport type Props<T> = {|\n  children: RenderComponent<T>,\n  className?: string,\n  columnCount: number,\n  columnWidth: itemSize,\n  direction: Direction,\n  height: number,\n  initialScrollLeft?: number,\n  initialScrollTop?: number,\n  innerRef?: any,\n  innerElementType?: string | React$AbstractComponent<InnerProps, any>,\n  innerTagName?: string, // deprecated\n  itemData: T,\n  itemKey?: (params: {|\n    columnIndex: number,\n    data: T,\n    rowIndex: number,\n  |}) => any,\n  onItemsRendered?: OnItemsRenderedCallback,\n  onScroll?: OnScrollCallback,\n  outerRef?: any,\n  outerElementType?: string | React$AbstractComponent<OuterProps, any>,\n  outerTagName?: string, // deprecated\n  overscanColumnCount?: number,\n  overscanColumnsCount?: number, // deprecated\n  overscanCount?: number, // deprecated\n  overscanRowCount?: number,\n  overscanRowsCount?: number, // deprecated\n  rowCount: number,\n  rowHeight: itemSize,\n  style?: Object,\n  useIsScrolling: boolean,\n  width: number,\n|};\n\ntype State = {|\n  instance: any,\n  isScrolling: boolean,\n  horizontalScrollDirection: ScrollDirection,\n  scrollLeft: number,\n  scrollTop: number,\n  scrollUpdateWasRequested: boolean,\n  verticalScrollDirection: ScrollDirection,\n|};\n\ntype getItemOffset = (\n  props: Props<any>,\n  index: number,\n  instanceProps: any\n) => number;\ntype getItemSize = (\n  props: Props<any>,\n  index: number,\n  instanceProps: any\n) => number;\ntype getEstimatedTotalSize = (props: Props<any>, instanceProps: any) => number;\ntype GetOffsetForItemAndAlignment = (\n  props: Props<any>,\n  index: number,\n  align: ScrollToAlign,\n  scrollOffset: number,\n  instanceProps: any,\n  scrollbarSize: number\n) => number;\ntype GetStartIndexForOffset = (\n  props: Props<any>,\n  offset: number,\n  instanceProps: any\n) => number;\ntype GetStopIndexForStartIndex = (\n  props: Props<any>,\n  startIndex: number,\n  scrollOffset: number,\n  instanceProps: any\n) => number;\ntype InitInstanceProps = (props: Props<any>, instance: any) => any;\ntype ValidateProps = (props: Props<any>) => void;\n\nconst IS_SCROLLING_DEBOUNCE_INTERVAL = 150;\n\nconst defaultItemKey = ({ columnIndex, data, rowIndex }) =>\n  `${rowIndex}:${columnIndex}`;\n\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.\nlet devWarningsOverscanCount = null;\nlet devWarningsOverscanRowsColumnsCount = null;\nlet devWarningsTagName = null;\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof window !== 'undefined' && typeof window.WeakSet !== 'undefined') {\n    devWarningsOverscanCount = new WeakSet();\n    devWarningsOverscanRowsColumnsCount = new WeakSet();\n    devWarningsTagName = new WeakSet();\n  }\n}\n\nexport default function createGridComponent({\n  getColumnOffset,\n  getColumnStartIndexForOffset,\n  getColumnStopIndexForStartIndex,\n  getColumnWidth,\n  getEstimatedTotalHeight,\n  getEstimatedTotalWidth,\n  getOffsetForColumnAndAlignment,\n  getOffsetForRowAndAlignment,\n  getRowHeight,\n  getRowOffset,\n  getRowStartIndexForOffset,\n  getRowStopIndexForStartIndex,\n  initInstanceProps,\n  shouldResetStyleCacheOnItemSizeChange,\n  validateProps,\n}: {|\n  getColumnOffset: getItemOffset,\n  getColumnStartIndexForOffset: GetStartIndexForOffset,\n  getColumnStopIndexForStartIndex: GetStopIndexForStartIndex,\n  getColumnWidth: getItemSize,\n  getEstimatedTotalHeight: getEstimatedTotalSize,\n  getEstimatedTotalWidth: getEstimatedTotalSize,\n  getOffsetForColumnAndAlignment: GetOffsetForItemAndAlignment,\n  getOffsetForRowAndAlignment: GetOffsetForItemAndAlignment,\n  getRowOffset: getItemOffset,\n  getRowHeight: getItemSize,\n  getRowStartIndexForOffset: GetStartIndexForOffset,\n  getRowStopIndexForStartIndex: GetStopIndexForStartIndex,\n  initInstanceProps: InitInstanceProps,\n  shouldResetStyleCacheOnItemSizeChange: boolean,\n  validateProps: ValidateProps,\n|}) {\n  return class Grid<T> extends PureComponent<Props<T>, State> {\n    _instanceProps: any = initInstanceProps(this.props, this);\n    _resetIsScrollingTimeoutId: TimeoutID | null = null;\n    _outerRef: ?HTMLDivElement;\n\n    static defaultProps = {\n      direction: 'ltr',\n      itemData: undefined,\n      useIsScrolling: false,\n    };\n\n    state: State = {\n      instance: this,\n      isScrolling: false,\n      horizontalScrollDirection: 'forward',\n      scrollLeft:\n        typeof this.props.initialScrollLeft === 'number'\n          ? this.props.initialScrollLeft\n          : 0,\n      scrollTop:\n        typeof this.props.initialScrollTop === 'number'\n          ? this.props.initialScrollTop\n          : 0,\n      scrollUpdateWasRequested: false,\n      verticalScrollDirection: 'forward',\n    };\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    constructor(props: Props<T>) {\n      super(props);\n    }\n\n    static getDerivedStateFromProps(\n      nextProps: Props<T>,\n      prevState: State\n    ): $Shape<State> | null {\n      validateSharedProps(nextProps, prevState);\n      validateProps(nextProps);\n      return null;\n    }\n\n    scrollTo({\n      scrollLeft,\n      scrollTop,\n    }: {\n      scrollLeft: number,\n      scrollTop: number,\n    }): void {\n      if (scrollLeft !== undefined) {\n        scrollLeft = Math.max(0, scrollLeft);\n      }\n      if (scrollTop !== undefined) {\n        scrollTop = Math.max(0, scrollTop);\n      }\n\n      this.setState(prevState => {\n        if (scrollLeft === undefined) {\n          scrollLeft = prevState.scrollLeft;\n        }\n        if (scrollTop === undefined) {\n          scrollTop = prevState.scrollTop;\n        }\n\n        if (\n          prevState.scrollLeft === scrollLeft &&\n          prevState.scrollTop === scrollTop\n        ) {\n          return null;\n        }\n\n        return {\n          horizontalScrollDirection:\n            prevState.scrollLeft < scrollLeft ? 'forward' : 'backward',\n          scrollLeft: scrollLeft,\n          scrollTop: scrollTop,\n          scrollUpdateWasRequested: true,\n          verticalScrollDirection:\n            prevState.scrollTop < scrollTop ? 'forward' : 'backward',\n        };\n      }, this._resetIsScrollingDebounced);\n    }\n\n    scrollToItem({\n      align = 'auto',\n      columnIndex,\n      rowIndex,\n    }: {\n      align: ScrollToAlign,\n      columnIndex?: number,\n      rowIndex?: number,\n    }): void {\n      const { columnCount, height, rowCount, width } = this.props;\n      const { scrollLeft, scrollTop } = this.state;\n      const scrollbarSize = getScrollbarSize();\n\n      if (columnIndex !== undefined) {\n        columnIndex = Math.max(0, Math.min(columnIndex, columnCount - 1));\n      }\n      if (rowIndex !== undefined) {\n        rowIndex = Math.max(0, Math.min(rowIndex, rowCount - 1));\n      }\n\n      const estimatedTotalHeight = getEstimatedTotalHeight(\n        this.props,\n        this._instanceProps\n      );\n      const estimatedTotalWidth = getEstimatedTotalWidth(\n        this.props,\n        this._instanceProps\n      );\n\n      // 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      const horizontalScrollbarSize =\n        estimatedTotalWidth > width ? scrollbarSize : 0;\n      const verticalScrollbarSize =\n        estimatedTotalHeight > height ? scrollbarSize : 0;\n\n      this.scrollTo({\n        scrollLeft:\n          columnIndex !== undefined\n            ? getOffsetForColumnAndAlignment(\n                this.props,\n                columnIndex,\n                align,\n                scrollLeft,\n                this._instanceProps,\n                verticalScrollbarSize\n              )\n            : scrollLeft,\n        scrollTop:\n          rowIndex !== undefined\n            ? getOffsetForRowAndAlignment(\n                this.props,\n                rowIndex,\n                align,\n                scrollTop,\n                this._instanceProps,\n                horizontalScrollbarSize\n              )\n            : scrollTop,\n      });\n    }\n\n    componentDidMount() {\n      const { initialScrollLeft, initialScrollTop } = this.props;\n\n      if (this._outerRef != null) {\n        const outerRef = ((this._outerRef: any): HTMLElement);\n        if (typeof initialScrollLeft === 'number') {\n          outerRef.scrollLeft = initialScrollLeft;\n        }\n        if (typeof initialScrollTop === 'number') {\n          outerRef.scrollTop = initialScrollTop;\n        }\n      }\n\n      this._callPropsCallbacks();\n    }\n\n    componentDidUpdate() {\n      const { direction } = this.props;\n      const { scrollLeft, scrollTop, scrollUpdateWasRequested } = this.state;\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        const outerRef = ((this._outerRef: any): HTMLElement);\n        if (direction === 'rtl') {\n          switch (getRTLOffsetType()) {\n            case 'negative':\n              outerRef.scrollLeft = -scrollLeft;\n              break;\n            case 'positive-ascending':\n              outerRef.scrollLeft = scrollLeft;\n              break;\n            default:\n              const { clientWidth, scrollWidth } = outerRef;\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    componentWillUnmount() {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n    }\n\n    render() {\n      const {\n        children,\n        className,\n        columnCount,\n        direction,\n        height,\n        innerRef,\n        innerElementType,\n        innerTagName,\n        itemData,\n        itemKey = defaultItemKey,\n        outerElementType,\n        outerTagName,\n        rowCount,\n        style,\n        useIsScrolling,\n        width,\n      } = this.props;\n      const { isScrolling } = this.state;\n\n      const [\n        columnStartIndex,\n        columnStopIndex,\n      ] = this._getHorizontalRangeToRender();\n      const [rowStartIndex, rowStopIndex] = this._getVerticalRangeToRender();\n\n      const items = [];\n      if (columnCount > 0 && rowCount) {\n        for (\n          let rowIndex = rowStartIndex;\n          rowIndex <= rowStopIndex;\n          rowIndex++\n        ) {\n          for (\n            let columnIndex = columnStartIndex;\n            columnIndex <= columnStopIndex;\n            columnIndex++\n          ) {\n            items.push(\n              createElement(children, {\n                columnIndex,\n                data: itemData,\n                isScrolling: useIsScrolling ? isScrolling : undefined,\n                key: itemKey({ columnIndex, data: itemData, rowIndex }),\n                rowIndex,\n                style: this._getItemStyle(rowIndex, columnIndex),\n              })\n            );\n          }\n        }\n      }\n\n      // Read this value AFTER items have been created,\n      // So their actual sizes (if variable) are taken into consideration.\n      const estimatedTotalHeight = getEstimatedTotalHeight(\n        this.props,\n        this._instanceProps\n      );\n      const estimatedTotalWidth = getEstimatedTotalWidth(\n        this.props,\n        this._instanceProps\n      );\n\n      return createElement(\n        outerElementType || outerTagName || 'div',\n        {\n          className,\n          onScroll: this._onScroll,\n          ref: this._outerRefSetter,\n          style: {\n            position: 'relative',\n            height,\n            width,\n            overflow: 'auto',\n            WebkitOverflowScrolling: 'touch',\n            willChange: 'transform',\n            direction,\n            ...style,\n          },\n        },\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\n    _callOnItemsRendered: (\n      overscanColumnStartIndex: number,\n      overscanColumnStopIndex: number,\n      overscanRowStartIndex: number,\n      overscanRowStopIndex: number,\n      visibleColumnStartIndex: number,\n      visibleColumnStopIndex: number,\n      visibleRowStartIndex: number,\n      visibleRowStopIndex: number\n    ) => void;\n    _callOnItemsRendered = memoizeOne(\n      (\n        overscanColumnStartIndex: number,\n        overscanColumnStopIndex: number,\n        overscanRowStartIndex: number,\n        overscanRowStopIndex: number,\n        visibleColumnStartIndex: number,\n        visibleColumnStopIndex: number,\n        visibleRowStartIndex: number,\n        visibleRowStopIndex: number\n      ) =>\n        ((this.props.onItemsRendered: any): OnItemsRenderedCallback)({\n          overscanColumnStartIndex,\n          overscanColumnStopIndex,\n          overscanRowStartIndex,\n          overscanRowStopIndex,\n          visibleColumnStartIndex,\n          visibleColumnStopIndex,\n          visibleRowStartIndex,\n          visibleRowStopIndex,\n        })\n    );\n\n    _callOnScroll: (\n      scrollLeft: number,\n      scrollTop: number,\n      horizontalScrollDirection: ScrollDirection,\n      verticalScrollDirection: ScrollDirection,\n      scrollUpdateWasRequested: boolean\n    ) => void;\n    _callOnScroll = memoizeOne(\n      (\n        scrollLeft: number,\n        scrollTop: number,\n        horizontalScrollDirection: ScrollDirection,\n        verticalScrollDirection: ScrollDirection,\n        scrollUpdateWasRequested: boolean\n      ) =>\n        ((this.props.onScroll: any): OnScrollCallback)({\n          horizontalScrollDirection,\n          scrollLeft,\n          scrollTop,\n          verticalScrollDirection,\n          scrollUpdateWasRequested,\n        })\n    );\n\n    _callPropsCallbacks() {\n      const { columnCount, onItemsRendered, onScroll, rowCount } = this.props;\n\n      if (typeof onItemsRendered === 'function') {\n        if (columnCount > 0 && rowCount > 0) {\n          const [\n            overscanColumnStartIndex,\n            overscanColumnStopIndex,\n            visibleColumnStartIndex,\n            visibleColumnStopIndex,\n          ] = this._getHorizontalRangeToRender();\n          const [\n            overscanRowStartIndex,\n            overscanRowStopIndex,\n            visibleRowStartIndex,\n            visibleRowStopIndex,\n          ] = this._getVerticalRangeToRender();\n          this._callOnItemsRendered(\n            overscanColumnStartIndex,\n            overscanColumnStopIndex,\n            overscanRowStartIndex,\n            overscanRowStopIndex,\n            visibleColumnStartIndex,\n            visibleColumnStopIndex,\n            visibleRowStartIndex,\n            visibleRowStopIndex\n          );\n        }\n      }\n\n      if (typeof onScroll === 'function') {\n        const {\n          horizontalScrollDirection,\n          scrollLeft,\n          scrollTop,\n          scrollUpdateWasRequested,\n          verticalScrollDirection,\n        } = this.state;\n        this._callOnScroll(\n          scrollLeft,\n          scrollTop,\n          horizontalScrollDirection,\n          verticalScrollDirection,\n          scrollUpdateWasRequested\n        );\n      }\n    }\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    _getItemStyle: (rowIndex: number, columnIndex: number) => Object;\n    _getItemStyle = (rowIndex: number, columnIndex: number): Object => {\n      const { columnWidth, direction, rowHeight } = this.props;\n\n      const itemStyleCache = this._getItemStyleCache(\n        shouldResetStyleCacheOnItemSizeChange && columnWidth,\n        shouldResetStyleCacheOnItemSizeChange && direction,\n        shouldResetStyleCacheOnItemSizeChange && rowHeight\n      );\n\n      const key = `${rowIndex}:${columnIndex}`;\n\n      let style;\n      if (itemStyleCache.hasOwnProperty(key)) {\n        style = itemStyleCache[key];\n      } else {\n        const offset = getColumnOffset(\n          this.props,\n          columnIndex,\n          this._instanceProps\n        );\n        const isRtl = direction === 'rtl';\n        itemStyleCache[key] = style = {\n          position: 'absolute',\n          left: isRtl ? undefined : offset,\n          right: isRtl ? offset : undefined,\n          top: getRowOffset(this.props, rowIndex, this._instanceProps),\n          height: getRowHeight(this.props, rowIndex, this._instanceProps),\n          width: getColumnWidth(this.props, columnIndex, this._instanceProps),\n        };\n      }\n\n      return style;\n    };\n\n    _getItemStyleCache: (_: any, __: any, ___: any) => ItemStyleCache;\n    _getItemStyleCache = memoizeOne((_: any, __: any, ___: any) => ({}));\n\n    _getHorizontalRangeToRender(): [number, number, number, number] {\n      const {\n        columnCount,\n        overscanColumnCount,\n        overscanColumnsCount,\n        overscanCount,\n        rowCount,\n      } = this.props;\n      const { horizontalScrollDirection, isScrolling, scrollLeft } = this.state;\n\n      const overscanCountResolved: number =\n        overscanColumnCount || overscanColumnsCount || overscanCount || 1;\n\n      if (columnCount === 0 || rowCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      const startIndex = getColumnStartIndexForOffset(\n        this.props,\n        scrollLeft,\n        this._instanceProps\n      );\n      const stopIndex = getColumnStopIndexForStartIndex(\n        this.props,\n        startIndex,\n        scrollLeft,\n        this._instanceProps\n      );\n\n      // 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      const overscanBackward =\n        !isScrolling || horizontalScrollDirection === 'backward'\n          ? Math.max(1, overscanCountResolved)\n          : 1;\n      const overscanForward =\n        !isScrolling || horizontalScrollDirection === 'forward'\n          ? Math.max(1, overscanCountResolved)\n          : 1;\n\n      return [\n        Math.max(0, startIndex - overscanBackward),\n        Math.max(0, Math.min(columnCount - 1, stopIndex + overscanForward)),\n        startIndex,\n        stopIndex,\n      ];\n    }\n\n    _getVerticalRangeToRender(): [number, number, number, number] {\n      const {\n        columnCount,\n        overscanCount,\n        overscanRowCount,\n        overscanRowsCount,\n        rowCount,\n      } = this.props;\n      const { isScrolling, verticalScrollDirection, scrollTop } = this.state;\n\n      const overscanCountResolved: number =\n        overscanRowCount || overscanRowsCount || overscanCount || 1;\n\n      if (columnCount === 0 || rowCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      const startIndex = getRowStartIndexForOffset(\n        this.props,\n        scrollTop,\n        this._instanceProps\n      );\n      const stopIndex = getRowStopIndexForStartIndex(\n        this.props,\n        startIndex,\n        scrollTop,\n        this._instanceProps\n      );\n\n      // 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      const overscanBackward =\n        !isScrolling || verticalScrollDirection === 'backward'\n          ? Math.max(1, overscanCountResolved)\n          : 1;\n      const overscanForward =\n        !isScrolling || verticalScrollDirection === 'forward'\n          ? Math.max(1, overscanCountResolved)\n          : 1;\n\n      return [\n        Math.max(0, startIndex - overscanBackward),\n        Math.max(0, Math.min(rowCount - 1, stopIndex + overscanForward)),\n        startIndex,\n        stopIndex,\n      ];\n    }\n\n    _onScroll = (event: ScrollEvent): void => {\n      const {\n        clientHeight,\n        clientWidth,\n        scrollLeft,\n        scrollTop,\n        scrollHeight,\n        scrollWidth,\n      } = event.currentTarget;\n      this.setState(prevState => {\n        if (\n          prevState.scrollLeft === scrollLeft &&\n          prevState.scrollTop === scrollTop\n        ) {\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        const { direction } = this.props;\n\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        let calculatedScrollLeft = scrollLeft;\n        if (direction === 'rtl') {\n          switch (getRTLOffsetType()) {\n            case 'negative':\n              calculatedScrollLeft = -scrollLeft;\n              break;\n            case 'positive-descending':\n              calculatedScrollLeft = scrollWidth - clientWidth - scrollLeft;\n              break;\n          }\n        }\n\n        // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n        calculatedScrollLeft = Math.max(\n          0,\n          Math.min(calculatedScrollLeft, scrollWidth - clientWidth)\n        );\n        const calculatedScrollTop = Math.max(\n          0,\n          Math.min(scrollTop, scrollHeight - clientHeight)\n        );\n\n        return {\n          isScrolling: true,\n          horizontalScrollDirection:\n            prevState.scrollLeft < scrollLeft ? 'forward' : 'backward',\n          scrollLeft: calculatedScrollLeft,\n          scrollTop: calculatedScrollTop,\n          verticalScrollDirection:\n            prevState.scrollTop < scrollTop ? 'forward' : 'backward',\n          scrollUpdateWasRequested: false,\n        };\n      }, this._resetIsScrollingDebounced);\n    };\n\n    _outerRefSetter = (ref: any): void => {\n      const { outerRef } = this.props;\n\n      this._outerRef = ((ref: any): HTMLDivElement);\n\n      if (typeof outerRef === 'function') {\n        outerRef(ref);\n      } else if (\n        outerRef != null &&\n        typeof outerRef === 'object' &&\n        outerRef.hasOwnProperty('current')\n      ) {\n        outerRef.current = ref;\n      }\n    };\n\n    _resetIsScrollingDebounced = () => {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n\n      this._resetIsScrollingTimeoutId = requestTimeout(\n        this._resetIsScrolling,\n        IS_SCROLLING_DEBOUNCE_INTERVAL\n      );\n    };\n\n    _resetIsScrolling = () => {\n      this._resetIsScrollingTimeoutId = null;\n\n      this.setState({ isScrolling: false }, () => {\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}\n\nconst validateSharedProps = (\n  {\n    children,\n    direction,\n    height,\n    innerTagName,\n    outerTagName,\n    overscanColumnsCount,\n    overscanCount,\n    overscanRowsCount,\n    width,\n  }: Props<any>,\n  { instance }: State\n): void => {\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(\n          'The overscanCount prop has been deprecated. ' +\n            'Please use the overscanColumnCount and overscanRowCount props instead.'\n        );\n      }\n    }\n\n    if (\n      typeof overscanColumnsCount === 'number' ||\n      typeof overscanRowsCount === 'number'\n    ) {\n      if (\n        devWarningsOverscanRowsColumnsCount &&\n        !devWarningsOverscanRowsColumnsCount.has(instance)\n      ) {\n        devWarningsOverscanRowsColumnsCount.add(instance);\n        console.warn(\n          'The overscanColumnsCount and overscanRowsCount props have been deprecated. ' +\n            'Please use the overscanColumnCount and overscanRowCount props instead.'\n        );\n      }\n    }\n\n    if (innerTagName != null || outerTagName != null) {\n      if (devWarningsTagName && !devWarningsTagName.has(instance)) {\n        devWarningsTagName.add(instance);\n        console.warn(\n          'The innerTagName and outerTagName props have been deprecated. ' +\n            'Please use the innerElementType and outerElementType props instead.'\n        );\n      }\n    }\n\n    if (children == null) {\n      throw Error(\n        'An invalid \"children\" prop has been specified. ' +\n          'Value should be a React component. ' +\n          `\"${children === null ? 'null' : typeof children}\" was specified.`\n      );\n    }\n\n    switch (direction) {\n      case 'ltr':\n      case 'rtl':\n        // Valid values\n        break;\n      default:\n        throw Error(\n          'An invalid \"direction\" prop has been specified. ' +\n            'Value should be either \"ltr\" or \"rtl\". ' +\n            `\"${direction}\" was specified.`\n        );\n    }\n\n    if (typeof width !== 'number') {\n      throw Error(\n        'An invalid \"width\" prop has been specified. ' +\n          'Grids must specify a number for width. ' +\n          `\"${width === null ? 'null' : typeof width}\" was specified.`\n      );\n    }\n\n    if (typeof height !== 'number') {\n      throw Error(\n        'An invalid \"height\" prop has been specified. ' +\n          'Grids must specify a number for height. ' +\n          `\"${height === null ? 'null' : typeof height}\" was specified.`\n      );\n    }\n  }\n};\n","// @flow\n\nimport memoizeOne from 'memoize-one';\nimport { createElement, PureComponent } from 'react';\nimport { cancelTimeout, requestTimeout } from './timer';\nimport { getRTLOffsetType } from './domHelpers';\n\nimport type { TimeoutID } from './timer';\n\nexport type ScrollToAlign = 'auto' | 'smart' | 'center' | 'start' | 'end';\n\ntype itemSize = number | ((index: number) => number);\n// TODO Deprecate directions \"horizontal\" and \"vertical\"\ntype Direction = 'ltr' | 'rtl' | 'horizontal' | 'vertical';\ntype Layout = 'horizontal' | 'vertical';\n\ntype RenderComponentProps<T> = {|\n  data: T,\n  index: number,\n  isScrolling?: boolean,\n  style: Object,\n|};\ntype RenderComponent<T> = React$ComponentType<$Shape<RenderComponentProps<T>>>;\n\ntype ScrollDirection = 'forward' | 'backward';\n\ntype onItemsRenderedCallback = ({\n  overscanStartIndex: number,\n  overscanStopIndex: number,\n  visibleStartIndex: number,\n  visibleStopIndex: number,\n}) => void;\ntype onScrollCallback = ({\n  scrollDirection: ScrollDirection,\n  scrollOffset: number,\n  scrollUpdateWasRequested: boolean,\n}) => void;\n\ntype ScrollEvent = SyntheticEvent<HTMLDivElement>;\ntype ItemStyleCache = { [index: number]: Object };\n\ntype OuterProps = {|\n  children: React$Node,\n  className: string | void,\n  onScroll: ScrollEvent => void,\n  style: {\n    [string]: mixed,\n  },\n|};\n\ntype InnerProps = {|\n  children: React$Node,\n  style: {\n    [string]: mixed,\n  },\n|};\n\nexport type Props<T> = {|\n  children: RenderComponent<T>,\n  className?: string,\n  direction: Direction,\n  height: number | string,\n  initialScrollOffset?: number,\n  innerRef?: any,\n  innerElementType?: string | React$AbstractComponent<InnerProps, any>,\n  innerTagName?: string, // deprecated\n  itemCount: number,\n  itemData: T,\n  itemKey?: (index: number, data: T) => any,\n  itemSize: itemSize,\n  layout: Layout,\n  onItemsRendered?: onItemsRenderedCallback,\n  onScroll?: onScrollCallback,\n  outerRef?: any,\n  outerElementType?: string | React$AbstractComponent<OuterProps, any>,\n  outerTagName?: string, // deprecated\n  overscanCount: number,\n  style?: Object,\n  useIsScrolling: boolean,\n  width: number | string,\n|};\n\ntype State = {|\n  instance: any,\n  isScrolling: boolean,\n  scrollDirection: ScrollDirection,\n  scrollOffset: number,\n  scrollUpdateWasRequested: boolean,\n|};\n\ntype GetItemOffset = (\n  props: Props<any>,\n  index: number,\n  instanceProps: any\n) => number;\ntype GetItemSize = (\n  props: Props<any>,\n  index: number,\n  instanceProps: any\n) => number;\ntype GetEstimatedTotalSize = (props: Props<any>, instanceProps: any) => number;\ntype GetOffsetForIndexAndAlignment = (\n  props: Props<any>,\n  index: number,\n  align: ScrollToAlign,\n  scrollOffset: number,\n  instanceProps: any\n) => number;\ntype GetStartIndexForOffset = (\n  props: Props<any>,\n  offset: number,\n  instanceProps: any\n) => number;\ntype GetStopIndexForStartIndex = (\n  props: Props<any>,\n  startIndex: number,\n  scrollOffset: number,\n  instanceProps: any\n) => number;\ntype InitInstanceProps = (props: Props<any>, instance: any) => any;\ntype ValidateProps = (props: Props<any>) => void;\n\nconst IS_SCROLLING_DEBOUNCE_INTERVAL = 150;\n\nconst defaultItemKey = (index: number, data: any) => index;\n\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.\nlet devWarningsDirection = null;\nlet devWarningsTagName = null;\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof window !== 'undefined' && typeof window.WeakSet !== 'undefined') {\n    devWarningsDirection = new WeakSet();\n    devWarningsTagName = new WeakSet();\n  }\n}\n\nexport default function createListComponent({\n  getItemOffset,\n  getEstimatedTotalSize,\n  getItemSize,\n  getOffsetForIndexAndAlignment,\n  getStartIndexForOffset,\n  getStopIndexForStartIndex,\n  initInstanceProps,\n  shouldResetStyleCacheOnItemSizeChange,\n  validateProps,\n}: {|\n  getItemOffset: GetItemOffset,\n  getEstimatedTotalSize: GetEstimatedTotalSize,\n  getItemSize: GetItemSize,\n  getOffsetForIndexAndAlignment: GetOffsetForIndexAndAlignment,\n  getStartIndexForOffset: GetStartIndexForOffset,\n  getStopIndexForStartIndex: GetStopIndexForStartIndex,\n  initInstanceProps: InitInstanceProps,\n  shouldResetStyleCacheOnItemSizeChange: boolean,\n  validateProps: ValidateProps,\n|}) {\n  return class List<T> extends PureComponent<Props<T>, State> {\n    _instanceProps: any = initInstanceProps(this.props, this);\n    _outerRef: ?HTMLDivElement;\n    _resetIsScrollingTimeoutId: TimeoutID | null = null;\n\n    static defaultProps = {\n      direction: 'ltr',\n      itemData: undefined,\n      layout: 'vertical',\n      overscanCount: 2,\n      useIsScrolling: false,\n    };\n\n    state: State = {\n      instance: this,\n      isScrolling: false,\n      scrollDirection: 'forward',\n      scrollOffset:\n        typeof this.props.initialScrollOffset === 'number'\n          ? this.props.initialScrollOffset\n          : 0,\n      scrollUpdateWasRequested: false,\n    };\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    constructor(props: Props<T>) {\n      super(props);\n    }\n\n    static getDerivedStateFromProps(\n      nextProps: Props<T>,\n      prevState: State\n    ): $Shape<State> | null {\n      validateSharedProps(nextProps, prevState);\n      validateProps(nextProps);\n      return null;\n    }\n\n    scrollTo(scrollOffset: number): void {\n      scrollOffset = Math.max(0, scrollOffset);\n\n      this.setState(prevState => {\n        if (prevState.scrollOffset === scrollOffset) {\n          return null;\n        }\n        return {\n          scrollDirection:\n            prevState.scrollOffset < scrollOffset ? 'forward' : 'backward',\n          scrollOffset: scrollOffset,\n          scrollUpdateWasRequested: true,\n        };\n      }, this._resetIsScrollingDebounced);\n    }\n\n    scrollToItem(index: number, align: ScrollToAlign = 'auto'): void {\n      const { itemCount } = this.props;\n      const { scrollOffset } = this.state;\n\n      index = Math.max(0, Math.min(index, itemCount - 1));\n\n      this.scrollTo(\n        getOffsetForIndexAndAlignment(\n          this.props,\n          index,\n          align,\n          scrollOffset,\n          this._instanceProps\n        )\n      );\n    }\n\n    componentDidMount() {\n      const { direction, initialScrollOffset, layout } = this.props;\n\n      if (typeof initialScrollOffset === 'number' && this._outerRef != null) {\n        const outerRef = ((this._outerRef: any): HTMLElement);\n        // TODO Deprecate direction \"horizontal\"\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    componentDidUpdate() {\n      const { direction, layout } = this.props;\n      const { scrollOffset, scrollUpdateWasRequested } = this.state;\n\n      if (scrollUpdateWasRequested && this._outerRef != null) {\n        const outerRef = ((this._outerRef: any): HTMLElement);\n\n        // TODO Deprecate direction \"horizontal\"\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              case 'positive-ascending':\n                outerRef.scrollLeft = scrollOffset;\n                break;\n              default:\n                const { clientWidth, scrollWidth } = outerRef;\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    componentWillUnmount() {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n    }\n\n    render() {\n      const {\n        children,\n        className,\n        direction,\n        height,\n        innerRef,\n        innerElementType,\n        innerTagName,\n        itemCount,\n        itemData,\n        itemKey = defaultItemKey,\n        layout,\n        outerElementType,\n        outerTagName,\n        style,\n        useIsScrolling,\n        width,\n      } = this.props;\n      const { isScrolling } = this.state;\n\n      // TODO Deprecate direction \"horizontal\"\n      const isHorizontal =\n        direction === 'horizontal' || layout === 'horizontal';\n\n      const onScroll = isHorizontal\n        ? this._onScrollHorizontal\n        : this._onScrollVertical;\n\n      const [startIndex, stopIndex] = this._getRangeToRender();\n\n      const items = [];\n      if (itemCount > 0) {\n        for (let index = startIndex; index <= stopIndex; index++) {\n          items.push(\n            createElement(children, {\n              data: itemData,\n              key: itemKey(index, itemData),\n              index,\n              isScrolling: useIsScrolling ? isScrolling : undefined,\n              style: this._getItemStyle(index),\n            })\n          );\n        }\n      }\n\n      // Read this value AFTER items have been created,\n      // So their actual sizes (if variable) are taken into consideration.\n      const estimatedTotalSize = getEstimatedTotalSize(\n        this.props,\n        this._instanceProps\n      );\n\n      return createElement(\n        outerElementType || outerTagName || 'div',\n        {\n          className,\n          onScroll,\n          ref: this._outerRefSetter,\n          style: {\n            position: 'relative',\n            height,\n            width,\n            overflow: 'auto',\n            WebkitOverflowScrolling: 'touch',\n            willChange: 'transform',\n            direction,\n            ...style,\n          },\n        },\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\n    _callOnItemsRendered: (\n      overscanStartIndex: number,\n      overscanStopIndex: number,\n      visibleStartIndex: number,\n      visibleStopIndex: number\n    ) => void;\n    _callOnItemsRendered = memoizeOne(\n      (\n        overscanStartIndex: number,\n        overscanStopIndex: number,\n        visibleStartIndex: number,\n        visibleStopIndex: number\n      ) =>\n        ((this.props.onItemsRendered: any): onItemsRenderedCallback)({\n          overscanStartIndex,\n          overscanStopIndex,\n          visibleStartIndex,\n          visibleStopIndex,\n        })\n    );\n\n    _callOnScroll: (\n      scrollDirection: ScrollDirection,\n      scrollOffset: number,\n      scrollUpdateWasRequested: boolean\n    ) => void;\n    _callOnScroll = memoizeOne(\n      (\n        scrollDirection: ScrollDirection,\n        scrollOffset: number,\n        scrollUpdateWasRequested: boolean\n      ) =>\n        ((this.props.onScroll: any): onScrollCallback)({\n          scrollDirection,\n          scrollOffset,\n          scrollUpdateWasRequested,\n        })\n    );\n\n    _callPropsCallbacks() {\n      if (typeof this.props.onItemsRendered === 'function') {\n        const { itemCount } = this.props;\n        if (itemCount > 0) {\n          const [\n            overscanStartIndex,\n            overscanStopIndex,\n            visibleStartIndex,\n            visibleStopIndex,\n          ] = this._getRangeToRender();\n          this._callOnItemsRendered(\n            overscanStartIndex,\n            overscanStopIndex,\n            visibleStartIndex,\n            visibleStopIndex\n          );\n        }\n      }\n\n      if (typeof this.props.onScroll === 'function') {\n        const {\n          scrollDirection,\n          scrollOffset,\n          scrollUpdateWasRequested,\n        } = this.state;\n        this._callOnScroll(\n          scrollDirection,\n          scrollOffset,\n          scrollUpdateWasRequested\n        );\n      }\n    }\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    _getItemStyle: (index: number) => Object;\n    _getItemStyle = (index: number): Object => {\n      const { direction, itemSize, layout } = this.props;\n\n      const itemStyleCache = this._getItemStyleCache(\n        shouldResetStyleCacheOnItemSizeChange && itemSize,\n        shouldResetStyleCacheOnItemSizeChange && layout,\n        shouldResetStyleCacheOnItemSizeChange && direction\n      );\n\n      let style;\n      if (itemStyleCache.hasOwnProperty(index)) {\n        style = itemStyleCache[index];\n      } else {\n        const offset = getItemOffset(this.props, index, this._instanceProps);\n        const size = getItemSize(this.props, index, this._instanceProps);\n\n        // TODO Deprecate direction \"horizontal\"\n        const isHorizontal =\n          direction === 'horizontal' || layout === 'horizontal';\n\n        const isRtl = direction === 'rtl';\n        const offsetHorizontal = isHorizontal ? offset : 0;\n        itemStyleCache[index] = style = {\n          position: 'absolute',\n          left: isRtl ? undefined : offsetHorizontal,\n          right: isRtl ? offsetHorizontal : undefined,\n          top: !isHorizontal ? offset : 0,\n          height: !isHorizontal ? size : '100%',\n          width: isHorizontal ? size : '100%',\n        };\n      }\n\n      return style;\n    };\n\n    _getItemStyleCache: (_: any, __: any, ___: any) => ItemStyleCache;\n    _getItemStyleCache = memoizeOne((_: any, __: any, ___: any) => ({}));\n\n    _getRangeToRender(): [number, number, number, number] {\n      const { itemCount, overscanCount } = this.props;\n      const { isScrolling, scrollDirection, scrollOffset } = this.state;\n\n      if (itemCount === 0) {\n        return [0, 0, 0, 0];\n      }\n\n      const startIndex = getStartIndexForOffset(\n        this.props,\n        scrollOffset,\n        this._instanceProps\n      );\n      const stopIndex = getStopIndexForStartIndex(\n        this.props,\n        startIndex,\n        scrollOffset,\n        this._instanceProps\n      );\n\n      // 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      const overscanBackward =\n        !isScrolling || scrollDirection === 'backward'\n          ? Math.max(1, overscanCount)\n          : 1;\n      const overscanForward =\n        !isScrolling || scrollDirection === 'forward'\n          ? Math.max(1, overscanCount)\n          : 1;\n\n      return [\n        Math.max(0, startIndex - overscanBackward),\n        Math.max(0, Math.min(itemCount - 1, stopIndex + overscanForward)),\n        startIndex,\n        stopIndex,\n      ];\n    }\n\n    _onScrollHorizontal = (event: ScrollEvent): void => {\n      const { clientWidth, scrollLeft, scrollWidth } = event.currentTarget;\n      this.setState(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        const { direction } = this.props;\n\n        let scrollOffset = scrollLeft;\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            case 'positive-descending':\n              scrollOffset = scrollWidth - clientWidth - scrollLeft;\n              break;\n          }\n        }\n\n        // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n        scrollOffset = Math.max(\n          0,\n          Math.min(scrollOffset, scrollWidth - clientWidth)\n        );\n\n        return {\n          isScrolling: true,\n          scrollDirection:\n            prevState.scrollOffset < scrollLeft ? 'forward' : 'backward',\n          scrollOffset,\n          scrollUpdateWasRequested: false,\n        };\n      }, this._resetIsScrollingDebounced);\n    };\n\n    _onScrollVertical = (event: ScrollEvent): void => {\n      const { clientHeight, scrollHeight, scrollTop } = event.currentTarget;\n      this.setState(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        }\n\n        // Prevent Safari's elastic scrolling from causing visual shaking when scrolling past bounds.\n        const scrollOffset = Math.max(\n          0,\n          Math.min(scrollTop, scrollHeight - clientHeight)\n        );\n\n        return {\n          isScrolling: true,\n          scrollDirection:\n            prevState.scrollOffset < scrollOffset ? 'forward' : 'backward',\n          scrollOffset,\n          scrollUpdateWasRequested: false,\n        };\n      }, this._resetIsScrollingDebounced);\n    };\n\n    _outerRefSetter = (ref: any): void => {\n      const { outerRef } = this.props;\n\n      this._outerRef = ((ref: any): HTMLDivElement);\n\n      if (typeof outerRef === 'function') {\n        outerRef(ref);\n      } else if (\n        outerRef != null &&\n        typeof outerRef === 'object' &&\n        outerRef.hasOwnProperty('current')\n      ) {\n        outerRef.current = ref;\n      }\n    };\n\n    _resetIsScrollingDebounced = () => {\n      if (this._resetIsScrollingTimeoutId !== null) {\n        cancelTimeout(this._resetIsScrollingTimeoutId);\n      }\n\n      this._resetIsScrollingTimeoutId = requestTimeout(\n        this._resetIsScrolling,\n        IS_SCROLLING_DEBOUNCE_INTERVAL\n      );\n    };\n\n    _resetIsScrolling = () => {\n      this._resetIsScrollingTimeoutId = null;\n\n      this.setState({ isScrolling: false }, () => {\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}\n\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\nconst validateSharedProps = (\n  {\n    children,\n    direction,\n    height,\n    layout,\n    innerTagName,\n    outerTagName,\n    width,\n  }: Props<any>,\n  { instance }: State\n): void => {\n  if (process.env.NODE_ENV !== 'production') {\n    if (innerTagName != null || outerTagName != null) {\n      if (devWarningsTagName && !devWarningsTagName.has(instance)) {\n        devWarningsTagName.add(instance);\n        console.warn(\n          'The innerTagName and outerTagName props have been deprecated. ' +\n            'Please use the innerElementType and outerElementType props instead.'\n        );\n      }\n    }\n\n    // TODO Deprecate direction \"horizontal\"\n    const 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(\n            'The direction prop should be either \"ltr\" (default) or \"rtl\". ' +\n              'Please use the layout prop to specify \"vertical\" (default) or \"horizontal\" orientation.'\n          );\n        }\n        break;\n      case 'ltr':\n      case 'rtl':\n        // Valid values\n        break;\n      default:\n        throw Error(\n          'An invalid \"direction\" prop has been specified. ' +\n            'Value should be either \"ltr\" or \"rtl\". ' +\n            `\"${direction}\" was specified.`\n        );\n    }\n\n    switch (layout) {\n      case 'horizontal':\n      case 'vertical':\n        // Valid values\n        break;\n      default:\n        throw Error(\n          'An invalid \"layout\" prop has been specified. ' +\n            'Value should be either \"horizontal\" or \"vertical\". ' +\n            `\"${layout}\" was specified.`\n        );\n    }\n\n    if (children == null) {\n      throw Error(\n        'An invalid \"children\" prop has been specified. ' +\n          'Value should be a React component. ' +\n          `\"${children === null ? 'null' : typeof children}\" was specified.`\n      );\n    }\n\n    if (isHorizontal && typeof width !== 'number') {\n      throw Error(\n        'An invalid \"width\" prop has been specified. ' +\n          'Horizontal lists must specify a number for width. ' +\n          `\"${width === null ? 'null' : typeof width}\" was specified.`\n      );\n    } else if (!isHorizontal && typeof height !== 'number') {\n      throw Error(\n        'An invalid \"height\" prop has been specified. ' +\n          'Vertical lists must specify a number for height. ' +\n          `\"${height === null ? 'null' : typeof height}\" was specified.`\n      );\n    }\n  }\n};\n","// @flow\n\nimport createListComponent from './createListComponent';\n\nimport type { Props, ScrollToAlign } from './createListComponent';\n\nconst DEFAULT_ESTIMATED_ITEM_SIZE = 50;\n\ntype VariableSizeProps = {|\n  estimatedItemSize: number,\n  ...Props<any>,\n|};\n\ntype itemSizeGetter = (index: number) => number;\n\ntype ItemMetadata = {|\n  offset: number,\n  size: number,\n|};\ntype InstanceProps = {|\n  itemMetadataMap: { [index: number]: ItemMetadata },\n  estimatedItemSize: number,\n  lastMeasuredIndex: number,\n|};\n\nconst getItemMetadata = (\n  props: Props<any>,\n  index: number,\n  instanceProps: InstanceProps\n): ItemMetadata => {\n  const { itemSize } = ((props: any): VariableSizeProps);\n  const { itemMetadataMap, lastMeasuredIndex } = instanceProps;\n\n  if (index > lastMeasuredIndex) {\n    let offset = 0;\n    if (lastMeasuredIndex >= 0) {\n      const itemMetadata = itemMetadataMap[lastMeasuredIndex];\n      offset = itemMetadata.offset + itemMetadata.size;\n    }\n\n    for (let i = lastMeasuredIndex + 1; i <= index; i++) {\n      let size = ((itemSize: any): itemSizeGetter)(i);\n\n      itemMetadataMap[i] = {\n        offset,\n        size,\n      };\n\n      offset += size;\n    }\n\n    instanceProps.lastMeasuredIndex = index;\n  }\n\n  return itemMetadataMap[index];\n};\n\nconst findNearestItem = (\n  props: Props<any>,\n  instanceProps: InstanceProps,\n  offset: number\n) => {\n  const { itemMetadataMap, lastMeasuredIndex } = instanceProps;\n\n  const lastMeasuredItemOffset =\n    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(\n      props,\n      instanceProps,\n      lastMeasuredIndex,\n      0,\n      offset\n    );\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(\n      props,\n      instanceProps,\n      Math.max(0, lastMeasuredIndex),\n      offset\n    );\n  }\n};\n\nconst findNearestItemBinarySearch = (\n  props: Props<any>,\n  instanceProps: InstanceProps,\n  high: number,\n  low: number,\n  offset: number\n): number => {\n  while (low <= high) {\n    const middle = low + Math.floor((high - low) / 2);\n    const currentOffset = getItemMetadata(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\nconst findNearestItemExponentialSearch = (\n  props: Props<any>,\n  instanceProps: InstanceProps,\n  index: number,\n  offset: number\n): number => {\n  const { itemCount } = props;\n  let interval = 1;\n\n  while (\n    index < itemCount &&\n    getItemMetadata(props, index, instanceProps).offset < offset\n  ) {\n    index += interval;\n    interval *= 2;\n  }\n\n  return findNearestItemBinarySearch(\n    props,\n    instanceProps,\n    Math.min(index, itemCount - 1),\n    Math.floor(index / 2),\n    offset\n  );\n};\n\nconst getEstimatedTotalSize = (\n  { itemCount }: Props<any>,\n  { itemMetadataMap, estimatedItemSize, lastMeasuredIndex }: InstanceProps\n) => {\n  let totalSizeOfMeasuredItems = 0;\n\n  // 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  if (lastMeasuredIndex >= itemCount) {\n    lastMeasuredIndex = itemCount - 1;\n  }\n\n  if (lastMeasuredIndex >= 0) {\n    const itemMetadata = itemMetadataMap[lastMeasuredIndex];\n    totalSizeOfMeasuredItems = itemMetadata.offset + itemMetadata.size;\n  }\n\n  const numUnmeasuredItems = itemCount - lastMeasuredIndex - 1;\n  const totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;\n\n  return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;\n};\n\nconst VariableSizeList = createListComponent({\n  getItemOffset: (\n    props: Props<any>,\n    index: number,\n    instanceProps: InstanceProps\n  ): number => getItemMetadata(props, index, instanceProps).offset,\n\n  getItemSize: (\n    props: Props<any>,\n    index: number,\n    instanceProps: InstanceProps\n  ): number => instanceProps.itemMetadataMap[index].size,\n\n  getEstimatedTotalSize,\n\n  getOffsetForIndexAndAlignment: (\n    props: Props<any>,\n    index: number,\n    align: ScrollToAlign,\n    scrollOffset: number,\n    instanceProps: InstanceProps\n  ): number => {\n    const { direction, height, layout, width } = props;\n\n    // TODO Deprecate direction \"horizontal\"\n    const isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    const size = (((isHorizontal ? width : height): any): number);\n    const itemMetadata = getItemMetadata(props, index, instanceProps);\n\n    // Get estimated total size after ItemMetadata is computed,\n    // To ensure it reflects actual measurements instead of just estimates.\n    const estimatedTotalSize = getEstimatedTotalSize(props, instanceProps);\n\n    const maxOffset = Math.max(\n      0,\n      Math.min(estimatedTotalSize - size, itemMetadata.offset)\n    );\n    const minOffset = Math.max(\n      0,\n      itemMetadata.offset - size + itemMetadata.size\n    );\n\n    if (align === 'smart') {\n      if (\n        scrollOffset >= minOffset - size &&\n        scrollOffset <= maxOffset + size\n      ) {\n        align = 'auto';\n      } else {\n        align = 'center';\n      }\n    }\n\n    switch (align) {\n      case 'start':\n        return maxOffset;\n      case 'end':\n        return minOffset;\n      case 'center':\n        return Math.round(minOffset + (maxOffset - minOffset) / 2);\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: (\n    props: Props<any>,\n    offset: number,\n    instanceProps: InstanceProps\n  ): number => findNearestItem(props, instanceProps, offset),\n\n  getStopIndexForStartIndex: (\n    props: Props<any>,\n    startIndex: number,\n    scrollOffset: number,\n    instanceProps: InstanceProps\n  ): number => {\n    const { direction, height, itemCount, layout, width } = props;\n\n    // TODO Deprecate direction \"horizontal\"\n    const isHorizontal = direction === 'horizontal' || layout === 'horizontal';\n    const size = (((isHorizontal ? width : height): any): number);\n    const itemMetadata = getItemMetadata(props, startIndex, instanceProps);\n    const maxOffset = scrollOffset + size;\n\n    let offset = itemMetadata.offset + itemMetadata.size;\n    let stopIndex = startIndex;\n\n    while (stopIndex < itemCount - 1 && offset < maxOffset) {\n      stopIndex++;\n      offset += getItemMetadata(props, stopIndex, instanceProps).size;\n    }\n\n    return stopIndex;\n  },\n\n  initInstanceProps(props: Props<any>, instance: any): InstanceProps {\n    const { estimatedItemSize } = ((props: any): VariableSizeProps);\n\n    const instanceProps = {\n      itemMetadataMap: {},\n      estimatedItemSize: estimatedItemSize || DEFAULT_ESTIMATED_ITEM_SIZE,\n      lastMeasuredIndex: -1,\n    };\n\n    instance.resetAfterIndex = (\n      index: number,\n      shouldForceUpdate?: boolean = true\n    ) => {\n      instanceProps.lastMeasuredIndex = Math.min(\n        instanceProps.lastMeasuredIndex,\n        index - 1\n      );\n\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      instance._getItemStyleCache(-1);\n\n      if (shouldForceUpdate) {\n        instance.forceUpdate();\n      }\n    };\n\n    return instanceProps;\n  },\n\n  shouldResetStyleCacheOnItemSizeChange: false,\n\n  validateProps: ({ itemSize }: Props<any>): void => {\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof itemSize !== 'function') {\n        throw Error(\n          'An invalid \"itemSize\" prop has been specified. ' +\n            'Value should be a function. ' +\n            `\"${itemSize === null ? 'null' : typeof itemSize}\" was specified.`\n        );\n      }\n    }\n  },\n});\n\nexport default VariableSizeList;\n","/** @license React v17.0.2\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.2\";\n","/** @license React v17.0.2\n * react-jsx-runtime.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';require(\"object-assign\");var f=require(\"react\"),g=60103;exports.Fragment=60107;if(\"function\"===typeof Symbol&&Symbol.for){var h=Symbol.for;g=h(\"react.element\");exports.Fragment=h(\"react.fragment\")}var m=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,n=Object.prototype.hasOwnProperty,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,k){var b,d={},e=null,l=null;void 0!==k&&(e=\"\"+k);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(l=a.ref);for(b in a)n.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:g,type:c,key:e,ref:l,props:d,_owner:m.current}}exports.jsx=q;exports.jsxs=q;\n"],"sourceRoot":""}