npm - @legendapp/list - Versions diffs - 3.0.0-beta.44 → 3.0.0-beta.46 - Mend

@legendapp/list 3.0.0-beta.44 → 3.0.0-beta.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/react.js CHANGED Viewed

@@ -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;
@@ -709,17 +726,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,
@@ -727,6 +747,7 @@ var Container = typedMemo(function Container2({
       top: otherAxisPos,
       ...paddingStyles || {}
     } : {
+      boxSizing: paddingStyles ? "border-box" : void 0,
       left: otherAxisPos,
       position: "absolute",
       right: numColumns > 1 ? null : 0,
@@ -955,9 +976,6 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
         style.marginRight = -gapX;
       }
     } else {
-      if (gapX) {
-        style.marginLeft = style.marginRight = -gapX;
-      }
       if (gapY) {
         style.marginBottom = -gapY;
       }
@@ -1135,6 +1153,7 @@ function resolveWindowScrollTarget({ clampedOffset, horizontal, listPos, scroll
 var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView2({
   children,
   style,
+  contentContainerClassName,
   contentContainerStyle,
   horizontal = false,
   contentOffset,
@@ -1270,18 +1289,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();
@@ -1347,13 +1366,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();
@@ -1366,6 +1386,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);
@@ -1379,32 +1414,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;
@@ -1418,8 +1455,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);
 };
@@ -1464,12 +1512,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) {
@@ -1529,171 +1579,80 @@ var ListComponent = typedMemo(function ListComponent2({
       }
     ),
     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);
-}
-// 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;
-  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);
+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."
+      );
     }
-  }
-  if (size === void 0) {
-    size = sizes.get(key);
-    if (size !== void 0) {
-      return size;
+  }, [stickyHeaderIndices, stickyIndices]);
+  React3.useEffect(() => {
+    if (useWindowScroll && renderScrollComponent) {
+      warnDevOnce(
+        "useWindowScrollRenderScrollComponent",
+        "useWindowScroll is not supported when renderScrollComponent is provided."
+      );
     }
-  }
-  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;
+  }, [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."
+      );
     }
-  }
-  if (viewPosition !== void 0 && index !== void 0) {
+  }, [childrenMode, ctx, keyExtractor]);
+  React3.useEffect(() => {
+    const state = ctx.state;
     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;
+    const useWindowScrollResolved = state.props.useWindowScroll;
+    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+      return;
     }
-  }
-  return offset;
+    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/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 useDevChecksNoop(_props) {
 }
