@legendapp/list 3.0.0-beta.2 → 3.0.0-beta.20

package/index.mjs

@@ -1,7 +1,7 @@
 import * as React3 from 'react';
 import React3__default, { forwardRef, useReducer, useEffect, createContext, useRef, useState, useMemo, useCallback, useImperativeHandle, useLayoutEffect, memo, useContext } from 'react';
 import { useSyncExternalStore } from 'use-sync-external-store/shim';
-import { unstable_batchedUpdates } from 'react-dom';
+import { unstable_batchedUpdates, flushSync } from 'react-dom';
 
 // src/components/LegendList.tsx
 forwardRef(function AnimatedView2(props, ref) {
@@ -12,31 +12,65 @@ var View = forwardRef(function View2(props, ref) {
 });
 var Text = View;
 
+// src/state/getContentInsetEnd.ts
+function getContentInsetEnd(state) {
+  var _a3;
+  const { props } = state;
+  const horizontal = props.horizontal;
+  let contentInset = props.contentInset;
+  if (!contentInset) {
+    const animatedInset = (_a3 = props.animatedProps) == null ? void 0 : _a3.contentInset;
+    if (animatedInset) {
+      if ("get" in animatedInset) {
+        contentInset = animatedInset.get();
+      } else {
+        contentInset = animatedInset;
+      }
+    }
+  }
+  return (horizontal ? contentInset == null ? void 0 : contentInset.right : contentInset == null ? void 0 : contentInset.bottom) || 0;
+}
+
+// src/state/getContentSize.ts
+function getContentSize(ctx) {
+  var _a3;
+  const { values, state } = ctx;
+  const stylePaddingTop = values.get("stylePaddingTop") || 0;
+  const stylePaddingBottom = state.props.stylePaddingBottom || 0;
+  const headerSize = values.get("headerSize") || 0;
+  const footerSize = values.get("footerSize") || 0;
+  const contentInsetBottom = getContentInsetEnd(state);
+  const totalSize = (_a3 = state.pendingTotalSize) != null ? _a3 : values.get("totalSize");
+  return headerSize + footerSize + totalSize + stylePaddingTop + stylePaddingBottom + (contentInsetBottom || 0);
+}
+
 // src/platform/Animated.tsx
 var createAnimatedValue = (value) => value;
 
 // src/state/state.tsx
 var ContextState = React3.createContext(null);
+var contextNum = 0;
 function StateProvider({ children }) {
   const [value] = React3.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()
   }));
