@legendapp/list 3.0.0 → 3.0.2

package/react-native.js

@@ -2002,18 +2002,29 @@ function shouldFinishInitialZeroTargetScroll(ctx) {
   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 getResolvedScrollCompletionState(ctx, scrollingTo) {
+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 = (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
+  const clampedTargetOffset = getCurrentTargetOffset(ctx, scrollingTo);
   const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
   const diff1 = Math.abs(scroll - clampedTargetOffset);
-  const diff2 = Math.abs(diff1 - adjust);
+  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 || !scrollingTo.animated && diff2 < 1)
+    isAtResolvedTarget: Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || canUseAdjustedCompletion && diff2 < 1)
   };
 }
 function checkFinishedScrollFrame(ctx) {
@@ -2070,6 +2081,7 @@ function checkFinishedScrollFallback(ctx) {
         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;
@@ -2079,6 +2091,9 @@ function checkFinishedScrollFallback(ctx) {
             scrollToFallbackOffset(ctx, targetOffset);
           });
           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) {
@@ -2121,773 +2136,1199 @@ function doScrollTo(ctx, params) {
   }
 }
 
-// src/core/scrollTo.ts
-function getAverageSizeSnapshot(state) {
-  if (Object.keys(state.averageSizes).length === 0) {
-    return void 0;
+// src/core/doMaintainScrollAtEnd.ts
+function doMaintainScrollAtEnd(ctx) {
+  const state = ctx.state;
+  const {
+    didContainersLayout,
+    pendingNativeMVCPAdjust,
+    refScroller,
+    props: { maintainScrollAtEnd }
+  } = state;
+  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    return false;
   }
-  const snapshot = {};
-  for (const itemType in state.averageSizes) {
-    const averages = state.averageSizes[itemType];
-    snapshot[itemType] = averages.avg;
+  state.pendingMaintainScrollAtEnd = false;
+  if (shouldMaintainScrollAtEnd) {
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
+      state.scroll = 0;
+    }
+    if (!state.maintainingScrollAtEnd) {
+      state.maintainingScrollAtEnd = true;
+      requestAnimationFrame(() => {
+        if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
+          const scroller = refScroller.current;
+          if (state.props.horizontal && isHorizontalRTL(state)) {
+            const currentContentSize = getContentSize(ctx);
+            const logicalEndOffset = getLogicalHorizontalMaxOffset(state, currentContentSize);
+            const nativeOffset = toNativeHorizontalOffset(state, logicalEndOffset, currentContentSize);
+            scroller == null ? void 0 : scroller.scrollTo({
+              animated: maintainScrollAtEnd.animated,
+              x: nativeOffset,
+              y: 0
+            });
+          } else {
+            scroller == null ? void 0 : scroller.scrollToEnd({
+              animated: maintainScrollAtEnd.animated
+            });
+          }
+          setTimeout(
+            () => {
+              state.maintainingScrollAtEnd = false;
+            },
+            maintainScrollAtEnd.animated ? 500 : 0
+          );
+        } else {
+          state.maintainingScrollAtEnd = false;
+        }
+      });
+    }
+    return true;
   }
-  return snapshot;
+  return false;
 }
-function syncInitialScrollNativeWatchdog(state, options) {
-  var _a3;
-  const { isInitialScroll, requestedOffset, targetOffset } = options;
-  const existingWatchdog = initialScrollWatchdog.get(state);
-  const shouldWatchInitialNativeScroll = !state.didFinishInitialScroll && (isInitialScroll || !!existingWatchdog) && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
-  const shouldClearInitialNativeScrollWatchdog = !state.didFinishInitialScroll && !!existingWatchdog && initialScrollWatchdog.isAtZeroTargetOffset(requestedOffset);
-  if (shouldWatchInitialNativeScroll) {
-    state.hasScrolled = false;
-    initialScrollWatchdog.set(state, {
-      startScroll: (_a3 = existingWatchdog == null ? void 0 : existingWatchdog.startScroll) != null ? _a3 : state.scroll,
-      targetOffset
-    });
-    return;
-  }
-  if (shouldClearInitialNativeScrollWatchdog) {
-    initialScrollWatchdog.clear(state);
+
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
+  const state = ctx.state;
+  if (Math.abs(positionDiff) > 0.1) {
+    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
+    const doit = () => {
+      if (needsScrollWorkaround) {
+        doScrollTo(ctx, { horizontal: state.props.horizontal, offset: state.scroll });
+      } else {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
+      }
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+      if (Platform.OS !== "web") {
+        const threshold = state.scroll - positionDiff / 2;
+        if (!state.ignoreScrollFromMVCP) {
+          state.ignoreScrollFromMVCP = {};
+        }
+        if (positionDiff > 0) {
+          state.ignoreScrollFromMVCP.lt = threshold;
+        } else {
+          state.ignoreScrollFromMVCP.gt = threshold;
+        }
+        if (state.ignoreScrollFromMVCPTimeout) {
+          clearTimeout(state.ignoreScrollFromMVCPTimeout);
+        }
+        const delay = needsScrollWorkaround ? 250 : 100;
+        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
+          var _a3;
+          state.ignoreScrollFromMVCP = void 0;
+          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
+          if (shouldForceUpdate) {
+            state.ignoreScrollFromMVCPIgnored = false;
+            state.scrollPending = state.scroll;
+            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
+          }
+        }, delay);
+      }
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
+    }
   }
 }