+var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
 // src/core/deferredPublicOnScroll.ts
 function withResolvedContentOffset(state, event, resolvedOffset) {
@@ -1841,33 +1800,462 @@ function setInitialScrollSession(state, options = {}) {
   return state.initialScrollSession;
 }
-// src/core/finishScrollTo.ts
-function finishScrollTo(ctx) {
-  var _a3, _b;
-  const state = ctx.state;
-  if (state == null ? void 0 : state.scrollingTo) {
-    const resolvePendingScroll = state.pendingScrollResolve;
-    state.pendingScrollResolve = void 0;
-    const scrollingTo = state.scrollingTo;
-    state.scrollHistory.length = 0;
-    state.scrollingTo = void 0;
-    if (state.pendingTotalSize !== void 0) {
-      addTotalSize(ctx, null, state.pendingTotalSize);
-    }
-    {
-      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
-    }
-    if (scrollingTo.isInitialScroll || state.initialScroll) {
-      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-      finishInitialScroll(ctx, {
-        onFinished: resolvePendingScroll,
-        preserveTarget: isOffsetSession && state.props.data.length === 0 || !!scrollingTo.isInitialScroll && !!((_b = state.initialScroll) == null ? void 0 : _b.preserveForFooterLayout),
+// src/utils/checkThreshold.ts
+var HYSTERESIS_MULTIPLIER = 1.3;
+var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot, allowReentryOnChange) => {
+  const absDistance = Math.abs(distance);
+  const within = atThreshold || threshold > 0 && absDistance <= threshold;
+  const updateSnapshot = () => {
+    setSnapshot({
+      atThreshold,
+      contentSize: context.contentSize,
+      dataLength: context.dataLength,
+      scrollPosition: context.scrollPosition
+    });
+  };
+  if (!wasReached) {
+    if (!within) {
+      return false;
+    }
+    onReached(distance);
+    updateSnapshot();
+    return true;
+  }
+  const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
+  if (reset) {
+    setSnapshot(void 0);
+    return false;
+  }
+  if (within) {
+    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
+    if (changed) {
+      if (allowReentryOnChange) {
+        onReached(distance);
+      }
+      updateSnapshot();
+    }
+  }
+  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) {
+    return;
+  }
+  const {
+    queuedInitialLayout,
+    scrollLength,
+    scroll,
+    maintainingScrollAtEnd,
+    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
+  } = state;
+  const contentSize = getContentSize(ctx);
+  if (contentSize > 0 && queuedInitialLayout) {
+    const insetEnd = getContentInsetEnd(ctx);
+    const distanceFromEnd = contentSize - scroll - scrollLength - insetEnd;
+    const isContentLess = contentSize < scrollLength;
+    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) {
+    return;
+  }
+  const {
+    dataChangeEpoch,
+    isStartReached,
+    props: { data, onStartReachedThreshold },
+    scroll,
+    scrollLength,
+    startReachedSnapshot,
+    startReachedSnapshotDataChangeEpoch,
+    totalSize
+  } = state;
+  const dataLength = data.length;
+  const threshold = onStartReachedThreshold * scrollLength;
+  const dataChanged = startReachedSnapshotDataChangeEpoch !== dataChangeEpoch;
+  const withinThreshold = threshold > 0 && Math.abs(scroll) <= threshold;
+  const allowReentryOnDataChange = !!isStartReached && withinThreshold && !!dataChanged && !isInMVCPActiveMode(state);
+  if (isStartReached && threshold > 0 && scroll > threshold && startReachedSnapshot && (dataChanged || startReachedSnapshot.contentSize !== totalSize || startReachedSnapshot.dataLength !== dataLength)) {
+    state.isStartReached = false;
+    state.startReachedSnapshot = void 0;
+    state.startReachedSnapshotDataChangeEpoch = void 0;
+  }
+  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
+    );
+  }
+}
+// src/utils/checkThresholds.ts
+function checkThresholds(ctx) {
+  checkAtBottom(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,
+  didInitialScroll
+}) {
+  const { state } = ctx;
+  const {
+    loadStartTime,
+    props: { onLoad }
+  } = state;
+  if (didLayout) {
+    state.didContainersLayout = true;
+  }
+  if (didInitialScroll) {
+    state.didFinishInitialScroll = true;
+  }
+  const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
+  if (isReadyToRender && !peek$(ctx, "readyToRender")) {
+    set$(ctx, "readyToRender", true);
+    if (onLoad) {
+      onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
+    }
+  }
+}
+// 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;
+  const state = ctx.state;
+  if (state == null ? void 0 : state.scrollingTo) {
+    const resolvePendingScroll = state.pendingScrollResolve;
+    state.pendingScrollResolve = void 0;
+    const scrollingTo = state.scrollingTo;
+    state.scrollHistory.length = 0;
+    state.scrollingTo = void 0;
+    if (state.pendingTotalSize !== void 0) {
+      addTotalSize(ctx, null, state.pendingTotalSize);
+    }
+    {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    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();
   }
 }
@@ -1878,6 +2266,7 @@ 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;
@@ -1891,7 +2280,7 @@ function doScrollTo(ctx, params) {
   const top = isHorizontal ? 0 : offset;
   scroller.scrollTo({ animated: isAnimated, x: left, y: top });
   if (isAnimated) {
-    const target = scroller.getScrollEventTarget();
+    const target = (_b = (_a3 = scroller.getScrollEventTarget) == null ? void 0 : _a3.call(scroller)) != null ? _b : null;
     listenForScrollEnd(ctx, {
       readOffset: () => scroller.getCurrentScrollOffset(),
       target,
@@ -1957,6 +2346,17 @@ function listenForScrollEnd(ctx, params) {
 }
 // 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;
@@ -2004,8 +2404,10 @@ function scrollTo(ctx, params) {
     if (isInitialScroll) {
       initialScrollCompletion.resetFlags(state);
     }
+    const averageSizeSnapshot = getAverageSizeSnapshot(state);
     state.scrollingTo = {
       ...scrollTarget,
+      ...averageSizeSnapshot ? { averageSizeSnapshot } : {},
       targetOffset,
       waitForInitialScrollCompletionFrame
     };
@@ -2062,180 +2464,7 @@ function scrollToIndex(ctx, {
   });
 }
-// src/utils/checkThreshold.ts
-var HYSTERESIS_MULTIPLIER = 1.3;
-var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot, allowReentryOnChange) => {
-  const absDistance = Math.abs(distance);
-  const within = atThreshold || threshold > 0 && absDistance <= threshold;
-  const updateSnapshot = () => {
-    setSnapshot({
-      atThreshold,
-      contentSize: context.contentSize,
-      dataLength: context.dataLength,
-      scrollPosition: context.scrollPosition
-    });
-  };
-  if (!wasReached) {
-    if (!within) {
-      return false;
-    }
-    onReached(distance);
-    updateSnapshot();
-    return true;
-  }
-  const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
-  if (reset) {
-    setSnapshot(void 0);
-    return false;
-  }
-  if (within) {
-    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
-    if (changed) {
-      if (allowReentryOnChange) {
-        onReached(distance);
-      }
-      updateSnapshot();
-    }
-  }
-  return true;
-};
-// src/utils/checkAtBottom.ts
-function checkAtBottom(ctx) {
-  var _a3;
-  const state = ctx.state;
-  if (!state || state.initialScroll) {
-    return;
-  }
-  const {
-    queuedInitialLayout,
-    scrollLength,
-    scroll,
-    maintainingScrollAtEnd,
-    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
-  } = state;
-  if (state.initialScroll) {
-    return;
-  }
-  const contentSize = getContentSize(ctx);
-  if (contentSize > 0 && queuedInitialLayout && !maintainingScrollAtEnd) {
-    const insetEnd = getContentInsetEnd(state);
-    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
-    );
-  }
-}
-// src/utils/checkAtTop.ts
-function checkAtTop(ctx) {
-  const state = ctx == null ? void 0 : ctx.state;
-  if (!state || state.initialScroll || state.scrollingTo) {
-    return;
-  }
-  const {
-    dataChangeEpoch,
-    isStartReached,
-    props: { data, onStartReachedThreshold },
-    scroll,
-    scrollLength,
-    startReachedSnapshot,
-    startReachedSnapshotDataChangeEpoch,
-    totalSize
-  } = state;
-  const dataLength = data.length;
-  const threshold = onStartReachedThreshold * scrollLength;
-  const dataChanged = startReachedSnapshotDataChangeEpoch !== dataChangeEpoch;
-  const withinThreshold = threshold > 0 && Math.abs(scroll) <= threshold;
-  const allowReentryOnDataChange = !!isStartReached && withinThreshold && !!dataChanged && !isInMVCPActiveMode(state);
-  if (isStartReached && threshold > 0 && scroll > threshold && startReachedSnapshot && (dataChanged || startReachedSnapshot.contentSize !== totalSize || startReachedSnapshot.dataLength !== dataLength)) {
-    state.isStartReached = false;
-    state.startReachedSnapshot = void 0;
-    state.startReachedSnapshotDataChangeEpoch = void 0;
-  }
-  state.isAtStart = scroll <= 0;
-  if (isStartReached && withinThreshold && dataChanged && !allowReentryOnDataChange) {
-    return;
-  }
-  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
-function checkThresholds(ctx) {
-  checkAtBottom(ctx);
-  checkAtTop(ctx);
-}
-// src/utils/setInitialRenderState.ts
-function setInitialRenderState(ctx, {
-  didLayout,
-  didInitialScroll
-}) {
-  const { state } = ctx;
-  const {
-    loadStartTime,
-    props: { onLoad }
-  } = state;
-  if (didLayout) {
-    state.didContainersLayout = true;
-  }
-  if (didInitialScroll) {
-    state.didFinishInitialScroll = true;
-  }
-  const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
-  if (isReadyToRender && !peek$(ctx, "readyToRender")) {
-    set$(ctx, "readyToRender", true);
-    if (onLoad) {
-      onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
-    }
-  }
-}
-// src/core/initialScroll.ts
-function syncInitialScrollOffset(state, offset) {
-  state.scroll = offset;
-  state.scrollPending = offset;
-  state.scrollPrev = offset;
-}
+// src/core/initialScroll.ts
 function dispatchInitialScroll(ctx, params) {
   const { forceScroll, resolvedOffset, target, waitForCompletionFrame } = params;
   const requestedIndex = target.index;
@@ -2256,6 +2485,11 @@ function dispatchInitialScroll(ctx, params) {
 }
 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;
@@ -2264,44 +2498,6 @@ function setInitialScrollTarget(state, target, options) {
     kind: ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? "offset" : "bootstrap"
   });
 }
-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, _f, _g;
-    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 = void 0;
-    }
-    setInitialScrollSession(state);
-    if ((options == null ? void 0 : options.recalculateItems) && ((_e = state.props) == null ? void 0 : _e.data)) {
-      (_f = state.triggerCalculateItemsInView) == null ? void 0 : _f.call(state, { forceFullItemPositions: true });
-    }
-    if (options == null ? void 0 : options.recalculateItems) {
-      checkThresholds(ctx);
-    }
-    setInitialRenderState(ctx, { didInitialScroll: true });
-    if (shouldReleaseDeferredPublicOnScroll) {
-      releaseDeferredPublicOnScroll(ctx, finalScrollOffset);
-    }
-    (_g = options == null ? void 0 : options.onFinished) == null ? void 0 : _g.call(options);
-  };
-  if (options == null ? void 0 : options.waitForCompletionFrame) {
-    requestAnimationFrame(complete);
-    return;
-  }
-  complete();
-}
 function resolveInitialScrollOffset(ctx, initialScroll) {
   var _a3, _b;
   const state = ctx.state;
@@ -2395,13 +2591,18 @@ function advanceCurrentInitialScrollSession(ctx, options) {
 function isNullOrUndefined2(value) {
   return value === null || value === void 0;
 }
-function getMountedBufferedIndices(state) {
-  const { startBuffered, endBuffered } = state;
-  if (!isNullOrUndefined2(endBuffered) && !isNullOrUndefined2(startBuffered) && startBuffered >= 0 && endBuffered >= 0) {
-    return Array.from(state.containerItemKeys.keys()).map((key) => state.indexByKey.get(key)).filter((index) => index !== void 0 && index >= startBuffered && index <= endBuffered).sort((a, b) => a - b);
+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);
@@ -2620,16 +2821,22 @@ function createRetargetedBottomAlignedInitialScroll(options) {
 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(state, target) {
+function clearPendingInitialScrollFooterLayout(ctx, options) {
+  const { dataLength, stylePaddingBottom, target } = options;
+  const state = ctx.state;
   if (!shouldPreserveInitialScrollForFooterLayout(target)) {
     return;
   }
-  if (state.didFinishInitialScroll && !getBootstrapInitialScrollSession(state)) {
-    state.initialScroll = void 0;
-    setInitialScrollSession(state);
-    return;
-  }
-  setInitialScrollTarget(state, { ...target, preserveForFooterLayout: void 0 });
+  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;
@@ -2644,6 +2851,25 @@ function getObservedBootstrapInitialScrollOffset(state) {
   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;
@@ -2680,15 +2906,16 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
   }
   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) {
-    if (!shouldResetDidFinish && didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
-      clearPendingInitialScrollFooterLayout(state, initialScroll);
-      return;
-    }
     const updatedInitialScroll = initialScrollAtEnd ? createInitialScrollAtEndTarget({
       dataLength,
       footerSize: peek$(ctx, "footerSize") || 0,
@@ -2701,6 +2928,14 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
       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
@@ -2742,7 +2977,11 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
     return;
   }
   if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
-    clearPendingInitialScrollFooterLayout(state, initialScroll);
+    clearPendingInitialScrollFooterLayout(ctx, {
+      dataLength,
+      stylePaddingBottom,
+      target: initialScroll
+    });
   } else {
     const updatedInitialScroll = createInitialScrollAtEndTarget({
       dataLength,
@@ -2752,10 +2991,15 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
     });
     const didTargetChange = initialScroll.index !== updatedInitialScroll.index || initialScroll.viewPosition !== updatedInitialScroll.viewPosition || initialScroll.viewOffset !== updatedInitialScroll.viewOffset;
     if (!didTargetChange) {
-      clearPendingInitialScrollFooterLayout(state, initialScroll);
+      clearPendingInitialScrollFooterLayout(ctx, {
+        dataLength,
+        stylePaddingBottom,
+        target: initialScroll
+      });
     } else {
+      const didFinishInitialScroll = !!state.didFinishInitialScroll;
       setInitialScrollTarget(state, updatedInitialScroll, {
-        resetDidFinish: !!state.didFinishInitialScroll
+        resetDidFinish: didFinishInitialScroll
       });
       rearmBootstrapInitialScroll(ctx, {
         scroll: resolveInitialScrollOffset(ctx, updatedInitialScroll),
@@ -2764,6 +3008,29 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
     }
   }
 }
+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;
@@ -2832,12 +3099,15 @@ function evaluateBootstrapInitialScroll(ctx) {
   }
 }
 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: shouldPreserveInitialScrollForFooterLayout(state.initialScroll),
+    preserveTarget: shouldPreserveResizeTarget,
     recalculateItems: true,
-    resolvedOffset
+    resolvedOffset,
+    schedulePreservedTargetClear: shouldPreserveResizeTarget
   });
 }
 function abortBootstrapInitialScroll(ctx) {
@@ -3215,7 +3485,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;
   }
@@ -3372,6 +3642,86 @@ function prepareMVCP(ctx, dataChanged) {
   }
 }
+// src/core/syncMountedContainer.ts
+function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
+  const state = ctx.state;
+  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;
+        }
+      }
+    }
+  }
+  return { didChangePosition, didRefreshData };
+}
 // src/core/prepareColumnStartState.ts
 function prepareColumnStartState(ctx, startIndex, useAverageSize) {
   var _a3;
@@ -3534,9 +3884,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
 }) {
@@ -3561,7 +3912,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;
@@ -3676,7 +4027,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;
@@ -3696,7 +4055,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 }
@@ -3705,6 +4064,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);
@@ -3720,7 +4081,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(
@@ -3789,7 +4150,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) {
@@ -3890,6 +4251,7 @@ function findAvailableContainers(ctx, numNeeded, startBuffered, endBuffered, pen
   const numContainers = peek$(ctx, "numContainers");
   const state = ctx.state;
   const { stickyContainerPool, containerItemTypes } = state;
+  const shouldAvoidAssignedContainerReuse = state.props.recycleItems && !!state.props.positionComponentInternal;
   const result = [];
   const availableContainers = [];
   const pendingRemovalSet = new Set(pendingRemoval);
@@ -3946,18 +4308,20 @@ function findAvailableContainers(ctx, numNeeded, startBuffered, endBuffered, pen
       }
     }
   }