@@ -104,15 +138,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 = React3.useContext(ContextState);
@@ -223,6 +266,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}`);
@@ -234,12 +282,12 @@ function findContainerId(ctx, key) {
 }
 
 // src/components/PositionView.tsx
-var PositionViewState = typedMemo(function PositionView({
+var PositionViewState = typedMemo(function PositionViewState2({
   id,
   horizontal,
   style,
   refView,
-  ...rest
+  ...props
 }) {
   const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
   const base = {
@@ -247,7 +295,8 @@ var PositionViewState = typedMemo(function PositionView({
   };
   const composed = isArray(style) ? Object.assign({}, ...style) : style;
   const combinedStyle = horizontal ? { ...base, ...composed, left: position } : { ...base, ...composed, top: position };
-  return /* @__PURE__ */ React3.createElement("div", { ref: refView, style: combinedStyle, ...rest });
+  const { animatedScrollY, stickyOffset, onLayout, ...webProps } = props;
+  return /* @__PURE__ */ React3.createElement("div", { ref: refView, ...webProps, style: combinedStyle });
 });
 var PositionViewSticky = typedMemo(function PositionViewSticky2({
   id,
@@ -292,63 +341,80 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
   }, [composed, horizontal, position, index, stickyOffset, headerSize, activeStickyIndex]);
   return /* @__PURE__ */ React3.createElement("div", { ref: refView, style: viewStyle, ...rest }, children);
 });
-var PositionView2 = PositionViewState;
+var PositionView = PositionViewState;
 
 // src/constants-platform.ts
 var IsNewArchitecture = true;
-var symbolFirst = Symbol();
 function useInit(cb) {
-  const refValue = useRef(symbolFirst);
-  if (refValue.current === symbolFirst) {
-    refValue.current = cb();
-  }
-  return refValue.current;
+  useState(() => cb());
 }
 
 // src/state/ContextContainer.ts
 var ContextContainer = createContext(null);
+function useContextContainer() {
+  return useContext(ContextContainer);
+}
 function useViewability(callback, configId) {
   const ctx = useStateContext();
-  const { containerId } = 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);
-  useEffect(
-    () => () => {
+  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 } = 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);
-  useEffect(
-    () => () => {
+  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 } = useContext(ContextContainer);
+  const containerContext = useContextContainer();
   const prevValues = useRef({
     prevIndex: void 0,
     prevItem: void 0
   });
   useEffect(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { index, value } = containerContext;
     let ret;
     if (prevValues.current.prevIndex !== void 0 && prevValues.current.prevItem !== void 0) {
       ret = effect({
@@ -363,48 +429,73 @@ function useRecyclingEffect(effect) {
       prevItem: value
     };
     return ret;
-  }, [index, value, effect]);
+  }, [effect, containerContext]);
 }
 function useRecyclingState(valueOrFun) {
-  const { index, value, itemKey, triggerLayout } = useContext(ContextContainer);
-  const refState = 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] = useState(() => {
+    return computeValue(containerContext);
   });
-  const [_, setRenderNum] = 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 = 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 = 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 } = 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() {
   const [scrollSize] = useArr$(["scrollSize"]);
   return scrollSize;
 }
+var noop = () => {
+};
 function useSyncLayout() {
-  {
-    const { triggerLayout: syncLayout } = useContext(ContextContainer);
+  const containerContext = useContextContainer();
+  if (containerContext) {
+    const { triggerLayout: syncLayout } = containerContext;
     return syncLayout;
+  } else {
+    return noop;
   }
 }
 
@@ -450,10 +541,9 @@ function createResizeObserver(element, callback) {
   }
   callbacks.add(callback);
   return () => {
-    const callbacks2 = callbackMap.get(element);
-    if (callbacks2) {
-      callbacks2.delete(callback);
-      if (callbacks2.size === 0) {
+    if (callbacks) {
+      callbacks.delete(callback);
+      if (callbacks.size === 0) {
         callbackMap.delete(element);
         observer.unobserve(element);
       }
@@ -488,10 +578,10 @@ function useOnLayoutSync({
     return createResizeObserver(element, (entry) => {
       var _a4;
       const target = entry.target instanceof HTMLElement ? entry.target : void 0;
-      const rect2 = (_a4 = entry.contentRect) != null ? _a4 : target == null ? void 0 : target.getBoundingClientRect();
-      if (rect2.width !== prevRect.width || rect2.height !== prevRect.height) {
-        prevRect = rect2;
-        emit(toLayout(rect2), false);
+      const rectObserved = (_a4 = entry.contentRect) != null ? _a4 : target == null ? void 0 : target.getBoundingClientRect();
+      if (rectObserved.width !== prevRect.width || rectObserved.height !== prevRect.height) {
+        prevRect = rectObserved;
+        emit(toLayout(rectObserved), false);
       }
     });
   }, deps || []);
@@ -516,7 +606,8 @@ var Container = typedMemo(function Container2({
   horizontal,
   getRenderedItem: getRenderedItem2,
   updateItemSize: updateItemSize2,
-  ItemSeparatorComponent
+  ItemSeparatorComponent,
+  stickyHeaderConfig
 }) {
   const ctx = useStateContext();
   const { columnWrapperStyle, animatedScrollY } = ctx;
@@ -619,7 +710,7 @@ var Container = typedMemo(function Container2({
     },
     [itemKey, layoutRenderCount]
   );
-  const PositionComponent = isSticky ? PositionViewSticky : PositionView2;
+  const PositionComponent = isSticky ? PositionViewSticky : PositionView;
   return /* @__PURE__ */ React3.createElement(
     PositionComponent,
     {
@@ -630,6 +721,7 @@ var Container = typedMemo(function Container2({
       key: recycleItems ? void 0 : itemKey,
       onLayout,
       refView: ref,
+      stickyHeaderConfig,
       stickyOffset: isSticky ? stickyOffset : void 0,
       style
     },
@@ -789,7 +881,8 @@ var Containers = typedMemo(function Containers2({
   ItemSeparatorComponent,
   waitForInitialLayout,
   updateItemSize: updateItemSize2,
-  getRenderedItem: getRenderedItem2
+  getRenderedItem: getRenderedItem2,
+  stickyHeaderConfig
 }) {
   const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
   const containers = [];
@@ -804,6 +897,7 @@ var Containers = typedMemo(function Containers2({
           id: i,
           key: i,
           recycleItems,
+          stickyHeaderConfig,
           updateItemSize: updateItemSize2
         }
       )
@@ -812,7 +906,8 @@ var Containers = typedMemo(function Containers2({
   return /* @__PURE__ */ React3.createElement(ContainersInner, { horizontal, numColumns, waitForInitialLayout }, containers);
 });
 function DevNumbers() {
-  return IS_DEV && React3.memo(function DevNumbers2() {
+  return IS_DEV && // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
+  React3.memo(function DevNumbers2() {
     return Array.from({ length: 100 }).map((_, index) => /* @__PURE__ */ React3.createElement(
       "div",
       {
@@ -860,7 +955,6 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
 }, ref) {
   const scrollRef = useRef(null);
   const contentRef = useRef(null);
-  const momentumTimeout = useRef(null);
   useImperativeHandle(ref, () => {
     const api = {
       getBoundingClientRect: () => {
@@ -926,16 +1020,6 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
         }
       };
       onScroll2(scrollEvent);
-      if (onMomentumScrollEnd) {
-        if (momentumTimeout.current != null) clearTimeout(momentumTimeout.current);
-        momentumTimeout.current = setTimeout(() => {
-          onMomentumScrollEnd({
-            nativeEvent: {
-              contentOffset: scrollEvent.nativeEvent.contentOffset
-            }
-          });
-        }, 100);
-      }
     },
     [onScroll2, onMomentumScrollEnd]
   );
@@ -997,7 +1081,8 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
     minWidth: horizontal ? "100%" : void 0,
     ...StyleSheet.flatten(contentContainerStyle)
   };
-  return /* @__PURE__ */ React3.createElement("div", { ref: scrollRef, style: scrollViewStyle, ...props }, refreshControl, /* @__PURE__ */ React3.createElement("div", { ref: contentRef, style: contentStyle }, children));
+  const { contentInset, scrollEventThrottle, ScrollComponent, ...webProps } = props;
+  return /* @__PURE__ */ React3.createElement("div", { ref: scrollRef, ...webProps, style: scrollViewStyle }, refreshControl, /* @__PURE__ */ React3.createElement("div", { ref: contentRef, style: contentStyle }, children));
 });
 function Padding() {
   const [paddingTop] = useArr$(["alignItemsPaddingTop"]);
@@ -1038,7 +1123,7 @@ function ScrollAdjust() {
     const scrollAdjust = peek$(ctx, "scrollAdjust");
     const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
     const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
-    const scrollView = (_a3 = ctx.internalState) == null ? void 0 : _a3.refScroller.current;
+    const scrollView = (_a3 = ctx.state) == null ? void 0 : _a3.refScroller.current;
     if (scrollView && scrollOffset !== lastScrollOffsetRef.current) {
       const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
       if (scrollDelta !== 0) {
@@ -1046,26 +1131,23 @@ function ScrollAdjust() {
         const prevScroll = el.scrollTop;
         const nextScroll = prevScroll + scrollDelta;
         const totalSize = el.scrollHeight;
-        if (scrollDelta > 0 && !ctx.internalState.adjustingFromInitialMount && totalSize < nextScroll + el.clientHeight) {
+        if (scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + el.clientHeight) {
           const child = el.firstElementChild;
           const prevPaddingBottom = child.style.paddingBottom;
           const pad = (nextScroll + el.clientHeight - totalSize) * 2;
           child.style.paddingBottom = `${pad}px`;
           void el.offsetHeight;
           scrollView.scrollBy(0, scrollDelta);
-          setTimeout(() => {
+          requestAnimationFrame(() => {
             child.style.paddingBottom = prevPaddingBottom;
-          }, 100);
+          });
         } else {
           scrollView.scrollBy(0, scrollDelta);
         }
-        if (IS_DEV) {
-          console.log("ScrollAdjust (web scrollBy)", scrollDelta, "total offset:", scrollOffset);
-        }
       }
       lastScrollOffsetRef.current = scrollOffset;
     }
-  }, []);
+  }, [ctx]);
   useValueListener$("scrollAdjust", callback);
   useValueListener$("scrollAdjustUserOffset", callback);
   return null;
@@ -1079,8 +1161,6 @@ var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
   useOnLayoutSync({ onLayoutChange, ref });
   return /* @__PURE__ */ React3.createElement("div", { ...rest, ref }, children);
 };
-
-// src/components/ListComponent.tsx
 var getComponent = (Component) => {
   if (React3.isValidElement(Component)) {
     return Component;
@@ -1090,6 +1170,8 @@ var getComponent = (Component) => {
   }
   return null;
 };
+
+// src/components/ListComponent.tsx
 var ListComponent = typedMemo(function ListComponent2({
   canRender,
   style,
@@ -1110,26 +1192,20 @@ var ListComponent = typedMemo(function ListComponent2({
   getRenderedItem: getRenderedItem2,
   updateItemSize: updateItemSize2,
   refScrollView,
-  maintainVisibleContentPosition,
   renderScrollComponent,
   scrollAdjustHandler,
   onLayoutHeader,
   snapToIndices,
+  stickyHeaderConfig,
   stickyHeaderIndices,
   ...rest
 }) {
   const ctx = useStateContext();
+  const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
   const ScrollComponent = renderScrollComponent ? useMemo(
     () => React3.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
     [renderScrollComponent]
   ) : ListComponentScrollView;
-  React3.useEffect(() => {
-    if (canRender) {
-      setTimeout(() => {
-        scrollAdjustHandler.setMounted();
-      }, 0);
-    }
-  }, [canRender]);
   const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
   return /* @__PURE__ */ React3.createElement(
     SnapOrScroll,
@@ -1143,7 +1219,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,
@@ -1161,6 +1237,7 @@ var ListComponent = typedMemo(function ListComponent2({
         horizontal,
         ItemSeparatorComponent,
         recycleItems,
+        stickyHeaderConfig,
         updateItemSize: updateItemSize2,
         waitForInitialLayout
       }
@@ -1193,10 +1270,11 @@ function getId(state, index) {
 }
 
 // src/core/calculateOffsetForIndex.ts
-function calculateOffsetForIndex(ctx, state, index) {
+function calculateOffsetForIndex(ctx, index) {
+  const state = ctx.state;
   let position = 0;
   if (index !== void 0) {
-    position = (state == null ? void 0 : state.positions.get(getId(state, index))) || 0;
+    position = state.positions.get(getId(state, index)) || 0;
     const paddingTop = peek$(ctx, "stylePaddingTop");
     if (paddingTop) {
       position += paddingTop;
@@ -1210,7 +1288,8 @@ function calculateOffsetForIndex(ctx, state, index) {
 }
 
 // src/utils/setPaddingTop.ts
-function setPaddingTop(ctx, state, { stylePaddingTop, alignItemsPaddingTop }) {
+function setPaddingTop(ctx, { stylePaddingTop, alignItemsPaddingTop }) {
+  const state = ctx.state;
   if (stylePaddingTop !== void 0) {
     const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
     if (stylePaddingTop < prevStylePaddingTop) {
@@ -1229,7 +1308,8 @@ function setPaddingTop(ctx, state, { stylePaddingTop, alignItemsPaddingTop }) {
 }
 
 // src/utils/updateAlignItemsPaddingTop.ts
-function updateAlignItemsPaddingTop(ctx, state) {
+function updateAlignItemsPaddingTop(ctx) {
+  const state = ctx.state;
   const {
     scrollLength,
     props: { alignItemsAtEnd, data }
@@ -1240,12 +1320,13 @@ function updateAlignItemsPaddingTop(ctx, state) {
       const contentSize = getContentSize(ctx);
       alignItemsPaddingTop = Math.max(0, Math.floor(scrollLength - contentSize));
     }
-    setPaddingTop(ctx, state, { alignItemsPaddingTop });
+    setPaddingTop(ctx, { alignItemsPaddingTop });
   }
 }
 
 // src/core/addTotalSize.ts
-function addTotalSize(ctx, state, key, add) {
+function addTotalSize(ctx, key, add) {
+  const state = ctx.state;
   const { alignItemsAtEnd } = state.props;
   const prevTotalSize = state.totalSize;
   let totalSize = state.totalSize;
@@ -1264,31 +1345,34 @@ function addTotalSize(ctx, state, key, add) {
       state.totalSize = totalSize;
       set$(ctx, "totalSize", totalSize);
       if (alignItemsAtEnd) {
-        updateAlignItemsPaddingTop(ctx, state);
+        updateAlignItemsPaddingTop(ctx);
       }
     }
   }
 }
 
 // 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) {
@@ -1296,7 +1380,6 @@ function getItemSize(ctx, state, key, index, data, useAverageSize, preferCachedS
   }
   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) {
@@ -1304,7 +1387,7 @@ function getItemSize(ctx, state, key, index, data, useAverageSize, preferCachedS
     }
   }
   if (getFixedItemSize) {
-    size = getFixedItemSize(index, data, itemType);
+    size = getFixedItemSize(data, index, itemType);
     if (size !== void 0) {
       sizesKnown.set(key, size);
     }
@@ -1322,93 +1405,188 @@ 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]));
+    const itemSize = getItemSize(ctx, getId(state, index), index, state.props.data[index]);
+    const trailingInset = getContentInsetEnd(state);
+    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
   }
   return offset;
 }
 
+// src/core/clampScrollOffset.ts
+function clampScrollOffset(ctx, offset) {
+  const state = ctx.state;
+  const contentSize = getContentSize(ctx);
+  let clampedOffset = offset;
+  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
+    const maxOffset = Math.max(0, contentSize - state.scrollLength);
+    clampedOffset = Math.min(offset, maxOffset);
+  }
+  clampedOffset = Math.max(0, clampedOffset);
+  return clampedOffset;
+}
+
+// src/utils/setInitialRenderState.ts
+function setInitialRenderState(ctx, {
+  didLayout,
+  didInitialScroll
+}) {
+  const { state } = ctx;
+  if (didLayout) {
+    state.didContainersLayout = true;
+  }
+  if (didInitialScroll) {
+    state.didFinishInitialScroll = true;
+  }
+  if (state.didContainersLayout && state.didFinishInitialScroll) {
+    set$(ctx, "readyToRender", true);
+  }
+}
+
 // src/core/finishScrollTo.ts
-function finishScrollTo(ctx, state) {
+function finishScrollTo(ctx) {
   var _a3, _b;
-  if (state) {
+  const state = ctx.state;
+  if (state == null ? void 0 : state.scrollingTo) {
+    const scrollingTo = state.scrollingTo;
     state.scrollHistory.length = 0;
     state.initialScroll = void 0;
     state.initialAnchor = void 0;
-    set$(ctx, "scrollingTo", void 0);
+    state.scrollingTo = void 0;
     if (state.pendingTotalSize !== void 0) {
-      addTotalSize(ctx, state, null, state.pendingTotalSize);
+      addTotalSize(ctx, null, state.pendingTotalSize);
     }
     if ((_a3 = state.props) == null ? void 0 : _a3.data) {
       (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
     }
+    {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    setInitialRenderState(ctx, { didInitialScroll: true });
+  }
+}
+
+// src/core/doScrollTo.ts
+var SCROLL_END_IDLE_MS = 80;
+var SCROLL_END_MAX_MS = 1500;
+var SMOOTH_SCROLL_DURATION_MS = 320;
+function doScrollTo(ctx, params) {
+  const state = ctx.state;
+  const { animated, horizontal, offset } = params;
+  const scroller = state.refScroller.current;
+  const node = typeof (scroller == null ? void 0 : scroller.getScrollableNode) === "function" ? scroller.getScrollableNode() : scroller;
+  if (node) {
+    const left = horizontal ? offset : 0;
+    const top = horizontal ? 0 : offset;
+    node.scrollTo({ behavior: animated ? "smooth" : "auto", left, top });
+    if (animated) {
+      listenForScrollEnd(ctx, node);
+    } else {
+      state.scroll = offset;
+      setTimeout(() => {
+        finishScrollTo(ctx);
+      }, 100);
+    }
   }
 }
+function listenForScrollEnd(ctx, node) {
+  const supportsScrollEnd = "onscrollend" in node;
+  let idleTimeout;
+  let maxTimeout;
+  let settled = false;
+  const targetToken = ctx.state.scrollingTo;
+  const finish = () => {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    if (targetToken === ctx.state.scrollingTo) {
+      finishScrollTo(ctx);
+    }
+  };
+  const onScroll2 = () => {
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    idleTimeout = setTimeout(finish, SCROLL_END_IDLE_MS);
+  };
+  const cleanup = () => {
+    if (supportsScrollEnd) {
+      node.removeEventListener("scrollend", finish);
+    } else {
+      node.removeEventListener("scroll", onScroll2);
+    }
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    if (maxTimeout) {
+      clearTimeout(maxTimeout);
+    }
+  };
+  if (supportsScrollEnd) {
+    node.addEventListener("scrollend", finish, { once: true });
+  } else {
+    node.addEventListener("scroll", onScroll2);
+    idleTimeout = setTimeout(finish, SMOOTH_SCROLL_DURATION_MS);
+    maxTimeout = setTimeout(finish, SCROLL_END_MAX_MS);
+  }
+  return cleanup;
+}
 
 // src/core/scrollTo.ts
-function scrollTo(ctx, state, params) {
-  var _a3;
-  const { noScrollingTo, ...scrollTarget } = params;
+function scrollTo(ctx, params) {
+  const state = ctx.state;
+  const { noScrollingTo, forceScroll, ...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);
+  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);
   state.scrollHistory.length = 0;
   if (!noScrollingTo) {
-    set$(ctx, "scrollingTo", scrollTarget);
+    state.scrollingTo = scrollTarget;
   }
   state.scrollPending = offset;
-  if (!isInitialScroll || Platform.OS === "android") {
-    (_a3 = refScroller.current) == null ? void 0 : _a3.scrollTo({
-      animated: !!animated,
-      x: horizontal ? offset : 0,
-      y: horizontal ? 0 : offset
-    });
-  }
-  if (!animated) {
+  if (forceScroll || !isInitialScroll || Platform.OS === "android") {
+    doScrollTo(ctx, { animated, horizontal, isInitialScroll, offset });
+  } else {
     state.scroll = offset;
-    {
-      const unlisten = listen$(ctx, "containersDidLayout", (value) => {
-        if (value && peek$(ctx, "scrollingTo")) {
-          finishScrollTo(ctx, state);
-          unlisten();
-        }
-      });
-    }
-    if (isInitialScroll) {
-      setTimeout(() => {
-        state.initialScroll = void 0;
-      }, 500);
-    }
   }
 }
 
 // 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;
+  if (wasReached === null) {
+    if (!within && distance >= 0) {
+      return false;
+    }
+    return null;
+  }
   const updateSnapshot = () => {
-    setSnapshot == null ? void 0 : setSnapshot({
+    setSnapshot({
       atThreshold,
       contentSize: context.contentSize,
       dataLength: context.dataLength,
@@ -1419,19 +1597,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();
     }
   }
@@ -1439,8 +1619,9 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
 };
 
 // src/utils/checkAtBottom.ts
-function checkAtBottom(ctx, state) {
+function checkAtBottom(ctx) {
   var _a3;
+  const state = ctx.state;
   if (!state) {
     return;
   }
@@ -1473,7 +1654,8 @@ function checkAtBottom(ctx, state) {
       },
       (snapshot) => {
         state.endReachedSnapshot = snapshot;
-      }
+      },
+      true
     );
   }
 }
@@ -1508,20 +1690,21 @@ function checkAtTop(state) {
     },
     (snapshot) => {
       state.startReachedSnapshot = snapshot;
-    }
+    },
+    false
   );
 }
 
 // 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 { scrollingTo, scrollAdjustHandler, lastScrollAdjustForHistory } = 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;
   }
@@ -1534,7 +1717,7 @@ function updateScroll(ctx, state, newScroll, forceUpdate) {
   if (state.scrollHistory.length > 5) {
     state.scrollHistory.shift();
   }
-  state.scrollPrev = state.scroll;
+  state.scrollPrev = prevScroll;
   state.scrollPrevTime = state.scrollTime;
   state.scroll = newScroll;
   state.scrollTime = currentTime;
@@ -1546,17 +1729,33 @@ function updateScroll(ctx, state, newScroll, forceUpdate) {
       return;
     }
   }
-  if (state.dataChangeNeedsScrollUpdate || Math.abs(state.scroll - state.scrollPrev) > 2) {
+  const scrollDelta = Math.abs(newScroll - prevScroll);
+  const scrollLength = state.scrollLength;
+  const lastCalculated = state.scrollLastCalculate;
+  const shouldUpdate = state.dataChangeNeedsScrollUpdate || state.scrollLastCalculate === void 0 || 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 });
+      checkAtBottom(ctx);
+      checkAtTop(state);
+    };
+    if (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 doit = () => {
       {
@@ -1568,8 +1767,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();
     } else {
       state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
@@ -1578,73 +1777,25 @@ function requestAdjust(ctx, state, positionDiff, dataChanged) {
   }
 }
 
-// src/core/ensureInitialAnchor.ts
-var INITIAL_ANCHOR_TOLERANCE = 0.5;
-var INITIAL_ANCHOR_MAX_ATTEMPTS = 4;
-var INITIAL_ANCHOR_SETTLED_TICKS = 2;
-function ensureInitialAnchor(ctx, state) {
-  var _a3, _b, _c, _d, _e;
-  const anchor = state.initialAnchor;
-  const item = state.props.data[anchor.index];
-  const containersDidLayout = peek$(ctx, "containersDidLayout");
-  if (!containersDidLayout) {
-    return;
-  }
-  const id = getId(state, anchor.index);
-  if (state.positions.get(id) === void 0) {
-    return;
-  }
-  const size = getItemSize(ctx, state, 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;
-  if (Math.abs(delta) <= INITIAL_ANCHOR_TOLERANCE) {
-    const settledTicks = ((_c = anchor.settledTicks) != null ? _c : 0) + 1;
-    if (settledTicks >= INITIAL_ANCHOR_SETTLED_TICKS) {
-      state.initialAnchor = void 0;
-    } else {
-      anchor.settledTicks = settledTicks;
-    }
-    return;
-  }
-  if (((_d = anchor.attempts) != null ? _d : 0) >= INITIAL_ANCHOR_MAX_ATTEMPTS) {
-    state.initialAnchor = void 0;
-    return;
-  }
-  const lastDelta = anchor.lastDelta;
-  if (lastDelta !== void 0 && Math.abs(delta) >= Math.abs(lastDelta)) {
-    state.initialAnchor = void 0;
-    return;
-  }
-  Object.assign(anchor, {
-    attempts: ((_e = anchor.attempts) != null ? _e : 0) + 1,
-    lastDelta: delta,
-    settledTicks: 0
-  });
-  requestAdjust(ctx, state, delta);
-}
-
 // src/core/mvcp.ts
-function prepareMVCP(ctx, state, dataChanged) {
+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 scrollingTo = state.scrollingTo;
   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 shouldMVCP = dataChanged ? mvcpData : mvcpScroll;
   const indexByKey = state.indexByKey;
   if (shouldMVCP) {
     if (scrollTarget !== void 0) {
       targetId = getId(state, scrollTarget);
-    } else if (idsInView.length > 0 && peek$(ctx, "containersDidLayout")) {
+    } else if (idsInView.length > 0 && state.didContainersLayout) {
       if (dataChanged) {
         for (let i = 0; i < idsInView.length; i++) {
           const id = idsInView[i];
@@ -1661,10 +1812,18 @@ function prepareMVCP(ctx, state, dataChanged) {
       prevPosition = positions.get(targetId);
     }
     return () => {
-      let positionDiff;
-      if (dataChanged && targetId === void 0 && maintainVisibleContentPosition) {
+      let positionDiff = 0;
+      if (dataChanged && targetId === void 0 && mvcpData) {
+        const data = state.props.data;
         for (let i = 0; i < idsInViewWithPositions.length; i++) {
           const { id, position } = idsInViewWithPositions[i];
+          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 = positions.get(id);
           if (newPosition !== void 0) {
             positionDiff = newPosition - position;
@@ -1687,16 +1846,28 @@ function prepareMVCP(ctx, state, dataChanged) {
           positionDiff = diff;
         }
       }
-      if (positionDiff !== void 0 && Math.abs(positionDiff) > 0.1) {
-        requestAdjust(ctx, state, positionDiff);
+      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 !== (scrollingTo == null ? void 0 : scrollingTo.itemSize)) {
+          const diff = newSize - prevSize;
+          if (diff !== 0) {
+            positionDiff += (newSize - prevSize) * scrollingToViewPosition;
+            scrollingTo.itemSize = newSize;
+          }
+        }
+      }
+      if (Math.abs(positionDiff) > 0.1) {
+        requestAdjust(ctx, positionDiff);
       }
     };
   }
 }
 
 // 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]);
@@ -1711,7 +1882,7 @@ function prepareColumnStartState(ctx, state, startIndex, useAverageSize) {
     const prevId = state.idCache[prevIndex];
     const prevPosition = (_a3 = state.positions.get(prevId)) != 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 {
@@ -1734,7 +1905,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;
   }
@@ -1748,7 +1920,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;
     }
@@ -1757,22 +1929,23 @@ function calculateRowMaxSize(ctx, state, startIndex, endIndex, useAverageSize) {
 }
 
 // src/core/updateTotalSize.ts
-function updateTotalSize(ctx, state) {
+function updateTotalSize(ctx) {
+  const state = ctx.state;
   const {
     positions,
     props: { data }
   } = state;
   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 lastSize = getItemSize(ctx, lastId, data.length - 1, data[data.length - 1]);
         if (lastSize !== void 0) {
           const totalSize = lastPosition + lastSize;
-          addTotalSize(ctx, state, null, totalSize);
+          addTotalSize(ctx, null, totalSize);
         }
       }
     }
@@ -1782,43 +1955,45 @@ 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 }
@@ -1833,30 +2008,32 @@ function updateSnapToOffsets(ctx, state) {
 }
 
 // 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 {
     columns,
     indexByKey,
     positions,
     idCache,
     sizesKnown,
-    props: { getEstimatedItemSize, snapToIndices, enableAverages }
+    props: { data, getEstimatedItemSize, snapToIndices },
+    scrollingTo
   } = state;
-  const data = state.props.data;
   const dataLength = data.length;
   const numColumns = peek$(ctx, "numColumns");
-  const scrollingTo = peek$(ctx, "scrollingTo");
   const hasColumns = numColumns > 1;
   const indexByKeyForChecking = IS_DEV ? /* @__PURE__ */ new Map() : void 0;
-  const shouldOptimize = !forceFullUpdate && !dataChanged && Math.abs(getScrollVelocity(state)) > 0;
+  const lastScrollDelta = state.lastScrollDelta;
+  const velocity = getScrollVelocity(state);
+  const shouldOptimize = !forceFullUpdate && !dataChanged && (Math.abs(velocity) > 0 || state.scrollLength > 0 && lastScrollDelta > state.scrollLength);
   const maxVisibleArea = scrollBottomBuffered + 1e3;
-  const useAverageSize = enableAverages && !getEstimatedItemSize;
+  const useAverageSize = !getEstimatedItemSize;
   const preferCachedSize = !doMVCP || dataChanged || state.scrollAdjustHandler.getAdjust() !== 0 || ((_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0) !== 0;
   let currentRowTop = 0;
   let column = 1;
@@ -1865,7 +2042,6 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
     if (hasColumns) {
       const { startIndex: processedStartIndex, currentRowTop: initialRowTop } = prepareColumnStartState(
         ctx,
-        state,
         startIndex,
         useAverageSize
       );
@@ -1875,7 +2051,7 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
       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 prevSize = (_c = sizesKnown.get(prevId)) != null ? _c : getItemSize(ctx, prevId, prevIndex, data[prevIndex], useAverageSize, preferCachedSize);
       currentRowTop = prevPosition + prevSize;
     }
   }
@@ -1892,7 +2068,7 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
       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 size = (_e = sizesKnown.get(id)) != null ? _e : getItemSize(ctx, id, i, data[i], useAverageSize, preferCachedSize);
     if (IS_DEV && needsIndexByKey) {
       if (indexByKeyForChecking.has(id)) {
         console.error(
@@ -1901,7 +2077,10 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
       }
       indexByKeyForChecking.set(id, i);
     }
-    positions.set(id, currentRowTop);
+    if (currentRowTop !== positions.get(id)) {
+      positions.set(id, currentRowTop);
+      notifyPosition$(ctx, id, currentRowTop);
+    }
     if (needsIndexByKey) {
       indexByKey.set(id, i);
     }
@@ -1921,10 +2100,10 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
     }
   }
   if (!didBreakEarly) {
-    updateTotalSize(ctx, state);
+    updateTotalSize(ctx);
   }
   if (snapToIndices) {
-    updateSnapToOffsets(ctx, state);
+    updateSnapToOffsets(ctx);
   }
 }
 
@@ -2002,7 +2181,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,
@@ -2023,7 +2202,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,
@@ -2083,11 +2262,11 @@ function computeViewability(state, ctx, viewabilityConfig, containerId, key, scr
   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,
@@ -2106,8 +2285,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) {
@@ -2135,8 +2317,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 = [];
@@ -2256,21 +2439,26 @@ 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,
+    itemSize,
     offset: firstIndexOffset,
     viewOffset,
     viewPosition: viewPosition != null ? viewPosition : 0
@@ -2278,23 +2466,28 @@ function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, vie
 }
 
 // src/utils/setDidLayout.ts
-function setDidLayout(ctx, state) {
+function setDidLayout(ctx) {
+  const state = ctx.state;
   const {
     loadStartTime,
     initialScroll,
     props: { onLoad }
   } = state;
   state.queuedInitialLayout = true;
-  checkAtBottom(ctx, state);
+  checkAtBottom(ctx);
   const setIt = () => {
-    set$(ctx, "containersDidLayout", true);
+    setInitialRenderState(ctx, { didLayout: true });
     if (onLoad) {
       onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
     }
   };
-  {
-    setIt();
+  if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
+    const target = initialScroll;
+    const runScroll = () => scrollToIndex(ctx, { ...target, animated: false });
+    runScroll();
+    requestAnimationFrame(runScroll);
   }
+  setIt();
 }
 
 // src/core/calculateItemsInView.ts
@@ -2312,15 +2505,17 @@ function findCurrentStickyIndex(stickyArray, scroll, state) {
   }
   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, 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;
@@ -2331,8 +2526,9 @@ function handleStickyActivation(ctx, state, stickyHeaderIndices, stickyArray, cu
     }
   }
 }
-function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, currentStickyIdx, pendingRemoval) {
+function handleStickyRecycling(ctx, stickyArray, scroll, scrollBuffer, currentStickyIdx, pendingRemoval) {
   var _a3, _b, _c;
+  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;
@@ -2356,7 +2552,7 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
       const currentId = (_b = state.idCache[itemIndex]) != null ? _b : 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]);
+        const currentSize = (_c = state.sizes.get(currentId)) != null ? _c : getItemSize(ctx, currentId, itemIndex, state.props.data[itemIndex]);
         shouldRecycle = currentPos !== void 0 && scroll > currentPos + currentSize + scrollBuffer * 3;
       }
     }
@@ -2365,7 +2561,8 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
     }
   }
 }
-function calculateItemsInView(ctx, state, params = {}) {
+function calculateItemsInView(ctx, params = {}) {
+  const state = ctx.state;
   unstable_batchedUpdates(() => {
     var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     const {
@@ -2389,9 +2586,6 @@ function calculateItemsInView(ctx, state, params = {}) {
     const stickyIndicesSet = state.props.stickyIndicesSet || /* @__PURE__ */ new Set();
     const prevNumContainers = peek$(ctx, "numContainers");
     if (!data || scrollLength === 0 || !prevNumContainers) {
-      if (state.initialAnchor) {
-        ensureInitialAnchor(ctx, state);
-      }
       return;
     }
     const totalSize = getContentSize(ctx);
@@ -2405,15 +2599,14 @@ 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);
     }
@@ -2421,11 +2614,12 @@ function calculateItemsInView(ctx, state, params = {}) {
       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);
+    const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyIndicesArr[currentStickyIdx] : -1;
+    if (currentStickyIdx >= 0 || previousStickyIndex >= 0) {
+      set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
+    }
     let scrollBufferTop = scrollBuffer;
     let scrollBufferBottom = scrollBuffer;
     if (speed > 0 || speed === 0 && scroll < Math.max(50, scrollBuffer)) {
@@ -2438,23 +2632,22 @@ function calculateItemsInView(ctx, state, params = {}) {
     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)) {
         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();
     }
-    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,
@@ -2473,9 +2666,9 @@ function calculateItemsInView(ctx, state, params = {}) {
     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 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;
@@ -2500,7 +2693,7 @@ 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 size = (_f = sizes.get(id)) != null ? _f : getItemSize(ctx, id, i, data[i]);
       const top = positions.get(id);
       if (!foundEnd) {
         if (startNoBuffer === null && top + size > scroll) {
@@ -2512,7 +2705,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) {
@@ -2520,7 +2717,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;
           }
@@ -2542,12 +2743,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++) {
@@ -2558,7 +2759,6 @@ function calculateItemsInView(ctx, state, params = {}) {
       }
     }
     if (startBuffered !== null && endBuffered !== null) {
-      let numContainers2 = prevNumContainers;
       const needNewContainers = [];
       for (let i = startBuffered; i <= endBuffered; i++) {
         const id = (_h = idCache[i]) != null ? _h : getId(state, i);
@@ -2569,7 +2769,6 @@ function calculateItemsInView(ctx, state, params = {}) {
       if (stickyIndicesArr.length > 0) {
         handleStickyActivation(
           ctx,
-          state,
           stickyIndicesSet,
           stickyIndicesArr,
           currentStickyIdx,
@@ -2577,18 +2776,16 @@ function calculateItemsInView(ctx, state, params = {}) {
           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,
@@ -2609,30 +2806,31 @@ function calculateItemsInView(ctx, state, params = {}) {
           if (requiredItemTypes) {
             state.containerItemTypes.set(containerIndex, requiredItemTypes[idx]);
           }
-          containerItemKeys.add(id);
+          containerItemKeys.set(id, containerIndex);
+          const containerSticky = `containerSticky${containerIndex}`;
           if (stickyIndicesSet.has(i)) {
-            set$(ctx, `containerSticky${containerIndex}`, true);
+            set$(ctx, containerSticky, true);
             const topPadding = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
             set$(ctx, `containerStickyOffset${containerIndex}`, topPadding);
             state.stickyContainerPool.add(containerIndex);
-          } else {
-            set$(ctx, `containerSticky${containerIndex}`, false);
+          } else if (peek$(ctx, containerSticky)) {
+            set$(ctx, containerSticky, false);
             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 (stickyIndicesArr.length > 0) {
-      handleStickyRecycling(ctx, state, stickyIndicesArr, scroll, scrollBuffer, currentStickyIdx, pendingRemoval);
+      handleStickyRecycling(ctx, stickyIndicesArr, scroll, scrollBuffer, currentStickyIdx, pendingRemoval);
     }
     let didChangePositions = false;
     for (let i = 0; i < numContainers; i++) {
@@ -2684,7 +2882,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     }
     if (!queuedInitialLayout && endBuffered !== null) {
       if (checkAllSizesKnown(state)) {
-        setDidLayout(ctx, state);
+        setDidLayout(ctx);
       }
     }
     if (viewabilityConfigCallbackPairs) {
@@ -2697,9 +2895,6 @@ function calculateItemsInView(ctx, state, params = {}) {
       }
     }
   });
-  if (state.initialAnchor) {
-    ensureInitialAnchor(ctx, state);
-  }
 }
 
 // src/core/checkActualChange.ts
@@ -2722,20 +2917,69 @@ function checkActualChange(state, dataProp, previousData) {
   return false;
 }
 
+// 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));
+    const maxOffset = clampScrollOffset(ctx, scroll);
+    const diff1 = Math.abs(scroll - clampedTargetOffset);
+    const diff2 = Math.abs(diff1 - adjust);
+    const isNotOverscrolled = Math.abs(scroll - maxOffset) < 1;
+    if (isNotOverscrolled && (diff1 < 1 || diff2 < 1)) {
+      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/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")) {
+  if (isAtEnd && maintainScrollAtEnd && didContainersLayout) {
     const paddingTop = peek$(ctx, "alignItemsPaddingTop");
     if (paddingTop > 0) {
       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
@@ -2806,28 +3050,30 @@ 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);
+    checkAtBottom(ctx);
   }
   delete state.previousData;
 }
 
 // src/core/doInitialAllocateContainers.ts
-function doInitialAllocateContainers(ctx, state) {
+function doInitialAllocateContainers(ctx) {
   var _a3, _b, _c;
+  const state = ctx.state;
   const {
     scrollLength,
     props: {
@@ -2848,8 +3094,10 @@ function doInitialAllocateContainers(ctx, state) {
       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 {
@@ -2865,10 +3113,10 @@ function doInitialAllocateContainers(ctx, state) {
     if (state.lastLayout) {
       if (state.initialScroll) {
         requestAnimationFrame(() => {
-          calculateItemsInView(ctx, state, { dataChanged: true, doMVCP: true });
+          calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
         });
       } else {
-        calculateItemsInView(ctx, state, { dataChanged: true, doMVCP: true });
+        calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
       }
     }
     return true;
@@ -2876,7 +3124,8 @@ function doInitialAllocateContainers(ctx, state) {
 }
 
 // src/core/handleLayout.ts
-function handleLayout(ctx, state, layout, setCanRender) {
+function handleLayout(ctx, layout, setCanRender) {
+  const state = ctx.state;
   const { maintainScrollAtEnd } = state.props;
   const measuredLength = layout[state.props.horizontal ? "width" : "height"];
   const previousLength = state.scrollLength;
@@ -2892,19 +3141,19 @@ 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);
+    updateAlignItemsPaddingTop(ctx);
+    checkAtBottom(ctx);
     checkAtTop(state);
     if (state) {
       state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
@@ -2920,8 +3169,9 @@ function handleLayout(ctx, state, layout, setCanRender) {
 }
 
 // src/core/onScroll.ts
-function onScroll(ctx, state, event) {
+function onScroll(ctx, event) {
   var _a3, _b, _c;
+  const state = ctx.state;
   const {
     scrollProcessingEnabled,
     props: { onScroll: onScrollProp }
@@ -2932,9 +3182,25 @@ 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;
   }
-  const newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
+  let newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
+  if (state.scrollingTo) {
+    const maxOffset = clampScrollOffset(ctx, newScroll);
+    if (newScroll !== maxOffset && Math.abs(newScroll - maxOffset) > 1) {
+      newScroll = maxOffset;
+      scrollTo(ctx, {
+        forceScroll: true,
+        isInitialScroll: true,
+        noScrollingTo: true,
+        offset: newScroll
+      });
+      return;
+    }
+  }
   state.scrollPending = newScroll;
-  updateScroll(ctx, state, newScroll);
+  updateScroll(ctx, newScroll);
+  if (state.scrollingTo) {
+    checkFinishedScroll(ctx);
+  }
   onScrollProp == null ? void 0 : onScrollProp(event);
 }
 
@@ -2943,51 +3209,58 @@ var ScrollAdjustHandler = class {
   constructor(ctx) {
     this.appliedAdjust = 0;
     this.pendingAdjust = 0;
-    this.mounted = false;
-    this.context = ctx;
-    {
-      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");
+    const scrollingTo = this.ctx.state.scrollingTo;
     if ((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) {
+    {
+      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);
+        } 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 updateItemSize(ctx, itemKey, sizeObj) {
   var _a3;
+  const state = ctx.state;
   const {
+    didContainersLayout,
     sizesKnown,
     props: {
       getFixedItemSize,
@@ -3010,31 +3283,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;
@@ -3070,22 +3336,22 @@ 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 });
+      calculateItemsInView(ctx, { doMVCP: true });
     }
     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 {
-    sizes,
     indexByKey,
     sizesKnown,
     averageSizes,
@@ -3093,9 +3359,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 = Math.round(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 : "" : "";
@@ -3103,15 +3370,25 @@ 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 (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 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 = useCallback((element) => {
     for (const ref of refs) {
@@ -3154,14 +3431,15 @@ function createColumnWrapperStyle(contentContainerStyle) {
 }
 
 // src/utils/createImperativeHandle.ts
-function createImperativeHandle(ctx, state) {
+function createImperativeHandle(ctx) {
+  const state = ctx.state;
   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
@@ -3176,7 +3454,7 @@ function createImperativeHandle(ctx, state) {
     getScrollableNode: () => refScroller.current.getScrollableNode(),
     getScrollResponder: () => refScroller.current.getScrollResponder(),
     getState: () => ({
-      activeStickyIndex: state.activeStickyIndex,
+      activeStickyIndex: peek$(ctx, "activeStickyIndex"),
       contentLength: state.totalSize,
       data: state.props.data,
       elementAtIndex: (index) => {
@@ -3187,6 +3465,8 @@ function createImperativeHandle(ctx, state) {
       endBuffered: state.endBuffered,
       isAtEnd: state.isAtEnd,
       isAtStart: state.isAtStart,
+      listen: (signalName, cb) => listen$(ctx, signalName, cb),
+      listenToPosition: (key, cb) => listenPosition$(ctx, key, cb),
       positionAtIndex: (index) => state.positions.get(getId(state, index)),
       positions: state.positions,
       scroll: state.scroll,
@@ -3211,23 +3491,23 @@ function createImperativeHandle(ctx, state) {
       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
         });
       }
     },
-    scrollToIndex: (params) => scrollToIndex(ctx, state, params),
+    scrollToIndex: (params) => scrollToIndex(ctx, params),
     scrollToItem: ({ item, ...props }) => {
       const data = state.props.data;
       const index = data.indexOf(item);
       if (index !== -1) {
-        scrollToIndex(ctx, state, { index, ...props });
+        scrollToIndex(ctx, { index, ...props });
       }
     },
-    scrollToOffset: (params) => scrollTo(ctx, state, params),
+    scrollToOffset: (params) => scrollTo(ctx, params),
     setScrollProcessingEnabled: (enabled) => {
       state.scrollProcessingEnabled = enabled;
     },
@@ -3237,8 +3517,9 @@ function createImperativeHandle(ctx, state) {
     }
   };
 }
-function getRenderedItem(ctx, state, key) {
+function getRenderedItem(ctx, key) {
   var _a3;
+  const state = ctx.state;
   if (!state) {
     return null;
   }
@@ -3265,6 +3546,25 @@ 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,
+      size: (_b = value.size) != null ? _b : true,
+      shouldRestorePosition: value.shouldRestorePosition
+    };
+  }
+  if (value === false) {
+    return { data: false, size: false };
+  }
+  return { data: false, size: true };
+}
 function useThrottleDebounce(mode) {
   const timeoutRef = useRef(null);
   const lastCallTimeRef = useRef(0);
@@ -3315,6 +3615,7 @@ function useThrottledOnScroll(originalHandler, scrollEventThrottle) {
 var DEFAULT_DRAW_DISTANCE = 250;
 var DEFAULT_ITEM_SIZE = 100;
 var LegendList = typedMemo(
+  // biome-ignore lint/nursery/noShadow: const function name shadowing is intentional
   typedForwardRef(function LegendList2(props, forwardedRef) {
     const { children, data: dataProp, renderItem: renderItemProp, ...restProps } = props;
     const isChildrenMode = children !== void 0 && dataProp === void 0;
@@ -3337,10 +3638,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     alignItemsAtEnd = false,
     columnWrapperStyle,
     contentContainerStyle: contentContainerStyleProp,
+    contentInset,
     data: dataProp = [],
     dataVersion,
     drawDistance = 250,
-    enableAverages = true,
     estimatedItemSize: estimatedItemSizeProp,
     estimatedListSize,
     extraData,
@@ -3358,7 +3659,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     ListHeaderComponent,
     maintainScrollAtEnd = false,
     maintainScrollAtEndThreshold = 0.1,
-    maintainVisibleContentPosition = false,
+    maintainVisibleContentPosition: maintainVisibleContentPositionProp,
     numColumns: numColumnsProp = 1,
     onEndReached,
     onEndReachedThreshold = 0.5,
@@ -3382,20 +3683,26 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     snapToIndices,
     stickyHeaderIndices: stickyHeaderIndicesProp,
     stickyIndices: stickyIndicesDeprecated,
+    // TODOV3: Remove from v3 release
     style: styleProp,
     suggestEstimatedItemSize,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
     waitForInitialLayout = true,
+    stickyHeaderConfig,
     ...rest
   } = props;
+  const animatedPropsInternal = props.animatedPropsInternal;
   const { childrenMode } = rest;
   const contentContainerStyle = { ...StyleSheet.flatten(contentContainerStyleProp) };
   const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
   const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
+  const maintainVisibleContentPositionConfig = normalizeMaintainVisibleContentPosition(
+    maintainVisibleContentPositionProp
+  );
   const [renderNum, setRenderNum] = 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 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 || 0 } : { index: initialScrollIndexProp || 0, viewOffset: initialScrollOffsetProp || 0 } : void 0;
   const [canRender, setCanRender] = React3.useState(!IsNewArchitecture);
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
@@ -3413,13 +3720,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }
   const refState = useRef();
   if (!refState.current) {
-    if (!ctx.internalState) {
+    if (!ctx.state) {
       const initialScrollLength = (estimatedListSize != null ? estimatedListSize : { height: 0, width: 0 } )[horizontal ? "width" : "height"];
-      ctx.internalState = {
-        activeStickyIndex: void 0,
+      ctx.state = {
+        activeStickyIndex: -1,
         averageSizes: {},
         columns: /* @__PURE__ */ new Map(),
-        containerItemKeys: /* @__PURE__ */ new Set(),
+        containerItemKeys: /* @__PURE__ */ new Map(),
         containerItemTypes: /* @__PURE__ */ new Map(),
         dataChangeNeedsScrollUpdate: false,
         didColumnsChange: false,
@@ -3442,11 +3749,12 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         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,
         nativeMarginTop: 0,
@@ -3476,12 +3784,12 @@ 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;
@@ -3495,20 +3803,21 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? useThrottledOnScroll(onScrollProp, scrollEventThrottle) : onScrollProp;
   state.props = {
     alignItemsAtEnd,
+    animatedProps: animatedPropsInternal,
+    contentInset,
     data: dataProp,
     dataVersion,
-    enableAverages,
     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,
@@ -3540,57 +3849,47 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     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 && Platform.OS === "ios") {
+    if (maintainVisibleContentPositionConfig.size && paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") {
       if (state.scroll < 0) {
         paddingDiff += state.scroll;
       }
-      requestAdjust(ctx, state, paddingDiff);
+      requestAdjust(ctx, paddingDiff);
     }
   };
   if (isFirstLocal) {
     initializeStateVars();
     updateItemPositions(
       ctx,
-      state,
       /*dataChanged*/
       true
     );
   }
   const initialContentOffset = useMemo(() => {
-    var _a4, _b2;
-    const { initialScroll } = refState.current;
-    if (!initialScroll) {
+    let value;
+    const { initialScroll, initialAnchor } = refState.current;
+    if (initialScroll) {
+      if (initialScroll.contentOffset !== void 0) {
+        value = initialScroll.contentOffset;
+      } else {
+        const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
+        const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
+        const clampedOffset = clampScrollOffset(ctx, resolvedOffset);
+        const updatedInitialScroll = { ...initialScroll, contentOffset: clampedOffset };
+        refState.current.initialScroll = updatedInitialScroll;
+        state.initialScroll = updatedInitialScroll;
+        value = clampedOffset;
+      }
+    } else {
       refState.current.initialAnchor = void 0;
-      return 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
-      };
+      value = 0;
+    }
+    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;
+    return value;
   }, [renderNum]);
   if (isFirstLocal || didDataChangeLocal || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
@@ -3618,12 +3917,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
   }, []);
   const doInitialScroll = useCallback(() => {
-    var _a4;
-    const initialScroll = state.initialScroll;
-    if (initialScroll) {
-      scrollTo(ctx, state, {
+    const { initialScroll, didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
+    if (initialScroll && !queuedInitialLayout && !didFinishInitialScroll && !scrollingTo) {
+      scrollTo(ctx, {
         animated: false,
-        index: (_a4 = state.initialScroll) == null ? void 0 : _a4.index,
+        index: initialScroll == null ? void 0 : initialScroll.index,
         isInitialScroll: true,
         offset: initialContentOffset,
         precomputedWithViewOffset: true
@@ -3632,7 +3930,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }, [initialContentOffset]);
   const onLayoutChange = useCallback((layout) => {
     doInitialScroll();
-    handleLayout(ctx, state, layout, setCanRender);
+    handleLayout(ctx, layout, setCanRender);
   }, []);
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
@@ -3642,7 +3940,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   });
   useLayoutEffect(() => {
     if (snapToIndices) {
-      updateSnapToOffsets(ctx, state);
+      updateSnapToOffsets(ctx);
     }
   }, [snapToIndices]);
   useLayoutEffect(() => {
@@ -3652,9 +3950,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       isFirst,
       props: { data }
     } = state;
-    const didAllocateContainers = data.length > 0 && doInitialAllocateContainers(ctx, state);
+    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;
@@ -3679,15 +3977,21 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, state), []);
+  useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx), []);
   {
     useEffect(doInitialScroll, []);
   }
   const fns = 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)
     }),
     []
   );
@@ -3699,24 +4003,15 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       alignItemsAtEnd,
       canRender,
       contentContainerStyle,
+      contentInset,
       getRenderedItem: fns.getRenderedItem,
       horizontal,
       initialContentOffset,
       ListEmptyComponent: dataProp.length === 0 ? ListEmptyComponent : void 0,
       ListHeaderComponent,
-      maintainVisibleContentPosition,
       onLayout,
       onLayoutHeader,
-      onMomentumScrollEnd: (event) => {
-        {
-          requestAnimationFrame(() => {
-            finishScrollTo(ctx, refState.current);
-          });
-        }
-        if (onMomentumScrollEnd) {
-          onMomentumScrollEnd(event);
-        }
-      },
+      onMomentumScrollEnd: fns.onMomentumScrollEnd,
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControl ? stylePaddingTopState > 0 ? React3.cloneElement(refreshControl, {
@@ -3731,8 +4026,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       scrollAdjustHandler: (_b = refState.current) == null ? void 0 : _b.scrollAdjustHandler,
-      scrollEventThrottle: 16 ,
+      scrollEventThrottle: 0,
       snapToIndices,
+      stickyHeaderConfig,
       stickyHeaderIndices,
       style,
       updateItemSize: fns.updateItemSize,
@@ -3741,4 +4037,4 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   ), IS_DEV && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React3.createElement(DebugView, { state: refState.current }));
 });
 
-export { LegendList, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };
+export { LegendList, typedForwardRef, typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };