@legendapp/list 3.3.10 → 3.4.0

package/react-native.js

@@ -458,6 +458,14 @@ var EDGE_POSITION_EPSILON = 1;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 
+// src/core/endOfContentTarget.ts
+function getEndAlignedViewOffset(stylePaddingEnd, footerSize = 0) {
+  return -stylePaddingEnd - footerSize;
+}
+function isEndOfContentTarget(target, dataLength) {
+  return !!target && dataLength > 0 && target.viewPosition === 1 && !!target.preserveForBottomPadding && target.index !== void 0 && target.index >= dataLength - 1;
+}
+
 // src/core/cancelImperativeScroll.ts
 function cancelScrollCompletionChecks({ scheduledWork }) {
   scheduledWork.cancel("checkFinishedScrollFrame");
@@ -642,26 +650,25 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
       scrollPosition: context.scrollPosition
     });
   };
+  let reached = !!wasReached;
   if (!wasReached) {
-    if (!within) {
-      return false;
-    }
-    onReached(distance);
-    updateSnapshot();
-    return true;
-  }
-  const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
-  if (reset) {
-    setSnapshot(void 0);
-    return false;
-  }
-  if (within) {
-    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
-    if (changed) {
+    if (within && onReached(distance)) {
       updateSnapshot();
+      reached = true;
+    }
+  } else {
+    const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
+    if (reset) {
+      setSnapshot(void 0);
+      reached = false;
+    } else if (within) {
+      const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
+      if (changed) {
+        updateSnapshot();
+      }
     }
   }
-  return true;
+  return reached;
 };
 
 // src/utils/edgeReachedGate.ts
@@ -708,7 +715,6 @@ function beginReachedEdgeUserScroll(ctx, scrollDelta) {
     return void 0;
   }
   const allowedEdge = scrollDelta < 0 ? "start" : "end";
-  state.edgeReachedGate = "closed";
   resetEdgeLatch(ctx, allowedEdge);
   return allowedEdge;
 }
