decord/source/314__isNativeReflectConstruct.js

// Module ID: 314
// Function ID: 315
// Name: _isNativeReflectConstruct
// Dependencies: [109, 41, 42, 93, 95, 98, 19, 17, 21, 315, 316, 38, 27, 317, 318, 319, 320, 313, 321, 322, 323, 70, 324, 325]

// Module 314 (_isNativeReflectConstruct)
import _objectWithoutProperties from "_objectWithoutProperties";
import _classCallCheck from "_classCallCheck";
import _possibleConstructorReturn from "_possibleConstructorReturn";
import _getPrototypeOf from "_getPrototypeOf";
import importDefaultResult from "_createClass";
import createContext from "createContext";
import noop from "createContext";
import get_ActivityIndicator from "elementsThatOverlapOffsets";
import jsxProd from "nullthrows";

let Platform;
let StyleSheet;
let c10;
let closure_12;
let closure_14;
let closure_16;
let closure_17;
let closure_18;
let closure_19;
let map1;
let unpackModuleId;
let VirtualizedList = arg1;
function _isNativeReflectConstruct() {
  try {
    const _Boolean = Boolean;
    const call = valueOf.call;
    const _Reflect = Reflect;
    const _Boolean2 = Boolean;
    if (typeof call === "unknown") {
      let callResult = valueOf();
    } else {
      callResult = call(constructResult);
    }
    let closure_0 = !callResult;
    function _isNativeReflectConstruct() {
      return closure_0;
    }
    return _isNativeReflectConstruct();
  } catch (err) {
  }
}
let closure_4 = ["onContentSizeChange"];
({ cloneElement: c10, isValidElement: unpackModuleId } = noop);
({ I18nManager: closure_12, Platform, RefreshControl: map1, ScrollView: closure_14, StyleSheet } = get_ActivityIndicator);
({ View: closure_16, findNodeHandle: closure_17 } = get_ActivityIndicator);
({ jsx: closure_18, jsxs: closure_19 } = jsxProd);
let c21 = false;
let c22 = "";
class VirtualizedList {
  constructor(arg0) {
    self = this;
    obj = apply;
    tmp = _isNativeReflectConstruct(this, apply);
    items = [];
    items[0] = global;
    tmp2 = _isNativeReflectConstruct;
    obj2 = _isNativeReflectConstruct(apply);
    tmp3 = _isNativeReflectConstruct;
    if (_isNativeReflectConstruct()) {
      tmp5 = globalThis;
      _Reflect = Reflect;
      constructResult = Reflect.construct(obj2, items, tmp2(self).constructor);
    } else {
      constructResult = obj2.apply(self, items);
    }
    tmp3Result = tmp3(self, constructResult);
    apply = tmp3Result;
    tmp3Result._getScrollMetrics = () => tmp3Result._scrollMetrics;
    tmp3Result._getOutermostParentListRef = () => {
      let outermostParentListRef = tmp3Result;
      if (tmp3Result._isNestedWithSameOrientation()) {
        const context = tmp3Result.context;
        outermostParentListRef = context.getOutermostParentListRef();
      }
      return outermostParentListRef;
    };
    tmp3Result._registerAsNestedChild = (ref) => {
      const _nestedChildLists = tmp3Result._nestedChildLists;
      _nestedChildLists.add(ref.ref, ref.cellKey);
      if (tmp3Result._hasInteracted) {
        ref.ref.recordInteraction();
        ref = ref.ref;
      }
    };
    tmp3Result._unregisterAsNestedChild = (ref) => {
      const _nestedChildLists = tmp3Result._nestedChildLists;
      _nestedChildLists.remove(ref.ref);
    };
    tmp3Result._onUpdateSeparators = (arr) => {
      let closure_0 = arg1;
      const item = arr.forEach((arg0) => {
        let obj = null != arg0;
        if (obj) {
          obj = _cellRefs._cellRefs[arg0];
        }
        if (obj) {
          obj.updateSeparatorProps(_cellRefs);
        }
      });
    };
    tmp3Result._getSpacerKey = (arg0) => {
      let str = "width";
      if (arg0) {
        str = "height";
      }
      return str;
    };
    tmp3Result._cellRefs = {};
    tmp6 = closure_1;
    tmp7 = closure_3;
    tmp8 = new require("ListMetricsAggregator")();
    tmp3Result._listMetrics = tmp8;
    tmp3Result._footerLength = 0;
    tmp3Result._hasTriggeredInitialScrollToIndex = false;
    tmp3Result._hasInteracted = false;
    tmp3Result._hasMore = false;
    tmp3Result._hasWarned = {};
    tmp3Result._headerLength = 0;
    tmp3Result._hiPriInProgress = false;
    map = new Map();
    tmp3Result._indicesToKeys = map;
    tmp3Result._lastFocusedCellKey = null;
    tmp10 = new require("ChildListCollection")();
    tmp3Result._nestedChildLists = tmp10;
    tmp3Result._offsetFromParentVirtualizedList = 0;
    tmp3Result._pendingViewabilityUpdate = false;
    tmp3Result._prevParentOffset = 0;
    tmp3Result._scrollMetrics = { dOffset: 0, dt: 10, offset: 0, timestamp: 0, velocity: 0, visibleLength: 0, zoomScale: 1 };
    tmp3Result._scrollRef = null;
    tmp3Result._sentStartForContentLength = 0;
    tmp3Result._sentEndForContentLength = 0;
    tmp3Result._updateCellsToRenderTimeoutID = null;
    tmp3Result._viewabilityTuples = [];
    tmp3Result._captureScrollRef = (_scrollRef) => {
      closure_0._scrollRef = _scrollRef;
    };
    tmp3Result._defaultRenderScrollComponent = (onRefresh) => {
      let progressViewOffset = onRefresh.onRefresh;
      if (tmp3Result._isNestedWithSameOrientation()) {
        const onContentSizeChange = onRefresh.onContentSizeChange;
        let obj = {};
        const merged = Object.assign(callback2(onRefresh, closure_4));
        return outer2_18(outer2_16, obj);
      } else if (progressViewOffset) {
        let str = onRefresh.refreshing;
        if (str == null) {
          str = "undefined";
        }
        importDefault(38)(typeof onRefresh.refreshing === "boolean", `\`refreshing\` prop must be set as a boolean in order to use \`onRefresh\`, but got \`${tmp11(str)}\``);
        obj = {};
        const merged1 = Object.assign(onRefresh);
        if (null == onRefresh.refreshControl) {
          const obj1 = { refreshing: null, onRefresh: null, progressViewOffset: null };
          obj1[0] = onRefresh.refreshing;
          obj1[1] = progressViewOffset;
          progressViewOffset = onRefresh.progressViewOffset;
          obj1[2] = progressViewOffset;
          let refreshControl = outer2_18(outer2_13, obj1);
        } else {
          refreshControl = onRefresh.refreshControl;
        }
        obj.refreshControl = refreshControl;
        outer2_18(outer2_14, obj);
        const tmp13 = typeof onRefresh.refreshing === "boolean";
        const tmp15 = outer2_18;
        const tmp16 = outer2_14;
        const tmp8 = importDefault(38);
      } else {
        obj = {};
        const merged2 = Object.assign(onRefresh);
        return outer2_18(outer2_14, obj);
      }
    };
    tmp3Result._onCellLayout = (layout, cellKey, cellIndex) => {
      let obj = tmp3Result;
      const _listMetrics = tmp3Result._listMetrics;
      obj = { cellIndex, cellKey, layout: layout.nativeEvent.layout, orientation: tmp3Result._orientation() };
      if (_listMetrics.notifyCellLayout(obj)) {
        const result = obj._scheduleCellsToRenderUpdate();
      }
      const result1 = obj._triggerRemeasureForChildListsInCell(cellKey);
      obj._computeBlankness();
      obj._updateViewableItems(obj.props, obj.state.cellsAroundViewport);
    };
    tmp3Result._onCellFocusCapture = (_lastFocusedCellKey) => {
      closure_0._lastFocusedCellKey = _lastFocusedCellKey;
      if (obj2.deferFlatListFocusChangeRenderUpdate()) {
        const result = obj._scheduleCellsToRenderUpdate();
      } else {
        obj._updateCellsToRender();
      }
    };
    tmp3Result._onCellUnmount = (arg0) => {
      delete tmp[tmp2];
      const _listMetrics = tmp3Result._listMetrics;
      _listMetrics.notifyCellUnmounted(arg0);
    };
    tmp3Result._onLayout = (nativeEvent) => {
      if (tmp3Result._isNestedWithSameOrientation()) {
        const result = obj.measureLayoutRelativeToContainingList();
      } else {
        obj._scrollMetrics.visibleLength = obj._selectLength(nativeEvent.nativeEvent.layout);
      }
      if (tmp3Result.props.onLayout) {
        const props = obj.props;
        props.onLayout(nativeEvent);
      }
      const result1 = obj._scheduleCellsToRenderUpdate();
      const result2 = obj._maybeCallOnEdgeReached();
    };
    tmp3Result._onLayoutEmpty = (arg0) => {
      if (tmp3Result.props.onLayout) {
        const props = tmp.props;
        props.onLayout(arg0);
      }
    };
    tmp3Result._onLayoutFooter = (nativeEvent) => {
      const result = tmp3Result._triggerRemeasureForChildListsInCell(tmp3Result._getFooterCellKey());
      tmp3Result._footerLength = tmp3Result._selectLength(nativeEvent.nativeEvent.layout);
    };
    tmp3Result._onLayoutHeader = (nativeEvent) => {
      tmp3Result._headerLength = tmp3Result._selectLength(nativeEvent.nativeEvent.layout);
    };
    tmp3Result._onContentSizeChange = (width, height) => {
      let obj = tmp3Result;
      const _listMetrics = tmp3Result._listMetrics;
      obj = { layout: obj, orientation: tmp3Result._orientation() };
      obj = { width, height };
      const result = _listMetrics.notifyListContentLayout(obj);
      const result1 = tmp3Result._maybeScrollToInitialScrollIndex(width, height);
      if (tmp3Result.props.onContentSizeChange) {
        const props = obj.props;
        props.onContentSizeChange(width, height);
      }
      const result2 = obj._scheduleCellsToRenderUpdate();
      const result3 = obj._maybeCallOnEdgeReached();
    };
    tmp3Result._convertParentScrollMetrics = (offset) => {
      const diff = offset.offset - tmp3Result._offsetFromParentVirtualizedList;
      const _listMetrics = tmp3Result._listMetrics;
      const diff1 = diff - tmp3Result._scrollMetrics.offset;
      return { visibleLength: offset.visibleLength, contentLength: _listMetrics.getContentLength(), offset: diff, dOffset: diff1 };
    };
    tmp3Result._onScroll = (timeStamp) => {
      let contentLength;
      let dOffset;
      let offset;
      let visibleLength;
      let obj = tmp3Result;
      const _nestedChildLists = tmp3Result._nestedChildLists;
      const item = _nestedChildLists.forEach((_onScroll) => {
        _onScroll._onScroll(closure_0);
      });
      if (timeStamp.props.onScroll) {
        const props = obj.props;
        props.onScroll(timeStamp);
      }
      timeStamp = timeStamp.timeStamp;
      const _selectLengthResult = obj._selectLength(timeStamp.nativeEvent.layoutMeasurement);
      contentLength = obj._selectLength(timeStamp.nativeEvent.contentSize);
      const result = obj._offsetFromScrollEvent(timeStamp);
      dOffset = result - obj._scrollMetrics.offset;
      offset = result;
      visibleLength = _selectLengthResult;
      if (obj._isNestedWithSameOrientation()) {
        const _listMetrics = obj._listMetrics;
        if (0 !== _listMetrics.getContentLength()) {
          obj = { visibleLength: null, offset: null };
          obj[0] = _selectLengthResult;
          obj[1] = result;
          const result1 = obj._convertParentScrollMetrics(obj);
          ({ visibleLength, contentLength, offset, dOffset } = result1);
        }
      }
      let num2 = 1;
      if (obj._scrollMetrics.timestamp) {
        const _Math = Math;
        num2 = Math.max(1, timeStamp - obj._scrollMetrics.timestamp);
      }
      const result2 = dOffset / num2;
      let tmp7 = num2 > 500 && obj._scrollMetrics.dt > 500;
      if (tmp7) {
        tmp7 = contentLength > 5 * visibleLength;
      }
      if (tmp7) {
        tmp7 = !obj._hasWarned.perf;
      }
      if (tmp7) {
        obj = { dt: null, prevDt: null, contentLength: null };
        obj[0] = num2;
        obj[1] = obj._scrollMetrics.dt;
        obj[2] = contentLength;
        importDefault(317)("VirtualizedList: You have a large list that is slow to update - make sure your renderItem function renders components that follow React performance best practices like PureComponent, shouldComponentUpdate, etc.", obj);
        obj._hasWarned.perf = true;
      }
      let num4 = 1;
      if (timeStamp.nativeEvent.zoomScale >= 0) {
        num4 = timeStamp.nativeEvent.zoomScale;
      }
      obj._scrollMetrics = { dt: num2, dOffset, offset, timestamp: timeStamp, velocity: result2, visibleLength, zoomScale: num4 };
      if (obj.state.pendingScrollUpdateCount > 0) {
        obj.setState((pendingScrollUpdateCount) => ({ pendingScrollUpdateCount: pendingScrollUpdateCount.pendingScrollUpdateCount - 1 }));
      }
      obj._updateViewableItems(obj.props, obj.state.cellsAroundViewport);
      if (obj.props) {
        const result3 = obj._maybeCallOnEdgeReached();
        if (0 !== result2) {
          const _fillRateHelper = obj._fillRateHelper;
          _fillRateHelper.activate();
        }
        obj._computeBlankness();
        const result4 = obj._scheduleCellsToRenderUpdate();
      }
    };
    tmp3Result._onScrollBeginDrag = (arg0) => {
      const _nestedChildLists = tmp3Result._nestedChildLists;
      const item = _nestedChildLists.forEach((_onScrollBeginDrag) => {
        _onScrollBeginDrag._onScrollBeginDrag(closure_0);
      });
      const _viewabilityTuples = tmp3Result._viewabilityTuples;
      const item1 = _viewabilityTuples.forEach((viewabilityHelper) => {
        viewabilityHelper = viewabilityHelper.viewabilityHelper;
        viewabilityHelper.recordInteraction();
      });
      arg0._hasInteracted = true;
      if (arg0.props.onScrollBeginDrag) {
        const props = arg0.props;
        props.onScrollBeginDrag(arg0);
      }
    };
    tmp3Result._onScrollEndDrag = (nativeEvent) => {
      const _nestedChildLists = tmp3Result._nestedChildLists;
      const item = _nestedChildLists.forEach((_onScrollEndDrag) => {
        _onScrollEndDrag._onScrollEndDrag(closure_0);
      });
      const velocity = nativeEvent.nativeEvent.velocity;
      if (velocity) {
        obj._scrollMetrics.velocity = obj._selectOffset(velocity);
      }
      nativeEvent._computeBlankness();
      if (nativeEvent.props.onScrollEndDrag) {
        const props = obj.props;
        props.onScrollEndDrag(nativeEvent);
      }
    };
    tmp3Result._onMomentumScrollBegin = (arg0) => {
      const _nestedChildLists = tmp3Result._nestedChildLists;
      const item = _nestedChildLists.forEach((_onMomentumScrollBegin) => {
        const result = _onMomentumScrollBegin._onMomentumScrollBegin(closure_0);
      });
      if (arg0.props.onMomentumScrollBegin) {
        const props = arg0.props;
        let result = props.onMomentumScrollBegin(arg0);
      }
    };
    tmp3Result._onMomentumScrollEnd = (arg0) => {
      const _nestedChildLists = tmp3Result._nestedChildLists;
      const item = _nestedChildLists.forEach((_onMomentumScrollEnd) => {
        _onMomentumScrollEnd._onMomentumScrollEnd(closure_0);
      });
      arg0._scrollMetrics.velocity = 0;
      arg0._computeBlankness();
      if (arg0.props.onMomentumScrollEnd) {
        const props = arg0.props;
        props.onMomentumScrollEnd(arg0);
      }
    };
    tmp3Result._updateCellsToRender = () => {
      tmp3Result._updateViewableItems(tmp3Result.props, tmp3Result.state.cellsAroundViewport);
      tmp3Result.setState((cellsAroundViewport, getItemCount) => {
        const result = closure_0._adjustCellsAroundViewport(getItemCount, cellsAroundViewport.cellsAroundViewport, cellsAroundViewport.pendingScrollUpdateCount);
        const _createRenderMaskResult = outer1_0._createRenderMask(getItemCount, result, closure_0._getNonViewportRenderRegions(getItemCount));
        if (result.first === cellsAroundViewport.cellsAroundViewport.first) {
          if (result.last === cellsAroundViewport.cellsAroundViewport.last) {
            let obj = null;
          }
          return obj;
        }
        obj = { cellsAroundViewport: result, renderMask: _createRenderMaskResult };
      });
    };
    tmp3Result._createViewToken = (index, isViewable, getItem) => {
      const value = getItem.getItem(getItem.data, index);
      return { index, item: value, key: tmp3Result._keyExtractor(value, index, getItem), isViewable };
    };
    tmp3Result._getNonViewportRenderRegions = (getItemCount) => {
      if (tmp3Result._lastFocusedCellKey) {
        if (tmp._cellRefs[tmp._lastFocusedCellKey]) {
          const index = tmp._cellRefs[tmp._lastFocusedCellKey].props.index;
          const itemCount = getItemCount.getItemCount(getItemCount.data);
          if (index < itemCount) {
            if (tmp3Result._getItemKey(getItemCount, index) === tmp._lastFocusedCellKey) {
              let diff = index - 1;
              let tmp5 = index;
              let tmp6 = tmp;
              if (0 <= diff) {
                let num = 0;
                let tmp4 = index;
                tmp5 = index;
                tmp6 = tmp;
                if (0 < tmp._scrollMetrics.visibleLength) {
                  const diff1 = tmp4 - 1;
                  const _listMetrics = tmp3Result._listMetrics;
                  const sum = num + _listMetrics.getCellMetricsApprox(diff, getItemCount).length;
                  const diff2 = diff - 1;
                  tmp5 = diff1;
                  tmp6 = tmp3Result;
                  while (0 <= diff2) {
                    diff = diff2;
                    tmp4 = diff1;
                    tmp5 = diff1;
                    tmp6 = tmp8;
                    num = sum;
                    if (sum >= tmp8._scrollMetrics.visibleLength) {
                      break;
                    }
                  }
                }
              }
              let sum1 = index + 1;
              let tmp13 = index;
              if (sum1 < itemCount) {
                let num2 = 0;
                let tmp14 = index;
                tmp13 = index;
                if (0 < tmp6._scrollMetrics.visibleLength) {
                  const sum2 = tmp14 + 1;
                  const _listMetrics2 = tmp3Result._listMetrics;
                  const sum3 = num2 + _listMetrics2.getCellMetricsApprox(sum1, getItemCount).length;
                  const sum4 = sum1 + 1;
                  tmp13 = sum2;
                  while (sum4 < itemCount) {
                    sum1 = sum4;
                    tmp14 = sum2;
                    tmp13 = sum2;
                    num2 = sum3;
                    if (sum3 >= tmp16._scrollMetrics.visibleLength) {
                      break;
                    }
                  }
                  tmp16 = tmp3Result;
                }
              }
              const obj = { first: null, last: null };
              obj[0] = tmp5;
              obj[1] = tmp13;
              const items = [obj];
              return items;
            }
          }
          return [];
        }
      }
      return [];
    };
    _checkPropsResult = tmp3Result._checkProps(global);
    tmp12 = new require("Info")(tmp3Result._listMetrics);
    tmp3Result._fillRateHelper = tmp12;
    props = tmp3Result.props;
    if (tmp3Result.props.viewabilityConfigCallbackPairs) {
      prop = props.viewabilityConfigCallbackPairs;
      tmp3Result._viewabilityTuples = prop.map((viewabilityConfig) => {
        const obj = { viewabilityHelper: null, onViewableItemsChanged: null };
        obj[0] = new callback(table[15])(viewabilityConfig.viewabilityConfig);
        obj[1] = viewabilityConfig.onViewableItemsChanged;
        return obj;
      });
    } else {
      ({ onViewableItemsChanged, viewabilityConfig } = props);
      if (onViewableItemsChanged) {
        _viewabilityTuples = tmp3Result._viewabilityTuples;
        obj = { viewabilityHelper: null, onViewableItemsChanged: null };
        tmp13 = new.target;
        tmp14 = new.target;
        tmp15 = viewabilityConfig;
        tmp16 = new require("ViewabilityHelper")(viewabilityConfig);
        tmp17 = tmp16;
        obj[0] = tmp16;
        obj[1] = onViewableItemsChanged;
        arr = _viewabilityTuples.push(obj);
      }
    }
    _initialRenderRegionResult = obj._initialRenderRegion(global);
    maintainVisibleContentPosition = tmp3Result.props.maintainVisibleContentPosition;
    num = undefined;
    if (maintainVisibleContentPosition != null) {
      num = maintainVisibleContentPosition.minIndexForVisible;
    }
    if (num == null) {
      num = 0;
    }
    obj1 = { cellsAroundViewport: _initialRenderRegionResult, renderMask: obj._createRenderMask(global, _initialRenderRegionResult), firstVisibleItemKey: null, pendingScrollUpdateCount: null };
    props2 = tmp3Result.props;
    _getItemKeyResult = null;
    if (props2.getItemCount(tmp3Result.props.data) > num) {
      _getItemKeyResult = obj._getItemKey(tmp3Result.props, num);
    }
    obj1[2] = _getItemKeyResult;
    num2 = 0;
    if (null != tmp3Result.props.initialScrollIndex) {
      num2 = 0;
      if (tmp3Result.props.initialScrollIndex > 0) {
        num2 = 1;
      }
    }
    obj1[3] = num2;
    tmp3Result.state = obj1;
    return tmp3Result;
  }
}
require("_inherits")(VirtualizedList, require("_isNativeReflectConstruct"));
let obj = {
  key: "scrollToEnd",
  value: function scrollToEnd(animated) {
    animated = !animated;
    if (animated) {
      animated = animated.animated;
    }
    const self = this;
    const props = this.props;
    const diff = props.getItemCount(this.props.data) - 1;
    if (diff >= 0) {
      const _listMetrics = self._listMetrics;
      const cellMetricsApprox = _listMetrics.getCellMetricsApprox(diff, self.props);
      const _Math = Math;
      const obj = { animated: null, offset: null };
      obj[0] = animated;
      obj[1] = Math.max(0, cellMetricsApprox.offset + cellMetricsApprox.length + self._footerLength - self._scrollMetrics.visibleLength);
      self.scrollToOffset(obj);
    }
  }
};
let items = [
  obj,
  {
    key: "scrollToIndex",
    value: function scrollToIndex(animated) {
      let data;
      let getItemCount;
      let index;
      let onScrollToIndexFailed;
      let viewOffset;
      let viewPosition;
      const self = this;
      const props = this.props;
      ({ data, getItemCount, onScrollToIndexFailed } = props);
      ({ index, viewOffset, viewPosition } = animated);
      importDefault(38)(index >= 0, "scrollToIndex out of range: requested index " + index + " but minimum is 0");
      const tmp = importDefault;
      const tmp3 = importDefault(38);
      const tmp4 = index >= 0;
      const tmp6 = importDefault(38);
      tmp6(getItemCount(data) >= 1, "scrollToIndex out of range: item length " + getItemCount(data) + " but minimum is 1");
      const tmp7 = getItemCount(data) >= 1;
      const tmp9 = importDefault(38);
      tmp9(index < getItemCount(data), "scrollToIndex out of range: requested index " + index + " is out of 0 to " + getItemCount(data) - 1);
      if (!props.getItemLayout) {
        const _listMetrics = self._listMetrics;
        if (index > _listMetrics.getHighestMeasuredCellIndex()) {
          tmp(38)(onScrollToIndexFailed, "scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, otherwise there is no way to know the location of offscreen indices or handle failures.");
          let obj = { averageItemLength: null, highestMeasuredFrameIndex: null, index: null };
          const _listMetrics2 = self._listMetrics;
          obj[0] = _listMetrics2.getAverageCellLength();
          const _listMetrics3 = self._listMetrics;
          obj[1] = _listMetrics3.getHighestMeasuredCellIndex();
          obj[2] = index;
          const result = onScrollToIndexFailed(obj);
        }
      }
      const _listMetrics4 = self._listMetrics;
      const _listMetrics5 = self._listMetrics;
      const cellMetricsApprox = _listMetrics4.getCellMetricsApprox(Math.floor(index), self.props);
      const cellOffsetApprox = _listMetrics5.getCellOffsetApprox(index, self.props);
      if (!viewPosition) {
        viewPosition = 0;
      }
      const bound = Math.max(0, cellOffsetApprox - viewPosition * (self._scrollMetrics.visibleLength - cellMetricsApprox.length));
      if (!viewOffset) {
        viewOffset = 0;
      }
      obj = { offset: bound - viewOffset, animated: animated.animated };
      self.scrollToOffset(obj);
    }
  },
  {
    key: "scrollToItem",
    value: function scrollToItem(arg0) {
      const self = this;
      const props = this.props;
      const data = props.data;
      const itemCount = props.getItemCount(data);
      let num = 0;
      if (0 < itemCount) {
        while (tmp2(data, num) !== tmp) {
          num = num + 1;
        }
        const obj = {};
        const merged = Object.assign(arg0);
        obj.index = num;
        self.scrollToIndex(obj);
      }
    }
  },
  {
    key: "scrollToOffset",
    value: function scrollToOffset(arg0) {
      const self = this;
      const _scrollRef = this._scrollRef;
      if (null != _scrollRef) {
        if (null != _scrollRef.scrollTo) {
          const _orientationResult = self._orientation();
          if (_orientationResult.horizontal) {
            if (_orientationResult.rtl) {
              const _listMetrics = self._listMetrics;
              if (!_listMetrics.hasContentLength()) {
                const _console2 = console;
                console.warn("scrollToOffset may not be called in RTL before content is laid out");
              }
            }
          }
          const obj = { animated: null };
          obj[0] = tmp;
          const merged = Object.assign(self._scrollToParamsFromOffset(tmp2));
          _scrollRef.scrollTo(obj);
        } else {
          const _console = console;
          console.warn("No scrollTo method provided. This may be because you have two nested VirtualizedLists with the same orientation, or because you are using a custom component that does not implement scrollTo.");
        }
      }
    }
  },
  {
    key: "_scrollToParamsFromOffset",
    value: function _scrollToParamsFromOffset(arg0) {
      const self = this;
      const _orientationResult = this._orientation();
      const horizontal = _orientationResult.horizontal;
      if (horizontal) {
        if (_orientationResult.rtl) {
          const _listMetrics = self._listMetrics;
          const cartesianOffsetResult = _listMetrics.cartesianOffset(arg0 + self._scrollMetrics.visibleLength);
          if (horizontal) {
            let obj = { x: null };
            obj[0] = cartesianOffsetResult;
          } else {
            obj = { y: null };
            obj[0] = cartesianOffsetResult;
          }
          return obj;
        }
      }
      if (horizontal) {
        const obj1 = { x: null };
        obj1[0] = arg0;
        obj = obj1;
      } else {
        obj = { y: null };
        obj[0] = arg0;
      }
      return obj;
    }
  },
  {
    key: "recordInteraction",
    value: function recordInteraction() {
      const _nestedChildLists = this._nestedChildLists;
      const item = _nestedChildLists.forEach((recordInteraction) => {
        recordInteraction.recordInteraction();
      });
      const _viewabilityTuples = this._viewabilityTuples;
      const item1 = _viewabilityTuples.forEach((viewabilityHelper) => {
        viewabilityHelper = viewabilityHelper.viewabilityHelper;
        viewabilityHelper.recordInteraction();
      });
      this._updateViewableItems(this.props, this.state.cellsAroundViewport);
    }
  },
  {
    key: "flashScrollIndicators",
    value: function flashScrollIndicators() {
      if (null != this._scrollRef) {
        const _scrollRef = this._scrollRef;
        const result = _scrollRef.flashScrollIndicators();
      }
    }
  },
  {
    key: "getScrollResponder",
    value: function getScrollResponder() {
      const self = this;
      if (this._scrollRef) {
        if (self._scrollRef.getScrollResponder) {
          const _scrollRef = self._scrollRef;
          return _scrollRef.getScrollResponder();
        }
      }
    }
  },
  {
    key: "getScrollableNode",
    value: function getScrollableNode() {
      const self = this;
      if (this._scrollRef) {
        if (self._scrollRef.getScrollableNode) {
          const _scrollRef = self._scrollRef;
          let scrollableNode = _scrollRef.getScrollableNode();
        }
        return scrollableNode;
      }
      scrollableNode = callback5(self._scrollRef);
    }
  },
  {
    key: "getScrollRef",
    value: function getScrollRef() {
      const self = this;
      if (this._scrollRef) {
        if (self._scrollRef.getScrollRef) {
          const _scrollRef2 = self._scrollRef;
          let _scrollRef = _scrollRef2.getScrollRef();
        }
        return _scrollRef;
      }
      _scrollRef = self._scrollRef;
    }
  },
  {
    key: "setNativeProps",
    value: function setNativeProps(arg0) {
      if (this._scrollRef) {
        const _scrollRef = tmp._scrollRef;
        _scrollRef.setNativeProps(arg0);
      }
    }
  },
  {
    key: "_getCellKey",
    value: function _getCellKey() {
      const context = this.context;
      let str;
      if (context != null) {
        str = context.cellKey;
      }
      if (!str) {
        str = "rootList";
      }
      return str;
    }
  },
  {
    key: "hasMore",
    value: function hasMore() {
      return this._hasMore;
    }
  },
  {
    key: "_checkProps",
    value: function _checkProps(arg0) {
      let data;
      let getItemCount;
      let initialScrollIndex;
      let onScroll;
      let windowSize;
      ({ onScroll, getItemCount, initialScrollIndex } = arg0);
      ({ windowSize, data } = arg0);
      let tmp4 = !onScroll;
      if (onScroll) {
        tmp4 = !onScroll.__isNative;
      }
      const self = this;
      importDefault(38)(tmp4, "Components based on VirtualizedList must be wrapped with Animated.createAnimatedComponent to support native onScroll events with useNativeDriver");
      const tmp3 = importDefault(38);
      const tmpResult = importDefault(38);
      tmpResult(VirtualizedList(320).windowSizeOrDefault(windowSize) > 0, "VirtualizedList: The windowSize prop must be present and set to a value greater than 0.");
      importDefault(38)(getItemCount, "VirtualizedList: The \"getItemCount\" prop must be provided");
      const itemCount = getItemCount(data);
      let initialScrollIndex2 = null == initialScrollIndex || self._hasTriggeredInitialScrollToIndex;
      if (!initialScrollIndex2) {
        let tmp10 = initialScrollIndex < 0;
        if (!tmp10) {
          tmp10 = itemCount > 0 && initialScrollIndex >= itemCount;
          const tmp11 = itemCount > 0 && initialScrollIndex >= itemCount;
        }
        initialScrollIndex2 = !tmp10;
      }
      if (!initialScrollIndex2) {
        initialScrollIndex2 = self._hasWarned.initialScrollIndex;
      }
      if (!initialScrollIndex2) {
        const _console = console;
        const _HermesInternal = HermesInternal;
        console.warn("initialScrollIndex \"" + initialScrollIndex + "\" is not valid (list has " + itemCount + " items)");
        self._hasWarned.initialScrollIndex = true;
      }
    }
  },
  {
    key: "_adjustCellsAroundViewport",
    value: function _adjustCellsAroundViewport(onEndReachedThreshold, cellsAroundViewport, pendingScrollUpdateCount) {
      let data;
      let getItemCount;
      const self = this;
      ({ data, getItemCount } = onEndReachedThreshold);
      let obj = VirtualizedList(320);
      const visibleLength = this._scrollMetrics.visibleLength;
      const _listMetrics = this._listMetrics;
      const result = obj.onEndReachedThresholdOrDefault(onEndReachedThreshold.onEndReachedThreshold);
      const contentLength = _listMetrics.getContentLength();
      if (visibleLength > 0) {
        if (contentLength > 0) {
          if (onEndReachedThreshold.disableVirtualization) {
            let num = 0;
            if (tmp5 < result * visibleLength) {
              let tmpResult = tmp(320);
              num = tmpResult.maxToRenderPerBatchOrDefault(onEndReachedThreshold.maxToRenderPerBatch);
            }
            obj = { first: 0, last: null };
            const _Math = Math;
            const sum = cellsAroundViewport.last + num;
            obj[1] = Math.min(sum, getItemCount(data) - 1);
            let windowedRenderLimits = obj;
          } else if (pendingScrollUpdateCount > 0) {
            let result1 = cellsAroundViewport;
            if (cellsAroundViewport.last >= getItemCount(data)) {
              result1 = VirtualizedList._constrainToItemCount(cellsAroundViewport, onEndReachedThreshold);
            }
            return result1;
          } else {
            tmpResult = tmp(313);
            const result2 = tmp(320).maxToRenderPerBatchOrDefault(onEndReachedThreshold.maxToRenderPerBatch);
            const tmpResult1 = tmp(320);
            windowedRenderLimits = tmpResult.computeWindowedRenderLimits(onEndReachedThreshold, result2, tmp(320).windowSizeOrDefault(onEndReachedThreshold.windowSize), cellsAroundViewport, self._listMetrics, self._scrollMetrics);
            const tmpResult2 = tmp(320);
            importDefault(38)(windowedRenderLimits.last < getItemCount(data), "computeWindowedRenderLimits() should return range in-bounds");
            const tmp20 = importDefault(38);
          }
          const _nestedChildLists = self._nestedChildLists;
          if (_nestedChildLists.size() > 0) {
            let last = self._findFirstChildWithMore(windowedRenderLimits.first, windowedRenderLimits.last);
            if (last == null) {
              last = windowedRenderLimits.last;
            }
            windowedRenderLimits.last = last;
          }
          return windowedRenderLimits;
        }
      }
      let result3 = cellsAroundViewport;
      if (cellsAroundViewport.last >= getItemCount(data)) {
        result3 = VirtualizedList._constrainToItemCount(cellsAroundViewport, onEndReachedThreshold);
      }
      return result3;
    }
  },
  {
    key: "_findFirstChildWithMore",
    value: function _findFirstChildWithMore(first, last) {
      const self = this;
      let sum = first;
      if (first <= last) {
        while (true) {
          let _indicesToKeys = self._indicesToKeys;
          let value = _indicesToKeys.get(sum);
          let tmp3 = sum;
          if (null != value) {
            let _nestedChildLists = self._nestedChildLists;
            if (_nestedChildLists.anyInCell(value, (hasMore) => hasMore.hasMore())) {
              break;
            }
          }
          sum = sum + 1;
        }
        return sum;
      }
      return null;
    }
  },
  {
    key: "componentDidMount",
    value: function componentDidMount() {
      const self = this;
      if (this._isNestedWithSameOrientation()) {
        const context = self.context;
        const obj = { ref: null, cellKey: null };
        obj[0] = self;
        obj[1] = self.context.cellKey;
        const result = context.registerAsNestedChild(obj);
      }
    }
  },
  {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      const self = this;
      if (this._isNestedWithSameOrientation()) {
        const context = self.context;
        const obj = { ref: null };
        obj[0] = self;
        const result = context.unregisterAsNestedChild(obj);
      }
      clearTimeout(self._updateCellsToRenderTimeoutID);
      const _viewabilityTuples = self._viewabilityTuples;
      const item = _viewabilityTuples.forEach((viewabilityHelper) => {
        viewabilityHelper = viewabilityHelper.viewabilityHelper;
        viewabilityHelper.dispose();
      });
      const _fillRateHelper = self._fillRateHelper;
      _fillRateHelper.deactivateAndFlush();
    }
  },
  {
    key: "_pushCells",
    value: function _pushCells(items, items1, has, first, last, arg5) {
      let CellRendererComponent;
      let ItemSeparatorComponent;
      let ListItemComponent;
      let debug;
      let getItem;
      let getItemCount;
      let getItemLayout;
      let horizontal;
      let renderItem;
      let self = this;
      self = this;
      const props = this.props;
      const data = props.data;
      let num = 0;
      ({ CellRendererComponent, ItemSeparatorComponent, ListItemComponent, debug, getItem, getItemCount, getItemLayout, horizontal, renderItem } = props);
      if (props.ListHeaderComponent) {
        num = 1;
      }
      const diff = getItemCount(data) - 1;
      const bound = Math.min(diff, last);
      let sum = first;
      let tmp5 = first;
      if (first <= bound) {
        do {
          let value = getItem(data, sum);
          let tmp7 = self;
          let _keyExtractorResult = self._keyExtractor(value, sum, self.props);
          self = _keyExtractorResult;
          let _indicesToKeys = self._indicesToKeys;
          let result = _indicesToKeys.set(sum, _keyExtractorResult);
          let tmp10 = sum;
          let tmp11 = tmp4;
          let tmp12 = tmp5;
          if (has.has(sum + num)) {
            let arr = items1.push(items.length);
          }
          let enabledResult = null == getItemLayout || debug;
          if (!enabledResult) {
            let _fillRateHelper = self._fillRateHelper;
            enabledResult = _fillRateHelper.enabled();
          }
          let tmp16 = importDefault;
          let tmp17 = dependencyMap;
          let tmp15 = outer1_18;
          let obj = { CellRendererComponent: null, ItemSeparatorComponent: null, ListItemComponent: null, cellKey: null, horizontal: null, index: null, inversionStyle: null, item: null, prevCellKey: null, onUpdateSeparators: null, onCellFocusCapture: null, onUnmount: null, ref: null, renderItem: null };
          obj[0] = CellRendererComponent;
          let tmp19;
          let tmp18 = importDefault(321);
          if (sum < diff) {
            tmp19 = ItemSeparatorComponent;
          }
          obj[1] = tmp19;
          obj[2] = ListItemComponent;
          obj[3] = _keyExtractorResult;
          obj[4] = horizontal;
          obj[5] = sum;
          obj[6] = arg5;
          obj[7] = value;
          obj[8] = tmp4;
          ({ _onUpdateSeparators: obj[9], _onCellFocusCapture: obj[10], _onCellUnmount: obj[11] } = self);
          obj[12] = function ref(arg0) {
            self._cellRefs[self] = arg0;
          };
          obj[13] = renderItem;
          if (enabledResult) {
            obj = { onCellLayout: null };
            obj[0] = self._onCellLayout;
            enabledResult = obj;
          }
          let tmp20 = obj;
          let tmp21 = enabledResult;
          let merged = Object.assign(enabledResult);
          arr = items.push(tmp15(tmp18, obj, _keyExtractorResult));
          sum = tmp5 + 1;
          tmp4 = _keyExtractorResult;
          tmp5 = sum;
        } while (sum <= bound);
      }
    }
  },
  {
    key: "_isNestedWithSameOrientation",
    value: function _isNestedWithSameOrientation() {
      const context = this.context;
      let tmp2 = !context;
      if (context) {
        tmp2 = !!context.horizontal !== VirtualizedList(320).horizontalOrDefault(tmp.props.horizontal);
        const obj = VirtualizedList(320);
        const tmp3 = !context.horizontal;
      }
      return !tmp2;
    }
  },
  {
    key: "_renderEmptyComponent",
    value: function _renderEmptyComponent(type, arg1) {
      const self = this;
      let closure_0 = type;
      let tmp = type;
      if (type.type !== React.Fragment) {
        const obj = { onLayout: null, style: null };
        obj[0] = function onLayout(arg0) {
          self._onLayoutEmpty(arg0);
          if (type.props.onLayout) {
            const props = type.props;
            props.onLayout(arg0);
          }
        };
        obj[1] = StyleSheet.compose(arg1, type.props.style);
        tmp = callback3(type, obj);
      }
      return tmp;
    }
  },
  {
    key: "render",
    value: function render() {
      let ListEmptyComponent;
      let ListFooterComponent;
      let ListHeaderComponent;
      const self = this;
      this._checkProps(this.props);
      ({ ListEmptyComponent, ListFooterComponent, ListHeaderComponent } = this.props);
      if (!this.props.inverted) {
        const items = [];
        const _Set = Set;
        const set = new Set(self.props.stickyHeaderIndices);
        const items1 = [];
        if (ListHeaderComponent) {
          if (set.has(0)) {
            items1.push(0);
          }
          let tmp14 = ListHeaderComponent;
          if (!callback4(ListHeaderComponent)) {
            tmp14 = callback6(ListHeaderComponent, {});
          }
          let obj = { cellKey: null, children: null };
          obj[0] = `${self._getCellKey()}-header`;
          obj = { collapsable: false, onLayout: null, style: null, children: null };
          obj[1] = self._onLayoutHeader;
          obj[2] = StyleSheet.compose(null, self.props.ListHeaderComponentStyle);
          obj[3] = tmp14;
          obj[1] = callback6(closure_16, obj);
          items.push(callback6(VirtualizedList(322).VirtualizedListCellContextProvider, obj, "$header"));
        }
        const props = self.props;
        const itemCount = props.getItemCount(tmp2);
        if (0 === itemCount) {
          if (ListEmptyComponent) {
            let tmp24 = ListEmptyComponent;
            if (!callback4(ListEmptyComponent)) {
              tmp24 = callback6(ListEmptyComponent, {});
            }
            const obj1 = { cellKey: null, children: null };
            obj1[0] = `${self._getCellKey()}-empty`;
            obj1[1] = self._renderEmptyComponent(tmp24, null);
            items.push(callback6(VirtualizedList(322).VirtualizedListCellContextProvider, obj1, "$empty"));
          }
        }
        if (itemCount > 0) {
          let c21 = false;
          let c22 = "";
          const renderMask = self.state.renderMask;
          const enumerateRegionsResult = renderMask.enumerateRegions();
          let isSpacer;
          if (enumerateRegionsResult[enumerateRegionsResult.length - 1] != null) {
            isSpacer = tmp83.isSpacer;
          }
          let tmp31 = null;
          if (isSpacer) {
            tmp31 = tmp83;
          }
          const iter = enumerateRegionsResult[Symbol.iterator]();
          const nextResult = iter.next();
          while (iter !== undefined) {
            let tmp36 = nextResult;
            if (nextResult.isSpacer) {
              if (self.props.disableVirtualization) {
                continue;
              } else {
                let tmp44 = nextResult;
                if (tmp36 === tmp31) {
                  if (!self.props.getItemLayout) {
                    let tmp45 = importDefault;
                    let tmp46 = dependencyMap;
                    let tmp48 = nextResult;
                    let _listMetrics = self._listMetrics;
                    let tmp47 = importDefault(323);
                    let diff = tmp36.first - 1;
                    let last = tmp47(diff, tmp36.last, _listMetrics.getHighestMeasuredCellIndex());
                  }
                  let _listMetrics2 = self._listMetrics;
                  let tmp51 = nextResult;
                  let _listMetrics3 = self._listMetrics;
                  let cellMetricsApprox = _listMetrics2.getCellMetricsApprox(tmp36.first, self.props);
                  let cellMetricsApprox1 = _listMetrics3.getCellMetricsApprox(last, self.props);
                  let tmp53 = callback6;
                  let tmp54 = closure_16;
                  let obj2 = { style: null };
                  let obj3 = {};
                  obj3[_getSpacerKeyResult] = cellMetricsApprox1.offset + cellMetricsApprox1.length - cellMetricsApprox.offset;
                  obj2[0] = obj3;
                  let _HermesInternal = HermesInternal;
                  let arr2 = items.push(callback6(closure_16, obj2, "$spacer-" + tmp36.first));
                }
                let tmp50 = nextResult;
                last = tmp36.last;
              }
            } else {
              let tmp37 = nextResult;
              let tmp38 = self;
              let tmp39 = items;
              let tmp40 = items1;
              let tmp41 = set;
              let tmp42 = null;
              let _pushCellsResult = self._pushCells(items, items1, set, tmp36.first, tmp36.last, null);
              continue;
            }
            continue;
          }
          const keys = self._hasWarned.keys;
          let tmp56 = !keys;
          if (!keys) {
            tmp56 = c21;
          }
          if (tmp56) {
            const _console = console;
            console.warn("VirtualizedList: missing keys for items, make sure to specify a key or id property on each item or provide a custom keyExtractor.", c22);
            self._hasWarned.keys = true;
          }
          _getSpacerKeyResult = self._getSpacerKey(!tmp3);
        }
        if (ListFooterComponent) {
          let tmp60 = ListFooterComponent;
          if (!callback4(ListFooterComponent)) {
            tmp60 = callback6(ListFooterComponent, {});
          }
          const obj4 = { cellKey: null, children: null };
          obj4[0] = self._getFooterCellKey();
          const obj5 = { onLayout: null, style: null, children: null };
          obj5[0] = self._onLayoutFooter;
          obj5[1] = StyleSheet.compose(null, self.props.ListFooterComponentStyle);
          obj5[2] = tmp60;
          obj4[1] = callback6(closure_16, obj5);
          items.push(callback6(VirtualizedList(322).VirtualizedListCellContextProvider, obj4, "$footer"));
        }
        const obj6 = {};
        const merged = Object.assign(self.props);
        ({ _onContentSizeChange: obj10.onContentSizeChange, _onLayout: obj10.onLayout, _onScroll: obj10.onScroll, _onScrollBeginDrag: obj10.onScrollBeginDrag, _onScrollEndDrag: obj10.onScrollEndDrag, _onMomentumScrollBegin: obj10.onMomentumScrollBegin, _onMomentumScrollEnd: obj10.onMomentumScrollEnd } = self);
        let num3 = self.props.scrollEventThrottle;
        if (num3 == null) {
          num3 = 0.0001;
        }
        obj6.scrollEventThrottle = num3;
        if (undefined !== self.props.invertStickyHeaders) {
          let inverted = self.props.invertStickyHeaders;
        } else {
          inverted = self.props.inverted;
        }
        obj6.invertStickyHeaders = inverted;
        obj6.stickyHeaderIndices = items1;
        if (null) {
          const items2 = [null, self.props.style];
          let style = items2;
        } else {
          style = self.props.style;
        }
        obj6.style = style;
        obj6.isInvertedVirtualizedList = self.props.inverted;
        let tmp70;
        if (null != self.props.maintainVisibleContentPosition) {
          const obj7 = {};
          const merged1 = Object.assign(self.props.maintainVisibleContentPosition);
          let num4 = 0;
          if (self.props.ListHeaderComponent) {
            num4 = 1;
          }
          obj7.minIndexForVisible = self.props.maintainVisibleContentPosition.minIndexForVisible + num4;
          tmp70 = obj7;
        }
        obj6.maintainVisibleContentPosition = tmp70;
        self._hasMore = self.state.cellsAroundViewport.last < itemCount - 1;
        const obj8 = { value: null, children: null };
        const obj9 = { cellKey: null, getScrollMetrics: null, horizontal: null, getOutermostParentListRef: null, registerAsNestedChild: null, unregisterAsNestedChild: null };
        obj9[1] = self._getScrollMetrics;
        obj9[2] = VirtualizedList(320).horizontalOrDefault(self.props.horizontal);
        ({ _getOutermostParentListRef: obj13[3], _registerAsNestedChild: obj13[4], _unregisterAsNestedChild: obj13[5] } = self);
        obj8[0] = obj9;
        let _defaultRenderScrollComponent = self.props.renderScrollComponent;
        if (!_defaultRenderScrollComponent) {
          _defaultRenderScrollComponent = self._defaultRenderScrollComponent;
        }
        const obj10 = { ref: null };
        obj10[0] = self._captureScrollRef;
        obj8[1] = closure_10(_defaultRenderScrollComponent(obj6), obj10, items);
        const tmp73Result = callback6(VirtualizedList(322).VirtualizedListContextProvider, obj8);
        let tmp78 = tmp73Result;
        if (self.props.debug) {
          const obj11 = { style: null, children: null };
          obj11[0] = debug.debug;
          const items3 = [tmp73Result, self._renderDebugOverlay()];
          obj11[1] = items3;
          tmp78 = callback7(closure_16, obj11);
        }
        return tmp78;
      } else {
        obj = VirtualizedList(320);
        obj.horizontalOrDefault(self.props.horizontal) ? debug.horizontallyInverted : debug.verticallyInverted;
      }
    }
  },
  {
    key: "componentDidUpdate",
    value: function componentDidUpdate(data) {
      const self = this;
      const props = this.props;
      let tmp2 = props.data === data.data;
      if (tmp2) {
        tmp2 = tmp === data.extraData;
      }
      if (!tmp2) {
        const _viewabilityTuples = self._viewabilityTuples;
        const item = _viewabilityTuples.forEach((viewabilityHelper) => {
          viewabilityHelper = viewabilityHelper.viewabilityHelper;
          viewabilityHelper.resetViewableIndices();
        });
      }
      const result = self._scheduleCellsToRenderUpdate();
      if (self._hiPriInProgress) {
        self._hiPriInProgress = false;
      }
      if (null != props.getItemLayout) {
        const result1 = self._maybeCallOnEdgeReached();
      }
    }
  },
  {
    key: "_computeBlankness",
    value: function _computeBlankness() {
      const _fillRateHelper = this._fillRateHelper;
      const blankness = _fillRateHelper.computeBlankness(this.props, this.state.cellsAroundViewport, this._scrollMetrics);
    }
  },
  {
    key: "_triggerRemeasureForChildListsInCell",
    value: function _triggerRemeasureForChildListsInCell(closure_0) {
      const _nestedChildLists = this._nestedChildLists;
      _nestedChildLists.forEachInCell(closure_0, (measureLayoutRelativeToContainingList) => {
        const result = measureLayoutRelativeToContainingList.measureLayoutRelativeToContainingList();
      });
    }
  },
  {
    key: "measureLayoutRelativeToContainingList",
    value: function measureLayoutRelativeToContainingList() {
      let _scrollRef;
      let context;
      let self = this;
      self = this;
      try {
        if (self._scrollRef) {
          ({ _scrollRef, context } = self);
          const outermostParentListRef = context.getOutermostParentListRef();
          _scrollRef.measureLayout(outermostParentListRef.getScrollRef(), (arg0, arg1, width, height) => {
            let _convertParentScrollMetrics;
            let context;
            let obj = { x: arg0, y: arg1 };
            self._offsetFromParentVirtualizedList = self._selectOffset(obj);
            const _listMetrics = self._listMetrics;
            obj = { layout: obj, orientation: self._orientation() };
            obj = { width, height };
            let result = _listMetrics.notifyListContentLayout(obj);
            ({ context, _convertParentScrollMetrics } = self);
            const result1 = _convertParentScrollMetrics(context.getScrollMetrics());
            if (tmp4) {
              ({ visibleLength: tmp._scrollMetrics.visibleLength, offset: tmp._scrollMetrics.offset } = result1);
              const _nestedChildLists = tmp._nestedChildLists;
              const item = _nestedChildLists.forEach((measureLayoutRelativeToContainingList) => {
                const result = measureLayoutRelativeToContainingList.measureLayoutRelativeToContainingList();
              });
            }
          }, (arg0) => {
            console.warn("VirtualizedList: Encountered an error while measuring a list's offset from its containing VirtualizedList.");
          });
        }
      } catch (tmp2) {
        const _console = console;
        console.warn("measureLayoutRelativeToContainingList threw an error", tmp2.stack);
      }
    }
  },
  {
    key: "_getFooterCellKey",
    value: function _getFooterCellKey() {
      return this._getCellKey() + "-footer";
    }
  },
  {
    key: "_renderDebugOverlay",
    value: function _renderDebugOverlay() {
      const self = this;
      const _listMetrics = this._listMetrics;
      const result = this._scrollMetrics.visibleLength / (_listMetrics.getContentLength() || 1);
      const VirtualizedList = result;
      const items = [];
      const props = self.props;
      const itemCount = props.getItemCount(self.props.data);
      for (let num = 0; num < itemCount; num = num + 1) {
        let _listMetrics2 = self._listMetrics;
        let cellMetricsApprox = _listMetrics2.getCellMetricsApprox(num, self.props);
        let tmp5 = num;
        if (cellMetricsApprox.isMounted) {
          let arr = items.push(cellMetricsApprox);
        }
      }
      const _listMetrics3 = self._listMetrics;
      const offset = _listMetrics3.getCellMetricsApprox(self.state.cellsAroundViewport.first, self.props).offset;
      const _listMetrics4 = self._listMetrics;
      const cellMetricsApprox1 = _listMetrics4.getCellMetricsApprox(self.state.cellsAroundViewport.last, self.props);
      const obj = { style: items1, children: null };
      items1 = [, ];
      ({ debugOverlayBase: arr3[0], debugOverlay: arr3[1] } = closure_23);
      const diff = cellMetricsApprox1.offset + cellMetricsApprox1.length - offset;
      const items2 = [
        items.map((offset) => {
          const style = [, , ];
          ({ debugOverlayBase: arr[0], debugOverlayFrame: arr[1] } = outer1_23);
          style[2] = { top: offset.offset * closure_0, height: offset.length * closure_0 };
          return outer1_18(outer1_16, { style }, "f" + arg1);
        }),
      ,

      ];
      const items3 = [, , ];
      ({ debugOverlayBase: arr5[0], debugOverlayFrameLast: arr5[1] } = closure_23);
      items3[2] = { top: offset * result, height: diff * result };
      items2[1] = callback6(closure_16, { style: items3 });
      const items4 = [, , ];
      ({ debugOverlayBase: arr6[0], debugOverlayFrameVis: arr6[1] } = closure_23);
      items4[2] = { top: self._scrollMetrics.offset * result, height: self._scrollMetrics.visibleLength * result };
      items2[2] = callback6(closure_16, { style: items4 });
      obj[1] = items2;
      return callback7(closure_16, obj);
    }
  },
  {
    key: "_selectLength",
    value: function _selectLength(width) {
      return VirtualizedList(320).horizontalOrDefault(this.props.horizontal) ? width.width : width.height;
    }
  },
  {
    key: "_selectOffset",
    value: function _selectOffset(arg0) {
      let x;
      let y;
      ({ y, x } = arg0);
      if (this._orientation().horizontal) {
        y = x;
      }
      return y;
    }
  },
  {
    key: "_orientation",
    value: function _orientation() {
      const obj = { horizontal: null, rtl: null };
      obj[0] = VirtualizedList(320).horizontalOrDefault(this.props.horizontal);
      obj[1] = isRTL.isRTL;
      return obj;
    }
  },
  {
    key: "_maybeCallOnEdgeReached",
    value: function _maybeCallOnEdgeReached() {
      let data;
      let getItemCount;
      let offset;
      let onEndReached;
      let onEndReachedThreshold;
      let onStartReached;
      let onStartReachedThreshold;
      let visibleLength;
      const self = this;
      const props = this.props;
      ({ onStartReached, onStartReachedThreshold, onEndReached, onEndReachedThreshold } = props);
      const _listMetrics = this._listMetrics;
      ({ data, getItemCount } = props);
      if (_listMetrics.hasContentLength()) {
        if (0 !== self._scrollMetrics.visibleLength) {
          if (self.state.pendingScrollUpdateCount <= 0) {
            ({ visibleLength, offset } = self._scrollMetrics);
            const _listMetrics6 = self._listMetrics;
            let num2 = _listMetrics6.getContentLength() - visibleLength - offset;
            if (offset < 0.001) {
              offset = 0;
            }
            if (num2 < 0.001) {
              num2 = 0;
            }
            let num3 = 2;
            let num4 = 2;
            if (null != onStartReachedThreshold) {
              num4 = onStartReachedThreshold * visibleLength;
            }
            if (null != onEndReachedThreshold) {
              num3 = onEndReachedThreshold * visibleLength;
            }
            let tmp3 = onEndReached;
            if (onEndReached) {
              tmp3 = self.state.cellsAroundViewport.last === getItemCount(data) - 1;
            }
            if (tmp3) {
              tmp3 = tmp4;
            }
            if (tmp3) {
              const _listMetrics2 = self._listMetrics;
              tmp3 = _listMetrics2.getContentLength() !== self._sentEndForContentLength;
            }
            if (tmp3) {
              const _listMetrics3 = self._listMetrics;
              self._sentEndForContentLength = _listMetrics3.getContentLength();
              let obj = { distanceFromEnd: null };
              obj[0] = num2;
              onEndReached(obj);
            }
            let tmp6 = null != onStartReached && 0 === self.state.cellsAroundViewport.first && tmp2;
            if (tmp6) {
              const _listMetrics4 = self._listMetrics;
              tmp6 = _listMetrics4.getContentLength() !== self._sentStartForContentLength;
            }
            if (tmp6) {
              const _listMetrics5 = self._listMetrics;
              self._sentStartForContentLength = _listMetrics5.getContentLength();
              obj = { distanceFromStart: null };
              obj[0] = offset;
              onStartReached(obj);
            }
            if (offset > num4) {
              self._sentStartForContentLength = 0;
            }
            if (num2 > num3) {
              self._sentEndForContentLength = 0;
            }
          }
        }
      }
    }
  },
  {
    key: "_maybeScrollToInitialScrollIndex",
    value: function _maybeScrollToInitialScrollIndex(width, height) {
      let tmp = width > 0;
      if (tmp) {
        tmp = height > 0;
      }
      const self = this;
      if (tmp) {
        tmp = null != self.props.initialScrollIndex;
      }
      if (tmp) {
        tmp = self.props.initialScrollIndex > 0;
      }
      if (tmp) {
        tmp = !self._hasTriggeredInitialScrollToIndex;
      }
      if (tmp) {
        if (null != self.props.contentOffset) {
          self._hasTriggeredInitialScrollToIndex = true;
        } else {
          const props = self.props;
          if (self.props.initialScrollIndex >= props.getItemCount(self.props.data)) {
            self.scrollToEnd({ animated: false });
          }
        }
        const obj = { animated: false, index: null };
        obj[1] = importDefault(70)(self.props.initialScrollIndex);
        self.scrollToIndex(obj);
      }
    }
  },
  {
    key: "unstable_onScroll",
    value: function unstable_onScroll(closure_0) {
      this._onScroll(closure_0);
    }
  },
  {
    key: "_offsetFromScrollEvent",
    value: function _offsetFromScrollEvent(nativeEvent) {
      let contentOffset;
      let contentSize;
      let layoutMeasurement;
      const self = this;
      ({ contentOffset, contentSize, layoutMeasurement } = nativeEvent.nativeEvent);
      const _orientationResult = this._orientation();
      if (_orientationResult.horizontal) {
        if (_orientationResult.rtl) {
          const _selectLengthResult = self._selectLength(contentSize);
          let diff = _selectLengthResult - (self._selectOffset(contentOffset) + self._selectLength(layoutMeasurement));
          const _selectOffsetResult = self._selectOffset(contentOffset);
        }
        return diff;
      }
      diff = self._selectOffset(contentOffset);
    }
  },
  {
    key: "_scheduleCellsToRenderUpdate",
    value: function _scheduleCellsToRenderUpdate() {
      let self = this;
      self = this;
      const _listMetrics = this._listMetrics;
      if (_listMetrics.getAverageCellLength() > 0) {
        if (self._shouldRenderWithPriority()) {
          if (!self._hiPriInProgress) {
            self._hiPriInProgress = true;
            if (null != self._updateCellsToRenderTimeoutID) {
              const _clearTimeout = clearTimeout;
              clearTimeout(self._updateCellsToRenderTimeoutID);
              self._updateCellsToRenderTimeoutID = null;
            }
            self._updateCellsToRender();
          }
        }
      }
      if (null == self._updateCellsToRenderTimeoutID) {
        let num = self.props.updateCellsBatchingPeriod;
        if (num == null) {
          num = 50;
        }
        self._updateCellsToRenderTimeoutID = setTimeout(() => {
          self._updateCellsToRenderTimeoutID = null;
          self._updateCellsToRender();
        }, num);
      }
    }
  },
  {
    key: "_shouldRenderWithPriority",
    value: function _shouldRenderWithPriority() {
      let first;
      let last;
      let offset;
      let velocity;
      let visibleLength;
      const self = this;
      ({ first, last } = this.state.cellsAroundViewport);
      ({ offset, visibleLength, velocity } = this._scrollMetrics);
      const props = this.props;
      const itemCount = props.getItemCount(this.props.data);
      const result = VirtualizedList(320).onStartReachedThresholdOrDefault(this.props.onStartReachedThreshold);
      const obj = VirtualizedList(320);
      let flag = false;
      const result1 = VirtualizedList(320).onEndReachedThresholdOrDefault(this.props.onEndReachedThreshold);
      if (first > 0) {
        const _listMetrics = self._listMetrics;
        const diff = offset - _listMetrics.getCellMetricsApprox(first, self.props).offset;
        let tmp5 = diff < 0;
        if (!tmp5) {
          let tmp6 = velocity < -2;
          if (tmp6) {
            tmp6 = diff < result * visibleLength / 2;
          }
          tmp5 = tmp6;
        }
        flag = tmp5;
      }
      let tmp7 = flag;
      if (!flag) {
        tmp7 = flag;
        if (last >= 0) {
          tmp7 = flag;
          if (last < itemCount - 1) {
            const _listMetrics2 = self._listMetrics;
            const diff1 = _listMetrics2.getCellMetricsApprox(last, self.props).offset - (offset + visibleLength);
            let tmp9 = diff1 < 0;
            if (!tmp9) {
              tmp9 = velocity > 2 && diff1 < result1 * visibleLength / 2;
              const tmp10 = velocity > 2 && diff1 < result1 * visibleLength / 2;
            }
            tmp7 = tmp9;
          }
        }
      }
      return tmp7;
    }
  },
  {
    key: "unstable_onScrollBeginDrag",
    value: function unstable_onScrollBeginDrag(closure_0) {
      this._onScrollBeginDrag(closure_0);
    }
  },
  {
    key: "unstable_onScrollEndDrag",
    value: function unstable_onScrollEndDrag(closure_0) {
      this._onScrollEndDrag(closure_0);
    }
  },
  {
    key: "unstable_onMomentumScrollBegin",
    value: function unstable_onMomentumScrollBegin(arg0) {
      const result = this._onMomentumScrollBegin(arg0);
    }
  },
  {
    key: "unstable_onMomentumScrollEnd",
    value: function unstable_onMomentumScrollEnd(closure_0) {
      this._onMomentumScrollEnd(closure_0);
    }
  },
  {
    key: "__getListMetrics",
    value: function __getListMetrics() {
      return this._listMetrics;
    }
  },
  {
    key: "_updateViewableItems",
    value: function _updateViewableItems(props, cellsAroundViewport) {
      const self = this;
      let closure_1 = props;
      let closure_0 = cellsAroundViewport;
      if (this.state.pendingScrollUpdateCount <= 0) {
        const _viewabilityTuples = this._viewabilityTuples;
        const item = _viewabilityTuples.forEach((viewabilityHelper) => {
          viewabilityHelper = viewabilityHelper.viewabilityHelper;
          viewabilityHelper.onUpdate(closure_1, self._scrollMetrics.offset, self._scrollMetrics.visibleLength, self._listMetrics, self._createViewToken, viewabilityHelper.onViewableItemsChanged, closure_0);
        });
      }
    }
  }
];
obj = {
  key: "_findItemIndexWithKey",
  value: function _findItemIndexWithKey(getItemCount, firstVisibleItemKey, index) {
    const itemCount = getItemCount.getItemCount(getItemCount.data);
    if (null != index) {
      if (index >= 0) {
        if (index < itemCount) {
          if (VirtualizedList._getItemKey(getItemCount, index) === firstVisibleItemKey) {
            return index;
          }
        }
      }
    }
    let num2 = 0;
    if (0 < itemCount) {
      while (VirtualizedList._getItemKey(getItemCount, num2) !== firstVisibleItemKey) {
        num2 = num2 + 1;
      }
      return num2;
    }
    return null;
  }
};
let items1 = [
  obj,
  {
    key: "_getItemKey",
    value: function _getItemKey(props, index) {
      return VirtualizedList._keyExtractor(props.getItem(props.data, index), index, props);
    }
  },
  {
    key: "_createRenderMask",
    value: function _createRenderMask(getItemCount, _initialRenderRegionResult, closure_0) {
      const itemCount = getItemCount.getItemCount(getItemCount.data);
      let tmp4 = _initialRenderRegionResult.first >= 0;
      if (tmp4) {
        tmp4 = _initialRenderRegionResult.last >= _initialRenderRegionResult.first - 1;
      }
      if (tmp4) {
        tmp4 = _initialRenderRegionResult.last < itemCount;
      }
      importDefault(38)(tmp4, "Invalid cells around viewport \"[" + _initialRenderRegionResult.first + ", " + _initialRenderRegionResult.last + "]\" was passed to VirtualizedList._createRenderMask");
      const cellRenderMask = new VirtualizedList(324).CellRenderMask(itemCount);
      if (itemCount > 0) {
        let items1 = closure_0;
        const items = [_initialRenderRegionResult];
        if (closure_0 == null) {
          items1 = [];
        }
        HermesBuiltin.arraySpread(items1, 1);
        for (const item10045 of items) {
          let addCellsResult = cellRenderMask.addCells(item10045);
          continue;
        }
        if (null == getItemCount.initialScrollIndex) {
          cellRenderMask.addCells(VirtualizedList._initialRenderRegion(getItemCount));
        }
        const _Set = Set;
        const set = new Set(getItemCount.stickyHeaderIndices);
        const result = VirtualizedList._ensureClosestStickyHeader(getItemCount, set, tmp6, _initialRenderRegionResult.first);
      }
      return cellRenderMask;
    }
  },
  {
    key: "_initialRenderRegion",
    value: function _initialRenderRegion(getItemCount) {
      const itemCount = getItemCount.getItemCount(getItemCount.data);
      let num = getItemCount.initialScrollIndex;
      const diff = itemCount - 1;
      if (num == null) {
        num = 0;
      }
      const bound = Math.max(0, Math.min(diff, Math.floor(num)));
      const obj = { first: bound, last: null };
      obj[1] = Math.min(itemCount, bound + VirtualizedList(320).initialNumToRenderOrDefault(getItemCount.initialNumToRender)) - 1;
      return obj;
    }
  },
  {
    key: "_ensureClosestStickyHeader",
    value: function _ensureClosestStickyHeader(ListHeaderComponent, set, addCells, first) {
      let num = 0;
      if (ListHeaderComponent.ListHeaderComponent) {
        num = 1;
      }
      let diff = first - 1;
      if (0 <= diff) {
        while (!set.has(diff + num)) {
          diff = diff - 1;
        }
        const obj = { first: null, last: null };
        obj[0] = diff;
        obj[1] = diff;
        addCells.addCells(obj);
      }
    }
  },
  {
    key: "getDerivedStateFromProps",
    value: function getDerivedStateFromProps(getItemCount, renderMask) {
      const itemCount = getItemCount.getItemCount(getItemCount.data);
      renderMask = renderMask.renderMask;
      if (itemCount === renderMask.numCells()) {
        return renderMask;
      } else {
        const firstVisibleItemKey = renderMask.firstVisibleItemKey;
        const maintainVisibleContentPosition = getItemCount.maintainVisibleContentPosition;
        let num;
        if (maintainVisibleContentPosition != null) {
          num = maintainVisibleContentPosition.minIndexForVisible;
        }
        if (num == null) {
          num = 0;
        }
        let _getItemKeyResult = null;
        if (getItemCount.getItemCount(getItemCount.data) > num) {
          _getItemKeyResult = VirtualizedList._getItemKey(getItemCount, num);
        }
        let tmp4 = null;
        if (null != getItemCount.maintainVisibleContentPosition) {
          tmp4 = null;
          if (null != firstVisibleItemKey) {
            tmp4 = null;
            if (null != _getItemKeyResult) {
              tmp4 = null;
              if (_getItemKeyResult !== firstVisibleItemKey) {
                const renderMask2 = renderMask.renderMask;
                const result = VirtualizedList._findItemIndexWithKey(getItemCount, firstVisibleItemKey, itemCount - renderMask2.numCells() + num);
                let diff = null;
                if (null != result) {
                  diff = result - num;
                }
                tmp4 = diff;
              }
            }
          }
        }
        let obj = VirtualizedList;
        const cellsAroundViewport = renderMask.cellsAroundViewport;
        if (null != tmp4) {
          obj = { first: null, last: null };
          obj[0] = cellsAroundViewport.first + tmp4;
          obj[1] = renderMask.cellsAroundViewport.last + tmp4;
          let tmp9 = obj;
        } else {
          tmp9 = cellsAroundViewport;
        }
        const result1 = VirtualizedList._constrainToItemCount(tmp9, getItemCount);
        obj = { cellsAroundViewport: null, renderMask: null, firstVisibleItemKey: null, pendingScrollUpdateCount: null };
        obj[0] = result1;
        obj[1] = obj._createRenderMask(getItemCount, result1);
        obj[2] = _getItemKeyResult;
        const pendingScrollUpdateCount = renderMask.pendingScrollUpdateCount;
        if (null != tmp4) {
          let sum = pendingScrollUpdateCount + 1;
        } else {
          sum = pendingScrollUpdateCount;
        }
        obj[3] = sum;
        return obj;
      }
    }
  },
  {
    key: "_constrainToItemCount",
    value: function _constrainToItemCount(first, getItemCount) {
      const diff = getItemCount.getItemCount(getItemCount.data) - 1;
      let obj = VirtualizedList(320);
      obj = { first: null, last: null };
      const bound = Math.max(0, diff - obj.maxToRenderPerBatchOrDefault(getItemCount.maxToRenderPerBatch));
      obj[0] = importDefault(323)(0, first.first, bound);
      obj[1] = Math.min(diff, first.last);
      return obj;
    }
  },
  {
    key: "_keyExtractor",
    value: function _keyExtractor(value, sum, props) {
      if (null != props.keyExtractor) {
        return props.keyExtractor(value, sum);
      } else {
        const keyExtractorResult = VirtualizedList(313).keyExtractor(value, sum);
        const _String = String;
        if (keyExtractorResult === String(sum)) {
          let c21 = true;
          if (tmp5) {
            const displayName = value.type.displayName;
          }
          tmp5 = value.type && value.type.displayName;
        }
        return keyExtractorResult;
      }
    }
  }
];
const importDefaultResultResult = importDefaultResult(VirtualizedList, items, items1);
importDefaultResultResult.contextType = require("createContext").VirtualizedListContext;
let items2 = [{ scale: -1 }];
let items3 = [{ scaleX: -1 }];
const styles = StyleSheet.create({ verticallyInverted: { transform: items2 }, horizontallyInverted: { transform: items3 }, debug: { flex: 1 }, debugOverlayBase: { position: "absolute", top: 0, right: 0 }, debugOverlay: { bottom: 0, width: 20, borderColor: "blue", borderWidth: 1 }, debugOverlayFrame: { left: 0, backgroundColor: "orange" }, debugOverlayFrameLast: { left: 0, borderColor: "green", borderWidth: 2 }, debugOverlayFrameVis: { left: 0, borderColor: "red", borderWidth: 2 } });

export default importDefaultResultResult;