@hanzogui/react-native-web-lite 2.0.0

package/dist/cjs/vendor/react-native/ViewabilityHelper.cjs

@@ -0,0 +1,134 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var ViewabilityHelper_exports = {};
+__export(ViewabilityHelper_exports, {
+  ViewabilityHelper: () => ViewabilityHelper,
+  default: () => ViewabilityHelper_default
+});
+module.exports = __toCommonJS(ViewabilityHelper_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+class ViewabilityHelper {
+  _config;
+  _hasInteracted = !1;
+  _timers = /* @__PURE__ */new Set();
+  _viewableIndices = [];
+  _viewableItems = /* @__PURE__ */new Map();
+  constructor(config = {
+    viewAreaCoveragePercentThreshold: 0
+  }) {
+    this._config = config;
+  }
+  /**
+   * Cleanup, e.g. on unmount. Clears any pending timers.
+   */
+  dispose() {
+    this._timers.forEach(clearTimeout);
+  }
+  /**
+   * Determines which items are viewable based on the current metrics and config.
+   */
+  computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange) {
+    const itemCount = props.getItemCount(props.data),
+      {
+        itemVisiblePercentThreshold,
+        viewAreaCoveragePercentThreshold
+      } = this._config,
+      viewAreaMode = viewAreaCoveragePercentThreshold != null,
+      viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
+    (0, import_react_native_web_internals.invariant)(viewablePercentThreshold != null && itemVisiblePercentThreshold != null != (viewAreaCoveragePercentThreshold != null), "Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold");
+    const viewableIndices = [];
+    if (itemCount === 0) return viewableIndices;
+    let firstVisible = -1;
+    const {
+      first,
+      last
+    } = renderRange || {
+      first: 0,
+      last: itemCount - 1
+    };
+    if (last >= itemCount) return console.warn("Invalid render range computing viewability " + JSON.stringify({
+      renderRange,
+      itemCount
+    })), [];
+    for (let idx = first; idx <= last; idx++) {
+      const metrics = getFrameMetrics(idx, props);
+      if (!metrics) continue;
+      const top = metrics.offset - scrollOffset,
+        bottom = top + metrics.length;
+      if (top < viewportHeight && bottom > 0) firstVisible = idx, _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length) && viewableIndices.push(idx);else if (firstVisible >= 0) break;
+    }
+    return viewableIndices;
+  }
+  /**
+   * Figures out which items are viewable and how that has changed from before and calls
+   * `onViewableItemsChanged` as appropriate.
+   */
+  onUpdate(props, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged, renderRange) {
+    const itemCount = props.getItemCount(props.data);
+    if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0, props)) return;
+    let viewableIndices = [];
+    if (itemCount && (viewableIndices = this.computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange)), !(this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every((v, ii) => v === viewableIndices[ii]))) if (this._viewableIndices = viewableIndices, this._config.minimumViewTime) {
+      const handle = setTimeout(() => {
+        this._timers.delete(handle), this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+      }, this._config.minimumViewTime);
+      this._timers.add(handle);
+    } else this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+  }
+  resetViewableIndices() {
+    this._viewableIndices = [];
+  }
+  recordInteraction() {
+    this._hasInteracted = !0;
+  }
+  _onUpdateSync(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+    viewableIndicesToCheck = viewableIndicesToCheck.filter(ii => this._viewableIndices.includes(ii));
+    const prevItems = this._viewableItems,
+      nextItems = new Map(viewableIndicesToCheck.map(ii => {
+        const viewable = createViewToken(ii, !0, props);
+        return [viewable.key, viewable];
+      })),
+      changed = [];
+    for (const [key, viewable] of nextItems) prevItems.has(key) || changed.push(viewable);
+    for (const [key, viewable] of prevItems) nextItems.has(key) || changed.push({
+      ...viewable,
+      isViewable: !1
+    });
+    changed.length > 0 && (this._viewableItems = nextItems, onViewableItemsChanged({
+      viewableItems: Array.from(nextItems.values()),
+      changed
+    }));
+  }
+}
+function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
+  if (_isEntirelyVisible(top, bottom, viewportHeight)) return !0;
+  {
+    const pixels = _getPixelsVisible(top, bottom, viewportHeight);
+    return 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength) >= viewablePercentThreshold;
+  }
+}
+function _getPixelsVisible(top, bottom, viewportHeight) {
+  const visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
+  return Math.max(0, visibleHeight);
+}
+function _isEntirelyVisible(top, bottom, viewportHeight) {
+  return top >= 0 && bottom <= viewportHeight && bottom > top;
+}
+var ViewabilityHelper_default = ViewabilityHelper;

package/dist/cjs/vendor/react-native/VirtualizeUtils/index.cjs

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var VirtualizeUtils_exports = {};
+__export(VirtualizeUtils_exports, {
+  computeWindowedRenderLimits: () => computeWindowedRenderLimits,
+  elementsThatOverlapOffsets: () => elementsThatOverlapOffsets,
+  keyExtractor: () => keyExtractor,
+  newRangeCount: () => newRangeCount
+});
+module.exports = __toCommonJS(VirtualizeUtils_exports);
+function elementsThatOverlapOffsets(offsets, props, getFrameMetrics, zoomScale = 1) {
+  const itemCount = props.getItemCount(props.data),
+    result = [];
+  for (let offsetIndex = 0; offsetIndex < offsets.length; offsetIndex++) {
+    const currentOffset = offsets[offsetIndex];
+    let left = 0,
+      right = itemCount - 1;
+    for (; left <= right;) {
+      const mid = left + (right - left >>> 1),
+        frame = getFrameMetrics(mid, props),
+        scaledOffsetStart = frame.offset * zoomScale,
+        scaledOffsetEnd = (frame.offset + frame.length) * zoomScale;
+      if (mid === 0 && currentOffset < scaledOffsetStart || mid !== 0 && currentOffset <= scaledOffsetStart) right = mid - 1;else if (currentOffset > scaledOffsetEnd) left = mid + 1;else {
+        result[offsetIndex] = mid;
+        break;
+      }
+    }
+  }
+  return result;
+}
+function newRangeCount(prev, next) {
+  return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
+}
+function computeWindowedRenderLimits(props, maxToRenderPerBatch, windowSize, prev, getFrameMetricsApprox, scrollMetrics) {
+  const itemCount = props.getItemCount(props.data);
+  if (itemCount === 0) return {
+    first: 0,
+    last: -1
+  };
+  const {
+      offset,
+      velocity,
+      visibleLength,
+      zoomScale = 1
+    } = scrollMetrics,
+    visibleBegin = Math.max(0, offset),
+    visibleEnd = visibleBegin + visibleLength,
+    overscanLength = (windowSize - 1) * visibleLength,
+    leadFactor = 0.5,
+    fillPreference = velocity > 1 ? "after" : velocity < -1 ? "before" : "none",
+    overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength),
+    overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
+  if (getFrameMetricsApprox(itemCount - 1, props).offset * zoomScale < overscanBegin) return {
+    first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
+    last: itemCount - 1
+  };
+  let [overscanFirst, first, last, overscanLast] = elementsThatOverlapOffsets([overscanBegin, visibleBegin, visibleEnd, overscanEnd], props, getFrameMetricsApprox, zoomScale);
+  overscanFirst = overscanFirst ?? 0, first = first ?? Math.max(0, overscanFirst), overscanLast = overscanLast ?? itemCount - 1, last = last ?? Math.min(overscanLast, first + maxToRenderPerBatch - 1);
+  const visible = {
+    first,
+    last
+  };
+  let newCellCount = newRangeCount(prev, visible);
+  for (; !(first <= overscanFirst && last >= overscanLast);) {
+    const maxNewCells = newCellCount >= maxToRenderPerBatch,
+      firstWillAddMore = first <= prev.first || first > prev.last,
+      firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore),
+      lastWillAddMore = last >= prev.last || last < prev.first,
+      lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
+    if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) break;
+    firstShouldIncrement && !(fillPreference === "after" && lastShouldIncrement && lastWillAddMore) && (firstWillAddMore && newCellCount++, first--), lastShouldIncrement && !(fillPreference === "before" && firstShouldIncrement && firstWillAddMore) && (lastWillAddMore && newCellCount++, last++);
+  }
+  if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) throw new Error("Bad window calculation " + JSON.stringify({
+    first,
+    last,
+    itemCount,
+    overscanFirst,
+    overscanLast,
+    visible
+  }));
+  return {
+    first,
+    last
+  };
+}
+function keyExtractor(item, index) {
+  return typeof item == "object" && item?.key != null ? item.key : typeof item == "object" && item?.id != null ? item.id : String(index);
+}

