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

package/react-native.mjs

@@ -826,7 +826,7 @@ var Containers = typedMemo(function Containers2({
       return !((_a3 = ctx.state) == null ? void 0 : _a3.initialScroll) ? !prevValue || value - prevValue > 20 ? 0 : 200 : void 0;
     }
   });
-  const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("readyToRender", { getValue: (value) => value ? 1 : 0 }) : void 0;
+  const animOpacity = waitForInitialLayout ? useValue$("readyToRender", { getValue: (value) => value ? 1 : 0 }) : void 0;
   const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
@@ -1109,6 +1109,7 @@ function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize) {
 
 // src/core/calculateOffsetWithOffsetPosition.ts
 function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
+  var _a3;
   const state = ctx.state;
   const { index, viewOffset, viewPosition } = params;
   let offset = offsetParam;
@@ -1122,10 +1123,16 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
     }
   }
   if (viewPosition !== void 0 && index !== void 0) {
-    const itemSize = getItemSize(ctx, getId(state, index), index, state.props.data[index]);
+    const dataLength = state.props.data.length;
+    if (dataLength === 0) {
+      return offset;
+    }
+    const isOutOfBounds = index < 0 || index >= dataLength;
+    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
+    const itemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
     const trailingInset = getContentInsetEnd(state);
     offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
-    if (index === state.props.data.length - 1) {
+    if (!isOutOfBounds && index === state.props.data.length - 1) {
       const footerSize = peek$(ctx, "footerSize") || 0;
       offset += footerSize;
     }
@@ -1327,7 +1334,9 @@ function finishScrollTo(ctx) {
     const scrollingTo = state.scrollingTo;
     state.scrollHistory.length = 0;
     state.initialScroll = void 0;
+    state.initialScrollUsesOffset = false;
     state.initialAnchor = void 0;
+    state.initialNativeScrollWatchdog = void 0;
     state.scrollingTo = void 0;
     if (state.pendingTotalSize !== void 0) {
       addTotalSize(ctx, null, state.pendingTotalSize);
@@ -1345,21 +1354,21 @@ function finishScrollTo(ctx) {
 }
 
 // src/core/checkFinishedScroll.ts
+var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
+var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
+var INITIAL_SCROLL_ZERO_TARGET_EPSILON = 1;
 function checkFinishedScroll(ctx) {
   ctx.state.animFrameCheckFinishedScroll = requestAnimationFrame(() => checkFinishedScrollFrame(ctx));
 }
 function checkFinishedScrollFrame(ctx) {
+  var _a3;
   const scrollingTo = ctx.state.scrollingTo;
   if (scrollingTo) {
     const { state } = ctx;
     state.animFrameCheckFinishedScroll = void 0;
     const scroll = state.scrollPending;
     const adjust = state.scrollAdjustHandler.getAdjust();
-    const clampedTargetOffset = clampScrollOffset(
-      ctx,
-      scrollingTo.offset - (scrollingTo.viewOffset || 0),
-      scrollingTo
-    );
+    const clampedTargetOffset = (_a3 = scrollingTo.targetOffset) != null ? _a3 : clampScrollOffset(ctx, scrollingTo.offset - (scrollingTo.viewOffset || 0), scrollingTo);
     const maxOffset = clampScrollOffset(ctx, scroll, scrollingTo);
     const diff1 = Math.abs(scroll - clampedTargetOffset);
     const diff2 = Math.abs(diff1 - adjust);
@@ -1373,17 +1382,33 @@ function checkFinishedScrollFrame(ctx) {
 function checkFinishedScrollFallback(ctx) {
   const state = ctx.state;
   const scrollingTo = state.scrollingTo;
-  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) || !state.didContainersLayout;
+  const shouldFinishInitialZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+  const slowTimeout = (scrollingTo == null ? void 0 : scrollingTo.isInitialScroll) && !shouldFinishInitialZeroTarget || !state.didContainersLayout;
   state.timeoutCheckFinishedScrollFallback = setTimeout(
     () => {
       let numChecks = 0;
       const checkHasScrolled = () => {
+        var _a3, _b;
         state.timeoutCheckFinishedScrollFallback = void 0;
         const isStillScrollingTo = state.scrollingTo;
         if (isStillScrollingTo) {
           numChecks++;
-          if (state.hasScrolled || numChecks > 5) {
+          const isNativeInitialPending = isNativeInitialNonZeroTarget(state) && !state.hasScrolled;
+          const maxChecks = isNativeInitialPending ? INITIAL_SCROLL_MAX_FALLBACK_CHECKS : 5;
+          const shouldFinishZeroTarget = shouldFinishInitialZeroTargetScroll(ctx);
+          if (shouldFinishZeroTarget || state.hasScrolled || numChecks > maxChecks) {
             finishScrollTo(ctx);
+          } else if (isNativeInitialPending && numChecks <= maxChecks) {
+            const targetOffset = (_b = (_a3 = state.initialNativeScrollWatchdog) == null ? void 0 : _a3.targetOffset) != null ? _b : state.scrollPending;
+            const scroller = state.refScroller.current;
+            if (scroller) {
+              scroller.scrollTo({
+                animated: false,
+                x: state.props.horizontal ? targetOffset : 0,
+                y: state.props.horizontal ? 0 : targetOffset
+              });
+            }
+            state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, 100);
           } else {
             state.timeoutCheckFinishedScrollFallback = setTimeout(checkHasScrolled, 100);
           }
@@ -1394,6 +1419,14 @@ function checkFinishedScrollFallback(ctx) {
     slowTimeout ? 500 : 100
   );
 }
+function isNativeInitialNonZeroTarget(state) {
+  return !state.didFinishInitialScroll && !!state.initialNativeScrollWatchdog && state.initialNativeScrollWatchdog.targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
+}
+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;
+}
 
 // src/core/doScrollTo.native.ts
 function doScrollTo(ctx, params) {
@@ -1417,7 +1450,9 @@ function doScrollTo(ctx, params) {
 }
 
 // src/core/scrollTo.ts
+var WATCHDOG_OFFSET_EPSILON = 1;
 function scrollTo(ctx, params) {
+  var _a3, _b;
   const state = ctx.state;
   const { noScrollingTo, forceScroll, ...scrollTarget } = params;
   const { animated, isInitialScroll, offset: scrollTargetOffset, precomputedWithViewOffset } = scrollTarget;
@@ -1434,9 +1469,23 @@ function scrollTo(ctx, params) {
   offset = clampScrollOffset(ctx, offset, scrollTarget);
   state.scrollHistory.length = 0;
   if (!noScrollingTo) {
-    state.scrollingTo = scrollTarget;
+    state.scrollingTo = {
+      ...scrollTarget,
+      targetOffset: offset
+    };
   }
   state.scrollPending = offset;
+  const shouldWatchInitialNativeScroll = !state.didFinishInitialScroll && (isInitialScroll || !!state.initialNativeScrollWatchdog) && offset > WATCHDOG_OFFSET_EPSILON;
+  const shouldClearInitialNativeScrollWatchdog = !state.didFinishInitialScroll && !!state.initialNativeScrollWatchdog && offset <= WATCHDOG_OFFSET_EPSILON;
+  if (shouldWatchInitialNativeScroll) {
+    state.hasScrolled = false;
+    state.initialNativeScrollWatchdog = {
+      startScroll: (_b = (_a3 = state.initialNativeScrollWatchdog) == null ? void 0 : _a3.startScroll) != null ? _b : state.scroll,
+      targetOffset: offset
+    };
+  } else if (shouldClearInitialNativeScrollWatchdog) {
+    state.initialNativeScrollWatchdog = void 0;
+  }
   if (forceScroll || !isInitialScroll || Platform2.OS === "android") {
     doScrollTo(ctx, { animated, horizontal, offset });
   } else {
@@ -1444,178 +1493,52 @@ function scrollTo(ctx, params) {
   }
 }
 
-// src/platform/flushSync.native.ts
-var flushSync = (fn) => {
-  fn();
-};
-
-// src/core/updateScroll.ts
-function updateScroll(ctx, newScroll, forceUpdate) {
+// src/core/doMaintainScrollAtEnd.ts
+function doMaintainScrollAtEnd(ctx) {
   const state = ctx.state;
-  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
-  const prevScroll = state.scroll;
-  state.hasScrolled = true;
-  state.lastBatchingAction = Date.now();
-  const currentTime = Date.now();
-  const adjust = 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();
+  const {
+    didContainersLayout,
+    isAtEnd,
+    pendingNativeMVCPAdjust,
+    refScroller,
+    props: { maintainScrollAtEnd }
+  } = state;
+  const shouldMaintainScrollAtEnd = !!(isAtEnd && maintainScrollAtEnd && didContainersLayout);
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    return false;
   }
-  if (ignoreScrollFromMVCP && !scrollingTo) {
-    const { lt, gt } = ignoreScrollFromMVCP;
-    if (lt && newScroll < lt || gt && newScroll > gt) {
-      state.ignoreScrollFromMVCPIgnored = true;
-      return;
+  state.pendingMaintainScrollAtEnd = false;
+  if (shouldMaintainScrollAtEnd) {
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
+      state.scroll = 0;
     }
-  }
-  state.scrollPrev = prevScroll;
-  state.scrollPrevTime = state.scrollTime;
-  state.scroll = newScroll;
-  state.scrollTime = currentTime;
-  const scrollDelta = Math.abs(newScroll - prevScroll);
-  const scrollLength = state.scrollLength;
-  const lastCalculated = state.scrollLastCalculate;
-  const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
-  if (shouldUpdate) {
-    state.scrollLastCalculate = state.scroll;
-    state.ignoreScrollFromMVCPIgnored = false;
-    state.lastScrollDelta = scrollDelta;
-    const runCalculateItems = () => {
+    requestAnimationFrame(() => {
       var _a3;
-      (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state, { doMVCP: scrollingTo !== void 0 });
-      checkThresholds(ctx);
-    };
-    if (Platform2.OS === "web" && scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength) {
-      flushSync(runCalculateItems);
-    } else {
-      runCalculateItems();
-    }
-    state.dataChangeNeedsScrollUpdate = false;
-    state.lastScrollDelta = 0;
-  }
-}
-
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
-  const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    const needsScrollWorkaround = Platform2.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
-    const doit = () => {
-      if (needsScrollWorkaround) {
-        scrollTo(ctx, {
-          noScrollingTo: true,
-          offset: state.scroll
+      if (state.isAtEnd) {
+        state.maintainingScrollAtEnd = true;
+        (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
+          animated: maintainScrollAtEnd.animated
         });
-      } 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 (Platform2.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(() => {
-          state.ignoreScrollFromMVCP = void 0;
-          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
-          if (shouldForceUpdate) {
-            state.ignoreScrollFromMVCPIgnored = false;
-            state.scrollPending = state.scroll;
-            updateScroll(ctx, state.scroll, true);
-          }
-        }, delay);
+        setTimeout(
+          () => {
+            state.maintainingScrollAtEnd = false;
+          },
+          maintainScrollAtEnd.animated ? 500 : 0
+        );
       }
-    } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
-    }
-  }
-}
-
-// src/core/ensureInitialAnchor.ts
-var INITIAL_ANCHOR_TOLERANCE = 0.5;
-var INITIAL_ANCHOR_MAX_ATTEMPTS = 4;
-var INITIAL_ANCHOR_SETTLED_TICKS = 2;
-function ensureInitialAnchor(ctx) {
-  var _a3, _b, _c, _d, _e;
-  const state = ctx.state;
-  const { initialAnchor, didContainersLayout, scroll, scrollLength } = state;
-  const anchor = initialAnchor;
-  const item = state.props.data[anchor.index];
-  if (!didContainersLayout) {
-    return;
-  }
-  const id = getId(state, anchor.index);
-  if (state.positions[anchor.index] === void 0) {
-    return;
-  }
-  const size = getItemSize(ctx, id, anchor.index, item, true, true);
-  if (size === void 0) {
-    return;
-  }
-  const availableSpace = Math.max(0, scrollLength - size);
-  const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
-  const desiredOffset = calculateOffsetForIndex(ctx, anchor.index) + topOffsetAdjustment - ((_a3 = anchor.viewOffset) != null ? _a3 : 0) - ((_b = anchor.viewPosition) != null ? _b : 0) * availableSpace;
-  const clampedDesiredOffset = clampScrollOffset(ctx, desiredOffset, anchor);
-  const delta = clampedDesiredOffset - scroll;
-  if (Math.abs(delta) <= INITIAL_ANCHOR_TOLERANCE) {
-    const settledTicks = ((_c = anchor.settledTicks) != null ? _c : 0) + 1;
-    if (settledTicks >= INITIAL_ANCHOR_SETTLED_TICKS) {
-      state.initialAnchor = void 0;
-    } else {
-      anchor.settledTicks = settledTicks;
-    }
-    return;
-  }
-  if (((_d = anchor.attempts) != null ? _d : 0) >= INITIAL_ANCHOR_MAX_ATTEMPTS) {
-    state.initialAnchor = void 0;
-    return;
-  }
-  const lastDelta = anchor.lastDelta;
-  if (lastDelta !== void 0 && Math.abs(delta) >= Math.abs(lastDelta)) {
-    state.initialAnchor = void 0;
-    return;
+    });
+    return true;
   }
-  Object.assign(anchor, {
-    attempts: ((_e = anchor.attempts) != null ? _e : 0) + 1,
-    lastDelta: delta,
-    settledTicks: 0
-  });
-  requestAdjust(ctx, delta);
+  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;
@@ -1655,6 +1578,100 @@ function updateAnchorLock(state, params) {
     };
   }
 }
+function shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotalSize, prevScroll, scrollTarget) {
+  if (!dataChanged || Platform2.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 && state.isAtEnd && 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;
@@ -1674,7 +1691,13 @@ function prepareMVCP(ctx, dataChanged) {
   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;
@@ -1776,18 +1799,206 @@ function prepareMVCP(ctx, dataChanged) {
           }
         }
       }
-      updateAnchorLock(state, {
-        anchorId: anchorIdForLock,
-        anchorPosition: anchorPositionForLock,
-        dataChanged,
-        now,
-        positionDiff
-      });
-      if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
-        requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
-      }
+      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) {
+        requestAdjust(ctx, positionDiff, dataChanged && mvcpData);
+      }
+    };
+  }
+}
+
+// src/platform/flushSync.native.ts
+var flushSync = (fn) => {
+  fn();
+};
+
+// src/core/updateScroll.ts
+function updateScroll(ctx, newScroll, forceUpdate) {
+  var _a3;
+  const state = ctx.state;
+  const { ignoreScrollFromMVCP, lastScrollAdjustForHistory, scrollAdjustHandler, scrollHistory, scrollingTo } = state;
+  const prevScroll = state.scroll;
+  state.hasScrolled = true;
+  state.lastBatchingAction = Date.now();
+  const currentTime = Date.now();
+  const adjust = 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 (Platform2.OS === "web" && scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength) {
+      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/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
+  const state = ctx.state;
+  if (Math.abs(positionDiff) > 0.1) {
+    const needsScrollWorkaround = Platform2.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
+    const doit = () => {
+      if (needsScrollWorkaround) {
+        scrollTo(ctx, {
+          noScrollingTo: true,
+          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 (Platform2.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(() => {
+          state.ignoreScrollFromMVCP = void 0;
+          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
+          if (shouldForceUpdate) {
+            state.ignoreScrollFromMVCPIgnored = false;
+            state.scrollPending = state.scroll;
+            updateScroll(ctx, state.scroll, true);
+          }
+        }, delay);
+      }
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
+    }
+  }
+}
+
+// src/core/ensureInitialAnchor.ts
+var INITIAL_ANCHOR_TOLERANCE = 0.5;
+var INITIAL_ANCHOR_MAX_ATTEMPTS = 4;
+var INITIAL_ANCHOR_SETTLED_TICKS = 2;
+function ensureInitialAnchor(ctx) {
+  var _a3, _b, _c, _d, _e, _f;
+  const state = ctx.state;
+  const { initialAnchor, didContainersLayout, scroll, scrollLength } = state;
+  const anchor = initialAnchor;
+  if (state.initialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll)) {
+    return;
+  }
+  const item = state.props.data[anchor.index];
+  if (!didContainersLayout) {
+    return;
+  }
+  const id = getId(state, anchor.index);
+  if (state.positions[anchor.index] === void 0) {
+    return;
+  }
+  const size = getItemSize(ctx, id, anchor.index, item, true, true);
+  if (size === void 0) {
+    return;
+  }
+  const availableSpace = Math.max(0, scrollLength - size);
+  const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+  const desiredOffset = calculateOffsetForIndex(ctx, anchor.index) + topOffsetAdjustment - ((_b = anchor.viewOffset) != null ? _b : 0) - ((_c = anchor.viewPosition) != null ? _c : 0) * availableSpace;
+  const clampedDesiredOffset = clampScrollOffset(ctx, desiredOffset, anchor);
+  const delta = clampedDesiredOffset - scroll;
+  if (Math.abs(delta) <= INITIAL_ANCHOR_TOLERANCE) {
+    const settledTicks = ((_d = anchor.settledTicks) != null ? _d : 0) + 1;
+    if (settledTicks >= INITIAL_ANCHOR_SETTLED_TICKS) {
+      state.initialAnchor = void 0;
+    } else {
+      anchor.settledTicks = settledTicks;
+    }
+    return;
+  }
+  if (((_e = anchor.attempts) != null ? _e : 0) >= INITIAL_ANCHOR_MAX_ATTEMPTS) {
+    state.initialAnchor = void 0;
+    return;
+  }
+  const lastDelta = anchor.lastDelta;
+  if (lastDelta !== void 0 && Math.abs(delta) >= Math.abs(lastDelta)) {
+    state.initialAnchor = void 0;
+    return;
   }
+  Object.assign(anchor, {
+    attempts: ((_f = anchor.attempts) != null ? _f : 0) + 1,
+    lastDelta: delta,
+    settledTicks: 0
+  });
+  requestAdjust(ctx, delta);
 }
 
 // src/core/prepareColumnStartState.ts
@@ -2443,7 +2654,14 @@ function comparatorByDistance(a, b) {
 }
 
 // src/core/scrollToIndex.ts
-function scrollToIndex(ctx, { index, viewOffset = 0, animated = true, viewPosition }) {
+function scrollToIndex(ctx, {
+  index,
+  viewOffset = 0,
+  animated = true,
+  forceScroll,
+  isInitialScroll,
+  viewPosition
+}) {
   const state = ctx.state;
   const { data } = state.props;
   if (index >= data.length) {
@@ -2461,7 +2679,9 @@ function scrollToIndex(ctx, { index, viewOffset = 0, animated = true, viewPositi
   const itemSize = getItemSize(ctx, targetId, index, state.props.data[index]);
   scrollTo(ctx, {
     animated,
+    forceScroll,
     index,
+    isInitialScroll,
     itemSize,
     offset: firstIndexOffset,
     viewOffset,
@@ -2469,15 +2689,58 @@ function scrollToIndex(ctx, { index, viewOffset = 0, animated = true, viewPositi
   });
 }
 
+// src/utils/performInitialScroll.ts
+function performInitialScroll(ctx, params) {
+  var _a3;
+  const { forceScroll, initialScrollUsesOffset, resolvedOffset, target } = params;
+  if (initialScrollUsesOffset || resolvedOffset !== void 0) {
+    scrollTo(ctx, {
+      animated: false,
+      forceScroll,
+      index: initialScrollUsesOffset ? void 0 : target.index,
+      isInitialScroll: true,
+      offset: (_a3 = resolvedOffset != null ? resolvedOffset : target.contentOffset) != null ? _a3 : 0,
+      precomputedWithViewOffset: resolvedOffset !== void 0
+    });
+    return;
+  }
+  if (target.index === void 0) {
+    return;
+  }
+  scrollToIndex(ctx, {
+    ...target,
+    animated: false,
+    forceScroll,
+    isInitialScroll: true
+  });
+}
+
 // src/utils/setDidLayout.ts
 function setDidLayout(ctx) {
   const state = ctx.state;
   const { initialScroll } = state;
   state.queuedInitialLayout = true;
   checkAtBottom(ctx);
-  if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
-    const target = initialScroll;
-    const runScroll = () => scrollToIndex(ctx, { ...target, animated: false });
+  if (initialScroll) {
+    const runScroll = () => {
+      var _a3, _b;
+      const target = state.initialScroll;
+      if (!target) {
+        return;
+      }
+      const activeInitialTargetOffset = ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) ? (_b = state.scrollingTo.targetOffset) != null ? _b : state.scrollingTo.offset : void 0;
+      const desiredInitialTargetOffset = state.initialScrollUsesOffset ? target.contentOffset : activeInitialTargetOffset;
+      const isAlreadyAtDesiredInitialTarget = desiredInitialTargetOffset !== void 0 && Math.abs(state.scroll - desiredInitialTargetOffset) <= 1 && Math.abs(state.scrollPending - desiredInitialTargetOffset) <= 1;
+      if (!isAlreadyAtDesiredInitialTarget) {
+        performInitialScroll(ctx, {
+          forceScroll: true,
+          initialScrollUsesOffset: state.initialScrollUsesOffset,
+          // Offset-based initial scrolls do not need item lookup, so they can run even before data exists.
+          // Re-run on the next frame to pick up measured viewport size without waiting for index resolution.
+          target
+        });
+      }
+    };
     runScroll();
     requestAnimationFrame(runScroll);
   }
@@ -2555,7 +2818,7 @@ function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentSt
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
   batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     const {
       columns,
       columnSpans,
@@ -2594,7 +2857,7 @@ function calculateItemsInView(ctx, params = {}) {
       }
       return;
     }
-    const totalSize = getContentSize(ctx);
+    let totalSize = getContentSize(ctx);
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
     const speed = getScrollVelocity(state);
@@ -2602,14 +2865,14 @@ function calculateItemsInView(ctx, params = {}) {
     const { queuedInitialLayout } = state;
     let { scroll: scrollState } = state;
     if (!queuedInitialLayout && initialScroll) {
-      const updatedOffset = calculateOffsetWithOffsetPosition(
+      const updatedOffset = state.initialScrollUsesOffset ? (_a3 = initialScroll.contentOffset) != null ? _a3 : 0 : calculateOffsetWithOffsetPosition(
         ctx,
         calculateOffsetForIndex(ctx, initialScroll.index),
         initialScroll
       );
       scrollState = updatedOffset;
     }
-    const scrollAdjustPending = (_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0;
+    const scrollAdjustPending = (_b = peek$(ctx, "scrollAdjustPending")) != null ? _b : 0;
     const scrollAdjustPad = scrollAdjustPending - topPad;
     let scroll = Math.round(scrollState + scrollExtra + scrollAdjustPad);
     if (scroll + scrollLength > totalSize) {
@@ -2654,13 +2917,14 @@ function calculateItemsInView(ctx, params = {}) {
       columns.length = 0;
       columnSpans.length = 0;
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_b = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _b : 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_c = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _c : 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
       forceFullUpdate: !!forceFullItemPositions,
       scrollBottomBuffered,
       startIndex
     });
+    totalSize = getContentSize(ctx);
     if (minIndexSizeChanged !== void 0) {
       state.minIndexSizeChanged = void 0;
     }
@@ -2672,9 +2936,9 @@ function calculateItemsInView(ctx, params = {}) {
     let endBuffered = null;
     let loopStart = !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
-      const id = (_c = idCache[i]) != null ? _c : getId(state, i);
+      const id = (_d = idCache[i]) != null ? _d : getId(state, i);
       const top = positions[i];
-      const size = (_d = sizes.get(id)) != null ? _d : getItemSize(ctx, id, i, data[i]);
+      const size = (_e = sizes.get(id)) != null ? _e : getItemSize(ctx, id, i, data[i]);
       const bottom = top + size;
       if (bottom > scroll - scrollBufferTop) {
         loopStart = i;
@@ -2705,14 +2969,14 @@ function calculateItemsInView(ctx, params = {}) {
     let firstFullyOnScreenIndex;
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = (_e = idCache[i]) != null ? _e : getId(state, i);
-      const size = (_f = sizes.get(id)) != null ? _f : getItemSize(ctx, id, i, data[i]);
+      const id = (_f = idCache[i]) != null ? _f : getId(state, i);
+      const size = (_g = sizes.get(id)) != null ? _g : getItemSize(ctx, id, i, data[i]);
       const top = positions[i];
       if (!foundEnd) {
         if (startNoBuffer === null && top + size > scroll) {
           startNoBuffer = i;
         }
-        if (firstFullyOnScreenIndex === void 0 && top >= scroll - 10) {
+        if (firstFullyOnScreenIndex === void 0 && top >= scroll - 10 && top <= scrollBottom) {
           firstFullyOnScreenIndex = i;
         }
         if (startBuffered === null && top + size > scrollTopBuffered) {
@@ -2742,9 +3006,12 @@ function calculateItemsInView(ctx, params = {}) {
       }
     }
     const idsInView = [];
-    for (let i = firstFullyOnScreenIndex; i <= endNoBuffer; i++) {
-      const id = (_g = idCache[i]) != null ? _g : getId(state, i);
-      idsInView.push(id);
+    const firstVisibleAnchorIndex = firstFullyOnScreenIndex != null ? firstFullyOnScreenIndex : startNoBuffer;
+    if (firstVisibleAnchorIndex !== null && firstVisibleAnchorIndex !== void 0 && endNoBuffer !== null) {
+      for (let i = firstVisibleAnchorIndex; i <= endNoBuffer; i++) {
+        const id = (_h = idCache[i]) != null ? _h : getId(state, i);
+        idsInView.push(id);
+      }
     }
     Object.assign(state, {
       endBuffered,
@@ -2775,7 +3042,7 @@ function calculateItemsInView(ctx, params = {}) {
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
       for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_h = idCache[i]) != null ? _h : getId(state, i);
+        const id = (_i = idCache[i]) != null ? _i : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainersSet.add(i);
           needNewContainers.push(i);
@@ -2784,7 +3051,7 @@ function calculateItemsInView(ctx, params = {}) {
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_i = idCache[index]) != null ? _i : getId(state, index);
+          const id = (_j = idCache[index]) != null ? _j : getId(state, index);
           if (id && !containerItemKeys.has(id) && !needNewContainersSet.has(index)) {
             needNewContainersSet.add(index);
             needNewContainers.push(index);
@@ -2822,7 +3089,7 @@ function calculateItemsInView(ctx, params = {}) {
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
           const containerIndex = availableContainers[idx];
-          const id = (_j = idCache[i]) != null ? _j : getId(state, i);
+          const id = (_k = idCache[i]) != null ? _k : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -2863,7 +3130,7 @@ function calculateItemsInView(ctx, params = {}) {
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_k = idCache[index]) != null ? _k : getId(state, index);
+          const id = (_l = idCache[index]) != null ? _l : getId(state, index);
           const containerIndex = containerItemKeys.get(id);
           if (containerIndex !== void 0) {
             state.stickyContainerPool.add(containerIndex);
@@ -2974,40 +3241,6 @@ function checkActualChange(state, dataProp, previousData) {
   return false;
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function doMaintainScrollAtEnd(ctx, animated) {
-  const state = ctx.state;
-  const {
-    didContainersLayout,
-    isAtEnd,
-    refScroller,
-    props: { maintainScrollAtEnd }
-  } = state;
-  if (isAtEnd && maintainScrollAtEnd && didContainersLayout) {
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
-    }
-    requestAnimationFrame(() => {
-      var _a3;
-      if (state.isAtEnd) {
-        state.maintainingScrollAtEnd = true;
-        (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
-          animated
-        });
-        setTimeout(
-          () => {
-            state.maintainingScrollAtEnd = false;
-          },
-          0
-        );
-      }
-    });
-    return true;
-  }
-  return false;
-}
-
 // src/utils/updateAveragesOnDataChange.ts
 function updateAveragesOnDataChange(state, oldData, newData) {
   var _a3;
@@ -3069,8 +3302,8 @@ function checkResetContainers(ctx, dataProp) {
   }
   const { maintainScrollAtEnd } = state.props;
   calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
-  const shouldMaintainScrollAtEnd = maintainScrollAtEnd === true || maintainScrollAtEnd.onDataChange;
-  const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx, false);
+  const shouldMaintainScrollAtEnd = maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onDataChange;
+  const didMaintainScrollAtEnd = shouldMaintainScrollAtEnd && doMaintainScrollAtEnd(ctx);
   if (!didMaintainScrollAtEnd && previousData && dataProp.length > previousData.length) {
     state.isEndReached = false;
   }
@@ -3174,8 +3407,8 @@ function handleLayout(ctx, layoutParam, setCanRender) {
     if (didChange || otherAxisSize !== prevOtherAxisSize) {
       set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
     }
-    if (maintainScrollAtEnd === true || maintainScrollAtEnd.onLayout) {
-      doMaintainScrollAtEnd(ctx, false);
+    if (maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onLayout) {
+      doMaintainScrollAtEnd(ctx);
     }
     checkThresholds(ctx);
     if (state) {
@@ -3192,6 +3425,12 @@ function handleLayout(ctx, layoutParam, setCanRender) {
 }
 
 // src/core/onScroll.ts
+var INITIAL_SCROLL_PROGRESS_EPSILON = 1;
+function didObserveInitialScrollProgress(newScroll, watchdog) {
+  const previousDistance = Math.abs(watchdog.startScroll - watchdog.targetOffset);
+  const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
+  return nextDistance <= INITIAL_SCROLL_PROGRESS_EPSILON || nextDistance + INITIAL_SCROLL_PROGRESS_EPSILON < previousDistance;
+}
 function onScroll(ctx, event) {
   var _a3, _b, _c, _d;
   const state = ctx.state;
@@ -3229,7 +3468,16 @@ function onScroll(ctx, event) {
     }
   }
   state.scrollPending = newScroll;
+  const initialNativeScrollWatchdog = state.initialNativeScrollWatchdog;
+  const didInitialScrollProgress = !!initialNativeScrollWatchdog && didObserveInitialScrollProgress(newScroll, initialNativeScrollWatchdog);
+  if (didInitialScrollProgress) {
+    state.initialNativeScrollWatchdog = void 0;
+  }
   updateScroll(ctx, newScroll, insetChanged);
+  if (initialNativeScrollWatchdog && !didInitialScrollProgress) {
+    state.hasScrolled = false;
+    state.initialNativeScrollWatchdog = initialNativeScrollWatchdog;
+  }
   if (state.scrollingTo) {
     checkFinishedScroll(ctx);
   }
@@ -3396,8 +3644,8 @@ function updateItemSize(ctx, itemKey, sizeObj) {
       runOrScheduleMVCPRecalculate(ctx);
     }
     if (shouldMaintainScrollAtEnd) {
-      if (maintainScrollAtEnd === true || maintainScrollAtEnd.onItemLayout) {
-        doMaintainScrollAtEnd(ctx, false);
+      if (maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onItemLayout) {
+        doMaintainScrollAtEnd(ctx);
       }
     }
   }
@@ -3773,6 +4021,34 @@ function getRenderedItem(ctx, key) {
   return { index, item: data[index], renderedItem };
 }
 
+// src/utils/normalizeMaintainScrollAtEnd.ts
+function normalizeMaintainScrollAtEndOn(on, hasExplicitOn) {
+  var _a3, _b, _c;
+  return {
+    animated: false,
+    onDataChange: hasExplicitOn ? (_a3 = on == null ? void 0 : on.dataChange) != null ? _a3 : false : true,
+    onItemLayout: hasExplicitOn ? (_b = on == null ? void 0 : on.itemLayout) != null ? _b : false : true,
+    onLayout: hasExplicitOn ? (_c = on == null ? void 0 : on.layout) != null ? _c : false : true
+  };
+}
+function normalizeMaintainScrollAtEnd(value) {
+  var _a3;
+  if (!value) {
+    return void 0;
+  }
+  if (value === true) {
+    return {
+      ...normalizeMaintainScrollAtEndOn(void 0, false),
+      animated: false
+    };
+  }
+  const normalizedTriggers = normalizeMaintainScrollAtEndOn(value.on, "on" in value);
+  return {
+    ...normalizedTriggers,
+    animated: (_a3 = value.animated) != null ? _a3 : false
+  };
+}
+
 // src/utils/normalizeMaintainVisibleContentPosition.ts
 function normalizeMaintainVisibleContentPosition(value) {
   var _a3, _b;
@@ -3874,7 +4150,7 @@ var LegendList = typedMemo2(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b, _c, _d, _e;
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
   const {
     alignItemsAtEnd = false,
     alwaysRender,
@@ -3960,16 +4236,24 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
   const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
+  const maintainScrollAtEndConfig = normalizeMaintainScrollAtEnd(maintainScrollAtEnd);
   const maintainVisibleContentPositionConfig = normalizeMaintainVisibleContentPosition(
     maintainVisibleContentPositionProp
   );
-  const initialScrollProp = initialScrollAtEnd ? { index: Math.max(0, dataProp.length - 1), viewOffset: -stylePaddingBottomState, viewPosition: 1 } : initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? {
-    index: initialScrollIndexProp.index || 0,
-    viewOffset: initialScrollIndexProp.viewOffset || (initialScrollIndexProp.viewPosition === 1 ? -stylePaddingBottomState : 0),
-    viewPosition: initialScrollIndexProp.viewPosition || 0
+  const hasInitialScrollIndex = initialScrollIndexProp !== void 0 && initialScrollIndexProp !== null;
+  const hasInitialScrollOffset = initialScrollOffsetProp !== void 0 && initialScrollOffsetProp !== null;
+  const initialScrollUsesOffsetOnly = !initialScrollAtEnd && !hasInitialScrollIndex && hasInitialScrollOffset;
+  const initialScrollProp = initialScrollAtEnd ? { index: Math.max(0, dataProp.length - 1), viewOffset: -stylePaddingBottomState, viewPosition: 1 } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
+    index: (_a3 = initialScrollIndexProp.index) != null ? _a3 : 0,
+    viewOffset: (_b = initialScrollIndexProp.viewOffset) != null ? _b : initialScrollIndexProp.viewPosition === 1 ? -stylePaddingBottomState : 0,
+    viewPosition: (_c = initialScrollIndexProp.viewPosition) != null ? _c : 0
   } : {
-    index: initialScrollIndexProp || 0,
-    viewOffset: initialScrollOffsetProp || 0
+    index: initialScrollIndexProp != null ? initialScrollIndexProp : 0,
+    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0
+  } : initialScrollUsesOffsetOnly ? {
+    contentOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0,
+    index: 0,
+    viewOffset: 0
   } : void 0;
   const [canRender, setCanRender] = React2.useState(!IsNewArchitecture);
   const ctx = useStateContext();
@@ -3984,8 +4268,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }, [
     alwaysRender == null ? void 0 : alwaysRender.top,
     alwaysRender == null ? void 0 : alwaysRender.bottom,
-    (_a3 = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _a3.join(","),
-    (_b = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _b.join(","),
+    (_d = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _d.join(","),
+    (_e = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _e.join(","),
     dataProp,
     dataVersion,
     keyExtractor
@@ -4029,14 +4313,22 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         idCache: [],
         idsInView: [],
         indexByKey: /* @__PURE__ */ new Map(),
-        initialAnchor: (initialScrollProp == null ? void 0 : initialScrollProp.index) !== void 0 && (initialScrollProp == null ? void 0 : initialScrollProp.viewPosition) !== void 0 ? {
+        initialAnchor: !initialScrollUsesOffsetOnly && (initialScrollProp == null ? void 0 : initialScrollProp.index) !== void 0 && (initialScrollProp == null ? void 0 : initialScrollProp.viewPosition) !== void 0 ? {
           attempts: 0,
           index: initialScrollProp.index,
           settledTicks: 0,
-          viewOffset: (_c = initialScrollProp.viewOffset) != null ? _c : 0,
+          viewOffset: (_f = initialScrollProp.viewOffset) != null ? _f : 0,
           viewPosition: initialScrollProp.viewPosition
         } : void 0,
+        initialNativeScrollWatchdog: void 0,
         initialScroll: initialScrollProp,
+        initialScrollLastDidFinish: false,
+        initialScrollLastTarget: initialScrollProp,
+        initialScrollLastTargetUsesOffset: initialScrollUsesOffsetOnly,
+        initialScrollPreviousDataLength: dataProp.length,
+        initialScrollRetryLastLength: void 0,
+        initialScrollRetryWindowUntil: 0,
+        initialScrollUsesOffset: initialScrollUsesOffsetOnly,
         isAtEnd: false,
         isAtStart: false,
         isEndReached: null,
@@ -4049,6 +4341,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         minIndexSizeChanged: 0,
         nativeContentInset: void 0,
         nativeMarginTop: 0,
+        pendingNativeMVCPAdjust: void 0,
         positions: [],
         props: {},
         queuedCalculateItemsInView: 0,
@@ -4086,7 +4379,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const state = refState.current;
   const isFirstLocal = state.isFirst;
   state.didColumnsChange = numColumnsProp !== state.props.numColumns;
-  const didDataChangeLocal = state.props.dataVersion !== dataVersion || state.props.data !== dataProp && checkActualChange(state, dataProp, state.props.data);
+  const didDataReferenceChangeLocal = state.props.data !== dataProp;
+  const didDataVersionChangeLocal = state.props.dataVersion !== dataVersion;
+  const didDataChangeLocal = didDataVersionChangeLocal || didDataReferenceChangeLocal && checkActualChange(state, dataProp, state.props.data);
   if (didDataChangeLocal) {
     state.dataChangeEpoch += 1;
     state.dataChangeNeedsScrollUpdate = true;
@@ -4112,7 +4407,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     initialContainerPoolRatio,
     itemsAreEqual,
     keyExtractor: useWrapIfItem(keyExtractor),
-    maintainScrollAtEnd,
+    maintainScrollAtEnd: maintainScrollAtEndConfig,
     maintainScrollAtEndThreshold,
     maintainVisibleContentPosition: maintainVisibleContentPositionConfig,
     numColumns: numColumnsProp,
@@ -4168,16 +4463,83 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     );
   }
   const resolveInitialScrollOffset = useCallback((initialScroll) => {
+    var _a4;
+    if (state.initialScrollUsesOffset) {
+      return clampScrollOffset(ctx, (_a4 = initialScroll.contentOffset) != null ? _a4 : 0);
+    }
     const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
     const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
     return clampScrollOffset(ctx, resolvedOffset, initialScroll);
   }, []);
+  const finishInitialScrollWithoutScroll = useCallback(() => {
+    refState.current.initialAnchor = void 0;
+    refState.current.initialScroll = void 0;
+    state.initialAnchor = void 0;
+    state.initialScroll = void 0;
+    state.initialScrollUsesOffset = false;
+    state.initialScrollLastTarget = void 0;
+    state.initialScrollLastTargetUsesOffset = false;
+    setInitialRenderState(ctx, { didInitialScroll: true });
+  }, []);
+  const setActiveInitialScrollTarget = useCallback(
+    (target, options) => {
+      var _a4;
+      const usesOffset = !!(options == null ? void 0 : options.usesOffset);
+      state.initialScrollUsesOffset = usesOffset;
+      state.initialScrollLastTarget = target;
+      state.initialScrollLastTargetUsesOffset = usesOffset;
+      refState.current.initialScroll = target;
+      state.initialScroll = target;
+      if ((options == null ? void 0 : options.resetDidFinish) && state.didFinishInitialScroll) {
+        state.didFinishInitialScroll = false;
+      }
+      if (!(options == null ? void 0 : options.syncAnchor)) {
+        return;
+      }
+      if (!IsNewArchitecture && !usesOffset && target.index !== void 0 && target.viewPosition !== void 0) {
+        state.initialAnchor = {
+          attempts: 0,
+          index: target.index,
+          settledTicks: 0,
+          viewOffset: (_a4 = target.viewOffset) != null ? _a4 : 0,
+          viewPosition: target.viewPosition
+        };
+      }
+    },
+    []
+  );
+  const shouldFinishInitialScrollAtOrigin = useCallback(
+    (initialScroll, offset) => {
+      var _a4, _b2, _c2;
+      if (offset !== 0 || initialScrollAtEnd) {
+        return false;
+      }
+      if (state.initialScrollUsesOffset) {
+        return Math.abs((_a4 = initialScroll.contentOffset) != null ? _a4 : 0) <= 1;
+      }
+      return initialScroll.index === 0 && ((_b2 = initialScroll.viewPosition) != null ? _b2 : 0) === 0 && Math.abs((_c2 = initialScroll.viewOffset) != null ? _c2 : 0) <= 1;
+    },
+    [initialScrollAtEnd]
+  );
+  const shouldFinishEmptyInitialScrollAtEnd = useCallback(
+    (initialScroll, offset) => {
+      return dataProp.length === 0 && initialScrollAtEnd && offset === 0 && initialScroll.viewPosition === 1;
+    },
+    [dataProp.length, initialScrollAtEnd]
+  );
+  const shouldRearmFinishedEmptyInitialScrollAtEnd = useCallback(
+    (initialScroll) => {
+      var _a4;
+      return !!(state.didFinishInitialScroll && dataProp.length > 0 && initialScroll && !state.initialScrollUsesOffset && initialScroll.index === 0 && initialScroll.viewPosition === 1 && ((_a4 = initialScroll.contentOffset) != null ? _a4 : 0) === 0);
+    },
+    [dataProp.length]
+  );
   const initialContentOffset = useMemo(() => {
     var _a4;
     let value;
     const { initialScroll, initialAnchor } = refState.current;
     if (initialScroll) {
-      if (!IsNewArchitecture && initialScroll.index !== void 0 && (!initialAnchor || (initialAnchor == null ? void 0 : initialAnchor.index) !== initialScroll.index)) {
+      if (!state.initialScrollUsesOffset && !IsNewArchitecture && initialScroll.index !== void 0 && (!initialAnchor || (initialAnchor == null ? void 0 : initialAnchor.index) !== initialScroll.index)) {
         refState.current.initialAnchor = {
           attempts: 0,
           index: initialScroll.index,
@@ -4191,16 +4553,22 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       } else {
         const clampedOffset = resolveInitialScrollOffset(initialScroll);
         const updatedInitialScroll = { ...initialScroll, contentOffset: clampedOffset };
-        refState.current.initialScroll = updatedInitialScroll;
-        state.initialScroll = updatedInitialScroll;
+        setActiveInitialScrollTarget(updatedInitialScroll, {
+          usesOffset: state.initialScrollUsesOffset
+        });
         value = clampedOffset;
       }
     } else {
       refState.current.initialAnchor = void 0;
       value = 0;
     }
-    if (!value) {
-      setInitialRenderState(ctx, { didInitialScroll: true });
+    const hasPendingDataDependentInitialScroll = !!initialScroll && dataProp.length === 0 && !shouldFinishInitialScrollAtOrigin(initialScroll, value) && !shouldFinishEmptyInitialScrollAtEnd(initialScroll, value);
+    if (!value && !hasPendingDataDependentInitialScroll) {
+      if (initialScroll && shouldFinishInitialScrollAtOrigin(initialScroll, value)) {
+        finishInitialScrollWithoutScroll();
+      } else {
+        setInitialRenderState(ctx, { didInitialScroll: true });
+      }
     }
     return value;
   }, []);
@@ -4217,24 +4585,131 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       set$(ctx, "totalSize", 0);
     }
   }
-  const doInitialScroll = useCallback(() => {
-    const { initialScroll, didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
-    if (initialScroll && !queuedInitialLayout && !didFinishInitialScroll && !scrollingTo) {
-      const offset = resolveInitialScrollOffset(initialScroll);
+  const doInitialScroll = useCallback((options) => {
+    var _a4, _b2;
+    const allowPostFinishRetry = !!(options == null ? void 0 : options.allowPostFinishRetry);
+    const { didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
+    const initialScroll = (_a4 = state.initialScroll) != null ? _a4 : allowPostFinishRetry ? state.initialScrollLastTarget : void 0;
+    const isInitialScrollInProgress = !!(scrollingTo == null ? void 0 : scrollingTo.isInitialScroll);
+    const needsContainerLayoutForInitialScroll = !state.initialScrollUsesOffset;
+    const shouldWaitForInitialLayout = waitForInitialLayout && needsContainerLayoutForInitialScroll && !queuedInitialLayout && !allowPostFinishRetry && !isInitialScrollInProgress;
+    if (!initialScroll || shouldWaitForInitialLayout || didFinishInitialScroll && !allowPostFinishRetry || scrollingTo && !isInitialScrollInProgress) {
+      return;
+    }
+    if (allowPostFinishRetry && state.initialScrollLastTargetUsesOffset) {
+      return;
+    }
+    const didMoveAwayFromInitialTarget = allowPostFinishRetry && initialScroll.contentOffset !== void 0 && Math.abs(state.scroll - initialScroll.contentOffset) > 1;
+    if (didMoveAwayFromInitialTarget) {
+      state.initialScrollRetryWindowUntil = 0;
+      return;
+    }
+    const offset = resolveInitialScrollOffset(initialScroll);
+    const activeInitialTargetOffset = isInitialScrollInProgress ? (_b2 = scrollingTo.targetOffset) != null ? _b2 : scrollingTo.offset : void 0;
+    const didOffsetChange = initialScroll.contentOffset === void 0 || Math.abs(initialScroll.contentOffset - offset) > 1;
+    const didActiveInitialTargetChange = activeInitialTargetOffset !== void 0 && Math.abs(activeInitialTargetOffset - offset) > 1;
+    if (!didOffsetChange && (allowPostFinishRetry || isInitialScrollInProgress && !didActiveInitialTargetChange)) {
+      return;
+    }
+    if (didOffsetChange) {
       const updatedInitialScroll = { ...initialScroll, contentOffset: offset };
-      refState.current.initialScroll = updatedInitialScroll;
-      state.initialScroll = updatedInitialScroll;
-      scrollTo(ctx, {
-        animated: false,
-        index: initialScroll.index,
-        isInitialScroll: true,
-        offset,
-        precomputedWithViewOffset: true
-      });
+      if (!state.initialScrollUsesOffset) {
+        state.initialScrollLastTarget = updatedInitialScroll;
+        state.initialScrollLastTargetUsesOffset = false;
+        if (state.initialScroll) {
+          refState.current.initialScroll = updatedInitialScroll;
+          state.initialScroll = updatedInitialScroll;
+        }
+      }
     }
+    const hasMeasuredScrollLayout = !!state.lastLayout && state.scrollLength > 0;
+    const shouldForceNativeInitialScroll = state.initialScrollUsesOffset && hasMeasuredScrollLayout || allowPostFinishRetry || !!queuedInitialLayout || isInitialScrollInProgress && didOffsetChange;
+    performInitialScroll(ctx, {
+      forceScroll: shouldForceNativeInitialScroll,
+      initialScrollUsesOffset: state.initialScrollUsesOffset,
+      resolvedOffset: offset,
+      target: initialScroll
+    });
   }, []);
+  useLayoutEffect(() => {
+    var _a4;
+    const previousDataLength = state.initialScrollPreviousDataLength;
+    state.initialScrollPreviousDataLength = dataProp.length;
+    if (previousDataLength !== 0 || dataProp.length === 0 || !state.initialScroll || !state.queuedInitialLayout) {
+      return;
+    }
+    if (initialScrollAtEnd) {
+      const lastIndex = Math.max(0, dataProp.length - 1);
+      const initialScroll = state.initialScroll;
+      const shouldRearm = shouldRearmFinishedEmptyInitialScrollAtEnd(initialScroll);
+      if (state.didFinishInitialScroll && !shouldRearm) {
+        return;
+      }
+      if (initialScroll && !state.initialScrollUsesOffset && initialScroll.index === lastIndex && initialScroll.viewPosition === 1 && !shouldRearm) {
+        return;
+      }
+      const updatedInitialScroll = {
+        contentOffset: void 0,
+        index: lastIndex,
+        viewOffset: (_a4 = initialScroll == null ? void 0 : initialScroll.viewOffset) != null ? _a4 : -stylePaddingBottomState,
+        viewPosition: 1
+      };
+      setActiveInitialScrollTarget(updatedInitialScroll, {
+        resetDidFinish: shouldRearm,
+        syncAnchor: true
+      });
+      doInitialScroll();
+      return;
+    }
+    if (state.didFinishInitialScroll) {
+      return;
+    }
+    doInitialScroll();
+  }, [
+    dataProp.length,
+    doInitialScroll,
+    initialScrollAtEnd,
+    shouldRearmFinishedEmptyInitialScrollAtEnd,
+    stylePaddingBottomState
+  ]);
+  useLayoutEffect(() => {
+    var _a4;
+    if (!initialScrollAtEnd) {
+      return;
+    }
+    const lastIndex = Math.max(0, dataProp.length - 1);
+    const initialScroll = state.initialScroll;
+    const shouldRearm = shouldRearmFinishedEmptyInitialScrollAtEnd(initialScroll);
+    if (state.didFinishInitialScroll && !shouldRearm) {
+      return;
+    }
+    if (shouldRearm) {
+      state.didFinishInitialScroll = false;
+    }
+    if (initialScroll && !state.initialScrollUsesOffset && initialScroll.index === lastIndex && initialScroll.viewPosition === 1 && !shouldRearm) {
+      return;
+    }
+    const updatedInitialScroll = {
+      contentOffset: void 0,
+      index: lastIndex,
+      viewOffset: (_a4 = initialScroll == null ? void 0 : initialScroll.viewOffset) != null ? _a4 : -stylePaddingBottomState,
+      viewPosition: 1
+    };
+    setActiveInitialScrollTarget(updatedInitialScroll, {
+      resetDidFinish: shouldRearm,
+      syncAnchor: true
+    });
+    doInitialScroll();
+  }, [
+    dataProp.length,
+    doInitialScroll,
+    initialScrollAtEnd,
+    shouldRearmFinishedEmptyInitialScrollAtEnd,
+    stylePaddingBottomState
+  ]);
   const onLayoutFooter = useCallback(
     (layout) => {
+      var _a4;
       if (!initialScrollAtEnd) {
         return;
       }
@@ -4249,16 +4724,48 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       const footerSize = layout[horizontal ? "width" : "height"];
       const viewOffset = -stylePaddingBottomState - footerSize;
       if (initialScroll.viewOffset !== viewOffset) {
+        const previousTargetOffset = (_a4 = initialScroll.contentOffset) != null ? _a4 : resolveInitialScrollOffset(initialScroll);
+        const didMoveAwayFromFinishedInitialTarget = state.didFinishInitialScroll && Math.abs(state.scroll - previousTargetOffset) > 1;
+        if (didMoveAwayFromFinishedInitialTarget) {
+          return;
+        }
         const updatedInitialScroll = { ...initialScroll, viewOffset };
-        refState.current.initialScroll = updatedInitialScroll;
-        state.initialScroll = updatedInitialScroll;
+        setActiveInitialScrollTarget(updatedInitialScroll, {
+          resetDidFinish: true
+        });
+        doInitialScroll();
       }
     },
-    [dataProp.length, horizontal, initialScrollAtEnd, stylePaddingBottomState]
+    [
+      dataProp.length,
+      doInitialScroll,
+      horizontal,
+      initialScrollAtEnd,
+      resolveInitialScrollOffset,
+      stylePaddingBottomState
+    ]
   );
   const onLayoutChange = useCallback((layout) => {
-    doInitialScroll();
+    var _a4;
     handleLayout(ctx, layout, setCanRender);
+    const SCROLL_LENGTH_RETRY_WINDOW_MS = 600;
+    const now = Date.now();
+    const didFinishInitialScroll = !!state.didFinishInitialScroll;
+    if (didFinishInitialScroll && !state.initialScrollLastDidFinish) {
+      state.initialScrollRetryWindowUntil = now + SCROLL_LENGTH_RETRY_WINDOW_MS;
+    }
+    state.initialScrollLastDidFinish = didFinishInitialScroll;
+    const previousScrollLength = state.initialScrollRetryLastLength;
+    const currentScrollLength = state.scrollLength;
+    const didScrollLengthChange = previousScrollLength === void 0 || Math.abs(currentScrollLength - previousScrollLength) > 1;
+    if (didScrollLengthChange) {
+      state.initialScrollRetryLastLength = currentScrollLength;
+    }
+    if (didFinishInitialScroll && didScrollLengthChange && now <= state.initialScrollRetryWindowUntil && !state.initialScrollLastTargetUsesOffset && ((_a4 = state.initialScrollLastTarget) == null ? void 0 : _a4.index) !== void 0) {
+      doInitialScroll({ allowPostFinishRetry: true });
+      return;
+    }
+    doInitialScroll();
   }, []);
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
@@ -4375,7 +4882,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_d = refreshControlElement.props.progressViewOffset) != null ? _d : 0) + stylePaddingTopState
+        progressViewOffset: ((_g = refreshControlElement.props.progressViewOffset) != null ? _g : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2.createElement(
         RefreshControl,
         {
@@ -4386,7 +4893,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       renderScrollComponent,
-      scrollAdjustHandler: (_e = refState.current) == null ? void 0 : _e.scrollAdjustHandler,
+      scrollAdjustHandler: (_h = refState.current) == null ? void 0 : _h.scrollAdjustHandler,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,
@@ -4398,8 +4905,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   ), IS_DEV && ENABLE_DEBUG_VIEW);
 });
 
-// src/react-native.ts
-var LegendList3 = LegendList;
+// src/entrypoints/shared.ts
+var LegendListRuntime = LegendList;
 var internal = {
   getComponent,
   IsNewArchitecture,
@@ -4410,4 +4917,8 @@ var internal = {
   useStateContext
 };
 
-export { LegendList3 as LegendList, internal, typedForwardRef, typedMemo2 as typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };
+// src/react-native.ts
+var LegendList3 = LegendListRuntime;
+var internal2 = internal;
+
+export { LegendList3 as LegendList, internal2 as internal, typedForwardRef, typedMemo2 as typedMemo, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };