@legendapp/list 3.0.0-beta.4 → 3.0.0-beta.40

package/index.native.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var React2 = require('react');
-var reactNative = require('react-native');
+var ReactNative = require('react-native');
 var shim = require('use-sync-external-store/shim');
 
 function _interopNamespace(e) {
@@ -23,35 +23,68 @@ function _interopNamespace(e) {
 }
 
 var React2__namespace = /*#__PURE__*/_interopNamespace(React2);
+var ReactNative__namespace = /*#__PURE__*/_interopNamespace(ReactNative);
 
 // src/components/LegendList.tsx
-reactNative.Animated.View;
-var View = reactNative.View;
-var Text = reactNative.Text;
-var createAnimatedValue = (value) => new reactNative.Animated.Value(value);
+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
 var ContextState = React2__namespace.createContext(null);
+var contextNum = 0;
 function StateProvider({ children }) {
   const [value] = React2__namespace.useState(() => ({
     animatedScrollY: createAnimatedValue(0),
     columnWrapperStyle: void 0,
-    internalState: void 0,
+    contextNum: contextNum++,
     listeners: /* @__PURE__ */ new Map(),
     mapViewabilityAmountCallbacks: /* @__PURE__ */ new Map(),
     mapViewabilityAmountValues: /* @__PURE__ */ new Map(),
     mapViewabilityCallbacks: /* @__PURE__ */ new Map(),
     mapViewabilityConfigStates: /* @__PURE__ */ new Map(),
     mapViewabilityValues: /* @__PURE__ */ new Map(),
+    positionListeners: /* @__PURE__ */ new Map(),
+    state: void 0,
     values: /* @__PURE__ */ new Map([
-      ["alignItemsPaddingTop", 0],
       ["stylePaddingTop", 0],
       ["headerSize", 0],
       ["numContainers", 0],
-      ["activeStickyIndex", void 0],
+      ["activeStickyIndex", -1],
       ["totalSize", 0],
-      ["scrollAdjustPending", 0],
-      ["scrollingTo", void 0]
+      ["scrollAdjustPending", 0]
     ]),
     viewRefs: /* @__PURE__ */ new Map()
   }));
@@ -119,15 +152,24 @@ function set$(ctx, signalName, value) {
     }
   }
 }
