@legendapp/list 3.0.0-beta.43 → 3.0.0-beta.45

package/index.js

@@ -34,37 +34,6 @@ var View = React3.forwardRef(function View2(props, ref) {
 });
 var Text = View;
 
-// src/state/getContentInsetEnd.ts
-function getContentInsetEnd(state) {
-  var _a3;
-  const { props } = state;
-  const horizontal = props.horizontal;
-  const contentInset = props.contentInset;
-  const baseInset = contentInset != null ? contentInset : state.nativeContentInset;
-  const overrideInset = (_a3 = state.contentInsetOverride) != null ? _a3 : void 0;
-  if (overrideInset) {
-    const mergedInset = { bottom: 0, right: 0, ...baseInset, ...overrideInset };
-    return (horizontal ? mergedInset.right : mergedInset.bottom) || 0;
-  }
-  if (baseInset) {
-    return (horizontal ? baseInset.right : baseInset.bottom) || 0;
-  }
-  return 0;
-}
-
-// src/state/getContentSize.ts
-function getContentSize(ctx) {
-  var _a3;
-  const { values, state } = ctx;
-  const stylePaddingTop = values.get("stylePaddingTop") || 0;
-  const stylePaddingBottom = state.props.stylePaddingBottom || 0;
-  const headerSize = values.get("headerSize") || 0;
-  const footerSize = values.get("footerSize") || 0;
-  const contentInsetBottom = getContentInsetEnd(state);
-  const totalSize = (_a3 = state.pendingTotalSize) != null ? _a3 : values.get("totalSize");
-  return headerSize + footerSize + totalSize + stylePaddingTop + stylePaddingBottom + (contentInsetBottom || 0);
-}
-
 // src/platform/Animated.tsx
 var createAnimatedValue = (value) => value;
 
@@ -89,6 +58,11 @@ function StateProvider({ children }) {
       ["headerSize", 0],
       ["numContainers", 0],
       ["activeStickyIndex", -1],
+      ["isAtEnd", false],
+      ["isAtStart", false],
+      ["isNearEnd", false],
+      ["isNearStart", false],
+      ["isWithinMaintainScrollAtEndThreshold", false],
       ["totalSize", 0],
       ["scrollAdjustPending", 0]
     ]),
@@ -180,29 +154,71 @@ function notifyPosition$(ctx, key, value) {
 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);
+  const value = shim.useSyncExternalStore(subscribe, get, 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]));
+  const getSelectedValue = React3__namespace.useCallback(() => selector(get()[0]), [get, selector]);
+  const value = shim.useSyncExternalStore(subscribe, getSelectedValue, getSelectedValue);
   return value;
 }
 
+// src/state/getContentInsetEnd.ts
+function getContentInsetEnd(ctx) {
+  var _a3, _b;
+  const state = ctx.state;
+  const { props } = state;
+  const horizontal = props.horizontal;
+  const contentInset = props.contentInset;
+  const baseInset = contentInset != null ? contentInset : state.nativeContentInset;
+  const baseEndInset = (horizontal ? baseInset == null ? void 0 : baseInset.right : baseInset == null ? void 0 : baseInset.bottom) || 0;
+  const anchoredEndSpaceSize = peek$(ctx, "anchoredEndSpaceSize");
+  const anchoredEndInset = ((_a3 = props.anchoredEndSpace) == null ? void 0 : _a3.includeInEndInset) && anchoredEndSpaceSize ? anchoredEndSpaceSize : 0;
+  const overrideInset = (_b = state.contentInsetOverride) != null ? _b : void 0;
+  if (overrideInset) {
+    const mergedInset = { bottom: 0, right: 0, ...baseInset, ...overrideInset };
+    return Math.max((horizontal ? mergedInset.right : mergedInset.bottom) || 0, anchoredEndInset);
+  }
+  return Math.max(baseEndInset, anchoredEndInset);
+}
+
+// src/state/getContentSize.ts
+function getContentSize(ctx) {
+  var _a3;
+  const { values, state } = ctx;
+  const stylePaddingTop = values.get("stylePaddingTop") || 0;
+  const stylePaddingBottom = state.props.stylePaddingBottom || 0;
+  const headerSize = values.get("headerSize") || 0;
+  const footerSize = values.get("footerSize") || 0;
+  const contentInsetBottom = getContentInsetEnd(ctx);
+  const totalSize = (_a3 = state.pendingTotalSize) != null ? _a3 : values.get("totalSize");
+  return headerSize + footerSize + totalSize + stylePaddingTop + stylePaddingBottom + (contentInsetBottom || 0);
+}
+
 // src/components/DebugView.tsx
 var DebugRow = ({ children }) => {
   return /* @__PURE__ */ React3__namespace.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
 };
-React3__namespace.memo(function DebugView2({ state }) {
+React3__namespace.memo(function DebugView2() {
   const ctx = useStateContext();
-  const [totalSize = 0, scrollAdjust = 0, rawScroll = 0, scroll = 0, _numContainers = 0, _numContainersPooled = 0] = useArr$([
+  const [
+    totalSize = 0,
+    scrollAdjust = 0,
+    rawScroll = 0,
+    scroll = 0,
+    _numContainers = 0,
+    _numContainersPooled = 0,
+    isAtEnd = false
+  ] = useArr$([
     "totalSize",
     "scrollAdjust",
     "debugRawScroll",
     "debugComputedScroll",
     "numContainers",
-    "numContainersPooled"
+    "numContainersPooled",
+    "isAtEnd"
   ]);
   const contentSize = getContentSize(ctx);
   const [, forceUpdate] = React3.useReducer((x) => x + 1, 0);
@@ -227,7 +243,7 @@ React3__namespace.memo(function DebugView2({ state }) {
     },
     /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "TotalSize:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, totalSize.toFixed(2))),
     /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "ContentSize:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, contentSize.toFixed(2))),
-    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "At end:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, String(state.isAtEnd))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "At end:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, String(isAtEnd))),
     /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, scrollAdjust.toFixed(2))),
     /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React3__namespace.createElement(Text, null, rawScroll.toFixed(2))),
     /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React3__namespace.createElement(Text, null, scroll.toFixed(2)))
@@ -250,6 +266,7 @@ var IS_DEV = (_a2 = processDev != null ? processDev : metroDev) != null ? _a2 :
 
 // src/constants.ts
 var POSITION_OUT_OF_VIEW = -1e7;
+var EDGE_POSITION_EPSILON = 1;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 var typedForwardRef = React3__namespace.forwardRef;
@@ -706,17 +723,20 @@ var Container = typedMemo(function Container2({
       const { columnGap, rowGap, gap } = columnWrapperStyle;
       if (horizontal) {
         paddingStyles = {
+          paddingBottom: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0,
           paddingRight: columnGap || gap || void 0,
-          paddingVertical: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0
+          paddingTop: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0
         };
       } else {
         paddingStyles = {
           paddingBottom: rowGap || gap || void 0,
-          paddingHorizontal: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0
+          paddingLeft: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0,
+          paddingRight: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0
         };
       }
     }
     return horizontal ? {
+      boxSizing: paddingStyles ? "border-box" : void 0,
       flexDirection: ItemSeparatorComponent ? "row" : void 0,
       height: otherAxisSize,
       left: 0,
@@ -724,6 +744,7 @@ var Container = typedMemo(function Container2({
       top: otherAxisPos,
       ...paddingStyles || {}
     } : {
+      boxSizing: paddingStyles ? "border-box" : void 0,
       left: otherAxisPos,
       position: "absolute",
       right: numColumns > 1 ? null : 0,
@@ -937,7 +958,7 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
   const ref = React3.useRef(null);
   const ctx = useStateContext();
   const columnWrapperStyle = ctx.columnWrapperStyle;
-  const [totalSize, otherAxisSize] = useArr$(["totalSize", "otherAxisSize"]);
+  const [otherAxisSize, totalSize] = useArr$(["otherAxisSize", "totalSize"]);
   useDOMOrder(ref);
   const style = horizontal ? { minHeight: otherAxisSize, position: "relative", width: totalSize } : { height: totalSize, minWidth: otherAxisSize, position: "relative" };
   if (columnWrapperStyle && numColumns > 1) {
@@ -952,9 +973,6 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
         style.marginRight = -gapX;
       }
     } else {
-      if (gapX) {
-        style.marginLeft = style.marginRight = -gapX;
-      }
       if (gapY) {
         style.marginBottom = -gapY;
       }
@@ -966,7 +984,6 @@ var Containers = typedMemo(function Containers2({
   horizontal,
   recycleItems,
   ItemSeparatorComponent,
-  waitForInitialLayout,
   updateItemSize: updateItemSize2,
   getRenderedItem: getRenderedItem2,
   stickyHeaderConfig
@@ -990,7 +1007,7 @@ var Containers = typedMemo(function Containers2({
       )
     );
   }
-  return /* @__PURE__ */ React3__namespace.createElement(ContainersInner, { horizontal, numColumns, waitForInitialLayout }, containers);
+  return /* @__PURE__ */ React3__namespace.createElement(ContainersInner, { horizontal, numColumns }, containers);
 });
 
 // src/platform/StyleSheet.tsx
@@ -1133,6 +1150,7 @@ function resolveWindowScrollTarget({ clampedOffset, horizontal, listPos, scroll
 var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView2({
   children,
   style,
+  contentContainerClassName,
   contentContainerStyle,
   horizontal = false,
   contentOffset,
@@ -1268,18 +1286,18 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
   const scrollEventCoalescer = useRafCoalescer(emitScroll);
   const handleScroll = React3.useCallback(
     (_event) => {
-      var _a3;
       if (!onScroll2) {
         return;
       }
-      const scrollingTo = (_a3 = ctx.state) == null ? void 0 : _a3.scrollingTo;
-      if (scrollingTo && !scrollingTo.animated) {
+      const state = ctx.state;
+      const shouldFlushImmediately = !!(state == null ? void 0 : state.scrollingTo) || !!(state == null ? void 0 : state.initialScrollSession) && !state.didFinishInitialScroll || !!(state == null ? void 0 : state.initialScroll) && !state.didFinishInitialScroll || !!state && isInMVCPActiveMode(state);
+      if (shouldFlushImmediately) {
         scrollEventCoalescer.flush();
       } else {
         scrollEventCoalescer.schedule();
       }
     },
-    [onScroll2, scrollEventCoalescer]
+    [ctx.state, onScroll2, scrollEventCoalescer]
   );
   React3.useLayoutEffect(() => {
     const target = getScrollTarget();
@@ -1345,13 +1363,14 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     ...StyleSheet.flatten(contentContainerStyle)
   };
   const {
+    contentContainerClassName: _contentContainerClassName,
     contentInset: _contentInset,
     scrollEventThrottle: _scrollEventThrottle,
     ScrollComponent: _ScrollComponent,
     useWindowScroll: _useWindowScroll,
     ...webProps
   } = props;
-  return /* @__PURE__ */ React3__namespace.createElement("div", { ref: scrollRef, ...webProps, style: scrollViewStyle }, refreshControl, /* @__PURE__ */ React3__namespace.createElement("div", { ref: contentRef, style: contentStyle }, children));
+  return /* @__PURE__ */ React3__namespace.createElement("div", { ref: scrollRef, ...webProps, style: scrollViewStyle }, refreshControl, /* @__PURE__ */ React3__namespace.createElement("div", { className: contentContainerClassName, ref: contentRef, style: contentStyle }, children));
 });
 function useValueListener$(key, callback) {
   const ctx = useStateContext();
@@ -1364,6 +1383,21 @@ function useValueListener$(key, callback) {
 }
 
 // src/components/ScrollAdjust.tsx
+function getScrollAdjustAxis(horizontal) {
+  return horizontal ? {
+    contentSizeKey: "scrollWidth",
+    paddingEndProp: "paddingRight",
+    viewportSizeKey: "clientWidth",
+    x: 1,
+    y: 0
+  } : {
+    contentSizeKey: "scrollHeight",
+    paddingEndProp: "paddingBottom",
+    viewportSizeKey: "clientHeight",
+    x: 0,
+    y: 1
+  };
+}
 function ScrollAdjust() {
   const ctx = useStateContext();
   const lastScrollOffsetRef = React3__namespace.useRef(0);
@@ -1377,32 +1411,34 @@ function ScrollAdjust() {
     if (scrollView && scrollOffset !== lastScrollOffsetRef.current) {
       const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
       if (scrollDelta !== 0) {
+        const axis = getScrollAdjustAxis(!!ctx.state.props.horizontal);
         const contentNode = scrollView.getContentNode();
         const prevScroll = scrollView.getCurrentScrollOffset();
         const el = scrollView.getScrollableNode();
+        const scrollBy = () => scrollView.scrollBy(axis.x * scrollDelta, axis.y * scrollDelta);
         if (!contentNode) {
-          scrollView.scrollBy(0, scrollDelta);
+          scrollBy();
           lastScrollOffsetRef.current = scrollOffset;
           return;
         }
-        const totalSize = contentNode.scrollHeight;
-        const viewportSize = el.clientHeight;
+        const totalSize = contentNode[axis.contentSizeKey];
+        const viewportSize = el[axis.viewportSizeKey];
         const nextScroll = prevScroll + scrollDelta;
         if (scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + viewportSize) {
-          const paddingBottom = ctx.state.props.stylePaddingBottom || 0;
+          const previousPaddingEnd = contentNode.style[axis.paddingEndProp];
           const pad = (nextScroll + viewportSize - totalSize) * 2;
-          contentNode.style.paddingBottom = `${pad}px`;
+          contentNode.style[axis.paddingEndProp] = `${pad}px`;
           void contentNode.offsetHeight;
-          scrollView.scrollBy(0, scrollDelta);
+          scrollBy();
           if (resetPaddingRafRef.current !== void 0) {
             cancelAnimationFrame(resetPaddingRafRef.current);
           }
           resetPaddingRafRef.current = requestAnimationFrame(() => {
             resetPaddingRafRef.current = void 0;
-            contentNode.style.paddingBottom = paddingBottom ? `${paddingBottom}px` : "0";
+            contentNode.style[axis.paddingEndProp] = previousPaddingEnd;
           });
         } else {
-          scrollView.scrollBy(0, scrollDelta);
+          scrollBy();
         }
       }
       lastScrollOffsetRef.current = scrollOffset;
@@ -1416,8 +1452,19 @@ function SnapWrapper({ ScrollComponent, ...props }) {
   const [snapToOffsets] = useArr$(["snapToOffsets"]);
   return /* @__PURE__ */ React3__namespace.createElement(ScrollComponent, { ...props, snapToOffsets });
 }
+function WebAnchoredEndSpace({ horizontal }) {
+  const ctx = useStateContext();
+  const [anchoredEndSpaceSize] = useArr$(["anchoredEndSpaceSize"]);
+  const shouldRenderAnchoredEndSpace = !!ctx.state.props.anchoredEndSpace && (anchoredEndSpaceSize || 0) > 0;
+  if (!shouldRenderAnchoredEndSpace) {
+    return null;
+  }
+  const style = horizontal ? { height: "100%", width: anchoredEndSpaceSize || 0 } : { height: anchoredEndSpaceSize || 0 };
+  return /* @__PURE__ */ React3__namespace.createElement("div", { style }, null);
+}
 var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
-  const ref = refView != null ? refView : React3.useRef(null);
+  const localRef = React3.useRef(null);
+  const ref = refView != null ? refView : localRef;
   useOnLayoutSync({ onLayoutChange, ref });
   return /* @__PURE__ */ React3__namespace.createElement("div", { ...rest, ref }, children);
 };
@@ -1441,7 +1488,6 @@ var ListComponent = typedMemo(function ListComponent2({
   recycleItems,
   ItemSeparatorComponent,
   alignItemsAtEnd: _alignItemsAtEnd,
-  waitForInitialLayout,
   onScroll: onScroll2,
   onLayout,
   ListHeaderComponent,
@@ -1463,12 +1509,14 @@ var ListComponent = typedMemo(function ListComponent2({
 }) {
   const ctx = useStateContext();
   const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
-  const ScrollComponent = renderScrollComponent ? React3.useMemo(
-    () => React3__namespace.forwardRef(
+  const ScrollComponent = React3.useMemo(() => {
+    if (!renderScrollComponent) {
+      return ListComponentScrollView;
+    }
+    return React3__namespace.forwardRef(
       (props, ref) => renderScrollComponent({ ...props, ref })
-    ),
-    [renderScrollComponent]
-  ) : ListComponentScrollView;
+    );
+  }, [renderScrollComponent]);
   const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
   React3.useLayoutEffect(() => {
     if (!ListHeaderComponent) {
@@ -1504,7 +1552,7 @@ var ListComponent = typedMemo(function ListComponent2({
           height: "100%"
         } : {}
       ],
-      contentOffset: initialContentOffset ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
+      contentOffset: initialContentOffset !== void 0 ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
       horizontal,
       maintainVisibleContentPosition: maintainVisibleContentPosition.size || maintainVisibleContentPosition.data ? { minIndexForVisible: 0 } : void 0,
       onLayout,
@@ -1524,168 +1572,229 @@ var ListComponent = typedMemo(function ListComponent2({
         ItemSeparatorComponent,
         recycleItems,
         stickyHeaderConfig,
-        updateItemSize: updateItemSize2,
-        waitForInitialLayout
+        updateItemSize: updateItemSize2
       }
     ),
     ListFooterComponent && /* @__PURE__ */ React3__namespace.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
+    /* @__PURE__ */ React3__namespace.createElement(WebAnchoredEndSpace, { horizontal }),
     IS_DEV && ENABLE_DEVMODE
   );
 });
-
-// src/core/calculateOffsetForIndex.ts
-function calculateOffsetForIndex(ctx, index) {
-  const state = ctx.state;
-  return index !== void 0 ? state.positions[index] || 0 : 0;
-}
-
-// src/core/getTopOffsetAdjustment.ts
-function getTopOffsetAdjustment(ctx) {
-  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
+var WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH = 100;
+var WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO = 0.9;
+var WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO = 0.9;
+function useDevChecksImpl(props) {
+  const ctx = useStateContext();
+  const { childrenMode, keyExtractor, renderScrollComponent, stickyHeaderIndices, stickyIndices, useWindowScroll } = props;
+  React3.useEffect(() => {
+    if (stickyIndices && !stickyHeaderIndices) {
+      warnDevOnce(
+        "stickyIndices",
+        "stickyIndices has been renamed to stickyHeaderIndices. Please update your props to use stickyHeaderIndices."
+      );
+    }
+  }, [stickyHeaderIndices, stickyIndices]);
+  React3.useEffect(() => {
+    if (useWindowScroll && renderScrollComponent) {
+      warnDevOnce(
+        "useWindowScrollRenderScrollComponent",
+        "useWindowScroll is not supported when renderScrollComponent is provided."
+      );
+    }
+  }, [renderScrollComponent, useWindowScroll]);
+  React3.useEffect(() => {
+    if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
+      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."
+      );
+    }
+  }, [childrenMode, ctx, keyExtractor]);
+  React3.useEffect(() => {
+    const state = ctx.state;
+    const dataLength = state.props.data.length;
+    const useWindowScrollResolved = state.props.useWindowScroll;
+    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+      return;
+    }
+    const warnIfUnboundedOuterSize = () => {
+      const readyToRender = peek$(ctx, "readyToRender");
+      const numContainers = peek$(ctx, "numContainers") || 0;
+      const totalSize = peek$(ctx, "totalSize") || 0;
+      const scrollLength = ctx.state.scrollLength || 0;
+      if (!readyToRender || totalSize <= 0 || scrollLength <= 0) {
+        return;
+      }
+      const rendersAlmostEverything = numContainers >= Math.ceil(dataLength * WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO);
+      const viewportMatchesContent = scrollLength >= totalSize * WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO;
+      if (rendersAlmostEverything && viewportMatchesContent) {
+        warnDevOnce(
+          "webUnboundedOuterSize",
+          "LegendList appears to have an unbounded outer height on web, so virtualization is effectively disabled. Set a bounded height or flex: 1 on the list container, or use useWindowScroll."
+        );
+      }
+    };
+    warnIfUnboundedOuterSize();
+    const unsubscribe = [
+      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
+      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
+      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
+    ];
+    return () => {
+      for (const unsub of unsubscribe) {
+        unsub();
+      }
+    };
+  }, [ctx]);
 }
-
-// src/utils/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[index] = id;
-  return id;
+function useDevChecksNoop(_props) {
 }
+var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
 
-// src/core/addTotalSize.ts
-function addTotalSize(ctx, key, add) {
-  const state = ctx.state;
-  const prevTotalSize = state.totalSize;
-  let totalSize = state.totalSize;
-  if (key === null) {
-    totalSize = add;
-    if (state.timeoutSetPaddingTop) {
-      clearTimeout(state.timeoutSetPaddingTop);
-      state.timeoutSetPaddingTop = void 0;
-    }
-  } else {
-    totalSize += add;
-  }
-  if (prevTotalSize !== totalSize) {
-    {
-      state.pendingTotalSize = void 0;
-      state.totalSize = totalSize;
-      set$(ctx, "totalSize", totalSize);
+// src/core/deferredPublicOnScroll.ts
+function withResolvedContentOffset(state, event, resolvedOffset) {
+  return {
+    ...event,
+    nativeEvent: {
+      ...event.nativeEvent,
+      contentOffset: state.props.horizontal ? { x: resolvedOffset, y: 0 } : { x: 0, y: resolvedOffset }
     }
-  }
+  };
 }
-
-// src/core/setSize.ts
-function setSize(ctx, itemKey, size) {
+function releaseDeferredPublicOnScroll(ctx, resolvedOffset) {
+  var _a3, _b, _c, _d;
   const state = ctx.state;
-  const { sizes } = state;
-  const previousSize = sizes.get(itemKey);
-  const diff = previousSize !== void 0 ? size - previousSize : size;
-  if (diff !== 0) {
-    addTotalSize(ctx, itemKey, diff);
+  const deferredEvent = state.deferredPublicOnScrollEvent;
+  state.deferredPublicOnScrollEvent = void 0;
+  if (deferredEvent) {
+    (_d = (_c = state.props).onScroll) == null ? void 0 : _d.call(
+      _c,
+      withResolvedContentOffset(
+        state,
+        deferredEvent,
+        (_b = (_a3 = resolvedOffset != null ? resolvedOffset : state.scrollPending) != null ? _a3 : state.scroll) != null ? _b : 0
+      )
+    );
   }
-  sizes.set(itemKey, size);
 }
 
-// src/utils/getItemSize.ts
-function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize) {
-  var _a3, _b;
-  const state = ctx.state;
-  const {
-    sizesKnown,
-    sizes,
-    averageSizes,
-    props: { estimatedItemSize, getEstimatedItemSize, getFixedItemSize, getItemType },
-    scrollingTo
-  } = state;
-  const sizeKnown = sizesKnown.get(key);
-  if (sizeKnown !== void 0) {
-    return sizeKnown;
-  }
-  let size;
-  if (preferCachedSize) {
-    const cachedSize = sizes.get(key);
-    if (cachedSize !== void 0) {
-      return cachedSize;
-    }
-  }
-  const itemType = getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-  if (getFixedItemSize) {
-    size = getFixedItemSize(data, index, itemType);
-    if (size !== void 0) {
-      sizesKnown.set(key, size);
-    }
-  }
-  if (size === void 0 && useAverageSize && sizeKnown === void 0 && !scrollingTo) {
-    const averageSizeForType = (_b = averageSizes[itemType]) == null ? void 0 : _b.avg;
-    if (averageSizeForType !== void 0) {
-      size = roundSize(averageSizeForType);
-    }
-  }
-  if (size === void 0) {
-    size = sizes.get(key);
-    if (size !== void 0) {
-      return size;
-    }
-  }
-  if (size === void 0) {
-    size = getEstimatedItemSize ? getEstimatedItemSize(data, index, itemType) : estimatedItemSize;
-  }
-  setSize(ctx, key, size);
-  return size;
+// src/core/initialScrollSession.ts
+var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
+function hasInitialScrollSessionCompletion(completion) {
+  return !!((completion == null ? void 0 : completion.didDispatchNativeScroll) || (completion == null ? void 0 : completion.didRetrySilentInitialScroll) || (completion == null ? void 0 : completion.watchdog));
+}
+function clearInitialScrollSession(state) {
+  state.initialScrollSession = void 0;
+  return void 0;
+}
+function createInitialScrollSession(options) {
+  const { bootstrap, completion, kind, previousDataLength } = options;
+  return kind === "offset" ? {
+    completion,
+    kind,
+    previousDataLength
+  } : {
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  };
 }
-
-// src/core/calculateOffsetWithOffsetPosition.ts
-function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
-  var _a3;
-  const state = ctx.state;
-  const { index, viewOffset, viewPosition } = params;
-  let offset = offsetParam;
-  if (viewOffset) {
-    offset -= viewOffset;
+function ensureInitialScrollSessionCompletion(state, kind = ((_b) => (_b = ((_a3) => (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind)()) != null ? _b : "bootstrap")()) {
+  var _a4, _b2;
+  if (!state.initialScrollSession) {
+    state.initialScrollSession = createInitialScrollSession({
+      completion: {},
+      kind,
+      previousDataLength: 0
+    });
+  } else if (state.initialScrollSession.kind !== kind) {
+    state.initialScrollSession = createInitialScrollSession({
+      bootstrap: state.initialScrollSession.kind === "bootstrap" ? state.initialScrollSession.bootstrap : void 0,
+      completion: state.initialScrollSession.completion,
+      kind,
+      previousDataLength: state.initialScrollSession.previousDataLength
+    });
   }
-  if (index !== void 0) {
-    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
-    if (topOffsetAdjustment) {
-      offset += topOffsetAdjustment;
+  (_b2 = (_a4 = state.initialScrollSession).completion) != null ? _b2 : _a4.completion = {};
+  return state.initialScrollSession.completion;
+}
+var initialScrollCompletion = {
+  didDispatchNativeScroll(state) {
+    var _a3, _b;
+    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didDispatchNativeScroll);
+  },
+  didRetrySilentInitialScroll(state) {
+    var _a3, _b;
+    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didRetrySilentInitialScroll);
+  },
+  markInitialScrollNativeDispatch(state) {
+    ensureInitialScrollSessionCompletion(state).didDispatchNativeScroll = true;
+  },
+  markSilentInitialScrollRetry(state) {
+    ensureInitialScrollSessionCompletion(state).didRetrySilentInitialScroll = true;
+  },
+  resetFlags(state) {
+    if (!state.initialScrollSession) {
+      return;
     }
+    const completion = ensureInitialScrollSessionCompletion(state, state.initialScrollSession.kind);
+    completion.didDispatchNativeScroll = void 0;
+    completion.didRetrySilentInitialScroll = void 0;
   }
-  if (viewPosition !== void 0 && index !== void 0) {
-    const dataLength = state.props.data.length;
-    if (dataLength === 0) {
-      return offset;
-    }
-    const isOutOfBounds = index < 0 || index >= dataLength;
-    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
-    const itemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
-    const trailingInset = getContentInsetEnd(state);
-    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
-    if (!isOutOfBounds && index === state.props.data.length - 1) {
-      const footerSize = peek$(ctx, "footerSize") || 0;
-      offset += footerSize;
+};
+var initialScrollWatchdog = {
+  clear(state) {
+    initialScrollWatchdog.set(state, void 0);
+  },
+  didObserveProgress(newScroll, watchdog) {
+    const previousDistance = Math.abs(watchdog.startScroll - watchdog.targetOffset);
+    const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
+    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET || nextDistance + INITIAL_SCROLL_MIN_TARGET_OFFSET < previousDistance;
+  },
+  get(state) {
+    var _a3, _b;
+    return (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog;
+  },
+  hasNonZeroTargetOffset(targetOffset) {
+    return targetOffset !== void 0 && targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  isAtZeroTargetOffset(targetOffset) {
+    return targetOffset <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  set(state, watchdog) {
+    var _a3, _b;
+    if (!watchdog && !((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog)) {
+      return;
     }
+    const completion = ensureInitialScrollSessionCompletion(state);
+    completion.watchdog = watchdog ? {
+      startScroll: watchdog.startScroll,
+      targetOffset: watchdog.targetOffset
+    } : void 0;
   }
-  return offset;
-}
-
-// src/core/clampScrollOffset.ts
-function clampScrollOffset(ctx, offset, scrollTarget) {
-  const state = ctx.state;
-  const contentSize = getContentSize(ctx);
-  let clampedOffset = offset;
-  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
-    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
-    const viewOffset = scrollTarget == null ? void 0 : scrollTarget.viewOffset;
-    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
-    const maxOffset = baseMaxOffset + extraEndOffset;
-    clampedOffset = Math.min(offset, maxOffset);
-  }
-  clampedOffset = Math.max(0, clampedOffset);
-  return clampedOffset;
+};
+function setInitialScrollSession(state, options = {}) {
+  var _a3, _b, _c;
+  const existingSession = state.initialScrollSession;
+  const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
+  const completion = existingSession == null ? void 0 : existingSession.completion;
+  const hasBootstrapOverride = Object.hasOwn(options, "bootstrap");
+  const bootstrap = kind === "bootstrap" ? hasBootstrapOverride ? options.bootstrap : (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0 : void 0;
+  if (!kind) {
+    return clearInitialScrollSession(state);
+  }
+  if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
+    return clearInitialScrollSession(state);
+  }
+  const previousDataLength = (_c = (_b = options.previousDataLength) != null ? _b : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _c : 0;
+  state.initialScrollSession = createInitialScrollSession({
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  });
+  return state.initialScrollSession;
 }
 
 // src/utils/checkThreshold.ts
@@ -1726,11 +1835,16 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
   return true;
 };
 
+// src/utils/hasActiveInitialScroll.ts
+function hasActiveInitialScroll(state) {
+  return !!(state == null ? void 0 : state.initialScroll) && !state.didFinishInitialScroll;
+}
+
 // src/utils/checkAtBottom.ts
 function checkAtBottom(ctx) {
   var _a3;
   const state = ctx.state;
-  if (!state || state.initialScroll) {
+  if (!state) {
     return;
   }
   const {
@@ -1740,42 +1854,48 @@ function checkAtBottom(ctx) {
     maintainingScrollAtEnd,
     props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
   } = state;
-  if (state.initialScroll) {
-    return;
-  }
   const contentSize = getContentSize(ctx);
-  if (contentSize > 0 && queuedInitialLayout && !maintainingScrollAtEnd) {
-    const insetEnd = getContentInsetEnd(state);
+  if (contentSize > 0 && queuedInitialLayout) {
+    const insetEnd = getContentInsetEnd(ctx);
     const distanceFromEnd = contentSize - scroll - scrollLength - insetEnd;
     const isContentLess = contentSize < scrollLength;
-    state.isAtEnd = isContentLess || distanceFromEnd < scrollLength * maintainScrollAtEndThreshold;
-    state.isEndReached = checkThreshold(
-      distanceFromEnd,
-      isContentLess,
-      onEndReachedThreshold * scrollLength,
-      state.isEndReached,
-      state.endReachedSnapshot,
-      {
-        contentSize,
-        dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length,
-        scrollPosition: scroll
-      },
-      (distance) => {
-        var _a4, _b;
-        return (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
-      },
-      (snapshot) => {
-        state.endReachedSnapshot = snapshot;
-      },
-      true
+    set$(ctx, "isAtEnd", isContentLess || distanceFromEnd <= EDGE_POSITION_EPSILON);
+    set$(ctx, "isNearEnd", isContentLess || distanceFromEnd <= onEndReachedThreshold * scrollLength);
+    set$(
+      ctx,
+      "isWithinMaintainScrollAtEndThreshold",
+      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength
     );
+    const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || maintainingScrollAtEnd;
+    if (!shouldSkipThresholdChecks) {
+      state.isEndReached = checkThreshold(
+        distanceFromEnd,
+        isContentLess,
+        onEndReachedThreshold * scrollLength,
+        state.isEndReached,
+        state.endReachedSnapshot,
+        {
+          contentSize,
+          dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length,
+          scrollPosition: scroll
+        },
+        (distance) => {
+          var _a4, _b;
+          return (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+        },
+        (snapshot) => {
+          state.endReachedSnapshot = snapshot;
+        },
+        true
+      );
+    }
   }
 }
 
 // src/utils/checkAtTop.ts
 function checkAtTop(ctx) {
   const state = ctx == null ? void 0 : ctx.state;
-  if (!state || state.initialScroll || state.scrollingTo) {
+  if (!state) {
     return;
   }
   const {
@@ -1798,31 +1918,33 @@ function checkAtTop(ctx) {
     state.startReachedSnapshot = void 0;
     state.startReachedSnapshotDataChangeEpoch = void 0;
   }
-  state.isAtStart = scroll <= 0;
-  if (isStartReached && withinThreshold && dataChanged && !allowReentryOnDataChange) {
-    return;
+  set$(ctx, "isAtStart", scroll <= EDGE_POSITION_EPSILON);
+  set$(ctx, "isNearStart", scroll <= threshold);
+  const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || !!state.scrollingTo;
+  const shouldDeferDataChangeRefire = isStartReached && withinThreshold && dataChanged && !allowReentryOnDataChange;
+  if (!shouldSkipThresholdChecks && !shouldDeferDataChangeRefire) {
+    state.isStartReached = checkThreshold(
+      scroll,
+      false,
+      threshold,
+      state.isStartReached,
+      allowReentryOnDataChange ? void 0 : startReachedSnapshot,
+      {
+        contentSize: totalSize,
+        dataLength,
+        scrollPosition: scroll
+      },
+      (distance) => {
+        var _a3, _b;
+        return (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+      },
+      (snapshot) => {
+        state.startReachedSnapshot = snapshot;
+        state.startReachedSnapshotDataChangeEpoch = snapshot ? dataChangeEpoch : void 0;
+      },
+      allowReentryOnDataChange
+    );
   }
-  state.isStartReached = checkThreshold(
-    scroll,
-    false,
-    threshold,
-    state.isStartReached,
-    allowReentryOnDataChange ? void 0 : startReachedSnapshot,
-    {
-      contentSize: totalSize,
-      dataLength,
-      scrollPosition: scroll
-    },
-    (distance) => {
-      var _a3, _b;
-      return (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
-    },
-    (snapshot) => {
-      state.startReachedSnapshot = snapshot;
-      state.startReachedSnapshotDataChangeEpoch = snapshot ? dataChangeEpoch : void 0;
-    },
-    allowReentryOnDataChange
-  );
 }
 
 // src/utils/checkThresholds.ts
@@ -1831,6 +1953,16 @@ function checkThresholds(ctx) {
   checkAtTop(ctx);
 }
 
+// src/core/recalculateSettledScroll.ts
+function recalculateSettledScroll(ctx) {
+  var _a3, _b;
+  const state = ctx.state;
+  if ((_a3 = state.props) == null ? void 0 : _a3.data) {
+    (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
+  }
+  checkThresholds(ctx);
+}
+
 // src/utils/setInitialRenderState.ts
 function setInitialRenderState(ctx, {
   didLayout,
@@ -1856,6 +1988,239 @@ function setInitialRenderState(ctx, {
   }
 }
 
+// src/core/finishInitialScroll.ts
+var PRESERVED_INITIAL_SCROLL_FALLBACK_CLEAR_DELAY_MS = 2e3;
+function syncInitialScrollOffset(state, offset) {
+  state.scroll = offset;
+  state.scrollPending = offset;
+  state.scrollPrev = offset;
+}
+function clearPreservedInitialScrollTargetTimeout(state) {
+  if (state.timeoutPreservedInitialScrollClear !== void 0) {
+    clearTimeout(state.timeoutPreservedInitialScrollClear);
+    state.timeoutPreservedInitialScrollClear = void 0;
+  }
+}
+function clearPreservedInitialScrollTarget(state) {
+  clearPreservedInitialScrollTargetTimeout(state);
+  state.clearPreservedInitialScrollOnNextFinish = void 0;
+  state.initialScroll = void 0;
+  setInitialScrollSession(state);
+}
+function finishInitialScroll(ctx, options) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  if ((options == null ? void 0 : options.resolvedOffset) !== void 0) {
+    syncInitialScrollOffset(state, options.resolvedOffset);
+  } else if ((options == null ? void 0 : options.syncObservedOffset) && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
+    const observedOffset = (_c = (_b = state.refScroller.current) == null ? void 0 : _b.getCurrentScrollOffset) == null ? void 0 : _c.call(_b);
+    if (typeof observedOffset === "number" && Number.isFinite(observedOffset)) {
+      syncInitialScrollOffset(state, observedOffset);
+    }
+  }
+  const complete = () => {
+    var _a4, _b2, _c2, _d, _e;
+    const shouldReleaseDeferredPublicOnScroll = ((_a4 = state.initialScrollSession) == null ? void 0 : _a4.kind) === "bootstrap";
+    const finalScrollOffset = (_d = (_c2 = (_b2 = options == null ? void 0 : options.resolvedOffset) != null ? _b2 : state.scrollPending) != null ? _c2 : state.scroll) != null ? _d : 0;
+    initialScrollWatchdog.clear(state);
+    if ((options == null ? void 0 : options.preserveTarget) && state.initialScroll) {
+      state.clearPreservedInitialScrollOnNextFinish = void 0;
+      setInitialScrollSession(state);
+      clearPreservedInitialScrollTargetTimeout(state);
+      if (options == null ? void 0 : options.schedulePreservedTargetClear) {
+        state.timeoutPreservedInitialScrollClear = setTimeout(() => {
+          var _a5;
+          state.timeoutPreservedInitialScrollClear = void 0;
+          if (!state.didFinishInitialScroll || ((_a5 = state.scrollingTo) == null ? void 0 : _a5.isInitialScroll) || !state.initialScroll) {
+            return;
+          }
+          clearPreservedInitialScrollTarget(state);
+        }, PRESERVED_INITIAL_SCROLL_FALLBACK_CLEAR_DELAY_MS);
+      }
+    } else {
+      clearPreservedInitialScrollTarget(state);
+    }
+    if (options == null ? void 0 : options.recalculateItems) {
+      recalculateSettledScroll(ctx);
+    }
+    setInitialRenderState(ctx, { didInitialScroll: true });
+    if (shouldReleaseDeferredPublicOnScroll) {
+      releaseDeferredPublicOnScroll(ctx, finalScrollOffset);
+    }
+    (_e = options == null ? void 0 : options.onFinished) == null ? void 0 : _e.call(options);
+  };
+  if (options == null ? void 0 : options.waitForCompletionFrame) {
+    requestAnimationFrame(complete);
+    return;
+  }
+  complete();
+}
+
+// src/core/calculateOffsetForIndex.ts
+function calculateOffsetForIndex(ctx, index) {
+  const state = ctx.state;
+  return index !== void 0 ? state.positions[index] || 0 : 0;
+}
+
+// src/core/getTopOffsetAdjustment.ts
+function getTopOffsetAdjustment(ctx) {
+  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
+}
+
+// src/utils/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[index] = id;
+  return id;
+}
+
+// src/core/addTotalSize.ts
+function addTotalSize(ctx, key, add) {
+  const state = ctx.state;
+  const prevTotalSize = state.totalSize;
+  let totalSize = state.totalSize;
+  if (key === null) {
+    totalSize = add;
+    if (state.timeoutSetPaddingTop) {
+      clearTimeout(state.timeoutSetPaddingTop);
+      state.timeoutSetPaddingTop = void 0;
+    }
+  } else {
+    totalSize += add;
+  }
+  if (prevTotalSize !== totalSize) {
+    {
+      state.pendingTotalSize = void 0;
+      state.totalSize = totalSize;
+      set$(ctx, "totalSize", totalSize);
+    }
+  }
+}
+
+// src/core/setSize.ts
+function setSize(ctx, itemKey, size) {
+  const state = ctx.state;
+  const { sizes } = state;
+  const previousSize = sizes.get(itemKey);
+  const diff = previousSize !== void 0 ? size - previousSize : size;
+  if (diff !== 0) {
+    addTotalSize(ctx, itemKey, diff);
+  }
+  sizes.set(itemKey, size);
+}
+
+// src/utils/getItemSize.ts
+function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const {
+    sizesKnown,
+    sizes,
+    averageSizes,
+    props: { estimatedItemSize, getEstimatedItemSize, getFixedItemSize, getItemType },
+    scrollingTo
+  } = state;
+  const sizeKnown = sizesKnown.get(key);
+  if (sizeKnown !== void 0) {
+    return sizeKnown;
+  }
+  let size;
+  const renderedSize = sizes.get(key);
+  if (preferCachedSize) {
+    if (renderedSize !== void 0) {
+      return renderedSize;
+    }
+  }
+  const itemType = getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+  if (getFixedItemSize) {
+    size = getFixedItemSize(data, index, itemType);
+    if (size !== void 0) {
+      sizesKnown.set(key, size);
+    }
+  }
+  if (size === void 0 && useAverageSize && sizeKnown === void 0 && !scrollingTo) {
+    const averageSizeForType = (_b = averageSizes[itemType]) == null ? void 0 : _b.avg;
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
+    }
+  }
+  if (size === void 0 && renderedSize !== void 0) {
+    return renderedSize;
+  }
+  if (size === void 0 && useAverageSize && sizeKnown === void 0 && scrollingTo) {
+    const averageSizeForType = (_c = scrollingTo.averageSizeSnapshot) == null ? void 0 : _c[itemType];
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
+    }
+  }
+  if (size === void 0) {
+    size = getEstimatedItemSize ? getEstimatedItemSize(data, index, itemType) : estimatedItemSize;
+  }
+  setSize(ctx, key, size);
+  return size;
+}
+function getItemSizeAtIndex(ctx, index) {
+  if (index === void 0 || index < 0) {
+    return void 0;
+  }
+  const targetId = getId(ctx.state, index);
+  return getItemSize(ctx, targetId, index, ctx.state.props.data[index]);
+}
+
+// src/core/calculateOffsetWithOffsetPosition.ts
+function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
+  var _a3;
+  const state = ctx.state;
+  const { index, viewOffset, viewPosition } = params;
+  let offset = offsetParam;
+  if (viewOffset) {
+    offset -= viewOffset;
+  }
+  if (index !== void 0) {
+    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+    if (topOffsetAdjustment) {
+      offset += topOffsetAdjustment;
+    }
+  }
+  if (viewPosition !== void 0 && index !== void 0) {
+    const dataLength = state.props.data.length;
+    if (dataLength === 0) {
+      return offset;
+    }
+    const isOutOfBounds = index < 0 || index >= dataLength;
+    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
+    const itemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
+    const trailingInset = getContentInsetEnd(ctx);
+    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
+    if (!isOutOfBounds && index === state.props.data.length - 1) {
+      const footerSize = peek$(ctx, "footerSize") || 0;
+      offset += footerSize;
+    }
+  }
+  return offset;
+}
+
+// src/core/clampScrollOffset.ts
+function clampScrollOffset(ctx, offset, scrollTarget) {
+  const state = ctx.state;
+  const contentSize = getContentSize(ctx);
+  let clampedOffset = offset;
+  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
+    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
+    const viewOffset = scrollTarget == null ? void 0 : scrollTarget.viewOffset;
+    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
+    const maxOffset = baseMaxOffset + extraEndOffset;
+    clampedOffset = Math.min(offset, maxOffset);
+  }
+  clampedOffset = Math.max(0, clampedOffset);
+  return clampedOffset;
+}
+
 // src/core/finishScrollTo.ts
 function finishScrollTo(ctx) {
   var _a3, _b;
@@ -1865,193 +2230,1134 @@ function finishScrollTo(ctx) {
     state.pendingScrollResolve = void 0;
     const scrollingTo = state.scrollingTo;
     state.scrollHistory.length = 0;
-    state.initialScroll = void 0;
-    state.initialScrollUsesOffset = false;
-    state.initialAnchor = void 0;
-    state.initialNativeScrollWatchdog = void 0;
     state.scrollingTo = void 0;
     if (state.pendingTotalSize !== void 0) {
       addTotalSize(ctx, null, state.pendingTotalSize);
     }
-    if ((_a3 = state.props) == null ? void 0 : _a3.data) {
-      (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
-    }
     {
       state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
     }
-    setInitialRenderState(ctx, { didInitialScroll: true });
-    checkThresholds(ctx);
+    if (scrollingTo.isInitialScroll || state.initialScroll) {
+      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
+      finishInitialScroll(ctx, {
+        onFinished: () => {
+          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+        },
+        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
+        recalculateItems: true,
+        schedulePreservedTargetClear: shouldPreserveResizeTarget,
+        syncObservedOffset: isOffsetSession,
+        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
+      });
+      return;
+    }
+    recalculateSettledScroll(ctx);
     resolvePendingScroll == null ? void 0 : resolvePendingScroll();
   }
 }
-
-// src/core/doScrollTo.ts
-var SCROLL_END_IDLE_MS = 80;
-var SCROLL_END_MAX_MS = 1500;
-var SMOOTH_SCROLL_DURATION_MS = 320;
-var SCROLL_END_TARGET_EPSILON = 1;
-function doScrollTo(ctx, params) {
+
+// src/core/doScrollTo.ts
+var SCROLL_END_IDLE_MS = 80;
+var SCROLL_END_MAX_MS = 1500;
+var SMOOTH_SCROLL_DURATION_MS = 320;
+var SCROLL_END_TARGET_EPSILON = 1;
+function doScrollTo(ctx, params) {
+  var _a3, _b;
+  const state = ctx.state;
+  const { animated, horizontal, offset } = params;
+  const scroller = state.refScroller.current;
+  const node = scroller == null ? void 0 : scroller.getScrollableNode();
+  if (!scroller || !node) {
+    return;
+  }
+  const isAnimated = !!animated;
+  const isHorizontal = !!horizontal;
+  const left = isHorizontal ? offset : 0;
+  const top = isHorizontal ? 0 : offset;
+  scroller.scrollTo({ animated: isAnimated, x: left, y: top });
+  if (isAnimated) {
+    const target = (_b = (_a3 = scroller.getScrollEventTarget) == null ? void 0 : _a3.call(scroller)) != null ? _b : null;
+    listenForScrollEnd(ctx, {
+      readOffset: () => scroller.getCurrentScrollOffset(),
+      target,
+      targetOffset: offset
+    });
+  } else {
+    state.scroll = offset;
+    setTimeout(() => {
+      finishScrollTo(ctx);
+    }, 100);
+  }
+}
+function listenForScrollEnd(ctx, params) {
+  const { readOffset, target, targetOffset } = params;
+  if (!target) {
+    finishScrollTo(ctx);
+    return;
+  }
+  const supportsScrollEnd = "onscrollend" in target;
+  let idleTimeout;
+  let settled = false;
+  const targetToken = ctx.state.scrollingTo;
+  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
+  const cleanup = () => {
+    target.removeEventListener("scroll", onScroll2);
+    if (supportsScrollEnd) {
+      target.removeEventListener("scrollend", onScrollEnd);
+    }
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    clearTimeout(maxTimeout);
+  };
+  const finish = (reason) => {
+    if (settled) return;
+    if (targetToken !== ctx.state.scrollingTo) {
+      settled = true;
+      cleanup();
+      return;
+    }
+    const currentOffset = readOffset();
+    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
+    if (reason === "scrollend" && !isNearTarget) {
+      return;
+    }
+    settled = true;
+    cleanup();
+    finishScrollTo(ctx);
+  };
+  const onScroll2 = () => {
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
+  };
+  const onScrollEnd = () => finish("scrollend");
+  target.addEventListener("scroll", onScroll2);
+  if (supportsScrollEnd) {
+    target.addEventListener("scrollend", onScrollEnd);
+  } else {
+    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
+  }
+}
+
+// src/core/scrollTo.ts
+function getAverageSizeSnapshot(state) {
+  if (Object.keys(state.averageSizes).length === 0) {
+    return void 0;
+  }
+  const snapshot = {};
+  for (const itemType in state.averageSizes) {
+    const averages = state.averageSizes[itemType];
+    snapshot[itemType] = averages.avg;
+  }
+  return snapshot;
+}
+function syncInitialScrollNativeWatchdog(state, options) {
+  var _a3;
+  const { isInitialScroll, requestedOffset, targetOffset } = options;
+  const existingWatchdog = initialScrollWatchdog.get(state);
+  const shouldWatchInitialNativeScroll = !state.didFinishInitialScroll && (isInitialScroll || !!existingWatchdog) && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
+  const shouldClearInitialNativeScrollWatchdog = !state.didFinishInitialScroll && !!existingWatchdog && initialScrollWatchdog.isAtZeroTargetOffset(requestedOffset);
+  if (shouldWatchInitialNativeScroll) {
+    state.hasScrolled = false;
+    initialScrollWatchdog.set(state, {
+      startScroll: (_a3 = existingWatchdog == null ? void 0 : existingWatchdog.startScroll) != null ? _a3 : state.scroll,
+      targetOffset
+    });
+    return;
+  }
+  if (shouldClearInitialNativeScrollWatchdog) {
+    initialScrollWatchdog.clear(state);
+  }
+}
+function scrollTo(ctx, params) {
+  var _a3;
+  const state = ctx.state;
+  const { noScrollingTo, forceScroll, ...scrollTarget } = params;
+  const {
+    animated,
+    isInitialScroll,
+    offset: scrollTargetOffset,
+    precomputedWithViewOffset,
+    waitForInitialScrollCompletionFrame
+  } = scrollTarget;
+  const {
+    props: { horizontal }
+  } = state;
+  if (state.animFrameCheckFinishedScroll) {
+    cancelAnimationFrame(ctx.state.animFrameCheckFinishedScroll);
+  }
+  if (state.timeoutCheckFinishedScrollFallback) {
+    clearTimeout(ctx.state.timeoutCheckFinishedScrollFallback);
+  }
+  const requestedOffset = precomputedWithViewOffset ? scrollTargetOffset : calculateOffsetWithOffsetPosition(ctx, scrollTargetOffset, scrollTarget);
+  const shouldPreserveRawInitialOffsetRequest = !!isInitialScroll && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+  const targetOffset = clampScrollOffset(ctx, requestedOffset, scrollTarget);
+  const offset = shouldPreserveRawInitialOffsetRequest ? requestedOffset : targetOffset;
+  state.scrollHistory.length = 0;
+  if (!noScrollingTo) {
+    if (isInitialScroll) {
+      initialScrollCompletion.resetFlags(state);
+    }
+    const averageSizeSnapshot = getAverageSizeSnapshot(state);
+    state.scrollingTo = {
+      ...scrollTarget,
+      ...averageSizeSnapshot ? { averageSizeSnapshot } : {},
+      targetOffset,
+      waitForInitialScrollCompletionFrame
+    };
+  }
+  state.scrollPending = targetOffset;
+  syncInitialScrollNativeWatchdog(state, { isInitialScroll, requestedOffset: offset, targetOffset });
+  if (forceScroll || !isInitialScroll || Platform.OS === "android") {
+    doScrollTo(ctx, { animated, horizontal, offset });
+  } else {
+    state.scroll = offset;
+  }
+}
+
+// src/core/scrollToIndex.ts
+function clampScrollIndex(index, dataLength) {
+  if (dataLength <= 0) {
+    return -1;
+  }
+  if (index >= dataLength) {
+    return dataLength - 1;
+  }
+  if (index < 0) {
+    return 0;
+  }
+  return index;
+}
+function scrollToIndex(ctx, {
+  index,
+  viewOffset = 0,
+  animated = true,
+  forceScroll,
+  isInitialScroll,
+  viewPosition
+}) {
+  const state = ctx.state;
+  const { data } = state.props;
+  index = clampScrollIndex(index, data.length);
+  const itemSize = getItemSizeAtIndex(ctx, index);
+  const firstIndexOffset = calculateOffsetForIndex(ctx, index);
+  const isLast = index === data.length - 1;
+  if (isLast && viewPosition === void 0) {
+    viewPosition = 1;
+  }
+  state.scrollForNextCalculateItemsInView = void 0;
+  scrollTo(ctx, {
+    animated,
+    forceScroll,
+    index,
+    isInitialScroll,
+    itemSize,
+    offset: firstIndexOffset,
+    viewOffset,
+    viewPosition: viewPosition != null ? viewPosition : 0
+  });
+}
+
+// src/core/initialScroll.ts
+function dispatchInitialScroll(ctx, params) {
+  const { forceScroll, resolvedOffset, target, waitForCompletionFrame } = params;
+  const requestedIndex = target.index;
+  const index = requestedIndex !== void 0 ? clampScrollIndex(requestedIndex, ctx.state.props.data.length) : void 0;
+  const itemSize = getItemSizeAtIndex(ctx, index);
+  scrollTo(ctx, {
+    animated: false,
+    forceScroll,
+    index: index !== void 0 && index >= 0 ? index : void 0,
+    isInitialScroll: true,
+    itemSize,
+    offset: resolvedOffset,
+    precomputedWithViewOffset: true,
+    viewOffset: target.viewOffset,
+    viewPosition: target.viewPosition,
+    waitForInitialScrollCompletionFrame: waitForCompletionFrame
+  });
+}
+function setInitialScrollTarget(state, target, options) {
+  var _a3;
+  state.clearPreservedInitialScrollOnNextFinish = void 0;
+  if (state.timeoutPreservedInitialScrollClear !== void 0) {
+    clearTimeout(state.timeoutPreservedInitialScrollClear);
+    state.timeoutPreservedInitialScrollClear = void 0;
+  }
+  state.initialScroll = target;
+  if ((options == null ? void 0 : options.resetDidFinish) && state.didFinishInitialScroll) {
+    state.didFinishInitialScroll = false;
+  }
+  setInitialScrollSession(state, {
+    kind: ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? "offset" : "bootstrap"
+  });
+}
+function resolveInitialScrollOffset(ctx, initialScroll) {
+  var _a3, _b;
+  const state = ctx.state;
+  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
+    return (_b = initialScroll.contentOffset) != null ? _b : 0;
+  }
+  const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
+  const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
+  return clampScrollOffset(ctx, resolvedOffset, initialScroll);
+}
+function getAdvanceableInitialScrollState(state, options) {
+  const { didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
+  const initialScroll = state.initialScroll;
+  const isInitialScrollInProgress = !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll);
+  const shouldWaitForInitialLayout = !!(options == null ? void 0 : options.requiresMeasuredLayout) && !queuedInitialLayout && !isInitialScrollInProgress;
+  if (!initialScroll || shouldWaitForInitialLayout || didFinishInitialScroll || scrollingTo && !isInitialScrollInProgress) {
+    return void 0;
+  }
+  return {
+    initialScroll,
+    isInitialScrollInProgress,
+    queuedInitialLayout,
+    scrollingTo
+  };
+}
+function advanceMeasuredInitialScroll(ctx, options) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const advanceableState = getAdvanceableInitialScrollState(state, {
+    requiresMeasuredLayout: true
+  });
+  if (!advanceableState) {
+    return false;
+  }
+  const { initialScroll, isInitialScrollInProgress, queuedInitialLayout } = advanceableState;
+  const scrollingTo = isInitialScrollInProgress ? advanceableState.scrollingTo : void 0;
+  const resolvedOffset = resolveInitialScrollOffset(ctx, initialScroll);
+  const activeInitialTargetOffset = scrollingTo ? (_a3 = scrollingTo.targetOffset) != null ? _a3 : scrollingTo.offset : void 0;
+  const didOffsetChange = initialScroll.contentOffset === void 0 || Math.abs(initialScroll.contentOffset - resolvedOffset) > 1;
+  const didActiveInitialTargetChange = activeInitialTargetOffset !== void 0 && Math.abs(activeInitialTargetOffset - resolvedOffset) > 1;
+  const isAlreadyAtDesiredInitialTarget = activeInitialTargetOffset !== void 0 && Math.abs(state.scroll - activeInitialTargetOffset) <= 1 && Math.abs(state.scrollPending - activeInitialTargetOffset) <= 1;
+  if (!(options == null ? void 0 : options.forceScroll) && !didOffsetChange && isInitialScrollInProgress && !didActiveInitialTargetChange) {
+    return false;
+  }
+  if ((options == null ? void 0 : options.forceScroll) && isAlreadyAtDesiredInitialTarget) {
+    return false;
+  }
+  if (didOffsetChange && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) !== "offset") {
+    setInitialScrollTarget(state, { ...initialScroll, contentOffset: resolvedOffset });
+  }
+  const forceScroll = (_c = options == null ? void 0 : options.forceScroll) != null ? _c : !!queuedInitialLayout || isInitialScrollInProgress && didOffsetChange;
+  dispatchInitialScroll(ctx, {
+    forceScroll,
+    resolvedOffset,
+    target: initialScroll
+  });
+  return true;
+}
+function advanceOffsetInitialScroll(ctx, options) {
+  var _a3, _b;
+  const state = ctx.state;
+  const advanceableState = getAdvanceableInitialScrollState(state);
+  if (!advanceableState) {
+    return false;
+  }
+  const { initialScroll, queuedInitialLayout } = advanceableState;
+  const resolvedOffset = (_a3 = initialScroll.contentOffset) != null ? _a3 : 0;
+  const isAlreadyAtDesiredInitialTarget = Math.abs(state.scroll - resolvedOffset) <= 1 && Math.abs(state.scrollPending - resolvedOffset) <= 1;
+  if ((options == null ? void 0 : options.forceScroll) && isAlreadyAtDesiredInitialTarget) {
+    return false;
+  }
+  const hasMeasuredScrollLayout = !!state.lastLayout && state.scrollLength > 0;
+  const forceScroll = (_b = options == null ? void 0 : options.forceScroll) != null ? _b : hasMeasuredScrollLayout || !!queuedInitialLayout;
+  dispatchInitialScroll(ctx, {
+    forceScroll,
+    resolvedOffset,
+    target: initialScroll
+  });
+  return true;
+}
+function advanceCurrentInitialScrollSession(ctx, options) {
+  var _a3;
+  return ((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? advanceOffsetInitialScroll(ctx, {
+    forceScroll: options == null ? void 0 : options.forceScroll
+  }) : advanceMeasuredInitialScroll(ctx, {
+    forceScroll: options == null ? void 0 : options.forceScroll
+  });
+}
+
+// src/utils/checkAllSizesKnown.ts
+function isNullOrUndefined2(value) {
+  return value === null || value === void 0;
+}
+function getMountedIndicesInRange(state, start, end) {
+  if (!isNullOrUndefined2(end) && !isNullOrUndefined2(start) && start >= 0 && end >= 0) {
+    return Array.from(state.containerItemKeys.keys()).map((key) => state.indexByKey.get(key)).filter((index) => index !== void 0 && index >= start && index <= end).sort((a, b) => a - b);
+  }
+  return [];
+}
+function getMountedBufferedIndices(state) {
+  return getMountedIndicesInRange(state, state.startBuffered, state.endBuffered);
+}
+function getMountedNoBufferIndices(state) {
+  return getMountedIndicesInRange(state, state.startNoBuffer, state.endNoBuffer);
+}
+function checkAllSizesKnown(state, indices = getMountedBufferedIndices(state)) {
+  return indices.length > 0 && indices.every((index) => {
+    const key = getId(state, index);
+    return state.sizesKnown.has(key);
+  });
+}
+
+// src/core/bootstrapInitialScroll.ts
+var DEFAULT_BOOTSTRAP_REVEAL_EPSILON = 1;
+var DEFAULT_BOOTSTRAP_REVEAL_MAX_FRAMES = 8;
+var DEFAULT_BOOTSTRAP_REVEAL_MAX_PASSES = 24;
+var BOOTSTRAP_REVEAL_ABORT_WARNING = "LegendList bootstrap initial scroll aborted after exceeding convergence bounds.";
+function getBootstrapInitialScrollSession(state) {
+  var _a3;
+  return ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
+}
+function isOffsetInitialScrollSession(state) {
+  var _a3;
+  return ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+}
+function doVisibleIndicesMatch(previous, next) {
+  if (!previous || previous.length !== next.length) {
+    return false;
+  }
+  for (let i = 0; i < previous.length; i++) {
+    if (previous[i] !== next[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function getBootstrapRevealVisibleIndices(options) {
+  const { dataLength, getSize, offset, positions, scrollLength, startIndex: requestedStartIndex } = options;
+  const endOffset = offset + scrollLength;
+  const visibleIndices = [];
+  let index = requestedStartIndex !== void 0 ? Math.max(0, Math.min(dataLength - 1, requestedStartIndex)) : 0;
+  while (index > 0) {
+    const previousIndex = index - 1;
+    const previousPosition = positions[previousIndex];
+    if (previousPosition === void 0) {
+      index = previousIndex;
+      continue;
+    }
+    const previousSize = getSize(previousIndex);
+    if (previousSize === void 0) {
+      index = previousIndex;
+      continue;
+    }
+    if (previousPosition + previousSize <= offset) {
+      break;
+    }
+    index = previousIndex;
+  }
+  for (; index < dataLength; index++) {
+    const position = positions[index];
+    if (position === void 0) {
+      continue;
+    }
+    const size = getSize(index);
+    if (size === void 0) {
+      continue;
+    }
+    if (position < endOffset && position + size > offset) {
+      visibleIndices.push(index);
+    } else if (visibleIndices.length > 0 && position >= endOffset) {
+      break;
+    }
+  }
+  return visibleIndices;
+}
+function shouldAbortBootstrapReveal(options) {
+  const {
+    mountFrameCount,
+    maxFrames = DEFAULT_BOOTSTRAP_REVEAL_MAX_FRAMES,
+    maxPasses = DEFAULT_BOOTSTRAP_REVEAL_MAX_PASSES,
+    passCount
+  } = options;
+  return mountFrameCount >= maxFrames || passCount >= maxPasses;
+}
+function abortBootstrapRevealIfNeeded(ctx, options) {
+  if (!shouldAbortBootstrapReveal(options)) {
+    return false;
+  }
+  if (IS_DEV) {
+    console.warn(BOOTSTRAP_REVEAL_ABORT_WARNING);
+  }
+  abortBootstrapInitialScroll(ctx);
+  return true;
+}
+function clearBootstrapInitialScrollSession(state) {
+  var _a3;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  const frameHandle = bootstrapInitialScroll == null ? void 0 : bootstrapInitialScroll.frameHandle;
+  if (frameHandle !== void 0 && typeof cancelAnimationFrame === "function") {
+    cancelAnimationFrame(frameHandle);
+  }
+  if (bootstrapInitialScroll) {
+    bootstrapInitialScroll.frameHandle = void 0;
+  }
+  setInitialScrollSession(state, {
+    bootstrap: void 0,
+    kind: (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind
+  });
+}
+function startBootstrapInitialScrollSession(state, options) {
+  var _a3, _b, _c;
+  const previousBootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  setInitialScrollSession(state, {
+    bootstrap: {
+      frameHandle: previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.frameHandle,
+      // Re-arming during the initial mount should spend from the same watchdog budget.
+      mountFrameCount: (_a3 = previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.mountFrameCount) != null ? _a3 : 0,
+      passCount: 0,
+      previousResolvedOffset: void 0,
+      scroll: options.scroll,
+      seedContentOffset: (_c = (_b = options.seedContentOffset) != null ? _b : previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.seedContentOffset) != null ? _c : options.scroll,
+      targetIndexSeed: options.targetIndexSeed,
+      visibleIndices: void 0
+    },
+    kind: "bootstrap"
+  });
+}
+function resetBootstrapInitialScrollSession(state, options) {
+  var _a3, _b, _c;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  if (!bootstrapInitialScroll) {
+    if ((options == null ? void 0 : options.scroll) !== void 0) {
+      startBootstrapInitialScrollSession(state, {
+        scroll: options.scroll,
+        seedContentOffset: options.seedContentOffset,
+        targetIndexSeed: options.targetIndexSeed
+      });
+    }
+  } else {
+    bootstrapInitialScroll.passCount = 0;
+    bootstrapInitialScroll.previousResolvedOffset = void 0;
+    bootstrapInitialScroll.scroll = (_a3 = options == null ? void 0 : options.scroll) != null ? _a3 : bootstrapInitialScroll.scroll;
+    bootstrapInitialScroll.seedContentOffset = (_b = options == null ? void 0 : options.seedContentOffset) != null ? _b : bootstrapInitialScroll.seedContentOffset;
+    bootstrapInitialScroll.targetIndexSeed = (_c = options == null ? void 0 : options.targetIndexSeed) != null ? _c : bootstrapInitialScroll.targetIndexSeed;
+    bootstrapInitialScroll.visibleIndices = void 0;
+    setInitialScrollSession(state, {
+      bootstrap: bootstrapInitialScroll,
+      kind: "bootstrap"
+    });
+  }
+}
+function queueBootstrapInitialScrollReevaluation(state) {
+  requestAnimationFrame(() => {
+    var _a3;
+    if (getBootstrapInitialScrollSession(state)) {
+      (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
+    }
+  });
+}
+function ensureBootstrapInitialScrollFrameTicker(ctx) {
+  const state = ctx.state;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  if (!bootstrapInitialScroll || bootstrapInitialScroll.frameHandle !== void 0) {
+    return;
+  }
+  const tick = () => {
+    const activeBootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+    if (!activeBootstrapInitialScroll) {
+      return;
+    }
+    activeBootstrapInitialScroll.frameHandle = void 0;
+    activeBootstrapInitialScroll.mountFrameCount += 1;
+    if (abortBootstrapRevealIfNeeded(ctx, {
+      mountFrameCount: activeBootstrapInitialScroll.mountFrameCount,
+      passCount: activeBootstrapInitialScroll.passCount
+    })) {
+      return;
+    }
+    ensureBootstrapInitialScrollFrameTicker(ctx);
+  };
+  bootstrapInitialScroll.frameHandle = requestAnimationFrame(tick);
+}
+function rearmBootstrapInitialScroll(ctx, options) {
+  resetBootstrapInitialScrollSession(ctx.state, options);
+  ensureBootstrapInitialScrollFrameTicker(ctx);
+  queueBootstrapInitialScrollReevaluation(ctx.state);
+}
+function createInitialScrollAtEndTarget(options) {
+  const { dataLength, footerSize, preserveForFooterLayout, stylePaddingBottom } = options;
+  return {
+    contentOffset: void 0,
+    index: Math.max(0, dataLength - 1),
+    preserveForBottomPadding: true,
+    preserveForFooterLayout,
+    viewOffset: -stylePaddingBottom - footerSize,
+    viewPosition: 1
+  };
+}
+function shouldPreserveInitialScrollForBottomPadding(target) {
+  return !!(target == null ? void 0 : target.preserveForBottomPadding);
+}
+function shouldPreserveInitialScrollForFooterLayout(target) {
+  return !!(target == null ? void 0 : target.preserveForFooterLayout);
+}
+function isRetargetableBottomAlignedInitialScrollTarget(target) {
+  return !!(target && target.viewPosition === 1 && (shouldPreserveInitialScrollForBottomPadding(target) || shouldPreserveInitialScrollForFooterLayout(target)));
+}
+function createRetargetedBottomAlignedInitialScroll(options) {
+  const { dataLength, footerSize, initialScrollAtEnd, stylePaddingBottom, target } = options;
+  const preserveForFooterLayout = shouldPreserveInitialScrollForFooterLayout(target);
+  return {
+    ...target,
+    contentOffset: void 0,
+    index: initialScrollAtEnd ? Math.max(0, dataLength - 1) : target.index,
+    preserveForBottomPadding: true,
+    preserveForFooterLayout,
+    viewOffset: -stylePaddingBottom - (preserveForFooterLayout ? footerSize : 0),
+    viewPosition: 1
+  };
+}
+function areEquivalentBootstrapInitialScrollTargets(current, next) {
+  return current.index === next.index && current.preserveForBottomPadding === next.preserveForBottomPadding && current.preserveForFooterLayout === next.preserveForFooterLayout && current.viewOffset === next.viewOffset && current.viewPosition === next.viewPosition;
+}
+function clearPendingInitialScrollFooterLayout(ctx, options) {
+  const { dataLength, stylePaddingBottom, target } = options;
+  const state = ctx.state;
+  if (!shouldPreserveInitialScrollForFooterLayout(target)) {
+    return;
+  }
+  const clearedFooterTarget = createInitialScrollAtEndTarget({
+    dataLength,
+    footerSize: 0,
+    preserveForFooterLayout: void 0,
+    stylePaddingBottom
+  });
+  setInitialScrollTarget(state, clearedFooterTarget);
+}
+function clearFinishedViewportRetargetableInitialScroll(state) {
+  clearPreservedInitialScrollTarget(state);
+}
+function didFinishedInitialScrollMoveAwayFromTarget(ctx, target, epsilon = DEFAULT_BOOTSTRAP_REVEAL_EPSILON) {
+  const state = ctx.state;
+  if (!state.didFinishInitialScroll) {
+    return false;
+  }
+  const currentOffset = getObservedBootstrapInitialScrollOffset(state);
+  return Math.abs(currentOffset - resolveInitialScrollOffset(ctx, target)) > epsilon;
+}
+function getObservedBootstrapInitialScrollOffset(state) {
+  var _a3, _b, _c, _d;
+  const observedOffset = (_b = (_a3 = state.refScroller.current) == null ? void 0 : _a3.getCurrentScrollOffset) == null ? void 0 : _b.call(_a3);
+  return typeof observedOffset === "number" && Number.isFinite(observedOffset) ? observedOffset : (_d = (_c = state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0;
+}
+function clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx) {
+  var _a3, _b;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  if (!state.didFinishInitialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) || (initialScroll == null ? void 0 : initialScroll.viewPosition) !== 1) {
+    return;
+  }
+  if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
+    if (shouldPreserveInitialScrollForFooterLayout(initialScroll)) {
+      clearPendingInitialScrollFooterLayout(ctx, {
+        dataLength: state.props.data.length,
+        stylePaddingBottom: (_b = state.props.stylePaddingBottom) != null ? _b : 0,
+        target: initialScroll
+      });
+      return;
+    }
+    clearFinishedViewportRetargetableInitialScroll(state);
+  }
+}
+function startBootstrapInitialScrollOnMount(ctx, options) {
+  var _a3, _b, _c;
+  const { initialScrollAtEnd, target } = options;
+  const state = ctx.state;
+  const offset = resolveInitialScrollOffset(ctx, target);
+  const shouldFinishAtOrigin = offset === 0 && !initialScrollAtEnd && (isOffsetInitialScrollSession(state) ? Math.abs((_a3 = target.contentOffset) != null ? _a3 : 0) <= 1 : target.index === 0 && ((_b = target.viewPosition) != null ? _b : 0) === 0 && Math.abs((_c = target.viewOffset) != null ? _c : 0) <= 1);
+  const shouldFinishWithPreservedTarget = state.props.data.length === 0 && target.index !== void 0;
+  if (shouldFinishAtOrigin) {
+    clearBootstrapInitialScrollSession(state);
+    finishInitialScroll(ctx, {
+      resolvedOffset: offset
+    });
+  } else if (shouldFinishWithPreservedTarget) {
+    clearBootstrapInitialScrollSession(state);
+    finishInitialScroll(ctx, {
+      preserveTarget: true,
+      resolvedOffset: offset
+    });
+  } else {
+    startBootstrapInitialScrollSession(state, {
+      scroll: offset,
+      seedContentOffset: 0 ,
+      targetIndexSeed: target.index
+    });
+    ensureBootstrapInitialScrollFrameTicker(ctx);
+  }
+}
+function handleBootstrapInitialScrollDataChange(ctx, options) {
+  const { dataLength, didDataChange, initialScrollAtEnd, previousDataLength, stylePaddingBottom } = options;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  if (isOffsetInitialScrollSession(state) || !initialScroll) {
+    return;
+  }
+  const shouldResetDidFinish = !!(state.didFinishInitialScroll && previousDataLength === 0 && dataLength > 0 && initialScroll.index !== void 0);
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  const shouldClearFinishedResizePreservation = didDataChange && dataLength > 0 && state.didFinishInitialScroll && !bootstrapInitialScroll && !shouldResetDidFinish;
+  if (shouldClearFinishedResizePreservation) {
+    clearPreservedInitialScrollTarget(state);
+    return;
+  }
+  const shouldRetargetBottomAligned = dataLength > 0 && (initialScrollAtEnd || isRetargetableBottomAlignedInitialScrollTarget(initialScroll));
+  if (!didDataChange && !shouldResetDidFinish && !shouldRetargetBottomAligned) {
+    return;
+  }
+  if (shouldRetargetBottomAligned) {
+    const updatedInitialScroll = initialScrollAtEnd ? createInitialScrollAtEndTarget({
+      dataLength,
+      footerSize: peek$(ctx, "footerSize") || 0,
+      preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
+      stylePaddingBottom
+    }) : createRetargetedBottomAlignedInitialScroll({
+      dataLength,
+      footerSize: peek$(ctx, "footerSize") || 0,
+      initialScrollAtEnd,
+      stylePaddingBottom,
+      target: initialScroll
+    });
+    if (!shouldResetDidFinish && didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
+      clearPendingInitialScrollFooterLayout(ctx, {
+        dataLength,
+        stylePaddingBottom,
+        target: initialScroll
+      });
+      return;
+    }
+    if (!areEquivalentBootstrapInitialScrollTargets(initialScroll, updatedInitialScroll) || !!bootstrapInitialScroll || shouldResetDidFinish || didDataChange) {
+      setInitialScrollTarget(state, updatedInitialScroll, {
+        resetDidFinish: shouldResetDidFinish
+      });
+      rearmBootstrapInitialScroll(ctx, {
+        scroll: resolveInitialScrollOffset(ctx, updatedInitialScroll),
+        seedContentOffset: shouldResetDidFinish && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
+        targetIndexSeed: updatedInitialScroll.index
+      });
+      return;
+    }
+  }
+  if (!didDataChange) {
+    return;
+  }
+  if (bootstrapInitialScroll || shouldResetDidFinish) {
+    setInitialScrollTarget(state, initialScroll, {
+      resetDidFinish: shouldResetDidFinish
+    });
+    rearmBootstrapInitialScroll(ctx, {
+      scroll: resolveInitialScrollOffset(ctx, initialScroll),
+      seedContentOffset: shouldResetDidFinish && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
+      targetIndexSeed: initialScroll.index
+    });
+  }
+}
+function handleBootstrapInitialScrollFooterLayout(ctx, options) {
+  const { dataLength, footerSize, initialScrollAtEnd, stylePaddingBottom } = options;
+  const state = ctx.state;
+  if (!initialScrollAtEnd) {
+    return;
+  }
+  const initialScroll = state.initialScroll;
+  if (isOffsetInitialScrollSession(state) || dataLength === 0 || !initialScroll) {
+    return;
+  }
+  const shouldProcessFooterLayout = !!getBootstrapInitialScrollSession(state) || shouldPreserveInitialScrollForFooterLayout(initialScroll);
+  if (!shouldProcessFooterLayout) {
+    return;
+  }
+  if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
+    clearPendingInitialScrollFooterLayout(ctx, {
+      dataLength,
+      stylePaddingBottom,
+      target: initialScroll
+    });
+  } else {
+    const updatedInitialScroll = createInitialScrollAtEndTarget({
+      dataLength,
+      footerSize,
+      preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
+      stylePaddingBottom
+    });
+    const didTargetChange = initialScroll.index !== updatedInitialScroll.index || initialScroll.viewPosition !== updatedInitialScroll.viewPosition || initialScroll.viewOffset !== updatedInitialScroll.viewOffset;
+    if (!didTargetChange) {
+      clearPendingInitialScrollFooterLayout(ctx, {
+        dataLength,
+        stylePaddingBottom,
+        target: initialScroll
+      });
+    } else {
+      const didFinishInitialScroll = !!state.didFinishInitialScroll;
+      setInitialScrollTarget(state, updatedInitialScroll, {
+        resetDidFinish: didFinishInitialScroll
+      });
+      rearmBootstrapInitialScroll(ctx, {
+        scroll: resolveInitialScrollOffset(ctx, updatedInitialScroll),
+        targetIndexSeed: updatedInitialScroll.index
+      });
+    }
+  }
+}
+function handleBootstrapInitialScrollLayoutChange(ctx) {
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  if (isOffsetInitialScrollSession(state) || state.props.data.length === 0 || !initialScroll) {
+    return;
+  }
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  if (!bootstrapInitialScroll && initialScroll.viewPosition !== 1) {
+    return;
+  }
+  const didFinishInitialScroll = state.didFinishInitialScroll;
+  if (didFinishInitialScroll) {
+    setInitialScrollTarget(state, initialScroll, {
+      resetDidFinish: true
+    });
+    state.clearPreservedInitialScrollOnNextFinish = true;
+  }
+  rearmBootstrapInitialScroll(ctx, {
+    scroll: resolveInitialScrollOffset(ctx, initialScroll),
+    seedContentOffset: didFinishInitialScroll && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
+    targetIndexSeed: initialScroll.index
+  });
+}
+function evaluateBootstrapInitialScroll(ctx) {
+  var _a3, _b;
+  const state = ctx.state;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  const initialScroll = state.initialScroll;
+  if (!bootstrapInitialScroll || !initialScroll || isOffsetInitialScrollSession(state) || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll)) {
+    return;
+  }
+  bootstrapInitialScroll.passCount += 1;
+  if (abortBootstrapRevealIfNeeded(ctx, {
+    mountFrameCount: bootstrapInitialScroll.mountFrameCount,
+    passCount: bootstrapInitialScroll.passCount
+  })) {
+    return;
+  }
+  if (initialScroll.index !== void 0 && state.startBuffered >= 0 && state.endBuffered >= 0 && initialScroll.index >= state.startBuffered && initialScroll.index <= state.endBuffered) {
+    bootstrapInitialScroll.targetIndexSeed = void 0;
+  }
+  const resolvedOffset = resolveInitialScrollOffset(ctx, initialScroll);
+  const mountedBufferedIndices = getMountedBufferedIndices(state);
+  const areMountedBufferedIndicesMeasured = checkAllSizesKnown(state, mountedBufferedIndices);
+  const didResolvedOffsetChange = Math.abs(bootstrapInitialScroll.scroll - resolvedOffset) > 1;
+  const { data } = state.props;
+  const visibleIndices = getBootstrapRevealVisibleIndices({
+    dataLength: data.length,
+    getSize: (index) => {
+      var _a4, _b2;
+      const id = (_a4 = state.idCache[index]) != null ? _a4 : getId(state, index);
+      return (_b2 = state.sizes.get(id)) != null ? _b2 : getItemSize(ctx, id, index, data[index]);
+    },
+    offset: resolvedOffset,
+    positions: state.positions,
+    scrollLength: state.scrollLength,
+    startIndex: (_b = bootstrapInitialScroll.targetIndexSeed) != null ? _b : state.startBuffered >= 0 ? state.startBuffered : void 0
+  });
+  const areVisibleIndicesMeasured = visibleIndices.length > 0 && visibleIndices.every((index) => {
+    var _a4;
+    const id = (_a4 = state.idCache[index]) != null ? _a4 : getId(state, index);
+    return state.sizesKnown.has(id);
+  });
+  const previousResolvedOffset = bootstrapInitialScroll.previousResolvedOffset;
+  const previousVisibleIndices = bootstrapInitialScroll.visibleIndices;
+  bootstrapInitialScroll.previousResolvedOffset = resolvedOffset;
+  bootstrapInitialScroll.visibleIndices = visibleIndices;
+  if (didResolvedOffsetChange) {
+    bootstrapInitialScroll.scroll = resolvedOffset;
+    queueBootstrapInitialScrollReevaluation(state);
+    return;
+  }
+  if (!areMountedBufferedIndicesMeasured || !areVisibleIndicesMeasured) {
+    return;
+  }
+  const didRevealSettle = previousResolvedOffset !== void 0 && Math.abs(previousResolvedOffset - resolvedOffset) <= DEFAULT_BOOTSTRAP_REVEAL_EPSILON && doVisibleIndicesMatch(previousVisibleIndices, visibleIndices);
+  if (!didRevealSettle) {
+    queueBootstrapInitialScrollReevaluation(state);
+    return;
+  }
+  {
+    clearBootstrapInitialScrollSession(state);
+    dispatchInitialScroll(ctx, {
+      forceScroll: true,
+      resolvedOffset,
+      target: initialScroll,
+      waitForCompletionFrame: Platform.OS === "web"
+    });
+  }
+}
+function finishBootstrapInitialScrollWithoutScroll(ctx, resolvedOffset) {
+  var _a3;
+  const state = ctx.state;
+  clearBootstrapInitialScrollSession(state);
+  const shouldPreserveResizeTarget = !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_a3 = state.initialScroll) == null ? void 0 : _a3.viewPosition) === 1;
+  finishInitialScroll(ctx, {
+    preserveTarget: shouldPreserveResizeTarget,
+    recalculateItems: true,
+    resolvedOffset,
+    schedulePreservedTargetClear: shouldPreserveResizeTarget
+  });
+}
+function abortBootstrapInitialScroll(ctx) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  const initialScroll = state.initialScroll;
+  if (bootstrapInitialScroll && initialScroll && !isOffsetInitialScrollSession(state) && state.refScroller.current) {
+    clearBootstrapInitialScrollSession(state);
+    dispatchInitialScroll(ctx, {
+      forceScroll: true,
+      resolvedOffset: bootstrapInitialScroll.scroll,
+      target: initialScroll,
+      waitForCompletionFrame: Platform.OS === "web"
+    });
+  } else {
+    finishBootstrapInitialScrollWithoutScroll(
+      ctx,
+      (_d = (_c = (_b = (_a3 = getBootstrapInitialScrollSession(state)) == null ? void 0 : _a3.scroll) != null ? _b : state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0
+    );
+  }
+}
+
+// src/core/checkFinishedScroll.ts
+var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
+var INITIAL_SCROLL_COMPLETION_TARGET_EPSILON = 1;
+var INITIAL_SCROLL_ZERO_TARGET_EPSILON = 1;
+var SILENT_INITIAL_SCROLL_RETRY_DELAY_MS = 16;
+function checkFinishedScroll(ctx, options) {
+  const scrollingTo = ctx.state.scrollingTo;
+  if (options == null ? void 0 : options.onlyIfAligned) {
+    if (!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) || scrollingTo.animated) {
+      return;
+    }
+    if (!getResolvedScrollCompletionState(ctx, scrollingTo).isAtResolvedTarget) {
+      return;
+    }
+  }
+  ctx.state.animFrameCheckFinishedScroll = requestAnimationFrame(() => checkFinishedScrollFrame(ctx));
+}
+function hasScrollCompletionOwnership(state, options) {
+  const { clampedTargetOffset, scrollingTo } = options;
+  return !scrollingTo.isInitialScroll || state.hasScrolled || clampedTargetOffset <= INITIAL_SCROLL_COMPLETION_TARGET_EPSILON;
+}
+function isSilentInitialDispatch(state, scrollingTo) {
+  return !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled;
+}
+function getInitialScrollWatchdogTargetOffset(state) {
+  var _a3;
+  return (_a3 = initialScrollWatchdog.get(state)) == null ? void 0 : _a3.targetOffset;
+}
+function isNativeInitialNonZeroTarget(state) {
+  const targetOffset = getInitialScrollWatchdogTargetOffset(state);
+  return !state.didFinishInitialScroll && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
+}
+function shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) {
+  var _a3, _b;
+  if (!scrollingTo.isInitialScroll || scrollingTo.animated || !state.didContainersLayout) {
+    return false;
+  }
+  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap") {
+    return false;
+  }
+  const targetOffset = (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset;
+  if (initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled) {
+    return false;
+  }
+  if (initialScrollWatchdog.isAtZeroTargetOffset(targetOffset) || Math.abs(state.scroll - targetOffset) > 1 || Math.abs(state.scrollPending - targetOffset) > 1) {
+    return false;
+  }
+  return !!scrollingTo.waitForInitialScrollCompletionFrame || isNativeInitialNonZeroTarget(state);
+}
+function shouldFinishInitialZeroTargetScroll(ctx) {
+  var _a3;
+  const { state } = ctx;
+  return !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) && state.props.data.length > 0 && getContentSize(ctx) <= state.scrollLength && state.scrollPending <= INITIAL_SCROLL_ZERO_TARGET_EPSILON;
+}
+function getResolvedScrollCompletionState(ctx, scrollingTo) {
+  var _a3;
+  const { state } = ctx;
+  const scroll = state.scrollPending;
+  const adjust = state.scrollAdjustHandler.getAdjust();
+  const clampedTargetOffset = (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
+  const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
+  const diff1 = Math.abs(scroll - clampedTargetOffset);
+  const diff2 = Math.abs(diff1 - adjust);
+  return {
+    clampedTargetOffset,
+    isAtResolvedTarget: Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || !scrollingTo.animated && diff2 < 1)
+  };
+}
+function checkFinishedScrollFrame(ctx) {
+  const scrollingTo = ctx.state.scrollingTo;
+  if (!scrollingTo) {
+    return;
+  }
+  const { state } = ctx;
+  state.animFrameCheckFinishedScroll = void 0;
+  const completionState = getResolvedScrollCompletionState(ctx, scrollingTo);
+  if (completionState.isAtResolvedTarget && hasScrollCompletionOwnership(state, {
+    clampedTargetOffset: completionState.clampedTargetOffset,
+    scrollingTo
+  })) {
+    finishScrollTo(ctx);
+  }
+}
+function scrollToFallbackOffset(ctx, offset) {
+  var _a3;
+  (_a3 = ctx.state.refScroller.current) == null ? void 0 : _a3.scrollTo({
+    animated: false,
+    x: ctx.state.props.horizontal ? offset : 0,
+    y: ctx.state.props.horizontal ? 0 : offset
+  });
+}
+function checkFinishedScrollFallback(ctx) {
+  const state = ctx.state;
+  const scrollingTo = state.scrollingTo;
+  const shouldFinishInitialZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+  const silentInitialDispatch = isSilentInitialDispatch(state, scrollingTo);
+  const canFinishInitialWithoutNativeProgress = scrollingTo !== void 0 ? shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) : false;
+  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && !shouldFinishInitialZeroTarget && !canFinishInitialWithoutNativeProgress || !state.didContainersLayout;
+  const initialDelay = shouldFinishInitialZeroTarget || canFinishInitialWithoutNativeProgress ? 0 : silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : slowTimeout ? 500 : 100;
+  state.timeoutCheckFinishedScrollFallback = setTimeout(() => {
+    let numChecks = 0;
+    const scheduleFallbackCheck = (delay) => {
+      state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, delay);
+    };
+    const checkHasScrolled = () => {
+      var _c;
+      state.timeoutCheckFinishedScrollFallback = void 0;
+      const isStillScrollingTo = state.scrollingTo;
+      if (isStillScrollingTo) {
+        numChecks++;
+        const isNativeInitialPending = isNativeInitialNonZeroTarget(state) && !state.hasScrolled;
+        const maxChecks = silentInitialDispatch ? 5 : isNativeInitialPending ? INITIAL_SCROLL_MAX_FALLBACK_CHECKS : 5;
+        const shouldFinishZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+        const canFinishInitialScrollWithoutNativeProgress = shouldFinishInitialScrollWithoutNativeProgress(
+          state,
+          isStillScrollingTo
+        );
+        const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
+        const canFinishAfterSilentNativeDispatch = silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
+        if (shouldFinishZeroTarget || state.hasScrolled || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
+          finishScrollTo(ctx);
+        } else if (isNativeInitialPending && numChecks <= maxChecks) {
+          const targetOffset = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : state.scrollPending;
+          scrollToFallbackOffset(ctx, targetOffset);
+          scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+        } else {
+          scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+        }
+      }
+    };
+    checkHasScrolled();
+  }, initialDelay);
+}
+
+// src/core/initialScrollLifecycle.ts
+function handleInitialScrollLayoutReady(ctx) {
+  var _a3;
+  if (!ctx.state.initialScroll) {
+    return;
+  }
+  const runScroll = () => advanceCurrentInitialScrollSession(ctx, { forceScroll: true });
+  runScroll();
+  if (((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) !== "offset") {
+    requestAnimationFrame(runScroll);
+  }
+  checkFinishedScroll(ctx, { onlyIfAligned: true });
+}
+function initializeInitialScrollOnMount(ctx, options) {
+  var _a3, _b;
+  const { dataLength, hasFooterComponent, initialContentOffset, initialScrollAtEnd, useBootstrapInitialScroll } = options;
   const state = ctx.state;
-  const { animated, horizontal, offset } = params;
-  const scroller = state.refScroller.current;
-  const node = scroller == null ? void 0 : scroller.getScrollableNode();
-  if (!scroller || !node) {
-    return;
-  }
-  const isAnimated = !!animated;
-  const isHorizontal = !!horizontal;
-  const left = isHorizontal ? offset : 0;
-  const top = isHorizontal ? 0 : offset;
-  scroller.scrollTo({ animated: isAnimated, x: left, y: top });
-  if (isAnimated) {
-    const target = scroller.getScrollEventTarget();
-    listenForScrollEnd(ctx, {
-      readOffset: () => scroller.getCurrentScrollOffset(),
-      target,
-      targetOffset: offset
+  const initialScroll = state.initialScroll;
+  const resolvedInitialContentOffset = initialContentOffset != null ? initialContentOffset : 0;
+  const preserveForFooterLayout = useBootstrapInitialScroll && initialScrollAtEnd && hasFooterComponent;
+  if (initialScroll && (initialScroll.contentOffset === void 0 || !!initialScroll.preserveForFooterLayout !== preserveForFooterLayout && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) !== "offset")) {
+    setInitialScrollTarget(state, {
+      ...initialScroll,
+      contentOffset: resolvedInitialContentOffset,
+      preserveForFooterLayout
     });
-  } else {
-    state.scroll = offset;
-    setTimeout(() => {
-      finishScrollTo(ctx);
-    }, 100);
   }
-}
-function listenForScrollEnd(ctx, params) {
-  const { readOffset, target, targetOffset } = params;
-  if (!target) {
-    finishScrollTo(ctx);
+  if (useBootstrapInitialScroll && initialScroll && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) !== "offset") {
+    startBootstrapInitialScrollOnMount(ctx, {
+      initialScrollAtEnd,
+      target: state.initialScroll
+    });
     return;
   }
-  const supportsScrollEnd = "onscrollend" in target;
-  let idleTimeout;
-  let settled = false;
-  const targetToken = ctx.state.scrollingTo;
-  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
-  const cleanup = () => {
-    target.removeEventListener("scroll", onScroll2);
-    if (supportsScrollEnd) {
-      target.removeEventListener("scrollend", onScrollEnd);
-    }
-    if (idleTimeout) {
-      clearTimeout(idleTimeout);
-    }
-    clearTimeout(maxTimeout);
-  };
-  const finish = (reason) => {
-    if (settled) return;
-    if (targetToken !== ctx.state.scrollingTo) {
-      settled = true;
-      cleanup();
-      return;
-    }
-    const currentOffset = readOffset();
-    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
-    if (reason === "scrollend" && !isNearTarget) {
-      return;
-    }
-    settled = true;
-    cleanup();
-    finishScrollTo(ctx);
-  };
-  const onScroll2 = () => {
-    if (idleTimeout) {
-      clearTimeout(idleTimeout);
+  const hasPendingDataDependentInitialScroll = !!initialScroll && dataLength === 0 && !(resolvedInitialContentOffset === 0 && !initialScrollAtEnd);
+  if (!resolvedInitialContentOffset && !hasPendingDataDependentInitialScroll) {
+    if (initialScroll && !initialScrollAtEnd) {
+      finishInitialScroll(ctx, {
+        resolvedOffset: resolvedInitialContentOffset
+      });
+    } else {
+      setInitialRenderState(ctx, { didInitialScroll: true });
     }
-    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
-  };
-  const onScrollEnd = () => finish("scrollend");
-  target.addEventListener("scroll", onScroll2);
-  if (supportsScrollEnd) {
-    target.addEventListener("scrollend", onScrollEnd);
-  } else {
-    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
   }
 }
-
-// src/core/scrollTo.ts
-var WATCHDOG_OFFSET_EPSILON = 1;
-function scrollTo(ctx, params) {
-  var _a3, _b;
+function handleInitialScrollDataChange(ctx, options) {
+  var _a3, _b, _c;
+  const { dataLength, didDataChange, initialScrollAtEnd, stylePaddingBottom, useBootstrapInitialScroll } = options;
   const state = ctx.state;
-  const { noScrollingTo, forceScroll, ...scrollTarget } = params;
-  const { animated, isInitialScroll, offset: scrollTargetOffset, precomputedWithViewOffset } = scrollTarget;
-  const {
-    props: { horizontal }
-  } = state;
-  if (state.animFrameCheckFinishedScroll) {
-    cancelAnimationFrame(ctx.state.animFrameCheckFinishedScroll);
+  const previousDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
+  if (state.initialScrollSession) {
+    state.initialScrollSession.previousDataLength = dataLength;
   }
-  if (state.timeoutCheckFinishedScrollFallback) {
-    clearTimeout(ctx.state.timeoutCheckFinishedScrollFallback);
-  }
-  let offset = precomputedWithViewOffset ? scrollTargetOffset : calculateOffsetWithOffsetPosition(ctx, scrollTargetOffset, scrollTarget);
-  offset = clampScrollOffset(ctx, offset, scrollTarget);
-  state.scrollHistory.length = 0;
-  if (!noScrollingTo) {
-    state.scrollingTo = {
-      ...scrollTarget,
-      targetOffset: offset
-    };
+  setInitialScrollSession(state);
+  if (useBootstrapInitialScroll) {
+    handleBootstrapInitialScrollDataChange(ctx, {
+      dataLength,
+      didDataChange,
+      initialScrollAtEnd,
+      previousDataLength,
+      stylePaddingBottom
+    });
+    return;
   }
-  state.scrollPending = offset;
-  const shouldWatchInitialNativeScroll = !state.didFinishInitialScroll && (isInitialScroll || !!state.initialNativeScrollWatchdog) && offset > WATCHDOG_OFFSET_EPSILON;
-  const shouldClearInitialNativeScrollWatchdog = !state.didFinishInitialScroll && !!state.initialNativeScrollWatchdog && offset <= WATCHDOG_OFFSET_EPSILON;
-  if (shouldWatchInitialNativeScroll) {
-    state.hasScrolled = false;
-    state.initialNativeScrollWatchdog = {
-      startScroll: (_b = (_a3 = state.initialNativeScrollWatchdog) == null ? void 0 : _a3.startScroll) != null ? _b : state.scroll,
-      targetOffset: offset
-    };
-  } else if (shouldClearInitialNativeScrollWatchdog) {
-    state.initialNativeScrollWatchdog = void 0;
+  const shouldReplayFinishedOffsetInitialScroll = previousDataLength === 0 && dataLength > 0 && !!state.initialScroll && ((_c = ctx.state.initialScrollSession) == null ? void 0 : _c.kind) === "offset" && !!state.didFinishInitialScroll;
+  if (previousDataLength !== 0 || dataLength === 0 || !state.initialScroll || !state.queuedInitialLayout || state.didFinishInitialScroll && !shouldReplayFinishedOffsetInitialScroll) {
+    return;
   }
-  if (forceScroll || !isInitialScroll || Platform.OS === "android") {
-    doScrollTo(ctx, { animated, horizontal, offset });
-  } else {
-    state.scroll = offset;
+  if (shouldReplayFinishedOffsetInitialScroll) {
+    state.didFinishInitialScroll = false;
   }
+  advanceCurrentInitialScrollSession(ctx);
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function doMaintainScrollAtEnd(ctx) {
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
   const state = ctx.state;
-  const {
-    didContainersLayout,
-    isAtEnd,
-    pendingNativeMVCPAdjust,
-    refScroller,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const shouldMaintainScrollAtEnd = !!(isAtEnd && maintainScrollAtEnd && didContainersLayout);
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
-  }
-  state.pendingMaintainScrollAtEnd = false;
-  if (shouldMaintainScrollAtEnd) {
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
-    }
-    requestAnimationFrame(() => {
-      var _a3;
-      if (state.isAtEnd) {
-        state.maintainingScrollAtEnd = true;
-        (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
-          animated: maintainScrollAtEnd.animated
-        });
-        setTimeout(
-          () => {
-            state.maintainingScrollAtEnd = false;
-          },
-          maintainScrollAtEnd.animated ? 500 : 0
-        );
+  if (Math.abs(positionDiff) > 0.1) {
+    const doit = () => {
+      {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
       }
-    });
-    return true;
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
+    }
   }
-  return false;
 }
 
 // src/core/mvcp.ts
@@ -2176,7 +3482,7 @@ function resolvePendingNativeMVCPAdjust(ctx, newScroll) {
     settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
     return true;
   }
-  if (state.pendingMaintainScrollAtEnd && state.isAtEnd && progressTowardAmount > MVCP_POSITION_EPSILON) {
+  if (state.pendingMaintainScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold") && progressTowardAmount > MVCP_POSITION_EPSILON) {
     settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
     return true;
   }
@@ -2293,132 +3599,124 @@ function prepareMVCP(ctx, dataChanged) {
               diff = 0;
             }
           }
-          positionDiff = diff;
-          anchorIdForLock = targetId;
-          anchorPositionForLock = newPosition;
-        }
-      }
-      if (scrollingToViewPosition && scrollingToViewPosition > 0) {
-        const newSize = getItemSize(ctx, targetId, scrollTarget, state.props.data[scrollTarget]);
-        const prevSize = scrollingTo == null ? void 0 : scrollingTo.itemSize;
-        if (newSize !== void 0 && prevSize !== void 0 && newSize !== prevSize) {
-          const diff = newSize - prevSize;
-          if (diff !== 0) {
-            positionDiff += diff * scrollingToViewPosition;
-            scrollingTo.itemSize = newSize;
-          }
-        }
-      }
-      updateAnchorLock(state, {
-        anchorId: anchorIdForLock,
-        anchorPosition: anchorPositionForLock,
-        dataChanged,
-        now,
-        positionDiff
-      });
-      if (shouldQueueNativeMVCPAdjust()) {
-        state.pendingNativeMVCPAdjust = {
-          amount: positionDiff,
-          furthestProgressTowardAmount: 0,
-          manualApplied: 0,
-          startScroll: prevScroll
-        };
-        maybeApplyPredictedNativeMVCPAdjust(ctx);
-        return;
-      }
-      if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
-        requestAdjust(ctx, positionDiff);
-      }
-    };
-  }
-}
-
-// src/core/updateScroll.ts
-function updateScroll(ctx, newScroll, forceUpdate) {
-  var _a3;
-  const state = ctx.state;
-  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
-  const prevScroll = state.scroll;
-  state.hasScrolled = true;
-  state.lastBatchingAction = Date.now();
-  const currentTime = Date.now();
-  const adjust = scrollAdjustHandler.getAdjust();
-  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
-  if (adjustChanged) {
-    scrollHistory.length = 0;
-  }
-  state.lastScrollAdjustForHistory = adjust;
-  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
-    if (!adjustChanged) {
-      scrollHistory.push({ scroll: newScroll, time: currentTime });
-    }
-  }
-  if (scrollHistory.length > 5) {
-    scrollHistory.shift();
-  }
-  if (ignoreScrollFromMVCP && !scrollingTo) {
-    const { lt, gt } = ignoreScrollFromMVCP;
-    if (lt && newScroll < lt || gt && newScroll > gt) {
-      state.ignoreScrollFromMVCPIgnored = true;
-      return;
-    }
-  }
-  state.scrollPrev = prevScroll;
-  state.scrollPrevTime = state.scrollTime;
-  state.scroll = newScroll;
-  state.scrollTime = currentTime;
-  const scrollDelta = Math.abs(newScroll - prevScroll);
-  const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
-  const scrollLength = state.scrollLength;
-  const lastCalculated = state.scrollLastCalculate;
-  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
-  if (shouldUpdate) {
-    state.scrollLastCalculate = state.scroll;
-    state.ignoreScrollFromMVCPIgnored = false;
-    state.lastScrollDelta = scrollDelta;
-    const runCalculateItems = () => {
-      var _a4;
-      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0 });
-      checkThresholds(ctx);
+          positionDiff = diff;
+          anchorIdForLock = targetId;
+          anchorPositionForLock = newPosition;
+        }
+      }
+      if (scrollingToViewPosition && scrollingToViewPosition > 0) {
+        const newSize = getItemSize(ctx, targetId, scrollTarget, state.props.data[scrollTarget]);
+        const prevSize = scrollingTo == null ? void 0 : scrollingTo.itemSize;
+        if (newSize !== void 0 && prevSize !== void 0 && newSize !== prevSize) {
+          const diff = newSize - prevSize;
+          if (diff !== 0) {
+            positionDiff += diff * scrollingToViewPosition;
+            scrollingTo.itemSize = newSize;
+          }
+        }
+      }
+      updateAnchorLock(state, {
+        anchorId: anchorIdForLock,
+        anchorPosition: anchorPositionForLock,
+        dataChanged,
+        now,
+        positionDiff
+      });
+      if (shouldQueueNativeMVCPAdjust()) {
+        state.pendingNativeMVCPAdjust = {
+          amount: positionDiff,
+          furthestProgressTowardAmount: 0,
+          manualApplied: 0,
+          startScroll: prevScroll
+        };
+        maybeApplyPredictedNativeMVCPAdjust(ctx);
+        return;
+      }
+      if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
+        requestAdjust(ctx, positionDiff);
+      }
     };
-    if (scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength) {
-      ReactDOM.flushSync(runCalculateItems);
-    } else {
-      runCalculateItems();
-    }
-    const shouldMaintainScrollAtEndAfterPendingSettle = !!state.pendingMaintainScrollAtEnd || !!((_a3 = state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onDataChange);
-    if (didResolvePendingNativeMVCPAdjust && shouldMaintainScrollAtEndAfterPendingSettle) {
-      state.pendingMaintainScrollAtEnd = false;
-      doMaintainScrollAtEnd(ctx);
-    }
-    state.dataChangeNeedsScrollUpdate = false;
-    state.lastScrollDelta = 0;
   }
 }
 
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
+// src/core/syncMountedContainer.ts
+function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
   const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    const doit = () => {
-      {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
+  const {
+    columns,
+    columnSpans,
+    positions,
+    props: { data, itemsAreEqual, keyExtractor }
+  } = state;
+  const item = data[itemIndex];
+  if (item === void 0) {
+    return { didChangePosition: false, didRefreshData: false };
+  }
+  const updateLayout = (_a3 = options == null ? void 0 : options.updateLayout) != null ? _a3 : true;
+  let didChangePosition = false;
+  let didRefreshData = false;
+  if (updateLayout) {
+    const positionValue = positions[itemIndex];
+    if (positionValue === void 0) {
+      set$(ctx, `containerPosition${containerIndex}`, POSITION_OUT_OF_VIEW);
+      return { didChangePosition: false, didRefreshData: false };
+    }
+    const position = (positionValue || 0) - ((_b = options == null ? void 0 : options.scrollAdjustPending) != null ? _b : 0);
+    const column = columns[itemIndex] || 1;
+    const span = columnSpans[itemIndex] || 1;
+    const prevPos = peek$(ctx, `containerPosition${containerIndex}`);
+    const prevColumn = peek$(ctx, `containerColumn${containerIndex}`);
+    const prevSpan = peek$(ctx, `containerSpan${containerIndex}`);
+    if (position > POSITION_OUT_OF_VIEW && position !== prevPos) {
+      set$(ctx, `containerPosition${containerIndex}`, position);
+      didChangePosition = true;
+    }
+    if (column >= 0 && column !== prevColumn) {
+      set$(ctx, `containerColumn${containerIndex}`, column);
+    }
+    if (span !== prevSpan) {
+      set$(ctx, `containerSpan${containerIndex}`, span);
+    }
+  }
+  const prevData = peek$(ctx, `containerItemData${containerIndex}`);
+  if (prevData !== item) {
+    const pendingDataComparison = ((_c = state.pendingDataComparison) == null ? void 0 : _c.previousData) === state.previousData && ((_d = state.pendingDataComparison) == null ? void 0 : _d.nextData) === data ? state.pendingDataComparison : void 0;
+    const cachedComparison = (_e = pendingDataComparison == null ? void 0 : pendingDataComparison.byIndex[itemIndex]) != null ? _e : 0;
+    if (cachedComparison === 2) {
+      set$(ctx, `containerItemData${containerIndex}`, item);
+      didRefreshData = true;
+    } else if (cachedComparison !== 1) {
+      const itemKey = (_g = (_f = peek$(ctx, `containerItemKey${containerIndex}`)) != null ? _f : state.idCache[itemIndex]) != null ? _g : getId(state, itemIndex);
+      const prevKey = keyExtractor == null ? void 0 : keyExtractor(prevData, itemIndex);
+      if (prevData === void 0 || !keyExtractor || prevKey !== itemKey) {
+        set$(ctx, `containerItemData${containerIndex}`, item);
+        didRefreshData = true;
+      } else if (!itemsAreEqual) {
+        set$(ctx, `containerItemData${containerIndex}`, item);
+        didRefreshData = true;
+      } else {
+        const isEqual = itemsAreEqual(prevData, item, itemIndex, data);
+        if (!state.pendingDataComparison || state.pendingDataComparison.previousData !== state.previousData || state.pendingDataComparison.nextData !== data) {
+          if (state.previousData) {
+            state.pendingDataComparison = {
+              byIndex: [],
+              nextData: data,
+              previousData: state.previousData
+            };
+          }
+        }
+        if ((_h = state.pendingDataComparison) == null ? void 0 : _h.byIndex) {
+          state.pendingDataComparison.byIndex[itemIndex] = isEqual ? 1 : 2;
+        }
+        if (!isEqual) {
+          set$(ctx, `containerItemData${containerIndex}`, item);
+          didRefreshData = true;
         }
       }
-    };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-    } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
     }
   }
+  return { didChangePosition, didRefreshData };
 }
 
 // src/core/prepareColumnStartState.ts
@@ -2583,9 +3881,10 @@ function updateSnapToOffsets(ctx) {
 }
 
 // src/core/updateItemPositions.ts
-function updateItemPositions(ctx, dataChanged, { startIndex, scrollBottomBuffered, forceFullUpdate = false, doMVCP } = {
+function updateItemPositions(ctx, dataChanged, { startIndex, scrollBottomBuffered, forceFullUpdate = false, doMVCP, optimizeForVisibleWindow = false } = {
   doMVCP: false,
   forceFullUpdate: false,
+  optimizeForVisibleWindow: false,
   scrollBottomBuffered: -1,
   startIndex: 0
 }) {
@@ -2610,7 +3909,7 @@ function updateItemPositions(ctx, dataChanged, { startIndex, scrollBottomBuffere
   const layoutConfig = overrideItemLayout ? { span: 1 } : void 0;
   const lastScrollDelta = state.lastScrollDelta;
   const velocity = getScrollVelocity(state);
-  const shouldOptimize = !forceFullUpdate && !dataChanged && (Math.abs(velocity) > 0 || state.scrollLength > 0 && lastScrollDelta > state.scrollLength);
+  const shouldOptimize = !forceFullUpdate && !dataChanged && (optimizeForVisibleWindow || Math.abs(velocity) > 0 || state.scrollLength > 0 && lastScrollDelta > state.scrollLength);
   const maxVisibleArea = scrollBottomBuffered + 1e3;
   const useAverageSize = !getEstimatedItemSize;
   const preferCachedSize = !doMVCP || dataChanged || state.scrollAdjustHandler.getAdjust() !== 0 || ((_b = peek$(ctx, "scrollAdjustPending")) != null ? _b : 0) !== 0;
@@ -2725,7 +4024,15 @@ function ensureViewabilityState(ctx, configId) {
   }
   let state = map.get(configId);
   if (!state) {
-    state = { end: -1, previousEnd: -1, previousStart: -1, start: -1, viewableItems: [] };
+    state = {
+      end: -1,
+      endBuffered: -1,
+      previousEnd: -1,
+      previousStart: -1,
+      start: -1,
+      startBuffered: -1,
+      viewableItems: []
+    };
     map.set(configId, state);
   }
   return state;
@@ -2745,7 +4052,7 @@ function setupViewability(props) {
   }
   return viewabilityConfigCallbackPairs;
 }
-function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollSize, start, end) {
+function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollSize, start, end, startBuffered = start, endBuffered = end) {
   const {
     timeouts,
     props: { data }
@@ -2754,6 +4061,8 @@ function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollS
     const viewabilityState = ensureViewabilityState(ctx, viewabilityConfigCallbackPair.viewabilityConfig.id);
     viewabilityState.start = start;
     viewabilityState.end = end;
+    viewabilityState.startBuffered = startBuffered;
+    viewabilityState.endBuffered = endBuffered;
     if (viewabilityConfigCallbackPair.viewabilityConfig.minimumViewTime) {
       const timer = setTimeout(() => {
         timeouts.delete(timer);
@@ -2769,7 +4078,7 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, stat
   const { viewabilityConfig, onViewableItemsChanged } = viewabilityConfigCallbackPair;
   const configId = viewabilityConfig.id;
   const viewabilityState = ensureViewabilityState(ctx, configId);
-  const { viewableItems: previousViewableItems, start, end } = viewabilityState;
+  const { viewableItems: previousViewableItems, start, end, startBuffered, endBuffered } = viewabilityState;
   const viewabilityTokens = /* @__PURE__ */ new Map();
   for (const [containerId, value] of ctx.mapViewabilityAmountValues) {
     viewabilityTokens.set(
@@ -2838,7 +4147,7 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, stat
       maybeUpdateViewabilityCallback(ctx, configId, change.containerId, change);
     }
     if (onViewableItemsChanged) {
-      onViewableItemsChanged({ changed, viewableItems });
+      onViewableItemsChanged({ changed, end, endBuffered, start, startBuffered, viewableItems });
     }
   }
   for (const [containerId, value] of ctx.mapViewabilityAmountValues) {
@@ -2934,23 +4243,6 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
 var unstableBatchedUpdates = ReactDOM__namespace.unstable_batchedUpdates;
 var batchedUpdates = typeof unstableBatchedUpdates === "function" ? unstableBatchedUpdates : (fn) => fn();
 
-// src/utils/checkAllSizesKnown.ts
-function isNullOrUndefined2(value) {
-  return value === null || value === void 0;
-}
-function checkAllSizesKnown(state) {
-  const { startBuffered, endBuffered, sizesKnown } = state;
-  if (!isNullOrUndefined2(endBuffered) && !isNullOrUndefined2(startBuffered) && startBuffered >= 0 && endBuffered >= 0) {
-    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/utils/findAvailableContainers.ts
 function findAvailableContainers(ctx, numNeeded, startBuffered, endBuffered, pendingRemoval, requiredItemTypes, needNewContainers) {
   const numContainers = peek$(ctx, "numContainers");
@@ -3073,97 +4365,11 @@ function comparatorByDistance(a, b) {
   return b.distance - a.distance;
 }
 
-// src/core/scrollToIndex.ts
-function scrollToIndex(ctx, {
-  index,
-  viewOffset = 0,
-  animated = true,
-  forceScroll,
-  isInitialScroll,
-  viewPosition
-}) {
-  const state = ctx.state;
-  const { data } = state.props;
-  if (index >= data.length) {
-    index = data.length - 1;
-  } else if (index < 0) {
-    index = 0;
-  }
-  const firstIndexOffset = calculateOffsetForIndex(ctx, index);
-  const isLast = index === data.length - 1;
-  if (isLast && viewPosition === void 0) {
-    viewPosition = 1;
-  }
-  state.scrollForNextCalculateItemsInView = void 0;
-  const targetId = getId(state, index);
-  const itemSize = getItemSize(ctx, targetId, index, state.props.data[index]);
-  scrollTo(ctx, {
-    animated,
-    forceScroll,
-    index,
-    isInitialScroll,
-    itemSize,
-    offset: firstIndexOffset,
-    viewOffset,
-    viewPosition: viewPosition != null ? viewPosition : 0
-  });
-}
-
-// src/utils/performInitialScroll.ts
-function performInitialScroll(ctx, params) {
-  var _a3;
-  const { forceScroll, initialScrollUsesOffset, resolvedOffset, target } = params;
-  if (initialScrollUsesOffset || resolvedOffset !== void 0) {
-    scrollTo(ctx, {
-      animated: false,
-      forceScroll,
-      index: initialScrollUsesOffset ? void 0 : target.index,
-      isInitialScroll: true,
-      offset: (_a3 = resolvedOffset != null ? resolvedOffset : target.contentOffset) != null ? _a3 : 0,
-      precomputedWithViewOffset: resolvedOffset !== void 0
-    });
-    return;
-  }
-  if (target.index === void 0) {
-    return;
-  }
-  scrollToIndex(ctx, {
-    ...target,
-    animated: false,
-    forceScroll,
-    isInitialScroll: true
-  });
-}
-
 // src/utils/setDidLayout.ts
 function setDidLayout(ctx) {
   const state = ctx.state;
-  const { initialScroll } = state;
   state.queuedInitialLayout = true;
   checkAtBottom(ctx);
-  if (initialScroll) {
-    const runScroll = () => {
-      var _a3, _b;
-      const target = state.initialScroll;
-      if (!target) {
-        return;
-      }
-      const activeInitialTargetOffset = ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) ? (_b = state.scrollingTo.targetOffset) != null ? _b : state.scrollingTo.offset : void 0;
-      const desiredInitialTargetOffset = state.initialScrollUsesOffset ? target.contentOffset : activeInitialTargetOffset;
-      const isAlreadyAtDesiredInitialTarget = desiredInitialTargetOffset !== void 0 && Math.abs(state.scroll - desiredInitialTargetOffset) <= 1 && Math.abs(state.scrollPending - desiredInitialTargetOffset) <= 1;
-      if (!isAlreadyAtDesiredInitialTarget) {
-        performInitialScroll(ctx, {
-          forceScroll: true,
-          initialScrollUsesOffset: state.initialScrollUsesOffset,
-          // Offset-based initial scrolls do not need item lookup, so they can run even before data exists.
-          // Re-run on the next frame to pick up measured viewport size without waiting for index resolution.
-          target
-        });
-      }
-    };
-    runScroll();
-    requestAnimationFrame(runScroll);
-  }
   setInitialRenderState(ctx, { didLayout: true });
 }
 
@@ -3238,7 +4444,7 @@ function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentSt
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
   batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
     const {
       columns,
       columnSpans,
@@ -3246,7 +4452,6 @@ function calculateItemsInView(ctx, params = {}) {
       enableScrollForNextCalculateItemsInView,
       idCache,
       indexByKey,
-      initialScroll,
       minIndexSizeChanged,
       positions,
       props: {
@@ -3254,7 +4459,6 @@ function calculateItemsInView(ctx, params = {}) {
         alwaysRenderIndicesSet,
         drawDistance,
         getItemType,
-        itemsAreEqual,
         keyExtractor,
         onStickyHeaderChange
       },
@@ -3270,6 +4474,8 @@ function calculateItemsInView(ctx, params = {}) {
     const alwaysRenderArr = alwaysRenderIndicesArr || [];
     const alwaysRenderSet = alwaysRenderIndicesSet || /* @__PURE__ */ new Set();
     const { dataChanged, doMVCP, forceFullItemPositions } = params;
+    const bootstrapInitialScrollState = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
+    const suppressInitialScrollSideEffects = !!bootstrapInitialScrollState;
     const prevNumContainers = peek$(ctx, "numContainers");
     if (!data || scrollLength === 0 || !prevNumContainers) {
       return;
@@ -3279,17 +4485,13 @@ function calculateItemsInView(ctx, params = {}) {
     const numColumns = peek$(ctx, "numColumns");
     const speed = getScrollVelocity(state);
     const scrollExtra = 0;
-    const { queuedInitialLayout } = state;
-    let { scroll: scrollState } = state;
-    if (!queuedInitialLayout && initialScroll) {
-      const updatedOffset = state.initialScrollUsesOffset ? (_a3 = initialScroll.contentOffset) != null ? _a3 : 0 : calculateOffsetWithOffsetPosition(
-        ctx,
-        calculateOffsetForIndex(ctx, initialScroll.index),
-        initialScroll
-      );
-      scrollState = updatedOffset;
-    }
-    const scrollAdjustPending = (_b = peek$(ctx, "scrollAdjustPending")) != null ? _b : 0;
+    const { initialScroll, queuedInitialLayout } = state;
+    const scrollState = suppressInitialScrollSideEffects ? (_b = bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.scroll) != null ? _b : state.scroll : !queuedInitialLayout && hasActiveInitialScroll(state) && initialScroll ? (
+      // Before the initial layout settles, keep viewport math anchored to the
+      // current initial-scroll target instead of transient native adjustments.
+      resolveInitialScrollOffset(ctx, initialScroll)
+    ) : state.scroll;
+    const scrollAdjustPending = (_c = peek$(ctx, "scrollAdjustPending")) != null ? _c : 0;
     const scrollAdjustPad = scrollAdjustPending - topPad;
     let scroll = Math.round(scrollState + scrollExtra + scrollAdjustPad);
     if (scroll + scrollLength > totalSize) {
@@ -3313,7 +4515,7 @@ function calculateItemsInView(ctx, params = {}) {
     const scrollTopBuffered = scroll - scrollBufferTop;
     const scrollBottom = scroll + scrollLength + (scroll < 0 ? -scroll : 0);
     const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
-    if (!dataChanged && !forceFullItemPositions && scrollForNextCalculateItemsInView) {
+    if (!suppressInitialScrollSideEffects && !dataChanged && !forceFullItemPositions && scrollForNextCalculateItemsInView) {
       const { top, bottom } = scrollForNextCalculateItemsInView;
       if (top === null && bottom === null) {
         state.scrollForNextCalculateItemsInView = void 0;
@@ -3323,7 +4525,7 @@ function calculateItemsInView(ctx, params = {}) {
         }
       }
     }
-    const checkMVCP = doMVCP ? prepareMVCP(ctx, dataChanged) : void 0;
+    const checkMVCP = doMVCP && !suppressInitialScrollSideEffects ? prepareMVCP(ctx, dataChanged) : void 0;
     if (dataChanged) {
       indexByKey.clear();
       idCache.length = 0;
@@ -3331,10 +4533,12 @@ function calculateItemsInView(ctx, params = {}) {
       columns.length = 0;
       columnSpans.length = 0;
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_c = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _c : 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_d = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _d : 0;
+    const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && minIndexSizeChanged !== void 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
       forceFullUpdate: !!forceFullItemPositions,
+      optimizeForVisibleWindow,
       scrollBottomBuffered,
       startIndex
     });
@@ -3348,11 +4552,11 @@ function calculateItemsInView(ctx, params = {}) {
     let startBufferedId = null;
     let endNoBuffer = null;
     let endBuffered = null;
-    let loopStart = !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
+    let loopStart = (_e = suppressInitialScrollSideEffects ? bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.targetIndexSeed : void 0) != null ? _e : !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
-      const id = (_d = idCache[i]) != null ? _d : getId(state, i);
+      const id = (_f = idCache[i]) != null ? _f : getId(state, i);
       const top = positions[i];
-      const size = (_e = sizes.get(id)) != null ? _e : getItemSize(ctx, id, i, data[i]);
+      const size = (_g = sizes.get(id)) != null ? _g : getItemSize(ctx, id, i, data[i]);
       const bottom = top + size;
       if (bottom > scroll - scrollBufferTop) {
         loopStart = i;
@@ -3383,8 +4587,8 @@ function calculateItemsInView(ctx, params = {}) {
     let firstFullyOnScreenIndex;
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = (_f = idCache[i]) != null ? _f : getId(state, i);
-      const size = (_g = sizes.get(id)) != null ? _g : getItemSize(ctx, id, i, data[i]);
+      const id = (_h = idCache[i]) != null ? _h : getId(state, i);
+      const size = (_i = sizes.get(id)) != null ? _i : getItemSize(ctx, id, i, data[i]);
       const top = positions[i];
       if (!foundEnd) {
         if (startNoBuffer === null && top + size > scroll) {
@@ -3423,7 +4627,7 @@ function calculateItemsInView(ctx, params = {}) {
     const firstVisibleAnchorIndex = firstFullyOnScreenIndex != null ? firstFullyOnScreenIndex : startNoBuffer;
     if (firstVisibleAnchorIndex !== null && firstVisibleAnchorIndex !== void 0 && endNoBuffer !== null) {
       for (let i = firstVisibleAnchorIndex; i <= endNoBuffer; i++) {
-        const id = (_h = idCache[i]) != null ? _h : getId(state, i);
+        const id = (_j = idCache[i]) != null ? _j : getId(state, i);
         idsInView.push(id);
       }
     }
@@ -3456,7 +4660,7 @@ function calculateItemsInView(ctx, params = {}) {
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
       for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_i = idCache[i]) != null ? _i : getId(state, i);
+        const id = (_k = idCache[i]) != null ? _k : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainersSet.add(i);
           needNewContainers.push(i);
@@ -3465,7 +4669,7 @@ function calculateItemsInView(ctx, params = {}) {
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_j = idCache[index]) != null ? _j : getId(state, index);
+          const id = (_l = idCache[index]) != null ? _l : getId(state, index);
           if (id && !containerItemKeys.has(id) && !needNewContainersSet.has(index)) {
             needNewContainersSet.add(index);
             needNewContainers.push(index);
@@ -3503,7 +4707,7 @@ function calculateItemsInView(ctx, params = {}) {
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
           const containerIndex = availableContainers[idx];
-          const id = (_k = idCache[i]) != null ? _k : getId(state, i);
+          const id = (_m = idCache[i]) != null ? _m : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -3544,7 +4748,7 @@ function calculateItemsInView(ctx, params = {}) {
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_l = idCache[index]) != null ? _l : getId(state, index);
+          const id = (_n = idCache[index]) != null ? _n : getId(state, index);
           const containerIndex = containerItemKeys.get(id);
           if (containerIndex !== void 0) {
             state.stickyContainerPool.add(containerIndex);
@@ -3582,46 +4786,39 @@ function calculateItemsInView(ctx, params = {}) {
         set$(ctx, `containerSpan${i}`, 1);
       } else {
         const itemIndex = indexByKey.get(itemKey);
-        const item = data[itemIndex];
-        if (item !== void 0) {
-          const positionValue = positions[itemIndex];
-          if (positionValue === void 0) {
-            set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
-          } else {
-            const position = (positionValue || 0) - scrollAdjustPending;
-            const column = columns[itemIndex] || 1;
-            const span = columnSpans[itemIndex] || 1;
-            const prevPos = peek$(ctx, `containerPosition${i}`);
-            const prevColumn = peek$(ctx, `containerColumn${i}`);
-            const prevSpan = peek$(ctx, `containerSpan${i}`);
-            const prevData = peek$(ctx, `containerItemData${i}`);
-            if (position > POSITION_OUT_OF_VIEW && position !== prevPos) {
-              set$(ctx, `containerPosition${i}`, position);
-              didChangePositions = true;
-            }
-            if (column >= 0 && column !== prevColumn) {
-              set$(ctx, `containerColumn${i}`, column);
-            }
-            if (span !== prevSpan) {
-              set$(ctx, `containerSpan${i}`, span);
-            }
-            if (prevData !== item && (itemsAreEqual ? !itemsAreEqual(prevData, item, itemIndex, data) : true)) {
-              set$(ctx, `containerItemData${i}`, item);
-            }
-          }
+        if (itemIndex !== void 0) {
+          didChangePositions = syncMountedContainer(ctx, i, itemIndex, {
+            scrollAdjustPending,
+            updateLayout: true
+          }).didChangePosition || didChangePositions;
         }
       }
     }
     if (didChangePositions) {
       set$(ctx, "lastPositionUpdate", Date.now());
     }
-    if (!queuedInitialLayout && endBuffered !== null) {
-      if (checkAllSizesKnown(state)) {
-        setDidLayout(ctx);
-      }
+    if (suppressInitialScrollSideEffects) {
+      evaluateBootstrapInitialScroll(ctx);
+      return;
+    }
+    const mountedBufferedIndices = getMountedBufferedIndices(state);
+    const mountedNoBufferIndices = getMountedNoBufferIndices(state);
+    const readinessIndices = hasActiveInitialScroll(state) ? mountedBufferedIndices : mountedNoBufferIndices.length > 0 ? mountedNoBufferIndices : mountedBufferedIndices;
+    if (!queuedInitialLayout && readinessIndices.length > 0 && checkAllSizesKnown(state, readinessIndices)) {
+      setDidLayout(ctx);
+      handleInitialScrollLayoutReady(ctx);
     }
-    if (viewabilityConfigCallbackPairs) {
-      updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollLength, startNoBuffer, endNoBuffer);
+    if (viewabilityConfigCallbackPairs && startNoBuffer !== null && endNoBuffer !== null) {
+      updateViewableItems(
+        ctx.state,
+        ctx,
+        viewabilityConfigCallbackPairs,
+        scrollLength,
+        startNoBuffer,
+        endNoBuffer,
+        startBuffered != null ? startBuffered : startNoBuffer,
+        endBuffered != null ? endBuffered : endNoBuffer
+      );
     }
     if (onStickyHeaderChange && stickyIndicesArr.length > 0 && nextActiveStickyIndex !== void 0 && nextActiveStickyIndex !== previousStickyIndex) {
       const item = data[nextActiveStickyIndex];
@@ -3632,163 +4829,63 @@ function calculateItemsInView(ctx, params = {}) {
   });
 }
 
-// src/core/checkActualChange.ts
-function checkActualChange(state, dataProp, previousData) {
-  if (!previousData || !dataProp || dataProp.length !== previousData.length) {
-    return true;
-  }
-  const {
-    idCache,
-    props: { keyExtractor }
-  } = state;
-  for (let i = 0; i < dataProp.length; i++) {
-    if (dataProp[i] !== previousData[i]) {
-      return true;
-    }
-    if (keyExtractor ? idCache[i] !== keyExtractor(previousData[i], i) : dataProp[i] !== previousData[i]) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// src/core/checkFinishedScroll.ts
-var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
-var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
-var INITIAL_SCROLL_ZERO_TARGET_EPSILON = 1;
-function checkFinishedScroll(ctx) {
-  ctx.state.animFrameCheckFinishedScroll = requestAnimationFrame(() => checkFinishedScrollFrame(ctx));
-}
-function checkFinishedScrollFrame(ctx) {
-  var _a3;
-  const scrollingTo = ctx.state.scrollingTo;
-  if (scrollingTo) {
-    const { state } = ctx;
-    state.animFrameCheckFinishedScroll = void 0;
-    const scroll = state.scrollPending;
-    const adjust = state.scrollAdjustHandler.getAdjust();
-    const clampedTargetOffset = (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
-    const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
-    const diff1 = Math.abs(scroll - clampedTargetOffset);
-    const diff2 = Math.abs(diff1 - adjust);
-    const isNotOverscrolled = Math.abs(scroll - maxOffset) < 1;
-    const isAtTarget = diff1 < 1 || !scrollingTo.animated && diff2 < 1;
-    if (isNotOverscrolled && isAtTarget) {
-      finishScrollTo(ctx);
-    }
-  }
-}
-function checkFinishedScrollFallback(ctx) {
+// src/core/doMaintainScrollAtEnd.ts
+function doMaintainScrollAtEnd(ctx) {
   const state = ctx.state;
-  const scrollingTo = state.scrollingTo;
-  const shouldFinishInitialZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
-  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && !shouldFinishInitialZeroTarget || !state.didContainersLayout;
-  state.timeoutCheckFinishedScrollFallback = setTimeout(
-    () => {
-      let numChecks = 0;
-      const checkHasScrolled = () => {
-        var _a3, _b;
-        state.timeoutCheckFinishedScrollFallback = void 0;
-        const isStillScrollingTo = state.scrollingTo;
-        if (isStillScrollingTo) {
-          numChecks++;
-          const isNativeInitialPending = isNativeInitialNonZeroTarget(state) && !state.hasScrolled;
-          const maxChecks = isNativeInitialPending ? INITIAL_SCROLL_MAX_FALLBACK_CHECKS : 5;
-          const shouldFinishZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
-          if (shouldFinishZeroTarget || state.hasScrolled || numChecks > maxChecks) {
-            finishScrollTo(ctx);
-          } else if (isNativeInitialPending && numChecks <= maxChecks) {
-            const targetOffset = (_b = (_a3 = state.initialNativeScrollWatchdog) == null ? void 0 : _a3.targetOffset) != null ? _b : state.scrollPending;
-            const scroller = state.refScroller.current;
-            if (scroller) {
-              scroller.scrollTo({
-                animated: false,
-                x: state.props.horizontal ? targetOffset : 0,
-                y: state.props.horizontal ? 0 : targetOffset
-              });
-            }
-            state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, 100);
-          } else {
-            state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, 100);
-          }
-        }
-      };
-      checkHasScrolled();
-    },
-    slowTimeout ? 500 : 100
-  );
-}
-function isNativeInitialNonZeroTarget(state) {
-  return !state.didFinishInitialScroll && !!state.initialNativeScrollWatchdog && state.initialNativeScrollWatchdog.targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
-}
-function shouldFinishInitialZeroTargetScroll(ctx) {
-  var _a3;
-  const { state } = ctx;
-  return !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) && state.props.data.length > 0 && getContentSize(ctx) <= state.scrollLength && state.scrollPending <= INITIAL_SCROLL_ZERO_TARGET_EPSILON;
-}
-
-// src/utils/updateAveragesOnDataChange.ts
-function updateAveragesOnDataChange(state, oldData, newData) {
-  var _a3;
   const {
-    averageSizes,
-    sizesKnown,
-    indexByKey,
-    props: { itemsAreEqual, getItemType, keyExtractor }
+    didContainersLayout,
+    pendingNativeMVCPAdjust,
+    refScroller,
+    props: { maintainScrollAtEnd }
   } = state;
-  if (!itemsAreEqual || !oldData.length || !newData.length) {
-    for (const key in averageSizes) {
-      delete averageSizes[key];
-    }
-    return;
-  }
-  const itemTypesToPreserve = {};
-  const newDataLength = newData.length;
-  const oldDataLength = oldData.length;
-  for (let newIndex = 0; newIndex < newDataLength; newIndex++) {
-    const newItem = newData[newIndex];
-    const id = keyExtractor ? keyExtractor(newItem, newIndex) : String(newIndex);
-    const oldIndex = indexByKey.get(id);
-    if (oldIndex !== void 0 && oldIndex < oldDataLength) {
-      const knownSize = sizesKnown.get(id);
-      if (knownSize === void 0) continue;
-      const oldItem = oldData[oldIndex];
-      const areEqual = itemsAreEqual(oldItem, newItem, newIndex, newData);
-      if (areEqual) {
-        const itemType = getItemType ? (_a3 = getItemType(newItem, newIndex)) != null ? _a3 : "" : "";
-        let typeData = itemTypesToPreserve[itemType];
-        if (!typeData) {
-          typeData = itemTypesToPreserve[itemType] = { count: 0, totalSize: 0 };
-        }
-        typeData.totalSize += knownSize;
-        typeData.count++;
-      }
-    }
-  }
-  for (const key in averageSizes) {
-    delete averageSizes[key];
+  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    return false;
   }
-  for (const itemType in itemTypesToPreserve) {
-    const { totalSize, count } = itemTypesToPreserve[itemType];
-    if (count > 0) {
-      averageSizes[itemType] = {
-        avg: totalSize / count,
-        num: count
-      };
+  state.pendingMaintainScrollAtEnd = false;
+  if (shouldMaintainScrollAtEnd) {
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
+      state.scroll = 0;
     }
+    requestAnimationFrame(() => {
+      var _a3;
+      if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
+        state.maintainingScrollAtEnd = true;
+        (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
+          animated: maintainScrollAtEnd.animated
+        });
+        setTimeout(
+          () => {
+            state.maintainingScrollAtEnd = false;
+          },
+          maintainScrollAtEnd.animated ? 500 : 0
+        );
+      }
+    });
+    return true;
   }
+  return false;
 }
 
 // src/core/checkResetContainers.ts
-function checkResetContainers(ctx, dataProp) {
+function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {}) {
   const state = ctx.state;
   const { previousData } = state;
-  if (previousData) {
-    updateAveragesOnDataChange(state, previousData, dataProp);
-  }
   const { maintainScrollAtEnd } = state.props;
+  if (didColumnsChange) {
+    state.sizes.clear();
+    state.sizesKnown.clear();
+    for (const key in state.averageSizes) {
+      delete state.averageSizes[key];
+    }
+    state.minIndexSizeChanged = 0;
+    state.scrollForNextCalculateItemsInView = void 0;
+  }
   calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
-  const shouldMaintainScrollAtEnd = maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onDataChange;
+  const shouldMaintainScrollAtEnd = !didColumnsChange && (maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onDataChange);
   const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx);
   if (!didMaintainScrollAtEnd && previousData && dataProp.length > previousData.length) {
     state.isEndReached = false;
@@ -3799,6 +4896,53 @@ function checkResetContainers(ctx, dataProp) {
   delete state.previousData;
 }
 
+// src/core/checkStructuralDataChange.ts
+function checkStructuralDataChange(state, dataProp, previousData) {
+  var _a3;
+  state.pendingDataComparison = void 0;
+  if (!previousData || !dataProp || dataProp.length !== previousData.length) {
+    return true;
+  }
+  const {
+    idCache,
+    props: { itemsAreEqual, keyExtractor }
+  } = state;
+  let byIndex;
+  for (let i = 0; i < dataProp.length; i++) {
+    if (dataProp[i] === previousData[i]) {
+      continue;
+    }
+    if (!keyExtractor) {
+      if (byIndex) {
+        state.pendingDataComparison = { byIndex, nextData: dataProp, previousData };
+      }
+      return true;
+    }
+    const previousKey = (_a3 = idCache[i]) != null ? _a3 : keyExtractor(previousData[i], i);
+    const nextKey = keyExtractor(dataProp[i], i);
+    if (previousKey !== nextKey) {
+      if (byIndex) {
+        state.pendingDataComparison = { byIndex, nextData: dataProp, previousData };
+      }
+      return true;
+    }
+    if (!itemsAreEqual) {
+      if (byIndex) {
+        state.pendingDataComparison = { byIndex, nextData: dataProp, previousData };
+      }
+      return true;
+    }
+    const isEqual = itemsAreEqual(previousData[i], dataProp[i], i, dataProp);
+    byIndex != null ? byIndex : byIndex = [];
+    byIndex[i] = isEqual ? 1 : 2;
+    if (!isEqual) {
+      state.pendingDataComparison = { byIndex, nextData: dataProp, previousData };
+      return true;
+    }
+  }
+  return false;
+}
+
 // src/core/doInitialAllocateContainers.ts
 function doInitialAllocateContainers(ctx) {
   var _a3, _b, _c;
@@ -3914,20 +5058,102 @@ function handleLayout(ctx, layoutParam, setCanRender) {
   setCanRender(true);
 }
 
+// src/core/updateScroll.ts
+function updateScroll(ctx, newScroll, forceUpdate) {
+  var _a3;
+  const state = ctx.state;
+  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
+  const prevScroll = state.scroll;
+  state.hasScrolled = true;
+  state.lastBatchingAction = Date.now();
+  const currentTime = Date.now();
+  const adjust = scrollAdjustHandler.getAdjust();
+  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
+  if (adjustChanged) {
+    scrollHistory.length = 0;
+  }
+  state.lastScrollAdjustForHistory = adjust;
+  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
+    if (!adjustChanged) {
+      scrollHistory.push({ scroll: newScroll, time: currentTime });
+    }
+  }
+  if (scrollHistory.length > 5) {
+    scrollHistory.shift();
+  }
+  if (ignoreScrollFromMVCP && !scrollingTo) {
+    const { lt, gt } = ignoreScrollFromMVCP;
+    if (lt && newScroll < lt || gt && newScroll > gt) {
+      state.ignoreScrollFromMVCPIgnored = true;
+      return;
+    }
+  }
+  state.scrollPrev = prevScroll;
+  state.scrollPrevTime = state.scrollTime;
+  state.scroll = newScroll;
+  state.scrollTime = currentTime;
+  const scrollDelta = Math.abs(newScroll - prevScroll);
+  const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
+  const scrollLength = state.scrollLength;
+  const lastCalculated = state.scrollLastCalculate;
+  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
+  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
+  if (shouldUpdate) {
+    state.scrollLastCalculate = state.scroll;
+    state.ignoreScrollFromMVCPIgnored = false;
+    state.lastScrollDelta = scrollDelta;
+    const runCalculateItems = () => {
+      var _a4;
+      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0 });
+      checkThresholds(ctx);
+    };
+    if (scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength) {
+      ReactDOM.flushSync(runCalculateItems);
+    } else {
+      runCalculateItems();
+    }
+    const shouldMaintainScrollAtEndAfterPendingSettle = !!state.pendingMaintainScrollAtEnd || !!((_a3 = state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onDataChange);
+    if (didResolvePendingNativeMVCPAdjust && shouldMaintainScrollAtEndAfterPendingSettle) {
+      state.pendingMaintainScrollAtEnd = false;
+      doMaintainScrollAtEnd(ctx);
+    }
+    state.dataChangeNeedsScrollUpdate = false;
+    state.lastScrollDelta = 0;
+  }
+}
+
 // src/core/onScroll.ts
-var INITIAL_SCROLL_PROGRESS_EPSILON = 1;
-function didObserveInitialScrollProgress(newScroll, watchdog) {
-  const previousDistance = Math.abs(watchdog.startScroll - watchdog.targetOffset);
-  const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
-  return nextDistance <= INITIAL_SCROLL_PROGRESS_EPSILON || nextDistance + INITIAL_SCROLL_PROGRESS_EPSILON < previousDistance;
+function trackInitialScrollNativeProgress(state, newScroll) {
+  const initialNativeScrollWatchdog = initialScrollWatchdog.get(state);
+  const didInitialScrollProgress = !!initialNativeScrollWatchdog && initialScrollWatchdog.didObserveProgress(newScroll, initialNativeScrollWatchdog);
+  if (didInitialScrollProgress) {
+    initialScrollWatchdog.clear(state);
+    return;
+  }
+  if (initialNativeScrollWatchdog) {
+    state.hasScrolled = false;
+    initialScrollWatchdog.set(state, {
+      startScroll: initialNativeScrollWatchdog.startScroll,
+      targetOffset: initialNativeScrollWatchdog.targetOffset
+    });
+  }
+}
+function shouldDeferPublicOnScroll(state) {
+  var _a3;
+  return !!state.initialScroll && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" && !state.didFinishInitialScroll;
+}
+function cloneScrollEvent(event) {
+  return {
+    ...event,
+    nativeEvent: {
+      ...event.nativeEvent
+    }
+  };
 }
 function onScroll(ctx, event) {
   var _a3, _b, _c, _d;
   const state = ctx.state;
-  const {
-    scrollProcessingEnabled,
-    props: { onScroll: onScrollProp }
-  } = state;
+  const { scrollProcessingEnabled } = state;
   if (scrollProcessingEnabled === false) {
     return;
   }
@@ -3958,20 +5184,19 @@ function onScroll(ctx, event) {
     }
   }
   state.scrollPending = newScroll;
-  const initialNativeScrollWatchdog = state.initialNativeScrollWatchdog;
-  const didInitialScrollProgress = !!initialNativeScrollWatchdog && didObserveInitialScrollProgress(newScroll, initialNativeScrollWatchdog);
-  if (didInitialScrollProgress) {
-    state.initialNativeScrollWatchdog = void 0;
-  }
   updateScroll(ctx, newScroll, insetChanged);
-  if (initialNativeScrollWatchdog && !didInitialScrollProgress) {
-    state.hasScrolled = false;
-    state.initialNativeScrollWatchdog = initialNativeScrollWatchdog;
-  }
+  trackInitialScrollNativeProgress(state, newScroll);
+  clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx);
   if (state.scrollingTo) {
     checkFinishedScroll(ctx);
   }
-  onScrollProp == null ? void 0 : onScrollProp(event);
+  if (state.props.onScroll) {
+    if (shouldDeferPublicOnScroll(state)) {
+      state.deferredPublicOnScrollEvent = cloneScrollEvent(event);
+    } else {
+      state.props.onScroll(event);
+    }
+  }
 }
 
 // src/core/ScrollAdjustHandler.ts
@@ -4025,6 +5250,43 @@ var ScrollAdjustHandler = class {
   }
 };
 
+// src/core/updateAnchoredEndSpace.ts
+function maybeUpdateAnchoredEndSpace(ctx) {
+  var _a3;
+  const state = ctx.state;
+  const anchoredEndSpace = state.props.anchoredEndSpace;
+  const previousSize = peek$(ctx, "anchoredEndSpaceSize");
+  let nextSize = 0;
+  if (anchoredEndSpace) {
+    const { anchorIndex, anchorMaxSize, anchorOffset = 0 } = anchoredEndSpace;
+    const { data } = state.props;
+    if (anchorIndex >= 0 && anchorIndex < data.length && state.scrollLength > 0) {
+      let contentBelowAnchor = 0;
+      const footerSize = ctx.values.get("footerSize") || 0;
+      const stylePaddingBottom = state.props.stylePaddingBottom || 0;
+      for (let index = anchorIndex; index < data.length; index++) {
+        const itemKey = getId(state, index);
+        const size = itemKey ? state.sizesKnown.get(itemKey) : void 0;
+        const effectiveSize = index === anchorIndex && anchorMaxSize !== void 0 ? Math.min(size || 0, Math.max(0, anchorMaxSize)) : size;
+        if (effectiveSize !== null && effectiveSize !== void 0 && effectiveSize > 0) {
+          contentBelowAnchor += effectiveSize;
+        }
+      }
+      contentBelowAnchor += footerSize + stylePaddingBottom;
+      nextSize = Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+    }
+  }
+  if (previousSize === nextSize) {
+    return nextSize;
+  }
+  set$(ctx, "anchoredEndSpaceSize", nextSize);
+  (_a3 = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onSizeChanged) == null ? void 0 : _a3.call(anchoredEndSpace, nextSize);
+  if (anchoredEndSpace == null ? void 0 : anchoredEndSpace.includeInEndInset) {
+    updateScroll(ctx, state.scroll, true);
+  }
+  return nextSize;
+}
+
 // src/core/updateItemSize.ts
 function runOrScheduleMVCPRecalculate(ctx) {
   const state = ctx.state;
@@ -4106,6 +5368,7 @@ function updateItemSize(ctx, itemKey, sizeObj) {
       previous: size - diff,
       size
     });
+    maybeUpdateAnchoredEndSpace(ctx);
   }
   if (minIndexSizeChanged !== void 0) {
     state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
@@ -4229,7 +5492,7 @@ function createImperativeHandle(ctx) {
   const IMPERATIVE_SCROLL_SETTLE_MAX_WAIT_MS = 800;
   const IMPERATIVE_SCROLL_SETTLE_STABLE_FRAMES = 2;
   let imperativeScrollToken = 0;
-  const isSettlingAfterDataChange = () => !!state.didDataChange || !!state.didColumnsChange || state.queuedMVCPRecalculate !== void 0 || state.ignoreScrollFromMVCP !== void 0 || hasActiveMVCPAnchorLock(state);
+  const isSettlingAfterDataChange = () => !!state.didDataChange || !!state.didColumnsChange || state.queuedMVCPRecalculate !== void 0 || state.ignoreScrollFromMVCP !== void 0;
   const runWhenSettled = (token, run) => {
     const startedAt = Date.now();
     let stableFrames = 0;
@@ -4251,9 +5514,10 @@ function createImperativeHandle(ctx) {
     };
     requestAnimationFrame(check);
   };
-  const runScrollWithPromise = (run) => new Promise((resolve) => {
+  const runScrollWithPromise = (run, options) => new Promise((resolve) => {
     var _a3;
     const token = ++imperativeScrollToken;
+    const shouldWaitOneFrame = !!(options == null ? void 0 : options.shouldWaitOneFrame);
     (_a3 = state.pendingScrollResolve) == null ? void 0 : _a3.call(state);
     state.pendingScrollResolve = resolve;
     const runNow = () => {
@@ -4268,11 +5532,12 @@ function createImperativeHandle(ctx) {
         resolve();
       }
     };
+    const execute = shouldWaitOneFrame ? () => requestAnimationFrame(runNow) : runNow;
     if (isSettlingAfterDataChange()) {
-      runWhenSettled(token, runNow);
-      return;
+      runWhenSettled(token, execute);
+    } else {
+      execute();
     }
-    runNow();
   });
   const scrollIndexIntoView = (options) => {
     if (state) {
@@ -4329,10 +5594,13 @@ function createImperativeHandle(ctx) {
       },
       end: state.endNoBuffer,
       endBuffered: state.endBuffered,
-      isAtEnd: state.isAtEnd,
-      isAtStart: state.isAtStart,
+      isAtEnd: peek$(ctx, "isAtEnd"),
+      isAtStart: peek$(ctx, "isAtStart"),
       isEndReached: state.isEndReached,
+      isNearEnd: peek$(ctx, "isNearEnd"),
+      isNearStart: peek$(ctx, "isNearStart"),
       isStartReached: state.isStartReached,
+      isWithinMaintainScrollAtEndThreshold: peek$(ctx, "isWithinMaintainScrollAtEndThreshold"),
       listen: (signalName, cb) => listen$(ctx, signalName, cb),
       listenToPosition: (key, cb) => listenPosition$(ctx, key, cb),
       positionAtIndex: (index) => state.positions[index],
@@ -4379,10 +5647,15 @@ function createImperativeHandle(ctx) {
       }
       return false;
     }),
-    scrollToIndex: (params) => runScrollWithPromise(() => {
-      scrollToIndex(ctx, params);
-      return true;
-    }),
+    scrollToIndex: (params) => runScrollWithPromise(
+      () => {
+        scrollToIndex(ctx, params);
+        return true;
+      },
+      {
+        shouldWaitOneFrame: params.index >= 0 && params.index >= state.props.data.length
+      }
+    ),
     scrollToItem: ({ item, ...props }) => runScrollWithPromise(() => {
       const data = state.props.data;
       const index = data.indexOf(item);
@@ -4478,7 +5751,7 @@ function getRenderedItem(ctx, key) {
       item,
       type: getItemType ? (_a3 = getItemType(item, index)) != null ? _a3 : "" : ""
     };
-    renderedItem = isFunction(renderItem) ? renderItem(itemProps) : React3__namespace.default.createElement(renderItem, itemProps);
+    renderedItem = React3__namespace.default.createElement(renderItem, itemProps);
   }
   return { index, item: data[index], renderedItem };
 }
@@ -4613,8 +5886,17 @@ var LegendList = typedMemo(
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
   var _a3, _b, _c, _d, _e, _f, _g, _h;
+  const noopOnScroll = React3.useCallback((_event) => {
+  }, []);
+  if (props.recycleItems === void 0) {
+    warnDevOnce(
+      "recycleItems-omitted",
+      "recycleItems was not provided, so it defaults to false. Set recycleItems explicitly to true for better performance with recycling-aware rows, or false to preserve remount-on-reuse behavior."
+    );
+  }
   const {
     alignItemsAtEnd = false,
+    anchoredEndSpace,
     alwaysRender,
     columnWrapperStyle,
     contentContainerStyle: contentContainerStyleProp,
@@ -4636,6 +5918,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     itemsAreEqual,
     keyExtractor: keyExtractorProp,
     ListEmptyComponent,
+    ListFooterComponent,
+    ListFooterComponentStyle,
     ListHeaderComponent,
     maintainScrollAtEnd = false,
     maintainScrollAtEndThreshold = 0.1,
@@ -4672,14 +5956,12 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     useWindowScroll = false,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
-    waitForInitialLayout = true,
     ...rest
   } = props;
   const animatedPropsInternal = props.animatedPropsInternal;
   const positionComponentInternal = props.positionComponentInternal;
   const stickyPositionComponentInternal = props.stickyPositionComponentInternal;
   const {
-    childrenMode,
     positionComponentInternal: _positionComponentInternal,
     stickyPositionComponentInternal: _stickyPositionComponentInternal,
     ...restProps
@@ -4705,8 +5987,15 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const hasInitialScrollIndex = initialScrollIndexProp !== void 0 && initialScrollIndexProp !== null;
   const hasInitialScrollOffset = initialScrollOffsetProp !== void 0 && initialScrollOffsetProp !== null;
   const initialScrollUsesOffsetOnly = !initialScrollAtEnd && !hasInitialScrollIndex && hasInitialScrollOffset;
-  const initialScrollProp = initialScrollAtEnd ? { index: Math.max(0, dataProp.length - 1), viewOffset: -stylePaddingBottomState, viewPosition: 1 } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
+  const usesBootstrapInitialScroll = initialScrollAtEnd || hasInitialScrollIndex;
+  const initialScrollProp = initialScrollAtEnd ? {
+    index: Math.max(0, dataProp.length - 1),
+    preserveForBottomPadding: true,
+    viewOffset: -stylePaddingBottomState,
+    viewPosition: 1
+  } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
     index: (_a3 = initialScrollIndexProp.index) != null ? _a3 : 0,
+    preserveForBottomPadding: initialScrollIndexProp.viewOffset === void 0 && initialScrollIndexProp.viewPosition === 1 ? true : void 0,
     viewOffset: (_b = initialScrollIndexProp.viewOffset) != null ? _b : initialScrollIndexProp.viewPosition === 1 ? -stylePaddingBottomState : 0,
     viewPosition: (_c = initialScrollIndexProp.viewPosition) != null ? _c : 0
   } : {
@@ -4736,18 +6025,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     dataVersion,
     keyExtractor
   ]);
-  if (IS_DEV && stickyIndicesDeprecated && !stickyHeaderIndicesProp) {
-    warnDevOnce(
-      "stickyIndices",
-      "stickyIndices has been renamed to stickyHeaderIndices. Please update your props to use stickyHeaderIndices."
-    );
-  }
-  if (IS_DEV && useWindowScroll && renderScrollComponent) {
-    warnDevOnce(
-      "useWindowScrollRenderScrollComponent",
-      "useWindowScroll is not supported when renderScrollComponent is provided."
-    );
-  }
   const useWindowScrollResolved = !!useWindowScroll && !renderScrollComponent;
   const refState = React3.useRef(void 0);
   const hasOverrideItemLayout = !!overrideItemLayout;
@@ -4756,7 +6033,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     if (!ctx.state) {
       const initialScrollLength = (estimatedListSize != null ? estimatedListSize : { height: 0, width: 0 } )[horizontal ? "width" : "height"];
       ctx.state = {
-        activeStickyIndex: -1,
         averageSizes: {},
         columnSpans: [],
         columns: [],
@@ -4775,24 +6051,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         idCache: [],
         idsInView: [],
         indexByKey: /* @__PURE__ */ new Map(),
-        initialAnchor: !initialScrollUsesOffsetOnly && (initialScrollProp == null ? void 0 : initialScrollProp.index) !== void 0 && (initialScrollProp == null ? void 0 : initialScrollProp.viewPosition) !== void 0 ? {
-          attempts: 0,
-          index: initialScrollProp.index,
-          settledTicks: 0,
-          viewOffset: (_f = initialScrollProp.viewOffset) != null ? _f : 0,
-          viewPosition: initialScrollProp.viewPosition
-        } : void 0,
-        initialNativeScrollWatchdog: void 0,
         initialScroll: initialScrollProp,
-        initialScrollLastDidFinish: false,
-        initialScrollLastTarget: initialScrollProp,
-        initialScrollLastTargetUsesOffset: initialScrollUsesOffsetOnly,
-        initialScrollPreviousDataLength: dataProp.length,
-        initialScrollRetryLastLength: void 0,
-        initialScrollRetryWindowUntil: 0,
-        initialScrollUsesOffset: initialScrollUsesOffsetOnly,
-        isAtEnd: false,
-        isAtStart: false,
+        initialScrollSession: initialScrollProp ? {
+          kind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
+          previousDataLength: dataProp.length
+        } : void 0,
         isEndReached: null,
         isFirst: true,
         isStartReached: null,
@@ -4803,6 +6066,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         minIndexSizeChanged: 0,
         nativeContentInset: void 0,
         nativeMarginTop: 0,
+        pendingDataComparison: void 0,
         pendingNativeMVCPAdjust: void 0,
         positions: [],
         props: {},
@@ -4833,6 +6097,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       };
       const internalState = ctx.state;
       internalState.triggerCalculateItemsInView = (params) => calculateItemsInView(ctx, params);
+      internalState.reprocessCurrentScroll = () => updateScroll(ctx, internalState.scroll, true);
       set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPositionConfig);
       set$(ctx, "extraData", extraData);
     }
@@ -4840,22 +6105,29 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }
   const state = refState.current;
   const isFirstLocal = state.isFirst;
-  state.didColumnsChange = numColumnsProp !== state.props.numColumns;
+  const previousNumColumnsProp = state.props.numColumns;
+  state.didColumnsChange = numColumnsProp !== previousNumColumnsProp;
   const didDataReferenceChangeLocal = state.props.data !== dataProp;
   const didDataVersionChangeLocal = state.props.dataVersion !== dataVersion;
-  const didDataChangeLocal = didDataVersionChangeLocal || didDataReferenceChangeLocal && checkActualChange(state, dataProp, state.props.data);
+  const didDataChangeLocal = didDataVersionChangeLocal || didDataReferenceChangeLocal && checkStructuralDataChange(state, dataProp, state.props.data);
+  if (didDataChangeLocal && state.didFinishInitialScroll && ((_f = state.initialScroll) == null ? void 0 : _f.viewPosition) === 1 && state.props.data.length > 0) {
+    clearPreservedInitialScrollTarget(state);
+  }
   if (didDataChangeLocal) {
     state.dataChangeEpoch += 1;
     state.dataChangeNeedsScrollUpdate = true;
     state.didDataChange = true;
     state.previousData = state.props.data;
   }
-  const throttleScrollFn = scrollEventThrottle && onScrollProp ? useThrottledOnScroll(onScrollProp, scrollEventThrottle) : onScrollProp;
+  const throttledOnScroll = useThrottledOnScroll(onScrollProp != null ? onScrollProp : noopOnScroll, scrollEventThrottle != null ? scrollEventThrottle : 0);
+  const throttleScrollFn = scrollEventThrottle && onScrollProp ? throttledOnScroll : onScrollProp;
+  const anchoredEndSpaceResolved = anchoredEndSpace ? { ...anchoredEndSpace, includeInEndInset: true } : anchoredEndSpace;
   state.props = {
     alignItemsAtEnd,
     alwaysRender,
     alwaysRenderIndicesArr: alwaysRenderIndices.arr,
     alwaysRenderIndicesSet: alwaysRenderIndices.set,
+    anchoredEndSpace: anchoredEndSpaceResolved,
     animatedProps: animatedPropsInternal,
     contentInset,
     data: dataProp,
@@ -4919,292 +6191,87 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       true
     );
   }
-  const resolveInitialScrollOffset = React3.useCallback((initialScroll) => {
-    var _a4;
-    if (state.initialScrollUsesOffset) {
-      return clampScrollOffset(ctx, (_a4 = initialScroll.contentOffset) != null ? _a4 : 0);
-    }
-    const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
-    const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
-    return clampScrollOffset(ctx, resolvedOffset, initialScroll);
-  }, []);
-  const finishInitialScrollWithoutScroll = React3.useCallback(() => {
-    refState.current.initialAnchor = void 0;
-    refState.current.initialScroll = void 0;
-    state.initialAnchor = void 0;
-    state.initialScroll = void 0;
-    state.initialScrollUsesOffset = false;
-    state.initialScrollLastTarget = void 0;
-    state.initialScrollLastTargetUsesOffset = false;
-    setInitialRenderState(ctx, { didInitialScroll: true });
-  }, []);
-  const setActiveInitialScrollTarget = React3.useCallback(
-    (target, options) => {
-      const usesOffset = !!(options == null ? void 0 : options.usesOffset);
-      state.initialScrollUsesOffset = usesOffset;
-      state.initialScrollLastTarget = target;
-      state.initialScrollLastTargetUsesOffset = usesOffset;
-      refState.current.initialScroll = target;
-      state.initialScroll = target;
-      if ((options == null ? void 0 : options.resetDidFinish) && state.didFinishInitialScroll) {
-        state.didFinishInitialScroll = false;
-      }
-      if (!(options == null ? void 0 : options.syncAnchor)) {
-        return;
-      }
-    },
-    []
-  );
-  const shouldFinishInitialScrollAtOrigin = React3.useCallback(
-    (initialScroll, offset) => {
-      var _a4, _b2, _c2;
-      if (offset !== 0 || initialScrollAtEnd) {
-        return false;
-      }
-      if (state.initialScrollUsesOffset) {
-        return Math.abs((_a4 = initialScroll.contentOffset) != null ? _a4 : 0) <= 1;
-      }
-      return initialScroll.index === 0 && ((_b2 = initialScroll.viewPosition) != null ? _b2 : 0) === 0 && Math.abs((_c2 = initialScroll.viewOffset) != null ? _c2 : 0) <= 1;
-    },
-    [initialScrollAtEnd]
-  );
-  const shouldFinishEmptyInitialScrollAtEnd = React3.useCallback(
-    (initialScroll, offset) => {
-      return dataProp.length === 0 && initialScrollAtEnd && offset === 0 && initialScroll.viewPosition === 1;
-    },
-    [dataProp.length, initialScrollAtEnd]
-  );
-  const shouldRearmFinishedEmptyInitialScrollAtEnd = React3.useCallback(
-    (initialScroll) => {
-      var _a4;
-      return !!(state.didFinishInitialScroll && dataProp.length > 0 && initialScroll && !state.initialScrollUsesOffset && initialScroll.index === 0 && initialScroll.viewPosition === 1 && ((_a4 = initialScroll.contentOffset) != null ? _a4 : 0) === 0);
-    },
-    [dataProp.length]
-  );
   const initialContentOffset = React3.useMemo(() => {
-    let value;
-    const { initialScroll, initialAnchor } = refState.current;
-    if (initialScroll) {
-      if (!state.initialScrollUsesOffset && false) ;
-      if (initialScroll.contentOffset !== void 0) {
-        value = initialScroll.contentOffset;
-      } else {
-        const clampedOffset = resolveInitialScrollOffset(initialScroll);
-        const updatedInitialScroll = { ...initialScroll, contentOffset: clampedOffset };
-        setActiveInitialScrollTarget(updatedInitialScroll, {
-          usesOffset: state.initialScrollUsesOffset
-        });
-        value = clampedOffset;
-      }
-    } else {
-      refState.current.initialAnchor = void 0;
-      value = 0;
-    }
-    const hasPendingDataDependentInitialScroll = !!initialScroll && dataProp.length === 0 && !shouldFinishInitialScrollAtOrigin(initialScroll, value) && !shouldFinishEmptyInitialScrollAtEnd(initialScroll, value);
-    if (!value && !hasPendingDataDependentInitialScroll) {
-      if (initialScroll && shouldFinishInitialScrollAtOrigin(initialScroll, value)) {
-        finishInitialScrollWithoutScroll();
-      } else {
-        setInitialRenderState(ctx, { didInitialScroll: true });
-      }
+    var _a4, _b2;
+    const initialScroll = state.initialScroll;
+    if (!initialScroll) {
+      return void 0;
     }
-    return value;
+    const resolvedOffset = (_a4 = initialScroll.contentOffset) != null ? _a4 : resolveInitialScrollOffset(ctx, initialScroll);
+    return usesBootstrapInitialScroll && ((_b2 = state.initialScrollSession) == null ? void 0 : _b2.kind) === "bootstrap" && Platform.OS === "web" ? void 0 : resolvedOffset;
+  }, [usesBootstrapInitialScroll]);
+  React3.useLayoutEffect(() => {
+    initializeInitialScrollOnMount(ctx, {
+      dataLength: dataProp.length,
+      hasFooterComponent: !!ListFooterComponent,
+      initialContentOffset,
+      initialScrollAtEnd,
+      useBootstrapInitialScroll: usesBootstrapInitialScroll
+    });
   }, []);
   if (isFirstLocal || didDataChangeLocal || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirstLocal && didDataChangeLocal) {
-      IS_DEV && !childrenMode && 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.length = 0;
       refState.current.totalSize = 0;
       set$(ctx, "totalSize", 0);
     }
   }
-  const doInitialScroll = React3.useCallback((options) => {
-    var _a4, _b2;
-    const allowPostFinishRetry = !!(options == null ? void 0 : options.allowPostFinishRetry);
-    const { didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
-    const initialScroll = (_a4 = state.initialScroll) != null ? _a4 : allowPostFinishRetry ? state.initialScrollLastTarget : void 0;
-    const isInitialScrollInProgress = !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll);
-    const needsContainerLayoutForInitialScroll = !state.initialScrollUsesOffset;
-    const shouldWaitForInitialLayout = waitForInitialLayout && needsContainerLayoutForInitialScroll && !queuedInitialLayout && !allowPostFinishRetry && !isInitialScrollInProgress;
-    if (!initialScroll || shouldWaitForInitialLayout || didFinishInitialScroll && !allowPostFinishRetry || scrollingTo && !isInitialScrollInProgress) {
-      return;
-    }
-    if (allowPostFinishRetry && state.initialScrollLastTargetUsesOffset) {
-      return;
-    }
-    const didMoveAwayFromInitialTarget = allowPostFinishRetry && initialScroll.contentOffset !== void 0 && Math.abs(state.scroll - initialScroll.contentOffset) > 1;
-    if (didMoveAwayFromInitialTarget) {
-      state.initialScrollRetryWindowUntil = 0;
-      return;
-    }
-    const offset = resolveInitialScrollOffset(initialScroll);
-    const activeInitialTargetOffset = isInitialScrollInProgress ? (_b2 = scrollingTo.targetOffset) != null ? _b2 : scrollingTo.offset : void 0;
-    const didOffsetChange = initialScroll.contentOffset === void 0 || Math.abs(initialScroll.contentOffset - offset) > 1;
-    const didActiveInitialTargetChange = activeInitialTargetOffset !== void 0 && Math.abs(activeInitialTargetOffset - offset) > 1;
-    if (!didOffsetChange && (allowPostFinishRetry || isInitialScrollInProgress && !didActiveInitialTargetChange)) {
-      return;
-    }
-    if (didOffsetChange) {
-      const updatedInitialScroll = { ...initialScroll, contentOffset: offset };
-      if (!state.initialScrollUsesOffset) {
-        state.initialScrollLastTarget = updatedInitialScroll;
-        state.initialScrollLastTargetUsesOffset = false;
-        if (state.initialScroll) {
-          refState.current.initialScroll = updatedInitialScroll;
-          state.initialScroll = updatedInitialScroll;
-        }
-      }
-    }
-    const hasMeasuredScrollLayout = !!state.lastLayout && state.scrollLength > 0;
-    const shouldForceNativeInitialScroll = state.initialScrollUsesOffset && hasMeasuredScrollLayout || allowPostFinishRetry || !!queuedInitialLayout || isInitialScrollInProgress && didOffsetChange;
-    performInitialScroll(ctx, {
-      forceScroll: shouldForceNativeInitialScroll,
-      initialScrollUsesOffset: state.initialScrollUsesOffset,
-      resolvedOffset: offset,
-      target: initialScroll
-    });
-  }, []);
-  React3.useLayoutEffect(() => {
-    var _a4;
-    const previousDataLength = state.initialScrollPreviousDataLength;
-    state.initialScrollPreviousDataLength = dataProp.length;
-    if (previousDataLength !== 0 || dataProp.length === 0 || !state.initialScroll || !state.queuedInitialLayout) {
-      return;
-    }
-    if (initialScrollAtEnd) {
-      const lastIndex = Math.max(0, dataProp.length - 1);
-      const initialScroll = state.initialScroll;
-      const shouldRearm = shouldRearmFinishedEmptyInitialScrollAtEnd(initialScroll);
-      if (state.didFinishInitialScroll && !shouldRearm) {
-        return;
-      }
-      if (initialScroll && !state.initialScrollUsesOffset && initialScroll.index === lastIndex && initialScroll.viewPosition === 1 && !shouldRearm) {
-        return;
-      }
-      const updatedInitialScroll = {
-        contentOffset: void 0,
-        index: lastIndex,
-        viewOffset: (_a4 = initialScroll == null ? void 0 : initialScroll.viewOffset) != null ? _a4 : -stylePaddingBottomState,
-        viewPosition: 1
-      };
-      setActiveInitialScrollTarget(updatedInitialScroll, {
-        resetDidFinish: shouldRearm,
-        syncAnchor: true
-      });
-      doInitialScroll();
-      return;
-    }
-    if (state.didFinishInitialScroll) {
-      return;
-    }
-    doInitialScroll();
-  }, [
-    dataProp.length,
-    doInitialScroll,
-    initialScrollAtEnd,
-    shouldRearmFinishedEmptyInitialScrollAtEnd,
-    stylePaddingBottomState
-  ]);
+  if (IS_DEV) {
+    useDevChecks(props);
+  }
   React3.useLayoutEffect(() => {
-    var _a4;
-    if (!initialScrollAtEnd) {
-      return;
-    }
-    const lastIndex = Math.max(0, dataProp.length - 1);
-    const initialScroll = state.initialScroll;
-    const shouldRearm = shouldRearmFinishedEmptyInitialScrollAtEnd(initialScroll);
-    if (state.didFinishInitialScroll && !shouldRearm) {
-      return;
-    }
-    if (shouldRearm) {
-      state.didFinishInitialScroll = false;
-    }
-    if (initialScroll && !state.initialScrollUsesOffset && initialScroll.index === lastIndex && initialScroll.viewPosition === 1 && !shouldRearm) {
-      return;
-    }
-    const updatedInitialScroll = {
-      contentOffset: void 0,
-      index: lastIndex,
-      viewOffset: (_a4 = initialScroll == null ? void 0 : initialScroll.viewOffset) != null ? _a4 : -stylePaddingBottomState,
-      viewPosition: 1
-    };
-    setActiveInitialScrollTarget(updatedInitialScroll, {
-      resetDidFinish: shouldRearm,
-      syncAnchor: true
+    handleInitialScrollDataChange(ctx, {
+      dataLength: dataProp.length,
+      didDataChange: didDataChangeLocal,
+      initialScrollAtEnd,
+      stylePaddingBottom: stylePaddingBottomState,
+      useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
-    doInitialScroll();
+  }, [dataProp.length, didDataChangeLocal, initialScrollAtEnd, stylePaddingBottomState, usesBootstrapInitialScroll]);
+  React3.useLayoutEffect(() => {
+    maybeUpdateAnchoredEndSpace(ctx);
   }, [
-    dataProp.length,
-    doInitialScroll,
-    initialScrollAtEnd,
-    shouldRearmFinishedEmptyInitialScrollAtEnd,
-    stylePaddingBottomState
+    ctx,
+    dataProp,
+    dataVersion,
+    anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex,
+    anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorMaxSize,
+    anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorOffset,
+    numColumnsProp
   ]);
   const onLayoutFooter = React3.useCallback(
     (layout) => {
-      var _a4;
-      if (!initialScrollAtEnd) {
+      if (!usesBootstrapInitialScroll) {
         return;
       }
-      const { initialScroll } = state;
-      if (!initialScroll) {
-        return;
+      handleBootstrapInitialScrollFooterLayout(ctx, {
+        dataLength: dataProp.length,
+        footerSize: layout[horizontal ? "width" : "height"],
+        initialScrollAtEnd,
+        stylePaddingBottom: stylePaddingBottomState
+      });
+    },
+    [dataProp.length, initialScrollAtEnd, horizontal, stylePaddingBottomState, usesBootstrapInitialScroll]
+  );
+  const onLayoutChange = React3.useCallback(
+    (layout, fromLayoutEffect) => {
+      const previousScrollLength = state.scrollLength;
+      const previousOtherAxisSize = state.otherAxisSize;
+      handleLayout(ctx, layout, setCanRender);
+      maybeUpdateAnchoredEndSpace(ctx);
+      const didLayoutAffectBootstrapTarget = previousScrollLength !== state.scrollLength || previousOtherAxisSize !== state.otherAxisSize;
+      if (usesBootstrapInitialScroll && !fromLayoutEffect && didLayoutAffectBootstrapTarget) {
+        handleBootstrapInitialScrollLayoutChange(ctx);
       }
-      const lastIndex = Math.max(0, dataProp.length - 1);
-      if (initialScroll.index !== lastIndex || initialScroll.viewPosition !== 1) {
+      if (usesBootstrapInitialScroll) {
         return;
       }
-      const footerSize = layout[horizontal ? "width" : "height"];
-      const viewOffset = -stylePaddingBottomState - footerSize;
-      if (initialScroll.viewOffset !== viewOffset) {
-        const previousTargetOffset = (_a4 = initialScroll.contentOffset) != null ? _a4 : resolveInitialScrollOffset(initialScroll);
-        const didMoveAwayFromFinishedInitialTarget = state.didFinishInitialScroll && Math.abs(state.scroll - previousTargetOffset) > 1;
-        if (didMoveAwayFromFinishedInitialTarget) {
-          return;
-        }
-        const updatedInitialScroll = { ...initialScroll, viewOffset };
-        setActiveInitialScrollTarget(updatedInitialScroll, {
-          resetDidFinish: true
-        });
-        doInitialScroll();
-      }
+      advanceCurrentInitialScrollSession(ctx);
     },
-    [
-      dataProp.length,
-      doInitialScroll,
-      horizontal,
-      initialScrollAtEnd,
-      resolveInitialScrollOffset,
-      stylePaddingBottomState
-    ]
+    [dataProp.length, initialScrollAtEnd, stylePaddingBottomState, usesBootstrapInitialScroll]
   );
-  const onLayoutChange = React3.useCallback((layout) => {
-    var _a4;
-    handleLayout(ctx, layout, setCanRender);
-    const SCROLL_LENGTH_RETRY_WINDOW_MS = 600;
-    const now = Date.now();
-    const didFinishInitialScroll = !!state.didFinishInitialScroll;
-    if (didFinishInitialScroll && !state.initialScrollLastDidFinish) {
-      state.initialScrollRetryWindowUntil = now + SCROLL_LENGTH_RETRY_WINDOW_MS;
-    }
-    state.initialScrollLastDidFinish = didFinishInitialScroll;
-    const previousScrollLength = state.initialScrollRetryLastLength;
-    const currentScrollLength = state.scrollLength;
-    const didScrollLengthChange = previousScrollLength === void 0 || Math.abs(currentScrollLength - previousScrollLength) > 1;
-    if (didScrollLengthChange) {
-      state.initialScrollRetryLastLength = currentScrollLength;
-    }
-    if (didFinishInitialScroll && didScrollLengthChange && now <= state.initialScrollRetryWindowUntil && !state.initialScrollLastTargetUsesOffset && ((_a4 = state.initialScrollLastTarget) == null ? void 0 : _a4.index) !== void 0) {
-      doInitialScroll({ allowPostFinishRetry: true });
-      return;
-    }
-    doInitialScroll();
-  }, []);
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
     onLayoutProp,
@@ -5216,6 +6283,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       updateSnapToOffsets(ctx);
     }
   }, [snapToIndices]);
+  React3.useLayoutEffect(
+    () => initializeStateVars(true),
+    [dataVersion, memoizedLastItemKeys.join(","), numColumnsProp, stylePaddingBottomState, stylePaddingTopState]
+  );
   React3.useLayoutEffect(() => {
     const {
       didColumnsChange,
@@ -5225,7 +6296,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     } = state;
     const didAllocateContainers = data.length > 0 && doInitialAllocateContainers(ctx);
     if (!didAllocateContainers && !isFirst && (didDataChange || didColumnsChange)) {
-      checkResetContainers(ctx, data);
+      checkResetContainers(ctx, data, { didColumnsChange });
+    }
+    if (didDataChange) {
+      state.pendingDataComparison = void 0;
     }
     state.didColumnsChange = false;
     state.didDataChange = false;
@@ -5240,10 +6314,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { forceFullItemPositions: true });
     }
   }, [extraData, hasOverrideItemLayout, numColumnsProp]);
-  React3.useLayoutEffect(
-    () => initializeStateVars(true),
-    [dataVersion, memoizedLastItemKeys.join(","), numColumnsProp, stylePaddingBottomState, stylePaddingTopState]
-  );
   React3.useEffect(() => {
     if (!onMetricsChange) {
       return;
@@ -5276,10 +6346,15 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
+  useInit(() => {
+  });
   React3.useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx), []);
-  {
-    React3.useEffect(doInitialScroll, []);
-  }
+  React3.useEffect(() => {
+    if (usesBootstrapInitialScroll) {
+      return;
+    }
+    advanceCurrentInitialScrollSession(ctx);
+  }, [ctx, usesBootstrapInitialScroll]);
   const fns = React3.useMemo(
     () => ({
       getRenderedItem: (key) => getRenderedItem(ctx, key),
@@ -5308,6 +6383,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       horizontal,
       initialContentOffset,
       ListEmptyComponent: dataProp.length === 0 ? ListEmptyComponent : void 0,
+      ListFooterComponent,
+      ListFooterComponentStyle,
       ListHeaderComponent,
       onLayout,
       onLayoutFooter,
@@ -5332,8 +6409,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       stickyHeaderIndices,
       style,
       updateItemSize: fns.updateItemSize,
-      useWindowScroll: useWindowScrollResolved,
-      waitForInitialLayout
+      useWindowScroll: useWindowScrollResolved
     }
   ), IS_DEV && ENABLE_DEBUG_VIEW);
 });