-  for (let u = 0; u < numContainers && result.length < numNeeded; u++) {
-    if (stickyContainerPool.has(u)) {
-      continue;
-    }
-    const key = peek$(ctx, `containerItemKey${u}`);
-    if (key === void 0) continue;
-    const index = state.indexByKey.get(key);
-    const isOutOfView = index < startBuffered || index > endBuffered;
-    if (isOutOfView) {
-      const distance = index < startBuffered ? startBuffered - index : index - endBuffered;
-      if (!requiredItemTypes || typeIndex < neededTypes.length && canReuseContainer(u, neededTypes[typeIndex])) {
-        availableContainers.push({ distance, index: u });
+  if (!shouldAvoidAssignedContainerReuse) {
+    for (let u = 0; u < numContainers && result.length < numNeeded; u++) {
+      if (stickyContainerPool.has(u)) {
+        continue;
+      }
+      const key = peek$(ctx, `containerItemKey${u}`);
+      if (key === void 0) continue;
+      const index = state.indexByKey.get(key);
+      const isOutOfView = index < startBuffered || index > endBuffered;
+      if (isOutOfView) {
+        const distance = index < startBuffered ? startBuffered - index : index - endBuffered;
+        if (!requiredItemTypes || typeIndex < neededTypes.length && canReuseContainer(u, neededTypes[typeIndex])) {
+          availableContainers.push({ distance, index: u });
+        }
       }
     }
   }
@@ -4101,7 +4465,6 @@ function calculateItemsInView(ctx, params = {}) {
         alwaysRenderIndicesSet,
         drawDistance,
         getItemType,
-        itemsAreEqual,
         keyExtractor,
         onStickyHeaderChange
       },
@@ -4128,11 +4491,11 @@ function calculateItemsInView(ctx, params = {}) {
     const numColumns = peek$(ctx, "numColumns");
     const speed = getScrollVelocity(state);
     const scrollExtra = 0;
-    const { queuedInitialLayout } = state;
-    const scrollState = suppressInitialScrollSideEffects ? (_b = bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.scroll) != null ? _b : state.scroll : !queuedInitialLayout && state.initialScroll ? (
+    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, state.initialScroll)
+      resolveInitialScrollOffset(ctx, initialScroll)
     ) : state.scroll;
     const scrollAdjustPending = (_c = peek$(ctx, "scrollAdjustPending")) != null ? _c : 0;
     const scrollAdjustPad = scrollAdjustPending - topPad;
@@ -4177,9 +4540,11 @@ function calculateItemsInView(ctx, params = {}) {
       columnSpans.length = 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
     });
@@ -4427,33 +4792,11 @@ 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;
         }
       }
     }
