@legendapp/list 2.0.0-next.0 → 2.0.0-next.2

package/dist/index.js

@@ -0,0 +1,2525 @@
+'use strict';
+
+var React3 = require('react');
+var reactNative = require('react-native');
+var shim = require('use-sync-external-store/shim');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React3__namespace = /*#__PURE__*/_interopNamespace(React3);
+
+// src/LegendList.tsx
+var ContextState = React3__namespace.createContext(null);
+function StateProvider({ children }) {
+  const [value] = React3__namespace.useState(() => ({
+    listeners: /* @__PURE__ */ new Map(),
+    values: /* @__PURE__ */ new Map([
+      ["alignItemsPaddingTop", 0],
+      ["stylePaddingTop", 0],
+      ["headerSize", 0]
+    ]),
+    mapViewabilityCallbacks: /* @__PURE__ */ new Map(),
+    mapViewabilityValues: /* @__PURE__ */ new Map(),
+    mapViewabilityAmountCallbacks: /* @__PURE__ */ new Map(),
+    mapViewabilityAmountValues: /* @__PURE__ */ new Map(),
+    columnWrapperStyle: void 0,
+    viewRefs: /* @__PURE__ */ new Map()
+  }));
+  return /* @__PURE__ */ React3__namespace.createElement(ContextState.Provider, { value }, children);
+}
+function useStateContext() {
+  return React3__namespace.useContext(ContextState);
+}
+function createSelectorFunctionsArr(ctx, signalNames) {
+  let lastValues = [];
+  let lastSignalValues = [];
+  return {
+    subscribe: (cb) => {
+      const listeners = [];
+      for (const signalName of signalNames) {
+        listeners.push(listen$(ctx, signalName, cb));
+      }
+      return () => {
+        for (const listener of listeners) {
+          listener();
+        }
+      };
+    },
+    get: () => {
+      const currentValues = [];
+      let hasChanged = false;
+      for (let i = 0; i < signalNames.length; i++) {
+        const value = peek$(ctx, signalNames[i]);
+        currentValues.push(value);
+        if (value !== lastSignalValues[i]) {
+          hasChanged = true;
+        }
+      }
+      lastSignalValues = currentValues;
+      if (hasChanged) {
+        lastValues = currentValues;
+      }
+      return lastValues;
+    }
+  };
+}
+function listen$(ctx, signalName, cb) {
+  const { listeners } = ctx;
+  let setListeners = listeners.get(signalName);
+  if (!setListeners) {
+    setListeners = /* @__PURE__ */ new Set();
+    listeners.set(signalName, setListeners);
+  }
+  setListeners.add(cb);
+  return () => setListeners.delete(cb);
+}
+function peek$(ctx, signalName) {
+  const { values } = ctx;
+  return values.get(signalName);
+}
+function set$(ctx, signalName, value) {
+  const { listeners, values } = ctx;
+  if (values.get(signalName) !== value) {
+    values.set(signalName, value);
+    const setListeners = listeners.get(signalName);
+    if (setListeners) {
+      for (const listener of setListeners) {
+        listener(value);
+      }
+    }
+  }
+}
+function getContentSize(ctx) {
+  const { values } = ctx;
+  const stylePaddingTop = values.get("stylePaddingTop") || 0;
+  const headerSize = values.get("headerSize") || 0;
+  const footerSize = values.get("footerSize") || 0;
+  const totalSize = values.get("totalSize") || 0;
+  return headerSize + footerSize + totalSize + stylePaddingTop;
+}
+function useArr$(signalNames) {
+  const ctx = React3__namespace.useContext(ContextState);
+  const { subscribe, get } = React3__namespace.useMemo(() => createSelectorFunctionsArr(ctx, signalNames), [ctx, signalNames]);
+  const value = shim.useSyncExternalStore(subscribe, get);
+  return value;
+}
+function useSelector$(signalName, selector) {
+  const ctx = React3__namespace.useContext(ContextState);
+  const { subscribe, get } = React3__namespace.useMemo(() => createSelectorFunctionsArr(ctx, [signalName]), [ctx, signalName]);
+  const value = shim.useSyncExternalStore(subscribe, () => selector(get()[0]));
+  return value;
+}
+
+// src/DebugView.tsx
+var DebugRow = ({ children }) => {
+  return /* @__PURE__ */ React3__namespace.createElement(reactNative.View, { style: { flexDirection: "row", alignItems: "center", justifyContent: "space-between" } }, children);
+};
+var DebugView = React3__namespace.memo(function DebugView2({ state }) {
+  const ctx = useStateContext();
+  const [totalSize = 0, scrollAdjust = 0, rawScroll = 0, scroll = 0, numContainers = 0, numContainersPooled = 0] = useArr$([
+    "totalSize",
+    "scrollAdjust",
+    "debugRawScroll",
+    "debugComputedScroll",
+    "numContainers",
+    "numContainersPooled"
+  ]);
+  const contentSize = getContentSize(ctx);
+  const [, forceUpdate] = React3.useReducer((x) => x + 1, 0);
+  useInterval(() => {
+    forceUpdate();
+  }, 100);
+  return /* @__PURE__ */ React3__namespace.createElement(
+    reactNative.View,
+    {
+      style: {
+        position: "absolute",
+        top: 0,
+        right: 0,
+        paddingLeft: 4,
+        paddingBottom: 4,
+        // height: 100,
+        backgroundColor: "#FFFFFFCC",
+        padding: 4,
+        borderRadius: 4
+      },
+      pointerEvents: "none"
+    },
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "TotalSize:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, totalSize.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "ContentSize:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, contentSize.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "At end:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, String(state.isAtEnd))),
+    /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "ScrollAdjust:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, scrollAdjust.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "RawScroll: "), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, rawScroll.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "ComputedScroll: "), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, scroll.toFixed(2)))
+  );
+});
+function useInterval(callback, delay) {
+  React3.useEffect(() => {
+    const interval = setInterval(callback, delay);
+    return () => clearInterval(interval);
+  }, [delay]);
+}
+
+// src/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+function isArray(obj) {
+  return Array.isArray(obj);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnDevOnce(id, text) {
+  if (__DEV__ && !warned.has(id)) {
+    warned.add(id);
+    console.warn(`[legend-list] ${text}`);
+  }
+}
+function roundSize(size) {
+  return Math.floor(size * 8) / 8;
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function comparatorDefault(a, b) {
+  return a - b;
+}
+function getPadding(s, type) {
+  var _a, _b, _c;
+  return (_c = (_b = (_a = s[`padding${type}`]) != null ? _a : s.paddingVertical) != null ? _b : s.padding) != null ? _c : 0;
+}
+function extractPadding(style, contentContainerStyle, type) {
+  return getPadding(style, type) + getPadding(contentContainerStyle, type);
+}
+var symbolFirst = Symbol();
+function useInit(cb) {
+  const refValue = React3.useRef(symbolFirst);
+  if (refValue.current === symbolFirst) {
+    refValue.current = cb();
+  }
+  return refValue.current;
+}
+
+// src/ContextContainer.ts
+var ContextContainer = React3.createContext(null);
+function useViewability(callback, configId) {
+  const ctx = useStateContext();
+  const { containerId } = React3.useContext(ContextContainer);
+  const key = containerId + (configId != null ? configId : "");
+  useInit(() => {
+    const value = ctx.mapViewabilityValues.get(key);
+    if (value) {
+      callback(value);
+    }
+  });
+  ctx.mapViewabilityCallbacks.set(key, callback);
+  React3.useEffect(
+    () => () => {
+      ctx.mapViewabilityCallbacks.delete(key);
+    },
+    []
+  );
+}
+function useViewabilityAmount(callback) {
+  const ctx = useStateContext();
+  const { containerId } = React3.useContext(ContextContainer);
+  useInit(() => {
+    const value = ctx.mapViewabilityAmountValues.get(containerId);
+    if (value) {
+      callback(value);
+    }
+  });
+  ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
+  React3.useEffect(
+    () => () => {
+      ctx.mapViewabilityAmountCallbacks.delete(containerId);
+    },
+    []
+  );
+}
+function useRecyclingEffect(effect) {
+  const { index, value } = React3.useContext(ContextContainer);
+  const prevValues = React3.useRef({
+    prevIndex: void 0,
+    prevItem: void 0
+  });
+  React3.useEffect(() => {
+    let ret = void 0;
+    if (prevValues.current.prevIndex !== void 0 && prevValues.current.prevItem !== void 0) {
+      ret = effect({
+        index,
+        item: value,
+        prevIndex: prevValues.current.prevIndex,
+        prevItem: prevValues.current.prevItem
+      });
+    }
+    prevValues.current = {
+      prevIndex: index,
+      prevItem: value
+    };
+    return ret;
+  }, [index, value]);
+}
+function useRecyclingState(valueOrFun) {
+  const { index, value, itemKey, triggerLayout } = React3.useContext(ContextContainer);
+  const refState = React3.useRef({
+    itemKey: null,
+    value: null
+  });
+  const [_, setRenderNum] = React3.useState(0);
+  const state = refState.current;
+  if (state.itemKey !== itemKey) {
+    state.itemKey = itemKey;
+    state.value = isFunction(valueOrFun) ? valueOrFun({
+      index,
+      item: value,
+      prevIndex: void 0,
+      prevItem: void 0
+    }) : valueOrFun;
+  }
+  const setState = React3.useCallback(
+    (newState) => {
+      state.value = isFunction(newState) ? newState(state.value) : newState;
+      setRenderNum((v) => v + 1);
+      triggerLayout();
+    },
+    [triggerLayout, state]
+  );
+  return [state.value, setState];
+}
+function useIsLastItem() {
+  const { itemKey } = React3.useContext(ContextContainer);
+  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false);
+  return isLast;
+}
+function useListScrollSize() {
+  const [scrollSize] = useArr$(["scrollSize"]);
+  return scrollSize;
+}
+var LeanViewComponent = React3__namespace.forwardRef((props, ref) => {
+  return React3__namespace.createElement("RCTView", { ...props, ref });
+});
+LeanViewComponent.displayName = "RCTView";
+var LeanView = reactNative.Platform.OS === "android" || reactNative.Platform.OS === "ios" ? LeanViewComponent : reactNative.View;
+
+// src/Separator.tsx
+function Separator({ ItemSeparatorComponent, itemKey, leadingItem }) {
+  const [lastItemKeys] = useArr$(["lastItemKeys"]);
+  const isALastItem = lastItemKeys.includes(itemKey);
+  return isALastItem ? null : /* @__PURE__ */ React.createElement(ItemSeparatorComponent, { leadingItem });
+}
+
+// src/constants.ts
+var POSITION_OUT_OF_VIEW = -1e7;
+var ENABLE_DEVMODE = __DEV__ && false;
+var ENABLE_DEBUG_VIEW = __DEV__ && false;
+var IsNewArchitecture = global.nativeFabricUIManager != null;
+
+// src/Container.tsx
+var Container = ({
+  id,
+  recycleItems,
+  horizontal,
+  getRenderedItem: getRenderedItem2,
+  updateItemSize: updateItemSize2,
+  ItemSeparatorComponent
+}) => {
+  const ctx = useStateContext();
+  const columnWrapperStyle = ctx.columnWrapperStyle;
+  const [column = 0, data, itemKey, position = POSITION_OUT_OF_VIEW, numColumns, extraData] = useArr$([
+    `containerColumn${id}`,
+    `containerItemData${id}`,
+    `containerItemKey${id}`,
+    `containerPosition${id}`,
+    "numColumns",
+    "extraData"
+  ]);
+  const refLastSize = React3.useRef();
+  const ref = React3.useRef(null);
+  const [layoutRenderCount, forceLayoutRender] = React3.useState(0);
+  const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
+  const otherAxisSize = numColumns > 1 ? `${1 / numColumns * 100}%` : void 0;
+  let didLayout = false;
+  let paddingStyles;
+  if (columnWrapperStyle) {
+    const { columnGap, rowGap, gap } = columnWrapperStyle;
+    if (horizontal) {
+      paddingStyles = {
+        paddingRight: columnGap || gap || void 0,
+        paddingVertical: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0
+      };
+    } else {
+      paddingStyles = {
+        paddingBottom: rowGap || gap || void 0,
+        paddingHorizontal: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0
+      };
+    }
+  }
+  const style = horizontal ? {
+    flexDirection: ItemSeparatorComponent ? "row" : void 0,
+    position: "absolute",
+    top: otherAxisPos,
+    height: otherAxisSize,
+    left: position,
+    ...paddingStyles || {}
+  } : {
+    position: "absolute",
+    left: otherAxisPos,
+    right: numColumns > 1 ? null : 0,
+    width: otherAxisSize,
+    top: position,
+    ...paddingStyles || {}
+  };
+  const renderedItemInfo = React3.useMemo(
+    () => itemKey !== void 0 ? getRenderedItem2(itemKey) : null,
+    [itemKey, data, extraData]
+  );
+  const { index, renderedItem } = renderedItemInfo || {};
+  const triggerLayout = React3.useCallback(() => {
+    forceLayoutRender((v) => v + 1);
+  }, []);
+  const contextValue = React3.useMemo(() => {
+    ctx.viewRefs.set(id, ref);
+    return { containerId: id, itemKey, index, value: data, triggerLayout };
+  }, [id, itemKey, index, data]);
+  const onLayout = (event) => {
+    var _a, _b;
+    if (!isNullOrUndefined(itemKey)) {
+      didLayout = true;
+      let layout = event.nativeEvent.layout;
+      const size = layout[horizontal ? "width" : "height"];
+      const doUpdate = () => {
+        refLastSize.current = { width: layout.width, height: layout.height };
+        updateItemSize2(itemKey, layout);
+      };
+      if (IsNewArchitecture || size > 0) {
+        doUpdate();
+      } else {
+        (_b = (_a = ref.current) == null ? void 0 : _a.measure) == null ? void 0 : _b.call(_a, (x, y, width, height) => {
+          layout = { width, height };
+          doUpdate();
+        });
+      }
+    }
+  };
+  if (IsNewArchitecture) {
+    React3.useLayoutEffect(() => {
+      var _a, _b;
+      if (!isNullOrUndefined(itemKey)) {
+        const measured = (_b = (_a = ref.current) == null ? void 0 : _a.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a);
+        if (measured) {
+          const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
+          if (size) {
+            updateItemSize2(itemKey, measured);
+          }
+        }
+      }
+    }, [itemKey, layoutRenderCount]);
+  } else {
+    React3.useEffect(() => {
+      if (!isNullOrUndefined(itemKey)) {
+        const timeout = setTimeout(() => {
+          if (!didLayout && refLastSize.current) {
+            updateItemSize2(itemKey, refLastSize.current);
+          }
+        }, 16);
+        return () => {
+          clearTimeout(timeout);
+        };
+      }
+    }, [itemKey]);
+  }
+  return /* @__PURE__ */ React3__namespace.createElement(LeanView, { style, onLayout, ref, key: recycleItems ? void 0 : itemKey }, /* @__PURE__ */ React3__namespace.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React3__namespace.createElement(
+    Separator,
+    {
+      itemKey,
+      ItemSeparatorComponent,
+      leadingItem: renderedItemInfo.item
+    }
+  )));
+};
+var typedForwardRef = React3.forwardRef;
+var typedMemo = React3.memo;
+var useAnimatedValue = (initialValue) => {
+  return React3.useRef(new reactNative.Animated.Value(initialValue)).current;
+};
+
+// src/useValue$.ts
+function useValue$(key, params) {
+  var _a;
+  const { getValue, delay } = params || {};
+  const ctx = useStateContext();
+  const animValue = useAnimatedValue((_a = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a : 0);
+  React3.useMemo(() => {
+    let newValue = void 0;
+    let prevValue = void 0;
+    let didQueueTask = false;
+    listen$(ctx, key, (v) => {
+      newValue = getValue ? getValue(v) : v;
+      if (delay !== void 0) {
+        const fn = () => {
+          didQueueTask = false;
+          if (newValue !== void 0) {
+            animValue.setValue(newValue);
+          }
+        };
+        const delayValue = typeof delay === "function" ? delay(newValue, prevValue) : delay;
+        prevValue = newValue;
+        if (!didQueueTask) {
+          didQueueTask = true;
+          if (delayValue === 0) {
+            queueMicrotask(fn);
+          } else {
+            setTimeout(fn, delayValue);
+          }
+        }
+      } else {
+        animValue.setValue(newValue);
+      }
+    });
+  }, []);
+  return animValue;
+}
+
+// src/Containers.tsx
+var Containers = typedMemo(function Containers2({
+  horizontal,
+  recycleItems,
+  ItemSeparatorComponent,
+  waitForInitialLayout,
+  updateItemSize: updateItemSize2,
+  getRenderedItem: getRenderedItem2
+}) {
+  const ctx = useStateContext();
+  const columnWrapperStyle = ctx.columnWrapperStyle;
+  const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
+  const animSize = useValue$("totalSize", {
+    // Use a microtask if increasing the size significantly, otherwise use a timeout
+    delay: (value, prevValue) => !prevValue || value - prevValue > 20 ? 0 : 200
+  });
+  const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("containersDidLayout", { getValue: (value) => value ? 1 : 0 }) : void 0;
+  const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
+  const containers = [];
+  for (let i = 0; i < numContainers; i++) {
+    containers.push(
+      /* @__PURE__ */ React3__namespace.createElement(
+        Container,
+        {
+          id: i,
+          key: i,
+          recycleItems,
+          horizontal,
+          getRenderedItem: getRenderedItem2,
+          updateItemSize: updateItemSize2,
+          ItemSeparatorComponent
+        }
+      )
+    );
+  }
+  const style = horizontal ? { width: animSize, opacity: animOpacity, minHeight: otherAxisSize } : { height: animSize, opacity: animOpacity, minWidth: otherAxisSize };
+  if (columnWrapperStyle && numColumns > 1) {
+    const { columnGap, rowGap, gap } = columnWrapperStyle;
+    const gapX = columnGap || gap || 0;
+    const gapY = rowGap || gap || 0;
+    if (horizontal) {
+      if (gapY) {
+        style.marginVertical = -gapY / 2;
+      }
+      if (gapX) {
+        style.marginRight = -gapX;
+      }
+    } else {
+      if (gapX) {
+        style.marginHorizontal = -gapX;
+      }
+      if (gapY) {
+        style.marginBottom = -gapY;
+      }
+    }
+  }
+  return /* @__PURE__ */ React3__namespace.createElement(reactNative.Animated.View, { style }, containers);
+});
+function ScrollAdjust() {
+  const bias = 1e7;
+  const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
+  const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
+  return /* @__PURE__ */ React3__namespace.createElement(
+    reactNative.View,
+    {
+      style: {
+        position: "absolute",
+        height: 0,
+        width: 0,
+        top: scrollOffset,
+        left: 0
+      }
+    }
+  );
+}
+function useSyncLayout({
+  onChange
+}) {
+  const ref = React3.useRef(null);
+  const onLayout = React3.useCallback(
+    (event) => {
+      onChange(event.nativeEvent.layout, false);
+    },
+    [onChange]
+  );
+  React3.useLayoutEffect(() => {
+    if (ref.current) {
+      ref.current.measure((x, y, width, height) => {
+        onChange({ x, y, width, height }, true);
+      });
+    }
+  }, []);
+  return { onLayout, ref };
+}
+
+// src/ListComponent.tsx
+var getComponent = (Component) => {
+  if (React3__namespace.isValidElement(Component)) {
+    return Component;
+  }
+  if (Component) {
+    return /* @__PURE__ */ React3__namespace.createElement(Component, null);
+  }
+  return null;
+};
+var Padding = () => {
+  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
+  return /* @__PURE__ */ React3__namespace.createElement(reactNative.Animated.View, { style: { paddingTop: animPaddingTop } });
+};
+var PaddingDevMode = () => {
+  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
+  return /* @__PURE__ */ React3__namespace.createElement(React3__namespace.Fragment, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React3__namespace.createElement(
+    reactNative.Animated.View,
+    {
+      style: {
+        position: "absolute",
+        top: 0,
+        height: animPaddingTop,
+        left: 0,
+        right: 0,
+        backgroundColor: "green"
+      }
+    }
+  ));
+};
+var ListComponent = typedMemo(function ListComponent2({
+  canRender,
+  style,
+  contentContainerStyle,
+  horizontal,
+  initialContentOffset,
+  recycleItems,
+  ItemSeparatorComponent,
+  alignItemsAtEnd,
+  waitForInitialLayout,
+  onScroll: onScroll2,
+  onLayout,
+  ListHeaderComponent,
+  ListHeaderComponentStyle,
+  ListFooterComponent,
+  ListFooterComponentStyle,
+  ListEmptyComponent,
+  getRenderedItem: getRenderedItem2,
+  updateItemSize: updateItemSize2,
+  refScrollView,
+  maintainVisibleContentPosition,
+  renderScrollComponent,
+  scrollAdjustHandler,
+  onLayoutHeader,
+  ...rest
+}) {
+  const ctx = useStateContext();
+  const { onLayout: onLayoutHeaderSync, ref: refHeader } = useSyncLayout({
+    onChange: onLayoutHeader
+  });
+  const ScrollComponent = renderScrollComponent ? React3.useMemo(
+    () => React3__namespace.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
+    [renderScrollComponent]
+  ) : reactNative.ScrollView;
+  React3__namespace.useEffect(() => {
+    if (canRender) {
+      setTimeout(() => {
+        scrollAdjustHandler.setMounted();
+      }, 0);
+    }
+  }, [canRender]);
+  return /* @__PURE__ */ React3__namespace.createElement(
+    ScrollComponent,
+    {
+      ...rest,
+      style,
+      maintainVisibleContentPosition: maintainVisibleContentPosition && !ListEmptyComponent ? { minIndexForVisible: 0 } : void 0,
+      contentContainerStyle: [
+        contentContainerStyle,
+        horizontal ? {
+          height: "100%"
+        } : {}
+      ],
+      onScroll: onScroll2,
+      onLayout,
+      horizontal,
+      contentOffset: initialContentOffset ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
+      ref: refScrollView
+    },
+    maintainVisibleContentPosition && /* @__PURE__ */ React3__namespace.createElement(ScrollAdjust, null),
+    ENABLE_DEVMODE ? /* @__PURE__ */ React3__namespace.createElement(PaddingDevMode, null) : /* @__PURE__ */ React3__namespace.createElement(Padding, null),
+    ListHeaderComponent && /* @__PURE__ */ React3__namespace.createElement(reactNative.View, { style: ListHeaderComponentStyle, onLayout: onLayoutHeaderSync, ref: refHeader }, getComponent(ListHeaderComponent)),
+    ListEmptyComponent && getComponent(ListEmptyComponent),
+    canRender && /* @__PURE__ */ React3__namespace.createElement(
+      Containers,
+      {
+        horizontal,
+        recycleItems,
+        waitForInitialLayout,
+        getRenderedItem: getRenderedItem2,
+        ItemSeparatorComponent,
+        updateItemSize: updateItemSize2
+      }
+    ),
+    ListFooterComponent && /* @__PURE__ */ React3__namespace.createElement(
+      reactNative.View,
+      {
+        style: ListFooterComponentStyle,
+        onLayout: (event) => {
+          const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
+          set$(ctx, "footerSize", size);
+        }
+      },
+      getComponent(ListFooterComponent)
+    )
+  );
+});
+
+// src/ScrollAdjustHandler.ts
+var ScrollAdjustHandler = class {
+  constructor(ctx) {
+    this.appliedAdjust = 0;
+    this.mounted = false;
+    this.context = ctx;
+  }
+  requestAdjust(add) {
+    const oldAdjustTop = peek$(this.context, "scrollAdjust") || 0;
+    this.appliedAdjust = add + oldAdjustTop;
+    const set = () => set$(this.context, "scrollAdjust", this.appliedAdjust);
+    if (this.mounted) {
+      set();
+    } else {
+      requestAnimationFrame(set);
+    }
+  }
+  setMounted() {
+    this.mounted = true;
+  }
+};
+
+// src/getId.ts
+function getId(state, index) {
+  const { data, keyExtractor } = state.props;
+  if (!data) {
+    return "";
+  }
+  const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
+  const id = ret;
+  state.idCache.set(index, id);
+  return id;
+}
+
+// src/calculateOffsetForIndex.ts
+function calculateOffsetForIndex(ctx, state, index) {
+  let position = 0;
+  if (index !== void 0) {
+    position = (state == null ? void 0 : state.positions.get(getId(state, index))) || 0;
+  }
+  const paddingTop = peek$(ctx, "stylePaddingTop");
+  if (paddingTop) {
+    position += paddingTop;
+  }
+  const headerSize = peek$(ctx, "headerSize");
+  if (headerSize) {
+    position += headerSize;
+  }
+  return position;
+}
+
+// src/getItemSize.ts
+function getItemSize(state, key, index, data, useAverageSize) {
+  const {
+    sizesKnown,
+    sizes,
+    scrollingTo,
+    props: { estimatedItemSize, getEstimatedItemSize }
+  } = state;
+  const sizeKnown = sizesKnown.get(key);
+  if (sizeKnown !== void 0) {
+    return sizeKnown;
+  }
+  let size;
+  if (IsNewArchitecture && useAverageSize !== void 0 && sizeKnown === void 0 && !getEstimatedItemSize && !scrollingTo) {
+    size = useAverageSize;
+  }
+  if (size === void 0) {
+    size = sizes.get(key);
+    if (size !== void 0) {
+      return size;
+    }
+  }
+  if (size === void 0) {
+    size = getEstimatedItemSize ? getEstimatedItemSize(index, data) : estimatedItemSize;
+  }
+  sizes.set(key, size);
+  return size;
+}
+
+// src/calculateOffsetWithOffsetPosition.ts
+function calculateOffsetWithOffsetPosition(state, offsetParam, params) {
+  const { index, viewOffset, viewPosition } = params;
+  let offset = offsetParam;
+  if (viewOffset) {
+    offset -= viewOffset;
+  }
+  if (viewPosition !== void 0 && index !== void 0) {
+    offset -= viewPosition * (state.scrollLength - getItemSize(state, getId(state, index), index, state.props.data[index]));
+  }
+  return offset;
+}
+
+// src/checkAllSizesKnown.ts
+function checkAllSizesKnown(state) {
+  const { startBuffered, endBuffered, sizesKnown } = state;
+  if (endBuffered !== null) {
+    let areAllKnown = true;
+    for (let i = startBuffered; areAllKnown && i <= endBuffered; i++) {
+      const key = getId(state, i);
+      areAllKnown && (areAllKnown = sizesKnown.has(key));
+    }
+    return areAllKnown;
+  }
+  return false;
+}
+
+// src/findAvailableContainers.ts
+function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffered, pendingRemoval) {
+  const numContainers = peek$(ctx, "numContainers");
+  const result = [];
+  const availableContainers = [];
+  for (let u = 0; u < numContainers; u++) {
+    const key = peek$(ctx, `containerItemKey${u}`);
+    let isOk = key === void 0;
+    if (!isOk) {
+      const index = pendingRemoval.indexOf(u);
+      if (index !== -1) {
+        pendingRemoval.splice(index, 1);
+        isOk = true;
+      }
+    }
+    if (isOk) {
+      result.push(u);
+      if (result.length >= numNeeded) {
+        return result;
+      }
+    }
+  }
+  for (let u = 0; u < numContainers; u++) {
+    const key = peek$(ctx, `containerItemKey${u}`);
+    if (key === void 0) continue;
+    const index = state.indexByKey.get(key);
+    if (index < startBuffered) {
+      availableContainers.push({ index: u, distance: startBuffered - index });
+    } else if (index > endBuffered) {
+      availableContainers.push({ index: u, distance: index - endBuffered });
+    }
+  }
+  const remaining = numNeeded - result.length;
+  if (remaining > 0) {
+    if (availableContainers.length > 0) {
+      if (availableContainers.length > remaining) {
+        availableContainers.sort(comparatorByDistance);
+        availableContainers.length = remaining;
+      }
+      for (const container of availableContainers) {
+        result.push(container.index);
+      }
+    }
+    const stillNeeded = numNeeded - result.length;
+    if (stillNeeded > 0) {
+      for (let i = 0; i < stillNeeded; i++) {
+        result.push(numContainers + i);
+      }
+      if (__DEV__ && numContainers + stillNeeded > peek$(ctx, "numContainersPooled")) {
+        console.warn(
+          "[legend-list] No unused container available, so creating one on demand. This can be a minor performance issue and is likely caused by the estimatedItemSize being too large. Consider decreasing estimatedItemSize or increasing initialContainerPoolRatio.",
+          {
+            debugInfo: {
+              numContainers,
+              numNeeded,
+              stillNeeded,
+              numContainersPooled: peek$(ctx, "numContainersPooled")
+            }
+          }
+        );
+      }
+    }
+  }
+  return result.sort(comparatorDefault);
+}
+function comparatorByDistance(a, b) {
+  return b.distance - a.distance;
+}
+
+// src/getScrollVelocity.ts
+var getScrollVelocity = (state) => {
+  const { scrollHistory } = state;
+  let velocity = 0;
+  if (scrollHistory.length >= 1) {
+    const newest = scrollHistory[scrollHistory.length - 1];
+    let oldest;
+    let start = 0;
+    for (let i = 0; i < scrollHistory.length - 1; i++) {
+      const entry = scrollHistory[i];
+      const nextEntry = scrollHistory[i + 1];
+      if (i > 0) {
+        const prevEntry = scrollHistory[i - 1];
+        const prevDirection = entry.scroll - prevEntry.scroll;
+        const currentDirection = nextEntry.scroll - entry.scroll;
+        if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
+          start = i;
+          break;
+        }
+      }
+    }
+    for (let i = start; i < scrollHistory.length - 1; i++) {
+      const entry = scrollHistory[i];
+      if (newest.time - entry.time <= 1e3) {
+        oldest = entry;
+        break;
+      }
+    }
+    if (oldest) {
+      const scrollDiff = newest.scroll - oldest.scroll;
+      const timeDiff = newest.time - oldest.time;
+      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
+    }
+  }
+  return velocity;
+};
+
+// src/requestAdjust.ts
+function requestAdjust(ctx, state, positionDiff) {
+  if (Math.abs(positionDiff) > 0.1) {
+    const doit = () => {
+      state.scrollAdjustHandler.requestAdjust(positionDiff);
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const didLayout = peek$(ctx, "containersDidLayout");
+    if (didLayout) {
+      doit();
+      const threshold = state.scroll - positionDiff / 2;
+      if (!state.ignoreScrollFromMVCP) {
+        state.ignoreScrollFromMVCP = {};
+      }
+      if (positionDiff > 0) {
+        state.ignoreScrollFromMVCP.lt = threshold;
+      } else {
+        state.ignoreScrollFromMVCP.gt = threshold;
+      }
+      if (state.ignoreScrollFromMVCPTimeout) {
+        clearTimeout(state.ignoreScrollFromMVCPTimeout);
+      }
+      state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
+        state.ignoreScrollFromMVCP = void 0;
+      }, 100);
+    } else {
+      requestAnimationFrame(doit);
+    }
+  }
+}
+
+// src/prepareMVCP.ts
+function prepareMVCP(ctx, state) {
+  const {
+    positions,
+    scrollingTo,
+    props: { maintainVisibleContentPosition }
+  } = state;
+  let prevPosition;
+  let targetId;
+  let targetIndex;
+  const scrollTarget = scrollingTo == null ? void 0 : scrollingTo.index;
+  if (maintainVisibleContentPosition) {
+    const indexByKey = state.indexByKey;
+    if (scrollTarget !== void 0) {
+      targetId = getId(state, scrollTarget);
+      targetIndex = scrollTarget;
+    } else if (state.idsInView.length > 0 && peek$(ctx, "containersDidLayout")) {
+      targetId = state.idsInView.find((id) => indexByKey.get(id) !== void 0);
+      targetIndex = indexByKey.get(targetId);
+    }
+    if (targetId !== void 0 && targetIndex !== void 0) {
+      prevPosition = positions.get(targetId);
+    }
+  }
+  return () => {
+    if (targetId !== void 0 && prevPosition !== void 0) {
+      const newPosition = positions.get(targetId);
+      if (newPosition !== void 0) {
+        const positionDiff = newPosition - prevPosition;
+        if (Math.abs(positionDiff) > 0.1) {
+          requestAdjust(ctx, state, positionDiff);
+        }
+      }
+    }
+  };
+}
+
+// src/checkThreshold.ts
+var checkThreshold = (distance, atThreshold, threshold, isReached, isBlockedByTimer, onReached, blockTimer) => {
+  const distanceAbs = Math.abs(distance);
+  const isAtThreshold = atThreshold || distanceAbs < threshold;
+  if (!isReached && !isBlockedByTimer) {
+    if (isAtThreshold) {
+      onReached == null ? void 0 : onReached(distance);
+      blockTimer == null ? void 0 : blockTimer(true);
+      setTimeout(() => {
+        blockTimer == null ? void 0 : blockTimer(false);
+      }, 700);
+      return true;
+    }
+  } else {
+    if (distance >= 1.3 * threshold) {
+      return false;
+    }
+  }
+  return isReached;
+};
+
+// src/checkAtBottom.ts
+function checkAtBottom(ctx, state) {
+  if (!state) {
+    return;
+  }
+  const {
+    queuedInitialLayout,
+    scrollLength,
+    scroll,
+    maintainingScrollAtEnd,
+    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
+  } = state;
+  const contentSize = getContentSize(ctx);
+  if (contentSize > 0 && queuedInitialLayout && !maintainingScrollAtEnd) {
+    const distanceFromEnd = contentSize - scroll - scrollLength;
+    const isContentLess = contentSize < scrollLength;
+    state.isAtEnd = isContentLess || distanceFromEnd < scrollLength * maintainScrollAtEndThreshold;
+    state.isEndReached = checkThreshold(
+      distanceFromEnd,
+      isContentLess,
+      onEndReachedThreshold * scrollLength,
+      state.isEndReached,
+      state.endReachedBlockedByTimer,
+      (distance) => {
+        var _a, _b;
+        return (_b = (_a = state.props).onEndReached) == null ? void 0 : _b.call(_a, { distanceFromEnd: distance });
+      },
+      (block) => {
+        state.endReachedBlockedByTimer = block;
+      }
+    );
+  }
+}
+
+// src/finishScrollTo.ts
+var finishScrollTo = (state) => {
+  if (state) {
+    state.scrollingTo = void 0;
+    state.scrollHistory.length = 0;
+  }
+};
+
+// src/scrollTo.ts
+function scrollTo(state, params = {}) {
+  var _a;
+  const { animated } = params;
+  const {
+    refScroller,
+    props: { horizontal }
+  } = state;
+  const offset = calculateOffsetWithOffsetPosition(state, params.offset, params);
+  state.scrollHistory.length = 0;
+  state.scrollingTo = params;
+  state.scrollPending = offset;
+  (_a = refScroller.current) == null ? void 0 : _a.scrollTo({
+    x: horizontal ? offset : 0,
+    y: horizontal ? 0 : offset,
+    animated: !!animated
+  });
+  if (!animated) {
+    state.scroll = offset;
+    setTimeout(() => finishScrollTo(state), 100);
+  }
+}
+
+// src/scrollToIndex.ts
+function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, viewPosition }) {
+  if (index >= state.props.data.length) {
+    index = state.props.data.length - 1;
+  } else if (index < 0) {
+    index = 0;
+  }
+  const firstIndexOffset = calculateOffsetForIndex(ctx, state, index);
+  const isLast = index === state.props.data.length - 1;
+  if (isLast && viewPosition === void 0) {
+    viewPosition = 1;
+  }
+  const firstIndexScrollPostion = firstIndexOffset - viewOffset;
+  state.scrollForNextCalculateItemsInView = void 0;
+  scrollTo(state, {
+    offset: firstIndexScrollPostion,
+    animated,
+    index,
+    viewPosition: viewPosition != null ? viewPosition : 0,
+    viewOffset
+  });
+}
+
+// src/setDidLayout.ts
+function setDidLayout(ctx, state) {
+  const {
+    loadStartTime,
+    initialScroll,
+    props: { onLoad }
+  } = state;
+  state.queuedInitialLayout = true;
+  checkAtBottom(ctx, state);
+  if (!IsNewArchitecture && initialScroll) {
+    scrollToIndex(ctx, state, { ...initialScroll, animated: false });
+  }
+  set$(ctx, "containersDidLayout", true);
+  if (onLoad) {
+    onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
+  }
+}
+
+// src/setPaddingTop.ts
+function setPaddingTop(ctx, { stylePaddingTop, alignItemsPaddingTop }) {
+  if (stylePaddingTop !== void 0) {
+    const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
+    if (stylePaddingTop < prevStylePaddingTop) {
+      const prevTotalSize = peek$(ctx, "totalSize") || 0;
+      set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
+      setTimeout(() => {
+        set$(ctx, "totalSize", prevTotalSize);
+      }, 16);
+    }
+    set$(ctx, "stylePaddingTop", stylePaddingTop);
+  }
+  if (alignItemsPaddingTop !== void 0) {
+    set$(ctx, "alignItemsPaddingTop", alignItemsPaddingTop);
+  }
+}
+
+// src/updateAlignItemsPaddingTop.ts
+function updateAlignItemsPaddingTop(ctx, state) {
+  const {
+    scrollLength,
+    props: { alignItemsAtEnd, data }
+  } = state;
+  if (alignItemsAtEnd) {
+    let alignItemsPaddingTop = 0;
+    if ((data == null ? void 0 : data.length) > 0) {
+      const contentSize = getContentSize(ctx);
+      alignItemsPaddingTop = Math.max(0, Math.floor(scrollLength - contentSize));
+    }
+    setPaddingTop(ctx, { alignItemsPaddingTop });
+  }
+}
+
+// src/updateTotalSize.ts
+function updateTotalSize(ctx, state) {
+  const {
+    positions,
+    props: { data }
+  } = state;
+  if (data.length === 0) {
+    addTotalSize(ctx, state, null, 0);
+  } else {
+    const lastId = getId(state, data.length - 1);
+    if (lastId !== void 0) {
+      const lastPosition = positions.get(lastId);
+      if (lastPosition !== void 0) {
+        const lastSize = getItemSize(state, lastId, data.length - 1, data[data.length - 1]);
+        if (lastSize !== void 0) {
+          const totalSize = lastPosition + lastSize;
+          addTotalSize(ctx, state, null, totalSize);
+        }
+      }
+    }
+  }
+}
+function addTotalSize(ctx, state, key, add) {
+  const { alignItemsAtEnd } = state.props;
+  {
+    state.totalSize = add;
+  }
+  set$(ctx, "totalSize", state.totalSize);
+  if (alignItemsAtEnd) {
+    updateAlignItemsPaddingTop(ctx, state);
+  }
+}
+
+// src/updateAllPositions.ts
+function updateAllPositions(ctx, state, dataChanged) {
+  var _a, _b, _c, _d, _e;
+  const { averageSizes, columns, indexByKey, positions, firstFullyOnScreenIndex, idCache, sizesKnown } = state;
+  const data = state.props.data;
+  const numColumns = peek$(ctx, "numColumns");
+  const indexByKeyForChecking = __DEV__ ? /* @__PURE__ */ new Map() : void 0;
+  const scrollVelocity = getScrollVelocity(state);
+  if (dataChanged) {
+    indexByKey.clear();
+    idCache.clear();
+  }
+  const itemType = "";
+  let averageSize = (_a = averageSizes[itemType]) == null ? void 0 : _a.avg;
+  if (averageSize !== void 0) {
+    averageSize = roundSize(averageSize);
+  }
+  const shouldUseBackwards = !dataChanged && scrollVelocity < 0 && firstFullyOnScreenIndex > 5 && firstFullyOnScreenIndex < data.length;
+  if (shouldUseBackwards && firstFullyOnScreenIndex !== void 0) {
+    const anchorId = getId(state, firstFullyOnScreenIndex);
+    const anchorPosition = positions.get(anchorId);
+    if (anchorPosition !== void 0) {
+      let currentRowTop2 = anchorPosition;
+      let maxSizeInRow2 = 0;
+      let bailout = false;
+      for (let i = firstFullyOnScreenIndex - 1; i >= 0; i--) {
+        const id = (_b = idCache.get(i)) != null ? _b : getId(state, i);
+        const size = (_c = sizesKnown.get(id)) != null ? _c : getItemSize(state, id, i, data[i], averageSize);
+        const itemColumn = columns.get(id);
+        maxSizeInRow2 = Math.max(maxSizeInRow2, size);
+        if (itemColumn === 1) {
+          currentRowTop2 -= maxSizeInRow2;
+          maxSizeInRow2 = 0;
+        }
+        if (currentRowTop2 < -2e3) {
+          bailout = true;
+          break;
+        }
+        positions.set(id, currentRowTop2);
+      }
+      if (!bailout) {
+        updateTotalSize(ctx, state);
+        return;
+      }
+    }
+  }
+  let currentRowTop = 0;
+  let column = 1;
+  let maxSizeInRow = 0;
+  const hasColumns = numColumns > 1;
+  const needsIndexByKey = dataChanged || indexByKey.size === 0;
+  const dataLength = data.length;
+  for (let i = 0; i < dataLength; i++) {
+    const id = (_d = idCache.get(i)) != null ? _d : getId(state, i);
+    const size = (_e = sizesKnown.get(id)) != null ? _e : getItemSize(state, id, i, data[i], averageSize);
+    if (__DEV__ && needsIndexByKey) {
+      if (indexByKeyForChecking.has(id)) {
+        console.error(
+          `[legend-list] Error: Detected overlapping key (${id}) which causes missing items and gaps and other terrrible things. Check that keyExtractor returns unique values.`
+        );
+      }
+      indexByKeyForChecking.set(id, i);
+    }
+    positions.set(id, currentRowTop);
+    if (needsIndexByKey) {
+      indexByKey.set(id, i);
+    }
+    columns.set(id, column);
+    if (hasColumns) {
+      if (size > maxSizeInRow) {
+        maxSizeInRow = size;
+      }
+      column++;
+      if (column > numColumns) {
+        currentRowTop += maxSizeInRow;
+        column = 1;
+        maxSizeInRow = 0;
+      }
+    } else {
+      currentRowTop += size;
+    }
+  }
+  updateTotalSize(ctx, state);
+}
+
+// src/viewability.ts
+var mapViewabilityConfigCallbackPairs = /* @__PURE__ */ new Map();
+function setupViewability(props) {
+  let { viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged } = props;
+  if (viewabilityConfig || onViewableItemsChanged) {
+    viewabilityConfigCallbackPairs = [
+      ...viewabilityConfigCallbackPairs || [],
+      {
+        viewabilityConfig: viewabilityConfig || {
+          viewAreaCoveragePercentThreshold: 0
+        },
+        onViewableItemsChanged
+      }
+    ];
+  }
+  if (viewabilityConfigCallbackPairs) {
+    for (const pair of viewabilityConfigCallbackPairs) {
+      mapViewabilityConfigCallbackPairs.set(pair.viewabilityConfig.id, {
+        viewableItems: [],
+        start: -1,
+        end: -1,
+        previousStart: -1,
+        previousEnd: -1
+      });
+    }
+  }
+  return viewabilityConfigCallbackPairs;
+}
+function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollSize, start, end) {
+  for (const viewabilityConfigCallbackPair of viewabilityConfigCallbackPairs) {
+    const viewabilityState = mapViewabilityConfigCallbackPairs.get(
+      viewabilityConfigCallbackPair.viewabilityConfig.id
+    );
+    viewabilityState.start = start;
+    viewabilityState.end = end;
+    if (viewabilityConfigCallbackPair.viewabilityConfig.minimumViewTime) {
+      const timer = setTimeout(() => {
+        state.timeouts.delete(timer);
+        updateViewableItemsWithConfig(state.data, viewabilityConfigCallbackPair, state, ctx, scrollSize);
+      }, viewabilityConfigCallbackPair.viewabilityConfig.minimumViewTime);
+      state.timeouts.add(timer);
+    } else {
+      updateViewableItemsWithConfig(state.data, viewabilityConfigCallbackPair, state, ctx, scrollSize);
+    }
+  }
+}
+function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, state, ctx, scrollSize) {
+  const { viewabilityConfig, onViewableItemsChanged } = viewabilityConfigCallbackPair;
+  const configId = viewabilityConfig.id;
+  const viewabilityState = mapViewabilityConfigCallbackPairs.get(configId);
+  const { viewableItems: previousViewableItems, start, end } = viewabilityState;
+  const viewabilityTokens = /* @__PURE__ */ new Map();
+  for (const [containerId, value] of ctx.mapViewabilityAmountValues) {
+    viewabilityTokens.set(
+      containerId,
+      computeViewability(
+        state,
+        ctx,
+        viewabilityConfig,
+        containerId,
+        value.key,
+        scrollSize,
+        value.item,
+        value.index
+      )
+    );
+  }
+  const changed = [];
+  if (previousViewableItems) {
+    for (const viewToken of previousViewableItems) {
+      const containerId = findContainerId(ctx, viewToken.key);
+      if (!isViewable(
+        state,
+        ctx,
+        viewabilityConfig,
+        containerId,
+        viewToken.key,
+        scrollSize,
+        viewToken.item,
+        viewToken.index
+      )) {
+        viewToken.isViewable = false;
+        changed.push(viewToken);
+      }
+    }
+  }
+  const viewableItems = [];
+  for (let i = start; i <= end; i++) {
+    const item = data[i];
+    if (item) {
+      const key = getId(state, i);
+      const containerId = findContainerId(ctx, key);
+      if (isViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, i)) {
+        const viewToken = {
+          item,
+          key,
+          index: i,
+          isViewable: true,
+          containerId
+        };
+        viewableItems.push(viewToken);
+        if (!(previousViewableItems == null ? void 0 : previousViewableItems.find((v) => v.key === viewToken.key))) {
+          changed.push(viewToken);
+        }
+      }
+    }
+  }
+  Object.assign(viewabilityState, {
+    viewableItems,
+    previousStart: start,
+    previousEnd: end
+  });
+  if (changed.length > 0) {
+    viewabilityState.viewableItems = viewableItems;
+    for (let i = 0; i < changed.length; i++) {
+      const change = changed[i];
+      maybeUpdateViewabilityCallback(ctx, configId, change.containerId, change);
+    }
+    if (onViewableItemsChanged) {
+      onViewableItemsChanged({ viewableItems, changed });
+    }
+  }
+  for (const [containerId, value] of ctx.mapViewabilityAmountValues) {
+    if (value.sizeVisible < 0) {
+      ctx.mapViewabilityAmountValues.delete(containerId);
+    }
+  }
+}
+function computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
+  const { sizes, positions, scroll: scrollState } = state;
+  const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
+  const { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = viewabilityConfig;
+  const viewAreaMode = viewAreaCoveragePercentThreshold != null;
+  const viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
+  const scroll = scrollState - topPad;
+  const top = positions.get(key) - scroll;
+  const size = sizes.get(key) || 0;
+  const bottom = top + size;
+  const isEntirelyVisible = top >= 0 && bottom <= scrollSize && bottom > top;
+  const sizeVisible = isEntirelyVisible ? size : Math.min(bottom, scrollSize) - Math.max(top, 0);
+  const percentVisible = size ? isEntirelyVisible ? 100 : 100 * (sizeVisible / size) : 0;
+  const percentOfScroller = size ? 100 * (sizeVisible / scrollSize) : 0;
+  const percent = isEntirelyVisible ? 100 : viewAreaMode ? percentOfScroller : percentVisible;
+  const isViewable2 = percent >= viewablePercentThreshold;
+  const value = {
+    index,
+    isViewable: isViewable2,
+    item,
+    key,
+    percentVisible,
+    percentOfScroller,
+    sizeVisible,
+    size,
+    scrollSize,
+    containerId
+  };
+  if (JSON.stringify(value) !== JSON.stringify(ctx.mapViewabilityAmountValues.get(containerId))) {
+    ctx.mapViewabilityAmountValues.set(containerId, value);
+    const cb = ctx.mapViewabilityAmountCallbacks.get(containerId);
+    if (cb) {
+      cb(value);
+    }
+  }
+  return value;
+}
+function isViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
+  const value = ctx.mapViewabilityAmountValues.get(containerId) || computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index);
+  return value.isViewable;
+}
+function findContainerId(ctx, key) {
+  const numContainers = peek$(ctx, "numContainers");
+  for (let i = 0; i < numContainers; i++) {
+    const itemKey = peek$(ctx, `containerItemKey${i}`);
+    if (itemKey === key) {
+      return i;
+    }
+  }
+  return -1;
+}
+function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
+  const key = containerId + configId;
+  ctx.mapViewabilityValues.set(key, viewToken);
+  const cb = ctx.mapViewabilityCallbacks.get(key);
+  cb == null ? void 0 : cb(viewToken);
+}
+
+// src/calculateItemsInView.ts
+function calculateItemsInView(ctx, state, params = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const {
+    scrollLength,
+    startBufferedId: startBufferedIdOrig,
+    positions,
+    columns,
+    containerItemKeys,
+    idCache,
+    sizes,
+    indexByKey,
+    scrollForNextCalculateItemsInView,
+    enableScrollForNextCalculateItemsInView,
+    minIndexSizeChanged
+  } = state;
+  const data = state.props.data;
+  if (!data || scrollLength === 0) {
+    return;
+  }
+  const totalSize = peek$(ctx, "totalSize");
+  const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
+  const numColumns = peek$(ctx, "numColumns");
+  const previousScrollAdjust = 0;
+  const { dataChanged, doMVCP } = params;
+  const speed = getScrollVelocity(state);
+  if (doMVCP || dataChanged) {
+    const checkMVCP = doMVCP ? prepareMVCP(ctx, state) : void 0;
+    updateAllPositions(ctx, state, dataChanged);
+    checkMVCP == null ? void 0 : checkMVCP();
+  }
+  const scrollExtra = 0;
+  const { queuedInitialLayout } = state;
+  let { scroll: scrollState } = state;
+  const initialScroll = state.props.initialScroll;
+  if (!queuedInitialLayout && initialScroll) {
+    const updatedOffset = calculateOffsetWithOffsetPosition(
+      state,
+      calculateOffsetForIndex(ctx, state, initialScroll.index),
+      initialScroll
+    );
+    scrollState = updatedOffset;
+  }
+  const scrollAdjustPad = -previousScrollAdjust - topPad;
+  let scroll = scrollState + scrollExtra + scrollAdjustPad;
+  if (scroll + scrollLength > totalSize) {
+    scroll = totalSize - scrollLength;
+  }
+  if (ENABLE_DEBUG_VIEW) {
+    set$(ctx, "debugRawScroll", scrollState);
+    set$(ctx, "debugComputedScroll", scroll);
+  }
+  const scrollBuffer = state.props.scrollBuffer;
+  let scrollBufferTop = scrollBuffer;
+  let scrollBufferBottom = scrollBuffer;
+  if (speed > 0) {
+    scrollBufferTop = scrollBuffer * 0.5;
+    scrollBufferBottom = scrollBuffer * 1.5;
+  } else {
+    scrollBufferTop = scrollBuffer * 1.5;
+    scrollBufferBottom = scrollBuffer * 0.5;
+  }
+  const scrollTopBuffered = scroll - scrollBufferTop;
+  const scrollBottom = scroll + scrollLength;
+  const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
+  if (scrollForNextCalculateItemsInView) {
+    const { top, bottom } = scrollForNextCalculateItemsInView;
+    if (scrollTopBuffered > top && scrollBottomBuffered < bottom) {
+      return;
+    }
+  }
+  let startNoBuffer = null;
+  let startBuffered = null;
+  let startBufferedId = null;
+  let endNoBuffer = null;
+  let endBuffered = null;
+  let loopStart = startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
+  if (minIndexSizeChanged !== void 0) {
+    loopStart = Math.min(minIndexSizeChanged, loopStart);
+    state.minIndexSizeChanged = void 0;
+  }
+  for (let i = loopStart; i >= 0; i--) {
+    const id = (_a = idCache.get(i)) != null ? _a : getId(state, i);
+    const top = positions.get(id);
+    const size = (_b = sizes.get(id)) != null ? _b : getItemSize(state, id, i, data[i]);
+    const bottom = top + size;
+    if (bottom > scroll - scrollBuffer) {
+      loopStart = i;
+    } else {
+      break;
+    }
+  }
+  const loopStartMod = loopStart % numColumns;
+  if (loopStartMod > 0) {
+    loopStart -= loopStartMod;
+  }
+  let foundEnd = false;
+  let nextTop;
+  let nextBottom;
+  const prevNumContainers = ctx.values.get("numContainers");
+  let maxIndexRendered = 0;
+  for (let i = 0; i < prevNumContainers; i++) {
+    const key = peek$(ctx, `containerItemKey${i}`);
+    if (key !== void 0) {
+      const index = indexByKey.get(key);
+      maxIndexRendered = Math.max(maxIndexRendered, index);
+    }
+  }
+  let firstFullyOnScreenIndex;
+  const dataLength = data.length;
+  for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
+    const id = (_c = idCache.get(i)) != null ? _c : getId(state, i);
+    const size = (_d = sizes.get(id)) != null ? _d : getItemSize(state, id, i, data[i]);
+    const top = positions.get(id);
+    if (!foundEnd) {
+      if (startNoBuffer === null && top + size > scroll) {
+        startNoBuffer = i;
+      }
+      if (firstFullyOnScreenIndex === void 0 && top >= scroll - 10) {
+        firstFullyOnScreenIndex = i;
+      }
+      if (startBuffered === null && top + size > scrollTopBuffered) {
+        startBuffered = i;
+        startBufferedId = id;
+        nextTop = top;
+      }
+      if (startNoBuffer !== null) {
+        if (top <= scrollBottom) {
+          endNoBuffer = i;
+        }
+        if (top <= scrollBottomBuffered) {
+          endBuffered = i;
+          nextBottom = top + size;
+        } else {
+          foundEnd = true;
+        }
+      }
+    }
+  }
+  const idsInView = [];
+  for (let i = firstFullyOnScreenIndex; i <= endNoBuffer; i++) {
+    const id = (_e = idCache.get(i)) != null ? _e : getId(state, i);
+    idsInView.push(id);
+  }
+  Object.assign(state, {
+    startBuffered,
+    startBufferedId,
+    startNoBuffer,
+    endBuffered,
+    endNoBuffer,
+    idsInView,
+    firstFullyOnScreenIndex
+  });
+  if (enableScrollForNextCalculateItemsInView && nextTop !== void 0 && nextBottom !== void 0) {
+    state.scrollForNextCalculateItemsInView = nextTop !== void 0 && nextBottom !== void 0 ? {
+      top: nextTop,
+      bottom: nextBottom
+    } : void 0;
+  }
+  const numContainers = peek$(ctx, "numContainers");
+  const pendingRemoval = [];
+  if (dataChanged) {
+    for (let i = 0; i < numContainers; i++) {
+      const itemKey = peek$(ctx, `containerItemKey${i}`);
+      if (!state.props.keyExtractor || itemKey && indexByKey.get(itemKey) === void 0) {
+        pendingRemoval.push(i);
+      }
+    }
+  }
+  if (startBuffered !== null && endBuffered !== null) {
+    let numContainers2 = prevNumContainers;
+    const needNewContainers = [];
+    for (let i = startBuffered; i <= endBuffered; i++) {
+      const id = (_f = idCache.get(i)) != null ? _f : getId(state, i);
+      if (!containerItemKeys.has(id)) {
+        needNewContainers.push(i);
+      }
+    }
+    if (needNewContainers.length > 0) {
+      const availableContainers = findAvailableContainers(
+        ctx,
+        state,
+        needNewContainers.length,
+        startBuffered,
+        endBuffered,
+        pendingRemoval
+      );
+      for (let idx = 0; idx < needNewContainers.length; idx++) {
+        const i = needNewContainers[idx];
+        const containerIndex = availableContainers[idx];
+        const id = (_g = idCache.get(i)) != null ? _g : getId(state, i);
+        const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
+        if (oldKey && oldKey !== id) {
+          containerItemKeys.delete(oldKey);
+        }
+        set$(ctx, `containerItemKey${containerIndex}`, id);
+        set$(ctx, `containerItemData${containerIndex}`, data[i]);
+        containerItemKeys.add(id);
+        if (containerIndex >= numContainers2) {
+          numContainers2 = containerIndex + 1;
+        }
+      }
+      if (numContainers2 !== prevNumContainers) {
+        set$(ctx, "numContainers", numContainers2);
+        if (numContainers2 > peek$(ctx, "numContainersPooled")) {
+          set$(ctx, "numContainersPooled", Math.ceil(numContainers2 * 1.5));
+        }
+      }
+    }
+  }
+  for (let i = 0; i < numContainers; i++) {
+    const itemKey = peek$(ctx, `containerItemKey${i}`);
+    if (pendingRemoval.includes(i)) {
+      if (itemKey) {
+        containerItemKeys.delete(itemKey);
+      }
+      set$(ctx, `containerItemKey${i}`, void 0);
+      set$(ctx, `containerItemData${i}`, void 0);
+      set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
+      set$(ctx, `containerColumn${i}`, -1);
+    } else {
+      const itemIndex = indexByKey.get(itemKey);
+      const item = data[itemIndex];
+      if (item !== void 0) {
+        const id = (_h = idCache.get(itemIndex)) != null ? _h : getId(state, itemIndex);
+        const position = positions.get(id);
+        if (position === void 0) {
+          set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
+        } else {
+          const pos = positions.get(id);
+          const column = columns.get(id) || 1;
+          const prevPos = peek$(ctx, `containerPosition${i}`);
+          const prevColumn = peek$(ctx, `containerColumn${i}`);
+          const prevData = peek$(ctx, `containerItemData${i}`);
+          if (!prevPos || pos > POSITION_OUT_OF_VIEW && pos !== prevPos) {
+            set$(ctx, `containerPosition${i}`, pos);
+          }
+          if (column >= 0 && column !== prevColumn) {
+            set$(ctx, `containerColumn${i}`, column);
+          }
+          if (prevData !== item) {
+            set$(ctx, `containerItemData${i}`, data[itemIndex]);
+          }
+        }
+      }
+    }
+  }
+  if (!queuedInitialLayout && endBuffered !== null) {
+    if (checkAllSizesKnown(state)) {
+      setDidLayout(ctx, state);
+    }
+  }
+  if (state.props.viewabilityConfigCallbackPairs) {
+    updateViewableItems(
+      state,
+      ctx,
+      state.props.viewabilityConfigCallbackPairs,
+      scrollLength,
+      startNoBuffer,
+      endNoBuffer
+    );
+  }
+}
+
+// src/checkAtTop.ts
+function checkAtTop(state) {
+  if (!state) {
+    return;
+  }
+  const {
+    scrollLength,
+    scroll,
+    props: { onStartReachedThreshold }
+  } = state;
+  const distanceFromTop = scroll;
+  state.isAtStart = distanceFromTop <= 0;
+  state.isStartReached = checkThreshold(
+    distanceFromTop,
+    false,
+    onStartReachedThreshold * scrollLength,
+    state.isStartReached,
+    state.startReachedBlockedByTimer,
+    (distance) => {
+      var _a, _b;
+      return (_b = (_a = state.props).onStartReached) == null ? void 0 : _b.call(_a, { distanceFromStart: distance });
+    },
+    (block) => {
+      state.startReachedBlockedByTimer = block;
+    }
+  );
+}
+
+// src/createColumnWrapperStyle.ts
+function createColumnWrapperStyle(contentContainerStyle) {
+  const { gap, columnGap, rowGap } = contentContainerStyle;
+  if (gap || columnGap || rowGap) {
+    contentContainerStyle.gap = void 0;
+    contentContainerStyle.columnGap = void 0;
+    contentContainerStyle.rowGap = void 0;
+    return {
+      gap,
+      columnGap,
+      rowGap
+    };
+  }
+}
+
+// src/doInitialAllocateContainers.ts
+function doInitialAllocateContainers(ctx, state) {
+  const { scrollLength } = state;
+  const data = state.props.data;
+  if (scrollLength > 0 && data.length > 0 && !peek$(ctx, "numContainers")) {
+    const averageItemSize = state.props.getEstimatedItemSize ? state.props.getEstimatedItemSize(0, data[0]) : state.props.estimatedItemSize;
+    const Extra = 1.5;
+    const numContainers = Math.ceil(
+      (scrollLength + state.props.scrollBuffer * 2) / averageItemSize * state.props.numColumns * Extra
+    );
+    for (let i = 0; i < numContainers; i++) {
+      set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
+      set$(ctx, `containerColumn${i}`, -1);
+    }
+    set$(ctx, "numContainers", numContainers);
+    set$(ctx, "numContainersPooled", numContainers * state.props.initialContainerPoolRatio);
+    if (!IsNewArchitecture) {
+      if (state.props.initialScroll) {
+        requestAnimationFrame(() => {
+          calculateItemsInView(ctx, state);
+        });
+      } else {
+        calculateItemsInView(ctx, state);
+      }
+    }
+    return true;
+  }
+}
+
+// src/doMaintainScrollAtEnd.ts
+function doMaintainScrollAtEnd(ctx, state, animated) {
+  const {
+    refScroller,
+    props: { maintainScrollAtEnd }
+  } = state;
+  if ((state == null ? void 0 : state.isAtEnd) && maintainScrollAtEnd && peek$(ctx, "containersDidLayout")) {
+    const paddingTop = peek$(ctx, "alignItemsPaddingTop");
+    if (paddingTop > 0) {
+      state.scroll = 0;
+    }
+    requestAnimationFrame(() => {
+      var _a;
+      state.maintainingScrollAtEnd = true;
+      (_a = refScroller.current) == null ? void 0 : _a.scrollToEnd({
+        animated
+      });
+      setTimeout(
+        () => {
+          state.maintainingScrollAtEnd = false;
+        },
+        0
+      );
+    });
+    return true;
+  }
+}
+function getRenderedItem(ctx, state, key) {
+  if (!state) {
+    return null;
+  }
+  const {
+    indexByKey,
+    props: { data, renderItem: renderItem2 }
+  } = state;
+  const index = indexByKey.get(key);
+  if (index === void 0) {
+    return null;
+  }
+  let renderedItem = null;
+  if (renderItem2) {
+    const itemProps = {
+      item: data[index],
+      index,
+      extraData: peek$(ctx, "extraData")
+    };
+    renderedItem = React3__namespace.default.createElement(renderItem2, itemProps);
+  }
+  return { index, item: data[index], renderedItem };
+}
+
+// src/handleLayout.ts
+function handleLayout(ctx, state, layout, setCanRender) {
+  const { maintainScrollAtEnd } = state.props;
+  const scrollLength = layout[state.props.horizontal ? "width" : "height"];
+  const otherAxisSize = layout[state.props.horizontal ? "height" : "width"];
+  const needsCalculate = !state.lastLayout || scrollLength > state.scrollLength || state.lastLayout.x !== layout.x || state.lastLayout.y !== layout.y;
+  state.lastLayout = layout;
+  const didChange = scrollLength !== state.scrollLength;
+  const prevOtherAxisSize = state.otherAxisSize;
+  state.scrollLength = scrollLength;
+  state.otherAxisSize = otherAxisSize;
+  state.lastBatchingAction = Date.now();
+  state.scrollForNextCalculateItemsInView = void 0;
+  doInitialAllocateContainers(ctx, state);
+  if (needsCalculate) {
+    calculateItemsInView(ctx, state, { doMVCP: true });
+  }
+  if (didChange || otherAxisSize !== prevOtherAxisSize) {
+    set$(ctx, "scrollSize", { width: layout.width, height: layout.height });
+  }
+  if (maintainScrollAtEnd === true || maintainScrollAtEnd.onLayout) {
+    doMaintainScrollAtEnd(ctx, state, false);
+  }
+  updateAlignItemsPaddingTop(ctx, state);
+  checkAtBottom(ctx, state);
+  checkAtTop(state);
+  if (state) {
+    state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
+  }
+  if (__DEV__ && scrollLength === 0) {
+    warnDevOnce(
+      "height0",
+      `List ${state.props.horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
+    );
+  }
+  setCanRender(true);
+}
+
+// src/onScroll.ts
+function onScroll(ctx, state, event) {
+  var _a, _b, _c, _d, _e;
+  if (((_b = (_a = event.nativeEvent) == null ? void 0 : _a.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
+    return;
+  }
+  const newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
+  const ignoreScrollFromMVCP = state.ignoreScrollFromMVCP;
+  if (ignoreScrollFromMVCP && !state.scrollingTo) {
+    const { lt, gt } = ignoreScrollFromMVCP;
+    if (lt && newScroll < lt || gt && newScroll > gt) {
+      return;
+    }
+  }
+  state.scrollPending = newScroll;
+  updateScroll(ctx, state, newScroll);
+  (_e = (_d = state.props).onScroll) == null ? void 0 : _e.call(_d, event);
+}
+function updateScroll(ctx, state, newScroll) {
+  const scrollingTo = state.scrollingTo;
+  state.hasScrolled = true;
+  state.lastBatchingAction = Date.now();
+  const currentTime = performance.now();
+  if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
+    state.scrollHistory.push({ scroll: newScroll, time: currentTime });
+  }
+  if (state.scrollHistory.length > 5) {
+    state.scrollHistory.shift();
+  }
+  state.scrollPrev = state.scroll;
+  state.scrollPrevTime = state.scrollTime;
+  state.scroll = newScroll;
+  state.scrollTime = currentTime;
+  calculateItemsInView(ctx, state);
+  checkAtBottom(ctx, state);
+  checkAtTop(state);
+}
+
+// src/updateItemSize.ts
+function updateItemSizes(ctx, state, itemUpdates) {
+  var _a;
+  const {
+    props: {
+      horizontal,
+      maintainVisibleContentPosition,
+      suggestEstimatedItemSize,
+      onItemSizeChanged,
+      data,
+      maintainScrollAtEnd
+    }
+  } = state;
+  if (!data) return;
+  let needsRecalculate = false;
+  let shouldMaintainScrollAtEnd = false;
+  let minIndexSizeChanged;
+  let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
+  for (const { itemKey, sizeObj } of itemUpdates) {
+    const index = state.indexByKey.get(itemKey);
+    const prevSizeKnown = state.sizesKnown.get(itemKey);
+    const diff = updateOneItemSize(state, itemKey, sizeObj);
+    const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+    if (diff !== 0) {
+      minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+      if (((_a = state.scrollingTo) == null ? void 0 : _a.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index) {
+        requestAdjust(ctx, state, diff * state.scrollingTo.viewPosition);
+      }
+      const { startBuffered, endBuffered } = state;
+      needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
+      if (!needsRecalculate) {
+        const numContainers = ctx.values.get("numContainers");
+        for (let i = 0; i < numContainers; i++) {
+          if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
+            needsRecalculate = true;
+            break;
+          }
+        }
+      }
+      if (state.needsOtherAxisSize) {
+        const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
+        maxOtherAxisSize = Math.max(maxOtherAxisSize, otherAxisSize);
+      }
+      if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
+        shouldMaintainScrollAtEnd = true;
+      }
+      onItemSizeChanged == null ? void 0 : onItemSizeChanged({
+        size,
+        previous: size - diff,
+        index,
+        itemKey,
+        itemData: state.props.data[index]
+      });
+    }
+  }
+  if (minIndexSizeChanged !== void 0) {
+    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
+  }
+  if (__DEV__ && suggestEstimatedItemSize && minIndexSizeChanged !== void 0) {
+    if (state.timeoutSizeMessage) clearTimeout(state.timeoutSizeMessage);
+    state.timeoutSizeMessage = setTimeout(() => {
+      var _a2;
+      state.timeoutSizeMessage = void 0;
+      const num = state.sizesKnown.size;
+      const avg = (_a2 = state.averageSizes[""]) == null ? void 0 : _a2.avg;
+      console.warn(
+        `[legend-list] Based on the ${num} items rendered so far, the optimal estimated size is ${avg}.`
+      );
+    }, 1e3);
+  }
+  const cur = peek$(ctx, "otherAxisSize");
+  if (!cur || maxOtherAxisSize > cur) {
+    set$(ctx, "otherAxisSize", maxOtherAxisSize);
+  }
+  const containersDidLayout = peek$(ctx, "containersDidLayout");
+  if (containersDidLayout || checkAllSizesKnown(state)) {
+    if (needsRecalculate) {
+      state.scrollForNextCalculateItemsInView = void 0;
+      calculateItemsInView(ctx, state, { doMVCP: true });
+    }
+    if (shouldMaintainScrollAtEnd) {
+      if (maintainScrollAtEnd === true || maintainScrollAtEnd.onItemLayout) {
+        doMaintainScrollAtEnd(ctx, state, false);
+      }
+    }
+  }
+}
+function updateItemSize(ctx, state, itemKey, sizeObj) {
+  if (IsNewArchitecture) {
+    const { sizesKnown } = state;
+    const numContainers = ctx.values.get("numContainers");
+    const changes = [];
+    for (let i = 0; i < numContainers; i++) {
+      const containerItemKey = peek$(ctx, `containerItemKey${i}`);
+      if (itemKey === containerItemKey) {
+        changes.push({ itemKey, sizeObj });
+      } else if (!sizesKnown.has(containerItemKey) && containerItemKey !== void 0) {
+        const containerRef = ctx.viewRefs.get(i);
+        if (containerRef == null ? void 0 : containerRef.current) {
+          let measured;
+          containerRef.current.measure((x, y, width, height) => {
+            measured = { x, y, width, height };
+          });
+          if (measured) {
+            changes.push({ itemKey: containerItemKey, sizeObj: measured });
+          }
+        }
+      }
+    }
+    if (changes.length > 0) {
+      updateItemSizes(ctx, state, changes);
+    }
+  } else {
+    updateItemSizes(ctx, state, [{ itemKey, sizeObj }]);
+  }
+}
+function updateOneItemSize(state, itemKey, sizeObj) {
+  const {
+    sizes,
+    indexByKey,
+    sizesKnown,
+    averageSizes,
+    props: { data, horizontal }
+  } = state;
+  if (!data) return 0;
+  const index = indexByKey.get(itemKey);
+  const prevSize = getItemSize(state, itemKey, index, data);
+  const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+  sizesKnown.set(itemKey, size);
+  const itemType = "";
+  let averages = averageSizes[itemType];
+  if (!averages) {
+    averages = averageSizes[itemType] = { num: 0, avg: 0 };
+  }
+  averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
+  averages.num++;
+  if (!prevSize || Math.abs(prevSize - size) > 0.1) {
+    sizes.set(itemKey, size);
+    return size - prevSize;
+  }
+  return 0;
+}
+var useCombinedRef = (...refs) => {
+  const callback = React3.useCallback((element) => {
+    for (const ref of refs) {
+      if (!ref) {
+        continue;
+      }
+      if (isFunction(ref)) {
+        ref(element);
+      } else {
+        ref.current = element;
+      }
+    }
+  }, refs);
+  return callback;
+};
+
+// src/LegendList.tsx
+var DEFAULT_DRAW_DISTANCE = 250;
+var DEFAULT_ITEM_SIZE = 100;
+var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
+  return /* @__PURE__ */ React3__namespace.createElement(StateProvider, null, /* @__PURE__ */ React3__namespace.createElement(LegendListInner, { ...props, ref: forwardedRef }));
+});
+var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
+  var _a;
+  const {
+    data: dataProp = [],
+    initialScrollIndex: initialScrollIndexProp,
+    initialScrollOffset,
+    horizontal,
+    drawDistance = 250,
+    recycleItems = false,
+    onEndReachedThreshold = 0.5,
+    onStartReachedThreshold = 0.5,
+    maintainScrollAtEnd = false,
+    maintainScrollAtEndThreshold = 0.1,
+    alignItemsAtEnd = false,
+    maintainVisibleContentPosition = false,
+    onScroll: onScrollProp,
+    onMomentumScrollEnd,
+    numColumns: numColumnsProp = 1,
+    columnWrapperStyle,
+    keyExtractor: keyExtractorProp,
+    renderItem: renderItem2,
+    estimatedListSize,
+    estimatedItemSize: estimatedItemSizeProp,
+    getEstimatedItemSize,
+    suggestEstimatedItemSize,
+    ListHeaderComponent,
+    ListEmptyComponent,
+    onItemSizeChanged,
+    refScrollView,
+    waitForInitialLayout = true,
+    extraData,
+    contentContainerStyle: contentContainerStyleProp,
+    style: styleProp,
+    onLayout: onLayoutProp,
+    onRefresh,
+    refreshing,
+    progressViewOffset,
+    refreshControl,
+    initialContainerPoolRatio = 2,
+    viewabilityConfig,
+    viewabilityConfigCallbackPairs,
+    onViewableItemsChanged,
+    onStartReached,
+    onEndReached,
+    onLoad,
+    ...rest
+  } = props;
+  const [renderNum, setRenderNum] = React3.useState(0);
+  const initialScroll = typeof initialScrollIndexProp === "number" ? { index: initialScrollIndexProp } : initialScrollIndexProp;
+  const initialScrollIndex = initialScroll == null ? void 0 : initialScroll.index;
+  const [canRender, setCanRender] = React3__namespace.useState(!IsNewArchitecture);
+  const contentContainerStyle = { ...reactNative.StyleSheet.flatten(contentContainerStyleProp) };
+  const style = { ...reactNative.StyleSheet.flatten(styleProp) };
+  const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
+  const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
+  const ctx = useStateContext();
+  ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
+  const refScroller = React3.useRef(null);
+  const combinedRef = useCombinedRef(refScroller, refScrollView);
+  const estimatedItemSize = estimatedItemSizeProp != null ? estimatedItemSizeProp : DEFAULT_ITEM_SIZE;
+  const scrollBuffer = (drawDistance != null ? drawDistance : DEFAULT_DRAW_DISTANCE) || 1;
+  const keyExtractor = keyExtractorProp != null ? keyExtractorProp : (item, index) => index.toString();
+  const refState = React3.useRef();
+  if (!refState.current) {
+    const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { width: 0, height: 0 } : reactNative.Dimensions.get("window"))[horizontal ? "width" : "height"];
+    refState.current = {
+      sizes: /* @__PURE__ */ new Map(),
+      positions: /* @__PURE__ */ new Map(),
+      columns: /* @__PURE__ */ new Map(),
+      pendingAdjust: 0,
+      isStartReached: false,
+      isEndReached: false,
+      isAtEnd: false,
+      isAtStart: false,
+      scrollLength: initialScrollLength,
+      startBuffered: -1,
+      startNoBuffer: -1,
+      endBuffered: -1,
+      endNoBuffer: -1,
+      firstFullyOnScreenIndex: -1,
+      scroll: 0,
+      totalSize: 0,
+      timeouts: /* @__PURE__ */ new Set(),
+      viewabilityConfigCallbackPairs: void 0,
+      scrollAdjustHandler: new ScrollAdjustHandler(ctx),
+      nativeMarginTop: 0,
+      scrollPrev: 0,
+      scrollPrevTime: 0,
+      scrollTime: 0,
+      scrollPending: 0,
+      indexByKey: /* @__PURE__ */ new Map(),
+      scrollHistory: [],
+      sizesKnown: /* @__PURE__ */ new Map(),
+      timeoutSizeMessage: 0,
+      startReachedBlockedByTimer: false,
+      endReachedBlockedByTimer: false,
+      scrollForNextCalculateItemsInView: void 0,
+      enableScrollForNextCalculateItemsInView: true,
+      minIndexSizeChanged: 0,
+      queuedCalculateItemsInView: 0,
+      lastBatchingAction: Date.now(),
+      averageSizes: {},
+      idsInView: [],
+      containerItemKeys: /* @__PURE__ */ new Set(),
+      idCache: /* @__PURE__ */ new Map(),
+      props: {},
+      refScroller: void 0,
+      loadStartTime: Date.now(),
+      initialScroll,
+      lastLayout: void 0
+    };
+    set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
+    set$(ctx, "extraData", extraData);
+  }
+  const state = refState.current;
+  const isFirst = !state.props.renderItem;
+  const didDataChange = state.props.data !== dataProp;
+  state.props = {
+    alignItemsAtEnd,
+    data: dataProp,
+    estimatedItemSize,
+    maintainScrollAtEnd,
+    maintainScrollAtEndThreshold,
+    onEndReachedThreshold,
+    onStartReachedThreshold,
+    stylePaddingBottom: stylePaddingBottomState,
+    horizontal: !!horizontal,
+    maintainVisibleContentPosition,
+    onItemSizeChanged,
+    suggestEstimatedItemSize: !!suggestEstimatedItemSize,
+    keyExtractor,
+    onScroll: onScrollProp,
+    getEstimatedItemSize,
+    onStartReached,
+    onEndReached,
+    onLoad,
+    renderItem: renderItem2,
+    initialScroll,
+    scrollBuffer,
+    viewabilityConfigCallbackPairs: void 0,
+    numColumns: numColumnsProp,
+    initialContainerPoolRatio,
+    stylePaddingTop: stylePaddingTopState
+  };
+  state.refScroller = refScroller;
+  const checkResetContainers = (isFirst2) => {
+    const state2 = refState.current;
+    if (state2) {
+      state2.props.data = dataProp;
+      if (!isFirst2) {
+        calculateItemsInView(ctx, state2, { dataChanged: true, doMVCP: true });
+        const shouldMaintainScrollAtEnd = maintainScrollAtEnd === true || maintainScrollAtEnd.onDataChange;
+        const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx, state2, false);
+        if (!didMaintainScrollAtEnd && dataProp.length > state2.props.data.length) {
+          state2.isEndReached = false;
+        }
+        if (!didMaintainScrollAtEnd) {
+          checkAtTop(state2);
+          checkAtBottom(ctx, state2);
+        }
+      }
+    }
+  };
+  const memoizedLastItemKeys = React3.useMemo(() => {
+    if (!dataProp.length) return [];
+    return Array.from(
+      { length: Math.min(numColumnsProp, dataProp.length) },
+      (_, i) => getId(state, dataProp.length - 1 - i)
+    );
+  }, [dataProp, numColumnsProp]);
+  const initalizeStateVars = () => {
+    set$(ctx, "lastItemKeys", memoizedLastItemKeys);
+    set$(ctx, "numColumns", numColumnsProp);
+    const prevPaddingTop = peek$(ctx, "stylePaddingTop");
+    setPaddingTop(ctx, { stylePaddingTop: stylePaddingTopState });
+    refState.current.props.stylePaddingBottom = stylePaddingBottomState;
+    const paddingDiff = stylePaddingTopState - prevPaddingTop;
+    if (paddingDiff && prevPaddingTop !== void 0 && reactNative.Platform.OS === "ios") {
+      calculateItemsInView(ctx, state, { doMVCP: true });
+      requestAdjust(ctx, state, paddingDiff);
+    }
+  };
+  if (isFirst) {
+    initalizeStateVars();
+    updateAllPositions(ctx, state);
+  }
+  const initialContentOffset = React3.useMemo(() => {
+    const initialContentOffset2 = initialScrollOffset || calculateOffsetForIndex(ctx, state, initialScrollIndex);
+    refState.current.isStartReached = initialContentOffset2 < refState.current.scrollLength * onStartReachedThreshold;
+    if (initialContentOffset2 > 0) {
+      scrollTo(state, { offset: initialContentOffset2, animated: false, index: initialScrollIndex });
+    }
+    return initialContentOffset2;
+  }, [renderNum]);
+  if (isFirst || didDataChange || numColumnsProp !== peek$(ctx, "numColumns")) {
+    refState.current.lastBatchingAction = Date.now();
+    if (!keyExtractorProp && !isFirst && didDataChange) {
+      __DEV__ && warnDevOnce(
+        "keyExtractor",
+        "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
+      );
+      refState.current.sizes.clear();
+      refState.current.positions.clear();
+    }
+  }
+  React3.useLayoutEffect(() => {
+    if (IsNewArchitecture) {
+      let measured;
+      refScroller.current.measure((x, y, width, height) => {
+        measured = { x, y, width, height };
+      });
+      if (measured) {
+        const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
+        if (size) {
+          handleLayout(ctx, state, measured, setCanRender);
+        }
+      }
+    }
+    if (!isFirst) {
+      calculateItemsInView(ctx, state, { doMVCP: true });
+    }
+  }, [dataProp]);
+  const onLayoutHeader = React3.useCallback((rect, fromLayoutEffect) => {
+    const size = rect[horizontal ? "width" : "height"];
+    set$(ctx, "headerSize", size);
+    if (initialScroll) {
+      if (IsNewArchitecture && reactNative.Platform.OS !== "android") {
+        if (fromLayoutEffect) {
+          setRenderNum((v) => v + 1);
+        }
+      } else {
+        setTimeout(() => {
+          scrollToIndex(ctx, state, { ...initialScroll, animated: false });
+        }, 17);
+      }
+    }
+  }, []);
+  React3.useLayoutEffect(() => {
+    const didAllocateContainers = doInitialAllocateContainersCallback();
+    if (!didAllocateContainers) {
+      checkResetContainers(
+        /*isFirst*/
+        isFirst
+      );
+    }
+  }, [dataProp, numColumnsProp]);
+  React3.useLayoutEffect(() => {
+    set$(ctx, "extraData", extraData);
+  }, [extraData]);
+  React3.useLayoutEffect(initalizeStateVars, [
+    memoizedLastItemKeys.join(","),
+    numColumnsProp,
+    stylePaddingTopState,
+    stylePaddingBottomState
+  ]);
+  const doInitialAllocateContainersCallback = () => {
+    return doInitialAllocateContainers(ctx, state);
+  };
+  React3.useEffect(() => {
+    const viewability = setupViewability({
+      viewabilityConfig,
+      viewabilityConfigCallbackPairs,
+      onViewableItemsChanged
+    });
+    state.viewabilityConfigCallbackPairs = viewability;
+    state.props.viewabilityConfigCallbackPairs = viewability;
+    state.enableScrollForNextCalculateItemsInView = !viewability;
+  }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
+  if (!IsNewArchitecture) {
+    useInit(() => {
+      doInitialAllocateContainersCallback();
+    });
+  }
+  const onLayout = React3.useCallback((event) => {
+    const layout = event.nativeEvent.layout;
+    handleLayout(ctx, state, layout, setCanRender);
+    if (onLayoutProp) {
+      onLayoutProp(event);
+    }
+  }, []);
+  React3.useImperativeHandle(
+    forwardedRef,
+    () => {
+      const scrollIndexIntoView = (options) => {
+        const state2 = refState.current;
+        if (state2) {
+          const { index, ...rest2 } = options;
+          const { startNoBuffer, endNoBuffer } = state2;
+          if (index < startNoBuffer || index > endNoBuffer) {
+            const viewPosition = index < startNoBuffer ? 0 : 1;
+            scrollToIndex(ctx, state2, {
+              ...rest2,
+              viewPosition,
+              index
+            });
+          }
+        }
+      };
+      return {
+        flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
+        getNativeScrollRef: () => refScroller.current,
+        getScrollableNode: () => refScroller.current.getScrollableNode(),
+        getScrollResponder: () => refScroller.current.getScrollResponder(),
+        getState: () => {
+          const state2 = refState.current;
+          return state2 ? {
+            contentLength: state2.totalSize,
+            end: state2.endNoBuffer,
+            endBuffered: state2.endBuffered,
+            isAtEnd: state2.isAtEnd,
+            isAtStart: state2.isAtStart,
+            scroll: state2.scroll,
+            scrollLength: state2.scrollLength,
+            start: state2.startNoBuffer,
+            startBuffered: state2.startBuffered,
+            sizes: state2.sizesKnown,
+            sizeAtIndex: (index) => state2.sizesKnown.get(getId(state2, index))
+          } : {};
+        },
+        scrollIndexIntoView,
+        scrollItemIntoView: ({ item, ...props2 }) => {
+          const data = refState.current.props.data;
+          const index = data.indexOf(item);
+          if (index !== -1) {
+            scrollIndexIntoView({ index, ...props2 });
+          }
+        },
+        scrollToIndex: (params) => scrollToIndex(ctx, state, params),
+        scrollToItem: ({ item, ...props2 }) => {
+          const data = refState.current.props.data;
+          const index = data.indexOf(item);
+          if (index !== -1) {
+            scrollToIndex(ctx, state, { index, ...props2 });
+          }
+        },
+        scrollToOffset: (params) => scrollTo(state, params),
+        scrollToEnd: (options) => {
+          const data = refState.current.props.data;
+          const stylePaddingBottom = refState.current.props.stylePaddingBottom;
+          const index = data.length - 1;
+          if (index !== -1) {
+            const paddingBottom = stylePaddingBottom || 0;
+            const footerSize = peek$(ctx, "footerSize") || 0;
+            scrollToIndex(ctx, state, {
+              index,
+              viewPosition: 1,
+              viewOffset: -paddingBottom - footerSize,
+              ...options
+            });
+          }
+        },
+        setVisibleContentAnchorOffset: (value) => {
+          const val = typeof value === "function" ? value(peek$(ctx, "scrollAdjustUserOffset") || 0) : value;
+          set$(ctx, "scrollAdjustUserOffset", val);
+        }
+      };
+    },
+    []
+  );
+  if (reactNative.Platform.OS === "web") {
+    React3.useEffect(() => {
+      if (initialContentOffset) {
+        scrollTo(state, { offset: initialContentOffset, animated: false });
+      }
+    }, []);
+  }
+  const fns = React3.useMemo(
+    () => ({
+      updateItemSize: (itemKey, sizeObj) => updateItemSize(ctx, state, itemKey, sizeObj),
+      getRenderedItem: (key) => getRenderedItem(ctx, state, key),
+      onScroll: (event) => onScroll(ctx, state, event)
+    }),
+    []
+  );
+  return /* @__PURE__ */ React3__namespace.createElement(React3__namespace.Fragment, null, /* @__PURE__ */ React3__namespace.createElement(
+    ListComponent,
+    {
+      ...rest,
+      canRender,
+      horizontal,
+      refScrollView: combinedRef,
+      initialContentOffset,
+      getRenderedItem: fns.getRenderedItem,
+      updateItemSize: fns.updateItemSize,
+      onScroll: fns.onScroll,
+      onMomentumScrollEnd: (event) => {
+        requestAnimationFrame(() => {
+          finishScrollTo(refState.current);
+        });
+        if (onMomentumScrollEnd) {
+          onMomentumScrollEnd(event);
+        }
+      },
+      onLayout,
+      recycleItems,
+      alignItemsAtEnd,
+      ListEmptyComponent: dataProp.length === 0 ? ListEmptyComponent : void 0,
+      ListHeaderComponent,
+      maintainVisibleContentPosition,
+      scrollEventThrottle: reactNative.Platform.OS === "web" ? 16 : void 0,
+      waitForInitialLayout,
+      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React3__namespace.cloneElement(refreshControl, {
+        progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState
+      }) : refreshControl : onRefresh && /* @__PURE__ */ React3__namespace.createElement(
+        reactNative.RefreshControl,
+        {
+          refreshing: !!refreshing,
+          onRefresh,
+          progressViewOffset: (progressViewOffset || 0) + stylePaddingTopState
+        }
+      ),
+      style,
+      contentContainerStyle,
+      scrollAdjustHandler: (_a = refState.current) == null ? void 0 : _a.scrollAdjustHandler,
+      onLayoutHeader
+    }
+  ), __DEV__ && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React3__namespace.createElement(DebugView, { state: refState.current }));
+});
+var typedForwardRef2 = React3.forwardRef;
+var renderItem = ({ item }) => item;
+var LazyLegendList = typedForwardRef2(function LazyLegendList2(props, forwardedRef) {
+  const { LegendList: LegendListProp, children, ...rest } = props;
+  const LegendListComponent = LegendListProp != null ? LegendListProp : LegendList;
+  const data = (isArray(children) ? children : React3__namespace.Children.toArray(children)).flat(1);
+  return (
+    // @ts-expect-error TODO: Fix this type
+    /* @__PURE__ */ React3__namespace.createElement(LegendListComponent, { ...rest, data, renderItem, ref: forwardedRef })
+  );
+});
+
+exports.LazyLegendList = LazyLegendList;
+exports.LegendList = LegendList;
+exports.useIsLastItem = useIsLastItem;
+exports.useListScrollSize = useListScrollSize;
+exports.useRecyclingEffect = useRecyclingEffect;
+exports.useRecyclingState = useRecyclingState;
+exports.useViewability = useViewability;
+exports.useViewabilityAmount = useViewabilityAmount;