{"version":3,"sources":["../node_modules/react/cjs/react-jsx-runtime.production.min.js","../../src/timer.js","../../src/domHelpers.js","../../src/createGridComponent.js","../../src/createListComponent.js","../../src/VariableSizeList.js","../node_modules/react/cjs/react.production.min.js"],"names":["require","f","g","exports","Fragment","Symbol","for","h","m","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentOwner","n","Object","prototype","hasOwnProperty","p","key","ref","__self","__source","q","c","a","k","b","d","e","l","call","defaultProps","$$typeof","type","props","_owner","current","jsx","jsxs","now","performance","Date","cancelTimeout","timeoutID","cancelAnimationFrame","id","requestTimeout","callback","delay","start","requestAnimationFrame","tick","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","_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","_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","outerRef","_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","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","_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","StrictMode","Profiler","r","t","Suspense","u","v","w","x","iterator","z","arguments","length","encodeURIComponent","A","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","B","C","context","refs","updater","D","E","isReactComponent","Error","F","constructor","isPureReactComponent","G","H","I","J","Array","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","IsSomeRendererActing","assign","Children","map","forEach","apply","count","toArray","only","Component","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"],"mappings":"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","file":"static/js/main~f734b0c6.9d831cec.chunk.js","sourcesContent":["/** @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","// @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"],"sourceRoot":""}