@legendapp/list 3.3.9 → 3.3.11

package/react-native.js

@@ -1014,6 +1014,7 @@ function supersedeInitialScroll(ctx) {
 function finishInitialScroll(ctx, options) {
   var _a3, _b, _c;
   const state = ctx.state;
+  const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
   if ((options == null ? void 0 : options.resolvedOffset) !== void 0) {
     syncInitialScrollOffset(state, options.resolvedOffset);
   } else if ((options == null ? void 0 : options.syncObservedOffset) && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
@@ -1023,9 +1024,13 @@ function finishInitialScroll(ctx, options) {
     }
   }
   const complete = () => {
-    var _a4, _b2, _c2, _d, _e;
-    const shouldReleaseDeferredPublicOnScroll = Platform.OS === "web" && ((_a4 = state.initialScrollSession) == null ? void 0 : _a4.kind) === "bootstrap";
-    const finalScrollOffset = (_d = (_c2 = (_b2 = options == null ? void 0 : options.resolvedOffset) != null ? _b2 : state.scrollPending) != null ? _c2 : state.scroll) != null ? _d : 0;
+    var _a4, _b2, _c2, _d, _e, _f;
+    if (freshDataTransitionEpoch !== state.freshDataTransitionEpoch) {
+      (_a4 = options == null ? void 0 : options.onFinished) == null ? void 0 : _a4.call(options);
+      return;
+    }
+    const shouldReleaseDeferredPublicOnScroll = Platform.OS === "web" && ((_b2 = state.initialScrollSession) == null ? void 0 : _b2.kind) === "bootstrap";
+    const finalScrollOffset = (_e = (_d = (_c2 = options == null ? void 0 : options.resolvedOffset) != null ? _c2 : state.scrollPending) != null ? _d : state.scroll) != null ? _e : 0;
     initialScrollWatchdog.clear(state);
     if ((options == null ? void 0 : options.preserveTarget) && state.initialScroll) {
       state.clearPreservedInitialScrollOnNextFinish = void 0;
@@ -1054,7 +1059,7 @@ function finishInitialScroll(ctx, options) {
     if (shouldReleaseDeferredPublicOnScroll) {
       releaseDeferredPublicOnScroll(ctx, finalScrollOffset);
     }
-    (_e = options == null ? void 0 : options.onFinished) == null ? void 0 : _e.call(options);
+    (_f = options == null ? void 0 : options.onFinished) == null ? void 0 : _f.call(options);
   };
   if (options == null ? void 0 : options.waitForCompletionFrame) {
     requestAnimationFrame(complete);
@@ -1338,246 +1343,21 @@ function clampScrollOffset(ctx, offset, scrollTarget) {
   return clampedOffset;
 }
 
-// src/core/finishScrollTo.ts
-function finishScrollTo(ctx) {
-  var _a3, _b;
-  const state = ctx.state;
-  if (state == null ? void 0 : state.scrollingTo) {
-    cancelScrollCompletionChecks(state);
-    const resolvePendingScroll = state.pendingScrollResolve;
-    state.pendingScrollResolve = void 0;
-    const scrollingTo = state.scrollingTo;
-    state.scrollHistory.length = 0;
-    state.scrollingTo = void 0;
-    state.scrollTargetPinnedRange = void 0;
-    if (state.pendingTotalSize !== void 0) {
-      addTotalSize(ctx, null, state.pendingTotalSize);
-    }
-    if (PlatformAdjustBreaksScroll) {
-      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
-    }
-    if (scrollingTo.isInitialScroll || state.initialScroll) {
-      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
-      finishInitialScroll(ctx, {
-        onFinished: () => {
-          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-        },
-        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
-        recalculateItems: true,
-        schedulePreservedTargetClear: shouldPreserveResizeTarget,
-        syncObservedOffset: isOffsetSession,
-        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
-      });
-      return;
-    }
-    recalculateSettledScroll(ctx);
-    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-  }
-}
-
-// src/core/checkFinishedScroll.ts
-var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
-var INITIAL_SCROLL_COMPLETION_TARGET_EPSILON = 1;
-var INITIAL_SCROLL_ZERO_TARGET_EPSILON = 1;
-var SILENT_INITIAL_SCROLL_RETRY_DELAY_MS = 16;
-var SILENT_INITIAL_SCROLL_TARGET_EPSILON = 1;
-function checkFinishedScroll(ctx, options) {
-  const scrollingTo = ctx.state.scrollingTo;
-  if (options == null ? void 0 : options.onlyIfAligned) {
-    if (!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) || scrollingTo.animated) {
-      return;
-    }
-    if (!getResolvedScrollCompletionState(ctx, scrollingTo).isAtResolvedTarget) {
-      return;
-    }
-  }
-  ctx.state.scheduledWork.frame(() => checkFinishedScrollFrame(ctx), "checkFinishedScrollFrame");
-}
-function hasScrollCompletionOwnership(state, options) {
-  const { clampedTargetOffset, scrollingTo } = options;
-  return !scrollingTo.isInitialScroll || state.hasScrolled || clampedTargetOffset <= INITIAL_SCROLL_COMPLETION_TARGET_EPSILON;
-}
-function isSilentInitialDispatch(state, scrollingTo) {
-  return !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled;
-}
-function getInitialScrollWatchdogTargetOffset(state) {
-  var _a3;
-  return (_a3 = initialScrollWatchdog.get(state)) == null ? void 0 : _a3.targetOffset;
-}
-function isNativeInitialNonZeroTarget(state) {
-  const targetOffset = getInitialScrollWatchdogTargetOffset(state);
-  return !state.didFinishInitialScroll && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
-}
-function shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) {
-  var _a3, _b;
-  if (!scrollingTo.isInitialScroll || scrollingTo.animated || !state.didContainersLayout) {
-    return false;
-  }
-  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap") {
-    return false;
-  }
-  const targetOffset = (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset;
-  if (initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled) {
-    return false;
-  }
-  if (initialScrollWatchdog.isAtZeroTargetOffset(targetOffset) || Math.abs(state.scroll - targetOffset) > 1 || Math.abs(state.scrollPending - targetOffset) > 1) {
-    return false;
-  }
-  return !!scrollingTo.waitForInitialScrollCompletionFrame || isNativeInitialNonZeroTarget(state);
-}
-function shouldFinishInitialZeroTargetScroll(ctx) {
-  var _a3;
-  const { state } = ctx;
-  return !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) && state.props.data.length > 0 && getContentSize(ctx) <= state.scrollLength && state.scrollPending <= INITIAL_SCROLL_ZERO_TARGET_EPSILON;
-}
-function isEndAlignedLastItemTarget(ctx, scrollingTo) {
-  return scrollingTo.index === ctx.state.props.data.length - 1 && scrollingTo.viewPosition === 1;
-}
-function getCurrentTargetOffset(ctx, scrollingTo) {
-  var _a3;
-  const index = scrollingTo.index;
-  const shouldRecomputeEndTarget = isEndAlignedLastItemTarget(ctx, scrollingTo);
-  const requestedTargetOffset = shouldRecomputeEndTarget && index !== void 0 ? calculateOffsetWithOffsetPosition(ctx, calculateOffsetForIndex(ctx, index), scrollingTo) : (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
-  return clampScrollOffset(ctx, requestedTargetOffset, scrollingTo);
-}
-function getResolvedScrollCompletionState(ctx, scrollingTo) {
-  const { state } = ctx;
-  const scroll = state.scrollPending;
-  const adjust = state.scrollAdjustHandler.getAdjust();
-  const clampedTargetOffset = getCurrentTargetOffset(ctx, scrollingTo);
-  const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
-  const diff1 = Math.abs(scroll - clampedTargetOffset);
-  const adjustedTargetOffset = clampedTargetOffset + adjust;
-  const diff2 = Math.abs(scroll - adjustedTargetOffset);
-  const canUseAdjustedCompletion = !scrollingTo.animated || Platform.OS === "ios";
-  return {
-    clampedTargetOffset,
-    isAtResolvedTarget: Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || canUseAdjustedCompletion && diff2 < 1)
-  };
-}
-function checkFinishedScrollFrame(ctx) {
-  const scrollingTo = ctx.state.scrollingTo;
-  if (!scrollingTo) {
-    return;
-  }
-  const { state } = ctx;
-  const completionState = getResolvedScrollCompletionState(ctx, scrollingTo);
-  if (completionState.isAtResolvedTarget && hasScrollCompletionOwnership(state, {
-    clampedTargetOffset: completionState.clampedTargetOffset,
-    scrollingTo
-  })) {
-    finishScrollTo(ctx);
-  }
-}
-function scrollToFallbackOffset(ctx, offset) {
-  var _a3;
-  (_a3 = ctx.state.refScroller.current) == null ? void 0 : _a3.scrollTo({
-    animated: false,
-    x: ctx.state.props.horizontal ? offset : 0,
-    y: ctx.state.props.horizontal ? 0 : offset
-  });
-}
-function checkFinishedScrollFallback(ctx) {
-  const state = ctx.state;
-  if (state.scheduledWork.has("checkFinishedScrollFallback")) {
-    return;
-  }
-  const scrollingTo = state.scrollingTo;
-  const shouldFinishInitialZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
-  const silentInitialDispatch = isSilentInitialDispatch(state, scrollingTo);
-  const canFinishInitialWithoutNativeProgress = scrollingTo !== void 0 ? shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) : false;
-  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && !shouldFinishInitialZeroTarget && !canFinishInitialWithoutNativeProgress || !state.didContainersLayout;
-  const initialDelay = shouldFinishInitialZeroTarget || canFinishInitialWithoutNativeProgress ? 0 : silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : slowTimeout ? 500 : 100;
-  let numChecks = 0;
-  const scheduleFallbackCheck = (delay) => {
-    state.scheduledWork.timeout(checkHasScrolled, delay, "checkFinishedScrollFallback");
-  };
-  const checkHasScrolled = () => {
-    var _a3, _b, _c, _d;
-    const isStillScrollingTo = state.scrollingTo;
-    if (isStillScrollingTo) {
-      numChecks++;
-      const isNativeInitialPending = isNativeInitialNonZeroTarget(state) && !state.hasScrolled;
-      const maxChecks = silentInitialDispatch ? 5 : isNativeInitialPending ? INITIAL_SCROLL_MAX_FALLBACK_CHECKS : 5;
-      const shouldFinishZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
-      const canFinishInitialScrollWithoutNativeProgress = shouldFinishInitialScrollWithoutNativeProgress(
-        state,
-        isStillScrollingTo
-      );
-      const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
-      const canFinishAfterSilentNativeDispatch = Platform.OS === "android" && silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
-      const shouldRetrySilentInitialNativeScroll = Platform.OS === "android" && canFinishAfterSilentNativeDispatch && !initialScrollCompletion.didRetrySilentInitialScroll(state);
-      const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
-      const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
-      const shouldRetryUnalignedEndScroll = Platform.OS === "ios" && !isStillScrollingTo.isInitialScroll && isEndAlignedLastItemTarget(ctx, isStillScrollingTo) && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
-      if (shouldRetrySilentInitialNativeScroll) {
-        const targetOffset = (_b = (_a3 = getInitialScrollWatchdogTargetOffset(state)) != null ? _a3 : isStillScrollingTo.targetOffset) != null ? _b : 0;
-        const jiggleOffset = targetOffset >= SILENT_INITIAL_SCROLL_TARGET_EPSILON ? targetOffset - SILENT_INITIAL_SCROLL_TARGET_EPSILON : targetOffset + SILENT_INITIAL_SCROLL_TARGET_EPSILON;
-        initialScrollCompletion.markSilentInitialScrollRetry(state);
-        scrollToFallbackOffset(ctx, jiggleOffset);
-        state.scheduledWork.frame(
-          () => scrollToFallbackOffset(ctx, targetOffset),
-          "checkFinishedScrollRetryFrame"
-        );
-        scheduleFallbackCheck(SILENT_INITIAL_SCROLL_RETRY_DELAY_MS);
-      } else if (shouldRetryUnalignedEndScroll) {
-        scrollToFallbackOffset(ctx, completionState.clampedTargetOffset);
-        scheduleFallbackCheck(100);
-      } else if (shouldFinishZeroTarget || shouldFinishAfterObservedScroll || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
-        finishScrollTo(ctx);
-      } else if ((isNativeInitialPending || shouldRetryUnalignedInitialScroll) && numChecks <= maxChecks) {
-        const targetOffset = (_d = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : isStillScrollingTo.targetOffset) != null ? _d : state.scrollPending;
-        scrollToFallbackOffset(ctx, targetOffset);
-        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
-      } else {
-        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
-      }
-    }
-  };
-  scheduleFallbackCheck(initialDelay);
-}
-
-// src/core/doScrollTo.native.ts
-function doScrollTo(ctx, params) {
-  const state = ctx.state;
-  const { animated, horizontal, isInitialScroll, offset } = params;
-  const isAnimated = !!animated;
-  const { refScroller } = state;
-  const scroller = refScroller.current;
-  if (!scroller) {
-    return;
-  }
-  const isHorizontal = !!horizontal;
-  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
-  const nativeOffset = toNativeHorizontalOffset(state, offset, contentSize);
-  scroller.scrollTo({
-    animated: isAnimated,
-    x: isHorizontal ? nativeOffset : 0,
-    y: isHorizontal ? 0 : offset
-  });
-  if (isInitialScroll) {
-    initialScrollCompletion.markInitialScrollNativeDispatch(state);
-  }
-  if (isAnimated && Math.abs(state.scroll - offset) <= 1) {
-    checkFinishedScroll(ctx);
-  }
-  if (!isAnimated) {
-    state.scroll = offset;
-    checkFinishedScrollFallback(ctx);
-  }
-}
-
 // src/core/scrollRequestTracker.ts
 function getScrollRequestTracker(ctx) {
   if (!ctx.scrollRequestTracker) {
     let currentToken = 0;
-    const start = (resolve) => {
+    let waitingToken;
+    const start = (resolve, isInternal = false) => {
       const state = ctx.state;
+      if (!isInternal && (state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd)) {
+        finishMaintainScrollAtEnd(ctx);
+      }
       state.scheduledWork.cancel("imperativeScrollReady");
       const token = ++currentToken;
       settlePendingImperativeScroll(state);
       state.pendingScrollResolve = resolve;
+      waitingToken = token;
       return token;
     };
     const runNow = (token, resolve, run) => {
@@ -1585,6 +1365,7 @@ function getScrollRequestTracker(ctx) {
       if (token !== currentToken) {
         return;
       }
+      waitingToken = void 0;
       const didStartScroll = run();
       if (!didStartScroll || !state.scrollingTo) {
         if (state.pendingScrollResolve === resolve) {
@@ -1595,6 +1376,7 @@ function getScrollRequestTracker(ctx) {
     };
     ctx.scrollRequestTracker = {
       isCurrent: (token) => token === currentToken,
+      isWaitingToRun: () => waitingToken === currentToken && !!ctx.state.pendingScrollResolve,
       runNow,
       runNowIfIdle: (run) => {
         const state = ctx.state;
@@ -1602,7 +1384,7 @@ function getScrollRequestTracker(ctx) {
           return Promise.resolve();
         }
         return new Promise((resolve) => {
-          const token = start(resolve);
+          const token = start(resolve, true);
           runNow(token, resolve, run);
         });
       },
@@ -1666,96 +1448,15 @@ function requestAdjust(ctx, positionDiff, source) {
   }
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function finishMaintainScrollAtEnd(ctx) {
-  var _a3;
-  const { state } = ctx;
-  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
-  const nextPadding = getAlignItemsAtEndPadding(ctx);
-  state.maintainingScrollAtEnd = void 0;
-  state.pendingMaintainScrollAtEnd = false;
-  if (currentPadding !== nextPadding) {
-    set$(ctx, "alignItemsAtEndPadding", nextPadding);
-    state.scrollForNextCalculateItemsInView = void 0;
-    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
-    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
-    requestAdjust(ctx, nextScroll - state.scroll);
-  }
-}
-function doMaintainScrollAtEnd(ctx) {
-  const state = ctx.state;
-  const {
-    didContainersLayout,
-    didFinishInitialScroll,
-    pendingNativeMVCPAdjust,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
-  const shouldMaintainScrollAtEnd = !!((isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain) && maintainScrollAtEnd && didFinishInitialScroll);
-  if (shouldMaintainScrollAtEnd && !didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = true;
-    return false;
-  }
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
-  }
-  if (shouldMaintainScrollAtEnd && didContainersLayout) {
-    state.pendingMaintainScrollAtEnd = false;
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
-    }
-    if (!state.maintainingScrollAtEnd) {
-      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
-      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
-      const scrollAtRequest = state.scroll;
-      state.maintainingScrollAtEnd = pendingState;
-      requestAnimationFrame(() => {
-        if (state.maintainingScrollAtEnd !== pendingState) {
-          return;
-        }
-        const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-        const didScrollSinceRequest = state.scroll !== scrollAtRequest;
-        if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
-          state.maintainingScrollAtEnd = activeState;
-          const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
-            () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
-          );
-          void scrollPromise.then(() => {
-            if (state.maintainingScrollAtEnd !== activeState) {
-              return;
-            }
-            if (state.pendingMaintainScrollAtEnd) {
-              state.maintainingScrollAtEnd = void 0;
-              doMaintainScrollAtEnd(ctx);
-            } else {
-              finishMaintainScrollAtEnd(ctx);
-            }
-          });
-        } else if (state.maintainingScrollAtEnd === pendingState) {
-          finishMaintainScrollAtEnd(ctx);
-        }
-      });
-    } else {
-      state.pendingMaintainScrollAtEnd = true;
-    }
-    return true;
-  }
-  finishMaintainScrollAtEnd(ctx);
-  return false;
-}
-
-// src/core/mvcp.ts
-var MVCP_POSITION_EPSILON = 0.1;
-var MVCP_ANCHOR_LOCK_TTL_MS = 300;
-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;
+// 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) {
@@ -2045,144 +1746,494 @@ function prepareMVCP(ctx, dataChanged, adjustmentSource) {
     };
   }
 }
-
-// src/platform/flushSync.native.ts
-var flushSync = (fn) => {
-  fn();
-};
-
-// src/utils/getScrollVelocity.ts
-var MAX_SCROLL_VELOCITY_WINDOW_MS = 1e3;
-var SCROLL_VELOCITY_HALF_LIFE_MS = 200;
-var getScrollVelocity = (state) => {
-  const { scrollHistory } = state;
-  const newestIndex = scrollHistory.length - 1;
-  if (newestIndex < 1) {
-    return 0;
-  }
-  const newest = scrollHistory[newestIndex];
-  if (Date.now() - newest.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
-    return 0;
+
+// src/platform/flushSync.native.ts
+var flushSync = (fn) => {
+  fn();
+};
+
+// src/utils/getScrollVelocity.ts
+var MAX_SCROLL_VELOCITY_WINDOW_MS = 1e3;
+var SCROLL_VELOCITY_HALF_LIFE_MS = 200;
+var getScrollVelocity = (state) => {
+  const { scrollHistory } = state;
+  const newestIndex = scrollHistory.length - 1;
+  if (newestIndex < 1) {
+    return 0;
+  }
+  const newest = scrollHistory[newestIndex];
+  if (Date.now() - newest.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
+    return 0;
+  }
+  let direction = 0;
+  let weightedVelocity = 0;
+  let totalWeight = 0;
+  for (let i = newestIndex; i > 0; i--) {
+    const current = scrollHistory[i];
+    const previous = scrollHistory[i - 1];
+    const scrollDiff = current.scroll - previous.scroll;
+    const timeDiff = current.time - previous.time;
+    const deltaSign = Math.sign(scrollDiff);
+    if (deltaSign !== 0) {
+      if (direction === 0) {
+        direction = deltaSign;
+      } else if (deltaSign !== direction) {
+        break;
+      }
+    }
+    if (newest.time - previous.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
+      break;
+    }
+    if (scrollDiff === 0 || timeDiff <= 0) {
+      continue;
+    }
+    const age = newest.time - current.time;
+    const weight = Math.exp(-age / SCROLL_VELOCITY_HALF_LIFE_MS);
+    weightedVelocity += scrollDiff / timeDiff * weight;
+    totalWeight += weight;
+  }
+  return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
+};
+
+// src/utils/isInMVCPActiveMode.native.ts
+function isInMVCPActiveMode(state) {
+  return state.dataChangeNeedsScrollUpdate;
+}
+
+// src/core/updateScroll.ts
+function updateScroll(ctx, newScroll, forceUpdate, options) {
+  var _a3;
+  const state = ctx.state;
+  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
+  const prevScroll = state.scroll;
+  if ((options == null ? void 0 : options.markHasScrolled) !== false) {
+    state.hasScrolled = true;
+  }
+  const currentTime = Date.now();
+  state.lastBatchingAction = currentTime;
+  const adjust = scrollAdjustHandler.getAdjust();
+  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
+  if (adjustChanged) {
+    scrollHistory.length = 0;
+  }
+  state.lastScrollAdjustForHistory = adjust;
+  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
+    if (!adjustChanged) {
+      scrollHistory.push({ scroll: newScroll, time: currentTime });
+    }
+  }
+  if (scrollHistory.length > 5) {
+    scrollHistory.shift();
+  }
+  if (ignoreScrollFromMVCP && !scrollingTo) {
+    const { lt, gt } = ignoreScrollFromMVCP;
+    if (lt && newScroll < lt || gt && newScroll > gt) {
+      state.ignoreScrollFromMVCPIgnored = true;
+      return;
+    }
+  }
+  state.scrollPrev = prevScroll;
+  state.scrollPrevTime = state.scrollTime;
+  state.scroll = newScroll;
+  state.scrollTime = currentTime;
+  const scrollDelta = Math.abs(newScroll - prevScroll);
+  const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
+  const didCancelMaintainScrollAtEnd = isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
+  if (didCancelMaintainScrollAtEnd) {
+    finishMaintainScrollAtEnd(ctx);
+  }
+  const allowedEdge = isUserScrollEvent ? beginReachedEdgeUserScroll(ctx, newScroll - prevScroll) : void 0;
+  const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
+  const scrollLength = state.scrollLength;
+  const isLargeUserScrollJump = scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust;
+  const scrollVelocity = getScrollVelocity(state);
+  updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
+  const lastCalculated = state.scrollLastCalculate;
+  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
+  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || didCancelMaintainScrollAtEnd || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
+  if (shouldUpdate) {
+    state.scrollLastCalculate = state.scroll;
+    state.ignoreScrollFromMVCPIgnored = false;
+    state.lastScrollDelta = scrollDelta;
+    const runCalculateItems = () => {
+      var _a4;
+      const calculateItemsParams = {
+        doMVCP: scrollingTo !== void 0,
+        scrollVelocity
+      };
+      if (isLargeUserScrollJump) {
+        calculateItemsParams.drawDistanceMode = "visible-first";
+      }
+      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, calculateItemsParams);
+      checkThresholds(ctx, allowedEdge);
+    };
+    if (isLargeUserScrollJump) {
+      state.mvcpAnchorLock = void 0;
+      state.pendingNativeMVCPAdjust = void 0;
+      state.userScrollAnchorReset = { keys: /* @__PURE__ */ new Set() };
+      state.scheduledWork.cancel("mvcpRecalculate");
+      flushSync(runCalculateItems);
+      scheduleFullDrawDistancePrewarm(ctx);
+    } else {
+      runCalculateItems();
+    }
+    const shouldMaintainScrollAtEndAfterPendingSettle = !!state.pendingMaintainScrollAtEnd || !!((_a3 = state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onDataChange);
+    if (didResolvePendingNativeMVCPAdjust && shouldMaintainScrollAtEndAfterPendingSettle) {
+      state.pendingMaintainScrollAtEnd = false;
+      doMaintainScrollAtEnd(ctx);
+    }
+    state.dataChangeNeedsScrollUpdate = false;
+    state.lastScrollDelta = 0;
+  }
+}
+
+// src/core/doMaintainScrollAtEnd.ts
+function interruptMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const maintaining = state.maintainingScrollAtEnd;
+  const cancelActiveScroll = !!(maintaining === "animated" || maintaining === "instant" || maintaining && ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isScrollToEnd));
+  if (cancelActiveScroll) {
+    cancelImperativeScroll(state);
+  }
+  if (maintaining || state.pendingMaintainScrollAtEnd) {
+    finishMaintainScrollAtEnd(ctx);
+  }
+  return cancelActiveScroll;
+}
+function finishMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
+  const nextPadding = getAlignItemsAtEndPadding(ctx);
+  state.maintainingScrollAtEnd = void 0;
+  state.pendingMaintainScrollAtEnd = false;
+  if (currentPadding !== nextPadding) {
+    set$(ctx, "alignItemsAtEndPadding", nextPadding);
+    state.scrollForNextCalculateItemsInView = void 0;
+    (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { forceFullItemPositions: true });
+    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
+    requestAdjust(ctx, nextScroll - state.scroll);
+  }
+}
+function doMaintainScrollAtEnd(ctx) {
+  var _a3, _b, _c, _d, _e;
+  const state = ctx.state;
+  const {
+    didContainersLayout,
+    didFinishInitialScroll,
+    pendingNativeMVCPAdjust,
+    props: { maintainScrollAtEnd }
+  } = state;
+  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+  const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
+  const shouldMaintainScrollAtEnd = !!(!((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) && (!state.scrollingTo || state.scrollingTo.isScrollToEnd) && (isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain || ((_b = state.scrollingTo) == null ? void 0 : _b.isScrollToEnd)) && maintainScrollAtEnd && didFinishInitialScroll);
+  if (shouldMaintainScrollAtEnd && !state.scrollingTo) {
+    const scroller = state.refScroller.current;
+    const nativeMax = (_c = scroller == null ? void 0 : scroller.getMaxScrollOffset) == null ? void 0 : _c.call(scroller);
+    const observed = (_d = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _d.call(scroller);
+    if (nativeMax !== void 0 && observed !== void 0 && nativeMax < state.scroll - 1 && Math.abs(observed - nativeMax) <= 1) {
+      state.pendingMaintainScrollAtEnd = true;
+      state.scrollPending = observed;
+      updateScroll(ctx, observed, true, { markHasScrolled: false });
+    }
+  }
+  if (shouldMaintainScrollAtEnd && !didContainersLayout) {
+    state.pendingMaintainScrollAtEnd = true;
+    return false;
+  }
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    return false;
+  }
+  if (shouldMaintainScrollAtEnd && (state.scrollingTo || state.pendingScrollResolve)) {
+    state.pendingMaintainScrollAtEnd = true;
+    (_e = state.maintainingScrollAtEnd) != null ? _e : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+    return false;
+  }
+  if (shouldMaintainScrollAtEnd && didContainersLayout) {
+    state.pendingMaintainScrollAtEnd = false;
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
+      state.scroll = 0;
+    }
+    if (!state.maintainingScrollAtEnd) {
+      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+      const scrollAtRequest = state.scroll;
+      state.maintainingScrollAtEnd = pendingState;
+      requestAnimationFrame(() => {
+        if (state.maintainingScrollAtEnd !== pendingState) {
+          return;
+        }
+        const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+        const didScrollSinceRequest = state.scroll !== scrollAtRequest;
+        if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
+          if (state.scrollingTo || state.pendingScrollResolve) {
+            state.pendingMaintainScrollAtEnd = true;
+            return;
+          }
+          state.maintainingScrollAtEnd = activeState;
+          const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
+            () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
+          );
+          void scrollPromise.then(() => {
+            if (state.maintainingScrollAtEnd !== activeState) {
+              return;
+            }
+            if (state.pendingMaintainScrollAtEnd) {
+              state.maintainingScrollAtEnd = void 0;
+              doMaintainScrollAtEnd(ctx);
+            } else {
+              finishMaintainScrollAtEnd(ctx);
+            }
+          });
+        } else if (state.maintainingScrollAtEnd === pendingState) {
+          finishMaintainScrollAtEnd(ctx);
+        }
+      });
+    } else {
+      state.pendingMaintainScrollAtEnd = true;
+    }
+    return true;
+  }
+  finishMaintainScrollAtEnd(ctx);
+  return false;
+}
+
+// src/core/finishScrollTo.ts
+function finishScrollTo(ctx) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  if (state == null ? void 0 : state.scrollingTo) {
+    cancelScrollCompletionChecks(state);
+    const resolvePendingScroll = ((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) ? void 0 : state.pendingScrollResolve;
+    if (resolvePendingScroll) {
+      state.pendingScrollResolve = void 0;
+    }
+    const scrollingTo = state.scrollingTo;
+    state.scrollHistory.length = 0;
+    state.scrollingTo = void 0;
+    state.scrollTargetPinnedRange = void 0;
+    if (state.pendingTotalSize !== void 0) {
+      addTotalSize(ctx, null, state.pendingTotalSize);
+    }
+    if (PlatformAdjustBreaksScroll) {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    if (scrollingTo.isInitialScroll || state.initialScroll) {
+      const isOffsetSession = ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) === "offset";
+      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_c = state.initialScroll) == null ? void 0 : _c.viewPosition) === 1;
+      finishInitialScroll(ctx, {
+        onFinished: () => {
+          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+        },
+        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
+        recalculateItems: true,
+        schedulePreservedTargetClear: shouldPreserveResizeTarget,
+        syncObservedOffset: isOffsetSession,
+        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
+      });
+      return;
+    }
+    recalculateSettledScroll(ctx);
+    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+    if (state.pendingMaintainScrollAtEnd) {
+      state.maintainingScrollAtEnd = void 0;
+      doMaintainScrollAtEnd(ctx);
+    }
+  }
+}
+
+// src/core/checkFinishedScroll.ts
+var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
+var INITIAL_SCROLL_COMPLETION_TARGET_EPSILON = 1;
+var INITIAL_SCROLL_ZERO_TARGET_EPSILON = 1;
+var SILENT_INITIAL_SCROLL_RETRY_DELAY_MS = 16;
+var SILENT_INITIAL_SCROLL_TARGET_EPSILON = 1;
+function checkFinishedScroll(ctx, options) {
+  const scrollingTo = ctx.state.scrollingTo;
+  if (options == null ? void 0 : options.onlyIfAligned) {
+    if (!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) || scrollingTo.animated) {
+      return;
+    }
+    if (!getResolvedScrollCompletionState(ctx, scrollingTo).isAtResolvedTarget) {
+      return;
+    }
+  }
+  ctx.state.scheduledWork.frame(() => checkFinishedScrollFrame(ctx), "checkFinishedScrollFrame");
+}
+function hasScrollCompletionOwnership(state, options) {
+  const { clampedTargetOffset, scrollingTo } = options;
+  return !scrollingTo.isInitialScroll || state.hasScrolled || clampedTargetOffset <= INITIAL_SCROLL_COMPLETION_TARGET_EPSILON;
+}
+function isSilentInitialDispatch(state, scrollingTo) {
+  return !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled;
+}
+function getInitialScrollWatchdogTargetOffset(state) {
+  var _a3;
+  return (_a3 = initialScrollWatchdog.get(state)) == null ? void 0 : _a3.targetOffset;
+}
+function isNativeInitialNonZeroTarget(state) {
+  const targetOffset = getInitialScrollWatchdogTargetOffset(state);
+  return !state.didFinishInitialScroll && initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset);
+}
+function shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) {
+  var _a3, _b;
+  if (!scrollingTo.isInitialScroll || scrollingTo.animated || !state.didContainersLayout) {
+    return false;
+  }
+  if (((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap") {
+    return false;
+  }
+  const targetOffset = (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset;
+  if (initialScrollWatchdog.hasNonZeroTargetOffset(targetOffset) && initialScrollCompletion.didDispatchNativeScroll(state) && !state.hasScrolled) {
+    return false;
+  }
+  if (initialScrollWatchdog.isAtZeroTargetOffset(targetOffset) || Math.abs(state.scroll - targetOffset) > 1 || Math.abs(state.scrollPending - targetOffset) > 1) {
+    return false;
+  }
+  return !!scrollingTo.waitForInitialScrollCompletionFrame || isNativeInitialNonZeroTarget(state);
+}
+function shouldFinishInitialZeroTargetScroll(ctx) {
+  var _a3;
+  const { state } = ctx;
+  return !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) && state.props.data.length > 0 && getContentSize(ctx) <= state.scrollLength && state.scrollPending <= INITIAL_SCROLL_ZERO_TARGET_EPSILON;
+}
+function isEndAlignedLastItemTarget(ctx, scrollingTo) {
+  return scrollingTo.index === ctx.state.props.data.length - 1 && scrollingTo.viewPosition === 1;
+}
+function getCurrentTargetOffset(ctx, scrollingTo) {
+  var _a3;
+  const index = scrollingTo.index;
+  const shouldRecomputeEndTarget = isEndAlignedLastItemTarget(ctx, scrollingTo);
+  const requestedTargetOffset = shouldRecomputeEndTarget && index !== void 0 ? calculateOffsetWithOffsetPosition(ctx, calculateOffsetForIndex(ctx, index), scrollingTo) : (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
+  return clampScrollOffset(ctx, requestedTargetOffset, scrollingTo);
+}
+function getResolvedScrollCompletionState(ctx, scrollingTo) {
+  const { state } = ctx;
+  const scroll = state.scrollPending;
+  const adjust = state.scrollAdjustHandler.getAdjust();
+  const clampedTargetOffset = getCurrentTargetOffset(ctx, scrollingTo);
+  const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
+  const diff1 = Math.abs(scroll - clampedTargetOffset);
+  const adjustedTargetOffset = clampedTargetOffset + adjust;
+  const diff2 = Math.abs(scroll - adjustedTargetOffset);
+  const canUseAdjustedCompletion = !scrollingTo.animated || Platform.OS === "ios";
+  return {
+    clampedTargetOffset,
+    isAtResolvedTarget: Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || canUseAdjustedCompletion && diff2 < 1)
+  };
+}
+function checkFinishedScrollFrame(ctx) {
+  const scrollingTo = ctx.state.scrollingTo;
+  if (!scrollingTo) {
+    return;
   }
-  let direction = 0;
-  let weightedVelocity = 0;
-  let totalWeight = 0;
-  for (let i = newestIndex; i > 0; i--) {
-    const current = scrollHistory[i];
-    const previous = scrollHistory[i - 1];
-    const scrollDiff = current.scroll - previous.scroll;
-    const timeDiff = current.time - previous.time;
-    const deltaSign = Math.sign(scrollDiff);
-    if (deltaSign !== 0) {
-      if (direction === 0) {
-        direction = deltaSign;
-      } else if (deltaSign !== direction) {
-        break;
-      }
-    }
-    if (newest.time - previous.time > MAX_SCROLL_VELOCITY_WINDOW_MS) {
-      break;
-    }
-    if (scrollDiff === 0 || timeDiff <= 0) {
-      continue;
-    }
-    const age = newest.time - current.time;
-    const weight = Math.exp(-age / SCROLL_VELOCITY_HALF_LIFE_MS);
-    weightedVelocity += scrollDiff / timeDiff * weight;
-    totalWeight += weight;
+  const { state } = ctx;
+  const completionState = getResolvedScrollCompletionState(ctx, scrollingTo);
+  if (completionState.isAtResolvedTarget && hasScrollCompletionOwnership(state, {
+    clampedTargetOffset: completionState.clampedTargetOffset,
+    scrollingTo
+  })) {
+    finishScrollTo(ctx);
   }
-  return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
-};
-
-// src/utils/isInMVCPActiveMode.native.ts
-function isInMVCPActiveMode(state) {
-  return state.dataChangeNeedsScrollUpdate;
 }
-
-// src/core/updateScroll.ts
-function updateScroll(ctx, newScroll, forceUpdate, options) {
+function scrollToFallbackOffset(ctx, offset) {
   var _a3;
+  (_a3 = ctx.state.refScroller.current) == null ? void 0 : _a3.scrollTo({
+    animated: false,
+    x: ctx.state.props.horizontal ? offset : 0,
+    y: ctx.state.props.horizontal ? 0 : offset
+  });
+}
+function checkFinishedScrollFallback(ctx) {
   const state = ctx.state;
-  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
-  const prevScroll = state.scroll;
-  if ((options == null ? void 0 : options.markHasScrolled) !== false) {
-    state.hasScrolled = true;
-  }
-  const currentTime = Date.now();
-  state.lastBatchingAction = currentTime;
-  const adjust = scrollAdjustHandler.getAdjust();
-  const adjustChanged = lastScrollAdjustForHistory !== void 0 && Math.abs(adjust - lastScrollAdjustForHistory) > 0.1;
-  if (adjustChanged) {
-    scrollHistory.length = 0;
+  if (state.scheduledWork.has("checkFinishedScrollFallback")) {
+    return;
   }
-  state.lastScrollAdjustForHistory = adjust;
-  if (scrollingTo === void 0 && !(scrollHistory.length === 0 && newScroll === state.scroll)) {
-    if (!adjustChanged) {
-      scrollHistory.push({ scroll: newScroll, time: currentTime });
+  const scrollingTo = state.scrollingTo;
+  const shouldFinishInitialZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+  const silentInitialDispatch = isSilentInitialDispatch(state, scrollingTo);
+  const canFinishInitialWithoutNativeProgress = scrollingTo !== void 0 ? shouldFinishInitialScrollWithoutNativeProgress(state, scrollingTo) : false;
+  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && !shouldFinishInitialZeroTarget && !canFinishInitialWithoutNativeProgress || !state.didContainersLayout;
+  const initialDelay = shouldFinishInitialZeroTarget || canFinishInitialWithoutNativeProgress ? 0 : silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : slowTimeout ? 500 : 100;
+  let numChecks = 0;
+  const scheduleFallbackCheck = (delay) => {
+    state.scheduledWork.timeout(checkHasScrolled, delay, "checkFinishedScrollFallback");
+  };
+  const checkHasScrolled = () => {
+    var _a3, _b, _c, _d;
+    const isStillScrollingTo = state.scrollingTo;
+    if (isStillScrollingTo) {
+      numChecks++;
+      const isNativeInitialPending = isNativeInitialNonZeroTarget(state) && !state.hasScrolled;
+      const maxChecks = silentInitialDispatch ? 5 : isNativeInitialPending ? INITIAL_SCROLL_MAX_FALLBACK_CHECKS : 5;
+      const shouldFinishZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+      const canFinishInitialScrollWithoutNativeProgress = shouldFinishInitialScrollWithoutNativeProgress(
+        state,
+        isStillScrollingTo
+      );
+      const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
+      const canFinishAfterSilentNativeDispatch = Platform.OS === "android" && silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
+      const shouldRetrySilentInitialNativeScroll = Platform.OS === "android" && canFinishAfterSilentNativeDispatch && !initialScrollCompletion.didRetrySilentInitialScroll(state);
+      const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
+      const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
+      const shouldRetryUnalignedEndScroll = Platform.OS !== "web" && !isStillScrollingTo.isInitialScroll && isEndAlignedLastItemTarget(ctx, isStillScrollingTo) && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
+      if (shouldRetrySilentInitialNativeScroll) {
+        const targetOffset = (_b = (_a3 = getInitialScrollWatchdogTargetOffset(state)) != null ? _a3 : isStillScrollingTo.targetOffset) != null ? _b : 0;
+        const jiggleOffset = targetOffset >= SILENT_INITIAL_SCROLL_TARGET_EPSILON ? targetOffset - SILENT_INITIAL_SCROLL_TARGET_EPSILON : targetOffset + SILENT_INITIAL_SCROLL_TARGET_EPSILON;
+        initialScrollCompletion.markSilentInitialScrollRetry(state);
+        scrollToFallbackOffset(ctx, jiggleOffset);
+        state.scheduledWork.frame(
+          () => scrollToFallbackOffset(ctx, targetOffset),
+          "checkFinishedScrollRetryFrame"
+        );
+        scheduleFallbackCheck(SILENT_INITIAL_SCROLL_RETRY_DELAY_MS);
+      } else if (shouldRetryUnalignedEndScroll) {
+        scrollToFallbackOffset(ctx, completionState.clampedTargetOffset);
+        scheduleFallbackCheck(100);
+      } else if (shouldFinishZeroTarget || shouldFinishAfterObservedScroll || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
+        finishScrollTo(ctx);
+      } else if ((isNativeInitialPending || shouldRetryUnalignedInitialScroll) && numChecks <= maxChecks) {
+        const targetOffset = (_d = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : isStillScrollingTo.targetOffset) != null ? _d : state.scrollPending;
+        scrollToFallbackOffset(ctx, targetOffset);
+        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+      } else {
+        scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+      }
     }
+  };
+  scheduleFallbackCheck(initialDelay);
+}
+
+// src/core/doScrollTo.native.ts
+function doScrollTo(ctx, params) {
+  const state = ctx.state;
+  const { animated, horizontal, isInitialScroll, offset } = params;
+  const isAnimated = !!animated;
+  const { refScroller } = state;
+  const scroller = refScroller.current;
+  if (!scroller) {
+    return;
   }
-  if (scrollHistory.length > 5) {
-    scrollHistory.shift();
-  }
-  if (ignoreScrollFromMVCP && !scrollingTo) {
-    const { lt, gt } = ignoreScrollFromMVCP;
-    if (lt && newScroll < lt || gt && newScroll > gt) {
-      state.ignoreScrollFromMVCPIgnored = true;
-      return;
-    }
+  const isHorizontal = !!horizontal;
+  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
+  const nativeOffset = toNativeHorizontalOffset(state, offset, contentSize);
+  scroller.scrollTo({
+    animated: isAnimated,
+    x: isHorizontal ? nativeOffset : 0,
+    y: isHorizontal ? 0 : offset
+  });
+  if (isInitialScroll) {
+    initialScrollCompletion.markInitialScrollNativeDispatch(state);
   }
-  state.scrollPrev = prevScroll;
-  state.scrollPrevTime = state.scrollTime;
-  state.scroll = newScroll;
-  state.scrollTime = currentTime;
-  const scrollDelta = Math.abs(newScroll - prevScroll);
-  const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
-  const didCancelMaintainScrollAtEnd = isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
-  if (didCancelMaintainScrollAtEnd) {
-    finishMaintainScrollAtEnd(ctx);
+  if (isAnimated && Math.abs(state.scroll - offset) <= 1) {
+    checkFinishedScroll(ctx);
   }
-  const allowedEdge = isUserScrollEvent ? beginReachedEdgeUserScroll(ctx, newScroll - prevScroll) : void 0;
-  const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
-  const scrollLength = state.scrollLength;
-  const isLargeUserScrollJump = scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust;
-  const scrollVelocity = getScrollVelocity(state);
-  updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
-  const lastCalculated = state.scrollLastCalculate;
-  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || didCancelMaintainScrollAtEnd || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
-  if (shouldUpdate) {
-    state.scrollLastCalculate = state.scroll;
-    state.ignoreScrollFromMVCPIgnored = false;
-    state.lastScrollDelta = scrollDelta;
-    const runCalculateItems = () => {
-      var _a4;
-      const calculateItemsParams = {
-        doMVCP: scrollingTo !== void 0,
-        scrollVelocity
-      };
-      if (isLargeUserScrollJump) {
-        calculateItemsParams.drawDistanceMode = "visible-first";
-      }
-      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, calculateItemsParams);
-      checkThresholds(ctx, allowedEdge);
-    };
-    if (isLargeUserScrollJump) {
-      state.mvcpAnchorLock = void 0;
-      state.pendingNativeMVCPAdjust = void 0;
-      state.userScrollAnchorReset = { keys: /* @__PURE__ */ new Set() };
-      state.scheduledWork.cancel("mvcpRecalculate");
-      flushSync(runCalculateItems);
-      scheduleFullDrawDistancePrewarm(ctx);
-    } else {
-      runCalculateItems();
-    }
-    const shouldMaintainScrollAtEndAfterPendingSettle = !!state.pendingMaintainScrollAtEnd || !!((_a3 = state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onDataChange);
-    if (didResolvePendingNativeMVCPAdjust && shouldMaintainScrollAtEndAfterPendingSettle) {
-      state.pendingMaintainScrollAtEnd = false;
-      doMaintainScrollAtEnd(ctx);
-    }
-    state.dataChangeNeedsScrollUpdate = false;
-    state.lastScrollDelta = 0;
+  if (!isAnimated) {
+    state.scroll = offset;
+    checkFinishedScrollFallback(ctx);
   }
 }
 
@@ -3191,6 +3242,11 @@ function handleInitialScrollDataChange(ctx, options) {
   const state = ctx.state;
   const previousInitialScrollDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
   const shouldUseLatestInitialScroll = dataLength > 0 && (!state.hasHadNonEmptyData || didStartFreshData);
+  if (didStartFreshData) {
+    cancelImperativeScroll(state);
+    state.maintainingScrollAtEnd = void 0;
+    state.pendingMaintainScrollAtEnd = false;
+  }
   if (dataLength > 0) {
     state.hasHadNonEmptyData = true;
   }
@@ -4735,6 +4791,7 @@ function maybeUpdateAnchoredEndSpace(ctx) {
   const nextAnchorIndex = anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex;
   let nextAnchorKey;
   let isReady = true;
+  let canUpdateSize = true;
   let nextSize = 0;
   if (anchoredEndSpace) {
     const { anchorIndex, anchorMaxSize, anchorOffset = 0 } = anchoredEndSpace;
@@ -4756,25 +4813,30 @@ function maybeUpdateAnchoredEndSpace(ctx) {
       contentBelowAnchor = Math.max(0, contentBelowAnchor - ctx.scrollAxisGap);
       contentBelowAnchor += (ctx.values.get("footerSize") || 0) + getStylePaddingEnd(state.props);
       isReady = !hasUnknownTailSize;
-      nextSize = hasUnknownTailSize ? previousSize || 0 : Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      const knownSizeBound = Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      nextSize = hasUnknownTailSize ? Math.min(previousSize || 0, knownSizeBound) : knownSizeBound;
     } else if (anchorIndex >= 0) {
       isReady = false;
+      canUpdateSize = false;
     }
   }
   const didSizeChange = previousSize !== nextSize && (previousSize !== void 0 || anchoredEndSpace !== void 0);
   const didEffectiveSizeChange = (previousSize || 0) !== nextSize;
+  const canApplySizeChange = canUpdateSize && (isReady || previousSize !== void 0);
   const didReadyAnchorChange = previousReadyAnchorIndex !== nextAnchorIndex || previousReadyAnchorKey !== nextAnchorKey;
-  if (isReady && (didSizeChange || didReadyAnchorChange)) {
+  const didBecomeReady = isReady && state.anchoredEndSpacePendingReady;
+  state.anchoredEndSpacePendingReady = !isReady;
+  if (canApplySizeChange && didSizeChange) {
+    set$(ctx, "anchoredEndSpaceSize", nextSize);
+    (_a3 = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onSizeChanged) == null ? void 0 : _a3.call(anchoredEndSpace, nextSize);
+  }
+  if (canApplySizeChange && didEffectiveSizeChange) {
+    updateContentMetricsState(ctx);
+    updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
+  }
+  if (isReady && (didSizeChange || didReadyAnchorChange || didBecomeReady)) {
     state.anchoredEndSpaceReadyAnchorIndex = nextAnchorIndex;
     state.anchoredEndSpaceReadyAnchorKey = nextAnchorKey;
-    if (didSizeChange) {
-      set$(ctx, "anchoredEndSpaceSize", nextSize);
-      (_a3 = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onSizeChanged) == null ? void 0 : _a3.call(anchoredEndSpace, nextSize);
-    }
-    if (didEffectiveSizeChange) {
-      updateContentMetricsState(ctx);
-      updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
-    }
     (_b = anchoredEndSpace == null ? void 0 : anchoredEndSpace.onReady) == null ? void 0 : _b.call(anchoredEndSpace, { anchorIndex: nextAnchorIndex, anchorKey: nextAnchorKey, size: nextSize });
   }
   return nextSize;
@@ -6678,6 +6740,9 @@ function scrollToEnd(ctx, options) {
     viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
     viewPosition: 1
   });
+  if (state.scrollingTo) {
+    state.scrollingTo.isScrollToEnd = true;
+  }
   return true;
 }
 
@@ -7411,6 +7476,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         endReachedSnapshot: void 0,
         firstFullyOnScreenIndex: -1,
         freshDataTransitionEpoch: 0,
+        handledDataChangeEpoch: 0,
+        handledFreshDataTransitionEpoch: 0,
         hasHadNonEmptyData: dataProp.length > 0,
         idCache: [],
         idsInView: [],
@@ -7495,6 +7562,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   if (shouldResetFreshDataLayout) {
     state.freshDataTransitionEpoch += 1;
   }
+  const dataChangeEpoch = state.dataChangeEpoch;
+  const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
   const throttledOnScroll = useThrottledOnScroll(onScrollProp != null ? onScrollProp : noopOnScroll, scrollEventThrottle != null ? scrollEventThrottle : 0);
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? throttledOnScroll : onScrollProp;
   const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_q = state.props.anchoredEndSpace) == null ? void 0 : _q.anchorIndex) !== (anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex);
@@ -7622,7 +7691,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     useDevChecks(props);
   }
   React2.useLayoutEffect(() => {
-    if (shouldResetFreshDataLayout) {
+    const didDataChange = state.handledDataChangeEpoch !== dataChangeEpoch;
+    const didStartFreshData = state.handledFreshDataTransitionEpoch !== freshDataTransitionEpoch;
+    state.handledDataChangeEpoch = dataChangeEpoch;
+    state.handledFreshDataTransitionEpoch = freshDataTransitionEpoch;
+    if (didStartFreshData) {
       resetInitialRenderState(ctx, {
         resetInitialScroll: !!initialScrollProp,
         resetLayout: true
@@ -7630,8 +7703,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
     handleInitialScrollDataChange(ctx, {
       dataLength: dataProp.length,
-      didDataChange: didDataChangeLocal,
-      didStartFreshData: shouldResetFreshDataLayout,
+      didDataChange,
+      didStartFreshData,
       initialScrollAtEnd,
       latestInitialScroll: initialScrollProp,
       latestInitialScrollSessionKind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
@@ -7641,8 +7714,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }, [
     dataProp.length,
     dataKey,
-    didDataChangeLocal,
-    shouldResetFreshDataLayout,
+    dataChangeEpoch,
+    freshDataTransitionEpoch,
     initialScrollAtEnd,
     stylePaddingEndState,
     usesBootstrapInitialScroll
@@ -7825,13 +7898,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: (event) => onScroll(ctx, event),
       onScrollBeginDrag: (event) => {
         var _a4, _b2;
-        const maintainingScrollAtEnd = state.maintainingScrollAtEnd;
-        if (maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant") {
-          cancelImperativeScroll(state);
-        }
-        if (maintainingScrollAtEnd) {
-          finishMaintainScrollAtEnd(ctx);
-        }
+        interruptMaintainScrollAtEnd(ctx);
         prepareReachedEdgeForNextUserScroll(ctx);
         (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
       },