-function scrollTo(ctx, params) {
-  var _a3;
-  const state = ctx.state;
-  const { noScrollingTo, forceScroll, ...scrollTarget } = params;
-  const {
-    animated,
-    isInitialScroll,
-    offset: scrollTargetOffset,
-    precomputedWithViewOffset,
-    waitForInitialScrollCompletionFrame
-  } = scrollTarget;
-  const {
-    props: { horizontal }
-  } = state;
-  if (state.animFrameCheckFinishedScroll) {
-    cancelAnimationFrame(ctx.state.animFrameCheckFinishedScroll);
+
+// src/core/mvcp.ts
+var MVCP_POSITION_EPSILON = 0.1;
+var MVCP_ANCHOR_LOCK_TTL_MS = 300;
+var MVCP_ANCHOR_LOCK_QUIET_PASSES_TO_RELEASE = 2;
+var NATIVE_END_CLAMP_EPSILON = 1;
+function resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) {
+  if (!enableMVCPAnchorLock) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
   }
-  if (state.timeoutCheckFinishedScrollFallback) {
-    clearTimeout(ctx.state.timeoutCheckFinishedScrollFallback);
+  const lock = state.mvcpAnchorLock;
+  if (!lock) {
+    return void 0;
   }
-  const requestedOffset = precomputedWithViewOffset ? scrollTargetOffset : calculateOffsetWithOffsetPosition(ctx, scrollTargetOffset, scrollTarget);
-  const shouldPreserveRawInitialOffsetRequest = !!isInitialScroll && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-  const targetOffset = clampScrollOffset(ctx, requestedOffset, scrollTarget);
-  const offset = shouldPreserveRawInitialOffsetRequest ? requestedOffset : targetOffset;
-  state.scrollHistory.length = 0;
-  if (!noScrollingTo) {
-    if (isInitialScroll) {
-      initialScrollCompletion.resetFlags(state);
+  const isExpired = now > lock.expiresAt;
+  const isMissing = state.indexByKey.get(lock.id) === void 0;
+  if (isExpired || isMissing || !mvcpData) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
+  }
+  return lock;
+}
+function updateAnchorLock(state, params) {
+  if (Platform.OS === "web") {
+    const { anchorId, anchorPosition, dataChanged, now, positionDiff } = params;
+    const enableMVCPAnchorLock = !!dataChanged || !!state.mvcpAnchorLock;
+    const mvcpData = state.props.maintainVisibleContentPosition.data;
+    if (!enableMVCPAnchorLock || !mvcpData || state.scrollingTo || !anchorId || anchorPosition === void 0) {
+      return;
     }
-    const averageSizeSnapshot = getAverageSizeSnapshot(state);
-    state.scrollingTo = {
-      ...scrollTarget,
-      ...averageSizeSnapshot ? { averageSizeSnapshot } : {},
-      targetOffset,
-      waitForInitialScrollCompletionFrame
+    const existingLock = state.mvcpAnchorLock;
+    const quietPasses = !dataChanged && Math.abs(positionDiff) <= MVCP_POSITION_EPSILON && (existingLock == null ? void 0 : existingLock.id) === anchorId ? existingLock.quietPasses + 1 : 0;
+    if (!dataChanged && quietPasses >= MVCP_ANCHOR_LOCK_QUIET_PASSES_TO_RELEASE) {
+      state.mvcpAnchorLock = void 0;
+      return;
+    }
+    state.mvcpAnchorLock = {
+      expiresAt: now + MVCP_ANCHOR_LOCK_TTL_MS,
+      id: anchorId,
+      position: anchorPosition,
+      quietPasses
     };
   }
-  state.scrollPending = targetOffset;
-  syncInitialScrollNativeWatchdog(state, { isInitialScroll, requestedOffset: offset, targetOffset });
-  if (forceScroll || !isInitialScroll || Platform.OS === "android") {
-    doScrollTo(ctx, { animated, horizontal, isInitialScroll, offset });
-  } else {
-    state.scroll = offset;
+}
+function shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotalSize, prevScroll, scrollTarget) {
+  if (!dataChanged || Platform.OS === "web" || !state.props.maintainVisibleContentPosition.data || scrollTarget !== void 0 || positionDiff >= -MVCP_POSITION_EPSILON) {
+    return false;
   }
+  const distanceFromEnd = prevTotalSize - prevScroll - state.scrollLength;
+  return distanceFromEnd < Math.abs(positionDiff) - MVCP_POSITION_EPSILON;
 }
-
-// src/core/scrollToIndex.ts
-function clampScrollIndex(index, dataLength) {
-  if (dataLength <= 0) {
-    return -1;
+function getPredictedNativeClamp(state, unresolvedAmount, totalSize) {
+  if (Math.abs(unresolvedAmount) <= MVCP_POSITION_EPSILON) {
+    return 0;
   }
-  if (index >= dataLength) {
-    return dataLength - 1;
+  const maxScroll = Math.max(0, totalSize - state.scrollLength);
+  const clampDelta = maxScroll - state.scroll;
+  if (unresolvedAmount < 0) {
+    return Math.max(unresolvedAmount, Math.min(0, clampDelta));
   }
-  if (index < 0) {
-    return 0;
+  if (unresolvedAmount > 0) {
+    return Math.min(unresolvedAmount, Math.max(0, clampDelta));
   }
-  return index;
+  return 0;
 }
-function scrollToIndex(ctx, {
-  index,
-  viewOffset = 0,
-  animated = true,
-  forceScroll,
-  isInitialScroll,
-  viewPosition
-}) {
+function getProgressTowardAmount(targetDelta, nativeDelta) {
+  return targetDelta < 0 ? -nativeDelta : nativeDelta;
+}
+function settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta) {
   const state = ctx.state;
-  const { data } = state.props;
-  index = clampScrollIndex(index, data.length);
-  const itemSize = getItemSizeAtIndex(ctx, index);
-  const firstIndexOffset = calculateOffsetForIndex(ctx, index);
-  const isLast = index === data.length - 1;
-  if (isLast && viewPosition === void 0) {
-    viewPosition = 1;
+  state.pendingNativeMVCPAdjust = void 0;
+  const remaining = remainingAfterManual - nativeDelta;
+  if (Math.abs(remaining) > MVCP_POSITION_EPSILON) {
+    requestAdjust(ctx, remaining, true);
   }
-  state.scrollForNextCalculateItemsInView = void 0;
-  scrollTo(ctx, {
-    animated,
-    forceScroll,
-    index,
-    isInitialScroll,
-    itemSize,
-    offset: firstIndexOffset,
-    viewOffset,
-    viewPosition: viewPosition != null ? viewPosition : 0
-  });
-}
-
-// src/core/initialScroll.ts
-function dispatchInitialScroll(ctx, params) {
-  const { forceScroll, resolvedOffset, target, waitForCompletionFrame } = params;
-  const requestedIndex = target.index;
-  const index = requestedIndex !== void 0 ? clampScrollIndex(requestedIndex, ctx.state.props.data.length) : void 0;
-  const itemSize = getItemSizeAtIndex(ctx, index);
-  scrollTo(ctx, {
-    animated: false,
-    forceScroll,
-    index: index !== void 0 && index >= 0 ? index : void 0,
-    isInitialScroll: true,
-    itemSize,
-    offset: resolvedOffset,
-    precomputedWithViewOffset: true,
-    viewOffset: target.viewOffset,
-    viewPosition: target.viewPosition,
-    waitForInitialScrollCompletionFrame: waitForCompletionFrame
-  });
-}
-function setInitialScrollTarget(state, target, options) {
-  var _a3;
-  state.clearPreservedInitialScrollOnNextFinish = void 0;
-  if (state.timeoutPreservedInitialScrollClear !== void 0) {
-    clearTimeout(state.timeoutPreservedInitialScrollClear);
-    state.timeoutPreservedInitialScrollClear = void 0;
-  }
-  state.initialScroll = target;
-  if ((options == null ? void 0 : options.resetDidFinish) && state.didFinishInitialScroll) {
-    state.didFinishInitialScroll = false;
-  }
-  setInitialScrollSession(state, {
-    kind: ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? "offset" : "bootstrap"
-  });
 }
-function resolveInitialScrollOffset(ctx, initialScroll) {
-  var _a3, _b;
+function maybeApplyPredictedNativeMVCPAdjust(ctx) {
   const state = ctx.state;
-  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
-    return (_b = initialScroll.contentOffset) != null ? _b : 0;
+  const pending = state.pendingNativeMVCPAdjust;
+  if (!pending || Math.abs(pending.manualApplied) > MVCP_POSITION_EPSILON) {
+    return;
   }
-  const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
-  const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
-  return clampScrollOffset(ctx, resolvedOffset, initialScroll);
-}
-function getAdvanceableInitialScrollState(state, options) {
-  const { didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
-  const initialScroll = state.initialScroll;
-  const isInitialScrollInProgress = !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll);
-  const shouldWaitForInitialLayout = !!(options == null ? void 0 : options.requiresMeasuredLayout) && !queuedInitialLayout && !isInitialScrollInProgress;
-  if (!initialScroll || shouldWaitForInitialLayout || didFinishInitialScroll || scrollingTo && !isInitialScrollInProgress) {
-    return void 0;
+  const totalSize = getContentSize(ctx);
+  const predictedNativeClamp = getPredictedNativeClamp(state, pending.amount, totalSize);
+  if (Math.abs(predictedNativeClamp) <= MVCP_POSITION_EPSILON) {
+    return;
   }
-  return {
-    initialScroll,
-    isInitialScrollInProgress,
-    queuedInitialLayout,
-    scrollingTo
-  };
+  const manualDesired = pending.amount - predictedNativeClamp;
+  if (Math.abs(manualDesired) <= MVCP_POSITION_EPSILON) {
+    return;
+  }
+  pending.manualApplied = manualDesired;
+  requestAdjust(ctx, manualDesired, true);
+  pending.furthestProgressTowardAmount = 0;
 }
-function advanceMeasuredInitialScroll(ctx, options) {
-  var _a3, _b, _c;
+function resolvePendingNativeMVCPAdjust(ctx, newScroll) {
   const state = ctx.state;
-  const advanceableState = getAdvanceableInitialScrollState(state, {
-    requiresMeasuredLayout: true
-  });
-  if (!advanceableState) {
+  const pending = state.pendingNativeMVCPAdjust;
+  if (!pending) {
     return false;
   }
-  const { initialScroll, isInitialScrollInProgress, queuedInitialLayout } = advanceableState;
-  const scrollingTo = isInitialScrollInProgress ? advanceableState.scrollingTo : void 0;
-  const resolvedOffset = resolveInitialScrollOffset(ctx, initialScroll);
-  const activeInitialTargetOffset = scrollingTo ? (_a3 = scrollingTo.targetOffset) != null ? _a3 : scrollingTo.offset : void 0;
-  const didOffsetChange = initialScroll.contentOffset === void 0 || Math.abs(initialScroll.contentOffset - resolvedOffset) > 1;
-  const didActiveInitialTargetChange = activeInitialTargetOffset !== void 0 && Math.abs(activeInitialTargetOffset - resolvedOffset) > 1;
-  const isAlreadyAtDesiredInitialTarget = activeInitialTargetOffset !== void 0 && Math.abs(state.scroll - resolvedOffset) <= 1 && Math.abs(state.scrollPending - resolvedOffset) <= 1;
-  if (!(options == null ? void 0 : options.forceScroll) && !didOffsetChange && isInitialScrollInProgress && !didActiveInitialTargetChange) {
-    return false;
+  const remainingAfterManual = pending.amount - pending.manualApplied;
+  const nativeDelta = newScroll - (pending.startScroll + pending.manualApplied);
+  const isWrongDirection = remainingAfterManual < 0 && nativeDelta > MVCP_POSITION_EPSILON || remainingAfterManual > 0 && nativeDelta < -MVCP_POSITION_EPSILON;
+  const progressTowardAmount = getProgressTowardAmount(remainingAfterManual, nativeDelta);
+  if (Math.abs(remainingAfterManual) <= MVCP_POSITION_EPSILON) {
+    state.pendingNativeMVCPAdjust = void 0;
+    return true;
   }
-  if ((options == null ? void 0 : options.forceScroll) && isAlreadyAtDesiredInitialTarget) {
+  if (isWrongDirection) {
+    state.pendingNativeMVCPAdjust = void 0;
     return false;
   }
-  if (didOffsetChange && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) !== "offset") {
-    setInitialScrollTarget(state, { ...initialScroll, contentOffset: resolvedOffset });
+  if (progressTowardAmount + MVCP_POSITION_EPSILON >= Math.abs(remainingAfterManual)) {
+    settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
+    return true;
   }
-  const forceScroll = (_c = options == null ? void 0 : options.forceScroll) != null ? _c : !!queuedInitialLayout || isInitialScrollInProgress && didOffsetChange;
-  dispatchInitialScroll(ctx, {
-    forceScroll,
-    resolvedOffset,
-    target: initialScroll
-  });
-  return true;
-}
-function advanceOffsetInitialScroll(ctx, options) {
-  var _a3, _b;
-  const state = ctx.state;
-  const advanceableState = getAdvanceableInitialScrollState(state);
-  if (!advanceableState) {
-    return false;
+  const expectedNativeClampScroll = Math.max(0, getContentSize(ctx) - state.scrollLength);
+  const distanceToClamp = Math.abs(newScroll - expectedNativeClampScroll);
+  const isAtExpectedNativeClamp = distanceToClamp <= NATIVE_END_CLAMP_EPSILON;
+  if (isAtExpectedNativeClamp) {
+    settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
+    return true;
   }
-  const { initialScroll, queuedInitialLayout } = advanceableState;
-  const resolvedOffset = (_a3 = initialScroll.contentOffset) != null ? _a3 : 0;
-  const isAlreadyAtDesiredInitialTarget = Math.abs(state.scroll - resolvedOffset) <= 1 && Math.abs(state.scrollPending - resolvedOffset) <= 1;
-  if ((options == null ? void 0 : options.forceScroll) && isAlreadyAtDesiredInitialTarget) {
+  if (state.pendingMaintainScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold") && progressTowardAmount > MVCP_POSITION_EPSILON) {
+    settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
+    return true;
+  }
+  if (progressTowardAmount > pending.furthestProgressTowardAmount + MVCP_POSITION_EPSILON) {
+    pending.furthestProgressTowardAmount = progressTowardAmount;
     return false;
   }
-  const hasMeasuredScrollLayout = !!state.lastLayout && state.scrollLength > 0;
-  const forceScroll = (_b = options == null ? void 0 : options.forceScroll) != null ? _b : hasMeasuredScrollLayout || !!queuedInitialLayout;
-  dispatchInitialScroll(ctx, {
-    forceScroll,
-    resolvedOffset,
-    target: initialScroll
-  });
-  return true;
-}
-function advanceCurrentInitialScrollSession(ctx, options) {
-  var _a3;
-  return ((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? advanceOffsetInitialScroll(ctx, {
-    forceScroll: options == null ? void 0 : options.forceScroll
-  }) : advanceMeasuredInitialScroll(ctx, {
-    forceScroll: options == null ? void 0 : options.forceScroll
-  });
-}
-
-// src/utils/checkAllSizesKnown.ts
-function isNullOrUndefined2(value) {
-  return value === null || value === void 0;
-}
-function getMountedIndicesInRange(state, start, end) {
-  if (!isNullOrUndefined2(end) && !isNullOrUndefined2(start) && start >= 0 && end >= 0) {
-    return Array.from(state.containerItemKeys.keys()).map((key) => state.indexByKey.get(key)).filter((index) => index !== void 0 && index >= start && index <= end).sort((a, b) => a - b);
+  if (pending.furthestProgressTowardAmount > MVCP_POSITION_EPSILON && progressTowardAmount < pending.furthestProgressTowardAmount - MVCP_POSITION_EPSILON) {
+    state.pendingNativeMVCPAdjust = void 0;
+    return false;
   }
-  return [];
-}
-function getMountedBufferedIndices(state) {
-  return getMountedIndicesInRange(state, state.startBuffered, state.endBuffered);
-}
-function getMountedNoBufferIndices(state) {
-  return getMountedIndicesInRange(state, state.startNoBuffer, state.endNoBuffer);
-}
-function checkAllSizesKnown(state, indices) {
-  return indices.length > 0 && indices.every((index) => {
-    const key = getId(state, index);
-    return key !== void 0 && state.sizesKnown.has(key);
-  });
+  return false;
 }
-
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
+function prepareMVCP(ctx, dataChanged) {
   const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
-    const doit = () => {
-      if (needsScrollWorkaround) {
-        scrollTo(ctx, {
-          noScrollingTo: true,
-          offset: state.scroll
-        });
-      } else {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
-        }
+  const { idsInView, positions, props } = state;
+  const {
+    maintainVisibleContentPosition: { data: mvcpData, size: mvcpScroll, shouldRestorePosition }
+  } = props;
+  const isWeb = Platform.OS === "web";
+  const now = Date.now();
+  const enableMVCPAnchorLock = isWeb && (!!dataChanged || !!state.mvcpAnchorLock);
+  const scrollingTo = state.scrollingTo;
+  const anchorLock = isWeb ? resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) : void 0;
+  let prevPosition;
+  let targetId;
+  const idsInViewWithPositions = [];
+  const scrollTarget = scrollingTo == null ? void 0 : scrollingTo.index;
+  const scrollingToViewPosition = scrollingTo == null ? void 0 : scrollingTo.viewPosition;
+  const isEndAnchoredScrollTarget = scrollTarget !== void 0 && state.props.data.length > 0 && scrollTarget >= state.props.data.length - 1 && (scrollingToViewPosition != null ? scrollingToViewPosition : 0) > 0;
+  const shouldMVCP = dataChanged ? mvcpData : mvcpScroll;
+  const indexByKey = state.indexByKey;
+  const prevScroll = state.scroll;
+  const prevTotalSize = getContentSize(ctx);
+  if (shouldMVCP) {
+    if (!isWeb && state.pendingNativeMVCPAdjust && scrollTarget === void 0) {
+      maybeApplyPredictedNativeMVCPAdjust(ctx);
+      return void 0;
+    }
+    if (anchorLock && scrollTarget === void 0) {
+      targetId = anchorLock.id;
+      prevPosition = anchorLock.position;
+    } else if (scrollTarget !== void 0) {
+      if (!IsNewArchitecture && (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll)) {
+        return void 0;
       }
-    };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-      if (Platform.OS !== "web") {
-        const threshold = state.scroll - positionDiff / 2;
-        if (!state.ignoreScrollFromMVCP) {
-          state.ignoreScrollFromMVCP = {};
+      targetId = getId(state, scrollTarget);
+    } else if (idsInView.length > 0 && state.didContainersLayout && !dataChanged) {
+      targetId = idsInView.find((id) => indexByKey.get(id) !== void 0);
+    }
+    if (dataChanged && idsInView.length > 0 && state.didContainersLayout) {
+      for (let i = 0; i < idsInView.length; i++) {
+        const id = idsInView[i];
+        const index = indexByKey.get(id);
+        if (index !== void 0) {
+          const position = positions[index];
+          if (position !== void 0) {
+            idsInViewWithPositions.push({ id, position });
+          }
         }
-        if (positionDiff > 0) {
-          state.ignoreScrollFromMVCP.lt = threshold;
-        } else {
-          state.ignoreScrollFromMVCP.gt = threshold;
+      }
+    }
+    if (targetId !== void 0 && prevPosition === void 0) {
+      const targetIndex = indexByKey.get(targetId);
+      if (targetIndex !== void 0) {
+        prevPosition = positions[targetIndex];
+      }
+    }
+    return () => {
+      let positionDiff = 0;
+      let anchorIdForLock = anchorLock == null ? void 0 : anchorLock.id;
+      let anchorPositionForLock;
+      let skipTargetAnchor = false;
+      const data = state.props.data;
+      const shouldValidateLockedAnchor = isWeb && dataChanged && mvcpData && scrollTarget === void 0 && targetId !== void 0 && (anchorLock == null ? void 0 : anchorLock.id) === targetId && shouldRestorePosition !== void 0;
+      if (shouldValidateLockedAnchor && targetId !== void 0) {
+        const index = indexByKey.get(targetId);
+        if (index !== void 0) {
+          const item = data[index];
+          skipTargetAnchor = item === void 0 || !shouldRestorePosition(item, index, data);
+          if (skipTargetAnchor && (anchorLock == null ? void 0 : anchorLock.id) === targetId) {
+            state.mvcpAnchorLock = void 0;
+          }
         }
-        if (state.ignoreScrollFromMVCPTimeout) {
-          clearTimeout(state.ignoreScrollFromMVCPTimeout);
+      }
+      const shouldUseFallbackVisibleAnchor = dataChanged && mvcpData && scrollTarget === void 0 && (() => {
+        if (targetId === void 0 || skipTargetAnchor) {
+          return true;
         }
-        const delay = needsScrollWorkaround ? 250 : 100;
-        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
-          var _a3;
-          state.ignoreScrollFromMVCP = void 0;
-          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
-          if (shouldForceUpdate) {
-            state.ignoreScrollFromMVCPIgnored = false;
-            state.scrollPending = state.scroll;
-            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
+        const targetIndex = indexByKey.get(targetId);
+        return targetIndex === void 0 || positions[targetIndex] === void 0;
+      })();
+      if (shouldUseFallbackVisibleAnchor) {
+        for (let i = 0; i < idsInViewWithPositions.length; i++) {
+          const { id, position } = idsInViewWithPositions[i];
+          const index = indexByKey.get(id);
+          if (index !== void 0 && shouldRestorePosition) {
+            const item = data[index];
+            if (item === void 0 || !shouldRestorePosition(item, index, data)) {
+              continue;
+            }
           }
-        }, delay);
+          const newPosition = index !== void 0 ? positions[index] : void 0;
+          if (newPosition !== void 0) {
+            positionDiff = newPosition - position;
+            anchorIdForLock = id;
+            anchorPositionForLock = newPosition;
+            break;
+          }
+        }
       }
-    } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
-    }
+      if (!skipTargetAnchor && targetId !== void 0 && prevPosition !== void 0) {
+        const targetIndex = indexByKey.get(targetId);
+        const newPosition = targetIndex !== void 0 ? positions[targetIndex] : void 0;
+        if (newPosition !== void 0) {
+          const totalSize = getContentSize(ctx);
+          let diff = newPosition - prevPosition;
+          if (diff !== 0 && isEndAnchoredScrollTarget && state.scroll + state.scrollLength > totalSize) {
+            if (diff > 0) {
+              diff = Math.max(0, totalSize - state.scroll - state.scrollLength);
+            } else {
+              diff = 0;
+            }
+          }
+          positionDiff = diff;
+          anchorIdForLock = targetId;
+          anchorPositionForLock = newPosition;
+        }
+      }
+      if (scrollingToViewPosition && scrollingToViewPosition > 0) {
+        const newSize = getItemSize(ctx, targetId, scrollTarget, state.props.data[scrollTarget]);
+        const prevSize = scrollingTo == null ? void 0 : scrollingTo.itemSize;
+        if (newSize !== void 0 && prevSize !== void 0 && newSize !== prevSize) {
+          const diff = newSize - prevSize;
+          if (diff !== 0) {
+            positionDiff += diff * scrollingToViewPosition;
+            scrollingTo.itemSize = newSize;
+          }
+        }
+      }
+      updateAnchorLock(state, {
+        anchorId: anchorIdForLock,
+        anchorPosition: anchorPositionForLock,
+        dataChanged,
+        now,
+        positionDiff
+      });
+      if (shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotalSize, prevScroll, scrollTarget)) {
+        state.pendingNativeMVCPAdjust = {
+          amount: positionDiff,
+          furthestProgressTowardAmount: 0,
+          manualApplied: 0,
+          startScroll: prevScroll
+        };
+        maybeApplyPredictedNativeMVCPAdjust(ctx);
+        return;
+      }
+      if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
+        const shouldSkipAdjustForMaintainedEnd = state.maintainingScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+        if (!shouldSkipAdjustForMaintainedEnd) {
+          requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
+        }
+      }
+    };
   }
 }
 
-// src/core/bootstrapInitialScroll.ts
-var DEFAULT_BOOTSTRAP_REVEAL_EPSILON = 1;
-var DEFAULT_BOOTSTRAP_REVEAL_MAX_FRAMES = 8;
-var DEFAULT_BOOTSTRAP_REVEAL_MAX_PASSES = 24;
-var BOOTSTRAP_REVEAL_ABORT_WARNING = "LegendList bootstrap initial scroll aborted after exceeding convergence bounds.";
-function getBootstrapInitialScrollSession(state) {
-  var _a3;
-  return ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
-}
-function isOffsetInitialScrollSession(state) {
+// src/platform/flushSync.native.ts
+var flushSync = (fn) => {
+  fn();
+};
+
+// src/core/updateScroll.ts
+function updateScroll(ctx, newScroll, forceUpdate, options) {
   var _a3;
-  return ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-}
-function doVisibleIndicesMatch(previous, next) {
-  if (!previous || previous.length !== next.length) {
-    return false;
+  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;
   }
-  for (let i = 0; i < previous.length; i++) {
-    if (previous[i] !== next[i]) {
-      return false;
-    }
+  state.lastBatchingAction = Date.now();
+  const currentTime = Date.now();
+  const adjust = scrollAdjustHandler.getAdjust();
+  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
+  if (adjustChanged) {
+    scrollHistory.length = 0;
   }
-  return true;
-}
-function getBootstrapRevealVisibleIndices(options) {
-  const { dataLength, getSize, offset, positions, scrollLength, startIndex: requestedStartIndex } = options;
-  const endOffset = offset + scrollLength;
-  const visibleIndices = [];
-  let index = requestedStartIndex !== void 0 ? Math.max(0, Math.min(dataLength - 1, requestedStartIndex)) : 0;
-  while (index > 0) {
-    const previousIndex = index - 1;
-    const previousPosition = positions[previousIndex];
-    if (previousPosition === void 0) {
-      index = previousIndex;
-      continue;
-    }
-    const previousSize = getSize(previousIndex);
-    if (previousSize === void 0) {
-      index = previousIndex;
-      continue;
-    }
-    if (previousPosition + previousSize <= offset) {
-      break;
+  state.lastScrollAdjustForHistory = adjust;
+  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
+    if (!adjustChanged) {
+      scrollHistory.push({ scroll: newScroll, time: currentTime });
     }
-    index = previousIndex;
   }
-  for (; index < dataLength; index++) {
-    const position = positions[index];
-    if (position === void 0) {
-      continue;
+  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 size = getSize(index);
-    if (size === void 0) {
-      continue;
+  }
+  state.scrollPrev = prevScroll;
+  state.scrollPrevTime = state.scrollTime;
+  state.scroll = newScroll;
+  state.scrollTime = currentTime;
+  const scrollDelta = Math.abs(newScroll - prevScroll);
+  const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
+  const scrollLength = state.scrollLength;
+  const lastCalculated = state.scrollLastCalculate;
+  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
+  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || 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;
+      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0 });
+      checkThresholds(ctx);
+    };
+    if (scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust) {
+      state.mvcpAnchorLock = void 0;
+      state.pendingNativeMVCPAdjust = void 0;
+      state.userScrollAnchorResetKeys = /* @__PURE__ */ new Set();
+      if (state.queuedMVCPRecalculate !== void 0) {
+        cancelAnimationFrame(state.queuedMVCPRecalculate);
+        state.queuedMVCPRecalculate = void 0;
+      }
+      flushSync(runCalculateItems);
+    } else {
+      runCalculateItems();
     }
-    if (position < endOffset && position + size > offset) {
-      visibleIndices.push(index);
-    } else if (visibleIndices.length > 0 && position >= endOffset) {
-      break;
+    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;
   }
-  return visibleIndices;
-}
-function shouldAbortBootstrapReveal(options) {
-  const {
-    mountFrameCount,
-    maxFrames = DEFAULT_BOOTSTRAP_REVEAL_MAX_FRAMES,
-    maxPasses = DEFAULT_BOOTSTRAP_REVEAL_MAX_PASSES,
-    passCount
-  } = options;
-  return mountFrameCount >= maxFrames || passCount >= maxPasses;
 }
-function abortBootstrapRevealIfNeeded(ctx, options) {
-  if (!shouldAbortBootstrapReveal(options)) {
-    return false;
+
+// src/core/scrollTo.ts
+function getAverageSizeSnapshot(state) {
+  if (Object.keys(state.averageSizes).length === 0) {
+    return void 0;
   }
-  if (IS_DEV) {
-    console.warn(BOOTSTRAP_REVEAL_ABORT_WARNING);
+  const snapshot = {};
+  for (const itemType in state.averageSizes) {
+    const averages = state.averageSizes[itemType];
+    snapshot[itemType] = averages.avg;
   }
-  abortBootstrapInitialScroll(ctx);
-  return true;
+  return snapshot;
 }
-function clearBootstrapInitialScrollSession(state) {
+function syncInitialScrollNativeWatchdog(state, options) {
   var _a3;
-  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  const frameHandle = bootstrapInitialScroll == null ? void 0 : bootstrapInitialScroll.frameHandle;
-  if (frameHandle !== void 0 && typeof cancelAnimationFrame === "function") {
-    cancelAnimationFrame(frameHandle);
+  const { isInitialScroll, requestedOffset, targetOffset } = options;
+  const existingWatchdog = initialScrollWatchdog.get(state);
+  const shouldWatchInitialNativeScroll = !state.didFinishInitialScroll && (isInitialScroll || !!existingWatchdog) && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
+  const shouldClearInitialNativeScrollWatchdog = !state.didFinishInitialScroll && !!existingWatchdog && initialScrollWatchdog.isAtZeroTargetOffset(requestedOffset);
+  if (shouldWatchInitialNativeScroll) {
+    state.hasScrolled = false;
+    initialScrollWatchdog.set(state, {
+      startScroll: (_a3 = existingWatchdog == null ? void 0 : existingWatchdog.startScroll) != null ? _a3 : state.scroll,
+      targetOffset
+    });
+    return;
   }
-  if (bootstrapInitialScroll) {
-    bootstrapInitialScroll.frameHandle = void 0;
+  if (shouldClearInitialNativeScrollWatchdog) {
+    initialScrollWatchdog.clear(state);
   }
-  setInitialScrollSession(state, {
-    bootstrap: null,
-    kind: (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind
-  });
-}
-function startBootstrapInitialScrollSession(state, options) {
-  var _a3, _b, _c;
-  const previousBootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  setInitialScrollSession(state, {
-    bootstrap: {
-      frameHandle: previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.frameHandle,
-      // Re-arming during the initial mount should spend from the same watchdog budget.
-      mountFrameCount: (_a3 = previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.mountFrameCount) != null ? _a3 : 0,
-      passCount: 0,
-      previousResolvedOffset: void 0,
-      scroll: options.scroll,
-      seedContentOffset: (_c = (_b = options.seedContentOffset) != null ? _b : previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.seedContentOffset) != null ? _c : options.scroll,
-      targetIndexSeed: options.targetIndexSeed,
-      visibleIndices: void 0
-    },
-    kind: "bootstrap"
-  });
 }
-function resetBootstrapInitialScrollSession(state, options) {
-  var _a3, _b, _c;
-  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  if (!bootstrapInitialScroll) {
-    if ((options == null ? void 0 : options.scroll) !== void 0) {
-      startBootstrapInitialScrollSession(state, {
-        scroll: options.scroll,
-        seedContentOffset: options.seedContentOffset,
-        targetIndexSeed: options.targetIndexSeed
-      });
+function scrollTo(ctx, params) {
+  var _a3;
+  const state = ctx.state;
+  const { noScrollingTo, forceScroll, ...scrollTarget } = params;
+  const {
+    animated,
+    isInitialScroll,
+    offset: scrollTargetOffset,
+    precomputedWithViewOffset,
+    waitForInitialScrollCompletionFrame
+  } = scrollTarget;
+  const {
+    props: { horizontal }
+  } = state;
+  if (state.animFrameCheckFinishedScroll) {
+    cancelAnimationFrame(ctx.state.animFrameCheckFinishedScroll);
+  }
+  if (state.timeoutCheckFinishedScrollFallback) {
+    clearTimeout(ctx.state.timeoutCheckFinishedScrollFallback);
+  }
+  const requestedOffset = precomputedWithViewOffset ? scrollTargetOffset : calculateOffsetWithOffsetPosition(ctx, scrollTargetOffset, scrollTarget);
+  const shouldPreserveRawInitialOffsetRequest = !!isInitialScroll && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+  const targetOffset = clampScrollOffset(ctx, requestedOffset, scrollTarget);
+  const offset = shouldPreserveRawInitialOffsetRequest ? requestedOffset : targetOffset;
+  state.scrollHistory.length = 0;
+  if (!noScrollingTo) {
+    if (isInitialScroll) {
+      initialScrollCompletion.resetFlags(state);
     }
+    const averageSizeSnapshot = getAverageSizeSnapshot(state);
+    state.scrollingTo = {
+      ...scrollTarget,
+      ...averageSizeSnapshot ? { averageSizeSnapshot } : {},
+      targetOffset,
+      waitForInitialScrollCompletionFrame
+    };
+  }
+  state.scrollPending = targetOffset;
+  syncInitialScrollNativeWatchdog(state, { isInitialScroll, requestedOffset: offset, targetOffset });
+  if (!animated && !isInitialScroll && !noScrollingTo && Math.abs(state.scroll - targetOffset) > 1) {
+    updateScroll(ctx, targetOffset, false, { markHasScrolled: false });
+  }
+  if (forceScroll || !isInitialScroll || Platform.OS === "android") {
+    doScrollTo(ctx, { animated, horizontal, isInitialScroll, offset });
   } else {
-    bootstrapInitialScroll.passCount = 0;
-    bootstrapInitialScroll.previousResolvedOffset = void 0;
-    bootstrapInitialScroll.scroll = (_a3 = options == null ? void 0 : options.scroll) != null ? _a3 : bootstrapInitialScroll.scroll;
-    bootstrapInitialScroll.seedContentOffset = (_b = options == null ? void 0 : options.seedContentOffset) != null ? _b : bootstrapInitialScroll.seedContentOffset;
-    bootstrapInitialScroll.targetIndexSeed = (_c = options == null ? void 0 : options.targetIndexSeed) != null ? _c : bootstrapInitialScroll.targetIndexSeed;
-    bootstrapInitialScroll.visibleIndices = void 0;
-    setInitialScrollSession(state, {
-      bootstrap: bootstrapInitialScroll,
-      kind: "bootstrap"
-    });
+    state.scroll = offset;
   }
 }
-function queueBootstrapInitialScrollReevaluation(state) {
-  requestAnimationFrame(() => {
-    var _a3;
-    if (getBootstrapInitialScrollSession(state)) {
-      (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
-    }
-  });
+
+// src/core/scrollToIndex.ts
+function clampScrollIndex(index, dataLength) {
+  if (dataLength <= 0) {
+    return -1;
+  }
+  if (index >= dataLength) {
+    return dataLength - 1;
+  }
+  if (index < 0) {
+    return 0;
+  }
+  return index;
 }
-function ensureBootstrapInitialScrollFrameTicker(ctx) {
+function scrollToIndex(ctx, {
+  index,
+  viewOffset = 0,
+  animated = true,
+  forceScroll,
+  isInitialScroll,
+  viewPosition
+}) {
   const state = ctx.state;
-  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  if (!bootstrapInitialScroll || bootstrapInitialScroll.frameHandle !== void 0) {
-    return;
+  const { data } = state.props;
+  index = clampScrollIndex(index, data.length);
+  const itemSize = getItemSizeAtIndex(ctx, index);
+  const firstIndexOffset = calculateOffsetForIndex(ctx, index);
+  const isLast = index === data.length - 1;
+  if (isLast && viewPosition === void 0) {
+    viewPosition = 1;
   }
-  const tick = () => {
-    const activeBootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-    if (!activeBootstrapInitialScroll) {
-      return;
-    }
-    activeBootstrapInitialScroll.frameHandle = void 0;
-    activeBootstrapInitialScroll.mountFrameCount += 1;
-    if (abortBootstrapRevealIfNeeded(ctx, {
-      mountFrameCount: activeBootstrapInitialScroll.mountFrameCount,
-      passCount: activeBootstrapInitialScroll.passCount
-    })) {
-      return;
-    }
-    ensureBootstrapInitialScrollFrameTicker(ctx);
-  };
-  bootstrapInitialScroll.frameHandle = requestAnimationFrame(tick);
-}
-function rearmBootstrapInitialScroll(ctx, options) {
-  resetBootstrapInitialScrollSession(ctx.state, options);
-  ensureBootstrapInitialScrollFrameTicker(ctx);
-  queueBootstrapInitialScrollReevaluation(ctx.state);
-}
-function createInitialScrollAtEndTarget(options) {
-  const { dataLength, footerSize, preserveForFooterLayout, stylePaddingBottom } = options;
-  return {
-    contentOffset: void 0,
-    index: Math.max(0, dataLength - 1),
-    preserveForBottomPadding: true,
-    preserveForFooterLayout,
-    viewOffset: -stylePaddingBottom - footerSize,
-    viewPosition: 1
-  };
+  state.scrollForNextCalculateItemsInView = void 0;
+  scrollTo(ctx, {
+    animated,
+    forceScroll,
+    index,
+    isInitialScroll,
+    itemSize,
+    offset: firstIndexOffset,
+    viewOffset,
+    viewPosition: viewPosition != null ? viewPosition : 0
+  });
 }
-function shouldPreserveInitialScrollForBottomPadding(target) {
-  return !!(target == null ? void 0 : target.preserveForBottomPadding);
+
+// src/core/initialScroll.ts
+function dispatchInitialScroll(ctx, params) {
+  const { forceScroll, resolvedOffset, target, waitForCompletionFrame } = params;
+  const requestedIndex = target.index;
+  const index = requestedIndex !== void 0 ? clampScrollIndex(requestedIndex, ctx.state.props.data.length) : void 0;
+  const itemSize = getItemSizeAtIndex(ctx, index);
+  scrollTo(ctx, {
+    animated: false,
+    forceScroll,
+    index: index !== void 0 && index >= 0 ? index : void 0,
+    isInitialScroll: true,
+    itemSize,
+    offset: resolvedOffset,
+    precomputedWithViewOffset: true,
+    viewOffset: target.viewOffset,
+    viewPosition: target.viewPosition,
+    waitForInitialScrollCompletionFrame: waitForCompletionFrame
+  });
 }
-function shouldPreserveInitialScrollForFooterLayout(target) {
-  return !!(target == null ? void 0 : target.preserveForFooterLayout);
+function setInitialScrollTarget(state, target, options) {
+  var _a3;
+  state.clearPreservedInitialScrollOnNextFinish = void 0;
+  if (state.timeoutPreservedInitialScrollClear !== void 0) {
+    clearTimeout(state.timeoutPreservedInitialScrollClear);
+    state.timeoutPreservedInitialScrollClear = void 0;
+  }
+  state.initialScroll = target;
+  if ((options == null ? void 0 : options.resetDidFinish) && state.didFinishInitialScroll) {
+    state.didFinishInitialScroll = false;
+  }
+  setInitialScrollSession(state, {
+    kind: ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? "offset" : "bootstrap"
+  });
 }
-function isRetargetableBottomAlignedInitialScrollTarget(target) {
-  return !!(target && target.viewPosition === 1 && (shouldPreserveInitialScrollForBottomPadding(target) || shouldPreserveInitialScrollForFooterLayout(target)));
+function resolveInitialScrollOffset(ctx, initialScroll) {
+  var _a3, _b;
+  const state = ctx.state;
+  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
+    return (_b = initialScroll.contentOffset) != null ? _b : 0;
+  }
+  const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
+  const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
+  return clampScrollOffset(ctx, resolvedOffset, initialScroll);
 }
-function createRetargetedBottomAlignedInitialScroll(options) {
-  const { dataLength, footerSize, initialScrollAtEnd, stylePaddingBottom, target } = options;
-  const preserveForFooterLayout = shouldPreserveInitialScrollForFooterLayout(target);
+function getAdvanceableInitialScrollState(state, options) {
+  const { didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
+  const initialScroll = state.initialScroll;
+  const isInitialScrollInProgress = !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll);
+  const shouldWaitForInitialLayout = !!(options == null ? void 0 : options.requiresMeasuredLayout) && !queuedInitialLayout && !isInitialScrollInProgress;
+  if (!initialScroll || shouldWaitForInitialLayout || didFinishInitialScroll || scrollingTo && !isInitialScrollInProgress) {
+    return void 0;
+  }
   return {
-    ...target,
-    contentOffset: void 0,
-    index: initialScrollAtEnd ? Math.max(0, dataLength - 1) : target.index,
-    preserveForBottomPadding: true,
-    preserveForFooterLayout,
-    viewOffset: -stylePaddingBottom - (preserveForFooterLayout ? footerSize : 0),
-    viewPosition: 1
+    initialScroll,
+    isInitialScrollInProgress,
+    queuedInitialLayout,
+    scrollingTo
   };
 }
-function areEquivalentBootstrapInitialScrollTargets(current, next) {
-  return current.index === next.index && current.preserveForBottomPadding === next.preserveForBottomPadding && current.preserveForFooterLayout === next.preserveForFooterLayout && current.viewOffset === next.viewOffset && current.viewPosition === next.viewPosition;
-}
-function clearPendingInitialScrollFooterLayout(ctx, options) {
-  const { dataLength, stylePaddingBottom, target } = options;
+function advanceMeasuredInitialScroll(ctx, options) {
+  var _a3, _b, _c;
   const state = ctx.state;
-  if (!shouldPreserveInitialScrollForFooterLayout(target)) {
-    return;
+  const advanceableState = getAdvanceableInitialScrollState(state, {
+    requiresMeasuredLayout: true
+  });
+  if (!advanceableState) {
+    return false;
   }
-  const clearedFooterTarget = createInitialScrollAtEndTarget({
-    dataLength,
-    footerSize: 0,
-    preserveForFooterLayout: void 0,
-    stylePaddingBottom
+  const { initialScroll, isInitialScrollInProgress, queuedInitialLayout } = advanceableState;
+  const scrollingTo = isInitialScrollInProgress ? advanceableState.scrollingTo : void 0;
+  const resolvedOffset = resolveInitialScrollOffset(ctx, initialScroll);
+  const activeInitialTargetOffset = scrollingTo ? (_a3 = scrollingTo.targetOffset) != null ? _a3 : scrollingTo.offset : void 0;
+  const didOffsetChange = initialScroll.contentOffset === void 0 || Math.abs(initialScroll.contentOffset - resolvedOffset) > 1;
+  const didActiveInitialTargetChange = activeInitialTargetOffset !== void 0 && Math.abs(activeInitialTargetOffset - resolvedOffset) > 1;
+  const isAlreadyAtDesiredInitialTarget = activeInitialTargetOffset !== void 0 && Math.abs(state.scroll - resolvedOffset) <= 1 && Math.abs(state.scrollPending - resolvedOffset) <= 1;
+  if (!(options == null ? void 0 : options.forceScroll) && !didOffsetChange && isInitialScrollInProgress && !didActiveInitialTargetChange) {
+    return false;
+  }
+  if ((options == null ? void 0 : options.forceScroll) && isAlreadyAtDesiredInitialTarget) {
+    return false;
+  }
+  if (didOffsetChange && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) !== "offset") {
+    setInitialScrollTarget(state, { ...initialScroll, contentOffset: resolvedOffset });
+  }
+  const forceScroll = (_c = options == null ? void 0 : options.forceScroll) != null ? _c : !!queuedInitialLayout || isInitialScrollInProgress && didOffsetChange;
+  dispatchInitialScroll(ctx, {
+    forceScroll,
+    resolvedOffset,
+    target: initialScroll
   });
-  setInitialScrollTarget(state, clearedFooterTarget);
-}
-function clearFinishedViewportRetargetableInitialScroll(state) {
-  clearPreservedInitialScrollTarget(state);
+  return true;
 }
-function didFinishedInitialScrollMoveAwayFromTarget(ctx, target, epsilon = DEFAULT_BOOTSTRAP_REVEAL_EPSILON) {
+function advanceOffsetInitialScroll(ctx, options) {
+  var _a3, _b;
   const state = ctx.state;
-  if (!state.didFinishInitialScroll) {
+  const advanceableState = getAdvanceableInitialScrollState(state);
+  if (!advanceableState) {
     return false;
   }
-  const currentOffset = getObservedBootstrapInitialScrollOffset(state);
-  return Math.abs(currentOffset - resolveInitialScrollOffset(ctx, target)) > epsilon;
-}
-function getObservedBootstrapInitialScrollOffset(state) {
-  var _a3, _b, _c, _d;
-  const observedOffset = (_b = (_a3 = state.refScroller.current) == null ? void 0 : _a3.getCurrentScrollOffset) == null ? void 0 : _b.call(_a3);
-  return typeof observedOffset === "number" && Number.isFinite(observedOffset) ? observedOffset : (_d = (_c = state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0;
+  const { initialScroll, queuedInitialLayout } = advanceableState;
+  const resolvedOffset = (_a3 = initialScroll.contentOffset) != null ? _a3 : 0;
+  const isAlreadyAtDesiredInitialTarget = Math.abs(state.scroll - resolvedOffset) <= 1 && Math.abs(state.scrollPending - resolvedOffset) <= 1;
+  if ((options == null ? void 0 : options.forceScroll) && isAlreadyAtDesiredInitialTarget) {
+    return false;
+  }
+  const hasMeasuredScrollLayout = !!state.lastLayout && state.scrollLength > 0;
+  const forceScroll = (_b = options == null ? void 0 : options.forceScroll) != null ? _b : hasMeasuredScrollLayout || !!queuedInitialLayout;
+  dispatchInitialScroll(ctx, {
+    forceScroll,
+    resolvedOffset,
+    target: initialScroll
+  });
+  return true;
 }
-function getPreservedEndAnchorOffsetDiff(ctx) {
+function advanceCurrentInitialScrollSession(ctx, options) {
   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)) {
-    return;
+  return ((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" ? advanceOffsetInitialScroll(ctx, {
+    forceScroll: options == null ? void 0 : options.forceScroll
+  }) : advanceMeasuredInitialScroll(ctx, {
+    forceScroll: options == null ? void 0 : options.forceScroll
+  });
+}
+
+// src/utils/checkAllSizesKnown.ts
+function isNullOrUndefined2(value) {
+  return value === null || value === void 0;
+}
+function getMountedIndicesInRange(state, start, end) {
+  if (!isNullOrUndefined2(end) && !isNullOrUndefined2(start) && start >= 0 && end >= 0) {
+    return Array.from(state.containerItemKeys.keys()).map((key) => state.indexByKey.get(key)).filter((index) => index !== void 0 && index >= start && index <= end).sort((a, b) => a - b);
   }
-  const currentOffset = typeof state.lastNativeScroll === "number" && Number.isFinite(state.lastNativeScroll) ? state.lastNativeScroll : getObservedBootstrapInitialScrollOffset(state);
-  return resolveInitialScrollOffset(ctx, initialScroll) - currentOffset;
+  return [];
 }
-function schedulePreservedEndAnchorCorrection(ctx) {
-  if (getPreservedEndAnchorOffsetDiff(ctx) === void 0) {
+function getMountedBufferedIndices(state) {
+  return getMountedIndicesInRange(state, state.startBuffered, state.endBuffered);
+}
+function getMountedNoBufferIndices(state) {
+  return getMountedIndicesInRange(state, state.startNoBuffer, state.endNoBuffer);
+}
+function checkAllSizesKnown(state, indices) {
+  return indices.length > 0 && indices.every((index) => {
+    const key = getId(state, index);
+    return key !== void 0 && state.sizesKnown.has(key);
+  });
+}
+
+// src/core/bootstrapInitialScroll.ts
+var DEFAULT_BOOTSTRAP_REVEAL_EPSILON = 1;
+var DEFAULT_BOOTSTRAP_REVEAL_MAX_FRAMES = 8;
+var DEFAULT_BOOTSTRAP_REVEAL_MAX_PASSES = 24;
+var BOOTSTRAP_REVEAL_ABORT_WARNING = "LegendList bootstrap initial scroll aborted after exceeding convergence bounds.";
+function getBootstrapInitialScrollSession(state) {
+  var _a3;
+  return ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
+}
+function isOffsetInitialScrollSession(state) {
+  var _a3;
+  return ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+}
+function doVisibleIndicesMatch(previous, next) {
+  if (!previous || previous.length !== next.length) {
     return false;
   }
-  const correction = {};
-  schedulePreservedEndAnchorCorrectionFrame(ctx, correction);
+  for (let i = 0; i < previous.length; i++) {
+    if (previous[i] !== next[i]) {
+      return false;
+    }
+  }
   return true;
 }
-function schedulePreservedEndAnchorCorrectionFrame(ctx, correction) {
-  const state = ctx.state;
-  state.preservedEndAnchorCorrection = correction;
-  requestAnimationFrame(() => {
-    var _a3;
-    const activeCorrection = state.preservedEndAnchorCorrection;
-    if (activeCorrection !== correction) {
-      return;
+function getBootstrapRevealVisibleIndices(options) {
+  const { dataLength, getSize, offset, positions, scrollLength, startIndex: requestedStartIndex } = options;
+  const endOffset = offset + scrollLength;
+  const visibleIndices = [];
+  let index = requestedStartIndex !== void 0 ? Math.max(0, Math.min(dataLength - 1, requestedStartIndex)) : 0;
+  while (index > 0) {
+    const previousIndex = index - 1;
+    const previousPosition = positions[previousIndex];
+    if (previousPosition === void 0) {
+      index = previousIndex;
+      continue;
     }
-    const offsetDiff = getPreservedEndAnchorOffsetDiff(ctx);
-    if (offsetDiff === void 0 || Math.abs(offsetDiff) <= DEFAULT_BOOTSTRAP_REVEAL_EPSILON) {
-      state.preservedEndAnchorCorrection = void 0;
-      return;
+    const previousSize = getSize(previousIndex);
+    if (previousSize === void 0) {
+      index = previousIndex;
+      continue;
     }
-    const hasObservedNativeScrollAfterRequest = !activeCorrection.lastRequestTime || ((_a3 = state.lastNativeScrollTime) != null ? _a3 : 0) > activeCorrection.lastRequestTime;
-    if (hasObservedNativeScrollAfterRequest) {
-      activeCorrection.lastRequestTime = Date.now();
-      requestAdjust(ctx, offsetDiff);
+    if (previousPosition + previousSize <= offset) {
+      break;
     }
-    schedulePreservedEndAnchorCorrectionFrame(ctx, correction);
-  });
-}
-function clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx) {
-  var _a3, _b;
-  const state = ctx.state;
-  const initialScroll = state.initialScroll;
-  if (!state.didFinishInitialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) || (initialScroll == null ? void 0 : initialScroll.viewPosition) !== 1 || state.preservedEndAnchorCorrection) {
-    return;
+    index = previousIndex;
   }
-  if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
-    const shouldKeepEndTargetAlive = isRetargetableBottomAlignedInitialScrollTarget(initialScroll) && peek$(ctx, "isAtEnd");
-    if (!shouldKeepEndTargetAlive) {
-      if (shouldPreserveInitialScrollForFooterLayout(initialScroll)) {
-        clearPendingInitialScrollFooterLayout(ctx, {
-          dataLength: state.props.data.length,
-          stylePaddingBottom: (_b = state.props.stylePaddingBottom) != null ? _b : 0,
-          target: initialScroll
-        });
-      } else {
-        clearFinishedViewportRetargetableInitialScroll(state);
-      }
+  for (; index < dataLength; index++) {
+    const position = positions[index];
+    if (position === void 0) {
+      continue;
+    }
+    const size = getSize(index);
+    if (size === void 0) {
+      continue;
+    }
+    if (position < endOffset && position + size > offset) {
+      visibleIndices.push(index);
+    } else if (visibleIndices.length > 0 && position >= endOffset) {
+      break;
     }
   }
+  return visibleIndices;
 }
-function startBootstrapInitialScrollOnMount(ctx, options) {
-  var _a3, _b, _c;
-  const { initialScrollAtEnd, target } = options;
-  const state = ctx.state;
-  const offset = resolveInitialScrollOffset(ctx, target);
-  const shouldFinishAtOrigin = offset === 0 && !initialScrollAtEnd && (isOffsetInitialScrollSession(state) ? Math.abs((_a3 = target.contentOffset) != null ? _a3 : 0) <= 1 : target.index === 0 && ((_b = target.viewPosition) != null ? _b : 0) === 0 && Math.abs((_c = target.viewOffset) != null ? _c : 0) <= 1);
-  const shouldFinishWithPreservedTarget = state.props.data.length === 0 && target.index !== void 0;
-  if (shouldFinishAtOrigin) {
-    clearBootstrapInitialScrollSession(state);
-    finishInitialScroll(ctx, {
-      resolvedOffset: offset
-    });
-  } else if (shouldFinishWithPreservedTarget) {
-    clearBootstrapInitialScrollSession(state);
-    finishInitialScroll(ctx, {
-      preserveTarget: true,
-      resolvedOffset: offset
-    });
-  } else {
-    startBootstrapInitialScrollSession(state, {
-      scroll: offset,
-      seedContentOffset: Platform.OS === "web" ? 0 : offset,
-      targetIndexSeed: target.index
-    });
-    ensureBootstrapInitialScrollFrameTicker(ctx);
-  }
+function shouldAbortBootstrapReveal(options) {
+  const {
+    mountFrameCount,
+    maxFrames = DEFAULT_BOOTSTRAP_REVEAL_MAX_FRAMES,
+    maxPasses = DEFAULT_BOOTSTRAP_REVEAL_MAX_PASSES,
+    passCount
+  } = options;
+  return mountFrameCount >= maxFrames || passCount >= maxPasses;
 }
-function handleBootstrapInitialScrollDataChange(ctx, options) {
-  const { dataLength, didDataChange, initialScrollAtEnd, previousDataLength, stylePaddingBottom } = options;
-  const state = ctx.state;
-  const initialScroll = state.initialScroll;
-  if (isOffsetInitialScrollSession(state) || !initialScroll) {
-    return;
+function abortBootstrapRevealIfNeeded(ctx, options) {
+  if (!shouldAbortBootstrapReveal(options)) {
+    return false;
   }
-  const shouldResetDidFinish = !!(state.didFinishInitialScroll && previousDataLength === 0 && dataLength > 0 && initialScroll.index !== void 0);
-  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  const shouldClearFinishedResizePreservation = !initialScrollAtEnd && didDataChange && dataLength > 0 && state.didFinishInitialScroll && !bootstrapInitialScroll && !shouldResetDidFinish;
-  if (shouldClearFinishedResizePreservation) {
-    clearPreservedInitialScrollTarget(state);
-    return;
+  if (IS_DEV) {
+    console.warn(BOOTSTRAP_REVEAL_ABORT_WARNING);
   }
-  const shouldRetargetBottomAligned = dataLength > 0 && (initialScrollAtEnd || isRetargetableBottomAlignedInitialScrollTarget(initialScroll));
-  if (!didDataChange && !shouldResetDidFinish && !shouldRetargetBottomAligned) {
-    return;
+  abortBootstrapInitialScroll(ctx);
+  return true;
+}
+function clearBootstrapInitialScrollSession(state) {
+  var _a3;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  const frameHandle = bootstrapInitialScroll == null ? void 0 : bootstrapInitialScroll.frameHandle;
+  if (frameHandle !== void 0 && typeof cancelAnimationFrame === "function") {
+    cancelAnimationFrame(frameHandle);
   }
-  if (shouldRetargetBottomAligned) {
-    const updatedInitialScroll = initialScrollAtEnd ? createInitialScrollAtEndTarget({
-      dataLength,
-      footerSize: peek$(ctx, "footerSize") || 0,
-      preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
-      stylePaddingBottom
-    }) : createRetargetedBottomAlignedInitialScroll({
-      dataLength,
-      footerSize: peek$(ctx, "footerSize") || 0,
-      initialScrollAtEnd,
-      stylePaddingBottom,
-      target: initialScroll
-    });
-    if (!shouldResetDidFinish && didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
-      clearPendingInitialScrollFooterLayout(ctx, {
-        dataLength,
-        stylePaddingBottom,
-        target: initialScroll
+  if (bootstrapInitialScroll) {
+    bootstrapInitialScroll.frameHandle = void 0;
+  }
+  setInitialScrollSession(state, {
+    bootstrap: null,
+    kind: (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind
+  });
+}
+function startBootstrapInitialScrollSession(state, options) {
+  var _a3, _b, _c;
+  const previousBootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  setInitialScrollSession(state, {
+    bootstrap: {
+      frameHandle: previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.frameHandle,
+      // Re-arming during the initial mount should spend from the same watchdog budget.
+      mountFrameCount: (_a3 = previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.mountFrameCount) != null ? _a3 : 0,
+      passCount: 0,
+      previousResolvedOffset: void 0,
+      scroll: options.scroll,
+      seedContentOffset: (_c = (_b = options.seedContentOffset) != null ? _b : previousBootstrapInitialScroll == null ? void 0 : previousBootstrapInitialScroll.seedContentOffset) != null ? _c : options.scroll,
+      targetIndexSeed: options.targetIndexSeed,
+      visibleIndices: void 0
+    },
+    kind: "bootstrap"
+  });
+}
+function resetBootstrapInitialScrollSession(state, options) {
+  var _a3, _b, _c;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  if (!bootstrapInitialScroll) {
+    if ((options == null ? void 0 : options.scroll) !== void 0) {
+      startBootstrapInitialScrollSession(state, {
+        scroll: options.scroll,
+        seedContentOffset: options.seedContentOffset,
+        targetIndexSeed: options.targetIndexSeed
       });
+    }
+  } else {
+    bootstrapInitialScroll.passCount = 0;
+    bootstrapInitialScroll.previousResolvedOffset = void 0;
+    bootstrapInitialScroll.scroll = (_a3 = options == null ? void 0 : options.scroll) != null ? _a3 : bootstrapInitialScroll.scroll;
+    bootstrapInitialScroll.seedContentOffset = (_b = options == null ? void 0 : options.seedContentOffset) != null ? _b : bootstrapInitialScroll.seedContentOffset;
+    bootstrapInitialScroll.targetIndexSeed = (_c = options == null ? void 0 : options.targetIndexSeed) != null ? _c : bootstrapInitialScroll.targetIndexSeed;
+    bootstrapInitialScroll.visibleIndices = void 0;
+    setInitialScrollSession(state, {
+      bootstrap: bootstrapInitialScroll,
+      kind: "bootstrap"
+    });
+  }
+}
+function queueBootstrapInitialScrollReevaluation(state) {
+  requestAnimationFrame(() => {
+    var _a3;
+    if (getBootstrapInitialScrollSession(state)) {
+      (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
+    }
+  });
+}
+function ensureBootstrapInitialScrollFrameTicker(ctx) {
+  const state = ctx.state;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  if (!bootstrapInitialScroll || bootstrapInitialScroll.frameHandle !== void 0) {
+    return;
+  }
+  const tick = () => {
+    const activeBootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+    if (!activeBootstrapInitialScroll) {
       return;
     }
-    if (!areEquivalentBootstrapInitialScrollTargets(initialScroll, updatedInitialScroll) || !!bootstrapInitialScroll || shouldResetDidFinish || didDataChange) {
-      setInitialScrollTarget(state, updatedInitialScroll, {
-        resetDidFinish: shouldResetDidFinish
-      });
-      rearmBootstrapInitialScroll(ctx, {
-        scroll: resolveInitialScrollOffset(ctx, updatedInitialScroll),
-        seedContentOffset: shouldResetDidFinish && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
-        targetIndexSeed: updatedInitialScroll.index
-      });
+    activeBootstrapInitialScroll.frameHandle = void 0;
+    activeBootstrapInitialScroll.mountFrameCount += 1;
+    if (abortBootstrapRevealIfNeeded(ctx, {
+      mountFrameCount: activeBootstrapInitialScroll.mountFrameCount,
+      passCount: activeBootstrapInitialScroll.passCount
+    })) {
       return;
     }
-  }
-  if (!didDataChange) {
+    ensureBootstrapInitialScrollFrameTicker(ctx);
+  };
+  bootstrapInitialScroll.frameHandle = requestAnimationFrame(tick);
+}
+function rearmBootstrapInitialScroll(ctx, options) {
+  resetBootstrapInitialScrollSession(ctx.state, options);
+  ensureBootstrapInitialScrollFrameTicker(ctx);
+  queueBootstrapInitialScrollReevaluation(ctx.state);
+}
+function createInitialScrollAtEndTarget(options) {
+  const { dataLength, footerSize, preserveForFooterLayout, stylePaddingBottom } = options;
+  return {
+    contentOffset: void 0,
+    index: Math.max(0, dataLength - 1),
+    preserveForBottomPadding: true,
+    preserveForFooterLayout,
+    viewOffset: -stylePaddingBottom - footerSize,
+    viewPosition: 1
+  };
+}
+function shouldPreserveInitialScrollForBottomPadding(target) {
+  return !!(target == null ? void 0 : target.preserveForBottomPadding);
+}
+function shouldPreserveInitialScrollForFooterLayout(target) {
+  return !!(target == null ? void 0 : target.preserveForFooterLayout);
+}
+function isRetargetableBottomAlignedInitialScrollTarget(target) {
+  return !!(target && target.viewPosition === 1 && (shouldPreserveInitialScrollForBottomPadding(target) || shouldPreserveInitialScrollForFooterLayout(target)));
+}
+function createRetargetedBottomAlignedInitialScroll(options) {
+  const { dataLength, footerSize, initialScrollAtEnd, stylePaddingBottom, target } = options;
+  const preserveForFooterLayout = shouldPreserveInitialScrollForFooterLayout(target);
+  return {
+    ...target,
+    contentOffset: void 0,
+    index: initialScrollAtEnd ? Math.max(0, dataLength - 1) : target.index,
+    preserveForBottomPadding: true,
+    preserveForFooterLayout,
+    viewOffset: -stylePaddingBottom - (preserveForFooterLayout ? footerSize : 0),
+    viewPosition: 1
+  };
+}
+function areEquivalentBootstrapInitialScrollTargets(current, next) {
+  return current.index === next.index && current.preserveForBottomPadding === next.preserveForBottomPadding && current.preserveForFooterLayout === next.preserveForFooterLayout && current.viewOffset === next.viewOffset && current.viewPosition === next.viewPosition;
+}
+function clearPendingInitialScrollFooterLayout(ctx, options) {
+  const { dataLength, stylePaddingBottom, target } = options;
+  const state = ctx.state;
+  if (!shouldPreserveInitialScrollForFooterLayout(target)) {
     return;
   }
-  if (bootstrapInitialScroll || shouldResetDidFinish) {
-    setInitialScrollTarget(state, initialScroll, {
-      resetDidFinish: shouldResetDidFinish
-    });
-    rearmBootstrapInitialScroll(ctx, {
-      scroll: resolveInitialScrollOffset(ctx, initialScroll),
-      seedContentOffset: shouldResetDidFinish && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
-      targetIndexSeed: initialScroll.index
-    });
-  }
+  const clearedFooterTarget = createInitialScrollAtEndTarget({
+    dataLength,
+    footerSize: 0,
+    preserveForFooterLayout: void 0,
+    stylePaddingBottom
+  });
+  setInitialScrollTarget(state, clearedFooterTarget);
 }
-function handleBootstrapInitialScrollFooterLayout(ctx, options) {
-  const { dataLength, footerSize, initialScrollAtEnd, stylePaddingBottom } = options;
+function clearFinishedViewportRetargetableInitialScroll(state) {
+  clearPreservedInitialScrollTarget(state);
+}
+function didFinishedInitialScrollMoveAwayFromTarget(ctx, target, epsilon = DEFAULT_BOOTSTRAP_REVEAL_EPSILON) {
   const state = ctx.state;
-  if (!initialScrollAtEnd) {
-    return;
+  if (!state.didFinishInitialScroll) {
+    return false;
   }
+  const currentOffset = getObservedBootstrapInitialScrollOffset(state);
+  return Math.abs(currentOffset - resolveInitialScrollOffset(ctx, target)) > epsilon;
+}
+function getObservedBootstrapInitialScrollOffset(state) {
+  var _a3, _b, _c, _d;
+  const observedOffset = (_b = (_a3 = state.refScroller.current) == null ? void 0 : _a3.getCurrentScrollOffset) == null ? void 0 : _b.call(_a3);
+  return typeof observedOffset === "number" && Number.isFinite(observedOffset) ? observedOffset : (_d = (_c = state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0;
+}
+function getPreservedEndAnchorOffsetDiff(ctx) {
+  var _a3;
+  const state = ctx.state;
   const initialScroll = state.initialScroll;
-  if (isOffsetInitialScrollSession(state) || dataLength === 0 || !initialScroll) {
-    return;
-  }
-  const shouldProcessFooterLayout = !!getBootstrapInitialScrollSession(state) || shouldPreserveInitialScrollForFooterLayout(initialScroll);
-  if (!shouldProcessFooterLayout) {
+  if (!state.didFinishInitialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) || !initialScroll || initialScroll.viewPosition !== 1 || state.props.data.length === 0 || isOffsetInitialScrollSession(state)) {
     return;
   }
-  if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
-    clearPendingInitialScrollFooterLayout(ctx, {
-      dataLength,
-      stylePaddingBottom,
-      target: initialScroll
-    });
-  } else {
-    const updatedInitialScroll = createInitialScrollAtEndTarget({
-      dataLength,
-      footerSize,
-      preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
-      stylePaddingBottom
-    });
-    const didTargetChange = initialScroll.index !== updatedInitialScroll.index || initialScroll.viewPosition !== updatedInitialScroll.viewPosition || initialScroll.viewOffset !== updatedInitialScroll.viewOffset;
-    if (!didTargetChange) {
-      clearPendingInitialScrollFooterLayout(ctx, {
-        dataLength,
-        stylePaddingBottom,
-        target: initialScroll
-      });
-    } else {
-      const didFinishInitialScroll = !!state.didFinishInitialScroll;
-      setInitialScrollTarget(state, updatedInitialScroll, {
-        resetDidFinish: didFinishInitialScroll
-      });
-      rearmBootstrapInitialScroll(ctx, {
-        scroll: resolveInitialScrollOffset(ctx, updatedInitialScroll),
-        targetIndexSeed: updatedInitialScroll.index
-      });
-    }
+  const currentOffset = typeof state.lastNativeScroll === "number" && Number.isFinite(state.lastNativeScroll) ? state.lastNativeScroll : getObservedBootstrapInitialScrollOffset(state);
+  return resolveInitialScrollOffset(ctx, initialScroll) - currentOffset;
+}
+function schedulePreservedEndAnchorCorrection(ctx) {
+  if (getPreservedEndAnchorOffsetDiff(ctx) === void 0) {
+    return false;
   }
+  const correction = {};
+  schedulePreservedEndAnchorCorrectionFrame(ctx, correction);
+  return true;
 }
-function handleBootstrapInitialScrollLayoutChange(ctx) {
-  var _a3, _b, _c;
+function schedulePreservedEndAnchorCorrectionFrame(ctx, correction) {
   const state = ctx.state;
-  const initialScroll = state.initialScroll;
-  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
-  if (initialScroll && state.props.data.length > 0 && !isOffsetInitialScrollSession(state) && (bootstrapInitialScroll || initialScroll.viewPosition === 1)) {
+  state.preservedEndAnchorCorrection = correction;
+  requestAnimationFrame(() => {
+    var _a3;
+    const activeCorrection = state.preservedEndAnchorCorrection;
+    if (activeCorrection !== correction) {
+      return;
+    }
+    const offsetDiff = getPreservedEndAnchorOffsetDiff(ctx);
+    if (offsetDiff === void 0 || Math.abs(offsetDiff) <= DEFAULT_BOOTSTRAP_REVEAL_EPSILON) {
+      state.preservedEndAnchorCorrection = void 0;
+      return;
+    }
+    const hasObservedNativeScrollAfterRequest = !activeCorrection.lastRequestTime || ((_a3 = state.lastNativeScrollTime) != null ? _a3 : 0) > activeCorrection.lastRequestTime;
+    if (hasObservedNativeScrollAfterRequest) {
+      activeCorrection.lastRequestTime = Date.now();
+      requestAdjust(ctx, offsetDiff);
+    }
+    schedulePreservedEndAnchorCorrectionFrame(ctx, correction);
+  });
+}
+function clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx) {
+  var _a3, _b;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  if (!state.didFinishInitialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) || (initialScroll == null ? void 0 : initialScroll.viewPosition) !== 1 || state.preservedEndAnchorCorrection) {
+    return;
+  }
+  if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
+    const shouldKeepEndTargetAlive = isRetargetableBottomAlignedInitialScrollTarget(initialScroll) && peek$(ctx, "isAtEnd");
+    if (!shouldKeepEndTargetAlive) {
+      if (shouldPreserveInitialScrollForFooterLayout(initialScroll)) {
+        clearPendingInitialScrollFooterLayout(ctx, {
+          dataLength: state.props.data.length,
+          stylePaddingBottom: (_b = state.props.stylePaddingBottom) != null ? _b : 0,
+          target: initialScroll
+        });
+      } else {
+        clearFinishedViewportRetargetableInitialScroll(state);
+      }
+    }
+  }
+}
+function startBootstrapInitialScrollOnMount(ctx, options) {
+  var _a3, _b, _c;
+  const { initialScrollAtEnd, target } = options;
+  const state = ctx.state;
+  const offset = resolveInitialScrollOffset(ctx, target);
+  const shouldFinishAtOrigin = offset === 0 && !initialScrollAtEnd && (isOffsetInitialScrollSession(state) ? Math.abs((_a3 = target.contentOffset) != null ? _a3 : 0) <= 1 : target.index === 0 && ((_b = target.viewPosition) != null ? _b : 0) === 0 && Math.abs((_c = target.viewOffset) != null ? _c : 0) <= 1);
+  const shouldFinishWithPreservedTarget = state.props.data.length === 0 && target.index !== void 0;
+  if (shouldFinishAtOrigin) {
+    clearBootstrapInitialScrollSession(state);
+    finishInitialScroll(ctx, {
+      resolvedOffset: offset
+    });
+  } else if (shouldFinishWithPreservedTarget) {
+    clearBootstrapInitialScrollSession(state);
+    finishInitialScroll(ctx, {
+      preserveTarget: true,
+      resolvedOffset: offset
+    });
+  } else {
+    startBootstrapInitialScrollSession(state, {
+      scroll: offset,
+      seedContentOffset: Platform.OS === "web" ? 0 : offset,
+      targetIndexSeed: target.index
+    });
+    ensureBootstrapInitialScrollFrameTicker(ctx);
+  }
+}
+function handleBootstrapInitialScrollDataChange(ctx, options) {
+  const { dataLength, didDataChange, initialScrollAtEnd, previousDataLength, stylePaddingBottom } = options;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  if (isOffsetInitialScrollSession(state) || !initialScroll) {
+    return;
+  }
+  const shouldResetDidFinish = !!(state.didFinishInitialScroll && previousDataLength === 0 && dataLength > 0 && initialScroll.index !== void 0);
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  const shouldClearFinishedResizePreservation = !initialScrollAtEnd && didDataChange && dataLength > 0 && state.didFinishInitialScroll && !bootstrapInitialScroll && !shouldResetDidFinish;
+  if (shouldClearFinishedResizePreservation) {
+    clearPreservedInitialScrollTarget(state);
+    return;
+  }
+  const shouldRetargetBottomAligned = dataLength > 0 && (initialScrollAtEnd || isRetargetableBottomAlignedInitialScrollTarget(initialScroll));
+  if (!didDataChange && !shouldResetDidFinish && !shouldRetargetBottomAligned) {
+    return;
+  }
+  if (shouldRetargetBottomAligned) {
+    const updatedInitialScroll = initialScrollAtEnd ? createInitialScrollAtEndTarget({
+      dataLength,
+      footerSize: peek$(ctx, "footerSize") || 0,
+      preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
+      stylePaddingBottom
+    }) : createRetargetedBottomAlignedInitialScroll({
+      dataLength,
+      footerSize: peek$(ctx, "footerSize") || 0,
+      initialScrollAtEnd,
+      stylePaddingBottom,
+      target: initialScroll
+    });
+    if (!shouldResetDidFinish && didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
+      clearPendingInitialScrollFooterLayout(ctx, {
+        dataLength,
+        stylePaddingBottom,
+        target: initialScroll
+      });
+      return;
+    }
+    if (!areEquivalentBootstrapInitialScrollTargets(initialScroll, updatedInitialScroll) || !!bootstrapInitialScroll || shouldResetDidFinish || didDataChange) {
+      setInitialScrollTarget(state, updatedInitialScroll, {
+        resetDidFinish: shouldResetDidFinish
+      });
+      rearmBootstrapInitialScroll(ctx, {
+        scroll: resolveInitialScrollOffset(ctx, updatedInitialScroll),
+        seedContentOffset: shouldResetDidFinish && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
+        targetIndexSeed: updatedInitialScroll.index
+      });
+      return;
+    }
+  }
+  if (!didDataChange) {
+    return;
+  }
+  if (bootstrapInitialScroll || shouldResetDidFinish) {
+    setInitialScrollTarget(state, initialScroll, {
+      resetDidFinish: shouldResetDidFinish
+    });
+    rearmBootstrapInitialScroll(ctx, {
+      scroll: resolveInitialScrollOffset(ctx, initialScroll),
+      seedContentOffset: shouldResetDidFinish && !bootstrapInitialScroll ? getObservedBootstrapInitialScrollOffset(state) : void 0,
+      targetIndexSeed: initialScroll.index
+    });
+  }
+}
+function handleBootstrapInitialScrollFooterLayout(ctx, options) {
+  const { dataLength, footerSize, initialScrollAtEnd, stylePaddingBottom } = options;
+  const state = ctx.state;
+  if (!initialScrollAtEnd) {
+    return;
+  }
+  const initialScroll = state.initialScroll;
+  if (isOffsetInitialScrollSession(state) || dataLength === 0 || !initialScroll) {
+    return;
+  }
+  const shouldProcessFooterLayout = !!getBootstrapInitialScrollSession(state) || shouldPreserveInitialScrollForFooterLayout(initialScroll);
+  if (!shouldProcessFooterLayout) {
+    return;
+  }
+  if (didFinishedInitialScrollMoveAwayFromTarget(ctx, initialScroll)) {
+    clearPendingInitialScrollFooterLayout(ctx, {
+      dataLength,
+      stylePaddingBottom,
+      target: initialScroll
+    });
+  } else {
+    const updatedInitialScroll = createInitialScrollAtEndTarget({
+      dataLength,
+      footerSize,
+      preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
+      stylePaddingBottom
+    });
+    const didTargetChange = initialScroll.index !== updatedInitialScroll.index || initialScroll.viewPosition !== updatedInitialScroll.viewPosition || initialScroll.viewOffset !== updatedInitialScroll.viewOffset;
+    if (!didTargetChange) {
+      clearPendingInitialScrollFooterLayout(ctx, {
+        dataLength,
+        stylePaddingBottom,
+        target: initialScroll
+      });
+    } else {
+      const didFinishInitialScroll = !!state.didFinishInitialScroll;
+      setInitialScrollTarget(state, updatedInitialScroll, {
+        resetDidFinish: didFinishInitialScroll
+      });
+      rearmBootstrapInitialScroll(ctx, {
+        scroll: resolveInitialScrollOffset(ctx, updatedInitialScroll),
+        targetIndexSeed: updatedInitialScroll.index
+      });
+    }
+  }
+}
+function handleBootstrapInitialScrollLayoutChange(ctx) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  const bootstrapInitialScroll = getBootstrapInitialScrollSession(state);
+  if (initialScroll && state.props.data.length > 0 && !isOffsetInitialScrollSession(state) && (bootstrapInitialScroll || initialScroll.viewPosition === 1)) {
     const resolvedOffset = resolveInitialScrollOffset(ctx, initialScroll);
     const scrollingTo = ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) ? state.scrollingTo : void 0;
     if (!bootstrapInitialScroll && (scrollingTo || state.didFinishInitialScroll)) {
@@ -3008,403 +3449,111 @@ function abortBootstrapInitialScroll(ctx) {
   const initialScroll = state.initialScroll;
   if (bootstrapInitialScroll && initialScroll && !isOffsetInitialScrollSession(state) && state.refScroller.current) {
     clearBootstrapInitialScrollSession(state);
-    dispatchInitialScroll(ctx, {
-      forceScroll: true,
-      resolvedOffset: bootstrapInitialScroll.scroll,
-      target: initialScroll,
-      waitForCompletionFrame: Platform.OS === "web"
-    });
-  } else {
-    finishBootstrapInitialScrollWithoutScroll(
-      ctx,
-      (_d = (_c = (_b = (_a3 = getBootstrapInitialScrollSession(state)) == null ? void 0 : _a3.scroll) != null ? _b : state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0
-    );
-  }
-}
-
-// src/core/initialScrollLifecycle.ts
-function retargetActiveInitialScrollAtEnd(ctx) {
-  var _a3;
-  const state = ctx.state;
-  const initialScroll = state.initialScroll;
-  if (state.didFinishInitialScroll) {
-    return schedulePreservedEndAnchorCorrection(ctx);
-  }
-  if (!initialScroll || ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" || initialScroll.viewPosition !== 1 || state.props.data.length === 0) {
-    return false;
-  }
-  return advanceCurrentInitialScrollSession(ctx, { forceScroll: true });
-}
-function handleInitialScrollLayoutReady(ctx) {
-  var _a3;
-  if (!ctx.state.initialScroll) {
-    return;
-  }
-  const runScroll = () => advanceCurrentInitialScrollSession(ctx, { forceScroll: true });
-  runScroll();
-  if (((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) !== "offset") {
-    requestAnimationFrame(runScroll);
-  }
-  checkFinishedScroll(ctx, { onlyIfAligned: true });
-}
-function initializeInitialScrollOnMount(ctx, options) {
-  var _a3, _b;
-  const {
-    alwaysDispatchInitialScroll,
-    dataLength,
-    hasFooterComponent,
-    initialContentOffset,
-    initialScrollAtEnd,
-    useBootstrapInitialScroll
-  } = options;
-  const state = ctx.state;
-  const initialScroll = state.initialScroll;
-  const resolvedInitialContentOffset = initialContentOffset != null ? initialContentOffset : 0;
-  const preserveForFooterLayout = useBootstrapInitialScroll && initialScrollAtEnd && hasFooterComponent;
-  if (initialScroll && (initialScroll.contentOffset === void 0 || !!initialScroll.preserveForFooterLayout !== preserveForFooterLayout && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) !== "offset")) {
-    setInitialScrollTarget(state, {
-      ...initialScroll,
-      contentOffset: resolvedInitialContentOffset,
-      preserveForFooterLayout
-    });
-  }
-  if (useBootstrapInitialScroll && initialScroll && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) !== "offset") {
-    startBootstrapInitialScrollOnMount(ctx, {
-      initialScrollAtEnd,
-      target: state.initialScroll
-    });
-    return;
-  }
-  const hasPendingDataDependentInitialScroll = !!initialScroll && dataLength === 0 && !(resolvedInitialContentOffset === 0 && !initialScrollAtEnd);
-  if (!alwaysDispatchInitialScroll && !resolvedInitialContentOffset && !hasPendingDataDependentInitialScroll) {
-    if (initialScroll && !initialScrollAtEnd) {
-      finishInitialScroll(ctx, {
-        resolvedOffset: resolvedInitialContentOffset
-      });
-    } else {
-      setInitialRenderState(ctx, { didInitialScroll: true });
-    }
-  }
-}
-function handleInitialScrollDataChange(ctx, options) {
-  var _a3, _b, _c;
-  const { dataLength, didDataChange, initialScrollAtEnd, stylePaddingBottom, useBootstrapInitialScroll } = options;
-  const state = ctx.state;
-  const previousDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
-  if (state.initialScrollSession) {
-    state.initialScrollSession.previousDataLength = dataLength;
-  }
-  setInitialScrollSession(state);
-  if (useBootstrapInitialScroll) {
-    handleBootstrapInitialScrollDataChange(ctx, {
-      dataLength,
-      didDataChange,
-      initialScrollAtEnd,
-      previousDataLength,
-      stylePaddingBottom
-    });
-    return;
-  }
-  const shouldReplayFinishedOffsetInitialScroll = previousDataLength === 0 && dataLength > 0 && !!state.initialScroll && ((_c = ctx.state.initialScrollSession) == null ? void 0 : _c.kind) === "offset" && !!state.didFinishInitialScroll;
-  if (previousDataLength !== 0 || dataLength === 0 || !state.initialScroll || !state.queuedInitialLayout || state.didFinishInitialScroll && !shouldReplayFinishedOffsetInitialScroll) {
-    return;
-  }
-  if (shouldReplayFinishedOffsetInitialScroll) {
-    state.didFinishInitialScroll = false;
-  }
-  advanceCurrentInitialScrollSession(ctx);
-}
-
-// src/core/mvcp.ts
-var MVCP_POSITION_EPSILON = 0.1;
-var MVCP_ANCHOR_LOCK_TTL_MS = 300;
-var MVCP_ANCHOR_LOCK_QUIET_PASSES_TO_RELEASE = 2;
-var NATIVE_END_CLAMP_EPSILON = 1;
-function resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) {
-  if (!enableMVCPAnchorLock) {
-    state.mvcpAnchorLock = void 0;
-    return void 0;
-  }
-  const lock = state.mvcpAnchorLock;
-  if (!lock) {
-    return void 0;
-  }
-  const isExpired = now > lock.expiresAt;
-  const isMissing = state.indexByKey.get(lock.id) === void 0;
-  if (isExpired || isMissing || !mvcpData) {
-    state.mvcpAnchorLock = void 0;
-    return void 0;
-  }
-  return lock;
-}
-function updateAnchorLock(state, params) {
-  if (Platform.OS === "web") {
-    const { anchorId, anchorPosition, dataChanged, now, positionDiff } = params;
-    const enableMVCPAnchorLock = !!dataChanged || !!state.mvcpAnchorLock;
-    const mvcpData = state.props.maintainVisibleContentPosition.data;
-    if (!enableMVCPAnchorLock || !mvcpData || state.scrollingTo || !anchorId || anchorPosition === void 0) {
-      return;
-    }
-    const existingLock = state.mvcpAnchorLock;
-    const quietPasses = !dataChanged && Math.abs(positionDiff) <= MVCP_POSITION_EPSILON && (existingLock == null ? void 0 : existingLock.id) === anchorId ? existingLock.quietPasses + 1 : 0;
-    if (!dataChanged && quietPasses >= MVCP_ANCHOR_LOCK_QUIET_PASSES_TO_RELEASE) {
-      state.mvcpAnchorLock = void 0;
-      return;
-    }
-    state.mvcpAnchorLock = {
-      expiresAt: now + MVCP_ANCHOR_LOCK_TTL_MS,
-      id: anchorId,
-      position: anchorPosition,
-      quietPasses
-    };
-  }
-}
-function shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotalSize, prevScroll, scrollTarget) {
-  if (!dataChanged || Platform.OS === "web" || !state.props.maintainVisibleContentPosition.data || scrollTarget !== void 0 || positionDiff >= -MVCP_POSITION_EPSILON) {
-    return false;
-  }
-  const distanceFromEnd = prevTotalSize - prevScroll - state.scrollLength;
-  return distanceFromEnd < Math.abs(positionDiff) - MVCP_POSITION_EPSILON;
-}
-function getPredictedNativeClamp(state, unresolvedAmount, totalSize) {
-  if (Math.abs(unresolvedAmount) <= MVCP_POSITION_EPSILON) {
-    return 0;
-  }
-  const maxScroll = Math.max(0, totalSize - state.scrollLength);
-  const clampDelta = maxScroll - state.scroll;
-  if (unresolvedAmount < 0) {
-    return Math.max(unresolvedAmount, Math.min(0, clampDelta));
-  }
-  if (unresolvedAmount > 0) {
-    return Math.min(unresolvedAmount, Math.max(0, clampDelta));
-  }
-  return 0;
-}
-function getProgressTowardAmount(targetDelta, nativeDelta) {
-  return targetDelta < 0 ? -nativeDelta : nativeDelta;
-}
-function settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta) {
-  const state = ctx.state;
-  state.pendingNativeMVCPAdjust = void 0;
-  const remaining = remainingAfterManual - nativeDelta;
-  if (Math.abs(remaining) > MVCP_POSITION_EPSILON) {
-    requestAdjust(ctx, remaining, true);
-  }
-}
-function maybeApplyPredictedNativeMVCPAdjust(ctx) {
-  const state = ctx.state;
-  const pending = state.pendingNativeMVCPAdjust;
-  if (!pending || Math.abs(pending.manualApplied) > MVCP_POSITION_EPSILON) {
-    return;
-  }
-  const totalSize = getContentSize(ctx);
-  const predictedNativeClamp = getPredictedNativeClamp(state, pending.amount, totalSize);
-  if (Math.abs(predictedNativeClamp) <= MVCP_POSITION_EPSILON) {
-    return;
-  }
-  const manualDesired = pending.amount - predictedNativeClamp;
-  if (Math.abs(manualDesired) <= MVCP_POSITION_EPSILON) {
-    return;
-  }
-  pending.manualApplied = manualDesired;
-  requestAdjust(ctx, manualDesired, true);
-  pending.furthestProgressTowardAmount = 0;
-}
-function resolvePendingNativeMVCPAdjust(ctx, newScroll) {
-  const state = ctx.state;
-  const pending = state.pendingNativeMVCPAdjust;
-  if (!pending) {
-    return false;
-  }
-  const remainingAfterManual = pending.amount - pending.manualApplied;
-  const nativeDelta = newScroll - (pending.startScroll + pending.manualApplied);
-  const isWrongDirection = remainingAfterManual < 0 && nativeDelta > MVCP_POSITION_EPSILON || remainingAfterManual > 0 && nativeDelta < -MVCP_POSITION_EPSILON;
-  const progressTowardAmount = getProgressTowardAmount(remainingAfterManual, nativeDelta);
-  if (Math.abs(remainingAfterManual) <= MVCP_POSITION_EPSILON) {
-    state.pendingNativeMVCPAdjust = void 0;
-    return true;
-  }
-  if (isWrongDirection) {
-    state.pendingNativeMVCPAdjust = void 0;
-    return false;
-  }
-  if (progressTowardAmount + MVCP_POSITION_EPSILON >= Math.abs(remainingAfterManual)) {
-    settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
-    return true;
-  }
-  const expectedNativeClampScroll = Math.max(0, getContentSize(ctx) - state.scrollLength);
-  const distanceToClamp = Math.abs(newScroll - expectedNativeClampScroll);
-  const isAtExpectedNativeClamp = distanceToClamp <= NATIVE_END_CLAMP_EPSILON;
-  if (isAtExpectedNativeClamp) {
-    settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
-    return true;
-  }
-  if (state.pendingMaintainScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold") && progressTowardAmount > MVCP_POSITION_EPSILON) {
-    settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
-    return true;
-  }
-  if (progressTowardAmount > pending.furthestProgressTowardAmount + MVCP_POSITION_EPSILON) {
-    pending.furthestProgressTowardAmount = progressTowardAmount;
-    return false;
-  }
-  if (pending.furthestProgressTowardAmount > MVCP_POSITION_EPSILON && progressTowardAmount < pending.furthestProgressTowardAmount - MVCP_POSITION_EPSILON) {
-    state.pendingNativeMVCPAdjust = void 0;
-    return false;
-  }
-  return false;
-}
-function prepareMVCP(ctx, dataChanged) {
-  const state = ctx.state;
-  const { idsInView, positions, props } = state;
-  const {
-    maintainVisibleContentPosition: { data: mvcpData, size: mvcpScroll, shouldRestorePosition }
-  } = props;
-  const isWeb = Platform.OS === "web";
-  const now = Date.now();
-  const enableMVCPAnchorLock = isWeb && (!!dataChanged || !!state.mvcpAnchorLock);
-  const scrollingTo = state.scrollingTo;
-  const anchorLock = isWeb ? resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) : void 0;
-  let prevPosition;
-  let targetId;
-  const idsInViewWithPositions = [];
-  const scrollTarget = scrollingTo == null ? void 0 : scrollingTo.index;
-  const scrollingToViewPosition = scrollingTo == null ? void 0 : scrollingTo.viewPosition;
-  const isEndAnchoredScrollTarget = scrollTarget !== void 0 && state.props.data.length > 0 && scrollTarget >= state.props.data.length - 1 && (scrollingToViewPosition != null ? scrollingToViewPosition : 0) > 0;
-  const shouldMVCP = dataChanged ? mvcpData : mvcpScroll;
-  const indexByKey = state.indexByKey;
-  const prevScroll = state.scroll;
-  const prevTotalSize = getContentSize(ctx);
-  if (shouldMVCP) {
-    if (!isWeb && state.pendingNativeMVCPAdjust && scrollTarget === void 0) {
-      maybeApplyPredictedNativeMVCPAdjust(ctx);
-      return void 0;
-    }
-    if (anchorLock && scrollTarget === void 0) {
-      targetId = anchorLock.id;
-      prevPosition = anchorLock.position;
-    } else if (scrollTarget !== void 0) {
-      if (!IsNewArchitecture && (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll)) {
-        return void 0;
-      }
-      targetId = getId(state, scrollTarget);
-    } else if (idsInView.length > 0 && state.didContainersLayout && !dataChanged) {
-      targetId = idsInView.find((id) => indexByKey.get(id) !== void 0);
-    }
-    if (dataChanged && idsInView.length > 0 && state.didContainersLayout) {
-      for (let i = 0; i < idsInView.length; i++) {
-        const id = idsInView[i];
-        const index = indexByKey.get(id);
-        if (index !== void 0) {
-          const position = positions[index];
-          if (position !== void 0) {
-            idsInViewWithPositions.push({ id, position });
-          }
-        }
-      }
-    }
-    if (targetId !== void 0 && prevPosition === void 0) {
-      const targetIndex = indexByKey.get(targetId);
-      if (targetIndex !== void 0) {
-        prevPosition = positions[targetIndex];
-      }
-    }
-    return () => {
-      let positionDiff = 0;
-      let anchorIdForLock = anchorLock == null ? void 0 : anchorLock.id;
-      let anchorPositionForLock;
-      let skipTargetAnchor = false;
-      const data = state.props.data;
-      const shouldValidateLockedAnchor = isWeb && dataChanged && mvcpData && scrollTarget === void 0 && targetId !== void 0 && (anchorLock == null ? void 0 : anchorLock.id) === targetId && shouldRestorePosition !== void 0;
-      if (shouldValidateLockedAnchor && targetId !== void 0) {
-        const index = indexByKey.get(targetId);
-        if (index !== void 0) {
-          const item = data[index];
-          skipTargetAnchor = item === void 0 || !shouldRestorePosition(item, index, data);
-          if (skipTargetAnchor && (anchorLock == null ? void 0 : anchorLock.id) === targetId) {
-            state.mvcpAnchorLock = void 0;
-          }
-        }
-      }
-      const shouldUseFallbackVisibleAnchor = dataChanged && mvcpData && scrollTarget === void 0 && (() => {
-        if (targetId === void 0 || skipTargetAnchor) {
-          return true;
-        }
-        const targetIndex = indexByKey.get(targetId);
-        return targetIndex === void 0 || positions[targetIndex] === void 0;
-      })();
-      if (shouldUseFallbackVisibleAnchor) {
-        for (let i = 0; i < idsInViewWithPositions.length; i++) {
-          const { id, position } = idsInViewWithPositions[i];
-          const index = indexByKey.get(id);
-          if (index !== void 0 && shouldRestorePosition) {
-            const item = data[index];
-            if (item === void 0 || !shouldRestorePosition(item, index, data)) {
-              continue;
-            }
-          }
-          const newPosition = index !== void 0 ? positions[index] : void 0;
-          if (newPosition !== void 0) {
-            positionDiff = newPosition - position;
-            anchorIdForLock = id;
-            anchorPositionForLock = newPosition;
-            break;
-          }
-        }
-      }
-      if (!skipTargetAnchor && targetId !== void 0 && prevPosition !== void 0) {
-        const targetIndex = indexByKey.get(targetId);
-        const newPosition = targetIndex !== void 0 ? positions[targetIndex] : void 0;
-        if (newPosition !== void 0) {
-          const totalSize = getContentSize(ctx);
-          let diff = newPosition - prevPosition;
-          if (diff !== 0 && isEndAnchoredScrollTarget && state.scroll + state.scrollLength > totalSize) {
-            if (diff > 0) {
-              diff = Math.max(0, totalSize - state.scroll - state.scrollLength);
-            } else {
-              diff = 0;
-            }
-          }
-          positionDiff = diff;
-          anchorIdForLock = targetId;
-          anchorPositionForLock = newPosition;
-        }
-      }
-      if (scrollingToViewPosition && scrollingToViewPosition > 0) {
-        const newSize = getItemSize(ctx, targetId, scrollTarget, state.props.data[scrollTarget]);
-        const prevSize = scrollingTo == null ? void 0 : scrollingTo.itemSize;
-        if (newSize !== void 0 && prevSize !== void 0 && newSize !== prevSize) {
-          const diff = newSize - prevSize;
-          if (diff !== 0) {
-            positionDiff += diff * scrollingToViewPosition;
-            scrollingTo.itemSize = newSize;
-          }
-        }
-      }
-      updateAnchorLock(state, {
-        anchorId: anchorIdForLock,
-        anchorPosition: anchorPositionForLock,
-        dataChanged,
-        now,
-        positionDiff
+    dispatchInitialScroll(ctx, {
+      forceScroll: true,
+      resolvedOffset: bootstrapInitialScroll.scroll,
+      target: initialScroll,
+      waitForCompletionFrame: Platform.OS === "web"
+    });
+  } else {
+    finishBootstrapInitialScrollWithoutScroll(
+      ctx,
+      (_d = (_c = (_b = (_a3 = getBootstrapInitialScrollSession(state)) == null ? void 0 : _a3.scroll) != null ? _b : state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0
+    );
+  }
+}
+
+// src/core/initialScrollLifecycle.ts
+function retargetActiveInitialScrollAtEnd(ctx) {
+  var _a3;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  if (state.didFinishInitialScroll) {
+    return schedulePreservedEndAnchorCorrection(ctx);
+  }
+  if (!initialScroll || ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" || initialScroll.viewPosition !== 1 || state.props.data.length === 0) {
+    return false;
+  }
+  return advanceCurrentInitialScrollSession(ctx, { forceScroll: true });
+}
+function handleInitialScrollLayoutReady(ctx) {
+  var _a3;
+  if (!ctx.state.initialScroll) {
+    return;
+  }
+  const runScroll = () => advanceCurrentInitialScrollSession(ctx, { forceScroll: true });
+  runScroll();
+  if (((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) !== "offset") {
+    requestAnimationFrame(runScroll);
+  }
+  checkFinishedScroll(ctx, { onlyIfAligned: true });
+}
+function initializeInitialScrollOnMount(ctx, options) {
+  var _a3, _b;
+  const {
+    alwaysDispatchInitialScroll,
+    dataLength,
+    hasFooterComponent,
+    initialContentOffset,
+    initialScrollAtEnd,
+    useBootstrapInitialScroll
+  } = options;
+  const state = ctx.state;
+  const initialScroll = state.initialScroll;
+  const resolvedInitialContentOffset = initialContentOffset != null ? initialContentOffset : 0;
+  const preserveForFooterLayout = useBootstrapInitialScroll && initialScrollAtEnd && hasFooterComponent;
+  if (initialScroll && (initialScroll.contentOffset === void 0 || !!initialScroll.preserveForFooterLayout !== preserveForFooterLayout && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) !== "offset")) {
+    setInitialScrollTarget(state, {
+      ...initialScroll,
+      contentOffset: resolvedInitialContentOffset,
+      preserveForFooterLayout
+    });
+  }
+  if (useBootstrapInitialScroll && initialScroll && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) !== "offset") {
+    startBootstrapInitialScrollOnMount(ctx, {
+      initialScrollAtEnd,
+      target: state.initialScroll
+    });
+    return;
+  }
+  const hasPendingDataDependentInitialScroll = !!initialScroll && dataLength === 0 && !(resolvedInitialContentOffset === 0 && !initialScrollAtEnd);
+  if (!alwaysDispatchInitialScroll && !resolvedInitialContentOffset && !hasPendingDataDependentInitialScroll) {
+    if (initialScroll && !initialScrollAtEnd) {
+      finishInitialScroll(ctx, {
+        resolvedOffset: resolvedInitialContentOffset
       });
-      if (shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotalSize, prevScroll, scrollTarget)) {
-        state.pendingNativeMVCPAdjust = {
-          amount: positionDiff,
-          furthestProgressTowardAmount: 0,
-          manualApplied: 0,
-          startScroll: prevScroll
-        };
-        maybeApplyPredictedNativeMVCPAdjust(ctx);
-        return;
-      }
-      if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
-        const shouldSkipAdjustForMaintainedEnd = state.maintainingScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-        if (!shouldSkipAdjustForMaintainedEnd) {
-          requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
-        }
-      }
-    };
+    } else {
+      setInitialRenderState(ctx, { didInitialScroll: true });
+    }
+  }
+}
+function handleInitialScrollDataChange(ctx, options) {
+  var _a3, _b, _c;
+  const { dataLength, didDataChange, initialScrollAtEnd, stylePaddingBottom, useBootstrapInitialScroll } = options;
+  const state = ctx.state;
+  const previousDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
+  if (state.initialScrollSession) {
+    state.initialScrollSession.previousDataLength = dataLength;
+  }
+  setInitialScrollSession(state);
+  if (useBootstrapInitialScroll) {
+    handleBootstrapInitialScrollDataChange(ctx, {
+      dataLength,
+      didDataChange,
+      initialScrollAtEnd,
+      previousDataLength,
+      stylePaddingBottom
+    });
+    return;
   }
+  const shouldReplayFinishedOffsetInitialScroll = previousDataLength === 0 && dataLength > 0 && !!state.initialScroll && ((_c = ctx.state.initialScrollSession) == null ? void 0 : _c.kind) === "offset" && !!state.didFinishInitialScroll;
+  if (previousDataLength !== 0 || dataLength === 0 || !state.initialScroll || !state.queuedInitialLayout || state.didFinishInitialScroll && !shouldReplayFinishedOffsetInitialScroll) {
+    return;
+  }
+  if (shouldReplayFinishedOffsetInitialScroll) {
+    state.didFinishInitialScroll = false;
+  }
+  advanceCurrentInitialScrollSession(ctx);
 }
 
 // src/core/resetLayoutCachesForDataChange.ts
@@ -4359,7 +4508,7 @@ function calculateItemsInView(ctx, params = {}) {
       scrollBottomBuffered = scrollBottom + scrollBufferBottom;
     };
     updateScrollRange();
-    if (!suppressInitialScrollSideEffects && !dataChanged && !forceFullItemPositions && scrollForNextCalculateItemsInView) {
+    if (enableScrollForNextCalculateItemsInView && !suppressInitialScrollSideEffects && !dataChanged && !forceFullItemPositions && scrollForNextCalculateItemsInView) {
       const { top, bottom } = scrollForNextCalculateItemsInView;
       if (top === null && bottom === null) {
         state.scrollForNextCalculateItemsInView = void 0;
@@ -4690,62 +4839,6 @@ function calculateItemsInView(ctx, params = {}) {
   });
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function doMaintainScrollAtEnd(ctx) {
-  const state = ctx.state;
-  const {
-    didContainersLayout,
-    pendingNativeMVCPAdjust,
-    refScroller,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
-  }
-  state.pendingMaintainScrollAtEnd = false;
-  if (shouldMaintainScrollAtEnd) {
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
-    }
-    if (!state.maintainingScrollAtEnd) {
-      state.maintainingScrollAtEnd = true;
-      requestAnimationFrame(() => {
-        if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
-          const scroller = refScroller.current;
-          if (state.props.horizontal && isHorizontalRTL(state)) {
-            const currentContentSize = getContentSize(ctx);
-            const logicalEndOffset = getLogicalHorizontalMaxOffset(state, currentContentSize);
-            const nativeOffset = toNativeHorizontalOffset(state, logicalEndOffset, currentContentSize);
-            scroller == null ? void 0 : scroller.scrollTo({
-              animated: maintainScrollAtEnd.animated,
-              x: nativeOffset,
-              y: 0
-            });
-          } else {
-            scroller == null ? void 0 : scroller.scrollToEnd({
-              animated: maintainScrollAtEnd.animated
-            });
-          }
-          setTimeout(
-            () => {
-              state.maintainingScrollAtEnd = false;
-            },
-            maintainScrollAtEnd.animated ? 500 : 0
-          );
-        } else {
-          state.maintainingScrollAtEnd = false;
-        }
-      });
-    }
-    return true;
-  }
-  return false;
-}
-
 // src/core/checkResetContainers.ts
 function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {}) {
   const state = ctx.state;
@@ -4926,84 +5019,6 @@ function handleLayout(ctx, layoutParam, setCanRender) {
   setCanRender(true);
 }
 
-// src/platform/flushSync.native.ts
-var flushSync = (fn) => {
-  fn();
-};
-
-// 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;
-  }
-  state.lastBatchingAction = Date.now();
-  const currentTime = Date.now();
-  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 didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
-  const scrollLength = state.scrollLength;
-  const lastCalculated = state.scrollLastCalculate;
-  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || 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;
-      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0 });
-      checkThresholds(ctx);
-    };
-    if (scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust) {
-      state.mvcpAnchorLock = void 0;
-      state.pendingNativeMVCPAdjust = void 0;
-      state.userScrollAnchorResetKeys = /* @__PURE__ */ new Set();
-      if (state.queuedMVCPRecalculate !== void 0) {
-        cancelAnimationFrame(state.queuedMVCPRecalculate);
-        state.queuedMVCPRecalculate = void 0;
-      }
-      flushSync(runCalculateItems);
-    } 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/onScroll.ts
 function trackInitialScrollNativeProgress(state, newScroll) {
   const initialNativeScrollWatchdog = initialScrollWatchdog.get(state);
@@ -6349,6 +6364,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     });
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
+    if (viewability) {
+      state.scrollForNextCalculateItemsInView = void 0;
+    }
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
   useInit(() => {
     if (!IsNewArchitecture) {