@@ -749,7 +755,7 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
     set$(
       ctx,
       "isWithinMaintainScrollAtEndThreshold",
-      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength || state.pendingMaintainScrollAtEnd || maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant"
+      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength || state.pendingMaintainScrollAtEnd || !!maintainingScrollAtEnd
     );
     const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || maintainingScrollAtEnd;
     if (!shouldSkipThresholdChecks) {
@@ -765,11 +771,13 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
           scrollPosition: scroll
         },
         (distance) => {
-          var _a4, _b;
-          if (canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
+          let dispatched = false;
+          if (state.props.onEndReached && canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
             markReachedEdge(ctx);
-            (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+            state.props.onEndReached({ distanceFromEnd: distance });
+            dispatched = true;
           }
+          return dispatched;
         },
         (snapshot) => {
           state.endReachedSnapshot = snapshot;
@@ -802,7 +810,7 @@ function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   }
   set$(ctx, "isAtStart", scroll <= EDGE_POSITION_EPSILON);
   set$(ctx, "isNearStart", scroll <= threshold);
-  const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || !!state.scrollingTo;
+  const shouldSkipThresholdChecks = !state.queuedInitialLayout || hasActiveInitialScroll(state) || !!state.scrollingTo;
   if (!shouldSkipThresholdChecks) {
     state.isStartReached = checkThreshold(
       scroll,
@@ -816,11 +824,13 @@ function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
         scrollPosition: scroll
       },
       (distance) => {
-        var _a3, _b;
-        if (canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
+        let dispatched = false;
+        if (state.props.onStartReached && canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
           markReachedEdge(ctx);
-          (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+          state.props.onStartReached({ distanceFromStart: distance });
+          dispatched = true;
         }
+        return dispatched;
       },
       (snapshot) => {
         state.startReachedSnapshot = snapshot;
@@ -939,6 +949,11 @@ function resetInitialRenderState(ctx, {
   if (resetLayout) {
     state.didContainersLayout = false;
     state.queuedInitialLayout = false;
+    state.edgeReachedGate = void 0;
+    state.isStartReached = null;
+    state.isEndReached = null;
+    state.startReachedSnapshot = void 0;
+    state.endReachedSnapshot = void 0;
   }
   if (resetInitialScroll) {
     state.didFinishInitialScroll = false;
@@ -953,7 +968,7 @@ function setInitialRenderState(ctx, {
   const { state } = ctx;
   const {
     loadStartTime,
-    props: { onLoad }
+    props: { onLoad, onReady }
   } = state;
   if (didLayout) {
     state.didContainersLayout = true;
@@ -974,6 +989,7 @@ function setInitialRenderState(ctx, {
         onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
       }
     }
+    onReady == null ? void 0 : onReady();
   }
 }
 
@@ -1014,6 +1030,7 @@ function supersedeInitialScroll(ctx) {
 function finishInitialScroll(ctx, options) {
   var _a3, _b, _c;
   const state = ctx.state;
+  const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
   if ((options == null ? void 0 : options.resolvedOffset) !== void 0) {
     syncInitialScrollOffset(state, options.resolvedOffset);
   } else if ((options == null ? void 0 : options.syncObservedOffset) && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
@@ -1023,9 +1040,13 @@ function finishInitialScroll(ctx, options) {
     }
   }
   const complete = () => {
-    var _a4, _b2, _c2, _d, _e;
-    const shouldReleaseDeferredPublicOnScroll = Platform.OS === "web" && ((_a4 = state.initialScrollSession) == null ? void 0 : _a4.kind) === "bootstrap";
-    const finalScrollOffset = (_d = (_c2 = (_b2 = options == null ? void 0 : options.resolvedOffset) != null ? _b2 : state.scrollPending) != null ? _c2 : state.scroll) != null ? _d : 0;
+    var _a4, _b2, _c2, _d, _e, _f;
+    if (freshDataTransitionEpoch !== state.freshDataTransitionEpoch) {
+      (_a4 = options == null ? void 0 : options.onFinished) == null ? void 0 : _a4.call(options);
+      return;
+    }
+    const shouldReleaseDeferredPublicOnScroll = Platform.OS === "web" && ((_b2 = state.initialScrollSession) == null ? void 0 : _b2.kind) === "bootstrap";
+    const finalScrollOffset = (_e = (_d = (_c2 = options == null ? void 0 : options.resolvedOffset) != null ? _c2 : state.scrollPending) != null ? _d : state.scroll) != null ? _e : 0;
     initialScrollWatchdog.clear(state);
     if ((options == null ? void 0 : options.preserveTarget) && state.initialScroll) {
       state.clearPreservedInitialScrollOnNextFinish = void 0;
@@ -1054,7 +1075,7 @@ function finishInitialScroll(ctx, options) {
     if (shouldReleaseDeferredPublicOnScroll) {
       releaseDeferredPublicOnScroll(ctx, finalScrollOffset);
     }
-    (_e = options == null ? void 0 : options.onFinished) == null ? void 0 : _e.call(options);
+    (_f = options == null ? void 0 : options.onFinished) == null ? void 0 : _f.call(options);
   };
   if (options == null ? void 0 : options.waitForCompletionFrame) {
     requestAnimationFrame(complete);
@@ -1314,10 +1335,6 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
     const itemSize = Math.max(0, measuredItemSize - (isOutOfBounds ? 0 : ctx.scrollAxisGap));
     const trailingInset = getContentInsetEnd(ctx);
     offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
-    if (!isOutOfBounds && index === state.props.data.length - 1) {
-      const footerSize = peek$(ctx, "footerSize") || 0;
-      offset += footerSize;
-    }
   }
   return offset;
 }
@@ -1338,246 +1355,21 @@ function clampScrollOffset(ctx, offset, scrollTarget) {
   return clampedOffset;
 }
 
-// src/core/finishScrollTo.ts
-function finishScrollTo(ctx) {
-  var _a3, _b;
-  const state = ctx.state;
-  if (state == null ? void 0 : state.scrollingTo) {
-    cancelScrollCompletionChecks(state);
-    const resolvePendingScroll = state.pendingScrollResolve;
-    state.pendingScrollResolve = void 0;
-    const scrollingTo = state.scrollingTo;
-    state.scrollHistory.length = 0;
-    state.scrollingTo = void 0;
-    state.scrollTargetPinnedRange = void 0;
-    if (state.pendingTotalSize !== void 0) {
-      addTotalSize(ctx, null, state.pendingTotalSize);
-    }
-    if (PlatformAdjustBreaksScroll) {
-      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
-    }
-    if (scrollingTo.isInitialScroll || state.initialScroll) {
-      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
-      finishInitialScroll(ctx, {
-        onFinished: () => {
-          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-        },
-        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
-        recalculateItems: true,
-        schedulePreservedTargetClear: shouldPreserveResizeTarget,
-        syncObservedOffset: isOffsetSession,
-        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
-      });
-      return;
-    }
-    recalculateSettledScroll(ctx);
-    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-  }
-}
-
-// src/core/checkFinishedScroll.ts
-var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
-var INITIAL_SCROLL_COMPLETION_TARGET_EPSILON = 1;
-var INITIAL_SCROLL_ZERO_TARGET_EPSILON = 1;
-var SILENT_INITIAL_SCROLL_RETRY_DELAY_MS = 16;
-var SILENT_INITIAL_SCROLL_TARGET_EPSILON = 1;
-function checkFinishedScroll(ctx, options) {
-  const scrollingTo = ctx.state.scrollingTo;
-  if (options == null ? void 0 : options.onlyIfAligned) {
-    if (!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) || scrollingTo.animated) {
-      return;
-    }
-    if (!getResolvedScrollCompletionState(ctx, scrollingTo).isAtResolvedTarget) {
-      return;
-    }
-  }
-  ctx.state.scheduledWork.frame(() => checkFinishedScrollFrame(ctx), "checkFinishedScrollFrame");
-}
-function hasScrollCompletionOwnership(state, options) {
-  const { clampedTargetOffset, scrollingTo } = options;
-  return !scrollingTo.isInitialScroll || state.hasScrolled || clampedTargetOffset <= INITIAL_SCROLL_COMPLETION_TARGET_EPSILON;
-}
-function isSilentInitialDispatch(state, scrollingTo) {
-  return !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled;
-}
-function getInitialScrollWatchdogTargetOffset(state) {
-  var _a3;
-  return (_a3 = initialScrollWatchdog.get(state)) == null ? void 0 : _a3.targetOffset;
-}
-function isNativeInitialNonZeroTarget(state) {
-  const targetOffset = getInitialScrollWatchdogTargetOffset(state);
-  return !state.didFinishInitialScroll && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
-}
-function shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) {
-  var _a3, _b;
-  if (!scrollingTo.isInitialScroll || scrollingTo.animated || !state.didContainersLayout) {
-    return false;
-  }
-  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap") {
-    return false;
-  }
-  const targetOffset = (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset;
-  if (initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled) {
-    return false;
-  }
-  if (initialScrollWatchdog.isAtZeroTargetOffset(targetOffset) || Math.abs(state.scroll - targetOffset) > 1 || Math.abs(state.scrollPending - targetOffset) > 1) {
-    return false;
-  }
-  return !!scrollingTo.waitForInitialScrollCompletionFrame || isNativeInitialNonZeroTarget(state);
-}
-function shouldFinishInitialZeroTargetScroll(ctx) {
-  var _a3;
-  const { state } = ctx;
-  return !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) && state.props.data.length > 0 && getContentSize(ctx) <= state.scrollLength && state.scrollPending <= INITIAL_SCROLL_ZERO_TARGET_EPSILON;
-}
-function isEndAlignedLastItemTarget(ctx, scrollingTo) {
-  return scrollingTo.index === ctx.state.props.data.length - 1 && scrollingTo.viewPosition === 1;
-}
-function getCurrentTargetOffset(ctx, scrollingTo) {
-  var _a3;
-  const index = scrollingTo.index;
-  const shouldRecomputeEndTarget = isEndAlignedLastItemTarget(ctx, scrollingTo);
-  const requestedTargetOffset = shouldRecomputeEndTarget && index !== void 0 ? calculateOffsetWithOffsetPosition(ctx, calculateOffsetForIndex(ctx, index), scrollingTo) : (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
-  return clampScrollOffset(ctx, requestedTargetOffset, scrollingTo);
-}
-function getResolvedScrollCompletionState(ctx, scrollingTo) {
-  const { state } = ctx;
-  const scroll = state.scrollPending;
-  const adjust = state.scrollAdjustHandler.getAdjust();
-  const clampedTargetOffset = getCurrentTargetOffset(ctx, scrollingTo);
-  const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
-  const diff1 = Math.abs(scroll - clampedTargetOffset);
-  const adjustedTargetOffset = clampedTargetOffset + adjust;
-  const diff2 = Math.abs(scroll - adjustedTargetOffset);
-  const canUseAdjustedCompletion = !scrollingTo.animated || Platform.OS === "ios";
-  return {
-    clampedTargetOffset,
-    isAtResolvedTarget: Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || canUseAdjustedCompletion && diff2 < 1)
-  };
-}
-function checkFinishedScrollFrame(ctx) {
-  const scrollingTo = ctx.state.scrollingTo;
-  if (!scrollingTo) {
-    return;
-  }
-  const { state } = ctx;
-  const completionState = getResolvedScrollCompletionState(ctx, scrollingTo);
-  if (completionState.isAtResolvedTarget && hasScrollCompletionOwnership(state, {
-    clampedTargetOffset: completionState.clampedTargetOffset,
-    scrollingTo
-  })) {
-    finishScrollTo(ctx);
-  }
-}
-function scrollToFallbackOffset(ctx, offset) {
-  var _a3;
-  (_a3 = ctx.state.refScroller.current) == null ? void 0 : _a3.scrollTo({
-    animated: false,
-    x: ctx.state.props.horizontal ? offset : 0,
-    y: ctx.state.props.horizontal ? 0 : offset
-  });
-}
-function checkFinishedScrollFallback(ctx) {
-  const state = ctx.state;
-  if (state.scheduledWork.has("checkFinishedScrollFallback")) {
-    return;
-  }
-  const scrollingTo = state.scrollingTo;
-  const shouldFinishInitialZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
-  const silentInitialDispatch = isSilentInitialDispatch(state, scrollingTo);
-  const canFinishInitialWithoutNativeProgress = scrollingTo !== void 0 ? shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) : false;
-  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && !shouldFinishInitialZeroTarget && !canFinishInitialWithoutNativeProgress || !state.didContainersLayout;
-  const initialDelay = shouldFinishInitialZeroTarget || canFinishInitialWithoutNativeProgress ? 0 : silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : slowTimeout ? 500 : 100;
-  let numChecks = 0;
-  const scheduleFallbackCheck = (delay) => {
-    state.scheduledWork.timeout(checkHasScrolled, delay, "checkFinishedScrollFallback");
-  };
-  const checkHasScrolled = () => {
-    var _a3, _b, _c, _d;
-    const isStillScrollingTo = state.scrollingTo;
-    if (isStillScrollingTo) {
-      numChecks++;
-      const isNativeInitialPending = isNativeInitialNonZeroTarget(state) && !state.hasScrolled;
-      const maxChecks = silentInitialDispatch ? 5 : isNativeInitialPending ? INITIAL_SCROLL_MAX_FALLBACK_CHECKS : 5;
-      const shouldFinishZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
-      const canFinishInitialScrollWithoutNativeProgress = shouldFinishInitialScrollWithoutNativeProgress(
-        state,
-        isStillScrollingTo
-      );
-      const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
-      const canFinishAfterSilentNativeDispatch = Platform.OS === "android" && silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
-      const shouldRetrySilentInitialNativeScroll = Platform.OS === "android" && canFinishAfterSilentNativeDispatch && !initialScrollCompletion.didRetrySilentInitialScroll(state);
-      const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
-      const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
-      const shouldRetryUnalignedEndScroll = Platform.OS === "ios" && !isStillScrollingTo.isInitialScroll && isEndAlignedLastItemTarget(ctx, isStillScrollingTo) && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
-      if (shouldRetrySilentInitialNativeScroll) {
-        const targetOffset = (_b = (_a3 = getInitialScrollWatchdogTargetOffset(state)) != null ? _a3 : isStillScrollingTo.targetOffset) != null ? _b : 0;
-        const jiggleOffset = targetOffset >= SILENT_INITIAL_SCROLL_TARGET_EPSILON ? targetOffset - SILENT_INITIAL_SCROLL_TARGET_EPSILON : targetOffset + SILENT_INITIAL_SCROLL_TARGET_EPSILON;
-        initialScrollCompletion.markSilentInitialScrollRetry(state);
-        scrollToFallbackOffset(ctx, jiggleOffset);
-        state.scheduledWork.frame(
-          () => scrollToFallbackOffset(ctx, targetOffset),
-          "checkFinishedScrollRetryFrame"
-        );
-        scheduleFallbackCheck(SILENT_INITIAL_SCROLL_RETRY_DELAY_MS);
-      } else if (shouldRetryUnalignedEndScroll) {
-        scrollToFallbackOffset(ctx, completionState.clampedTargetOffset);
-        scheduleFallbackCheck(100);
-      } else if (shouldFinishZeroTarget || shouldFinishAfterObservedScroll || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
-        finishScrollTo(ctx);
-      } else if ((isNativeInitialPending || shouldRetryUnalignedInitialScroll) && numChecks <= maxChecks) {
-        const targetOffset = (_d = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : isStillScrollingTo.targetOffset) != null ? _d : state.scrollPending;
-        scrollToFallbackOffset(ctx, targetOffset);
-        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
-      } else {
-        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
-      }
-    }
-  };
-  scheduleFallbackCheck(initialDelay);
-}
-
-// src/core/doScrollTo.native.ts
-function doScrollTo(ctx, params) {
-  const state = ctx.state;
-  const { animated, horizontal, isInitialScroll, offset } = params;
-  const isAnimated = !!animated;
-  const { refScroller } = state;
-  const scroller = refScroller.current;
-  if (!scroller) {
-    return;
-  }
-  const isHorizontal = !!horizontal;
-  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
-  const nativeOffset = toNativeHorizontalOffset(state, offset, contentSize);
-  scroller.scrollTo({
-    animated: isAnimated,
-    x: isHorizontal ? nativeOffset : 0,
-    y: isHorizontal ? 0 : offset
-  });
-  if (isInitialScroll) {
-    initialScrollCompletion.markInitialScrollNativeDispatch(state);
-  }
-  if (isAnimated && Math.abs(state.scroll - offset) <= 1) {
-    checkFinishedScroll(ctx);
-  }
-  if (!isAnimated) {
-    state.scroll = offset;
-    checkFinishedScrollFallback(ctx);
-  }
-}
-
 // src/core/scrollRequestTracker.ts
 function getScrollRequestTracker(ctx) {
   if (!ctx.scrollRequestTracker) {
     let currentToken = 0;
-    const start = (resolve) => {
+    let waitingToken;
+    const start = (resolve, isInternal = false) => {
       const state = ctx.state;
+      if (!isInternal && (state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd)) {
+        finishMaintainScrollAtEnd(ctx);
+      }
       state.scheduledWork.cancel("imperativeScrollReady");
       const token = ++currentToken;
       settlePendingImperativeScroll(state);
       state.pendingScrollResolve = resolve;
+      waitingToken = token;
       return token;
     };
     const runNow = (token, resolve, run) => {
@@ -1585,6 +1377,7 @@ function getScrollRequestTracker(ctx) {
       if (token !== currentToken) {
         return;
       }
+      waitingToken = void 0;
       const didStartScroll = run();
       if (!didStartScroll || !state.scrollingTo) {
         if (state.pendingScrollResolve === resolve) {
@@ -1595,6 +1388,7 @@ function getScrollRequestTracker(ctx) {
     };
     ctx.scrollRequestTracker = {
       isCurrent: (token) => token === currentToken,
+      isWaitingToRun: () => waitingToken === currentToken && !!ctx.state.pendingScrollResolve,
       runNow,
       runNowIfIdle: (run) => {
         const state = ctx.state;
@@ -1602,7 +1396,7 @@ function getScrollRequestTracker(ctx) {
           return Promise.resolve();
         }
         return new Promise((resolve) => {
-          const token = start(resolve);
+          const token = start(resolve, true);
           runNow(token, resolve, run);
         });
       },
@@ -1666,87 +1460,6 @@ function requestAdjust(ctx, positionDiff, source) {
   }
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function finishMaintainScrollAtEnd(ctx) {
-  var _a3;
-  const { state } = ctx;
-  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
-  const nextPadding = getAlignItemsAtEndPadding(ctx);
-  state.maintainingScrollAtEnd = void 0;
-  state.pendingMaintainScrollAtEnd = false;
-  if (currentPadding !== nextPadding) {
-    set$(ctx, "alignItemsAtEndPadding", nextPadding);
-    state.scrollForNextCalculateItemsInView = void 0;
-    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
-    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
-    requestAdjust(ctx, nextScroll - state.scroll);
-  }
-}
-function doMaintainScrollAtEnd(ctx) {
-  const state = ctx.state;
-  const {
-    didContainersLayout,
-    didFinishInitialScroll,
-    pendingNativeMVCPAdjust,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
-  const shouldMaintainScrollAtEnd = !!((isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain) && maintainScrollAtEnd && didFinishInitialScroll);
-  if (shouldMaintainScrollAtEnd && !didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = true;
-    return false;
-  }
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
-  }
-  if (shouldMaintainScrollAtEnd && didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = false;
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
-    }
-    if (!state.maintainingScrollAtEnd) {
-      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
-      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
-      const scrollAtRequest = state.scroll;
-      state.maintainingScrollAtEnd = pendingState;
-      requestAnimationFrame(() => {
-        if (state.maintainingScrollAtEnd !== pendingState) {
-          return;
-        }
-        const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-        const didScrollSinceRequest = state.scroll !== scrollAtRequest;
-        if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
-          state.maintainingScrollAtEnd = activeState;
-          const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
-            () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
-          );
-          void scrollPromise.then(() => {
-            if (state.maintainingScrollAtEnd !== activeState) {
-              return;
-            }
-            if (state.pendingMaintainScrollAtEnd) {
-              state.maintainingScrollAtEnd = void 0;
-              doMaintainScrollAtEnd(ctx);
-            } else {
-              finishMaintainScrollAtEnd(ctx);
-            }
-          });
-        } else if (state.maintainingScrollAtEnd === pendingState) {
-          finishMaintainScrollAtEnd(ctx);
-        }
-      });
-    } else {
-      state.pendingMaintainScrollAtEnd = true;
-    }
-    return true;
-  }
-  finishMaintainScrollAtEnd(ctx);
-  return false;
-}
-
 // src/core/mvcp.ts
 var MVCP_POSITION_EPSILON = 0.1;
 var MVCP_ANCHOR_LOCK_TTL_MS = 300;
@@ -2064,125 +1777,489 @@ var getScrollVelocity = (state) => {
   if (Date.now() - newest.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
     return 0;
   }
-  let direction = 0;
-  let weightedVelocity = 0;
-  let totalWeight = 0;
-  for (let i = newestIndex; i > 0; i--) {
-    const current = scrollHistory[i];
-    const previous = scrollHistory[i - 1];
-    const scrollDiff = current.scroll - previous.scroll;
-    const timeDiff = current.time - previous.time;
-    const deltaSign = Math.sign(scrollDiff);
-    if (deltaSign !== 0) {
-      if (direction === 0) {
-        direction = deltaSign;
-      } else if (deltaSign !== direction) {
-        break;
-      }
-    }
-    if (newest.time - previous.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
-      break;
-    }
-    if (scrollDiff === 0 || timeDiff <= 0) {
-      continue;
-    }
-    const age = newest.time - current.time;
-    const weight = Math.exp(-age / SCROLL_VELOCITY_HALF_LIFE_MS);
-    weightedVelocity += scrollDiff / timeDiff * weight;
-    totalWeight += weight;
+  let direction = 0;
+  let weightedVelocity = 0;
+  let totalWeight = 0;
+  for (let i = newestIndex; i > 0; i--) {
+    const current = scrollHistory[i];
+    const previous = scrollHistory[i - 1];
+    const scrollDiff = current.scroll - previous.scroll;
+    const timeDiff = current.time - previous.time;
+    const deltaSign = Math.sign(scrollDiff);
+    if (deltaSign !== 0) {
+      if (direction === 0) {
+        direction = deltaSign;
+      } else if (deltaSign !== direction) {
+        break;
+      }
+    }
+    if (newest.time - previous.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
+      break;
+    }
+    if (scrollDiff === 0 || timeDiff <= 0) {
+      continue;
+    }
+    const age = newest.time - current.time;
+    const weight = Math.exp(-age / SCROLL_VELOCITY_HALF_LIFE_MS);
+    weightedVelocity += scrollDiff / timeDiff * weight;
+    totalWeight += weight;
+  }
+  return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
+};
+
+// src/utils/isInMVCPActiveMode.native.ts
+function isInMVCPActiveMode(state) {
+  return state.dataChangeNeedsScrollUpdate;
+}
+
+// src/core/updateScroll.ts
+function updateScroll(ctx, newScroll, forceUpdate, options) {
+  var _a3;
+  const state = ctx.state;
+  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
+  const prevScroll = state.scroll;
+  if ((options == null ? void 0 : options.markHasScrolled) !== false) {
+    state.hasScrolled = true;
+  }
+  const currentTime = Date.now();
+  state.lastBatchingAction = currentTime;
+  const adjust = scrollAdjustHandler.getAdjust();
+  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
+  if (adjustChanged) {
+    scrollHistory.length = 0;
+  }
+  state.lastScrollAdjustForHistory = adjust;
+  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
+    if (!adjustChanged) {
+      scrollHistory.push({ scroll: newScroll, time: currentTime });
+    }
+  }
+  if (scrollHistory.length > 5) {
+    scrollHistory.shift();
+  }
+  if (ignoreScrollFromMVCP && !scrollingTo) {
+    const { lt, gt } = ignoreScrollFromMVCP;
+    if (lt && newScroll < lt || gt && newScroll > gt) {
+      state.ignoreScrollFromMVCPIgnored = true;
+      return;
+    }
+  }
+  state.scrollPrev = prevScroll;
+  state.scrollPrevTime = state.scrollTime;
+  state.scroll = newScroll;
+  state.scrollTime = currentTime;
+  const scrollDelta = Math.abs(newScroll - prevScroll);
+  const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
+  const didCancelMaintainScrollAtEnd = Platform.OS === "web" && isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
+  if (didCancelMaintainScrollAtEnd) {
+    finishMaintainScrollAtEnd(ctx);
+  }
+  const allowedEdge = isUserScrollEvent ? beginReachedEdgeUserScroll(ctx, newScroll - prevScroll) : void 0;
+  const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
+  const scrollLength = state.scrollLength;
+  const isLargeUserScrollJump = scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust;
+  const scrollVelocity = getScrollVelocity(state);
+  updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
+  const lastCalculated = state.scrollLastCalculate;
+  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
+  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || didCancelMaintainScrollAtEnd || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
+  if (shouldUpdate) {
+    state.scrollLastCalculate = state.scroll;
+    state.ignoreScrollFromMVCPIgnored = false;
+    state.lastScrollDelta = scrollDelta;
+    const runCalculateItems = () => {
+      var _a4;
+      const calculateItemsParams = {
+        doMVCP: scrollingTo !== void 0,
+        scrollVelocity
+      };
+      if (isLargeUserScrollJump) {
+        calculateItemsParams.drawDistanceMode = "visible-first";
+      }
+      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, calculateItemsParams);
+      checkThresholds(ctx, allowedEdge);
+    };
+    if (isLargeUserScrollJump) {
+      state.mvcpAnchorLock = void 0;
+      state.pendingNativeMVCPAdjust = void 0;
+      state.userScrollAnchorReset = { keys: /* @__PURE__ */ new Set() };
+      state.scheduledWork.cancel("mvcpRecalculate");
+      flushSync(runCalculateItems);
+      scheduleFullDrawDistancePrewarm(ctx);
+    } else {
+      runCalculateItems();
+    }
+    const shouldMaintainScrollAtEndAfterPendingSettle = !!state.pendingMaintainScrollAtEnd || !!((_a3 = state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onDataChange);
+    if (didResolvePendingNativeMVCPAdjust && shouldMaintainScrollAtEndAfterPendingSettle) {
+      state.pendingMaintainScrollAtEnd = false;
+      doMaintainScrollAtEnd(ctx);
+    }
+    state.dataChangeNeedsScrollUpdate = false;
+    state.lastScrollDelta = 0;
+  }
+}
+
+// src/core/doMaintainScrollAtEnd.ts
+function interruptMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const maintaining = state.maintainingScrollAtEnd;
+  const cancelActiveScroll = !!(maintaining === "animated" || maintaining === "instant" || maintaining && ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isScrollToEnd));
+  if (cancelActiveScroll) {
+    cancelImperativeScroll(state);
+  }
+  if (maintaining || state.pendingMaintainScrollAtEnd) {
+    finishMaintainScrollAtEnd(ctx);
+  }
+  return cancelActiveScroll;
+}
+function finishMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
+  const nextPadding = getAlignItemsAtEndPadding(ctx);
+  state.maintainingScrollAtEnd = void 0;
+  state.pendingMaintainScrollAtEnd = false;
+  if (currentPadding !== nextPadding) {
+    set$(ctx, "alignItemsAtEndPadding", nextPadding);
+    state.scrollForNextCalculateItemsInView = void 0;
+    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
+    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
+    requestAdjust(ctx, nextScroll - state.scroll);
+  }
+}
+function doMaintainScrollAtEnd(ctx, options) {
+  var _a3, _b, _c, _d, _e, _f;
+  const state = ctx.state;
+  let didMaintain = false;
+  if (state.isDragging) {
+    finishMaintainScrollAtEnd(ctx);
+  } else {
+    const {
+      didContainersLayout,
+      didFinishInitialScroll,
+      pendingNativeMVCPAdjust,
+      props: { maintainScrollAtEnd }
+    } = state;
+    const immediate = (options == null ? void 0 : options.immediate) && Platform.OS === "web" && !(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.animated);
+    const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+    const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
+    const shouldMaintainScrollAtEnd = !!(!((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) && (!state.scrollingTo || state.scrollingTo.isScrollToEnd) && (isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain || ((_b = state.scrollingTo) == null ? void 0 : _b.isScrollToEnd)) && maintainScrollAtEnd && didFinishInitialScroll);
+    if (shouldMaintainScrollAtEnd && !state.scrollingTo) {
+      const scroller = state.refScroller.current;
+      const nativeMax = (_c = scroller == null ? void 0 : scroller.getMaxScrollOffset) == null ? void 0 : _c.call(scroller);
+      const observed = (_d = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _d.call(scroller);
+      if (nativeMax !== void 0 && observed !== void 0 && nativeMax < state.scroll - 1 && Math.abs(observed - nativeMax) <= 1) {
+        state.pendingMaintainScrollAtEnd = true;
+        state.scrollPending = observed;
+        updateScroll(ctx, observed, true, { markHasScrolled: false });
+      }
+    }
+    if (shouldMaintainScrollAtEnd && !didContainersLayout) {
+      state.pendingMaintainScrollAtEnd = true;
+    } else if (pendingNativeMVCPAdjust) {
+      state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    } else if (shouldMaintainScrollAtEnd && (state.scrollingTo || state.pendingScrollResolve)) {
+      if (immediate && ((_e = state.scrollingTo) == null ? void 0 : _e.isScrollToEnd) && !state.scrollingTo.animated) {
+        state.pendingMaintainScrollAtEnd = false;
+        ctx.scrollToEnd({ animated: false });
+        didMaintain = true;
+      } else {
+        state.pendingMaintainScrollAtEnd = true;
+        (_f = state.maintainingScrollAtEnd) != null ? _f : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      }
+    } else if (shouldMaintainScrollAtEnd && didContainersLayout) {
+      state.pendingMaintainScrollAtEnd = false;
+      const contentSize = getContentSize(ctx);
+      if (contentSize < state.scrollLength) {
+        state.scroll = 0;
+      }
+      if (!state.maintainingScrollAtEnd || immediate && state.maintainingScrollAtEnd === "pending-instant") {
+        const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+        const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+        const scrollAtRequest = state.scroll;
+        state.maintainingScrollAtEnd = pendingState;
+        const run = () => {
+          if (state.maintainingScrollAtEnd === pendingState) {
+            if (state.isDragging) {
+              finishMaintainScrollAtEnd(ctx);
+            } else {
+              const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+              const didScrollSinceRequest = Platform.OS === "web" && state.scroll !== scrollAtRequest;
+              if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
+                if (state.scrollingTo || state.pendingScrollResolve) {
+                  state.pendingMaintainScrollAtEnd = true;
+                } else {
+                  state.maintainingScrollAtEnd = activeState;
+                  const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
+                    () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
+                  );
+                  void scrollPromise.then(() => {
+                    if (state.maintainingScrollAtEnd === activeState) {
+                      if (state.pendingMaintainScrollAtEnd) {
+                        state.maintainingScrollAtEnd = void 0;
+                        doMaintainScrollAtEnd(ctx);
+                      } else {
+                        finishMaintainScrollAtEnd(ctx);
+                      }
+                    }
+                  });
+                }
+              } else if (state.maintainingScrollAtEnd === pendingState) {
+                finishMaintainScrollAtEnd(ctx);
+              }
+            }
+          }
+        };
+        if (immediate) {
+          run();
+        } else {
+          requestAnimationFrame(run);
+        }
+      } else {
+        state.pendingMaintainScrollAtEnd = true;
+      }
+      didMaintain = true;
+    } else {
+      finishMaintainScrollAtEnd(ctx);
+    }
+  }
+  return didMaintain;
+}
+
+// src/core/finishScrollTo.ts
+function finishScrollTo(ctx) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  if (state == null ? void 0 : state.scrollingTo) {
+    cancelScrollCompletionChecks(state);
+    const resolvePendingScroll = ((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) ? void 0 : state.pendingScrollResolve;
+    if (resolvePendingScroll) {
+      state.pendingScrollResolve = void 0;
+    }
+    const scrollingTo = state.scrollingTo;
+    state.scrollHistory.length = 0;
+    state.scrollingTo = void 0;
+    state.scrollTargetPinnedRange = void 0;
+    if (state.pendingTotalSize !== void 0) {
+      addTotalSize(ctx, null, state.pendingTotalSize);
+    }
+    if (PlatformAdjustBreaksScroll) {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    if (scrollingTo.isInitialScroll || state.initialScroll) {
+      const isOffsetSession = ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) === "offset";
+      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_c = state.initialScroll) == null ? void 0 : _c.viewPosition) === 1;
+      finishInitialScroll(ctx, {
+        onFinished: () => {
+          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+        },
+        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
+        recalculateItems: true,
+        schedulePreservedTargetClear: shouldPreserveResizeTarget,
+        syncObservedOffset: isOffsetSession,
+        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
+      });
+      return;
+    }
+    recalculateSettledScroll(ctx);
+    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+    if (state.pendingMaintainScrollAtEnd) {
+      state.maintainingScrollAtEnd = void 0;
+      doMaintainScrollAtEnd(ctx);
+    }
+  }
+}
+
+// src/core/checkFinishedScroll.ts
+var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
+var INITIAL_SCROLL_COMPLETION_TARGET_EPSILON = 1;
+var INITIAL_SCROLL_ZERO_TARGET_EPSILON = 1;
+var SILENT_INITIAL_SCROLL_RETRY_DELAY_MS = 16;
+var SILENT_INITIAL_SCROLL_TARGET_EPSILON = 1;
+function checkFinishedScroll(ctx, options) {
+  const scrollingTo = ctx.state.scrollingTo;
+  if (options == null ? void 0 : options.onlyIfAligned) {
+    if (!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) || scrollingTo.animated) {
+      return;
+    }
+    if (!getResolvedScrollCompletionState(ctx, scrollingTo).isAtResolvedTarget) {
+      return;
+    }
+  }
+  ctx.state.scheduledWork.frame(() => checkFinishedScrollFrame(ctx), "checkFinishedScrollFrame");
+}
+function hasScrollCompletionOwnership(state, options) {
+  const { clampedTargetOffset, scrollingTo } = options;
+  return !scrollingTo.isInitialScroll || state.hasScrolled || clampedTargetOffset <= INITIAL_SCROLL_COMPLETION_TARGET_EPSILON;
+}
+function isSilentInitialDispatch(state, scrollingTo) {
+  return !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled;
+}
+function getInitialScrollWatchdogTargetOffset(state) {
+  var _a3;
+  return (_a3 = initialScrollWatchdog.get(state)) == null ? void 0 : _a3.targetOffset;
+}
+function isNativeInitialNonZeroTarget(state) {
+  const targetOffset = getInitialScrollWatchdogTargetOffset(state);
+  return !state.didFinishInitialScroll && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
+}
+function shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) {
+  var _a3, _b;
+  if (!scrollingTo.isInitialScroll || scrollingTo.animated || !state.didContainersLayout) {
+    return false;
+  }
+  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap") {
+    return false;
+  }
+  const targetOffset = (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset;
+  if (initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled) {
+    return false;
+  }
+  if (initialScrollWatchdog.isAtZeroTargetOffset(targetOffset) || Math.abs(state.scroll - targetOffset) > 1 || Math.abs(state.scrollPending - targetOffset) > 1) {
+    return false;
+  }
+  return !!scrollingTo.waitForInitialScrollCompletionFrame || isNativeInitialNonZeroTarget(state);
+}
+function shouldFinishInitialZeroTargetScroll(ctx) {
+  var _a3;
+  const { state } = ctx;
+  return !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) && state.props.data.length > 0 && getContentSize(ctx) <= state.scrollLength && state.scrollPending <= INITIAL_SCROLL_ZERO_TARGET_EPSILON;
+}
+function isEndAlignedLastItemTarget(ctx, scrollingTo) {
+  return scrollingTo.index === ctx.state.props.data.length - 1 && scrollingTo.viewPosition === 1;
+}
+function getCurrentTargetOffset(ctx, scrollingTo) {
+  var _a3;
+  const index = scrollingTo.index;
+  const shouldRecomputeEndTarget = isEndAlignedLastItemTarget(ctx, scrollingTo);
+  const requestedTargetOffset = shouldRecomputeEndTarget && index !== void 0 ? calculateOffsetWithOffsetPosition(ctx, calculateOffsetForIndex(ctx, index), scrollingTo) : (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
+  return clampScrollOffset(ctx, requestedTargetOffset, scrollingTo);
+}
+function getResolvedScrollCompletionState(ctx, scrollingTo) {
+  const { state } = ctx;
+  const scroll = state.scrollPending;
+  const adjust = state.scrollAdjustHandler.getAdjust();
+  const clampedTargetOffset = getCurrentTargetOffset(ctx, scrollingTo);
+  const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
+  const diff1 = Math.abs(scroll - clampedTargetOffset);
+  const adjustedTargetOffset = clampedTargetOffset + adjust;
+  const diff2 = Math.abs(scroll - adjustedTargetOffset);
+  const canUseAdjustedCompletion = !scrollingTo.animated || Platform.OS === "ios";
+  return {
+    clampedTargetOffset,
+    isAtResolvedTarget: Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || canUseAdjustedCompletion && diff2 < 1)
+  };
+}
+function checkFinishedScrollFrame(ctx) {
+  const scrollingTo = ctx.state.scrollingTo;
+  if (!scrollingTo) {
+    return;
+  }
+  const { state } = ctx;
+  const completionState = getResolvedScrollCompletionState(ctx, scrollingTo);
+  if (completionState.isAtResolvedTarget && hasScrollCompletionOwnership(state, {
+    clampedTargetOffset: completionState.clampedTargetOffset,
+    scrollingTo
+  })) {
+    finishScrollTo(ctx);
   }
-  return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
-};
-
-// src/utils/isInMVCPActiveMode.native.ts
-function isInMVCPActiveMode(state) {
-  return state.dataChangeNeedsScrollUpdate;
 }
-
-// src/core/updateScroll.ts
-function updateScroll(ctx, newScroll, forceUpdate, options) {
+function scrollToFallbackOffset(ctx, offset) {
   var _a3;
+  (_a3 = ctx.state.refScroller.current) == null ? void 0 : _a3.scrollTo({
+    animated: false,
+    x: ctx.state.props.horizontal ? offset : 0,
+    y: ctx.state.props.horizontal ? 0 : offset
+  });
+}
+function checkFinishedScrollFallback(ctx) {
   const state = ctx.state;
-  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
-  const prevScroll = state.scroll;
-  if ((options == null ? void 0 : options.markHasScrolled) !== false) {
-    state.hasScrolled = true;
-  }
-  const currentTime = Date.now();
-  state.lastBatchingAction = currentTime;
-  const adjust = scrollAdjustHandler.getAdjust();
-  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
-  if (adjustChanged) {
-    scrollHistory.length = 0;
+  if (state.scheduledWork.has("checkFinishedScrollFallback")) {
+    return;
   }
-  state.lastScrollAdjustForHistory = adjust;
-  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
-    if (!adjustChanged) {
-      scrollHistory.push({ scroll: newScroll, time: currentTime });
+  const scrollingTo = state.scrollingTo;
+  const shouldFinishInitialZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+  const silentInitialDispatch = isSilentInitialDispatch(state, scrollingTo);
+  const canFinishInitialWithoutNativeProgress = scrollingTo !== void 0 ? shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) : false;
+  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && !shouldFinishInitialZeroTarget && !canFinishInitialWithoutNativeProgress || !state.didContainersLayout;
+  const initialDelay = shouldFinishInitialZeroTarget || canFinishInitialWithoutNativeProgress ? 0 : silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : slowTimeout ? 500 : 100;
+  let numChecks = 0;
+  const scheduleFallbackCheck = (delay) => {
+    state.scheduledWork.timeout(checkHasScrolled, delay, "checkFinishedScrollFallback");
+  };
+  const checkHasScrolled = () => {
+    var _a3, _b, _c, _d;
+    const isStillScrollingTo = state.scrollingTo;
+    if (isStillScrollingTo) {
+      numChecks++;
+      const isNativeInitialPending = isNativeInitialNonZeroTarget(state) && !state.hasScrolled;
+      const maxChecks = silentInitialDispatch ? 5 : isNativeInitialPending ? INITIAL_SCROLL_MAX_FALLBACK_CHECKS : 5;
+      const shouldFinishZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+      const canFinishInitialScrollWithoutNativeProgress = shouldFinishInitialScrollWithoutNativeProgress(
+        state,
+        isStillScrollingTo
+      );
+      const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
+      const canFinishAfterSilentNativeDispatch = Platform.OS === "android" && silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
+      const shouldRetrySilentInitialNativeScroll = Platform.OS === "android" && canFinishAfterSilentNativeDispatch && !initialScrollCompletion.didRetrySilentInitialScroll(state);
+      const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
+      const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
+      const shouldRetryUnalignedEndScroll = Platform.OS !== "web" && !isStillScrollingTo.isInitialScroll && isEndAlignedLastItemTarget(ctx, isStillScrollingTo) && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
+      if (shouldRetrySilentInitialNativeScroll) {
+        const targetOffset = (_b = (_a3 = getInitialScrollWatchdogTargetOffset(state)) != null ? _a3 : isStillScrollingTo.targetOffset) != null ? _b : 0;
+        const jiggleOffset = targetOffset >= SILENT_INITIAL_SCROLL_TARGET_EPSILON ? targetOffset - SILENT_INITIAL_SCROLL_TARGET_EPSILON : targetOffset + SILENT_INITIAL_SCROLL_TARGET_EPSILON;
+        initialScrollCompletion.markSilentInitialScrollRetry(state);
+        scrollToFallbackOffset(ctx, jiggleOffset);
+        state.scheduledWork.frame(
+          () => scrollToFallbackOffset(ctx, targetOffset),
+          "checkFinishedScrollRetryFrame"
+        );
+        scheduleFallbackCheck(SILENT_INITIAL_SCROLL_RETRY_DELAY_MS);
+      } else if (shouldRetryUnalignedEndScroll) {
+        scrollToFallbackOffset(ctx, completionState.clampedTargetOffset);
+        scheduleFallbackCheck(100);
+      } else if (shouldFinishZeroTarget || shouldFinishAfterObservedScroll || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
+        finishScrollTo(ctx);
+      } else if ((isNativeInitialPending || shouldRetryUnalignedInitialScroll) && numChecks <= maxChecks) {
+        const targetOffset = (_d = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : isStillScrollingTo.targetOffset) != null ? _d : state.scrollPending;
+        scrollToFallbackOffset(ctx, targetOffset);
+        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+      } else {
+        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+      }
     }
+  };
+  scheduleFallbackCheck(initialDelay);
+}
+
+// src/core/doScrollTo.native.ts
+function doScrollTo(ctx, params) {
+  const state = ctx.state;
+  const { animated, horizontal, isInitialScroll, offset } = params;
+  const isAnimated = !!animated;
+  const { refScroller } = state;
+  const scroller = refScroller.current;
+  if (!scroller) {
+    return;
   }
-  if (scrollHistory.length > 5) {
-    scrollHistory.shift();
-  }
-  if (ignoreScrollFromMVCP && !scrollingTo) {
-    const { lt, gt } = ignoreScrollFromMVCP;
-    if (lt && newScroll < lt || gt && newScroll > gt) {
-      state.ignoreScrollFromMVCPIgnored = true;
-      return;
-    }
+  const isHorizontal = !!horizontal;
+  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
+  const nativeOffset = toNativeHorizontalOffset(state, offset, contentSize);
+  scroller.scrollTo({
+    animated: isAnimated,
+    x: isHorizontal ? nativeOffset : 0,
+    y: isHorizontal ? 0 : offset
+  });
+  if (isInitialScroll) {
+    initialScrollCompletion.markInitialScrollNativeDispatch(state);
   }
-  state.scrollPrev = prevScroll;
-  state.scrollPrevTime = state.scrollTime;
-  state.scroll = newScroll;
-  state.scrollTime = currentTime;
-  const scrollDelta = Math.abs(newScroll - prevScroll);
-  const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
-  const didCancelMaintainScrollAtEnd = isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
-  if (didCancelMaintainScrollAtEnd) {
-    finishMaintainScrollAtEnd(ctx);
+  if (isAnimated && Math.abs(state.scroll - offset) <= 1) {
+    checkFinishedScroll(ctx);
   }
-  const allowedEdge = isUserScrollEvent ? beginReachedEdgeUserScroll(ctx, newScroll - prevScroll) : void 0;
-  const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
-  const scrollLength = state.scrollLength;
-  const isLargeUserScrollJump = scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust;
-  const scrollVelocity = getScrollVelocity(state);
-  updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
-  const lastCalculated = state.scrollLastCalculate;
-  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || didCancelMaintainScrollAtEnd || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
-  if (shouldUpdate) {
-    state.scrollLastCalculate = state.scroll;
-    state.ignoreScrollFromMVCPIgnored = false;
-    state.lastScrollDelta = scrollDelta;
-    const runCalculateItems = () => {
-      var _a4;
-      const calculateItemsParams = {
-        doMVCP: scrollingTo !== void 0,
-        scrollVelocity
-      };
-      if (isLargeUserScrollJump) {
-        calculateItemsParams.drawDistanceMode = "visible-first";
-      }
-      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, calculateItemsParams);
-      checkThresholds(ctx, allowedEdge);
-    };
-    if (isLargeUserScrollJump) {
-      state.mvcpAnchorLock = void 0;
-      state.pendingNativeMVCPAdjust = void 0;
-      state.userScrollAnchorReset = { keys: /* @__PURE__ */ new Set() };
-      state.scheduledWork.cancel("mvcpRecalculate");
-      flushSync(runCalculateItems);
-      scheduleFullDrawDistancePrewarm(ctx);
-    } else {
-      runCalculateItems();
-    }
-    const shouldMaintainScrollAtEndAfterPendingSettle = !!state.pendingMaintainScrollAtEnd || !!((_a3 = state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onDataChange);
-    if (didResolvePendingNativeMVCPAdjust && shouldMaintainScrollAtEndAfterPendingSettle) {
-      state.pendingMaintainScrollAtEnd = false;
-      doMaintainScrollAtEnd(ctx);
-    }
-    state.dataChangeNeedsScrollUpdate = false;
-    state.lastScrollDelta = 0;
+  if (!isAnimated) {
+    state.scroll = offset;
+    checkFinishedScrollFallback(ctx);
   }
 }
 
@@ -2336,7 +2413,9 @@ function scrollTo(ctx, params) {
       pinScrollTargetRenderRange(ctx, targetOffset, scrollTarget.index);
     }
   }
-  state.scrollPending = targetOffset;
+  if (!animated || isInitialScroll) {
+    state.scrollPending = targetOffset;
+  }
   syncInitialScrollNativeWatchdog(state, { isInitialScroll, requestedOffset: offset, targetOffset });
   if (!isInitialScroll && !noScrollingTo && Math.abs(state.scroll - targetOffset) > 1) {
     if (animated) {
@@ -2713,13 +2792,13 @@ function rearmBootstrapInitialScroll(ctx, options) {
   queueBootstrapInitialScrollReevaluation(ctx.state);
 }
 function createInitialScrollAtEndTarget(options) {
-  const { dataLength, footerSize, preserveForFooterLayout, stylePaddingEnd } = options;
+  const { dataLength, footerSize, index, preserveForFooterLayout, stylePaddingEnd } = options;
   return {
     contentOffset: void 0,
-    index: Math.max(0, dataLength - 1),
+    index: index != null ? index : Math.max(0, dataLength - 1),
     preserveForBottomPadding: true,
     preserveForFooterLayout,
-    viewOffset: -stylePaddingEnd - footerSize,
+    viewOffset: getEndAlignedViewOffset(stylePaddingEnd, footerSize),
     viewPosition: 1
   };
 }
@@ -2735,13 +2814,14 @@ function isRetargetableBottomAlignedInitialScrollTarget(target) {
 function createRetargetedBottomAlignedInitialScroll(options) {
   const { dataLength, footerSize, initialScrollAtEnd, stylePaddingEnd, target } = options;
   const preserveForFooterLayout = shouldPreserveInitialScrollForFooterLayout(target);
+  const alignsToContentEnd = initialScrollAtEnd || isEndOfContentTarget(target, dataLength);
   return {
     ...target,
     contentOffset: void 0,
     index: initialScrollAtEnd ? Math.max(0, dataLength - 1) : target.index,
     preserveForBottomPadding: true,
     preserveForFooterLayout,
-    viewOffset: -stylePaddingEnd - (preserveForFooterLayout ? footerSize : 0),
+    viewOffset: getEndAlignedViewOffset(stylePaddingEnd, alignsToContentEnd ? footerSize : 0),
     viewPosition: 1
   };
 }
@@ -2755,7 +2835,7 @@ function clearPendingInitialScrollFooterLayout(ctx, options) {
   }
   const clearedFooterTarget = createInitialScrollAtEndTarget({
     dataLength,
-    footerSize: 0,
+    footerSize: peek$(ctx, "footerSize") || 0,
     preserveForFooterLayout: void 0,
     stylePaddingEnd
   });
@@ -2778,13 +2858,12 @@ function getObservedBootstrapInitialScrollOffset(state) {
   return typeof observedOffset === "number" && Number.isFinite(observedOffset) ? observedOffset : (_d = (_c = state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0;
 }
 function getPreservedEndAnchorOffsetDiff(ctx) {
-  var _a3;
   const state = ctx.state;
   const initialScroll = state.initialScroll;
-  if (!state.didFinishInitialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) || !initialScroll || initialScroll.viewPosition !== 1 || state.props.data.length === 0 || isOffsetInitialScrollSession(state)) {
+  if (!state.didFinishInitialScroll || state.scrollingTo || state.pendingScrollResolve || state.maintainingScrollAtEnd || state.isDragging || !initialScroll || initialScroll.viewPosition !== 1 || state.props.data.length === 0 || isOffsetInitialScrollSession(state)) {
     return;
   }
-  const currentOffset = typeof state.lastNativeScroll === "number" && Number.isFinite(state.lastNativeScroll) ? state.lastNativeScroll : getObservedBootstrapInitialScrollOffset(state);
+  const currentOffset = Platform.OS !== "web" && typeof state.lastNativeScroll === "number" && Number.isFinite(state.lastNativeScroll) ? state.lastNativeScroll : getObservedBootstrapInitialScrollOffset(state);
   return resolveInitialScrollOffset(ctx, initialScroll) - currentOffset;
 }
 function schedulePreservedEndAnchorCorrection(ctx) {
@@ -2812,6 +2891,9 @@ function schedulePreservedEndAnchorCorrectionFrame(ctx, correction) {
     const hasObservedNativeScrollAfterRequest = !activeCorrection.lastRequestTime || ((_a3 = state.lastNativeScrollTime) != null ? _a3 : 0) > activeCorrection.lastRequestTime;
     if (hasObservedNativeScrollAfterRequest) {
       activeCorrection.lastRequestTime = Date.now();
+      if (Platform.OS === "web") {
+        state.scroll = getObservedBootstrapInitialScrollOffset(state);
+      }
       requestAdjust(ctx, offsetDiff);
     }
     schedulePreservedEndAnchorCorrectionFrame(ctx, correction);
@@ -2934,10 +3016,10 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
 function handleBootstrapInitialScrollFooterLayout(ctx, options) {
   const { dataLength, footerSize, initialScrollAtEnd, stylePaddingEnd } = options;
   const state = ctx.state;
-  if (!initialScrollAtEnd) {
+  const initialScroll = state.initialScroll;
+  if (!initialScrollAtEnd && !isEndOfContentTarget(initialScroll, dataLength)) {
     return;
   }
-  const initialScroll = state.initialScroll;
   if (isOffsetInitialScrollSession(state) || dataLength === 0 || !initialScroll) {
     return;
   }
@@ -2955,6 +3037,7 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
     const updatedInitialScroll = createInitialScrollAtEndTarget({
       dataLength,
       footerSize,
+      index: initialScrollAtEnd ? void 0 : initialScroll.index,
       preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
       stylePaddingEnd
     });
@@ -3191,6 +3274,11 @@ function handleInitialScrollDataChange(ctx, options) {
   const state = ctx.state;
   const previousInitialScrollDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
   const shouldUseLatestInitialScroll = dataLength > 0 && (!state.hasHadNonEmptyData || didStartFreshData);
+  if (didStartFreshData) {
+    cancelImperativeScroll(state);
+    state.maintainingScrollAtEnd = void 0;
+    state.pendingMaintainScrollAtEnd = false;
+  }
   if (dataLength > 0) {
     state.hasHadNonEmptyData = true;
   }
@@ -3909,7 +3997,7 @@ function getExpandedContainerPoolSize(dataLength, numContainers) {
 }
 
 // src/utils/findAvailableContainers.ts
-function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, getRequiredItemType, protectedKeys) {
+function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, protectedKeys, reverseItemOrder = false) {
   var _a3;
   const numNeeded = needNewContainers.length;
   if (numNeeded === 0) {
@@ -3918,16 +4006,27 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
   const numContainers = peek$(ctx, "numContainers");
   const state = ctx.state;
   const { containerItemMetadata, stickyContainerPool } = state;
+  const { data, getItemType } = state.props;
+  const hasItemTypes = !!getItemType;
   const shouldAvoidAssignedContainerReuse = state.props.recycleItems && !!state.props.positionComponentInternal;
   const pendingRemovalSet = pendingRemoval.length > 0 ? new Set(pendingRemoval) : void 0;
-  const requests = needNewContainers.map((itemIndex, order) => ({
-    isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
-    itemIndex,
-    itemType: getRequiredItemType == null ? void 0 : getRequiredItemType(itemIndex),
-    order
-  }));
-  const normalRequests = requests.filter((request) => !request.isSticky);
-  const stickyRequests = requests.filter((request) => request.isSticky);
+  const requests = new Array(numNeeded);
+  const normalRequests = [];
+  const stickyRequests = [];
+  for (let order = 0; order < numNeeded; order++) {
+    const itemIndex = needNewContainers[order];
+    const itemType = getItemType == null ? void 0 : getItemType(data[itemIndex], itemIndex);
+    const request = {
+      isBuffered: itemIndex >= startBuffered && itemIndex <= endBuffered,
+      isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
+      itemIndex,
+      itemType: hasItemTypes ? itemType !== void 0 ? String(itemType) : "" : void 0,
+      order,
+      renderPriority: reverseItemOrder ? -itemIndex : itemIndex
+    };
+    requests[order] = request;
+    (request.isSticky ? stickyRequests : normalRequests).push(request);
+  }
   const normalCandidates = [];
   const stickyCandidates = [];
   for (let containerIndex = 0; containerIndex < numContainers; containerIndex++) {
@@ -3983,7 +4082,7 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
     }
   };
   const assignFromPool = (pendingRequests, candidates, allowCrossType) => {
-    if (getRequiredItemType) {
+    if (hasItemTypes) {
       assignMatching(
         pendingRequests,
         candidates,
@@ -4007,6 +4106,11 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
     }
     assign(request, containerIndex);
   }
+  if (normalRequests.length > 1 || stickyRequests.length > 1) {
+    const containerIndices = [];
+    reorderPoolAssignments(normalRequests, allocations, containerIndices, hasItemTypes);
+    reorderPoolAssignments(stickyRequests, allocations, containerIndices, hasItemTypes);
+  }
   if (pendingRemovalChanged) {
     pendingRemoval.length = 0;
     if (pendingRemovalSet) {
@@ -4036,12 +4140,53 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
 function comparatorByDistance(a, b) {
   return b.distance - a.distance;
 }
+function comparatorByRenderPriority(a, b) {
+  return Number(b.isBuffered) - Number(a.isBuffered) || a.renderPriority - b.renderPriority;
+}
+function comparatorByIndex(a, b) {
+  return a - b;
+}
+function reorderPoolAssignments(requests, allocations, containerIndices, groupByType) {
+  if (requests.length >= 2) {
+    if (groupByType) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const request of requests) {
+        const group = groups.get(request.itemType);
+        if (group) {
+          group.push(request);
+        } else {
+          groups.set(request.itemType, [request]);
+        }
+      }
+      for (const group of groups.values()) {
+        reorderPoolAssignments(group, allocations, containerIndices, false);
+      }
+    } else {
+      containerIndices.length = 0;
+      let indicesSorted = true;
+      for (let i = 0; i < requests.length; i++) {
+        const containerIndex = allocations[requests[i].order].containerIndex;
+        if (i > 0 && containerIndex < containerIndices[i - 1]) {
+          indicesSorted = false;
+        }
+        containerIndices.push(containerIndex);
+      }
+      if (!indicesSorted) {
+        containerIndices.sort(comparatorByIndex);
+      }
+      requests.sort(comparatorByRenderPriority);
+      for (let i = 0; i < requests.length; i++) {
+        allocations[requests[i].order].containerIndex = containerIndices[i];
+      }
+    }
+  }
+}
 
 // src/utils/setDidLayout.ts
 function setDidLayout(ctx) {
   const state = ctx.state;
   state.queuedInitialLayout = true;
-  checkAtBottom(ctx);
+  checkThresholds(ctx);
   setInitialRenderState(ctx, { didLayout: true });
   if (state.pendingMaintainScrollAtEnd) {
     doMaintainScrollAtEnd(ctx);
@@ -4269,9 +4414,9 @@ function calculateItemsInView(ctx, params = {}) {
       enableScrollForNextCalculateItemsInView,
       idCache,
       indexByKey,
-      minIndexSizeChanged,
+      positionRecalculationStartIndex,
       positions,
-      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, getItemType, keyExtractor, onStickyHeaderChange },
+      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, keyExtractor, onStickyHeaderChange },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -4387,21 +4532,21 @@ function calculateItemsInView(ctx, params = {}) {
     if (dataChanged) {
       resetLayoutCachesForDataChange(state);
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _e : 0;
-    const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && minIndexSizeChanged !== void 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = positionRecalculationStartIndex != null ? positionRecalculationStartIndex : state.startBuffered) != null ? _e : 0;
+    const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && positionRecalculationStartIndex !== void 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
       // A changed size shifts every following position. The scrolling early-exit
       // would leave the untouched suffix in the old coordinate space.
-      forceFullUpdate: !!forceFullItemPositions || minIndexSizeChanged !== void 0,
+      forceFullUpdate: !!forceFullItemPositions || positionRecalculationStartIndex !== void 0,
       optimizeForVisibleWindow,
       scrollBottomBuffered,
       scrollVelocity: speed,
       startIndex
     });
     totalSize = getContentSize(ctx);
-    if (minIndexSizeChanged !== void 0) {
-      state.minIndexSizeChanged = void 0;
+    if (positionRecalculationStartIndex !== void 0) {
+      state.positionRecalculationStartIndex = void 0;
     }
     let protectedContainerKeys;
     if (dataChanged && doMVCP && state.props.maintainVisibleContentPosition.data && state.didContainersLayout && state.idsInView.length > 0) {
@@ -4577,18 +4722,18 @@ function calculateItemsInView(ctx, params = {}) {
         set$(ctx, "activeStickyIndex", -1);
       }
       if (needNewContainers.length > 0) {
-        const getRequiredItemType = getItemType ? (i) => {
-          const itemType = getItemType(data[i], i);
-          return itemType !== void 0 ? String(itemType) : "";
-        } : void 0;
         const availableContainerAllocations = findAvailableContainers(
           ctx,
           needNewContainers,
           startBuffered,
           endBuffered,
           pendingRemoval,
-          getRequiredItemType,
-          protectedContainerKeys
+          protectedContainerKeys,
+          // Initial end alignment has no scroll velocity yet. Keep its
+          // target-side rows first until the initial scroll settles.
+          // After a pause velocity can be zero on the first movement;
+          // use its displacement without treating initial insets as motion.
+          hasActiveInitialScroll(state) ? (initialScroll == null ? void 0 : initialScroll.viewPosition) === 1 : (speed || (state.hasScrolled ? state.scroll - state.scrollPrev : 0)) < 0
         );
         for (const allocation of availableContainerAllocations) {
           const i = allocation.itemIndex;
@@ -4735,6 +4880,7 @@ function maybeUpdateAnchoredEndSpace(ctx) {
   const nextAnchorIndex = anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex;
   let nextAnchorKey;
   let isReady = true;
+  let canUpdateSize = true;
   let nextSize = 0;
   if (anchoredEndSpace) {
     const { anchorIndex, anchorMaxSize, anchorOffset = 0 } = anchoredEndSpace;
@@ -4756,25 +4902,30 @@ function maybeUpdateAnchoredEndSpace(ctx) {
       contentBelowAnchor = Math.max(0, contentBelowAnchor - ctx.scrollAxisGap);
       contentBelowAnchor += (ctx.values.get("footerSize") || 0) + getStylePaddingEnd(state.props);
       isReady = !hasUnknownTailSize;
-      nextSize = hasUnknownTailSize ? previousSize || 0 : Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      const knownSizeBound = Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      nextSize = hasUnknownTailSize ? Math.min(previousSize || 0, knownSizeBound) : knownSizeBound;
     } else if (anchorIndex >= 0) {
       isReady = false;
+      canUpdateSize = false;
     }
   }
   const didSizeChange = previousSize !== nextSize && (previousSize !== void 0 || anchoredEndSpace !== void 0);
   const didEffectiveSizeChange = (previousSize || 0) !== nextSize;
+  const canApplySizeChange = canUpdateSize && (isReady || previousSize !== void 0);
   const didReadyAnchorChange = previousReadyAnchorIndex !== nextAnchorIndex || previousReadyAnchorKey !== nextAnchorKey;
-  if (isReady && (didSizeChange || didReadyAnchorChange)) {
+  const didBecomeReady = isReady && state.anchoredEndSpacePendingReady;
+  state.anchoredEndSpacePendingReady = !isReady;
+  if (canApplySizeChange && didSizeChange) {
+    set$(ctx, "anchoredEndSpaceSize", nextSize);
+    (_a3 = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onSizeChanged) == null ? void 0 : _a3.call(anchoredEndSpace, nextSize);
+  }
+  if (canApplySizeChange && didEffectiveSizeChange) {
+    updateContentMetricsState(ctx);
+    updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
+  }
+  if (isReady && (didSizeChange || didReadyAnchorChange || didBecomeReady)) {
     state.anchoredEndSpaceReadyAnchorIndex = nextAnchorIndex;
     state.anchoredEndSpaceReadyAnchorKey = nextAnchorKey;
-    if (didSizeChange) {
-      set$(ctx, "anchoredEndSpaceSize", nextSize);
-      (_a3 = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onSizeChanged) == null ? void 0 : _a3.call(anchoredEndSpace, nextSize);
-    }
-    if (didEffectiveSizeChange) {
-      updateContentMetricsState(ctx);
-      updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
-    }
     (_b = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onReady) == null ? void 0 : _b.call(anchoredEndSpace, { anchorIndex: nextAnchorIndex, anchorKey: nextAnchorKey, size: nextSize });
   }
   return nextSize;
@@ -4878,6 +5029,7 @@ function updateItemSizesBatch(ctx, measurements) {
   var _a3;
   const state = ctx.state;
   const result = {};
+  const previousTotalSize = state.totalSize;
   for (const measurement of measurements) {
     const ownsMeasuredItem = measurement.containerId === void 0 || peek$(ctx, `containerItemKey${measurement.containerId}`) === measurement.itemKey;
     if (ownsMeasuredItem) {
@@ -4888,6 +5040,9 @@ function updateItemSizesBatch(ctx, measurements) {
       mergeItemSizeUpdateResult(result, nextResult);
     }
   }
+  if (state.totalSize !== previousTotalSize) {
+    set$(ctx, "totalSize", state.totalSize);
+  }
   flushItemSizeUpdates(ctx, result);
 }
 function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
@@ -4926,12 +5081,12 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
   }
   let needsRecalculate = !didContainersLayout;
   let shouldMaintainScrollAtEnd = false;
-  let minIndexSizeChanged;
+  let positionRecalculationStartIndex;
   const prevSizeKnown = state.sizesKnown.get(itemKey);
-  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem);
+  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, false);
   const size = roundSize(horizontal ? sizeObj.width : sizeObj.height);
   if (diff !== 0) {
-    minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+    positionRecalculationStartIndex = positionRecalculationStartIndex !== void 0 ? Math.min(positionRecalculationStartIndex, index) : index;
     const { startBuffered, endBuffered } = state;
     needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
     if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
@@ -4948,8 +5103,8 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
       size
     });
   }
-  if (minIndexSizeChanged !== void 0) {
-    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
+  if (positionRecalculationStartIndex !== void 0) {
+    state.positionRecalculationStartIndex = state.positionRecalculationStartIndex !== void 0 ? Math.min(state.positionRecalculationStartIndex, positionRecalculationStartIndex) : positionRecalculationStartIndex;
   }
   updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
   if (didContainersLayout || checkAllSizesKnown(state, state.startBuffered, state.endBuffered)) {
@@ -4966,7 +5121,7 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     didMeasureUserScrollAnchorResetItem
   };
 }
-function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
+function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, notifyTotalSize = true) {
   var _a3, _b;
   const state = ctx.state;
   const {
@@ -4989,7 +5144,16 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     fixedItemSize,
     itemType
   } : void 0;
-  const prevSize = getItemSize(ctx, itemKey, index, itemData, void 0, void 0, void 0, resolvedItemSize);
+  const prevSize = getItemSize(
+    ctx,
+    itemKey,
+    index,
+    itemData,
+    void 0,
+    void 0,
+    notifyTotalSize,
+    resolvedItemSize
+  );
   const rawSize = horizontal ? sizeObj.width : sizeObj.height;
   const prevSizeKnown = sizesKnown.get(itemKey);
   if (Platform.OS !== "web" && prevSizeKnown !== void 0 && isNativeLayoutNoise(rawSize - prevSizeKnown)) {
@@ -5014,7 +5178,7 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     }
   }
   if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-    setSize(ctx, itemKey, size);
+    setSize(ctx, itemKey, size, notifyTotalSize);
     return size - prevSize;
   }
   return 0;
@@ -5165,10 +5329,16 @@ function useValue$(key, params) {
     var _a3;
     return (_a3 = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a3 : 0;
   };
-  const animValue = useAnimatedValue(getNewValue());
+  const initialValue = getNewValue();
+  const animValue = useAnimatedValue(initialValue);
+  const lastValue = React2.useRef(initialValue);
   React2.useLayoutEffect(() => {
     const syncCurrentValue = () => {
-      animValue.setValue(getNewValue());
+      const nextValue = getNewValue();
+      if (lastValue.current !== nextValue) {
+        lastValue.current = nextValue;
+        animValue.setValue(nextValue);
+      }
     };
     const unsubscribe = listen$(ctx, key, syncCurrentValue);
     syncCurrentValue();
@@ -6083,6 +6253,7 @@ var ListComponent = typedMemo(function ListComponent2({
   renderScrollComponent,
   onLayoutFooter,
   onInternalScrollBeginDrag,
+  onInternalScrollEndDrag,
   onInternalScrollEnd,
   scrollAdjustHandler,
   snapToIndices,
@@ -6154,7 +6325,7 @@ var ListComponent = typedMemo(function ListComponent2({
     SnapOrScroll,
     {
       ...rest,
-      ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} : { onScrollBeginDrag: onInternalScrollBeginDrag },
+      ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} : { onScrollBeginDrag: onInternalScrollBeginDrag, onScrollEndDrag: onInternalScrollEndDrag },
       contentContainerStyle: [
         horizontal ? { height: "100%" } : {},
         contentContainerStyle,
@@ -6273,7 +6444,7 @@ function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {})
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
-    state.minIndexSizeChanged = 0;
+    state.positionRecalculationStartIndex = 0;
     state.scrollForNextCalculateItemsInView = void 0;
   }
   calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
@@ -6437,7 +6608,7 @@ function handleLayout(ctx, layoutParam, setCanRender) {
       set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
     }
     if (maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onLayout) {
-      doMaintainScrollAtEnd(ctx);
+      doMaintainScrollAtEnd(ctx, { immediate: true });
     }
     checkThresholds(ctx);
     if (state) {
@@ -6670,14 +6841,17 @@ function scrollToEnd(ctx, options) {
   if (index === -1) {
     return false;
   }
-  const paddingBottom = state.props.stylePaddingBottom || 0;
+  const paddingBottom = getStylePaddingEnd(state.props);
   const footerSize = peek$(ctx, "footerSize") || 0;
   scrollToIndex(ctx, {
     ...options,
     index,
-    viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
+    viewOffset: getEndAlignedViewOffset(paddingBottom, footerSize) + ((options == null ? void 0 : options.viewOffset) || 0),
     viewPosition: 1
   });
+  if (state.scrollingTo) {
+    state.scrollingTo.isScrollToEnd = true;
+  }
   return true;
 }
 
@@ -6875,7 +7049,7 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
-    state.minIndexSizeChanged = 0;
+    state.positionRecalculationStartIndex = 0;
     state.scrollForNextCalculateItemsInView = void 0;
     state.pendingTotalSize = void 0;
     state.totalSize = 0;
@@ -7269,10 +7443,12 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onMetricsChange,
     onLayout: onLayoutProp,
     onLoad,
+    onReady,
     onMomentumScrollEnd,
     onRefresh,
     onScroll: onScrollProp,
     onScrollBeginDrag,
+    onScrollEndDrag,
     onStartReached,
     onStartReachedThreshold = 0.5,
     onStickyHeaderChange,
@@ -7341,17 +7517,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const initialScrollProp = initialScrollAtEnd ? {
     index: Math.max(0, dataProp.length - 1),
     preserveForBottomPadding: true,
-    viewOffset: -stylePaddingEndState,
+    viewOffset: getEndAlignedViewOffset(stylePaddingEndState),
     viewPosition: 1
   } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
     index: (_b = initialScrollIndexProp.index) != null ? _b : 0,
     preserveForBottomPadding: initialScrollIndexProp.viewOffset === void 0 && initialScrollIndexProp.viewPosition === 1 ? true : void 0,
-    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 ? -stylePaddingEndState : 0,
+    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
     viewPosition: (_d = initialScrollIndexProp.viewPosition) != null ? _d : 0
   } : {
     index: initialScrollIndexProp != null ? initialScrollIndexProp : 0,
     preserveForBottomPadding: shouldBottomAlignNumericInitialScrollIndex ? true : void 0,
-    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? -stylePaddingEndState : 0,
+    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
     viewPosition: shouldBottomAlignNumericInitialScrollIndex ? 1 : void 0
   } : initialScrollUsesOffsetOnly ? {
     contentOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0,
@@ -7411,6 +7587,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         endReachedSnapshot: void 0,
         firstFullyOnScreenIndex: -1,
         freshDataTransitionEpoch: 0,
+        handledDataChangeEpoch: 0,
+        handledFreshDataTransitionEpoch: 0,
         hasHadNonEmptyData: dataProp.length > 0,
         idCache: [],
         idsInView: [],
@@ -7427,11 +7605,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         lastLayout: void 0,
         lastScrollDelta: 0,
         loadStartTime: Date.now(),
-        minIndexSizeChanged: 0,
         nativeContentInset: void 0,
         nativeMarginTop: 0,
         pendingDataComparison: void 0,
         pendingNativeMVCPAdjust: void 0,
+        positionRecalculationStartIndex: 0,
         positions: [],
         props: {},
         queuedCalculateItemsInView: 0,
@@ -7470,8 +7648,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     refState.current = ctx.state;
   }
   const state = refState.current;
-  const handledDataChangeEpochRef = React2.useRef(state.dataChangeEpoch);
-  const handledFreshDataTransitionEpochRef = React2.useRef(state.freshDataTransitionEpoch);
   const isFirstLocal = state.isFirst;
   const previousAdaptiveRender = state.props.adaptiveRender;
   const previousHideItemsUntilMeasured = state.props.hideItemsUntilMeasured;
@@ -7536,8 +7712,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onItemSizeChanged,
     onLoad,
     onMomentumScrollEnd,
+    onReady,
     onScroll: throttleScrollFn,
     onScrollBeginDrag,
+    onScrollEndDrag,
     onStartReached,
     onStartReachedThreshold,
     onStickyHeaderChange,
@@ -7626,10 +7804,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     useDevChecks(props);
   }
   React2.useLayoutEffect(() => {
-    const didDataChange = handledDataChangeEpochRef.current !== dataChangeEpoch;
-    const didStartFreshData = handledFreshDataTransitionEpochRef.current !== freshDataTransitionEpoch;
-    handledDataChangeEpochRef.current = dataChangeEpoch;
-    handledFreshDataTransitionEpochRef.current = freshDataTransitionEpoch;
+    const didDataChange = state.handledDataChangeEpoch !== dataChangeEpoch;
+    const didStartFreshData = state.handledFreshDataTransitionEpoch !== freshDataTransitionEpoch;
+    state.handledDataChangeEpoch = dataChangeEpoch;
+    state.handledFreshDataTransitionEpoch = freshDataTransitionEpoch;
     if (didStartFreshData) {
       resetInitialRenderState(ctx, {
         resetInitialScroll: !!initialScrollProp,
@@ -7833,17 +8011,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: (event) => onScroll(ctx, event),
       onScrollBeginDrag: (event) => {
         var _a4, _b2;
-        const maintainingScrollAtEnd = state.maintainingScrollAtEnd;
-        if (maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant") {
-          cancelImperativeScroll(state);
-        }
-        if (maintainingScrollAtEnd) {
-          finishMaintainScrollAtEnd(ctx);
-        }
+        state.isDragging = true;
+        interruptMaintainScrollAtEnd(ctx);
         prepareReachedEdgeForNextUserScroll(ctx);
         (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
       },
-      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx)
+      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx),
+      onScrollEndDrag: (event) => {
+        var _a4, _b2;
+        state.isDragging = false;
+        (_b2 = (_a4 = state.props).onScrollEndDrag) == null ? void 0 : _b2.call(_a4, event);
+      }
     }),
     []
   );
@@ -7867,6 +8045,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ListHeaderComponent,
       onInternalScrollBeginDrag: fns.onScrollBeginDrag,
       onInternalScrollEnd: fns.onScrollEnd,
+      onInternalScrollEndDrag: fns.onScrollEndDrag,
       onLayout,
       onLayoutFooter,
       onMomentumScrollEnd: fns.onMomentumScrollEnd,