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

package/react-native.js

@@ -29,37 +29,6 @@ var ReactNative__namespace = /*#__PURE__*/_interopNamespace(ReactNative);
 ReactNative.Animated.View;
 var View = ReactNative.View;
 var Text = ReactNative.Text;
-
-// 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);
-}
 var createAnimatedValue = (value) => new ReactNative.Animated.Value(value);
 
 // src/state/state.tsx
@@ -83,6 +52,11 @@ function StateProvider({ children }) {
       ["headerSize", 0],
       ["numContainers", 0],
       ["activeStickyIndex", -1],
+      ["isAtEnd", false],
+      ["isAtStart", false],
+      ["isNearEnd", false],
+      ["isNearStart", false],
+      ["isWithinMaintainScrollAtEndThreshold", false],
       ["totalSize", 0],
       ["scrollAdjustPending", 0]
     ]),
@@ -174,29 +148,71 @@ function notifyPosition$(ctx, key, value) {
 function useArr$(signalNames) {
   const ctx = React2__namespace.useContext(ContextState);
   const { subscribe, get } = React2__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 = React2__namespace.useContext(ContextState);
   const { subscribe, get } = React2__namespace.useMemo(() => createSelectorFunctionsArr(ctx, [signalName]), [ctx, signalName]);
-  const value = shim.useSyncExternalStore(subscribe, () => selector(get()[0]));
+  const getSelectedValue = React2__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__ */ React2__namespace.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
 };
-React2__namespace.memo(function DebugView2({ state }) {
+React2__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] = React2.useReducer((x) => x + 1, 0);
@@ -221,7 +237,7 @@ React2__namespace.memo(function DebugView2({ state }) {
     },
     /* @__PURE__ */ React2__namespace.createElement(DebugRow, null, /* @__PURE__ */ React2__namespace.createElement(Text, null, "TotalSize:"), /* @__PURE__ */ React2__namespace.createElement(Text, null, totalSize.toFixed(2))),
     /* @__PURE__ */ React2__namespace.createElement(DebugRow, null, /* @__PURE__ */ React2__namespace.createElement(Text, null, "ContentSize:"), /* @__PURE__ */ React2__namespace.createElement(Text, null, contentSize.toFixed(2))),
-    /* @__PURE__ */ React2__namespace.createElement(DebugRow, null, /* @__PURE__ */ React2__namespace.createElement(Text, null, "At end:"), /* @__PURE__ */ React2__namespace.createElement(Text, null, String(state.isAtEnd))),
+    /* @__PURE__ */ React2__namespace.createElement(DebugRow, null, /* @__PURE__ */ React2__namespace.createElement(Text, null, "At end:"), /* @__PURE__ */ React2__namespace.createElement(Text, null, String(isAtEnd))),
     /* @__PURE__ */ React2__namespace.createElement(DebugRow, null, /* @__PURE__ */ React2__namespace.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React2__namespace.createElement(Text, null, scrollAdjust.toFixed(2))),
     /* @__PURE__ */ React2__namespace.createElement(DebugRow, null, /* @__PURE__ */ React2__namespace.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React2__namespace.createElement(Text, null, rawScroll.toFixed(2))),
     /* @__PURE__ */ React2__namespace.createElement(DebugRow, null, /* @__PURE__ */ React2__namespace.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React2__namespace.createElement(Text, null, scroll.toFixed(2)))
@@ -234,6 +250,30 @@ function useInterval(callback, delay) {
   }, [delay]);
 }
 
+// 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/utils/devEnvironment.ts
 var metroDev = typeof __DEV__ !== "undefined" ? __DEV__ : void 0;
 var _a;
@@ -244,6 +284,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;
 
@@ -255,93 +296,26 @@ var useAnimatedValue = (initialValue) => {
   return animAnimatedValue;
 };
 
-// src/utils/helpers.ts
-function isFunction(obj) {
-  return typeof obj === "function";
-}
-function isArray(obj) {
-  return Array.isArray(obj);
-}
-var warned = /* @__PURE__ */ new Set();
-function warnDevOnce(id, text) {
-  if (IS_DEV && !warned.has(id)) {
-    warned.add(id);
-    console.warn(`[legend-list] ${text}`);
-  }
-}
-function roundSize(size) {
-  return Math.floor(size * 8) / 8;
-}
-function isNullOrUndefined(value) {
-  return value === null || value === void 0;
-}
-function comparatorDefault(a, b) {
-  return a - b;
-}
-function getPadding(s, type) {
-  var _a3, _b, _c;
-  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : s.paddingVertical) != null ? _b : s.padding) != null ? _c : 0;
-}
-function extractPadding(style, contentContainerStyle, type) {
-  return getPadding(style, type) + getPadding(contentContainerStyle, type);
-}
-function findContainerId(ctx, key) {
-  var _a3, _b;
-  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
-  if (directMatch !== void 0) {
-    return directMatch;
-  }
-  const numContainers = peek$(ctx, "numContainers");
-  for (let i = 0; i < numContainers; i++) {
-    const itemKey = peek$(ctx, `containerItemKey${i}`);
-    if (itemKey === key) {
-      return i;
-    }
-  }
-  return -1;
-}
-
 // src/hooks/useValue$.ts
 function useValue$(key, params) {
-  const { getValue, delay } = params || {};
+  const { getValue } = params || {};
   const ctx = useStateContext();
   const getNewValue = () => {
     var _a3;
     return (_a3 = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a3 : 0;
   };
   const animValue = useAnimatedValue(getNewValue());
-  React2.useMemo(() => {
-    let prevValue;
-    let didQueueTask = false;
-    listen$(ctx, key, () => {
-      const newValue = getNewValue();
-      if (delay !== void 0) {
-        const fn = () => {
-          didQueueTask = false;
-          const latestValue = getNewValue();
-          if (latestValue !== void 0) {
-            animValue.setValue(latestValue);
-          }
-        };
-        const delayValue = isFunction(delay) ? delay(newValue, prevValue) : delay;
-        prevValue = newValue;
-        if (!didQueueTask) {
-          didQueueTask = true;
-          if (delayValue === void 0) {
-            fn();
-          } else if (delayValue === 0) {
-            queueMicrotask(fn);
-          } else {
-            setTimeout(fn, delayValue);
-          }
-        }
-      } else {
-        animValue.setValue(newValue);
-      }
-    });
-  }, []);
+  React2.useLayoutEffect(() => {
+    const syncCurrentValue = () => {
+      animValue.setValue(getNewValue());
+    };
+    const unsubscribe = listen$(ctx, key, syncCurrentValue);
+    syncCurrentValue();
+    return unsubscribe;
+  }, [animValue, ctx, key]);
   return animValue;
 }
+var typedForwardRef = React2__namespace.forwardRef;
 var typedMemo = React2__namespace.memo;
 var getComponent = (Component) => {
   if (React2__namespace.isValidElement(Component)) {
@@ -361,18 +335,8 @@ var PositionViewState = typedMemo(function PositionViewState2({
   refView,
   ...rest
 }) {
-  const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
-  return /* @__PURE__ */ React2__namespace.createElement(
-    ReactNative.View,
-    {
-      ref: refView,
-      style: [
-        style,
-        horizontal ? { transform: [{ translateX: position }] } : { transform: [{ translateY: position }] }
-      ],
-      ...rest
-    }
-  );
+  const [position = POSITION_OUT_OF_VIEW, _itemKey] = useArr$([`containerPosition${id}`, `containerItemKey${id}`]);
+  return /* @__PURE__ */ React2__namespace.createElement(ReactNative.View, { ref: refView, style: [style, horizontal ? { left: position } : { top: position }], ...rest });
 });
 var PositionViewAnimated = typedMemo(function PositionViewAnimated2({
   id,
@@ -403,25 +367,46 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
   children,
   ...rest
 }) {
-  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0] = useArr$([
+  const ctx = useStateContext();
+  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0, itemKey, _totalSize = 0] = useArr$([
     `containerPosition${id}`,
     "headerSize",
-    "stylePaddingTop"
+    "stylePaddingTop",
+    `containerItemKey${id}`,
+    "totalSize"
   ]);
+  const pushLimit = React2__namespace.useMemo(
+    () => getStickyPushLimit(ctx.state, index, itemKey),
+    [ctx.state, index, itemKey, _totalSize]
+  );
   const transform = React2__namespace.useMemo(() => {
     var _a3;
     if (animatedScrollY) {
       const stickyConfigOffset = (_a3 = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a3 : 0;
       const stickyStart = position + headerSize + stylePaddingTop - stickyConfigOffset;
-      const stickyPosition = animatedScrollY.interpolate({
-        extrapolateLeft: "clamp",
-        extrapolateRight: "extend",
-        inputRange: [stickyStart, stickyStart + 5e3],
-        outputRange: [position, position + 5e3]
-      });
+      let stickyPosition;
+      if (pushLimit !== void 0) {
+        if (pushLimit <= position) {
+          stickyPosition = pushLimit;
+        } else {
+          stickyPosition = animatedScrollY.interpolate({
+            extrapolateLeft: "clamp",
+            extrapolateRight: "clamp",
+            inputRange: [stickyStart, stickyStart + (pushLimit - position)],
+            outputRange: [position, pushLimit]
+          });
+        }
+      } else {
+        stickyPosition = animatedScrollY.interpolate({
+          extrapolateLeft: "clamp",
+          extrapolateRight: "extend",
+          inputRange: [stickyStart, stickyStart + 5e3],
+          outputRange: [position, position + 5e3]
+        });
+      }
       return horizontal ? [{ translateX: stickyPosition }] : [{ translateY: stickyPosition }];
     }
-  }, [animatedScrollY, headerSize, horizontal, position, stylePaddingTop, stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset]);
+  }, [animatedScrollY, headerSize, horizontal, position, pushLimit, stylePaddingTop, stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset]);
   const viewStyle = React2__namespace.useMemo(() => [style, { zIndex: index + 1e3 }, { transform }], [style, transform]);
   const renderStickyHeaderBackdrop = React2__namespace.useMemo(() => {
     if (!(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)) {
@@ -446,6 +431,52 @@ function useInit(cb) {
   React2.useState(() => cb());
 }
 
+// src/utils/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+function isArray(obj) {
+  return Array.isArray(obj);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnDevOnce(id, text) {
+  if (IS_DEV && !warned.has(id)) {
+    warned.add(id);
+    console.warn(`[legend-list] ${text}`);
+  }
+}
+function roundSize(size) {
+  return Math.floor(size * 8) / 8;
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function comparatorDefault(a, b) {
+  return a - b;
+}
+function getPadding(s, type) {
+  var _a3, _b, _c;
+  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : s.paddingVertical) != null ? _b : s.padding) != null ? _c : 0;
+}
+function extractPadding(style, contentContainerStyle, type) {
+  return getPadding(style, type) + getPadding(contentContainerStyle, type);
+}
+function findContainerId(ctx, key) {
+  var _a3, _b;
+  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
+  if (directMatch !== void 0) {
+    return directMatch;
+  }
+  const numContainers = peek$(ctx, "numContainers");
+  for (let i = 0; i < numContainers; i++) {
+    const itemKey = peek$(ctx, `containerItemKey${i}`);
+    if (itemKey === key) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 // src/state/ContextContainer.ts
 var ContextContainer = React2.createContext(null);
 function useContextContainer() {
@@ -613,11 +644,11 @@ function useOnLayoutSync({
       const { layout } = event.nativeEvent;
       if (layout.height !== ((_a3 = lastLayoutRef.current) == null ? void 0 : _a3.height) || layout.width !== ((_b = lastLayoutRef.current) == null ? void 0 : _b.width)) {
         onLayoutChange(layout, false);
-        onLayoutProp == null ? void 0 : onLayoutProp(event);
         lastLayoutRef.current = layout;
       }
+      onLayoutProp == null ? void 0 : onLayoutProp(event);
     },
-    [onLayoutChange]
+    [onLayoutChange, onLayoutProp]
   );
   if (IsNewArchitecture) {
     React2.useLayoutEffect(() => {
@@ -634,8 +665,6 @@ function useOnLayoutSync({
 }
 var Platform2 = ReactNative.Platform;
 var PlatformAdjustBreaksScroll = Platform2.OS === "android";
-var typedForwardRef = React2__namespace.forwardRef;
-var typedMemo2 = React2__namespace.memo;
 
 // src/utils/isInMVCPActiveMode.native.ts
 function isInMVCPActiveMode(state) {
@@ -643,7 +672,7 @@ function isInMVCPActiveMode(state) {
 }
 
 // src/components/Container.tsx
-var Container = typedMemo2(function Container2({
+var Container = typedMemo(function Container2({
   id,
   recycleItems,
   horizontal,
@@ -687,17 +716,20 @@ var Container = typedMemo2(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,
@@ -705,6 +737,7 @@ var Container = typedMemo2(function Container2({
       top: otherAxisPos,
       ...paddingStyles || {}
     } : {
+      boxSizing: paddingStyles ? "border-box" : void 0,
       left: otherAxisPos,
       position: "absolute",
       right: numColumns > 1 ? null : 0,
@@ -838,16 +871,9 @@ var Containers = typedMemo(function Containers2({
   const ctx = useStateContext();
   const columnWrapperStyle = ctx.columnWrapperStyle;
   const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
-  const animSize = useValue$("totalSize", {
-    // Use a microtask if increasing the size significantly, otherwise use a timeout
-    // If this is the initial scroll, we don't want to delay because we want to update the size immediately
-    delay: (value, prevValue) => {
-      var _a3;
-      return !((_a3 = ctx.state) == null ? void 0 : _a3.initialScroll) ? !prevValue || value - prevValue > 20 ? 0 : 200 : void 0;
-    }
-  });
+  const animSize = useValue$("totalSize");
+  const otherAxisSize = useValue$("otherAxisSize");
   const animOpacity = useValue$("readyToRender", { getValue: (value) => value ? 1 : 0 });
-  const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
     containers.push(
@@ -891,17 +917,20 @@ var Containers = typedMemo(function Containers2({
 });
 var ListComponentScrollView = ReactNative.Animated.ScrollView;
 function ScrollAdjust() {
+  var _a3;
+  const ctx = useStateContext();
   const bias = 1e7;
   const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
   const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
+  const horizontal = !!((_a3 = ctx.state) == null ? void 0 : _a3.props.horizontal);
   return /* @__PURE__ */ React2__namespace.createElement(
     ReactNative.View,
     {
       style: {
         height: 0,
-        left: 0,
+        left: horizontal ? scrollOffset : 0,
         position: "absolute",
-        top: scrollOffset,
+        top: horizontal ? 0 : scrollOffset,
         width: 0
       }
     }
@@ -911,14 +940,25 @@ function SnapWrapper({ ScrollComponent, ...props }) {
   const [snapToOffsets] = useArr$(["snapToOffsets"]);
   return /* @__PURE__ */ React2__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__ */ React2__namespace.createElement("div", { style }, null);
+}
 var LayoutView = ({ onLayoutChange, refView, ...rest }) => {
-  const ref = refView != null ? refView : React2.useRef(null);
+  const localRef = React2.useRef(null);
+  const ref = refView != null ? refView : localRef;
   const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
   return /* @__PURE__ */ React2__namespace.createElement(ReactNative.View, { ...rest, onLayout, ref });
 };
 
 // src/components/ListComponent.tsx
-var ListComponent = typedMemo2(function ListComponent2({
+var ListComponent = typedMemo(function ListComponent2({
   canRender,
   style,
   contentContainerStyle,
@@ -948,12 +988,14 @@ var ListComponent = typedMemo2(function ListComponent2({
 }) {
   const ctx = useStateContext();
   const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
-  const ScrollComponent = renderScrollComponent ? React2.useMemo(
-    () => React2__namespace.forwardRef(
+  const ScrollComponent = React2.useMemo(() => {
+    if (!renderScrollComponent) {
+      return ListComponentScrollView;
+    }
+    return React2__namespace.forwardRef(
       (props, ref) => renderScrollComponent({ ...props, ref })
-    ),
-    [renderScrollComponent]
-  ) : ListComponentScrollView;
+    );
+  }, [renderScrollComponent]);
   const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
   React2.useLayoutEffect(() => {
     if (!ListHeaderComponent) {
@@ -1013,183 +1055,90 @@ var ListComponent = typedMemo2(function ListComponent2({
       }
     ),
     ListFooterComponent && /* @__PURE__ */ React2__namespace.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
+    Platform2.OS === "web" && /* @__PURE__ */ React2__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;
+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;
+  React2.useEffect(() => {
+    if (stickyIndices && !stickyHeaderIndices) {
+      warnDevOnce(
+        "stickyIndices",
+        "stickyIndices has been renamed to stickyHeaderIndices. Please update your props to use stickyHeaderIndices."
+      );
+    }
+  }, [stickyHeaderIndices, stickyIndices]);
+  React2.useEffect(() => {
+    if (useWindowScroll && renderScrollComponent) {
+      warnDevOnce(
+        "useWindowScrollRenderScrollComponent",
+        "useWindowScroll is not supported when renderScrollComponent is provided."
+      );
+    }
+  }, [renderScrollComponent, useWindowScroll]);
+  React2.useEffect(() => {
+    if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
+      warnDevOnce(
+        "keyExtractor",
+        "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
+      );
+    }
+  }, [childrenMode, ctx, keyExtractor]);
+  React2.useEffect(() => {
+    const state = ctx.state;
+    const dataLength = state.props.data.length;
+    const useWindowScrollResolved = state.props.useWindowScroll;
+    if (Platform2.OS !== "web" || useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+      return;
+    }
+    const warnIfUnboundedOuterSize = () => {
+      const readyToRender = peek$(ctx, "readyToRender");
+      const numContainers = peek$(ctx, "numContainers") || 0;
+      const totalSize = peek$(ctx, "totalSize") || 0;
+      const scrollLength = ctx.state.scrollLength || 0;
+      if (!readyToRender || totalSize <= 0 || scrollLength <= 0) {
+        return;
+      }
+      const rendersAlmostEverything = numContainers >= Math.ceil(dataLength * WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO);
+      const viewportMatchesContent = scrollLength >= totalSize * WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO;
+      if (rendersAlmostEverything && viewportMatchesContent) {
+        warnDevOnce(
+          "webUnboundedOuterSize",
+          "LegendList appears to have an unbounded outer height on web, so virtualization is effectively disabled. Set a bounded height or flex: 1 on the list container, or use useWindowScroll."
+        );
+      }
+    };
+    warnIfUnboundedOuterSize();
+    const unsubscribe = [
+      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
+      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
+      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
+    ];
+    return () => {
+      for (const unsub of unsubscribe) {
+        unsub();
+      }
+    };
+  }, [ctx]);
 }
-
-// src/core/getTopOffsetAdjustment.ts
-function getTopOffsetAdjustment(ctx) {
-  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
+function useDevChecksNoop(_props) {
 }
+var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
 
-// 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) {
-    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
-      state.pendingTotalSize = totalSize;
-    } else {
-      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);
-    }
-  }
-  if (size === void 0) {
-    size = sizes.get(key);
-    if (size !== void 0) {
-      return size;
-    }
-  }
-  if (size === void 0) {
-    size = getEstimatedItemSize ? getEstimatedItemSize(data, index, itemType) : estimatedItemSize;
-  }
-  setSize(ctx, key, size);
-  return size;
-}
-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(state);
-    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) && (Platform2.OS !== "android" || state.lastLayout)) {
-    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/deferredPublicOnScroll.ts
-function withResolvedContentOffset(state, event, resolvedOffset) {
-  return {
-    ...event,
-    nativeEvent: {
-      ...event.nativeEvent,
-      contentOffset: state.props.horizontal ? { x: resolvedOffset, y: 0 } : { x: 0, y: resolvedOffset }
-    }
-  };
+// src/core/deferredPublicOnScroll.ts
+function withResolvedContentOffset(state, event, resolvedOffset) {
+  return {
+    ...event,
+    nativeEvent: {
+      ...event.nativeEvent,
+      contentOffset: state.props.horizontal ? { x: resolvedOffset, y: 0 } : { x: 0, y: resolvedOffset }
+    }
+  };
 }
 function releaseDeferredPublicOnScroll(ctx, resolvedOffset) {
   var _a3, _b, _c, _d;
@@ -1268,63 +1217,489 @@ var initialScrollCompletion = {
     if (!state.initialScrollSession) {
       return;
     }
-    const completion = ensureInitialScrollSessionCompletion(state, state.initialScrollSession.kind);
-    completion.didDispatchNativeScroll = void 0;
-    completion.didRetrySilentInitialScroll = void 0;
+    const completion = ensureInitialScrollSessionCompletion(state, state.initialScrollSession.kind);
+    completion.didDispatchNativeScroll = void 0;
+    completion.didRetrySilentInitialScroll = void 0;
+  }
+};
+var initialScrollWatchdog = {
+  clear(state) {
+    initialScrollWatchdog.set(state, void 0);
+  },
+  didObserveProgress(newScroll, watchdog) {
+    const previousDistance = Math.abs(watchdog.startScroll - watchdog.targetOffset);
+    const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
+    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET || nextDistance + INITIAL_SCROLL_MIN_TARGET_OFFSET < previousDistance;
+  },
+  get(state) {
+    var _a3, _b;
+    return (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog;
+  },
+  hasNonZeroTargetOffset(targetOffset) {
+    return targetOffset !== void 0 && targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  isAtZeroTargetOffset(targetOffset) {
+    return targetOffset <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  set(state, watchdog) {
+    var _a3, _b;
+    if (!watchdog && !((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog)) {
+      return;
+    }
+    const completion = ensureInitialScrollSessionCompletion(state);
+    completion.watchdog = watchdog ? {
+      startScroll: watchdog.startScroll,
+      targetOffset: watchdog.targetOffset
+    } : void 0;
+  }
+};
+function setInitialScrollSession(state, options = {}) {
+  var _a3, _b, _c;
+  const existingSession = state.initialScrollSession;
+  const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
+  const completion = existingSession == null ? void 0 : existingSession.completion;
+  const hasBootstrapOverride = Object.hasOwn(options, "bootstrap");
+  const bootstrap = kind === "bootstrap" ? hasBootstrapOverride ? options.bootstrap : (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0 : void 0;
+  if (!kind) {
+    return clearInitialScrollSession(state);
+  }
+  if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
+    return clearInitialScrollSession(state);
+  }
+  const previousDataLength = (_c = (_b = options.previousDataLength) != null ? _b : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _c : 0;
+  state.initialScrollSession = createInitialScrollSession({
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  });
+  return state.initialScrollSession;
+}
+
+// src/utils/checkThreshold.ts
+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 = Platform2.OS === "web" && ((_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) {
+    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
+      state.pendingTotalSize = totalSize;
+    } else {
+      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);
+    }
   }
-};
-var initialScrollWatchdog = {
-  clear(state) {
-    initialScrollWatchdog.set(state, void 0);
-  },
-  didObserveProgress(newScroll, watchdog) {
-    const previousDistance = Math.abs(watchdog.startScroll - watchdog.targetOffset);
-    const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
-    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET || nextDistance + INITIAL_SCROLL_MIN_TARGET_OFFSET < previousDistance;
-  },
-  get(state) {
-    var _a3, _b;
-    return (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog;
-  },
-  hasNonZeroTargetOffset(targetOffset) {
-    return targetOffset !== void 0 && targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  isAtZeroTargetOffset(targetOffset) {
-    return targetOffset <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  set(state, watchdog) {
-    var _a3, _b;
-    if (!watchdog && !((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog)) {
-      return;
+  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);
     }
-    const completion = ensureInitialScrollSessionCompletion(state);
-    completion.watchdog = watchdog ? {
-      startScroll: watchdog.startScroll,
-      targetOffset: watchdog.targetOffset
-    } : void 0;
   }
-};
-function setInitialScrollSession(state, options = {}) {
-  var _a3, _b, _c;
-  const existingSession = state.initialScrollSession;
-  const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
-  const completion = existingSession == null ? void 0 : existingSession.completion;
-  const hasBootstrapOverride = Object.hasOwn(options, "bootstrap");
-  const bootstrap = kind === "bootstrap" ? hasBootstrapOverride ? options.bootstrap : (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0 : void 0;
-  if (!kind) {
-    return clearInitialScrollSession(state);
+  if (size === void 0) {
+    size = getEstimatedItemSize ? getEstimatedItemSize(data, index, itemType) : estimatedItemSize;
   }
-  if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
-    return clearInitialScrollSession(state);
+  setSize(ctx, key, size);
+  return size;
+}
+function getItemSizeAtIndex(ctx, index) {
+  if (index === void 0 || index < 0) {
+    return void 0;
   }
-  const previousDataLength = (_c = (_b = options.previousDataLength) != null ? _b : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _c : 0;
-  state.initialScrollSession = createInitialScrollSession({
-    bootstrap,
-    completion,
-    kind,
-    previousDataLength
-  });
-  return state.initialScrollSession;
+  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) && (Platform2.OS !== "android" || state.lastLayout)) {
+    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
@@ -1345,15 +1720,20 @@ function finishScrollTo(ctx) {
     }
     if (scrollingTo.isInitialScroll || state.initialScroll) {
       const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
       finishInitialScroll(ctx, {
-        onFinished: resolvePendingScroll,
-        preserveTarget: isOffsetSession && state.props.data.length === 0 || !!scrollingTo.isInitialScroll && !!((_b = state.initialScroll) == null ? void 0 : _b.preserveForFooterLayout),
+        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();
   }
 }
@@ -1528,6 +1908,17 @@ function doScrollTo(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;
@@ -1575,8 +1966,10 @@ function scrollTo(ctx, params) {
     if (isInitialScroll) {
       initialScrollCompletion.resetFlags(state);
     }
+    const averageSizeSnapshot = getAverageSizeSnapshot(state);
     state.scrollingTo = {
       ...scrollTarget,
+      ...averageSizeSnapshot ? { averageSizeSnapshot } : {},
       targetOffset,
       waitForInitialScrollCompletionFrame
     };
@@ -1630,183 +2023,10 @@ function scrollToIndex(ctx, {
     offset: firstIndexOffset,
     viewOffset,
     viewPosition: viewPosition != null ? viewPosition : 0
-  });
-}
-
-// 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;
-}
 function dispatchInitialScroll(ctx, params) {
   const { forceScroll, resolvedOffset, target, waitForCompletionFrame } = params;
   const requestedIndex = target.index;
@@ -1827,6 +2047,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;
@@ -1835,44 +2060,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 = Platform2.OS === "web" && ((_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;
@@ -1966,13 +2153,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);
@@ -2191,16 +2383,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;
@@ -2215,6 +2413,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;
@@ -2251,15 +2468,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,
@@ -2272,6 +2490,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
@@ -2313,7 +2539,11 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
     return;
   }
   if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
-    clearPendingInitialScrollFooterLayout(state, initialScroll);
+    clearPendingInitialScrollFooterLayout(ctx, {
+      dataLength,
+      stylePaddingBottom,
+      target: initialScroll
+    });
   } else {
     const updatedInitialScroll = createInitialScrollAtEndTarget({
       dataLength,
@@ -2323,10 +2553,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),
@@ -2335,6 +2570,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;
@@ -2392,7 +2650,7 @@ function evaluateBootstrapInitialScroll(ctx) {
     queueBootstrapInitialScrollReevaluation(state);
     return;
   }
-  if (Platform2.OS !== "web" && Platform2.OS !== "android" && Math.abs(bootstrapInitialScroll.seedContentOffset - resolvedOffset) <= 1) {
+  if (Platform2.OS !== "web" && Platform2.OS !== "android" && Math.abs(bootstrapInitialScroll.seedContentOffset - resolvedOffset) <= 1 && Math.abs(getObservedBootstrapInitialScrollOffset(state) - resolvedOffset) <= 1) {
     finishBootstrapInitialScrollWithoutScroll(ctx, resolvedOffset);
   } else {
     clearBootstrapInitialScrollSession(state);
@@ -2405,12 +2663,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) {
@@ -2687,7 +2948,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;
   }
@@ -2852,6 +3113,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;
@@ -3014,9 +3355,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
 }) {
@@ -3041,7 +3383,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 || Platform2.OS === "web" && state.scrollLength > 0 && lastScrollDelta > state.scrollLength);
+  const shouldOptimize = !forceFullUpdate && !dataChanged && (optimizeForVisibleWindow || Math.abs(velocity) > 0 || Platform2.OS === "web" && 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;
@@ -3156,7 +3498,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;
@@ -3176,7 +3526,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 }
@@ -3185,6 +3535,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);
@@ -3200,7 +3552,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(
@@ -3269,7 +3621,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) {
@@ -3581,7 +3933,6 @@ function calculateItemsInView(ctx, params = {}) {
         alwaysRenderIndicesSet,
         drawDistance,
         getItemType,
-        itemsAreEqual,
         keyExtractor,
         onStickyHeaderChange
       },
@@ -3608,11 +3959,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;
@@ -3657,9 +4008,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
     });
@@ -3907,33 +4260,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;
         }
       }
     }
@@ -3944,7 +4275,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);
     }
@@ -3955,7 +4289,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) {
@@ -3967,37 +4303,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;
@@ -4010,7 +4326,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
@@ -4028,68 +4344,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;
@@ -4100,6 +4370,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;
@@ -4344,6 +4661,7 @@ function onScroll(ctx, event) {
   state.scrollPending = newScroll;
   updateScroll(ctx, newScroll, insetChanged);
   trackInitialScrollNativeProgress(state, newScroll);
+  clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx);
   if (state.scrollingTo) {
     checkFinishedScroll(ctx);
   }
@@ -4407,6 +4725,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;
@@ -4490,6 +4845,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;
@@ -4620,26 +4976,13 @@ function createColumnWrapperStyle(contentContainerStyle) {
   }
 }
 
-// src/utils/hasActiveMVCPAnchorLock.ts
-function hasActiveMVCPAnchorLock(state) {
-  const lock = state.mvcpAnchorLock;
-  if (!lock) {
-    return false;
-  }
-  if (Date.now() > lock.expiresAt) {
-    state.mvcpAnchorLock = void 0;
-    return false;
-  }
-  return true;
-}
-
 // src/utils/createImperativeHandle.ts
 function createImperativeHandle(ctx) {
   const state = ctx.state;
   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;
@@ -4661,9 +5004,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 = () => {
@@ -4678,11 +5022,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) {
@@ -4739,10 +5084,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],
@@ -4789,10 +5137,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);
@@ -4888,7 +5241,7 @@ function getRenderedItem(ctx, key) {
       item,
       type: getItemType ? (_a3 = getItemType(item, index)) != null ? _a3 : "" : ""
     };
-    renderedItem = isFunction(renderItem) ? renderItem(itemProps) : React2__namespace.default.createElement(renderItem, itemProps);
+    renderedItem = React2__namespace.default.createElement(renderItem, itemProps);
   }
   return { index, item: data[index], renderedItem };
 }
@@ -5003,7 +5356,7 @@ function useThrottledOnScroll(originalHandler, scrollEventThrottle) {
 }
 
 // src/components/LegendList.tsx
-var LegendList = typedMemo2(
+var LegendList = typedMemo(
   // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
   typedForwardRef(function LegendList2(props, forwardedRef) {
     const { children, data: dataProp, renderItem: renderItemProp, ...restProps } = props;
@@ -5022,9 +5375,18 @@ var LegendList = typedMemo2(
   })
 );
 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 = React2.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,
@@ -5090,7 +5452,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const positionComponentInternal = props.positionComponentInternal;
   const stickyPositionComponentInternal = props.stickyPositionComponentInternal;
   const {
-    childrenMode,
     positionComponentInternal: _positionComponentInternal,
     stickyPositionComponentInternal: _stickyPositionComponentInternal,
     ...restProps
@@ -5154,18 +5515,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 = Platform2.OS === "web" && !!useWindowScroll && !renderScrollComponent;
   const refState = React2.useRef(void 0);
   const hasOverrideItemLayout = !!overrideItemLayout;
@@ -5174,7 +5523,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     if (!ctx.state) {
       const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { height: 0, width: 0 } : getWindowSize())[horizontal ? "width" : "height"];
       ctx.state = {
-        activeStickyIndex: -1,
         averageSizes: {},
         columnSpans: [],
         columns: [],
@@ -5198,8 +5546,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,
@@ -5210,6 +5556,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         minIndexSizeChanged: 0,
         nativeContentInset: void 0,
         nativeMarginTop: 0,
+        pendingDataComparison: void 0,
         pendingNativeMVCPAdjust: void 0,
         positions: [],
         props: {},
@@ -5248,22 +5595,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 = Platform2.OS === "web" && anchoredEndSpace ? { ...anchoredEndSpace, includeInEndInset: true } : anchoredEndSpace;
   state.props = {
     alignItemsAtEnd,
     alwaysRender,
     alwaysRenderIndicesArr: alwaysRenderIndices.arr,
     alwaysRenderIndicesSet: alwaysRenderIndices.set,
+    anchoredEndSpace: anchoredEndSpaceResolved,
     animatedProps: animatedPropsInternal,
     contentInset,
     data: dataProp,
@@ -5353,16 +5707,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);
+  }
   React2.useLayoutEffect(() => {
     handleInitialScrollDataChange(ctx, {
       dataLength: dataProp.length,
@@ -5372,6 +5725,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
   }, [dataProp.length, didDataChangeLocal, initialScrollAtEnd, stylePaddingBottomState, usesBootstrapInitialScroll]);
+  React2.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 = React2.useCallback(
     (layout) => {
       if (!usesBootstrapInitialScroll) {
@@ -5387,14 +5751,21 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     [dataProp.length, initialScrollAtEnd, horizontal, stylePaddingBottomState, usesBootstrapInitialScroll]
   );
   const onLayoutChange = React2.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,
@@ -5407,6 +5778,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       updateSnapToOffsets(ctx);
     }
   }, [snapToIndices]);
+  React2.useLayoutEffect(
+    () => initializeStateVars(true),
+    [dataVersion, memoizedLastItemKeys.join(","), numColumnsProp, stylePaddingBottomState, stylePaddingTopState]
+  );
   React2.useLayoutEffect(() => {
     const {
       didColumnsChange,
@@ -5416,7 +5791,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;
@@ -5431,10 +5809,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { forceFullItemPositions: true });
     }
   }, [extraData, hasOverrideItemLayout, numColumnsProp]);
-  React2.useLayoutEffect(
-    () => initializeStateVars(true),
-    [dataVersion, memoizedLastItemKeys.join(","), numColumnsProp, stylePaddingBottomState, stylePaddingTopState]
-  );
   React2.useEffect(() => {
     if (!onMetricsChange) {
       return;
@@ -5467,20 +5841,18 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  if (!IsNewArchitecture) {
-    useInit(() => {
+  useInit(() => {
+    if (!IsNewArchitecture) {
       doInitialAllocateContainers(ctx);
-    });
-  }
+    }
+  });
   React2.useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx), []);
-  if (Platform2.OS === "web") {
-    React2.useEffect(() => {
-      if (usesBootstrapInitialScroll) {
-        return;
-      }
-      advanceCurrentInitialScrollSession(ctx);
-    }, [usesBootstrapInitialScroll]);
-  }
+  React2.useEffect(() => {
+    if (Platform2.OS !== "web" || usesBootstrapInitialScroll) {
+      return;
+    }
+    advanceCurrentInitialScrollSession(ctx);
+  }, [ctx, usesBootstrapInitialScroll]);
   const fns = React2.useMemo(
     () => ({
       getRenderedItem: (key) => getRenderedItem(ctx, key),
@@ -5518,7 +5890,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2__namespace.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_f = refreshControlElement.props.progressViewOffset) != null ? _f : 0) + stylePaddingTopState
+        progressViewOffset: ((_g = refreshControlElement.props.progressViewOffset) != null ? _g : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2__namespace.createElement(
         ReactNative.RefreshControl,
         {
@@ -5529,7 +5901,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,
@@ -5544,9 +5916,12 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
 var LegendListRuntime = LegendList;
 var internal = {
   getComponent,
+  getStickyPushLimit,
   IsNewArchitecture,
   POSITION_OUT_OF_VIEW,
   peek$,
+  typedForwardRef,
+  typedMemo,
   useArr$,
   useCombinedRef,
   useStateContext
@@ -5558,8 +5933,6 @@ var internal2 = internal;
 
 exports.LegendList = LegendList3;
 exports.internal = internal2;
-exports.typedForwardRef = typedForwardRef;
-exports.typedMemo = typedMemo2;
 exports.useIsLastItem = useIsLastItem;
 exports.useListScrollSize = useListScrollSize;
 exports.useRecyclingEffect = useRecyclingEffect;