@@ -4464,7 +4807,10 @@ function calculateItemsInView(ctx, params = {}) {
       evaluateBootstrapInitialScroll(ctx);
       return;
     }
-    if (!queuedInitialLayout && endBuffered !== null && checkAllSizesKnown(state)) {
+    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);
     }
@@ -4475,7 +4821,9 @@ function calculateItemsInView(ctx, params = {}) {
         viewabilityConfigCallbackPairs,
         scrollLength,
         startNoBuffer,
-        endNoBuffer
+        endNoBuffer,
+        startBuffered != null ? startBuffered : startNoBuffer,
+        endBuffered != null ? endBuffered : endNoBuffer
       );
     }
     if (onStickyHeaderChange && stickyIndicesArr.length > 0 && nextActiveStickyIndex !== void 0 && nextActiveStickyIndex !== previousStickyIndex) {
@@ -4487,37 +4835,17 @@ 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/doMaintainScrollAtEnd.ts
 function doMaintainScrollAtEnd(ctx) {
   const state = ctx.state;
   const {
     didContainersLayout,
-    isAtEnd,
     pendingNativeMVCPAdjust,
     refScroller,
     props: { maintainScrollAtEnd }
   } = state;
-  const shouldMaintainScrollAtEnd = !!(isAtEnd && maintainScrollAtEnd && didContainersLayout);
+  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
   if (pendingNativeMVCPAdjust) {
     state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
     return false;
@@ -4530,7 +4858,7 @@ function doMaintainScrollAtEnd(ctx) {
     }
     requestAnimationFrame(() => {
       var _a3;
-      if (state.isAtEnd) {
+      if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
         state.maintainingScrollAtEnd = true;
         (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
           animated: maintainScrollAtEnd.animated
@@ -4548,68 +4876,22 @@ function doMaintainScrollAtEnd(ctx) {
   return false;
 }
-// src/utils/updateAveragesOnDataChange.ts
-function updateAveragesOnDataChange(state, oldData, newData) {
-  var _a3;
-  const {
-    averageSizes,
-    sizesKnown,
-    indexByKey,
-    props: { itemsAreEqual, getItemType, keyExtractor }
-  } = 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];
-  }
-  for (const itemType in itemTypesToPreserve) {
-    const { totalSize, count } = itemTypesToPreserve[itemType];
-    if (count > 0) {
-      averageSizes[itemType] = {
-        avg: totalSize / count,
-        num: count
-      };
-    }
-  }
-}
 // 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;
@@ -4620,6 +4902,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;
@@ -4863,6 +5192,7 @@ function onScroll(ctx, event) {
   state.scrollPending = newScroll;
   updateScroll(ctx, newScroll, insetChanged);
   trackInitialScrollNativeProgress(state, newScroll);
+  clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx);
   if (state.scrollingTo) {
     checkFinishedScroll(ctx);
   }
@@ -4926,6 +5256,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;
@@ -5007,6 +5374,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;
@@ -5130,7 +5498,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;
@@ -5152,9 +5520,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 = () => {
@@ -5169,11 +5538,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) {
@@ -5230,10 +5600,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],
@@ -5280,10 +5653,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);
@@ -5379,7 +5757,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 };
 }
@@ -5513,9 +5891,18 @@ var LegendList = typedMemo(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b, _c, _d, _e, _f, _g;
+  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,
@@ -5581,7 +5968,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const positionComponentInternal = props.positionComponentInternal;
   const stickyPositionComponentInternal = props.stickyPositionComponentInternal;
   const {
-    childrenMode,
     positionComponentInternal: _positionComponentInternal,
     stickyPositionComponentInternal: _stickyPositionComponentInternal,
     ...restProps
@@ -5645,18 +6031,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;
@@ -5665,7 +6039,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: [],
@@ -5689,8 +6062,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
           kind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
           previousDataLength: dataProp.length
         } : void 0,
-        isAtEnd: false,
-        isAtStart: false,
         isEndReached: null,
         isFirst: true,
         isStartReached: null,
@@ -5701,6 +6072,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         minIndexSizeChanged: 0,
         nativeContentInset: void 0,
         nativeMarginTop: 0,
+        pendingDataComparison: void 0,
         pendingNativeMVCPAdjust: void 0,
         positions: [],
         props: {},
@@ -5739,22 +6111,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,
@@ -5839,16 +6218,15 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   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);
     }
   }
+  if (IS_DEV) {
+    useDevChecks(props);
+  }
   React3.useLayoutEffect(() => {
     handleInitialScrollDataChange(ctx, {
       dataLength: dataProp.length,
@@ -5858,6 +6236,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
   }, [dataProp.length, didDataChangeLocal, initialScrollAtEnd, stylePaddingBottomState, usesBootstrapInitialScroll]);
+  React3.useLayoutEffect(() => {
+    maybeUpdateAnchoredEndSpace(ctx);
+  }, [
+    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) => {
       if (!usesBootstrapInitialScroll) {
@@ -5873,14 +6262,21 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     [dataProp.length, initialScrollAtEnd, horizontal, stylePaddingBottomState, usesBootstrapInitialScroll]
   );
   const onLayoutChange = React3.useCallback(
-    (layout) => {
+    (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);
+      }
       if (usesBootstrapInitialScroll) {
         return;
       }
       advanceCurrentInitialScrollSession(ctx);
     },
-    [usesBootstrapInitialScroll]
+    [dataProp.length, initialScrollAtEnd, stylePaddingBottomState, usesBootstrapInitialScroll]
   );
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
@@ -5893,6 +6289,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,
@@ -5902,7 +6302,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;
@@ -5917,10 +6320,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;
@@ -5953,15 +6352,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(() => {
-      if (usesBootstrapInitialScroll) {
-        return;
-      }
-      advanceCurrentInitialScrollSession(ctx);
-    }, [usesBootstrapInitialScroll]);
-  }
+  React3.useEffect(() => {
+    if (usesBootstrapInitialScroll) {
+      return;
+    }
+    advanceCurrentInitialScrollSession(ctx);
+  }, [ctx, usesBootstrapInitialScroll]);
   const fns = React3.useMemo(
     () => ({
       getRenderedItem: (key) => getRenderedItem(ctx, key),
@@ -5999,7 +6398,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React3__namespace.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_f = refreshControlElement.props.progressViewOffset) != null ? _f : 0) + stylePaddingTopState
+        progressViewOffset: ((_g = refreshControlElement.props.progressViewOffset) != null ? _g : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React3__namespace.createElement(
         RefreshControl,
         {
@@ -6010,7 +6409,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       renderScrollComponent,
-      scrollAdjustHandler: (_g = refState.current) == null ? void 0 : _g.scrollAdjustHandler,
+      scrollAdjustHandler: (_h = refState.current) == null ? void 0 : _h.scrollAdjustHandler,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,
@@ -6021,13 +6420,40 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   ), IS_DEV && ENABLE_DEBUG_VIEW);
 });
+// src/components/stickyPositionUtils.ts
+function getStickyPushLimit(state, index, itemKey) {
+  if (!itemKey) {
+    return void 0;
+  }
+  const currentSize = state.sizes.get(itemKey);
+  if (!(currentSize && currentSize > 0)) {
+    return void 0;
+  }
+  const stickyIndexInArray = state.props.stickyIndicesArr.indexOf(index);
+  if (stickyIndexInArray === -1) {
+    return void 0;
+  }
+  const nextStickyIndex = state.props.stickyIndicesArr[stickyIndexInArray + 1];
+  if (nextStickyIndex === void 0) {
+    return void 0;
+  }
+  const nextStickyPosition = state.positions[nextStickyIndex];
+  if (nextStickyPosition === void 0) {
+    return void 0;
+  }
+  return nextStickyPosition - currentSize;
+}
 // src/entrypoints/shared.ts
 var LegendListRuntime = LegendList;
 var internal = {
   getComponent,
+  getStickyPushLimit,
   IsNewArchitecture,
   POSITION_OUT_OF_VIEW,
   peek$,
+  typedForwardRef,
+  typedMemo,
   useArr$,
   useCombinedRef,
   useStateContext
@@ -6039,8 +6465,6 @@ var internal2 = internal;
 exports.LegendList = LegendList3;
 exports.internal = internal2;
-exports.typedForwardRef = typedForwardRef;
-exports.typedMemo = typedMemo;
 exports.useIsLastItem = useIsLastItem;
 exports.useListScrollSize = useListScrollSize;
 exports.useRecyclingEffect = useRecyclingEffect;