package/dist/cjs/vendor/react-native/VirtualizedList/CellRenderMask.cjs

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var CellRenderMask_exports = {};
+__export(CellRenderMask_exports, {
+  CellRenderMask: () => CellRenderMask
+});
+module.exports = __toCommonJS(CellRenderMask_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+class CellRenderMask {
+  constructor(numCells) {
+    (0, import_react_native_web_internals.invariant)(numCells >= 0, "CellRenderMask must contain a non-negative number os cells"), this._numCells = numCells, numCells === 0 ? this._regions = [] : this._regions = [{
+      first: 0,
+      last: numCells - 1,
+      isSpacer: !0
+    }];
+  }
+  enumerateRegions() {
+    return this._regions;
+  }
+  addCells(cells) {
+    if ((0, import_react_native_web_internals.invariant)(cells.first >= 0 && cells.first < this._numCells && cells.last >= -1 && cells.last < this._numCells && cells.last >= cells.first - 1, "CellRenderMask.addCells called with invalid cell range"), cells.last < cells.first) return;
+    const [firstIntersect, firstIntersectIdx] = this._findRegion(cells.first),
+      [lastIntersect, lastIntersectIdx] = this._findRegion(cells.last);
+    if (firstIntersectIdx === lastIntersectIdx && !firstIntersect.isSpacer) return;
+    const newLeadRegion = [],
+      newTailRegion = [],
+      newMainRegion = {
+        ...cells,
+        isSpacer: !1
+      };
+    firstIntersect.first < newMainRegion.first && (firstIntersect.isSpacer ? newLeadRegion.push({
+      first: firstIntersect.first,
+      last: newMainRegion.first - 1,
+      isSpacer: !0
+    }) : newMainRegion.first = firstIntersect.first), lastIntersect.last > newMainRegion.last && (lastIntersect.isSpacer ? newTailRegion.push({
+      first: newMainRegion.last + 1,
+      last: lastIntersect.last,
+      isSpacer: !0
+    }) : newMainRegion.last = lastIntersect.last);
+    const replacementRegions = [...newLeadRegion, newMainRegion, ...newTailRegion],
+      numRegionsToDelete = lastIntersectIdx - firstIntersectIdx + 1;
+    this._regions.splice(firstIntersectIdx, numRegionsToDelete, ...replacementRegions);
+  }
+  numCells() {
+    return this._numCells;
+  }
+  equals(other) {
+    return this._numCells === other._numCells && this._regions.length === other._regions.length && this._regions.every((region, i) => region.first === other._regions[i].first && region.last === other._regions[i].last && region.isSpacer === other._regions[i].isSpacer);
+  }
+  _findRegion(cellIdx) {
+    let firstIdx = 0,
+      lastIdx = this._regions.length - 1;
+    for (; firstIdx <= lastIdx;) {
+      const middleIdx = Math.floor((firstIdx + lastIdx) / 2),
+        middleRegion = this._regions[middleIdx];
+      if (cellIdx >= middleRegion.first && cellIdx <= middleRegion.last) return [middleRegion, middleIdx];
+      cellIdx < middleRegion.first ? lastIdx = middleIdx - 1 : cellIdx > middleRegion.last && (firstIdx = middleIdx + 1);
+    }
+    (0, import_react_native_web_internals.invariant)(!1, `A region was not found containing cellIdx ${cellIdx}`);
+  }
+}

package/dist/cjs/vendor/react-native/VirtualizedList/ChildListCollection.cjs

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var ChildListCollection_exports = {};
+__export(ChildListCollection_exports, {
+  ChildListCollection: () => ChildListCollection,
+  default: () => ChildListCollection_default
+});
+module.exports = __toCommonJS(ChildListCollection_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+class ChildListCollection {
+  _cellKeyToChildren = /* @__PURE__ */new Map();
+  _childrenToCellKey = /* @__PURE__ */new Map();
+  add(list, cellKey) {
+    (0, import_react_native_web_internals.invariant)(!this._childrenToCellKey.has(list), "Trying to add already present child list");
+    const cellLists = this._cellKeyToChildren.get(cellKey) ?? /* @__PURE__ */new Set();
+    cellLists.add(list), this._cellKeyToChildren.set(cellKey, cellLists), this._childrenToCellKey.set(list, cellKey);
+  }
+  remove(list) {
+    const cellKey = this._childrenToCellKey.get(list);
+    (0, import_react_native_web_internals.invariant)(cellKey != null, "Trying to remove non-present child list"), this._childrenToCellKey.delete(list);
+    const cellLists = this._cellKeyToChildren.get(cellKey);
+    (0, import_react_native_web_internals.invariant)(cellLists, "_cellKeyToChildren should contain cellKey"), cellLists.delete(list), cellLists.size === 0 && this._cellKeyToChildren.delete(cellKey);
+  }
+  forEach(fn) {
+    for (const listSet of this._cellKeyToChildren.values()) for (const list of listSet) fn(list);
+  }
+  forEachInCell(cellKey, fn) {
+    const listSet = this._cellKeyToChildren.get(cellKey) ?? [];
+    for (const list of listSet) fn(list);
+  }
+  anyInCell(cellKey, fn) {
+    const listSet = this._cellKeyToChildren.get(cellKey) ?? [];
+    for (const list of listSet) if (fn(list)) return !0;
+    return !1;
+  }
+  size() {
+    return this._childrenToCellKey.size;
+  }
+}
+var ChildListCollection_default = ChildListCollection;

package/dist/cjs/vendor/react-native/VirtualizedList/StateSafePureComponent.cjs

@@ -0,0 +1,82 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var StateSafePureComponent_exports = {};
+__export(StateSafePureComponent_exports, {
+  StateSafePureComponent: () => StateSafePureComponent,
+  default: () => StateSafePureComponent_default
+});
+module.exports = __toCommonJS(StateSafePureComponent_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  React = __toESM(require("react"), 1);
+class StateSafePureComponent extends React.PureComponent {
+  _inAsyncStateUpdate = !1;
+  constructor(props) {
+    super(props), this._installSetStateHooks();
+  }
+  setState(partialState, callback) {
+    typeof partialState == "function" ? super.setState((state, props) => {
+      this._inAsyncStateUpdate = !0;
+      let ret;
+      try {
+        ret = partialState(state, props);
+      } catch (err) {
+        throw err;
+      } finally {
+        this._inAsyncStateUpdate = !1;
+      }
+      return ret;
+    }, callback) : super.setState(partialState, callback);
+  }
+  _installSetStateHooks() {
+    const that = this;
+    let {
+      props,
+      state
+    } = this;
+    Object.defineProperty(this, "props", {
+      get() {
+        return (0, import_react_native_web_internals.invariant)(!that._inAsyncStateUpdate, '"this.props" should not be accessed during state updates'), props;
+      },
+      set(newProps) {
+        props = newProps;
+      }
+    }), Object.defineProperty(this, "state", {
+      get() {
+        return (0, import_react_native_web_internals.invariant)(!that._inAsyncStateUpdate, '"this.state" should not be acceessed during state updates'), state;
+      },
+      set(newState) {
+        state = newState;
+      }
+    });
+  }
+}
+var StateSafePureComponent_default = StateSafePureComponent;

package/dist/cjs/vendor/react-native/VirtualizedList/VirtualizedListCellRenderer.cjs

@@ -0,0 +1,173 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var VirtualizedListCellRenderer_exports = {};
+__export(VirtualizedListCellRenderer_exports, {
+  CellRenderer: () => CellRenderer,
+  default: () => VirtualizedListCellRenderer_default
+});
+module.exports = __toCommonJS(VirtualizedListCellRenderer_exports);
+var import_View = require("../../../View/index.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  import_VirtualizedListContext = require("./VirtualizedListContext.cjs"),
+  React = __toESM(require("react"), 1),
+  import_jsx_runtime = require("react/jsx-runtime");
+class CellRenderer extends React.Component {
+  state = {
+    separatorProps: {
+      highlighted: !1,
+      leadingItem: this.props.item
+    }
+  };
+  static getDerivedStateFromProps(props, prevState) {
+    return {
+      separatorProps: {
+        ...prevState.separatorProps,
+        leadingItem: props.item
+      }
+    };
+  }
+  // TODO: consider factoring separator stuff out of VirtualizedList into FlatList since it's not
+  // reused by SectionList and we can keep VirtualizedList simpler.
+  // $FlowFixMe[missing-local-annot]
+  _separators = {
+    highlight: () => {
+      const {
+        cellKey,
+        prevCellKey
+      } = this.props;
+      this.props.onUpdateSeparators?.([cellKey, prevCellKey], {
+        highlighted: !0
+      });
+    },
+    unhighlight: () => {
+      const {
+        cellKey,
+        prevCellKey
+      } = this.props;
+      this.props.onUpdateSeparators?.([cellKey, prevCellKey], {
+        highlighted: !1
+      });
+    },
+    updateProps: (select, newProps) => {
+      const {
+        cellKey,
+        prevCellKey
+      } = this.props;
+      this.props.onUpdateSeparators?.([select === "leading" ? prevCellKey : cellKey], newProps);
+    }
+  };
+  updateSeparatorProps(newProps) {
+    this.setState(state => ({
+      separatorProps: {
+        ...state.separatorProps,
+        ...newProps
+      }
+    }));
+  }
+  componentWillUnmount() {
+    this.props.onUnmount?.(this.props.cellKey);
+  }
+  _onLayout = nativeEvent => {
+    this.props.onCellLayout?.(nativeEvent, this.props.cellKey, this.props.index);
+  };
+  _renderElement(renderItem, ListItemComponent, item, index) {
+    if (renderItem && ListItemComponent && console.warn("VirtualizedList: Both ListItemComponent and renderItem props are present. ListItemComponent will take precedence over renderItem."), ListItemComponent) return React.createElement(ListItemComponent, {
+      item,
+      index,
+      separators: this._separators
+    });
+    if (renderItem) return renderItem({
+      item,
+      index,
+      separators: this._separators
+    });
+    (0, import_react_native_web_internals.invariant)(!1, "VirtualizedList: Either ListItemComponent or renderItem props are required but none were found.");
+  }
+  render() {
+    const {
+        CellRendererComponent,
+        ItemSeparatorComponent,
+        ListItemComponent,
+        cellKey,
+        horizontal,
+        item,
+        index,
+        inversionStyle,
+        onCellFocusCapture,
+        onCellLayout,
+        renderItem
+      } = this.props,
+      element = this._renderElement(renderItem, ListItemComponent, item, index),
+      itemSeparator = React.isValidElement(ItemSeparatorComponent) ?
+      // $FlowFixMe[incompatible-type]
+      ItemSeparatorComponent :
+      // $FlowFixMe[incompatible-type]
+      ItemSeparatorComponent && /* @__PURE__ */(0, import_jsx_runtime.jsx)(ItemSeparatorComponent, {
+        ...this.state.separatorProps
+      }),
+      cellStyle = inversionStyle ? horizontal ? [styles.rowReverse, inversionStyle] : [styles.columnReverse, inversionStyle] : horizontal ? [styles.row, inversionStyle] : inversionStyle,
+      result = CellRendererComponent ? /* @__PURE__ */(0, import_jsx_runtime.jsxs)(CellRendererComponent, {
+        cellKey,
+        index,
+        item,
+        style: cellStyle,
+        onFocusCapture: onCellFocusCapture,
+        ...(onCellLayout && {
+          onLayout: this._onLayout
+        }),
+        children: [element, itemSeparator]
+      }) : /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_View.View, {
+        style: cellStyle,
+        onFocusCapture: onCellFocusCapture,
+        ...(onCellLayout && {
+          onLayout: this._onLayout
+        }),
+        children: [element, itemSeparator]
+      });
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_VirtualizedListContext.VirtualizedListCellContextProvider, {
+      cellKey: this.props.cellKey,
+      children: result
+    });
+  }
+}
+const styles = import_react_native_web_internals.StyleSheet.create({
+  row: {
+    flexDirection: "row"
+  },
+  rowReverse: {
+    flexDirection: "row-reverse"
+  },
+  columnReverse: {
+    flexDirection: "column-reverse"
+  }
+});
+var VirtualizedListCellRenderer_default = CellRenderer;