-function getContentSize(ctx) {
-  var _a3, _b;
-  const { values, internalState } = ctx;
-  const stylePaddingTop = values.get("stylePaddingTop") || 0;
-  const stylePaddingBottom = (internalState == null ? void 0 : internalState.props.stylePaddingBottom) || 0;
-  const headerSize = values.get("headerSize") || 0;
-  const footerSize = values.get("footerSize") || 0;
-  const totalSize = (_b = (_a3 = ctx.internalState) == null ? void 0 : _a3.pendingTotalSize) != null ? _b : values.get("totalSize");
-  return headerSize + footerSize + totalSize + stylePaddingTop + stylePaddingBottom;
+function listenPosition$(ctx, key, cb) {
+  const { positionListeners } = ctx;
+  let setListeners = positionListeners.get(key);
+  if (!setListeners) {
+    setListeners = /* @__PURE__ */ new Set();
+    positionListeners.set(key, setListeners);
+  }
+  setListeners.add(cb);
+  return () => setListeners.delete(cb);
+}
+function notifyPosition$(ctx, key, value) {
+  const { positionListeners } = ctx;
+  const setListeners = positionListeners.get(key);
+  if (setListeners) {
+    for (const listener of setListeners) {
+      listener(value);
+    }
+  }
 }
 function useArr$(signalNames) {
   const ctx = React2__namespace.useContext(ContextState);
@@ -146,7 +188,7 @@ function useSelector$(signalName, selector) {
 var DebugRow = ({ children }) => {
   return /* @__PURE__ */ React2__namespace.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
 };
-var DebugView = React2__namespace.memo(function DebugView2({ state }) {
+React2__namespace.memo(function DebugView2({ state }) {
   const ctx = useStateContext();
   const [totalSize = 0, scrollAdjust = 0, rawScroll = 0, scroll = 0, _numContainers = 0, _numContainersPooled = 0] = useArr$([
     "totalSize",
@@ -198,7 +240,7 @@ var _a;
 var envMode = typeof process !== "undefined" && typeof process.env === "object" && process.env ? (_a = process.env.NODE_ENV) != null ? _a : process.env.MODE : void 0;
 var processDev = typeof envMode === "string" ? envMode.toLowerCase() !== "production" : void 0;
 var _a2;
-var IS_DEV = (_a2 = metroDev != null ? metroDev : processDev) != null ? _a2 : false;
+var IS_DEV = (_a2 = processDev != null ? processDev : metroDev) != null ? _a2 : false;
 
 // src/constants.ts
 var POSITION_OUT_OF_VIEW = -1e7;
@@ -206,9 +248,10 @@ var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 
 // src/constants-platform.native.ts
-var IsNewArchitecture = global.nativeFabricUIManager != null;
+var f = global.nativeFabricUIManager;
+var IsNewArchitecture = f !== void 0 && f != null;
 var useAnimatedValue = (initialValue) => {
-  const [animAnimatedValue] = React2.useState(() => new reactNative.Animated.Value(initialValue));
+  const [animAnimatedValue] = React2.useState(() => new ReactNative.Animated.Value(initialValue));
   return animAnimatedValue;
 };
 
@@ -243,6 +286,11 @@ 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}`);
@@ -265,7 +313,7 @@ function useValue$(key, params) {
   React2.useMemo(() => {
     let prevValue;
     let didQueueTask = false;
-    listen$(ctx, key, (v) => {
+    listen$(ctx, key, () => {
       const newValue = getNewValue();
       if (delay !== void 0) {
         const fn = () => {
@@ -294,11 +342,19 @@ function useValue$(key, params) {
   }, []);
   return animValue;
 }
-var typedForwardRef = React2.forwardRef;
-var typedMemo = React2.memo;
+var typedMemo = React2__namespace.memo;
+var getComponent = (Component) => {
+  if (React2__namespace.isValidElement(Component)) {
+    return Component;
+  }
+  if (Component) {
+    return /* @__PURE__ */ React2__namespace.createElement(Component, null);
+  }
+  return null;
+};
 
 // src/components/PositionView.native.tsx
-var PositionViewState = typedMemo(function PositionView({
+var PositionViewState = typedMemo(function PositionViewState2({
   id,
   horizontal,
   style,
@@ -307,7 +363,7 @@ var PositionViewState = typedMemo(function PositionView({
 }) {
   const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
   return /* @__PURE__ */ React2__namespace.createElement(
-    reactNative.View,
+    ReactNative.View,
     {
       ref: refView,
       style: [
@@ -318,7 +374,7 @@ var PositionViewState = typedMemo(function PositionView({
     }
   );
 });
-var PositionViewAnimated = typedMemo(function PositionView2({
+var PositionViewAnimated = typedMemo(function PositionViewAnimated2({
   id,
   horizontal,
   style,
@@ -329,12 +385,12 @@ var PositionViewAnimated = typedMemo(function PositionView2({
     getValue: (v) => v != null ? v : POSITION_OUT_OF_VIEW
   });
   let position;
-  if (reactNative.Platform.OS === "ios" || reactNative.Platform.OS === "android") {
+  if (ReactNative.Platform.OS === "ios" || ReactNative.Platform.OS === "android") {
     position = horizontal ? { transform: [{ translateX: position$ }] } : { transform: [{ translateY: position$ }] };
   } else {
     position = horizontal ? { left: position$ } : { top: position$ };
   }
-  return /* @__PURE__ */ React2__namespace.createElement(reactNative.Animated.View, { ref: refView, style: [style, position], ...rest });
+  return /* @__PURE__ */ React2__namespace.createElement(ReactNative.Animated.View, { ref: refView, style: [style, position], ...rest });
 });
 var PositionViewSticky = typedMemo(function PositionViewSticky2({
   id,
@@ -342,74 +398,120 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
   style,
   refView,
   animatedScrollY,
-  stickyOffset,
   index,
+  stickyHeaderConfig,
+  children,
   ...rest
 }) {
-  const [position = POSITION_OUT_OF_VIEW, headerSize] = useArr$([`containerPosition${id}`, "headerSize"]);
+  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0] = useArr$([
+    `containerPosition${id}`,
+    "headerSize",
+    "stylePaddingTop"
+  ]);
   const transform = React2__namespace.useMemo(() => {
-    if (animatedScrollY && stickyOffset !== void 0) {
+    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: [position + headerSize, position + 5e3 + headerSize],
+        inputRange: [stickyStart, stickyStart + 5e3],
         outputRange: [position, position + 5e3]
       });
       return horizontal ? [{ translateX: stickyPosition }] : [{ translateY: stickyPosition }];
     }
-  }, [animatedScrollY, headerSize, horizontal, stickyOffset, position]);
+  }, [animatedScrollY, headerSize, horizontal, position, stylePaddingTop, stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset]);
   const viewStyle = React2__namespace.useMemo(() => [style, { zIndex: index + 1e3 }, { transform }], [style, transform]);
-  return /* @__PURE__ */ React2__namespace.createElement(reactNative.Animated.View, { ref: refView, style: viewStyle, ...rest });
+  const renderStickyHeaderBackdrop = React2__namespace.useMemo(() => {
+    if (!(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)) {
+      return null;
+    }
+    return /* @__PURE__ */ React2__namespace.createElement(
+      ReactNative.View,
+      {
+        style: {
+          inset: 0,
+          pointerEvents: "none",
+          position: "absolute"
+        }
+      },
+      getComponent(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)
+    );
+  }, [stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent]);
+  return /* @__PURE__ */ React2__namespace.createElement(ReactNative.Animated.View, { ref: refView, style: viewStyle, ...rest }, renderStickyHeaderBackdrop, children);
 });
-var PositionView3 = IsNewArchitecture ? PositionViewState : PositionViewAnimated;
+var PositionView = IsNewArchitecture ? PositionViewState : PositionViewAnimated;
 function useInit(cb) {
   React2.useState(() => cb());
 }
 
 // src/state/ContextContainer.ts
 var ContextContainer = React2.createContext(null);
+function useContextContainer() {
+  return React2.useContext(ContextContainer);
+}
 function useViewability(callback, configId) {
   const ctx = useStateContext();
-  const { containerId } = React2.useContext(ContextContainer);
-  const key = containerId + (configId != null ? configId : "");
+  const containerContext = useContextContainer();
   useInit(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    const key = containerId + (configId != null ? configId : "");
     const value = ctx.mapViewabilityValues.get(key);
     if (value) {
       callback(value);
     }
   });
-  ctx.mapViewabilityCallbacks.set(key, callback);
-  React2.useEffect(
-    () => () => {
+  React2.useEffect(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    const key = containerId + (configId != null ? configId : "");
+    ctx.mapViewabilityCallbacks.set(key, callback);
+    return () => {
       ctx.mapViewabilityCallbacks.delete(key);
-    },
-    []
-  );
+    };
+  }, [ctx, callback, configId, containerContext]);
 }
 function useViewabilityAmount(callback) {
   const ctx = useStateContext();
-  const { containerId } = React2.useContext(ContextContainer);
+  const containerContext = useContextContainer();
   useInit(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
     const value = ctx.mapViewabilityAmountValues.get(containerId);
     if (value) {
       callback(value);
     }
   });
-  ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
-  React2.useEffect(
-    () => () => {
+  React2.useEffect(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
+    return () => {
       ctx.mapViewabilityAmountCallbacks.delete(containerId);
-    },
-    []
-  );
+    };
+  }, [ctx, callback, containerContext]);
 }
 function useRecyclingEffect(effect) {
-  const { index, value } = React2.useContext(ContextContainer);
+  const containerContext = useContextContainer();
   const prevValues = React2.useRef({
     prevIndex: void 0,
     prevItem: void 0
   });
   React2.useEffect(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { index, value } = containerContext;
     let ret;
     if (prevValues.current.prevIndex !== void 0 && prevValues.current.prevItem !== void 0) {
       ret = effect({
@@ -424,38 +526,58 @@ function useRecyclingEffect(effect) {
       prevItem: value
     };
     return ret;
-  }, [index, value, effect]);
+  }, [effect, containerContext]);
 }
 function useRecyclingState(valueOrFun) {
-  const { index, value, itemKey, triggerLayout } = React2.useContext(ContextContainer);
-  const refState = React2.useRef({
-    itemKey: null,
-    value: null
+  var _a3, _b;
+  const containerContext = useContextContainer();
+  const computeValue = (ctx) => {
+    if (isFunction(valueOrFun)) {
+      const initializer = valueOrFun;
+      return ctx ? initializer({
+        index: ctx.index,
+        item: ctx.value,
+        prevIndex: void 0,
+        prevItem: void 0
+      }) : initializer();
+    }
+    return valueOrFun;
+  };
+  const [stateValue, setStateValue] = React2.useState(() => {
+    return computeValue(containerContext);
   });
-  const [_, setRenderNum] = React2.useState(0);
-  const state = refState.current;
-  if (state.itemKey !== itemKey) {
-    state.itemKey = itemKey;
-    state.value = isFunction(valueOrFun) ? valueOrFun({
-      index,
-      item: value,
-      prevIndex: void 0,
-      prevItem: void 0
-    }) : valueOrFun;
+  const prevItemKeyRef = React2.useRef((_a3 = containerContext == null ? void 0 : containerContext.itemKey) != null ? _a3 : null);
+  const currentItemKey = (_b = containerContext == null ? void 0 : containerContext.itemKey) != null ? _b : null;
+  if (currentItemKey !== null && prevItemKeyRef.current !== currentItemKey) {
+    prevItemKeyRef.current = currentItemKey;
+    setStateValue(computeValue(containerContext));
   }
+  const triggerLayout = containerContext == null ? void 0 : containerContext.triggerLayout;
   const setState = React2.useCallback(
     (newState) => {
-      state.value = isFunction(newState) ? newState(state.value) : newState;
-      setRenderNum((v) => v + 1);
+      if (!triggerLayout) {
+        return;
+      }
+      setStateValue((prevValue) => {
+        return isFunction(newState) ? newState(prevValue) : newState;
+      });
       triggerLayout();
     },
-    [triggerLayout, state]
+    [triggerLayout]
   );
-  return [state.value, setState];
+  return [stateValue, setState];
 }
 function useIsLastItem() {
-  const { itemKey } = React2.useContext(ContextContainer);
-  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false);
+  const containerContext = useContextContainer();
+  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => {
+    if (containerContext) {
+      const { itemKey } = containerContext;
+      if (!isNullOrUndefined(itemKey)) {
+        return (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false;
+      }
+    }
+    return false;
+  });
   return isLast;
 }
 function useListScrollSize() {
@@ -465,8 +587,9 @@ function useListScrollSize() {
 var noop = () => {
 };
 function useSyncLayout() {
-  if (IsNewArchitecture) {
-    const { triggerLayout: syncLayout } = React2.useContext(ContextContainer);
+  const containerContext = useContextContainer();
+  if (IsNewArchitecture && containerContext) {
+    const { triggerLayout: syncLayout } = containerContext;
     return syncLayout;
   } else {
     return noop;
@@ -509,30 +632,44 @@ function useOnLayoutSync({
   }
   return { onLayout };
 }
+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) {
+  return state.dataChangeNeedsScrollUpdate;
+}
 
 // src/components/Container.tsx
-var Container = typedMemo(function Container2({
+var Container = typedMemo2(function Container2({
   id,
   recycleItems,
   horizontal,
   getRenderedItem: getRenderedItem2,
   updateItemSize: updateItemSize2,
-  ItemSeparatorComponent
+  ItemSeparatorComponent,
+  stickyHeaderConfig
 }) {
   const ctx = useStateContext();
   const { columnWrapperStyle, animatedScrollY } = ctx;
-  const [column = 0, data, itemKey, numColumns, extraData, isSticky, stickyOffset] = useArr$([
+  const positionComponentInternal = ctx.state.props.positionComponentInternal;
+  const stickyPositionComponentInternal = ctx.state.props.stickyPositionComponentInternal;
+  const [column = 0, span = 1, data, itemKey, numColumns = 1, extraData, isSticky] = useArr$([
     `containerColumn${id}`,
+    `containerSpan${id}`,
     `containerItemData${id}`,
     `containerItemKey${id}`,
     "numColumns",
     "extraData",
-    `containerSticky${id}`,
-    `containerStickyOffset${id}`
+    `containerSticky${id}`
   ]);
   const itemLayoutRef = React2.useRef({
+    didLayout: false,
     horizontal,
     itemKey,
+    pendingShrinkToken: 0,
     updateItemSize: updateItemSize2
   });
   itemLayoutRef.current.horizontal = horizontal;
@@ -540,9 +677,10 @@ var Container = typedMemo(function Container2({
   itemLayoutRef.current.updateItemSize = updateItemSize2;
   const ref = React2.useRef(null);
   const [layoutRenderCount, forceLayoutRender] = React2.useState(0);
-  const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
-  const otherAxisSize = numColumns > 1 ? `${1 / numColumns * 100}%` : void 0;
-  const didLayoutRef = React2.useRef(false);
+  const resolvedColumn = column > 0 ? column : 1;
+  const resolvedSpan = Math.min(Math.max(span || 1, 1), numColumns);
+  const otherAxisPos = numColumns > 1 ? `${(resolvedColumn - 1) / numColumns * 100}%` : 0;
+  const otherAxisSize = numColumns > 1 ? `${resolvedSpan / numColumns * 100}%` : void 0;
   const style = React2.useMemo(() => {
     let paddingStyles;
     if (columnWrapperStyle) {
@@ -597,19 +735,41 @@ var Container = typedMemo(function Container2({
     const {
       horizontal: currentHorizontal,
       itemKey: currentItemKey,
-      updateItemSize: updateItemSizeFn
+      updateItemSize: updateItemSizeFn,
+      lastSize,
+      pendingShrinkToken
     } = itemLayoutRef.current;
     if (isNullOrUndefined(currentItemKey)) {
       return;
     }
-    didLayoutRef.current = true;
+    itemLayoutRef.current.didLayout = true;
     let layout = rectangle;
-    const size = roundSize(rectangle[currentHorizontal ? "width" : "height"]);
+    const axis = currentHorizontal ? "width" : "height";
+    const size = roundSize(rectangle[axis]);
+    const prevSize = lastSize ? roundSize(lastSize[axis]) : void 0;
     const doUpdate = () => {
-      itemLayoutRef.current.lastSize = { height: layout.height, width: layout.width };
+      itemLayoutRef.current.lastSize = layout;
       updateItemSizeFn(currentItemKey, layout);
-      didLayoutRef.current = true;
+      itemLayoutRef.current.didLayout = true;
     };
+    const shouldDeferWebShrinkLayoutUpdate = Platform2.OS === "web" && !isInMVCPActiveMode(ctx.state) && prevSize !== void 0 && size + 1 < prevSize;
+    if (shouldDeferWebShrinkLayoutUpdate) {
+      const token = pendingShrinkToken + 1;
+      itemLayoutRef.current.pendingShrinkToken = token;
+      requestAnimationFrame(() => {
+        var _a4;
+        if (itemLayoutRef.current.pendingShrinkToken !== token) {
+          return;
+        }
+        const element = ref.current;
+        const rect = (_a4 = element == null ? void 0 : element.getBoundingClientRect) == null ? void 0 : _a4.call(element);
+        if (rect) {
+          layout = { height: rect.height, width: rect.width };
+        }
+        doUpdate();
+      });
+      return;
+    }
     if (IsNewArchitecture || size > 0) {
       doUpdate();
     } else {
@@ -622,16 +782,15 @@ var Container = typedMemo(function Container2({
   const { onLayout } = useOnLayoutSync(
     {
       onLayoutChange,
-      ref
-    },
+      ref},
     [itemKey, layoutRenderCount]
   );
   if (!IsNewArchitecture) {
     React2.useEffect(() => {
       if (!isNullOrUndefined(itemKey)) {
-        didLayoutRef.current = false;
+        itemLayoutRef.current.didLayout = false;
         const timeout = setTimeout(() => {
-          if (!didLayoutRef.current) {
+          if (!itemLayoutRef.current.didLayout) {
             const {
               itemKey: currentItemKey,
               lastSize,
@@ -639,7 +798,7 @@ var Container = typedMemo(function Container2({
             } = itemLayoutRef.current;
             if (lastSize && !isNullOrUndefined(currentItemKey)) {
               updateItemSizeFn(currentItemKey, lastSize);
-              didLayoutRef.current = true;
+              itemLayoutRef.current.didLayout = true;
             }
           }
         }, 16);
@@ -649,7 +808,7 @@ var Container = typedMemo(function Container2({
       }
     }, [itemKey]);
   }
-  const PositionComponent = isSticky ? PositionViewSticky : PositionView3;
+  const PositionComponent = isSticky ? stickyPositionComponentInternal ? stickyPositionComponentInternal : PositionViewSticky : positionComponentInternal ? positionComponentInternal : PositionView;
   return /* @__PURE__ */ React2__namespace.createElement(
     PositionComponent,
     {
@@ -660,7 +819,7 @@ var Container = typedMemo(function Container2({
       key: recycleItems ? void 0 : itemKey,
       onLayout,
       refView: ref,
-      stickyOffset: isSticky ? stickyOffset : void 0,
+      stickyHeaderConfig,
       style
     },
     /* @__PURE__ */ React2__namespace.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React2__namespace.createElement(Separator, { ItemSeparatorComponent, leadingItem: renderedItemInfo.item }))
@@ -673,6 +832,7 @@ var Containers = typedMemo(function Containers2({
   recycleItems,
   ItemSeparatorComponent,
   waitForInitialLayout,
+  stickyHeaderConfig,
   updateItemSize: updateItemSize2,
   getRenderedItem: getRenderedItem2
 }) {
@@ -684,10 +844,10 @@ var Containers = typedMemo(function Containers2({
     // 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.internalState) == null ? void 0 : _a3.initialScroll) ? !prevValue || value - prevValue > 20 ? 0 : 200 : void 0;
+      return !((_a3 = ctx.state) == null ? void 0 : _a3.initialScroll) ? !prevValue || value - prevValue > 20 ? 0 : 200 : void 0;
     }
   });
-  const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("containersDidLayout", { getValue: (value) => value ? 1 : 0 }) : void 0;
+  const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("readyToRender", { getValue: (value) => value ? 1 : 0 }) : void 0;
   const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
@@ -701,25 +861,26 @@ var Containers = typedMemo(function Containers2({
           id: i,
           key: i,
           recycleItems,
+          stickyHeaderConfig,
           updateItemSize: updateItemSize2
         }
       )
     );
   }
   const style = horizontal ? { minHeight: otherAxisSize, opacity: animOpacity, width: animSize } : { height: animSize, minWidth: otherAxisSize, opacity: animOpacity };
-  if (columnWrapperStyle && numColumns > 1) {
+  if (columnWrapperStyle) {
     const { columnGap, rowGap, gap } = columnWrapperStyle;
     const gapX = columnGap || gap || 0;
     const gapY = rowGap || gap || 0;
     if (horizontal) {
-      if (gapY) {
+      if (gapY && numColumns > 1) {
         style.marginVertical = -gapY / 2;
       }
       if (gapX) {
         style.marginRight = -gapX;
       }
     } else {
-      if (gapX) {
+      if (gapX && numColumns > 1) {
         style.marginHorizontal = -gapX;
       }
       if (gapY) {
@@ -727,53 +888,15 @@ var Containers = typedMemo(function Containers2({
       }
     }
   }
-  return /* @__PURE__ */ React2__namespace.createElement(reactNative.Animated.View, { style }, containers);
+  return /* @__PURE__ */ React2__namespace.createElement(ReactNative.Animated.View, { style }, containers);
 });
-function DevNumbers() {
-  return IS_DEV && React2__namespace.memo(function DevNumbers2() {
-    return Array.from({ length: 100 }).map((_, index) => /* @__PURE__ */ React2__namespace.createElement(
-      reactNative.View,
-      {
-        key: index,
-        style: {
-          height: 100,
-          pointerEvents: "none",
-          position: "absolute",
-          top: index * 100,
-          width: "100%"
-        }
-      },
-      /* @__PURE__ */ React2__namespace.createElement(reactNative.Text, { style: { color: "red" } }, index * 100)
-    ));
-  });
-}
-var ListComponentScrollView = reactNative.Animated.ScrollView;
-function Padding() {
-  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React2__namespace.createElement(reactNative.Animated.View, { style: { paddingTop: animPaddingTop } });
-}
-function PaddingDevMode() {
-  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React2__namespace.createElement(React2__namespace.Fragment, null, /* @__PURE__ */ React2__namespace.createElement(reactNative.Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React2__namespace.createElement(
-    reactNative.Animated.View,
-    {
-      style: {
-        backgroundColor: "green",
-        height: animPaddingTop,
-        left: 0,
-        position: "absolute",
-        right: 0,
-        top: 0
-      }
-    }
-  ));
-}
+var ListComponentScrollView = ReactNative.Animated.ScrollView;
 function ScrollAdjust() {
   const bias = 1e7;
   const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
   const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
   return /* @__PURE__ */ React2__namespace.createElement(
-    reactNative.View,
+    ReactNative.View,
     {
       style: {
         height: 0,
@@ -790,22 +913,13 @@ function SnapWrapper({ ScrollComponent, ...props }) {
   return /* @__PURE__ */ React2__namespace.createElement(ScrollComponent, { ...props, snapToOffsets });
 }
 var LayoutView = ({ onLayoutChange, refView, ...rest }) => {
-  const ref = refView != null ? refView : React2.useRef();
+  const ref = refView != null ? refView : React2.useRef(null);
   const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
-  return /* @__PURE__ */ React2__namespace.createElement(reactNative.View, { ...rest, onLayout, ref });
+  return /* @__PURE__ */ React2__namespace.createElement(ReactNative.View, { ...rest, onLayout, ref });
 };
 
 // src/components/ListComponent.tsx
-var getComponent = (Component) => {
-  if (React2__namespace.isValidElement(Component)) {
-    return Component;
-  }
-  if (Component) {
-    return /* @__PURE__ */ React2__namespace.createElement(Component, null);
-  }
-  return null;
-};
-var ListComponent = typedMemo(function ListComponent2({
+var ListComponent = typedMemo2(function ListComponent2({
   canRender,
   style,
   contentContainerStyle,
@@ -813,7 +927,7 @@ var ListComponent = typedMemo(function ListComponent2({
   initialContentOffset,
   recycleItems,
   ItemSeparatorComponent,
-  alignItemsAtEnd,
+  alignItemsAtEnd: _alignItemsAtEnd,
   waitForInitialLayout,
   onScroll: onScroll2,
   onLayout,
@@ -825,31 +939,52 @@ var ListComponent = typedMemo(function ListComponent2({
   getRenderedItem: getRenderedItem2,
   updateItemSize: updateItemSize2,
   refScrollView,
-  maintainVisibleContentPosition,
   renderScrollComponent,
+  onLayoutFooter,
   scrollAdjustHandler,
-  onLayoutHeader,
   snapToIndices,
+  stickyHeaderConfig,
   stickyHeaderIndices,
+  useWindowScroll = false,
   ...rest
 }) {
   const ctx = useStateContext();
+  const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
   const ScrollComponent = renderScrollComponent ? React2.useMemo(
-    () => React2__namespace.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
+    () => React2__namespace.forwardRef(
+      (props, ref) => renderScrollComponent({ ...props, ref })
+    ),
     [renderScrollComponent]
   ) : ListComponentScrollView;
-  React2__namespace.useEffect(() => {
-    if (canRender) {
-      setTimeout(() => {
-        scrollAdjustHandler.setMounted();
-      }, 0);
-    }
-  }, [canRender]);
   const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
+  React2.useLayoutEffect(() => {
+    if (!ListHeaderComponent) {
+      set$(ctx, "headerSize", 0);
+    }
+    if (!ListFooterComponent) {
+      set$(ctx, "footerSize", 0);
+    }
+  }, [ListHeaderComponent, ListFooterComponent, ctx]);
+  const onLayoutHeader = React2.useCallback(
+    (rect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      set$(ctx, "headerSize", size);
+    },
+    [ctx, horizontal]
+  );
+  const onLayoutFooterInternal = React2.useCallback(
+    (rect, fromLayoutEffect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      set$(ctx, "footerSize", size);
+      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
+    },
+    [ctx, horizontal, onLayoutFooter]
+  );
   return /* @__PURE__ */ React2__namespace.createElement(
     SnapOrScroll,
     {
       ...rest,
+      ...ScrollComponent === ListComponentScrollView ? { useWindowScroll } : {},
       contentContainerStyle: [
         contentContainerStyle,
         horizontal ? {
@@ -858,7 +993,7 @@ var ListComponent = typedMemo(function ListComponent2({
       ],
       contentOffset: initialContentOffset ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
       horizontal,
-      maintainVisibleContentPosition: maintainVisibleContentPosition ? { minIndexForVisible: 0 } : void 0,
+      maintainVisibleContentPosition: maintainVisibleContentPosition.size || maintainVisibleContentPosition.data ? { minIndexForVisible: 0 } : void 0,
       onLayout,
       onScroll: onScroll2,
       ref: refScrollView,
@@ -866,7 +1001,6 @@ var ListComponent = typedMemo(function ListComponent2({
       style
     },
     /* @__PURE__ */ React2__namespace.createElement(ScrollAdjust, null),
-    ENABLE_DEVMODE ? /* @__PURE__ */ React2__namespace.createElement(PaddingDevMode, null) : /* @__PURE__ */ React2__namespace.createElement(Padding, null),
     ListHeaderComponent && /* @__PURE__ */ React2__namespace.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
     ListEmptyComponent && getComponent(ListEmptyComponent),
     canRender && !ListEmptyComponent && /* @__PURE__ */ React2__namespace.createElement(
@@ -876,25 +1010,27 @@ var ListComponent = typedMemo(function ListComponent2({
         horizontal,
         ItemSeparatorComponent,
         recycleItems,
+        stickyHeaderConfig,
         updateItemSize: updateItemSize2,
         waitForInitialLayout
       }
     ),
-    ListFooterComponent && /* @__PURE__ */ React2__namespace.createElement(
-      LayoutView,
-      {
-        onLayoutChange: (layout) => {
-          const size = layout[horizontal ? "width" : "height"];
-          set$(ctx, "footerSize", size);
-        },
-        style: ListFooterComponentStyle
-      },
-      getComponent(ListFooterComponent)
-    ),
-    IS_DEV && ENABLE_DEVMODE && /* @__PURE__ */ React2__namespace.createElement(DevNumbers, null)
+    ListFooterComponent && /* @__PURE__ */ React2__namespace.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
+    IS_DEV && ENABLE_DEVMODE
   );
 });
 
+// src/core/calculateOffsetForIndex.ts
+function calculateOffsetForIndex(ctx, index) {
+  const state = ctx.state;
+  return index !== void 0 ? state.positions[index] || 0 : 0;
+}
+
+// src/core/getTopOffsetAdjustment.ts
+function getTopOffsetAdjustment(ctx) {
+  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
+}
+
 // src/utils/getId.ts
 function getId(state, index) {
   const { data, keyExtractor } = state.props;
@@ -907,61 +1043,9 @@ function getId(state, index) {
   return id;
 }
 
-// src/core/calculateOffsetForIndex.ts
-function calculateOffsetForIndex(ctx, state, index) {
-  let position = 0;
-  if (index !== void 0) {
-    position = (state == null ? void 0 : state.positions.get(getId(state, index))) || 0;
-    const paddingTop = peek$(ctx, "stylePaddingTop");
-    if (paddingTop) {
-      position += paddingTop;
-    }
-    const headerSize = peek$(ctx, "headerSize");
-    if (headerSize) {
-      position += headerSize;
-    }
-  }
-  return position;
-}
-
-// src/utils/setPaddingTop.ts
-function setPaddingTop(ctx, state, { stylePaddingTop, alignItemsPaddingTop }) {
-  if (stylePaddingTop !== void 0) {
-    const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
-    if (stylePaddingTop < prevStylePaddingTop) {
-      let prevTotalSize = peek$(ctx, "totalSize") || 0;
-      set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
-      state.timeoutSetPaddingTop = setTimeout(() => {
-        prevTotalSize = peek$(ctx, "totalSize") || 0;
-        set$(ctx, "totalSize", prevTotalSize - prevStylePaddingTop);
-      }, 16);
-    }
-    set$(ctx, "stylePaddingTop", stylePaddingTop);
-  }
-  if (alignItemsPaddingTop !== void 0) {
-    set$(ctx, "alignItemsPaddingTop", alignItemsPaddingTop);
-  }
-}
-
-// src/utils/updateAlignItemsPaddingTop.ts
-function updateAlignItemsPaddingTop(ctx, state) {
-  const {
-    scrollLength,
-    props: { alignItemsAtEnd, data }
-  } = state;
-  if (alignItemsAtEnd) {
-    let alignItemsPaddingTop = 0;
-    if ((data == null ? void 0 : data.length) > 0) {
-      const contentSize = getContentSize(ctx);
-      alignItemsPaddingTop = Math.max(0, Math.floor(scrollLength - contentSize));
-    }
-    setPaddingTop(ctx, state, { alignItemsPaddingTop });
-  }
-}
-
 // src/core/addTotalSize.ts
-function addTotalSize(ctx, state, key, add) {
-  const { alignItemsAtEnd } = state.props;
+function addTotalSize(ctx, key, add) {
+  const state = ctx.state;
   const prevTotalSize = state.totalSize;
   let totalSize = state.totalSize;
   if (key === null) {
@@ -980,48 +1064,47 @@ function addTotalSize(ctx, state, key, add) {
       state.pendingTotalSize = void 0;
       state.totalSize = totalSize;
       set$(ctx, "totalSize", totalSize);
-      if (alignItemsAtEnd) {
-        updateAlignItemsPaddingTop(ctx, state);
-      }
     }
   }
 }
 
 // src/core/setSize.ts
-function setSize(ctx, state, itemKey, size) {
+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, state, itemKey, diff);
+    addTotalSize(ctx, itemKey, diff);
   }
   sizes.set(itemKey, size);
 }
 
 // src/utils/getItemSize.ts
-function getItemSize(ctx, state, key, index, data, useAverageSize, preferCachedSize) {
+function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize) {
   var _a3, _b;
+  const state = ctx.state;
   const {
     sizesKnown,
     sizes,
     averageSizes,
-    props: { estimatedItemSize, getEstimatedItemSize, getFixedItemSize, getItemType }
+    props: { estimatedItemSize, getEstimatedItemSize, getFixedItemSize, getItemType },
+    scrollingTo
   } = state;
   const sizeKnown = sizesKnown.get(key);
   if (sizeKnown !== void 0) {
     return sizeKnown;
   }
   let size;
-  const itemType = getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-  const scrollingTo = peek$(ctx, "scrollingTo");
   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(index, data, itemType);
+    size = getFixedItemSize(data, index, itemType);
     if (size !== void 0) {
       sizesKnown.set(key, size);
     }
@@ -1039,96 +1122,61 @@ function getItemSize(ctx, state, key, index, data, useAverageSize, preferCachedS
     }
   }
   if (size === void 0) {
-    size = getEstimatedItemSize ? getEstimatedItemSize(index, data, itemType) : estimatedItemSize;
+    size = getEstimatedItemSize ? getEstimatedItemSize(data, index, itemType) : estimatedItemSize;
   }
-  setSize(ctx, state, key, size);
+  setSize(ctx, key, size);
   return size;
 }
 
 // src/core/calculateOffsetWithOffsetPosition.ts
-function calculateOffsetWithOffsetPosition(ctx, state, offsetParam, params) {
+function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
+  const state = ctx.state;
   const { index, viewOffset, viewPosition } = params;
   let offset = offsetParam;
   if (viewOffset) {
     offset -= viewOffset;
   }
-  if (viewPosition !== void 0 && index !== void 0) {
-    offset -= viewPosition * (state.scrollLength - getItemSize(ctx, state, getId(state, index), index, state.props.data[index]));
-  }
-  return offset;
-}
-
-// src/core/finishScrollTo.ts
-function finishScrollTo(ctx, state) {
-  var _a3, _b;
-  if (state) {
-    state.scrollHistory.length = 0;
-    state.initialScroll = void 0;
-    state.initialAnchor = void 0;
-    set$(ctx, "scrollingTo", void 0);
-    if (state.pendingTotalSize !== void 0) {
-      addTotalSize(ctx, state, null, state.pendingTotalSize);
+  if (index !== void 0) {
+    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+    if (topOffsetAdjustment) {
+      offset += topOffsetAdjustment;
     }
-    if ((_a3 = state.props) == null ? void 0 : _a3.data) {
-      (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
+  }
+  if (viewPosition !== void 0 && index !== void 0) {
+    const itemSize = getItemSize(ctx, getId(state, index), index, state.props.data[index]);
+    const trailingInset = getContentInsetEnd(state);
+    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
+    if (index === state.props.data.length - 1) {
+      const footerSize = peek$(ctx, "footerSize") || 0;
+      offset += footerSize;
     }
   }
+  return offset;
 }
-var Platform2 = reactNative.Platform;
 
-// src/core/scrollTo.ts
-function scrollTo(ctx, state, params) {
-  var _a3;
-  const { noScrollingTo, ...scrollTarget } = params;
-  const { animated, isInitialScroll, offset: scrollTargetOffset, precomputedWithViewOffset } = scrollTarget;
-  const {
-    refScroller,
-    props: { horizontal }
-  } = state;
-  let offset = precomputedWithViewOffset ? scrollTargetOffset : calculateOffsetWithOffsetPosition(ctx, state, scrollTargetOffset, scrollTarget);
-  if (Number.isFinite(state.scrollLength) && Number.isFinite(state.totalSize)) {
-    const maxOffset = Math.max(0, getContentSize(ctx) - state.scrollLength);
-    offset = Math.min(offset, maxOffset);
-  }
-  state.scrollHistory.length = 0;
-  if (!noScrollingTo) {
-    set$(ctx, "scrollingTo", scrollTarget);
-  }
-  state.scrollPending = offset;
-  if (!isInitialScroll || Platform2.OS === "android") {
-    (_a3 = refScroller.current) == null ? void 0 : _a3.scrollTo({
-      animated: !!animated,
-      x: horizontal ? offset : 0,
-      y: horizontal ? 0 : offset
-    });
-  }
-  if (!animated) {
-    state.scroll = offset;
-    if (Platform2.OS === "web") {
-      const unlisten = listen$(ctx, "containersDidLayout", (value) => {
-        if (value && peek$(ctx, "scrollingTo")) {
-          finishScrollTo(ctx, state);
-          unlisten();
-        }
-      });
-    } else {
-      setTimeout(() => finishScrollTo(ctx, state), 100);
-    }
-    if (isInitialScroll) {
-      setTimeout(() => {
-        state.initialScroll = void 0;
-      }, 500);
-    }
-  }
+// 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/utils/checkThreshold.ts
 var HYSTERESIS_MULTIPLIER = 1.3;
-var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot) => {
+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 == null ? void 0 : setSnapshot({
+    setSnapshot({
       atThreshold,
       contentSize: context.contentSize,
       dataLength: context.dataLength,
@@ -1139,19 +1187,21 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
     if (!within) {
       return false;
     }
-    onReached == null ? void 0 : onReached(distance);
+    onReached(distance);
     updateSnapshot();
     return true;
   }
   const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
   if (reset) {
-    setSnapshot == null ? void 0 : setSnapshot(void 0);
+    setSnapshot(void 0);
     return false;
   }
   if (within) {
     const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
     if (changed) {
-      onReached == null ? void 0 : onReached(distance);
+      if (allowReentryOnChange) {
+        onReached(distance);
+      }
       updateSnapshot();
     }
   }
@@ -1159,9 +1209,10 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
 };
 
 // src/utils/checkAtBottom.ts
-function checkAtBottom(ctx, state) {
+function checkAtBottom(ctx) {
   var _a3;
-  if (!state) {
+  const state = ctx.state;
+  if (!state || state.initialScroll) {
     return;
   }
   const {
@@ -1171,9 +1222,13 @@ function checkAtBottom(ctx, state) {
     maintainingScrollAtEnd,
     props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
   } = state;
+  if (state.initialScroll) {
+    return;
+  }
   const contentSize = getContentSize(ctx);
   if (contentSize > 0 && queuedInitialLayout && !maintainingScrollAtEnd) {
-    const distanceFromEnd = contentSize - scroll - scrollLength;
+    const insetEnd = getContentInsetEnd(state);
+    const distanceFromEnd = contentSize - scroll - scrollLength - insetEnd;
     const isContentLess = contentSize < scrollLength;
     state.isAtEnd = isContentLess || distanceFromEnd < scrollLength * maintainScrollAtEndThreshold;
     state.isEndReached = checkThreshold(
@@ -1193,72 +1248,250 @@ function checkAtBottom(ctx, state) {
       },
       (snapshot) => {
         state.endReachedSnapshot = snapshot;
-      }
+      },
+      true
     );
   }
 }
 
 // src/utils/checkAtTop.ts
-function checkAtTop(state) {
-  var _a3;
-  if (!state) {
+function checkAtTop(ctx) {
+  const state = ctx == null ? void 0 : ctx.state;
+  if (!state || state.initialScroll || state.scrollingTo) {
     return;
   }
   const {
-    scrollLength,
+    dataChangeEpoch,
+    isStartReached,
+    props: { data, onStartReachedThreshold },
     scroll,
-    props: { onStartReachedThreshold }
+    scrollLength,
+    startReachedSnapshot,
+    startReachedSnapshotDataChangeEpoch,
+    totalSize
   } = state;
-  const distanceFromTop = scroll;
-  state.isAtStart = distanceFromTop <= 0;
+  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(
-    distanceFromTop,
+    scroll,
     false,
-    onStartReachedThreshold * scrollLength,
+    threshold,
     state.isStartReached,
-    state.startReachedSnapshot,
+    allowReentryOnDataChange ? void 0 : startReachedSnapshot,
     {
-      contentSize: state.totalSize,
-      dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length,
+      contentSize: totalSize,
+      dataLength,
       scrollPosition: scroll
     },
     (distance) => {
-      var _a4, _b;
-      return (_b = (_a4 = state.props).onStartReached) == null ? void 0 : _b.call(_a4, { distanceFromStart: 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/finishScrollTo.ts
+function finishScrollTo(ctx) {
+  var _a3, _b;
+  const state = ctx.state;
+  if (state == null ? void 0 : state.scrollingTo) {
+    const resolvePendingScroll = state.pendingScrollResolve;
+    state.pendingScrollResolve = void 0;
+    const scrollingTo = state.scrollingTo;
+    state.scrollHistory.length = 0;
+    state.initialScroll = void 0;
+    state.initialAnchor = void 0;
+    state.scrollingTo = void 0;
+    if (state.pendingTotalSize !== void 0) {
+      addTotalSize(ctx, null, state.pendingTotalSize);
+    }
+    if ((_a3 = state.props) == null ? void 0 : _a3.data) {
+      (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
     }
+    if (PlatformAdjustBreaksScroll) {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    setInitialRenderState(ctx, { didInitialScroll: true });
+    checkThresholds(ctx);
+    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+  }
+}
+
+// src/core/checkFinishedScroll.ts
+function checkFinishedScroll(ctx) {
+  ctx.state.animFrameCheckFinishedScroll = requestAnimationFrame(() => checkFinishedScrollFrame(ctx));
+}
+function checkFinishedScrollFrame(ctx) {
+  const scrollingTo = ctx.state.scrollingTo;
+  if (scrollingTo) {
+    const { state } = ctx;
+    state.animFrameCheckFinishedScroll = void 0;
+    const scroll = state.scrollPending;
+    const adjust = state.scrollAdjustHandler.getAdjust();
+    const clampedTargetOffset = clampScrollOffset(
+      ctx,
+      scrollingTo.offset - (scrollingTo.viewOffset || 0),
+      scrollingTo
+    );
+    const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
+    const diff1 = Math.abs(scroll - clampedTargetOffset);
+    const diff2 = Math.abs(diff1 - adjust);
+    const isNotOverscrolled = Math.abs(scroll - maxOffset) < 1;
+    const isAtTarget = diff1 < 1 || !scrollingTo.animated && diff2 < 1;
+    if (isNotOverscrolled && isAtTarget) {
+      finishScrollTo(ctx);
+    }
+  }
+}
+function checkFinishedScrollFallback(ctx) {
+  const state = ctx.state;
+  const scrollingTo = state.scrollingTo;
+  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) || !state.didContainersLayout;
+  state.timeoutCheckFinishedScrollFallback = setTimeout(
+    () => {
+      let numChecks = 0;
+      const checkHasScrolled = () => {
+        state.timeoutCheckFinishedScrollFallback = void 0;
+        const isStillScrollingTo = state.scrollingTo;
+        if (isStillScrollingTo) {
+          numChecks++;
+          if (state.hasScrolled || numChecks > 5) {
+            finishScrollTo(ctx);
+          } else {
+            state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, 100);
+          }
+        }
+      };
+      checkHasScrolled();
+    },
+    slowTimeout ? 500 : 100
   );
 }
 
+// src/core/doScrollTo.native.ts
+function doScrollTo(ctx, params) {
+  const state = ctx.state;
+  const { animated, horizontal, offset } = params;
+  const isAnimated = !!animated;
+  const { refScroller } = state;
+  const scroller = refScroller.current;
+  if (!scroller) {
+    return;
+  }
+  scroller.scrollTo({
+    animated: isAnimated,
+    x: horizontal ? offset : 0,
+    y: horizontal ? 0 : offset
+  });
+  if (!isAnimated) {
+    state.scroll = offset;
+    checkFinishedScrollFallback(ctx);
+  }
+}
+
+// src/core/scrollTo.ts
+function scrollTo(ctx, params) {
+  const state = ctx.state;
+  const { noScrollingTo, forceScroll, ...scrollTarget } = params;
+  const { animated, isInitialScroll, offset: scrollTargetOffset, precomputedWithViewOffset } = scrollTarget;
+  const {
+    props: { horizontal }
+  } = state;
+  if (state.animFrameCheckFinishedScroll) {
+    cancelAnimationFrame(ctx.state.animFrameCheckFinishedScroll);
+  }
+  if (state.timeoutCheckFinishedScrollFallback) {
+    clearTimeout(ctx.state.timeoutCheckFinishedScrollFallback);
+  }
+  let offset = precomputedWithViewOffset ? scrollTargetOffset : calculateOffsetWithOffsetPosition(ctx, scrollTargetOffset, scrollTarget);
+  offset = clampScrollOffset(ctx, offset, scrollTarget);
+  state.scrollHistory.length = 0;
+  if (!noScrollingTo) {
+    state.scrollingTo = scrollTarget;
+  }
+  state.scrollPending = offset;
+  if (forceScroll || !isInitialScroll || Platform2.OS === "android") {
+    doScrollTo(ctx, { animated, horizontal, offset });
+  } else {
+    state.scroll = offset;
+  }
+}
+
+// src/platform/flushSync.native.ts
+var flushSync = (fn) => {
+  fn();
+};
+
 // src/core/updateScroll.ts
-function updateScroll(ctx, state, newScroll, forceUpdate) {
-  var _a3;
-  const scrollingTo = peek$(ctx, "scrollingTo");
+function updateScroll(ctx, newScroll, forceUpdate) {
+  const state = ctx.state;
+  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
+  const prevScroll = state.scroll;
   state.hasScrolled = true;
   state.lastBatchingAction = Date.now();
   const currentTime = Date.now();
-  const adjust = state.scrollAdjustHandler.getAdjust();
-  const lastHistoryAdjust = state.lastScrollAdjustForHistory;
-  const adjustChanged = lastHistoryAdjust !== void 0 && Math.abs(adjust - lastHistoryAdjust) > 0.1;
+  const adjust = scrollAdjustHandler.getAdjust();
+  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
   if (adjustChanged) {
-    state.scrollHistory.length = 0;
+    scrollHistory.length = 0;
   }
   state.lastScrollAdjustForHistory = adjust;
-  if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
+  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
     if (!adjustChanged) {
-      state.scrollHistory.push({ scroll: newScroll, time: currentTime });
+      scrollHistory.push({ scroll: newScroll, time: currentTime });
     }
   }
-  if (state.scrollHistory.length > 5) {
-    state.scrollHistory.shift();
+  if (scrollHistory.length > 5) {
+    scrollHistory.shift();
   }
-  state.scrollPrev = state.scroll;
-  state.scrollPrevTime = state.scrollTime;
-  state.scroll = newScroll;
-  state.scrollTime = currentTime;
-  const ignoreScrollFromMVCP = state.ignoreScrollFromMVCP;
   if (ignoreScrollFromMVCP && !scrollingTo) {
     const { lt, gt } = ignoreScrollFromMVCP;
     if (lt && newScroll < lt || gt && newScroll > gt) {
@@ -1266,22 +1499,42 @@ function updateScroll(ctx, state, newScroll, forceUpdate) {
       return;
     }
   }
-  if (forceUpdate || state.dataChangeNeedsScrollUpdate || Math.abs(state.scroll - state.scrollPrev) > 2) {
+  state.scrollPrev = prevScroll;
+  state.scrollPrevTime = state.scrollTime;
+  state.scroll = newScroll;
+  state.scrollTime = currentTime;
+  const scrollDelta = Math.abs(newScroll - prevScroll);
+  const scrollLength = state.scrollLength;
+  const lastCalculated = state.scrollLastCalculate;
+  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
+  const shouldUpdate = useAggressiveItemRecalculation || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
+  if (shouldUpdate) {
+    state.scrollLastCalculate = state.scroll;
     state.ignoreScrollFromMVCPIgnored = false;
-    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { doMVCP: scrollingTo !== void 0 });
-    checkAtBottom(ctx, state);
-    checkAtTop(state);
+    state.lastScrollDelta = scrollDelta;
+    const runCalculateItems = () => {
+      var _a3;
+      (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { doMVCP: scrollingTo !== void 0 });
+      checkThresholds(ctx);
+    };
+    if (Platform2.OS === "web" && scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength) {
+      flushSync(runCalculateItems);
+    } else {
+      runCalculateItems();
+    }
     state.dataChangeNeedsScrollUpdate = false;
+    state.lastScrollDelta = 0;
   }
 }
 
 // src/utils/requestAdjust.ts
-function requestAdjust(ctx, state, positionDiff, dataChanged) {
+function requestAdjust(ctx, positionDiff, dataChanged) {
+  const state = ctx.state;
   if (Math.abs(positionDiff) > 0.1) {
     const needsScrollWorkaround = Platform2.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
     const doit = () => {
       if (needsScrollWorkaround) {
-        scrollTo(ctx, state, {
+        scrollTo(ctx, {
           noScrollingTo: true,
           offset: state.scroll
         });
@@ -1294,8 +1547,8 @@ function requestAdjust(ctx, state, positionDiff, dataChanged) {
     };
     state.scroll += positionDiff;
     state.scrollForNextCalculateItemsInView = void 0;
-    const didLayout = peek$(ctx, "containersDidLayout");
-    if (didLayout) {
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
       doit();
       if (Platform2.OS !== "web") {
         const threshold = state.scroll - positionDiff / 2;
@@ -1317,7 +1570,7 @@ function requestAdjust(ctx, state, positionDiff, dataChanged) {
           if (shouldForceUpdate) {
             state.ignoreScrollFromMVCPIgnored = false;
             state.scrollPending = state.scroll;
-            updateScroll(ctx, state, state.scroll, true);
+            updateScroll(ctx, state.scroll, true);
           }
         }, delay);
       }
@@ -1332,28 +1585,28 @@ function requestAdjust(ctx, state, positionDiff, dataChanged) {
 var INITIAL_ANCHOR_TOLERANCE = 0.5;
 var INITIAL_ANCHOR_MAX_ATTEMPTS = 4;
 var INITIAL_ANCHOR_SETTLED_TICKS = 2;
-function ensureInitialAnchor(ctx, state) {
+function ensureInitialAnchor(ctx) {
   var _a3, _b, _c, _d, _e;
-  const anchor = state.initialAnchor;
+  const state = ctx.state;
+  const { initialAnchor, didContainersLayout, scroll, scrollLength } = state;
+  const anchor = initialAnchor;
   const item = state.props.data[anchor.index];
-  const containersDidLayout = peek$(ctx, "containersDidLayout");
-  if (!containersDidLayout) {
+  if (!didContainersLayout) {
     return;
   }
   const id = getId(state, anchor.index);
-  if (state.positions.get(id) === void 0) {
+  if (state.positions[anchor.index] === void 0) {
     return;
   }
-  const size = getItemSize(ctx, state, id, anchor.index, item, true, true);
+  const size = getItemSize(ctx, id, anchor.index, item, true, true);
   if (size === void 0) {
     return;
   }
-  const availableSpace = Math.max(0, state.scrollLength - size);
-  const desiredOffset = calculateOffsetForIndex(ctx, state, anchor.index) - ((_a3 = anchor.viewOffset) != null ? _a3 : 0) - ((_b = anchor.viewPosition) != null ? _b : 0) * availableSpace;
-  const contentSize = getContentSize(ctx);
-  const maxOffset = Math.max(0, contentSize - state.scrollLength);
-  const clampedDesiredOffset = Math.max(0, Math.min(desiredOffset, maxOffset));
-  const delta = clampedDesiredOffset - state.scroll;
+  const availableSpace = Math.max(0, scrollLength - size);
+  const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+  const desiredOffset = calculateOffsetForIndex(ctx, anchor.index) + topOffsetAdjustment - ((_a3 = anchor.viewOffset) != null ? _a3 : 0) - ((_b = anchor.viewPosition) != null ? _b : 0) * availableSpace;
+  const clampedDesiredOffset = clampScrollOffset(ctx, desiredOffset, anchor);
+  const delta = clampedDesiredOffset - scroll;
   if (Math.abs(delta) <= INITIAL_ANCHOR_TOLERANCE) {
     const settledTicks = ((_c = anchor.settledTicks) != null ? _c : 0) + 1;
     if (settledTicks >= INITIAL_ANCHOR_SETTLED_TICKS) {
@@ -1377,60 +1630,151 @@ function ensureInitialAnchor(ctx, state) {
     lastDelta: delta,
     settledTicks: 0
   });
-  requestAdjust(ctx, state, delta);
+  requestAdjust(ctx, delta);
 }
 
 // src/core/mvcp.ts
-function prepareMVCP(ctx, state, dataChanged) {
+var MVCP_POSITION_EPSILON = 0.1;
+var MVCP_ANCHOR_LOCK_TTL_MS = 300;
+var MVCP_ANCHOR_LOCK_QUIET_PASSES_TO_RELEASE = 2;
+function resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) {
+  if (!enableMVCPAnchorLock) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
+  }
+  const lock = state.mvcpAnchorLock;
+  if (!lock) {
+    return void 0;
+  }
+  const isExpired = now > lock.expiresAt;
+  const isMissing = state.indexByKey.get(lock.id) === void 0;
+  if (isExpired || isMissing || !mvcpData) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
+  }
+  return lock;
+}
+function updateAnchorLock(state, params) {
+  if (Platform2.OS === "web") {
+    const { anchorId, anchorPosition, dataChanged, now, positionDiff } = params;
+    const enableMVCPAnchorLock = !!dataChanged || !!state.mvcpAnchorLock;
+    const mvcpData = state.props.maintainVisibleContentPosition.data;
+    if (!enableMVCPAnchorLock || !mvcpData || state.scrollingTo || !anchorId || anchorPosition === void 0) {
+      return;
+    }
+    const existingLock = state.mvcpAnchorLock;
+    const quietPasses = !dataChanged && Math.abs(positionDiff) <= MVCP_POSITION_EPSILON && (existingLock == null ? void 0 : existingLock.id) === anchorId ? existingLock.quietPasses + 1 : 0;
+    if (!dataChanged && quietPasses >= MVCP_ANCHOR_LOCK_QUIET_PASSES_TO_RELEASE) {
+      state.mvcpAnchorLock = void 0;
+      return;
+    }
+    state.mvcpAnchorLock = {
+      expiresAt: now + MVCP_ANCHOR_LOCK_TTL_MS,
+      id: anchorId,
+      position: anchorPosition,
+      quietPasses
+    };
+  }
+}
+function prepareMVCP(ctx, dataChanged) {
+  const state = ctx.state;
   const { idsInView, positions, props } = state;
-  const { maintainVisibleContentPosition } = props;
-  const scrollingTo = peek$(ctx, "scrollingTo");
+  const {
+    maintainVisibleContentPosition: { data: mvcpData, size: mvcpScroll, shouldRestorePosition }
+  } = props;
+  const isWeb = Platform2.OS === "web";
+  const now = Date.now();
+  const enableMVCPAnchorLock = isWeb && (!!dataChanged || !!state.mvcpAnchorLock);
+  const scrollingTo = state.scrollingTo;
+  const anchorLock = isWeb ? resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) : void 0;
   let prevPosition;
   let targetId;
   const idsInViewWithPositions = [];
   const scrollTarget = scrollingTo == null ? void 0 : scrollingTo.index;
-  const shouldMVCP = !dataChanged || maintainVisibleContentPosition;
+  const scrollingToViewPosition = scrollingTo == null ? void 0 : scrollingTo.viewPosition;
+  const isEndAnchoredScrollTarget = scrollTarget !== void 0 && state.props.data.length > 0 && scrollTarget >= state.props.data.length - 1 && (scrollingToViewPosition != null ? scrollingToViewPosition : 0) > 0;
+  const shouldMVCP = dataChanged ? mvcpData : mvcpScroll;
   const indexByKey = state.indexByKey;
   if (shouldMVCP) {
-    if (scrollTarget !== void 0) {
+    if (anchorLock && scrollTarget === void 0) {
+      targetId = anchorLock.id;
+      prevPosition = anchorLock.position;
+    } else if (scrollTarget !== void 0) {
       if (!IsNewArchitecture && (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll)) {
         return void 0;
       }
       targetId = getId(state, scrollTarget);
-    } else if (idsInView.length > 0 && peek$(ctx, "containersDidLayout")) {
-      if (dataChanged) {
-        for (let i = 0; i < idsInView.length; i++) {
-          const id = idsInView[i];
-          const index = indexByKey.get(id);
-          if (index !== void 0) {
-            idsInViewWithPositions.push({ id, position: positions.get(id) });
+    } else if (idsInView.length > 0 && state.didContainersLayout && !dataChanged) {
+      targetId = idsInView.find((id) => indexByKey.get(id) !== void 0);
+    }
+    if (dataChanged && idsInView.length > 0 && state.didContainersLayout) {
+      for (let i = 0; i < idsInView.length; i++) {
+        const id = idsInView[i];
+        const index = indexByKey.get(id);
+        if (index !== void 0) {
+          const position = positions[index];
+          if (position !== void 0) {
+            idsInViewWithPositions.push({ id, position });
           }
         }
-      } else {
-        targetId = idsInView.find((id) => indexByKey.get(id) !== void 0);
       }
     }
-    if (targetId !== void 0) {
-      prevPosition = positions.get(targetId);
+    if (targetId !== void 0 && prevPosition === void 0) {
+      const targetIndex = indexByKey.get(targetId);
+      if (targetIndex !== void 0) {
+        prevPosition = positions[targetIndex];
+      }
     }
     return () => {
-      let positionDiff;
-      if (dataChanged && targetId === void 0 && maintainVisibleContentPosition) {
+      let positionDiff = 0;
+      let anchorIdForLock = anchorLock == null ? void 0 : anchorLock.id;
+      let anchorPositionForLock;
+      let skipTargetAnchor = false;
+      const data = state.props.data;
+      const shouldValidateLockedAnchor = isWeb && dataChanged && mvcpData && scrollTarget === void 0 && targetId !== void 0 && (anchorLock == null ? void 0 : anchorLock.id) === targetId && shouldRestorePosition !== void 0;
+      if (shouldValidateLockedAnchor && targetId !== void 0) {
+        const index = indexByKey.get(targetId);
+        if (index !== void 0) {
+          const item = data[index];
+          skipTargetAnchor = item === void 0 || !shouldRestorePosition(item, index, data);
+          if (skipTargetAnchor && (anchorLock == null ? void 0 : anchorLock.id) === targetId) {
+            state.mvcpAnchorLock = void 0;
+          }
+        }
+      }
+      const shouldUseFallbackVisibleAnchor = dataChanged && mvcpData && scrollTarget === void 0 && (() => {
+        if (targetId === void 0 || skipTargetAnchor) {
+          return true;
+        }
+        const targetIndex = indexByKey.get(targetId);
+        return targetIndex === void 0 || positions[targetIndex] === void 0;
+      })();
+      if (shouldUseFallbackVisibleAnchor) {
         for (let i = 0; i < idsInViewWithPositions.length; i++) {
           const { id, position } = idsInViewWithPositions[i];
-          const newPosition = positions.get(id);
+          const index = indexByKey.get(id);
+          if (index !== void 0 && shouldRestorePosition) {
+            const item = data[index];
+            if (item === void 0 || !shouldRestorePosition(item, index, data)) {
+              continue;
+            }
+          }
+          const newPosition = index !== void 0 ? positions[index] : void 0;
           if (newPosition !== void 0) {
             positionDiff = newPosition - position;
+            anchorIdForLock = id;
+            anchorPositionForLock = newPosition;
             break;
           }
         }
       }
-      if (targetId !== void 0 && prevPosition !== void 0) {
-        const newPosition = positions.get(targetId);
+      if (!skipTargetAnchor && targetId !== void 0 && prevPosition !== void 0) {
+        const targetIndex = indexByKey.get(targetId);
+        const newPosition = targetIndex !== void 0 ? positions[targetIndex] : void 0;
         if (newPosition !== void 0) {
           const totalSize = getContentSize(ctx);
           let diff = newPosition - prevPosition;
-          if (diff !== 0 && state.scroll + state.scrollLength > totalSize) {
+          if (diff !== 0 && isEndAnchoredScrollTarget && state.scroll + state.scrollLength > totalSize) {
             if (diff > 0) {
               diff = Math.max(0, totalSize - state.scroll - state.scrollLength);
             } else {
@@ -1438,33 +1782,52 @@ function prepareMVCP(ctx, state, dataChanged) {
             }
           }
           positionDiff = diff;
+          anchorIdForLock = targetId;
+          anchorPositionForLock = newPosition;
         }
       }
-      if (positionDiff !== void 0 && Math.abs(positionDiff) > 0.1) {
-        requestAdjust(ctx, state, positionDiff, dataChanged && maintainVisibleContentPosition);
+      if (scrollingToViewPosition && scrollingToViewPosition > 0) {
+        const newSize = getItemSize(ctx, targetId, scrollTarget, state.props.data[scrollTarget]);
+        const prevSize = scrollingTo == null ? void 0 : scrollingTo.itemSize;
+        if (newSize !== void 0 && prevSize !== void 0 && newSize !== prevSize) {
+          const diff = newSize - prevSize;
+          if (diff !== 0) {
+            positionDiff += diff * scrollingToViewPosition;
+            scrollingTo.itemSize = newSize;
+          }
+        }
+      }
+      updateAnchorLock(state, {
+        anchorId: anchorIdForLock,
+        anchorPosition: anchorPositionForLock,
+        dataChanged,
+        now,
+        positionDiff
+      });
+      if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
+        requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
       }
     };
   }
 }
 
 // src/core/prepareColumnStartState.ts
-function prepareColumnStartState(ctx, state, startIndex, useAverageSize) {
+function prepareColumnStartState(ctx, startIndex, useAverageSize) {
   var _a3;
+  const state = ctx.state;
   const numColumns = peek$(ctx, "numColumns");
   let rowStartIndex = startIndex;
-  const columnAtStart = state.columns.get(state.idCache[startIndex]);
+  const columnAtStart = state.columns[startIndex];
   if (columnAtStart !== 1) {
     rowStartIndex = findRowStartIndex(state, numColumns, startIndex);
   }
   let currentRowTop = 0;
-  const curId = state.idCache[rowStartIndex];
-  const column = state.columns.get(curId);
+  const column = state.columns[rowStartIndex];
   if (rowStartIndex > 0) {
     const prevIndex = rowStartIndex - 1;
-    const prevId = state.idCache[prevIndex];
-    const prevPosition = (_a3 = state.positions.get(prevId)) != null ? _a3 : 0;
+    const prevPosition = (_a3 = state.positions[prevIndex]) != null ? _a3 : 0;
     const prevRowStart = findRowStartIndex(state, numColumns, prevIndex);
-    const prevRowHeight = calculateRowMaxSize(ctx, state, prevRowStart, prevIndex, useAverageSize);
+    const prevRowHeight = calculateRowMaxSize(ctx, prevRowStart, prevIndex, useAverageSize);
     currentRowTop = prevPosition + prevRowHeight;
   }
   return {
@@ -1479,7 +1842,7 @@ function findRowStartIndex(state, numColumns, index) {
   }
   let rowStart = Math.max(0, index);
   while (rowStart > 0) {
-    const columnForIndex = state.columns.get(state.idCache[rowStart]);
+    const columnForIndex = state.columns[rowStart];
     if (columnForIndex === 1) {
       break;
     }
@@ -1487,7 +1850,8 @@ function findRowStartIndex(state, numColumns, index) {
   }
   return rowStart;
 }
-function calculateRowMaxSize(ctx, state, startIndex, endIndex, useAverageSize) {
+function calculateRowMaxSize(ctx, startIndex, endIndex, useAverageSize) {
+  const state = ctx.state;
   if (endIndex < startIndex) {
     return 0;
   }
@@ -1501,7 +1865,7 @@ function calculateRowMaxSize(ctx, state, startIndex, endIndex, useAverageSize) {
       continue;
     }
     const id = state.idCache[i];
-    const size = getItemSize(ctx, state, id, i, data[i], useAverageSize);
+    const size = getItemSize(ctx, id, i, data[i], useAverageSize);
     if (size > maxSize) {
       maxSize = size;
     }
@@ -1510,22 +1874,44 @@ function calculateRowMaxSize(ctx, state, startIndex, endIndex, useAverageSize) {
 }
 
 // src/core/updateTotalSize.ts
-function updateTotalSize(ctx, state) {
+function updateTotalSize(ctx) {
+  var _a3, _b;
+  const state = ctx.state;
   const {
     positions,
     props: { data }
   } = state;
+  const numColumns = (_a3 = peek$(ctx, "numColumns")) != null ? _a3 : 1;
   if (data.length === 0) {
-    addTotalSize(ctx, state, null, 0);
+    addTotalSize(ctx, null, 0);
   } else {
-    const lastId = getId(state, data.length - 1);
-    if (lastId !== void 0) {
-      const lastPosition = positions.get(lastId);
-      if (lastPosition !== void 0) {
-        const lastSize = getItemSize(ctx, state, lastId, data.length - 1, data[data.length - 1]);
+    const lastIndex = data.length - 1;
+    const lastId = getId(state, lastIndex);
+    const lastPosition = positions[lastIndex];
+    if (lastId !== void 0 && lastPosition !== void 0) {
+      if (numColumns > 1) {
+        let rowStart = lastIndex;
+        while (rowStart > 0) {
+          const column = state.columns[rowStart];
+          if (column === 1 || column === void 0) {
+            break;
+          }
+          rowStart -= 1;
+        }
+        let maxSize = 0;
+        for (let i = rowStart; i <= lastIndex; i++) {
+          const rowId = (_b = state.idCache[i]) != null ? _b : getId(state, i);
+          const size = getItemSize(ctx, rowId, i, data[i]);
+          if (size > maxSize) {
+            maxSize = size;
+          }
+        }
+        addTotalSize(ctx, null, lastPosition + maxSize);
+      } else {
+        const lastSize = getItemSize(ctx, lastId, lastIndex, data[lastIndex]);
         if (lastSize !== void 0) {
           const totalSize = lastPosition + lastSize;
-          addTotalSize(ctx, state, null, totalSize);
+          addTotalSize(ctx, null, totalSize);
         }
       }
     }
@@ -1535,90 +1921,107 @@ function updateTotalSize(ctx, state) {
 // src/utils/getScrollVelocity.ts
 var getScrollVelocity = (state) => {
   const { scrollHistory } = state;
-  let velocity = 0;
-  if (scrollHistory.length >= 1) {
-    const newest = scrollHistory[scrollHistory.length - 1];
-    let oldest;
-    let start = 0;
-    const now = Date.now();
-    for (let i = 0; i < scrollHistory.length - 1; i++) {
-      const entry = scrollHistory[i];
-      const nextEntry = scrollHistory[i + 1];
-      if (i > 0) {
-        const prevEntry = scrollHistory[i - 1];
-        const prevDirection = entry.scroll - prevEntry.scroll;
-        const currentDirection = nextEntry.scroll - entry.scroll;
-        if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
-          start = i;
-          break;
-        }
-      }
+  const newestIndex = scrollHistory.length - 1;
+  if (newestIndex < 1) {
+    return 0;
+  }
+  const newest = scrollHistory[newestIndex];
+  const now = Date.now();
+  let direction = 0;
+  for (let i = newestIndex; i > 0; i--) {
+    const delta = scrollHistory[i].scroll - scrollHistory[i - 1].scroll;
+    if (delta !== 0) {
+      direction = Math.sign(delta);
+      break;
     }
-    for (let i = start; i < scrollHistory.length - 1; i++) {
-      const entry = scrollHistory[i];
-      if (now - entry.time <= 1e3) {
-        oldest = entry;
-        break;
-      }
+  }
+  if (direction === 0) {
+    return 0;
+  }
+  let oldest = newest;
+  for (let i = newestIndex - 1; i >= 0; i--) {
+    const current = scrollHistory[i];
+    const next = scrollHistory[i + 1];
+    const delta = next.scroll - current.scroll;
+    const deltaSign = Math.sign(delta);
+    if (deltaSign !== 0 && deltaSign !== direction) {
+      break;
     }
-    if (oldest && oldest !== newest) {
-      const scrollDiff = newest.scroll - oldest.scroll;
-      const timeDiff = newest.time - oldest.time;
-      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
+    if (now - current.time > 1e3) {
+      break;
     }
+    oldest = current;
   }
-  return velocity;
+  const scrollDiff = newest.scroll - oldest.scroll;
+  const timeDiff = newest.time - oldest.time;
+  return timeDiff > 0 ? scrollDiff / timeDiff : 0;
 };
 
 // src/utils/updateSnapToOffsets.ts
-function updateSnapToOffsets(ctx, state) {
+function updateSnapToOffsets(ctx) {
+  const state = ctx.state;
   const {
-    positions,
     props: { snapToIndices }
   } = state;
   const snapToOffsets = Array(snapToIndices.length);
   for (let i = 0; i < snapToIndices.length; i++) {
     const idx = snapToIndices[i];
-    const key = getId(state, idx);
-    snapToOffsets[i] = positions.get(key);
+    getId(state, idx);
+    snapToOffsets[i] = state.positions[idx];
   }
   set$(ctx, "snapToOffsets", snapToOffsets);
 }
 
 // src/core/updateItemPositions.ts
-function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottomBuffered, forceFullUpdate = false, doMVCP } = {
+function updateItemPositions(ctx, dataChanged, { startIndex, scrollBottomBuffered, forceFullUpdate = false, doMVCP } = {
   doMVCP: false,
   forceFullUpdate: false,
   scrollBottomBuffered: -1,
   startIndex: 0
 }) {
   var _a3, _b, _c, _d, _e;
+  const state = ctx.state;
+  const hasPositionListeners = ctx.positionListeners.size > 0;
   const {
     columns,
+    columnSpans,
     indexByKey,
     positions,
     idCache,
     sizesKnown,
-    props: { getEstimatedItemSize, snapToIndices, enableAverages }
+    props: { data, getEstimatedItemSize, overrideItemLayout, snapToIndices },
+    scrollingTo
   } = state;
-  const data = state.props.data;
   const dataLength = data.length;
-  const numColumns = peek$(ctx, "numColumns");
-  const scrollingTo = peek$(ctx, "scrollingTo");
+  const numColumns = (_a3 = peek$(ctx, "numColumns")) != null ? _a3 : 1;
   const hasColumns = numColumns > 1;
   const indexByKeyForChecking = IS_DEV ? /* @__PURE__ */ new Map() : void 0;
-  const shouldOptimize = !forceFullUpdate && !dataChanged && Math.abs(getScrollVelocity(state)) > 0;
+  const extraData = peek$(ctx, "extraData");
+  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 maxVisibleArea = scrollBottomBuffered + 1e3;
-  const useAverageSize = enableAverages && !getEstimatedItemSize;
-  const preferCachedSize = !doMVCP || dataChanged || state.scrollAdjustHandler.getAdjust() !== 0 || ((_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0) !== 0;
+  const useAverageSize = !getEstimatedItemSize;
+  const preferCachedSize = !doMVCP || dataChanged || state.scrollAdjustHandler.getAdjust() !== 0 || ((_b = peek$(ctx, "scrollAdjustPending")) != null ? _b : 0) !== 0;
   let currentRowTop = 0;
   let column = 1;
   let maxSizeInRow = 0;
+  if (dataChanged) {
+    columnSpans.length = 0;
+  }
+  if (!hasColumns) {
+    if (columns.length) {
+      columns.length = 0;
+    }
+    if (columnSpans.length) {
+      columnSpans.length = 0;
+    }
+  }
   if (startIndex > 0) {
     if (hasColumns) {
       const { startIndex: processedStartIndex, currentRowTop: initialRowTop } = prepareColumnStartState(
         ctx,
-        state,
         startIndex,
         useAverageSize
       );
@@ -1627,12 +2030,13 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
     } else if (startIndex < dataLength) {
       const prevIndex = startIndex - 1;
       const prevId = getId(state, prevIndex);
-      const prevPosition = (_b = positions.get(prevId)) != null ? _b : 0;
-      const prevSize = (_c = sizesKnown.get(prevId)) != null ? _c : getItemSize(ctx, state, prevId, prevIndex, data[prevIndex], useAverageSize, preferCachedSize);
+      const prevPosition = (_c = positions[prevIndex]) != null ? _c : 0;
+      const prevSize = (_d = sizesKnown.get(prevId)) != null ? _d : getItemSize(ctx, prevId, prevIndex, data[prevIndex], useAverageSize, preferCachedSize);
       currentRowTop = prevPosition + prevSize;
     }
   }
   const needsIndexByKey = dataChanged || indexByKey.size === 0;
+  const canOverrideSpan = hasColumns && !!overrideItemLayout && !!layoutConfig;
   let didBreakEarly = false;
   let breakAt;
   for (let i = startIndex; i < dataLength; i++) {
@@ -1644,8 +2048,23 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
       const itemsPerRow = hasColumns ? numColumns : 1;
       breakAt = i + itemsPerRow + 10;
     }
-    const id = (_d = idCache[i]) != null ? _d : getId(state, i);
-    const size = (_e = sizesKnown.get(id)) != null ? _e : getItemSize(ctx, state, id, i, data[i], useAverageSize, preferCachedSize);
+    const id = (_e = idCache[i]) != null ? _e : getId(state, i);
+    let span = 1;
+    if (canOverrideSpan) {
+      layoutConfig.span = 1;
+      overrideItemLayout(layoutConfig, data[i], i, numColumns, extraData);
+      const requestedSpan = layoutConfig.span;
+      if (requestedSpan !== void 0 && Number.isFinite(requestedSpan)) {
+        span = Math.max(1, Math.min(numColumns, Math.round(requestedSpan)));
+      }
+    }
+    if (hasColumns && column + span - 1 > numColumns) {
+      currentRowTop += maxSizeInRow;
+      column = 1;
+      maxSizeInRow = 0;
+    }
+    const knownSize = sizesKnown.get(id);
+    const size = knownSize !== void 0 ? knownSize : getItemSize(ctx, id, i, data[i], useAverageSize, preferCachedSize);
     if (IS_DEV && needsIndexByKey) {
       if (indexByKeyForChecking.has(id)) {
         console.error(
@@ -1654,30 +2073,36 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
       }
       indexByKeyForChecking.set(id, i);
     }
-    positions.set(id, currentRowTop);
+    if (currentRowTop !== positions[i]) {
+      positions[i] = currentRowTop;
+      if (hasPositionListeners) {
+        notifyPosition$(ctx, id, currentRowTop);
+      }
+    }
     if (needsIndexByKey) {
       indexByKey.set(id, i);
     }
-    columns.set(id, column);
-    if (hasColumns) {
+    if (!hasColumns) {
+      currentRowTop += size;
+    } else {
+      columns[i] = column;
+      columnSpans[i] = span;
       if (size > maxSizeInRow) {
         maxSizeInRow = size;
       }
-      column++;
+      column += span;
       if (column > numColumns) {
         currentRowTop += maxSizeInRow;
         column = 1;
         maxSizeInRow = 0;
       }
-    } else {
-      currentRowTop += size;
     }
   }
   if (!didBreakEarly) {
-    updateTotalSize(ctx, state);
+    updateTotalSize(ctx);
   }
   if (snapToIndices) {
-    updateSnapToOffsets(ctx, state);
+    updateSnapToOffsets(ctx);
   }
 }
 
@@ -1755,7 +2180,7 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, stat
   if (previousViewableItems) {
     for (const viewToken of previousViewableItems) {
       const containerId = findContainerId(ctx, viewToken.key);
-      if (!isViewable(
+      if (!checkIsViewable(
         state,
         ctx,
         viewabilityConfig,
@@ -1776,7 +2201,7 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, stat
     if (item) {
       const key = getId(state, i);
       const containerId = findContainerId(ctx, key);
-      if (isViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, i)) {
+      if (checkIsViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, i)) {
         const viewToken = {
           containerId,
           index: i,
@@ -1822,25 +2247,49 @@ function shallowEqual(prev, next) {
   return true;
 }
 function computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
-  const { sizes, positions, scroll: scrollState } = state;
+  const { sizes, scroll: scrollState } = state;
   const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
   const { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = viewabilityConfig;
   const viewAreaMode = viewAreaCoveragePercentThreshold != null;
   const viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
   const scroll = scrollState - topPad;
-  const top = positions.get(key) - scroll;
+  const position = state.positions[index];
   const size = sizes.get(key) || 0;
+  if (position === void 0) {
+    const value2 = {
+      containerId,
+      index,
+      isViewable: false,
+      item,
+      key,
+      percentOfScroller: 0,
+      percentVisible: 0,
+      scrollSize,
+      size,
+      sizeVisible: -1
+    };
+    const prev2 = ctx.mapViewabilityAmountValues.get(containerId);
+    if (!shallowEqual(prev2, value2)) {
+      ctx.mapViewabilityAmountValues.set(containerId, value2);
+      const cb = ctx.mapViewabilityAmountCallbacks.get(containerId);
+      if (cb) {
+        cb(value2);
+      }
+    }
+    return value2;
+  }
+  const top = position - scroll;
   const bottom = top + size;
   const isEntirelyVisible = top >= 0 && bottom <= scrollSize && bottom > top;
   const sizeVisible = isEntirelyVisible ? size : Math.min(bottom, scrollSize) - Math.max(top, 0);
   const percentVisible = size ? isEntirelyVisible ? 100 : 100 * (sizeVisible / size) : 0;
   const percentOfScroller = size ? 100 * (sizeVisible / scrollSize) : 0;
   const percent = isEntirelyVisible ? 100 : viewAreaMode ? percentOfScroller : percentVisible;
-  const isViewable2 = percent >= viewablePercentThreshold;
+  const isViewable = percent >= viewablePercentThreshold;
   const value = {
     containerId,
     index,
-    isViewable: isViewable2,
+    isViewable,
     item,
     key,
     percentOfScroller,
@@ -1859,8 +2308,11 @@ function computeViewability(state, ctx, viewabilityConfig, containerId, key, scr
   }
   return value;
 }
-function isViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
-  const value = ctx.mapViewabilityAmountValues.get(containerId) || computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index);
+function checkIsViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
+  let value = ctx.mapViewabilityAmountValues.get(containerId);
+  if (!value || value.key !== key) {
+    value = computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index);
+  }
   return value.isViewable;
 }
 function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
@@ -1869,6 +2321,8 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
   const cb = ctx.mapViewabilityCallbacks.get(key);
   cb == null ? void 0 : cb(viewToken);
 }
+var unstableBatchedUpdates = ReactNative__namespace.unstable_batchedUpdates;
+var batchedUpdates = typeof unstableBatchedUpdates === "function" ? unstableBatchedUpdates : (fn) => fn();
 
 // src/utils/checkAllSizesKnown.ts
 function isNullOrUndefined2(value) {
@@ -1888,8 +2342,9 @@ function checkAllSizesKnown(state) {
 }
 
 // src/utils/findAvailableContainers.ts
-function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffered, pendingRemoval, requiredItemTypes, needNewContainers) {
+function findAvailableContainers(ctx, numNeeded, startBuffered, endBuffered, pendingRemoval, requiredItemTypes, needNewContainers) {
   const numContainers = peek$(ctx, "numContainers");
+  const state = ctx.state;
   const { stickyContainerPool, containerItemTypes } = state;
   const result = [];
   const availableContainers = [];
@@ -2009,103 +2464,93 @@ function comparatorByDistance(a, b) {
 }
 
 // src/core/scrollToIndex.ts
-function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, viewPosition }) {
-  if (index >= state.props.data.length) {
-    index = state.props.data.length - 1;
+function scrollToIndex(ctx, { index, viewOffset = 0, animated = true, viewPosition }) {
+  const state = ctx.state;
+  const { data } = state.props;
+  if (index >= data.length) {
+    index = data.length - 1;
   } else if (index < 0) {
     index = 0;
   }
-  const firstIndexOffset = calculateOffsetForIndex(ctx, state, index);
-  const isLast = index === state.props.data.length - 1;
+  const firstIndexOffset = calculateOffsetForIndex(ctx, index);
+  const isLast = index === data.length - 1;
   if (isLast && viewPosition === void 0) {
     viewPosition = 1;
   }
   state.scrollForNextCalculateItemsInView = void 0;
-  scrollTo(ctx, state, {
+  const targetId = getId(state, index);
+  const itemSize = getItemSize(ctx, targetId, index, state.props.data[index]);
+  scrollTo(ctx, {
     animated,
     index,
-    offset: firstIndexOffset,
-    viewOffset,
-    viewPosition: viewPosition != null ? viewPosition : 0
-  });
-}
-
-// src/utils/setDidLayout.ts
-function setDidLayout(ctx, state) {
-  const {
-    loadStartTime,
-    initialScroll,
-    props: { onLoad }
-  } = state;
-  state.queuedInitialLayout = true;
-  checkAtBottom(ctx, state);
-  const setIt = () => {
-    set$(ctx, "containersDidLayout", true);
-    if (onLoad) {
-      onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
-    }
-  };
-  if (Platform2.OS === "android" && initialScroll) {
-    if (IsNewArchitecture) {
-      scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-      requestAnimationFrame(() => {
-        scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-        setIt();
-      });
-    } else {
-      scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-      setIt();
-    }
-  } else {
-    setIt();
-  }
+    itemSize,
+    offset: firstIndexOffset,
+    viewOffset,
+    viewPosition: viewPosition != null ? viewPosition : 0
+  });
+}
+
+// src/utils/setDidLayout.ts
+function setDidLayout(ctx) {
+  const state = ctx.state;
+  const { initialScroll } = state;
+  state.queuedInitialLayout = true;
+  checkAtBottom(ctx);
+  if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
+    const target = initialScroll;
+    const runScroll = () => scrollToIndex(ctx, { ...target, animated: false });
+    runScroll();
+    requestAnimationFrame(runScroll);
+  }
+  setInitialRenderState(ctx, { didLayout: true });
 }
 
 // src/core/calculateItemsInView.ts
 function findCurrentStickyIndex(stickyArray, scroll, state) {
-  var _a3;
-  const idCache = state.idCache;
   const positions = state.positions;
   for (let i = stickyArray.length - 1; i >= 0; i--) {
     const stickyIndex = stickyArray[i];
-    const stickyId = (_a3 = idCache[stickyIndex]) != null ? _a3 : getId(state, stickyIndex);
-    const stickyPos = stickyId ? positions.get(stickyId) : void 0;
+    const stickyPos = positions[stickyIndex];
     if (stickyPos !== void 0 && scroll >= stickyPos) {
       return i;
     }
   }
   return -1;
 }
-function getActiveStickyIndices(ctx, state, stickyHeaderIndices) {
+function getActiveStickyIndices(ctx, stickyHeaderIndices) {
+  const state = ctx.state;
   return new Set(
     Array.from(state.stickyContainerPool).map((i) => peek$(ctx, `containerItemKey${i}`)).map((key) => key ? state.indexByKey.get(key) : void 0).filter((idx) => idx !== void 0 && stickyHeaderIndices.has(idx))
   );
 }
-function handleStickyActivation(ctx, state, stickyHeaderIndices, stickyArray, currentStickyIdx, needNewContainers, startBuffered, endBuffered) {
+function handleStickyActivation(ctx, stickyHeaderIndices, stickyArray, currentStickyIdx, needNewContainers, needNewContainersSet, startBuffered, endBuffered) {
   var _a3;
-  const activeIndices = getActiveStickyIndices(ctx, state, stickyHeaderIndices);
-  state.activeStickyIndex = currentStickyIdx >= 0 ? stickyArray[currentStickyIdx] : void 0;
+  const state = ctx.state;
+  const activeIndices = getActiveStickyIndices(ctx, stickyHeaderIndices);
+  set$(ctx, "activeStickyIndex", currentStickyIdx >= 0 ? stickyArray[currentStickyIdx] : -1);
   for (let offset = 0; offset <= 1; offset++) {
     const idx = currentStickyIdx - offset;
     if (idx < 0 || activeIndices.has(stickyArray[idx])) continue;
     const stickyIndex = stickyArray[idx];
     const stickyId = (_a3 = state.idCache[stickyIndex]) != null ? _a3 : getId(state, stickyIndex);
-    if (stickyId && !state.containerItemKeys.has(stickyId) && (stickyIndex < startBuffered || stickyIndex > endBuffered)) {
+    if (stickyId && !state.containerItemKeys.has(stickyId) && (stickyIndex < startBuffered || stickyIndex > endBuffered) && !needNewContainersSet.has(stickyIndex)) {
+      needNewContainersSet.add(stickyIndex);
       needNewContainers.push(stickyIndex);
     }
   }
 }
-function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, currentStickyIdx, pendingRemoval) {
-  var _a3, _b, _c;
+function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentStickyIdx, pendingRemoval, alwaysRenderIndicesSet) {
+  var _a3, _b;
+  const state = ctx.state;
   for (const containerIndex of state.stickyContainerPool) {
     const itemKey = peek$(ctx, `containerItemKey${containerIndex}`);
     const itemIndex = itemKey ? state.indexByKey.get(itemKey) : void 0;
     if (itemIndex === void 0) continue;
+    if (alwaysRenderIndicesSet.has(itemIndex)) continue;
     const arrayIdx = stickyArray.indexOf(itemIndex);
     if (arrayIdx === -1) {
       state.stickyContainerPool.delete(containerIndex);
       set$(ctx, `containerSticky${containerIndex}`, false);
-      set$(ctx, `containerStickyOffset${containerIndex}`, void 0);
       continue;
     }
     const isRecentSticky = arrayIdx >= currentStickyIdx - 1 && arrayIdx <= currentStickyIdx + 1;
@@ -2113,15 +2558,14 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
     const nextIndex = stickyArray[arrayIdx + 1];
     let shouldRecycle = false;
     if (nextIndex) {
-      const nextId = (_a3 = state.idCache[nextIndex]) != null ? _a3 : getId(state, nextIndex);
-      const nextPos = nextId ? state.positions.get(nextId) : void 0;
-      shouldRecycle = nextPos !== void 0 && scroll > nextPos + scrollBuffer * 2;
+      const nextPos = state.positions[nextIndex];
+      shouldRecycle = nextPos !== void 0 && scroll > nextPos + drawDistance * 2;
     } else {
-      const currentId = (_b = state.idCache[itemIndex]) != null ? _b : getId(state, itemIndex);
+      const currentId = (_a3 = state.idCache[itemIndex]) != null ? _a3 : getId(state, itemIndex);
       if (currentId) {
-        const currentPos = state.positions.get(currentId);
-        const currentSize = (_c = state.sizes.get(currentId)) != null ? _c : getItemSize(ctx, state, currentId, itemIndex, state.props.data[itemIndex]);
-        shouldRecycle = currentPos !== void 0 && scroll > currentPos + currentSize + scrollBuffer * 3;
+        const currentPos = state.positions[itemIndex];
+        const currentSize = (_b = state.sizes.get(currentId)) != null ? _b : getItemSize(ctx, currentId, itemIndex, state.props.data[itemIndex]);
+        shouldRecycle = currentPos !== void 0 && scroll > currentPos + currentSize + drawDistance * 3;
       }
     }
     if (shouldRecycle) {
@@ -2129,11 +2573,13 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
     }
   }
 }
-function calculateItemsInView(ctx, state, params = {}) {
-  reactNative.unstable_batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+function calculateItemsInView(ctx, params = {}) {
+  const state = ctx.state;
+  batchedUpdates(() => {
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const {
       columns,
+      columnSpans,
       containerItemKeys,
       enableScrollForNextCalculateItemsInView,
       idCache,
@@ -2141,7 +2587,15 @@ function calculateItemsInView(ctx, state, params = {}) {
       initialScroll,
       minIndexSizeChanged,
       positions,
-      props: { getItemType, itemsAreEqual, keyExtractor, onStickyHeaderChange, scrollBuffer },
+      props: {
+        alwaysRenderIndicesArr,
+        alwaysRenderIndicesSet,
+        drawDistance,
+        getItemType,
+        itemsAreEqual,
+        keyExtractor,
+        onStickyHeaderChange
+      },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -2151,17 +2605,19 @@ function calculateItemsInView(ctx, state, params = {}) {
     const { data } = state.props;
     const stickyIndicesArr = state.props.stickyIndicesArr || [];
     const stickyIndicesSet = state.props.stickyIndicesSet || /* @__PURE__ */ new Set();
+    const alwaysRenderArr = alwaysRenderIndicesArr || [];
+    const alwaysRenderSet = alwaysRenderIndicesSet || /* @__PURE__ */ new Set();
+    const { dataChanged, doMVCP, forceFullItemPositions } = params;
     const prevNumContainers = peek$(ctx, "numContainers");
     if (!data || scrollLength === 0 || !prevNumContainers) {
-      if (state.initialAnchor) {
-        ensureInitialAnchor(ctx, state);
+      if (!IsNewArchitecture && state.initialAnchor) {
+        ensureInitialAnchor(ctx);
       }
       return;
     }
     const totalSize = getContentSize(ctx);
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
-    const { dataChanged, doMVCP, forceFullItemPositions } = params;
     const speed = getScrollVelocity(state);
     const scrollExtra = 0;
     const { queuedInitialLayout } = state;
@@ -2169,56 +2625,58 @@ function calculateItemsInView(ctx, state, params = {}) {
     if (!queuedInitialLayout && initialScroll) {
       const updatedOffset = calculateOffsetWithOffsetPosition(
         ctx,
-        state,
-        calculateOffsetForIndex(ctx, state, initialScroll.index),
+        calculateOffsetForIndex(ctx, initialScroll.index),
         initialScroll
       );
       scrollState = updatedOffset;
     }
     const scrollAdjustPending = (_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0;
     const scrollAdjustPad = scrollAdjustPending - topPad;
-    let scroll = scrollState + scrollExtra + scrollAdjustPad;
+    let scroll = Math.round(scrollState + scrollExtra + scrollAdjustPad);
     if (scroll + scrollLength > totalSize) {
       scroll = Math.max(0, totalSize - scrollLength);
     }
-    if (ENABLE_DEBUG_VIEW) {
-      set$(ctx, "debugRawScroll", scrollState);
-      set$(ctx, "debugComputedScroll", scroll);
-    }
-    const previousStickyIndex = state.activeStickyIndex;
+    const previousStickyIndex = peek$(ctx, "activeStickyIndex");
     const currentStickyIdx = stickyIndicesArr.length > 0 ? findCurrentStickyIndex(stickyIndicesArr, scroll, state) : -1;
-    const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyIndicesArr[currentStickyIdx] : void 0;
-    state.activeStickyIndex = nextActiveStickyIndex;
-    set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
-    let scrollBufferTop = scrollBuffer;
-    let scrollBufferBottom = scrollBuffer;
-    if (speed > 0 || speed === 0 && scroll < Math.max(50, scrollBuffer)) {
-      scrollBufferTop = scrollBuffer * 0.5;
-      scrollBufferBottom = scrollBuffer * 1.5;
+    const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyIndicesArr[currentStickyIdx] : -1;
+    if (currentStickyIdx >= 0 || previousStickyIndex >= 0) {
+      set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
+    }
+    let scrollBufferTop = drawDistance;
+    let scrollBufferBottom = drawDistance;
+    if (speed > 0 || speed === 0 && scroll < Math.max(50, drawDistance)) {
+      scrollBufferTop = drawDistance * 0.5;
+      scrollBufferBottom = drawDistance * 1.5;
     } else {
-      scrollBufferTop = scrollBuffer * 1.5;
-      scrollBufferBottom = scrollBuffer * 0.5;
+      scrollBufferTop = drawDistance * 1.5;
+      scrollBufferBottom = drawDistance * 0.5;
     }
     const scrollTopBuffered = scroll - scrollBufferTop;
     const scrollBottom = scroll + scrollLength + (scroll < 0 ? -scroll : 0);
     const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
-    if (!dataChanged && scrollForNextCalculateItemsInView) {
+    if (!dataChanged && !forceFullItemPositions && scrollForNextCalculateItemsInView) {
       const { top, bottom } = scrollForNextCalculateItemsInView;
-      if (scrollTopBuffered > top && scrollBottomBuffered < bottom) {
-        if (state.initialAnchor) {
-          ensureInitialAnchor(ctx, state);
+      if (top === null && bottom === null) {
+        state.scrollForNextCalculateItemsInView = void 0;
+      } else if ((top === null || scrollTopBuffered > top) && (bottom === null || scrollBottomBuffered < bottom)) {
+        if (!IsNewArchitecture && state.initialAnchor) {
+          ensureInitialAnchor(ctx);
+        }
+        if (Platform2.OS !== "web" || !isInMVCPActiveMode(state)) {
+          return;
         }
-        return;
       }
     }
-    const checkMVCP = doMVCP ? prepareMVCP(ctx, state, dataChanged) : void 0;
+    const checkMVCP = doMVCP ? prepareMVCP(ctx, dataChanged) : void 0;
     if (dataChanged) {
       indexByKey.clear();
       idCache.length = 0;
-      positions.clear();
+      positions.length = 0;
+      columns.length = 0;
+      columnSpans.length = 0;
     }
-    const startIndex = dataChanged ? 0 : (_b = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _b : 0;
-    updateItemPositions(ctx, state, dataChanged, {
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_b = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _b : 0;
+    updateItemPositions(ctx, dataChanged, {
       doMVCP,
       forceFullUpdate: !!forceFullItemPositions,
       scrollBottomBuffered,
@@ -2236,18 +2694,23 @@ function calculateItemsInView(ctx, state, params = {}) {
     let loopStart = !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
       const id = (_c = idCache[i]) != null ? _c : getId(state, i);
-      const top = positions.get(id);
-      const size = (_d = sizes.get(id)) != null ? _d : getItemSize(ctx, state, id, i, data[i]);
+      const top = positions[i];
+      const size = (_d = sizes.get(id)) != null ? _d : getItemSize(ctx, id, i, data[i]);
       const bottom = top + size;
-      if (bottom > scroll - scrollBuffer) {
+      if (bottom > scroll - scrollBufferTop) {
         loopStart = i;
       } else {
         break;
       }
     }
-    const loopStartMod = loopStart % numColumns;
-    if (loopStartMod > 0) {
-      loopStart -= loopStartMod;
+    if (numColumns > 1) {
+      while (loopStart > 0) {
+        const loopColumn = columns[loopStart];
+        if (loopColumn === 1 || loopColumn === void 0) {
+          break;
+        }
+        loopStart -= 1;
+      }
     }
     let foundEnd = false;
     let nextTop;
@@ -2264,8 +2727,8 @@ function calculateItemsInView(ctx, state, params = {}) {
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
       const id = (_e = idCache[i]) != null ? _e : getId(state, i);
-      const size = (_f = sizes.get(id)) != null ? _f : getItemSize(ctx, state, id, i, data[i]);
-      const top = positions.get(id);
+      const size = (_f = sizes.get(id)) != null ? _f : getItemSize(ctx, id, i, data[i]);
+      const top = positions[i];
       if (!foundEnd) {
         if (startNoBuffer === null && top + size > scroll) {
           startNoBuffer = i;
@@ -2276,7 +2739,11 @@ function calculateItemsInView(ctx, state, params = {}) {
         if (startBuffered === null && top + size > scrollTopBuffered) {
           startBuffered = i;
           startBufferedId = id;
-          nextTop = top;
+          if (scrollTopBuffered < 0) {
+            nextTop = null;
+          } else {
+            nextTop = top;
+          }
         }
         if (startNoBuffer !== null) {
           if (top <= scrollBottom) {
@@ -2284,7 +2751,11 @@ function calculateItemsInView(ctx, state, params = {}) {
           }
           if (top <= scrollBottomBuffered) {
             endBuffered = i;
-            nextBottom = top + size;
+            if (scrollBottomBuffered > totalSize) {
+              nextBottom = null;
+            } else {
+              nextBottom = top + size;
+            }
           } else {
             foundEnd = true;
           }
@@ -2306,12 +2777,12 @@ function calculateItemsInView(ctx, state, params = {}) {
       startNoBuffer
     });
     if (enableScrollForNextCalculateItemsInView && nextTop !== void 0 && nextBottom !== void 0) {
-      state.scrollForNextCalculateItemsInView = nextTop !== void 0 && nextBottom !== void 0 ? {
+      state.scrollForNextCalculateItemsInView = isNullOrUndefined(nextTop) && isNullOrUndefined(nextBottom) ? void 0 : {
         bottom: nextBottom,
         top: nextTop
-      } : void 0;
+      };
     }
-    const numContainers = peek$(ctx, "numContainers");
+    let numContainers = prevNumContainers;
     const pendingRemoval = [];
     if (dataChanged) {
       for (let i = 0; i < numContainers; i++) {
@@ -2322,37 +2793,46 @@ function calculateItemsInView(ctx, state, params = {}) {
       }
     }
     if (startBuffered !== null && endBuffered !== null) {
-      let numContainers2 = prevNumContainers;
       const needNewContainers = [];
+      const needNewContainersSet = /* @__PURE__ */ new Set();
       for (let i = startBuffered; i <= endBuffered; i++) {
         const id = (_h = idCache[i]) != null ? _h : getId(state, i);
         if (!containerItemKeys.has(id)) {
+          needNewContainersSet.add(i);
           needNewContainers.push(i);
         }
       }
+      if (alwaysRenderArr.length > 0) {
+        for (const index of alwaysRenderArr) {
+          if (index < 0 || index >= dataLength) continue;
+          const id = (_i = idCache[index]) != null ? _i : getId(state, index);
+          if (id && !containerItemKeys.has(id) && !needNewContainersSet.has(index)) {
+            needNewContainersSet.add(index);
+            needNewContainers.push(index);
+          }
+        }
+      }
       if (stickyIndicesArr.length > 0) {
         handleStickyActivation(
           ctx,
-          state,
           stickyIndicesSet,
           stickyIndicesArr,
           currentStickyIdx,
           needNewContainers,
+          needNewContainersSet,
           startBuffered,
           endBuffered
         );
-      } else {
-        state.activeStickyIndex = void 0;
-        set$(ctx, "activeStickyIndex", void 0);
+      } else if (previousStickyIndex !== -1) {
+        set$(ctx, "activeStickyIndex", -1);
       }
       if (needNewContainers.length > 0) {
         const requiredItemTypes = getItemType ? needNewContainers.map((i) => {
           const itemType = getItemType(data[i], i);
-          return itemType ? String(itemType) : "";
+          return itemType !== void 0 ? String(itemType) : "";
         }) : void 0;
         const availableContainers = findAvailableContainers(
           ctx,
-          state,
           needNewContainers.length,
           startBuffered,
           endBuffered,
@@ -2363,7 +2843,7 @@ function calculateItemsInView(ctx, state, params = {}) {
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
           const containerIndex = availableContainers[idx];
-          const id = (_i = idCache[i]) != null ? _i : getId(state, i);
+          const id = (_j = idCache[i]) != null ? _j : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -2373,30 +2853,55 @@ function calculateItemsInView(ctx, state, params = {}) {
           if (requiredItemTypes) {
             state.containerItemTypes.set(containerIndex, requiredItemTypes[idx]);
           }
-          containerItemKeys.add(id);
-          if (stickyIndicesSet.has(i)) {
-            set$(ctx, `containerSticky${containerIndex}`, true);
-            const topPadding = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
-            set$(ctx, `containerStickyOffset${containerIndex}`, topPadding);
+          containerItemKeys.set(id, containerIndex);
+          const containerSticky = `containerSticky${containerIndex}`;
+          const isSticky = stickyIndicesSet.has(i);
+          const isAlwaysRender = alwaysRenderSet.has(i);
+          if (isSticky) {
+            set$(ctx, containerSticky, true);
             state.stickyContainerPool.add(containerIndex);
           } else {
-            set$(ctx, `containerSticky${containerIndex}`, false);
-            state.stickyContainerPool.delete(containerIndex);
+            if (peek$(ctx, containerSticky)) {
+              set$(ctx, containerSticky, false);
+            }
+            if (isAlwaysRender) {
+              state.stickyContainerPool.add(containerIndex);
+            } else if (state.stickyContainerPool.has(containerIndex)) {
+              state.stickyContainerPool.delete(containerIndex);
+            }
           }
-          if (containerIndex >= numContainers2) {
-            numContainers2 = containerIndex + 1;
+          if (containerIndex >= numContainers) {
+            numContainers = containerIndex + 1;
           }
         }
-        if (numContainers2 !== prevNumContainers) {
-          set$(ctx, "numContainers", numContainers2);
-          if (numContainers2 > peek$(ctx, "numContainersPooled")) {
-            set$(ctx, "numContainersPooled", Math.ceil(numContainers2 * 1.5));
+        if (numContainers !== prevNumContainers) {
+          set$(ctx, "numContainers", numContainers);
+          if (numContainers > peek$(ctx, "numContainersPooled")) {
+            set$(ctx, "numContainersPooled", Math.ceil(numContainers * 1.5));
+          }
+        }
+      }
+      if (alwaysRenderArr.length > 0) {
+        for (const index of alwaysRenderArr) {
+          if (index < 0 || index >= dataLength) continue;
+          const id = (_k = idCache[index]) != null ? _k : getId(state, index);
+          const containerIndex = containerItemKeys.get(id);
+          if (containerIndex !== void 0) {
+            state.stickyContainerPool.add(containerIndex);
           }
         }
       }
     }
-    if (stickyIndicesArr.length > 0) {
-      handleStickyRecycling(ctx, state, stickyIndicesArr, scroll, scrollBuffer, currentStickyIdx, pendingRemoval);
+    if (state.stickyContainerPool.size > 0) {
+      handleStickyRecycling(
+        ctx,
+        stickyIndicesArr,
+        scroll,
+        drawDistance,
+        currentStickyIdx,
+        pendingRemoval,
+        alwaysRenderSet
+      );
     }
     let didChangePositions = false;
     for (let i = 0; i < numContainers; i++) {
@@ -2408,26 +2913,27 @@ function calculateItemsInView(ctx, state, params = {}) {
         state.containerItemTypes.delete(i);
         if (state.stickyContainerPool.has(i)) {
           set$(ctx, `containerSticky${i}`, false);
-          set$(ctx, `containerStickyOffset${i}`, void 0);
           state.stickyContainerPool.delete(i);
         }
         set$(ctx, `containerItemKey${i}`, void 0);
         set$(ctx, `containerItemData${i}`, void 0);
         set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
         set$(ctx, `containerColumn${i}`, -1);
+        set$(ctx, `containerSpan${i}`, 1);
       } else {
         const itemIndex = indexByKey.get(itemKey);
         const item = data[itemIndex];
         if (item !== void 0) {
-          const id = (_j = idCache[itemIndex]) != null ? _j : getId(state, itemIndex);
-          const positionValue = positions.get(id);
+          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.get(id) || 1;
+            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);
@@ -2436,6 +2942,9 @@ function calculateItemsInView(ctx, state, params = {}) {
             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);
             }
@@ -2448,7 +2957,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     }
     if (!queuedInitialLayout && endBuffered !== null) {
       if (checkAllSizesKnown(state)) {
-        setDidLayout(ctx, state);
+        setDidLayout(ctx);
       }
     }
     if (viewabilityConfigCallbackPairs) {
@@ -2461,8 +2970,8 @@ function calculateItemsInView(ctx, state, params = {}) {
       }
     }
   });
-  if (state.initialAnchor) {
-    ensureInitialAnchor(ctx, state);
+  if (!IsNewArchitecture && state.initialAnchor) {
+    ensureInitialAnchor(ctx);
   }
 }
 
@@ -2487,19 +2996,22 @@ function checkActualChange(state, dataProp, previousData) {
 }
 
 // src/core/doMaintainScrollAtEnd.ts
-function doMaintainScrollAtEnd(ctx, state, animated) {
+function doMaintainScrollAtEnd(ctx, animated) {
+  const state = ctx.state;
   const {
+    didContainersLayout,
+    isAtEnd,
     refScroller,
     props: { maintainScrollAtEnd }
   } = state;
-  if ((state == null ? void 0 : state.isAtEnd) && maintainScrollAtEnd && peek$(ctx, "containersDidLayout")) {
-    const paddingTop = peek$(ctx, "alignItemsPaddingTop");
-    if (paddingTop > 0) {
+  if (isAtEnd && maintainScrollAtEnd && didContainersLayout) {
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
       state.scroll = 0;
     }
     requestAnimationFrame(() => {
       var _a3;
-      if (state == null ? void 0 : state.isAtEnd) {
+      if (state.isAtEnd) {
         state.maintainingScrollAtEnd = true;
         (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
           animated
@@ -2570,36 +3082,37 @@ function updateAveragesOnDataChange(state, oldData, newData) {
 }
 
 // src/core/checkResetContainers.ts
-function checkResetContainers(ctx, state, dataProp) {
+function checkResetContainers(ctx, dataProp) {
+  const state = ctx.state;
   const { previousData } = state;
   if (previousData) {
     updateAveragesOnDataChange(state, previousData, dataProp);
   }
   const { maintainScrollAtEnd } = state.props;
-  calculateItemsInView(ctx, state, { dataChanged: true, doMVCP: true });
+  calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
   const shouldMaintainScrollAtEnd = maintainScrollAtEnd === true || maintainScrollAtEnd.onDataChange;
-  const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx, state, false);
+  const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx, false);
   if (!didMaintainScrollAtEnd && previousData && dataProp.length > previousData.length) {
     state.isEndReached = false;
   }
   if (!didMaintainScrollAtEnd) {
-    checkAtTop(state);
-    checkAtBottom(ctx, state);
+    checkThresholds(ctx);
   }
   delete state.previousData;
 }
 
 // src/core/doInitialAllocateContainers.ts
-function doInitialAllocateContainers(ctx, state, dataChanged) {
+function doInitialAllocateContainers(ctx) {
   var _a3, _b, _c;
+  const state = ctx.state;
   const {
     scrollLength,
     props: {
       data,
+      drawDistance,
       getEstimatedItemSize,
       getFixedItemSize,
       getItemType,
-      scrollBuffer,
       numColumns,
       estimatedItemSize
     }
@@ -2612,40 +3125,58 @@ function doInitialAllocateContainers(ctx, state, dataChanged) {
       const num = Math.min(20, data.length);
       for (let i = 0; i < num; i++) {
         const item = data[i];
-        const itemType = getItemType ? (_a3 = getItemType(item, i)) != null ? _a3 : "" : "";
-        totalSize += (_c = (_b = getFixedItemSize == null ? void 0 : getFixedItemSize(i, item, itemType)) != null ? _b : getEstimatedItemSize == null ? void 0 : getEstimatedItemSize(i, item, itemType)) != null ? _c : estimatedItemSize;
+        if (item !== void 0) {
+          const itemType = (_a3 = getItemType == null ? void 0 : getItemType(item, i)) != null ? _a3 : "";
+          totalSize += (_c = (_b = getFixedItemSize == null ? void 0 : getFixedItemSize(item, i, itemType)) != null ? _b : getEstimatedItemSize == null ? void 0 : getEstimatedItemSize(item, i, itemType)) != null ? _c : estimatedItemSize;
+        }
       }
       averageItemSize = totalSize / num;
     } else {
       averageItemSize = estimatedItemSize;
     }
-    const numContainers = Math.ceil((scrollLength + scrollBuffer * 2) / averageItemSize * numColumns);
+    const numContainers = Math.ceil((scrollLength + drawDistance * 2) / averageItemSize * numColumns);
     for (let i = 0; i < numContainers; i++) {
       set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
       set$(ctx, `containerColumn${i}`, -1);
+      set$(ctx, `containerSpan${i}`, 1);
     }
     set$(ctx, "numContainers", numContainers);
     set$(ctx, "numContainersPooled", numContainers * state.props.initialContainerPoolRatio);
     if (!IsNewArchitecture || state.lastLayout) {
       if (state.initialScroll) {
         requestAnimationFrame(() => {
-          calculateItemsInView(ctx, state, { dataChanged, doMVCP: true });
+          calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
         });
       } else {
-        calculateItemsInView(ctx, state, { dataChanged, doMVCP: true });
+        calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
       }
     }
     return true;
   }
 }
+function getWindowSize() {
+  const screenSize = ReactNative.Dimensions.get("window");
+  return {
+    height: screenSize.height,
+    width: screenSize.width
+  };
+}
 
 // src/core/handleLayout.ts
-function handleLayout(ctx, state, layout, setCanRender) {
-  const { maintainScrollAtEnd } = state.props;
-  const measuredLength = layout[state.props.horizontal ? "width" : "height"];
+function handleLayout(ctx, layoutParam, setCanRender) {
+  const state = ctx.state;
+  const { maintainScrollAtEnd, useWindowScroll } = state.props;
+  const scrollAxis = state.props.horizontal ? "width" : "height";
+  const otherAxis = state.props.horizontal ? "height" : "width";
+  let layout = layoutParam;
+  if (useWindowScroll) {
+    const windowScrollAxisLength = getWindowSize()[scrollAxis];
+    layout = windowScrollAxisLength > 0 ? { ...layoutParam, [scrollAxis]: windowScrollAxisLength } : layoutParam;
+  }
+  const measuredLength = layout[scrollAxis];
   const previousLength = state.scrollLength;
   const scrollLength = measuredLength > 0 ? measuredLength : previousLength;
-  const otherAxisSize = layout[state.props.horizontal ? "height" : "width"];
+  const otherAxisSize = layout[otherAxis];
   const needsCalculate = !state.lastLayout || scrollLength > state.scrollLength || state.lastLayout.x !== layout.x || state.lastLayout.y !== layout.y;
   state.lastLayout = layout;
   const prevOtherAxisSize = state.otherAxisSize;
@@ -2656,20 +3187,18 @@ function handleLayout(ctx, state, layout, setCanRender) {
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
     if (scrollLength > 0) {
-      doInitialAllocateContainers(ctx, state);
+      doInitialAllocateContainers(ctx);
     }
     if (needsCalculate) {
-      calculateItemsInView(ctx, state, { doMVCP: true });
+      calculateItemsInView(ctx, { doMVCP: true });
     }
     if (didChange || otherAxisSize !== prevOtherAxisSize) {
       set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
     }
     if (maintainScrollAtEnd === true || maintainScrollAtEnd.onLayout) {
-      doMaintainScrollAtEnd(ctx, state, false);
+      doMaintainScrollAtEnd(ctx, false);
     }
-    updateAlignItemsPaddingTop(ctx, state);
-    checkAtBottom(ctx, state);
-    checkAtTop(state);
+    checkThresholds(ctx);
     if (state) {
       state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
     }
@@ -2684,8 +3213,9 @@ function handleLayout(ctx, state, layout, setCanRender) {
 }
 
 // src/core/onScroll.ts
-function onScroll(ctx, state, event) {
-  var _a3, _b, _c;
+function onScroll(ctx, event) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
   const {
     scrollProcessingEnabled,
     props: { onScroll: onScrollProp }
@@ -2696,17 +3226,34 @@ function onScroll(ctx, state, event) {
   if (((_b = (_a3 = event.nativeEvent) == null ? void 0 : _a3.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
     return;
   }
+  let insetChanged = false;
+  if ((_d = event.nativeEvent) == null ? void 0 : _d.contentInset) {
+    const { contentInset } = event.nativeEvent;
+    const prevInset = state.nativeContentInset;
+    if (!prevInset || prevInset.top !== contentInset.top || prevInset.bottom !== contentInset.bottom || prevInset.left !== contentInset.left || prevInset.right !== contentInset.right) {
+      state.nativeContentInset = contentInset;
+      insetChanged = true;
+    }
+  }
   let newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
+  if (state.scrollingTo && state.scrollingTo.offset >= newScroll) {
+    const maxOffset = clampScrollOffset(ctx, newScroll, state.scrollingTo);
+    if (newScroll !== maxOffset && Math.abs(newScroll - maxOffset) > 1) {
+      newScroll = maxOffset;
+      scrollTo(ctx, {
+        forceScroll: true,
+        isInitialScroll: true,
+        noScrollingTo: true,
+        offset: newScroll
+      });
+      return;
+    }
+  }
   state.scrollPending = newScroll;
-  const maxOffset = Math.max(0, getContentSize(ctx) - state.scrollLength);
-  if (state.initialScroll && newScroll > maxOffset) {
-    newScroll = maxOffset;
-    scrollTo(ctx, state, {
-      noScrollingTo: true,
-      offset: newScroll
-    });
+  updateScroll(ctx, newScroll, insetChanged);
+  if (state.scrollingTo) {
+    checkFinishedScroll(ctx);
   }
-  updateScroll(ctx, state, newScroll);
   onScrollProp == null ? void 0 : onScrollProp(event);
 }
 
@@ -2715,51 +3262,80 @@ var ScrollAdjustHandler = class {
   constructor(ctx) {
     this.appliedAdjust = 0;
     this.pendingAdjust = 0;
-    this.mounted = false;
-    this.context = ctx;
-    if (Platform2.OS === "web") {
-      const commitPendingAdjust = () => {
-        const state = this.context.internalState;
-        const pending = this.pendingAdjust;
-        if (pending !== 0) {
-          this.pendingAdjust = 0;
-          this.appliedAdjust += pending;
-          state.scroll += pending;
-          state.scrollForNextCalculateItemsInView = void 0;
-          set$(this.context, "scrollAdjustPending", 0);
-          set$(this.context, "scrollAdjust", this.appliedAdjust);
-          calculateItemsInView(this.context, this.context.internalState);
-        }
-      };
-      listen$(this.context, "scrollingTo", (value) => {
-        if (value === void 0) {
-          commitPendingAdjust();
-        }
-      });
-    }
+    this.ctx = ctx;
   }
   requestAdjust(add) {
-    const scrollingTo = peek$(this.context, "scrollingTo");
-    if (Platform2.OS === "web" && (scrollingTo == null ? void 0 : scrollingTo.animated) && !scrollingTo.isInitialScroll) {
+    const scrollingTo = this.ctx.state.scrollingTo;
+    if (PlatformAdjustBreaksScroll && (scrollingTo == null ? void 0 : scrollingTo.animated) && !scrollingTo.isInitialScroll) {
       this.pendingAdjust += add;
-      set$(this.context, "scrollAdjustPending", this.pendingAdjust);
+      set$(this.ctx, "scrollAdjustPending", this.pendingAdjust);
     } else {
       this.appliedAdjust += add;
-      set$(this.context, "scrollAdjust", this.appliedAdjust);
+      set$(this.ctx, "scrollAdjust", this.appliedAdjust);
+    }
+    if (this.ctx.state.scrollingTo) {
+      checkFinishedScroll(this.ctx);
     }
-  }
-  setMounted() {
-    this.mounted = true;
   }
   getAdjust() {
     return this.appliedAdjust;
   }
+  commitPendingAdjust(scrollTarget) {
+    if (PlatformAdjustBreaksScroll) {
+      const state = this.ctx.state;
+      const pending = this.pendingAdjust;
+      this.pendingAdjust = 0;
+      if (pending !== 0) {
+        let targetScroll;
+        if ((scrollTarget == null ? void 0 : scrollTarget.index) !== void 0) {
+          const currentOffset = calculateOffsetForIndex(this.ctx, scrollTarget.index);
+          targetScroll = calculateOffsetWithOffsetPosition(this.ctx, currentOffset, scrollTarget);
+          targetScroll = clampScrollOffset(this.ctx, targetScroll, scrollTarget);
+        } else {
+          targetScroll = clampScrollOffset(this.ctx, state.scroll + pending);
+        }
+        const adjustment = targetScroll - state.scroll;
+        if (Math.abs(adjustment) > 0.1 || Math.abs(pending) > 0.1) {
+          this.appliedAdjust += adjustment;
+          state.scroll = targetScroll;
+          state.scrollForNextCalculateItemsInView = void 0;
+          set$(this.ctx, "scrollAdjust", this.appliedAdjust);
+        }
+        set$(this.ctx, "scrollAdjustPending", 0);
+        calculateItemsInView(this.ctx);
+      }
+    }
+  }
 };
 
 // src/core/updateItemSize.ts
-function updateItemSize(ctx, state, itemKey, sizeObj) {
+function runOrScheduleMVCPRecalculate(ctx) {
+  const state = ctx.state;
+  if (Platform2.OS === "web") {
+    if (!state.mvcpAnchorLock) {
+      if (state.queuedMVCPRecalculate !== void 0) {
+        cancelAnimationFrame(state.queuedMVCPRecalculate);
+        state.queuedMVCPRecalculate = void 0;
+      }
+      calculateItemsInView(ctx, { doMVCP: true });
+      return;
+    }
+    if (state.queuedMVCPRecalculate !== void 0) {
+      return;
+    }
+    state.queuedMVCPRecalculate = requestAnimationFrame(() => {
+      state.queuedMVCPRecalculate = void 0;
+      calculateItemsInView(ctx, { doMVCP: true });
+    });
+  } else {
+    calculateItemsInView(ctx, { doMVCP: true });
+  }
+}
+function updateItemSize(ctx, itemKey, sizeObj) {
   var _a3;
+  const state = ctx.state;
   const {
+    didContainersLayout,
     sizesKnown,
     props: {
       getFixedItemSize,
@@ -2782,31 +3358,24 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
       return;
     }
     const type = getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
-    const size2 = getFixedItemSize(index, itemData, type);
+    const size2 = getFixedItemSize(itemData, index, type);
     if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
       return;
     }
   }
-  const containersDidLayout = peek$(ctx, "containersDidLayout");
-  let needsRecalculate = !containersDidLayout;
+  let needsRecalculate = !didContainersLayout;
   let shouldMaintainScrollAtEnd = false;
   let minIndexSizeChanged;
   let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
   const prevSizeKnown = state.sizesKnown.get(itemKey);
-  const diff = updateOneItemSize(ctx, state, itemKey, sizeObj);
+  const diff = updateOneItemSize(ctx, itemKey, sizeObj);
   const size = roundSize(horizontal ? sizeObj.width : sizeObj.height);
   if (diff !== 0) {
     minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
     const { startBuffered, endBuffered } = state;
     needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
-    if (!needsRecalculate) {
-      const numContainers = ctx.values.get("numContainers");
-      for (let i = 0; i < numContainers; i++) {
-        if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
-          needsRecalculate = true;
-          break;
-        }
-      }
+    if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
+      needsRecalculate = true;
     }
     if (state.needsOtherAxisSize) {
       const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
@@ -2842,20 +3411,21 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
   if (!cur || maxOtherAxisSize > cur) {
     set$(ctx, "otherAxisSize", maxOtherAxisSize);
   }
-  if (containersDidLayout || checkAllSizesKnown(state)) {
+  if (didContainersLayout || checkAllSizesKnown(state)) {
     if (needsRecalculate) {
       state.scrollForNextCalculateItemsInView = void 0;
-      calculateItemsInView(ctx, state, { doMVCP: true });
+      runOrScheduleMVCPRecalculate(ctx);
     }
     if (shouldMaintainScrollAtEnd) {
       if (maintainScrollAtEnd === true || maintainScrollAtEnd.onItemLayout) {
-        doMaintainScrollAtEnd(ctx, state, false);
+        doMaintainScrollAtEnd(ctx, false);
       }
     }
   }
 }
-function updateOneItemSize(ctx, state, itemKey, sizeObj) {
+function updateOneItemSize(ctx, itemKey, sizeObj) {
   var _a3;
+  const state = ctx.state;
   const {
     indexByKey,
     sizesKnown,
@@ -2864,9 +3434,10 @@ function updateOneItemSize(ctx, state, itemKey, sizeObj) {
   } = state;
   if (!data) return 0;
   const index = indexByKey.get(itemKey);
-  const prevSize = getItemSize(ctx, state, itemKey, index, data[index]);
+  const prevSize = getItemSize(ctx, itemKey, index, data[index]);
   const rawSize = horizontal ? sizeObj.width : sizeObj.height;
   const size = Platform2.OS === "web" ? Math.round(rawSize) : roundSize(rawSize);
+  const prevSizeKnown = sizesKnown.get(itemKey);
   sizesKnown.set(itemKey, size);
   if (!getEstimatedItemSize && !getFixedItemSize && size > 0) {
     const itemType = getItemType ? (_a3 = getItemType(data[index], index)) != null ? _a3 : "" : "";
@@ -2874,15 +3445,28 @@ function updateOneItemSize(ctx, state, itemKey, sizeObj) {
     if (!averages) {
       averages = averageSizes[itemType] = { avg: 0, num: 0 };
     }
-    averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
-    averages.num++;
+    if (averages.num === 0) {
+      averages.avg = size;
+      averages.num++;
+    } else if (prevSizeKnown !== void 0 && prevSizeKnown > 0) {
+      averages.avg += (size - prevSizeKnown) / averages.num;
+    } else {
+      averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
+      averages.num++;
+    }
   }
   if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-    setSize(ctx, state, itemKey, size);
+    setSize(ctx, itemKey, size);
     return size - prevSize;
   }
   return 0;
 }
+function useWrapIfItem(fn) {
+  return React2.useMemo(
+    () => fn ? (arg1, arg2, arg3) => arg1 !== void 0 && arg2 !== void 0 ? fn(arg1, arg2, arg3) : void 0 : void 0,
+    [fn]
+  );
+}
 var useCombinedRef = (...refs) => {
   const callback = React2.useCallback((element) => {
     for (const ref of refs) {
@@ -2898,19 +3482,13 @@ var useCombinedRef = (...refs) => {
   }, refs);
   return callback;
 };
-function getWindowSize() {
-  const screenSize = reactNative.Dimensions.get("window");
-  return {
-    height: screenSize.height,
-    width: screenSize.width
-  };
-}
-var StyleSheet = reactNative.StyleSheet;
+var StyleSheet = ReactNative.StyleSheet;
 function useStickyScrollHandler(stickyHeaderIndices, horizontal, ctx, onScroll2) {
+  const shouldUseRnAnimatedEngine = !ctx.state.props.stickyPositionComponentInternal;
   return React2.useMemo(() => {
-    if (stickyHeaderIndices == null ? void 0 : stickyHeaderIndices.length) {
+    if ((stickyHeaderIndices == null ? void 0 : stickyHeaderIndices.length) && shouldUseRnAnimatedEngine) {
       const { animatedScrollY } = ctx;
-      return reactNative.Animated.event(
+      return ReactNative.Animated.event(
         [
           {
             nativeEvent: {
@@ -2925,7 +3503,7 @@ function useStickyScrollHandler(stickyHeaderIndices, horizontal, ctx, onScroll2)
       );
     }
     return onScroll2;
-  }, [stickyHeaderIndices == null ? void 0 : stickyHeaderIndices.join(","), horizontal]);
+  }, [stickyHeaderIndices == null ? void 0 : stickyHeaderIndices.join(","), horizontal, shouldUseRnAnimatedEngine]);
 }
 
 // src/utils/createColumnWrapperStyle.ts
@@ -2943,31 +3521,118 @@ 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, state) {
+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 runWhenSettled = (token, run) => {
+    const startedAt = Date.now();
+    let stableFrames = 0;
+    const check = () => {
+      if (token !== imperativeScrollToken) {
+        return;
+      }
+      if (isSettlingAfterDataChange()) {
+        stableFrames = 0;
+      } else {
+        stableFrames += 1;
+      }
+      const timedOut = Date.now() - startedAt >= IMPERATIVE_SCROLL_SETTLE_MAX_WAIT_MS;
+      if (stableFrames >= IMPERATIVE_SCROLL_SETTLE_STABLE_FRAMES || timedOut) {
+        run();
+        return;
+      }
+      requestAnimationFrame(check);
+    };
+    requestAnimationFrame(check);
+  };
+  const runScrollWithPromise = (run) => new Promise((resolve) => {
+    var _a3;
+    const token = ++imperativeScrollToken;
+    (_a3 = state.pendingScrollResolve) == null ? void 0 : _a3.call(state);
+    state.pendingScrollResolve = resolve;
+    const runNow = () => {
+      if (token !== imperativeScrollToken) {
+        return;
+      }
+      const didStartScroll = run();
+      if (!didStartScroll || !state.scrollingTo) {
+        if (state.pendingScrollResolve === resolve) {
+          state.pendingScrollResolve = void 0;
+        }
+        resolve();
+      }
+    };
+    if (isSettlingAfterDataChange()) {
+      runWhenSettled(token, runNow);
+      return;
+    }
+    runNow();
+  });
   const scrollIndexIntoView = (options) => {
     if (state) {
       const { index, ...rest } = options;
       const { startNoBuffer, endNoBuffer } = state;
       if (index < startNoBuffer || index > endNoBuffer) {
         const viewPosition = index < startNoBuffer ? 0 : 1;
-        scrollToIndex(ctx, state, {
+        scrollToIndex(ctx, {
           ...rest,
           index,
           viewPosition
         });
+        return true;
       }
     }
+    return false;
   };
   const refScroller = state.refScroller;
+  const clearCaches = (options) => {
+    var _a3, _b;
+    const mode = (_a3 = options == null ? void 0 : options.mode) != null ? _a3 : "sizes";
+    state.sizes.clear();
+    state.sizesKnown.clear();
+    for (const key in state.averageSizes) {
+      delete state.averageSizes[key];
+    }
+    state.minIndexSizeChanged = 0;
+    state.scrollForNextCalculateItemsInView = void 0;
+    state.pendingTotalSize = void 0;
+    state.totalSize = 0;
+    set$(ctx, "totalSize", 0);
+    if (mode === "full") {
+      state.indexByKey.clear();
+      state.idCache.length = 0;
+      state.positions.length = 0;
+      state.columns.length = 0;
+      state.columnSpans.length = 0;
+    }
+    (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
+  };
   return {
+    clearCaches,
     flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
     getNativeScrollRef: () => refScroller.current,
     getScrollableNode: () => refScroller.current.getScrollableNode(),
     getScrollResponder: () => refScroller.current.getScrollResponder(),
     getState: () => ({
-      activeStickyIndex: state.activeStickyIndex,
-      contentLength: state.totalSize,
+      activeStickyIndex: peek$(ctx, "activeStickyIndex"),
+      contentLength: getContentSize(ctx),
       data: state.props.data,
       elementAtIndex: (index) => {
         var _a3;
@@ -2977,47 +3642,71 @@ function createImperativeHandle(ctx, state) {
       endBuffered: state.endBuffered,
       isAtEnd: state.isAtEnd,
       isAtStart: state.isAtStart,
-      positionAtIndex: (index) => state.positions.get(getId(state, index)),
-      positions: state.positions,
+      isEndReached: state.isEndReached,
+      isStartReached: state.isStartReached,
+      listen: (signalName, cb) => listen$(ctx, signalName, cb),
+      listenToPosition: (key, cb) => listenPosition$(ctx, key, cb),
+      positionAtIndex: (index) => state.positions[index],
+      positionByKey: (key) => {
+        const index = state.indexByKey.get(key);
+        return index === void 0 ? void 0 : state.positions[index];
+      },
       scroll: state.scroll,
       scrollLength: state.scrollLength,
+      scrollVelocity: getScrollVelocity(state),
       sizeAtIndex: (index) => state.sizesKnown.get(getId(state, index)),
       sizes: state.sizesKnown,
       start: state.startNoBuffer,
       startBuffered: state.startBuffered
     }),
-    scrollIndexIntoView,
-    scrollItemIntoView: ({ item, ...props }) => {
+    reportContentInset: (inset) => {
+      state.contentInsetOverride = inset != null ? inset : void 0;
+      updateScroll(ctx, state.scroll, true);
+    },
+    scrollIndexIntoView: (options) => runScrollWithPromise(() => scrollIndexIntoView(options)),
+    scrollItemIntoView: ({ item, ...props }) => runScrollWithPromise(() => {
       const data = state.props.data;
       const index = data.indexOf(item);
       if (index !== -1) {
         scrollIndexIntoView({ index, ...props });
+        return true;
       }
-    },
-    scrollToEnd: (options) => {
+      return false;
+    }),
+    scrollToEnd: (options) => runScrollWithPromise(() => {
       const data = state.props.data;
       const stylePaddingBottom = state.props.stylePaddingBottom;
       const index = data.length - 1;
       if (index !== -1) {
         const paddingBottom = stylePaddingBottom || 0;
         const footerSize = peek$(ctx, "footerSize") || 0;
-        scrollToIndex(ctx, state, {
+        scrollToIndex(ctx, {
+          ...options,
           index,
           viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
-          viewPosition: 1,
-          ...options
+          viewPosition: 1
         });
+        return true;
       }
-    },
-    scrollToIndex: (params) => scrollToIndex(ctx, state, params),
-    scrollToItem: ({ item, ...props }) => {
+      return false;
+    }),
+    scrollToIndex: (params) => runScrollWithPromise(() => {
+      scrollToIndex(ctx, params);
+      return true;
+    }),
+    scrollToItem: ({ item, ...props }) => runScrollWithPromise(() => {
       const data = state.props.data;
       const index = data.indexOf(item);
       if (index !== -1) {
-        scrollToIndex(ctx, state, { index, ...props });
+        scrollToIndex(ctx, { index, ...props });
+        return true;
       }
-    },
-    scrollToOffset: (params) => scrollTo(ctx, state, params),
+      return false;
+    }),
+    scrollToOffset: (params) => runScrollWithPromise(() => {
+      scrollTo(ctx, params);
+      return true;
+    }),
     setScrollProcessingEnabled: (enabled) => {
       state.scrollProcessingEnabled = enabled;
     },
@@ -3027,8 +3716,57 @@ function createImperativeHandle(ctx, state) {
     }
   };
 }
-function getRenderedItem(ctx, state, key) {
+
+// src/utils/getAlwaysRenderIndices.ts
+var sortAsc = (a, b) => a - b;
+var toCount = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+var addIndex = (result, dataLength, index) => {
+  if (index >= 0 && index < dataLength) {
+    result.add(index);
+  }
+};
+function getAlwaysRenderIndices(config, data, keyExtractor) {
+  var _a3, _b;
+  if (!config || data.length === 0) {
+    return [];
+  }
+  const result = /* @__PURE__ */ new Set();
+  const dataLength = data.length;
+  const topCount = toCount(config.top);
+  if (topCount > 0) {
+    for (let i = 0; i < Math.min(topCount, dataLength); i++) {
+      addIndex(result, dataLength, i);
+    }
+  }
+  const bottomCount = toCount(config.bottom);
+  if (bottomCount > 0) {
+    for (let i = Math.max(0, dataLength - bottomCount); i < dataLength; i++) {
+      addIndex(result, dataLength, i);
+    }
+  }
+  if ((_a3 = config.indices) == null ? void 0 : _a3.length) {
+    for (const index of config.indices) {
+      if (!Number.isFinite(index)) continue;
+      addIndex(result, dataLength, Math.floor(index));
+    }
+  }
+  if ((_b = config.keys) == null ? void 0 : _b.length) {
+    const keys = new Set(config.keys);
+    for (let i = 0; i < dataLength && keys.size > 0; i++) {
+      const key = keyExtractor(data[i], i);
+      if (keys.has(key)) {
+        addIndex(result, dataLength, i);
+        keys.delete(key);
+      }
+    }
+  }
+  const indices = Array.from(result);
+  indices.sort(sortAsc);
+  return indices;
+}
+function getRenderedItem(ctx, key) {
   var _a3;
+  const state = ctx.state;
   if (!state) {
     return null;
   }
@@ -3055,6 +3793,42 @@ function getRenderedItem(ctx, state, key) {
   }
   return { index, item: data[index], renderedItem };
 }
+
+// src/utils/normalizeMaintainVisibleContentPosition.ts
+function normalizeMaintainVisibleContentPosition(value) {
+  var _a3, _b;
+  if (value === true) {
+    return { data: true, size: true };
+  }
+  if (value && typeof value === "object") {
+    return {
+      data: (_a3 = value.data) != null ? _a3 : false,
+      shouldRestorePosition: value.shouldRestorePosition,
+      size: (_b = value.size) != null ? _b : true
+    };
+  }
+  if (value === false) {
+    return { data: false, size: false };
+  }
+  return { data: false, size: true };
+}
+
+// src/utils/setPaddingTop.ts
+function setPaddingTop(ctx, { stylePaddingTop }) {
+  const state = ctx.state;
+  if (stylePaddingTop !== void 0) {
+    const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
+    if (stylePaddingTop < prevStylePaddingTop) {
+      let prevTotalSize = peek$(ctx, "totalSize") || 0;
+      set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
+      state.timeoutSetPaddingTop = setTimeout(() => {
+        prevTotalSize = peek$(ctx, "totalSize") || 0;
+        set$(ctx, "totalSize", prevTotalSize - prevStylePaddingTop);
+      }, 16);
+    }
+    set$(ctx, "stylePaddingTop", stylePaddingTop);
+  }
+}
 function useThrottleDebounce(mode) {
   const timeoutRef = React2.useRef(null);
   const lastCallTimeRef = React2.useRef(0);
@@ -3102,9 +3876,8 @@ function useThrottledOnScroll(originalHandler, scrollEventThrottle) {
 }
 
 // src/components/LegendList.tsx
-var DEFAULT_DRAW_DISTANCE = 250;
-var DEFAULT_ITEM_SIZE = 100;
-var LegendList = typedMemo(
+var LegendList = typedMemo2(
+  // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
   typedForwardRef(function LegendList2(props, forwardedRef) {
     const { children, data: dataProp, renderItem: renderItemProp, ...restProps } = props;
     const isChildrenMode = children !== void 0 && dataProp === void 0;
@@ -3122,16 +3895,17 @@ var LegendList = typedMemo(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b;
+  var _a3, _b, _c, _d, _e;
   const {
     alignItemsAtEnd = false,
+    alwaysRender,
     columnWrapperStyle,
     contentContainerStyle: contentContainerStyleProp,
+    contentInset,
     data: dataProp = [],
     dataVersion,
     drawDistance = 250,
-    enableAverages = true,
-    estimatedItemSize: estimatedItemSizeProp,
+    estimatedItemSize = 100,
     estimatedListSize,
     extraData,
     getEstimatedItemSize,
@@ -3148,11 +3922,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     ListHeaderComponent,
     maintainScrollAtEnd = false,
     maintainScrollAtEndThreshold = 0.1,
-    maintainVisibleContentPosition = false,
+    maintainVisibleContentPosition: maintainVisibleContentPositionProp,
     numColumns: numColumnsProp = 1,
+    overrideItemLayout,
     onEndReached,
     onEndReachedThreshold = 0.5,
     onItemSizeChanged,
+    onMetricsChange,
     onLayout: onLayoutProp,
     onLoad,
     onMomentumScrollEnd,
@@ -3167,50 +3943,102 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     refreshControl,
     refreshing,
     refScrollView,
+    renderScrollComponent,
     renderItem,
     scrollEventThrottle,
     snapToIndices,
     stickyHeaderIndices: stickyHeaderIndicesProp,
     stickyIndices: stickyIndicesDeprecated,
+    // TODOV3: Remove from v3 release
     style: styleProp,
     suggestEstimatedItemSize,
+    useWindowScroll = false,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
     waitForInitialLayout = true,
     ...rest
   } = props;
-  const { childrenMode } = rest;
-  const contentContainerStyle = { ...StyleSheet.flatten(contentContainerStyleProp) };
+  const animatedPropsInternal = props.animatedPropsInternal;
+  const positionComponentInternal = props.positionComponentInternal;
+  const stickyPositionComponentInternal = props.stickyPositionComponentInternal;
+  const {
+    childrenMode,
+    positionComponentInternal: _positionComponentInternal,
+    stickyPositionComponentInternal: _stickyPositionComponentInternal,
+    ...restProps
+  } = rest;
+  const contentContainerStyleBase = StyleSheet.flatten(contentContainerStyleProp);
+  const shouldFlexGrow = alignItemsAtEnd && (horizontal ? (contentContainerStyleBase == null ? void 0 : contentContainerStyleBase.minWidth) == null : (contentContainerStyleBase == null ? void 0 : contentContainerStyleBase.minHeight) == null);
+  const contentContainerStyle = {
+    ...contentContainerStyleBase,
+    ...alignItemsAtEnd ? {
+      display: "flex",
+      flexDirection: horizontal ? "row" : "column",
+      ...shouldFlexGrow ? { flexGrow: 1 } : {},
+      justifyContent: "flex-end"
+    } : {}
+  };
   const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
   const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
-  const [renderNum, setRenderNum] = React2.useState(0);
-  const initialScrollProp = initialScrollAtEnd ? { index: Math.max(0, dataProp.length - 1), viewOffset: -stylePaddingBottomState } : initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? { index: initialScrollIndexProp.index || 0, viewOffset: initialScrollIndexProp.viewOffset || 0 } : { index: initialScrollIndexProp || 0, viewOffset: initialScrollOffsetProp || 0 } : void 0;
+  const maintainVisibleContentPositionConfig = normalizeMaintainVisibleContentPosition(
+    maintainVisibleContentPositionProp
+  );
+  const initialScrollProp = initialScrollAtEnd ? { index: Math.max(0, dataProp.length - 1), viewOffset: -stylePaddingBottomState, viewPosition: 1 } : initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? {
+    index: initialScrollIndexProp.index || 0,
+    viewOffset: initialScrollIndexProp.viewOffset || (initialScrollIndexProp.viewPosition === 1 ? -stylePaddingBottomState : 0),
+    viewPosition: initialScrollIndexProp.viewPosition || 0
+  } : {
+    index: initialScrollIndexProp || 0,
+    viewOffset: initialScrollOffsetProp || 0
+  } : void 0;
   const [canRender, setCanRender] = React2__namespace.useState(!IsNewArchitecture);
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
   const refScroller = React2.useRef(null);
   const combinedRef = useCombinedRef(refScroller, refScrollView);
-  const estimatedItemSize = estimatedItemSizeProp != null ? estimatedItemSizeProp : DEFAULT_ITEM_SIZE;
-  const scrollBuffer = (drawDistance != null ? drawDistance : DEFAULT_DRAW_DISTANCE) || 1;
-  const keyExtractor = keyExtractorProp != null ? keyExtractorProp : (_item, index) => index.toString();
+  const keyExtractor = keyExtractorProp != null ? keyExtractorProp : ((_item, index) => index.toString());
   const stickyHeaderIndices = stickyHeaderIndicesProp != null ? stickyHeaderIndicesProp : stickyIndicesDeprecated;
+  const alwaysRenderIndices = React2.useMemo(() => {
+    const indices = getAlwaysRenderIndices(alwaysRender, dataProp, keyExtractor);
+    return { arr: indices, set: new Set(indices) };
+  }, [
+    alwaysRender == null ? void 0 : alwaysRender.top,
+    alwaysRender == null ? void 0 : alwaysRender.bottom,
+    (_a3 = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _a3.join(","),
+    (_b = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _b.join(","),
+    dataProp,
+    dataVersion,
+    keyExtractor
+  ]);
   if (IS_DEV && stickyIndicesDeprecated && !stickyHeaderIndicesProp) {
     warnDevOnce(
       "stickyIndices",
       "stickyIndices has been renamed to stickyHeaderIndices. Please update your props to use stickyHeaderIndices."
     );
   }
-  const refState = React2.useRef();
+  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;
+  const prevHasOverrideItemLayout = React2.useRef(hasOverrideItemLayout);
   if (!refState.current) {
-    if (!ctx.internalState) {
+    if (!ctx.state) {
       const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { height: 0, width: 0 } : getWindowSize())[horizontal ? "width" : "height"];
-      ctx.internalState = {
-        activeStickyIndex: void 0,
+      ctx.state = {
+        activeStickyIndex: -1,
         averageSizes: {},
-        columns: /* @__PURE__ */ new Map(),
-        containerItemKeys: /* @__PURE__ */ new Set(),
+        columnSpans: [],
+        columns: [],
+        containerItemKeys: /* @__PURE__ */ new Map(),
         containerItemTypes: /* @__PURE__ */ new Map(),
+        contentInsetOverride: void 0,
+        dataChangeEpoch: 0,
         dataChangeNeedsScrollUpdate: false,
         didColumnsChange: false,
         didDataChange: false,
@@ -3226,24 +4054,26 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
           attempts: 0,
           index: initialScrollProp.index,
           settledTicks: 0,
-          viewOffset: (_a3 = initialScrollProp.viewOffset) != null ? _a3 : 0,
+          viewOffset: (_c = initialScrollProp.viewOffset) != null ? _c : 0,
           viewPosition: initialScrollProp.viewPosition
         } : void 0,
         initialScroll: initialScrollProp,
         isAtEnd: false,
         isAtStart: false,
-        isEndReached: false,
+        isEndReached: null,
         isFirst: true,
-        isStartReached: false,
+        isStartReached: null,
         lastBatchingAction: Date.now(),
         lastLayout: void 0,
+        lastScrollDelta: 0,
         loadStartTime: Date.now(),
         minIndexSizeChanged: 0,
+        nativeContentInset: void 0,
         nativeMarginTop: 0,
-        positions: /* @__PURE__ */ new Map(),
+        positions: [],
         props: {},
         queuedCalculateItemsInView: 0,
-        refScroller: void 0,
+        refScroller: { current: null },
         scroll: 0,
         scrollAdjustHandler: new ScrollAdjustHandler(ctx),
         scrollForNextCalculateItemsInView: void 0,
@@ -3259,6 +4089,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         startBuffered: -1,
         startNoBuffer: -1,
         startReachedSnapshot: void 0,
+        startReachedSnapshotDataChangeEpoch: void 0,
         stickyContainerPool: /* @__PURE__ */ new Set(),
         stickyContainers: /* @__PURE__ */ new Map(),
         timeoutSizeMessage: 0,
@@ -3266,18 +4097,19 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         totalSize: 0,
         viewabilityConfigCallbackPairs: void 0
       };
-      const internalState = ctx.internalState;
-      internalState.triggerCalculateItemsInView = (params) => calculateItemsInView(ctx, internalState, params);
-      set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
+      const internalState = ctx.state;
+      internalState.triggerCalculateItemsInView = (params) => calculateItemsInView(ctx, params);
+      set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPositionConfig);
       set$(ctx, "extraData", extraData);
     }
-    refState.current = ctx.internalState;
+    refState.current = ctx.state;
   }
   const state = refState.current;
   const isFirstLocal = state.isFirst;
   state.didColumnsChange = numColumnsProp !== state.props.numColumns;
   const didDataChangeLocal = state.props.dataVersion !== dataVersion || state.props.data !== dataProp && checkActualChange(state, dataProp, state.props.data);
   if (didDataChangeLocal) {
+    state.dataChangeEpoch += 1;
     state.dataChangeNeedsScrollUpdate = true;
     state.didDataChange = true;
     state.previousData = state.props.data;
@@ -3285,20 +4117,25 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? useThrottledOnScroll(onScrollProp, scrollEventThrottle) : onScrollProp;
   state.props = {
     alignItemsAtEnd,
+    alwaysRender,
+    alwaysRenderIndicesArr: alwaysRenderIndices.arr,
+    alwaysRenderIndicesSet: alwaysRenderIndices.set,
+    animatedProps: animatedPropsInternal,
+    contentInset,
     data: dataProp,
     dataVersion,
-    enableAverages,
+    drawDistance,
     estimatedItemSize,
-    getEstimatedItemSize,
-    getFixedItemSize,
-    getItemType,
+    getEstimatedItemSize: useWrapIfItem(getEstimatedItemSize),
+    getFixedItemSize: useWrapIfItem(getFixedItemSize),
+    getItemType: useWrapIfItem(getItemType),
     horizontal: !!horizontal,
     initialContainerPoolRatio,
     itemsAreEqual,
-    keyExtractor,
+    keyExtractor: useWrapIfItem(keyExtractor),
     maintainScrollAtEnd,
     maintainScrollAtEndThreshold,
-    maintainVisibleContentPosition,
+    maintainVisibleContentPosition: maintainVisibleContentPositionConfig,
     numColumns: numColumnsProp,
     onEndReached,
     onEndReachedThreshold,
@@ -3308,15 +4145,18 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onStartReached,
     onStartReachedThreshold,
     onStickyHeaderChange,
+    overrideItemLayout,
+    positionComponentInternal,
     recycleItems: !!recycleItems,
     renderItem,
-    scrollBuffer,
     snapToIndices,
     stickyIndicesArr: stickyHeaderIndices != null ? stickyHeaderIndices : [],
     stickyIndicesSet: React2.useMemo(() => new Set(stickyHeaderIndices != null ? stickyHeaderIndices : []), [stickyHeaderIndices == null ? void 0 : stickyHeaderIndices.join(",")]),
+    stickyPositionComponentInternal,
     stylePaddingBottom: stylePaddingBottomState,
     stylePaddingTop: stylePaddingTopState,
-    suggestEstimatedItemSize: !!suggestEstimatedItemSize
+    suggestEstimatedItemSize: !!suggestEstimatedItemSize,
+    useWindowScroll: useWindowScrollResolved
   };
   state.refScroller = refScroller;
   const memoizedLastItemKeys = React2.useMemo(() => {
@@ -3326,62 +4166,65 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       (_, i) => getId(state, dataProp.length - 1 - i)
     );
   }, [dataProp, dataVersion, numColumnsProp]);
-  const initializeStateVars = () => {
+  const initializeStateVars = (shouldAdjustPadding) => {
     set$(ctx, "lastItemKeys", memoizedLastItemKeys);
     set$(ctx, "numColumns", numColumnsProp);
     const prevPaddingTop = peek$(ctx, "stylePaddingTop");
-    setPaddingTop(ctx, state, { stylePaddingTop: stylePaddingTopState });
+    setPaddingTop(ctx, { stylePaddingTop: stylePaddingTopState });
     refState.current.props.stylePaddingBottom = stylePaddingBottomState;
     let paddingDiff = stylePaddingTopState - prevPaddingTop;
-    if (paddingDiff && prevPaddingTop !== void 0 && Platform2.OS === "ios") {
+    if (shouldAdjustPadding && maintainVisibleContentPositionConfig.size && paddingDiff && prevPaddingTop !== void 0 && Platform2.OS === "ios") {
       if (state.scroll < 0) {
         paddingDiff += state.scroll;
       }
-      requestAdjust(ctx, state, paddingDiff);
+      requestAdjust(ctx, paddingDiff);
     }
   };
   if (isFirstLocal) {
-    initializeStateVars();
+    initializeStateVars(false);
     updateItemPositions(
       ctx,
-      state,
       /*dataChanged*/
       true
     );
   }
+  const resolveInitialScrollOffset = React2.useCallback((initialScroll) => {
+    const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
+    const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
+    return clampScrollOffset(ctx, resolvedOffset, initialScroll);
+  }, []);
   const initialContentOffset = React2.useMemo(() => {
-    var _a4, _b2;
-    const { initialScroll } = refState.current;
-    if (!initialScroll) {
+    var _a4;
+    let value;
+    const { initialScroll, initialAnchor } = refState.current;
+    if (initialScroll) {
+      if (!IsNewArchitecture && initialScroll.index !== void 0 && (!initialAnchor || (initialAnchor == null ? void 0 : initialAnchor.index) !== initialScroll.index)) {
+        refState.current.initialAnchor = {
+          attempts: 0,
+          index: initialScroll.index,
+          settledTicks: 0,
+          viewOffset: (_a4 = initialScroll.viewOffset) != null ? _a4 : 0,
+          viewPosition: initialScroll.viewPosition
+        };
+      }
+      if (initialScroll.contentOffset !== void 0) {
+        value = initialScroll.contentOffset;
+      } else {
+        const clampedOffset = resolveInitialScrollOffset(initialScroll);
+        const updatedInitialScroll = { ...initialScroll, contentOffset: clampedOffset };
+        refState.current.initialScroll = updatedInitialScroll;
+        state.initialScroll = updatedInitialScroll;
+        value = clampedOffset;
+      }
+    } else {
       refState.current.initialAnchor = void 0;
-      return 0;
+      value = 0;
     }
-    if (initialScroll.index !== void 0 && (!refState.current.initialAnchor || ((_a4 = refState.current.initialAnchor) == null ? void 0 : _a4.index) !== initialScroll.index)) {
-      refState.current.initialAnchor = {
-        attempts: 0,
-        index: initialScroll.index,
-        settledTicks: 0,
-        viewOffset: (_b2 = initialScroll.viewOffset) != null ? _b2 : 0,
-        viewPosition: initialScroll.viewPosition
-      };
+    if (!value) {
+      setInitialRenderState(ctx, { didInitialScroll: true });
     }
-    if (initialScroll.contentOffset !== void 0) {
-      return initialScroll.contentOffset;
-    }
-    const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, state, initialScroll.index) : 0;
-    const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, state, baseOffset, initialScroll);
-    let clampedOffset = resolvedOffset;
-    if (Number.isFinite(state.scrollLength) && Number.isFinite(state.totalSize)) {
-      const maxOffset = Math.max(0, state.totalSize - state.scrollLength);
-      clampedOffset = Math.min(clampedOffset, maxOffset);
-    }
-    clampedOffset = Math.max(0, clampedOffset);
-    const updatedInitialScroll = { ...initialScroll, contentOffset: clampedOffset };
-    refState.current.initialScroll = updatedInitialScroll;
-    state.initialScroll = updatedInitialScroll;
-    refState.current.isStartReached = clampedOffset < refState.current.scrollLength * onStartReachedThreshold;
-    return clampedOffset;
-  }, [renderNum]);
+    return value;
+  }, []);
   if (isFirstLocal || didDataChangeLocal || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirstLocal && didDataChangeLocal) {
@@ -3390,41 +4233,53 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
       );
       refState.current.sizes.clear();
-      refState.current.positions.clear();
+      refState.current.positions.length = 0;
       refState.current.totalSize = 0;
       set$(ctx, "totalSize", 0);
     }
   }
-  const onLayoutHeader = React2.useCallback((rect, fromLayoutEffect) => {
-    const { initialScroll } = refState.current;
-    const size = rect[horizontal ? "width" : "height"];
-    set$(ctx, "headerSize", size);
-    if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
-      if (IsNewArchitecture && Platform2.OS !== "android") {
-        if (fromLayoutEffect) {
-          setRenderNum((v) => v + 1);
-        }
-      } else {
-        setTimeout(doInitialScroll, 17);
-      }
-    }
-  }, []);
   const doInitialScroll = React2.useCallback(() => {
-    var _a4;
-    const initialScroll = state.initialScroll;
-    if (initialScroll) {
-      scrollTo(ctx, state, {
+    const { initialScroll, didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
+    if (initialScroll && !queuedInitialLayout && !didFinishInitialScroll && !scrollingTo) {
+      const offset = resolveInitialScrollOffset(initialScroll);
+      const updatedInitialScroll = { ...initialScroll, contentOffset: offset };
+      refState.current.initialScroll = updatedInitialScroll;
+      state.initialScroll = updatedInitialScroll;
+      scrollTo(ctx, {
         animated: false,
-        index: (_a4 = state.initialScroll) == null ? void 0 : _a4.index,
+        index: initialScroll.index,
         isInitialScroll: true,
-        offset: initialContentOffset,
+        offset,
         precomputedWithViewOffset: true
       });
     }
-  }, [initialContentOffset]);
+  }, []);
+  const onLayoutFooter = React2.useCallback(
+    (layout) => {
+      if (!initialScrollAtEnd) {
+        return;
+      }
+      const { initialScroll } = state;
+      if (!initialScroll) {
+        return;
+      }
+      const lastIndex = Math.max(0, dataProp.length - 1);
+      if (initialScroll.index !== lastIndex || initialScroll.viewPosition !== 1) {
+        return;
+      }
+      const footerSize = layout[horizontal ? "width" : "height"];
+      const viewOffset = -stylePaddingBottomState - footerSize;
+      if (initialScroll.viewOffset !== viewOffset) {
+        const updatedInitialScroll = { ...initialScroll, viewOffset };
+        refState.current.initialScroll = updatedInitialScroll;
+        state.initialScroll = updatedInitialScroll;
+      }
+    },
+    [dataProp.length, horizontal, initialScrollAtEnd, stylePaddingBottomState]
+  );
   const onLayoutChange = React2.useCallback((layout) => {
     doInitialScroll();
-    handleLayout(ctx, state, layout, setCanRender);
+    handleLayout(ctx, layout, setCanRender);
   }, []);
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
@@ -3434,7 +4289,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   });
   React2.useLayoutEffect(() => {
     if (snapToIndices) {
-      updateSnapToOffsets(ctx, state);
+      updateSnapToOffsets(ctx);
     }
   }, [snapToIndices]);
   React2.useLayoutEffect(() => {
@@ -3444,24 +4299,50 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       isFirst,
       props: { data }
     } = state;
-    const didAllocateContainers = data.length > 0 && doInitialAllocateContainers(ctx, state, !!(didDataChange || didColumnsChange));
+    const didAllocateContainers = data.length > 0 && doInitialAllocateContainers(ctx);
     if (!didAllocateContainers && !isFirst && (didDataChange || didColumnsChange)) {
-      checkResetContainers(ctx, state, data);
+      checkResetContainers(ctx, data);
     }
     state.didColumnsChange = false;
     state.didDataChange = false;
     state.isFirst = false;
   }, [dataProp, dataVersion, numColumnsProp]);
   React2.useLayoutEffect(() => {
+    var _a4;
     set$(ctx, "extraData", extraData);
-  }, [extraData]);
-  React2.useLayoutEffect(initializeStateVars, [
-    dataVersion,
-    memoizedLastItemKeys.join(","),
-    numColumnsProp,
-    stylePaddingBottomState,
-    stylePaddingTopState
-  ]);
+    const didToggleOverride = prevHasOverrideItemLayout.current !== hasOverrideItemLayout;
+    prevHasOverrideItemLayout.current = hasOverrideItemLayout;
+    if ((hasOverrideItemLayout || didToggleOverride) && numColumnsProp > 1) {
+      (_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;
+    }
+    let lastMetrics;
+    const emitMetrics = () => {
+      const metrics = {
+        footerSize: peek$(ctx, "footerSize") || 0,
+        headerSize: peek$(ctx, "headerSize") || 0
+      };
+      if (!lastMetrics || metrics.headerSize !== lastMetrics.headerSize || metrics.footerSize !== lastMetrics.footerSize) {
+        lastMetrics = metrics;
+        onMetricsChange(metrics);
+      }
+    };
+    emitMetrics();
+    const unsubscribe = [listen$(ctx, "headerSize", emitMetrics), listen$(ctx, "footerSize", emitMetrics)];
+    return () => {
+      for (const unsub of unsubscribe) {
+        unsub();
+      }
+    };
+  }, [ctx, onMetricsChange]);
   React2.useEffect(() => {
     const viewability = setupViewability({
       onViewableItemsChanged,
@@ -3471,54 +4352,53 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  React2.useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, state), []);
+  if (!IsNewArchitecture) {
+    useInit(() => {
+      doInitialAllocateContainers(ctx);
+    });
+  }
+  React2.useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx), []);
   if (Platform2.OS === "web") {
     React2.useEffect(doInitialScroll, []);
   }
   const fns = React2.useMemo(
     () => ({
-      getRenderedItem: (key) => getRenderedItem(ctx, state, key),
-      onScroll: (event) => onScroll(ctx, state, event),
-      updateItemSize: (itemKey, sizeObj) => updateItemSize(ctx, state, itemKey, sizeObj)
+      getRenderedItem: (key) => getRenderedItem(ctx, key),
+      onMomentumScrollEnd: (event) => {
+        checkFinishedScrollFallback(ctx);
+        if (onMomentumScrollEnd) {
+          onMomentumScrollEnd(event);
+        }
+      },
+      onScroll: (event) => onScroll(ctx, event),
+      updateItemSize: (itemKey, sizeObj) => updateItemSize(ctx, itemKey, sizeObj)
     }),
     []
   );
   const onScrollHandler = useStickyScrollHandler(stickyHeaderIndices, horizontal, ctx, fns.onScroll);
+  const refreshControlElement = refreshControl;
   return /* @__PURE__ */ React2__namespace.createElement(React2__namespace.Fragment, null, /* @__PURE__ */ React2__namespace.createElement(
     ListComponent,
     {
-      ...rest,
+      ...restProps,
       alignItemsAtEnd,
       canRender,
       contentContainerStyle,
+      contentInset,
       getRenderedItem: fns.getRenderedItem,
       horizontal,
       initialContentOffset,
       ListEmptyComponent: dataProp.length === 0 ? ListEmptyComponent : void 0,
       ListHeaderComponent,
-      maintainVisibleContentPosition,
       onLayout,
-      onLayoutHeader,
-      onMomentumScrollEnd: (event) => {
-        if (IsNewArchitecture) {
-          requestAnimationFrame(() => {
-            finishScrollTo(ctx, refState.current);
-          });
-        } else {
-          setTimeout(() => {
-            finishScrollTo(ctx, refState.current);
-          }, 1e3);
-        }
-        if (onMomentumScrollEnd) {
-          onMomentumScrollEnd(event);
-        }
-      },
+      onLayoutFooter,
+      onMomentumScrollEnd: fns.onMomentumScrollEnd,
       onScroll: onScrollHandler,
       recycleItems,
-      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React2__namespace.cloneElement(refreshControl, {
-        progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState
-      }) : refreshControl : onRefresh && /* @__PURE__ */ React2__namespace.createElement(
-        reactNative.RefreshControl,
+      refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2__namespace.cloneElement(refreshControlElement, {
+        progressViewOffset: ((_d = refreshControlElement.props.progressViewOffset) != null ? _d : 0) + stylePaddingTopState
+      }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2__namespace.createElement(
+        ReactNative.RefreshControl,
         {
           onRefresh,
           progressViewOffset: (progressViewOffset || 0) + stylePaddingTopState,
@@ -3526,18 +4406,30 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         }
       ),
       refScrollView: combinedRef,
-      scrollAdjustHandler: (_b = refState.current) == null ? void 0 : _b.scrollAdjustHandler,
-      scrollEventThrottle: Platform2.OS === "web" ? 16 : void 0,
+      renderScrollComponent,
+      scrollAdjustHandler: (_e = refState.current) == null ? void 0 : _e.scrollAdjustHandler,
+      scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,
       style,
       updateItemSize: fns.updateItemSize,
+      useWindowScroll: useWindowScrollResolved,
       waitForInitialLayout
     }
-  ), IS_DEV && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React2__namespace.createElement(DebugView, { state: refState.current }));
+  ), IS_DEV && ENABLE_DEBUG_VIEW);
 });
 
-exports.LegendList = LegendList;
+// src/index.ts
+var LegendList3 = LegendList;
+if (IS_DEV) {
+  console.warn(
+    "[legend-list] Legend List 3.0 deprecates the root import (@legendapp/list) because it now supports both react and react-native. The root import is fully functional, but please switch to platform-specific imports for strict platform types:\n  - React Native: @legendapp/list/react-native\n  - React: @legendapp/list/react\nSee README for details."
+  );
+}
+
+exports.LegendList = LegendList3;
+exports.typedForwardRef = typedForwardRef;
+exports.typedMemo = typedMemo2;
 exports.useIsLastItem = useIsLastItem;
 exports.useListScrollSize = useListScrollSize;
 exports.useRecyclingEffect = useRecyclingEffect;