@legendapp/list 3.3.11 → 3.5.0

package/react.mjs

@@ -409,6 +409,14 @@ var EDGE_POSITION_EPSILON = 1;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 
+// src/core/endOfContentTarget.ts
+function getEndAlignedViewOffset(stylePaddingEnd, footerSize = 0) {
+  return -stylePaddingEnd - footerSize;
+}
+function isEndOfContentTarget(target, dataLength) {
+  return !!target && dataLength > 0 && target.viewPosition === 1 && !!target.preserveForBottomPadding && target.index !== void 0 && target.index >= dataLength - 1;
+}
+
 // src/core/cancelImperativeScroll.ts
 function cancelScrollCompletionChecks({ scheduledWork }) {
   scheduledWork.cancel("checkFinishedScrollFrame");
@@ -593,26 +601,25 @@ var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, co
       scrollPosition: context.scrollPosition
     });
   };
+  let reached = !!wasReached;
   if (!wasReached) {
-    if (!within) {
-      return false;
-    }
-    onReached(distance);
-    updateSnapshot();
-    return true;
-  }
-  const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
-  if (reset) {
-    setSnapshot(void 0);
-    return false;
-  }
-  if (within) {
-    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
-    if (changed) {
+    if (within && onReached(distance)) {
       updateSnapshot();
+      reached = true;
+    }
+  } else {
+    const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
+    if (reset) {
+      setSnapshot(void 0);
+      reached = false;
+    } else if (within) {
+      const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
+      if (changed) {
+        updateSnapshot();
+      }
     }
   }
-  return true;
+  return reached;
 };
 
 // src/utils/edgeReachedGate.ts
@@ -659,7 +666,6 @@ function beginReachedEdgeUserScroll(ctx, scrollDelta) {
     return void 0;
   }
   const allowedEdge = scrollDelta < 0 ? "start" : "end";
-  state.edgeReachedGate = "closed";
   resetEdgeLatch(ctx, allowedEdge);
   return allowedEdge;
 }
@@ -700,7 +706,7 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
     set$(
       ctx,
       "isWithinMaintainScrollAtEndThreshold",
-      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength || state.pendingMaintainScrollAtEnd || maintainingScrollAtEnd === "animated" || maintainingScrollAtEnd === "instant"
+      isContentLess || distanceFromEnd <= maintainScrollAtEndThreshold * scrollLength || state.pendingMaintainScrollAtEnd || !!maintainingScrollAtEnd
     );
     const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || maintainingScrollAtEnd;
     if (!shouldSkipThresholdChecks) {
@@ -716,11 +722,13 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
           scrollPosition: scroll
         },
         (distance) => {
-          var _a4, _b;
-          if (canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
+          let dispatched = false;
+          if (state.props.onEndReached && canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
             markReachedEdge(ctx);
-            (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+            state.props.onEndReached({ distanceFromEnd: distance });
+            dispatched = true;
           }
+          return dispatched;
         },
         (snapshot) => {
           state.endReachedSnapshot = snapshot;
@@ -753,7 +761,7 @@ function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   }
   set$(ctx, "isAtStart", scroll <= EDGE_POSITION_EPSILON);
   set$(ctx, "isNearStart", scroll <= threshold);
-  const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || !!state.scrollingTo;
+  const shouldSkipThresholdChecks = !state.queuedInitialLayout || hasActiveInitialScroll(state) || !!state.scrollingTo;
   if (!shouldSkipThresholdChecks) {
     state.isStartReached = checkThreshold(
       scroll,
@@ -767,11 +775,13 @@ function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
         scrollPosition: scroll
       },
       (distance) => {
-        var _a3, _b;
-        if (canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
+        let dispatched = false;
+        if (state.props.onStartReached && canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
           markReachedEdge(ctx);
-          (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+          state.props.onStartReached({ distanceFromStart: distance });
+          dispatched = true;
         }
+        return dispatched;
       },
       (snapshot) => {
         state.startReachedSnapshot = snapshot;
@@ -870,8 +880,14 @@ function scheduleFullDrawDistancePrewarm(ctx) {
     return;
   }
   state.scheduledWork.frame(() => {
-    var _a3;
-    return (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state);
+    var _a3, _b, _c;
+    if (state.props.hasExternalScroll && !hasActiveInitialScroll(state) && !state.scrollingTo && !state.pendingNativeMVCPAdjust) {
+      const offset = (_b = (_a3 = state.refScroller.current) == null ? void 0 : _a3.getRawScrollOffset) == null ? void 0 : _b.call(_a3);
+      if (offset !== void 0) {
+        state.scroll = state.scrollPending = state.props.horizontal ? toLogicalHorizontalOffset(state, offset, state.totalSize) : offset;
+      }
+    }
+    (_c = state.triggerCalculateItemsInView) == null ? void 0 : _c.call(state);
   }, "fullDrawDistancePrewarm");
 }
 
@@ -884,6 +900,14 @@ function resetInitialRenderState(ctx, {
   if (resetLayout) {
     state.didContainersLayout = false;
     state.queuedInitialLayout = false;
+    state.scrollBufferDirection = void 0;
+    state.scrollHistory.length = 0;
+    state.scheduledWork.cancel("renderRangeProjection");
+    state.edgeReachedGate = void 0;
+    state.isStartReached = null;
+    state.isEndReached = null;
+    state.startReachedSnapshot = void 0;
+    state.endReachedSnapshot = void 0;
   }
   if (resetInitialScroll) {
     state.didFinishInitialScroll = false;
@@ -898,7 +922,7 @@ function setInitialRenderState(ctx, {
   const { state } = ctx;
   const {
     loadStartTime,
-    props: { onLoad }
+    props: { onLoad, onReady }
   } = state;
   if (didLayout) {
     state.didContainersLayout = true;
@@ -919,6 +943,7 @@ function setInitialRenderState(ctx, {
         onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
       }
     }
+    onReady == null ? void 0 : onReady();
   }
 }
 
@@ -1104,6 +1129,7 @@ function setSize(ctx, itemKey, size, notifyTotalSize = true) {
   const previousSize = sizes.get(itemKey);
   const diff = previousSize !== void 0 ? size - previousSize : size;
   if (diff !== 0) {
+    state.positionsAreCurrent = false;
     addTotalSize(ctx, itemKey, diff, notifyTotalSize);
   }
   sizes.set(itemKey, size);
@@ -1164,6 +1190,7 @@ function getKnownOrFixedSize(ctx, key, index, data, resolved) {
     const fixedSize = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
     if (fixedSize !== void 0) {
       size = fixedSize + ctx.scrollAxisGap;
+      state.positionsAreCurrent = false;
       state.sizesKnown.set(key, size);
     }
   }
@@ -1262,10 +1289,6 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
     const itemSize = Math.max(0, measuredItemSize - (isOutOfBounds ? 0 : ctx.scrollAxisGap));
     const trailingInset = getContentInsetEnd(ctx);
     offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
-    if (!isOutOfBounds && index === state.props.data.length - 1) {
-      const footerSize = peek$(ctx, "footerSize") || 0;
-      offset += footerSize;
-    }
   }
   return offset;
 }
@@ -1749,6 +1772,9 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   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;
+  if (isUserScrollEvent) {
+    state.scrollBufferDirection = newScroll > prevScroll ? 1 : -1;
+  }
   const didCancelMaintainScrollAtEnd = isUserScrollEvent && newScroll < prevScroll && !!(state.maintainingScrollAtEnd || state.pendingMaintainScrollAtEnd);
   if (didCancelMaintainScrollAtEnd) {
     finishMaintainScrollAtEnd(ctx);
@@ -1827,89 +1853,104 @@ function finishMaintainScrollAtEnd(ctx) {
     requestAdjust(ctx, nextScroll - state.scroll);
   }
 }
-function doMaintainScrollAtEnd(ctx) {
-  var _a3, _b, _c, _d, _e;
+function doMaintainScrollAtEnd(ctx, options) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
   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) {
+  let didMaintain = false;
+  if (state.isDragging || ((_b = (_a3 = state.refScroller.current) == null ? void 0 : _a3.isScrollInRange) == null ? void 0 : _b.call(_a3)) === false) {
+    finishMaintainScrollAtEnd(ctx);
+  } else {
+    const {
+      didContainersLayout,
+      didFinishInitialScroll,
+      pendingNativeMVCPAdjust,
+      props: { maintainScrollAtEnd }
+    } = state;
+    const immediate = (options == null ? void 0 : options.immediate) && Platform.OS === "web" && !(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.animated);
+    const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+    const isReplayingPendingMaintain = !!state.pendingMaintainScrollAtEnd;
+    const shouldMaintainScrollAtEnd = !!(!((_c = ctx.scrollRequestTracker) == null ? void 0 : _c.isWaitingToRun()) && (!state.scrollingTo || state.scrollingTo.isScrollToEnd) && (isWithinMaintainScrollAtEndThreshold || isReplayingPendingMaintain || ((_d = state.scrollingTo) == null ? void 0 : _d.isScrollToEnd)) && maintainScrollAtEnd && didFinishInitialScroll);
+    if (shouldMaintainScrollAtEnd && !state.scrollingTo) {
+      const scroller = state.refScroller.current;
+      const nativeMax = (_e = scroller == null ? void 0 : scroller.getMaxScrollOffset) == null ? void 0 : _e.call(scroller);
+      const observed = (_f = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _f.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;
-      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 {
+    } else if (pendingNativeMVCPAdjust) {
+      state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    } else if (shouldMaintainScrollAtEnd && (state.scrollingTo || state.pendingScrollResolve)) {
+      if (immediate && ((_g = state.scrollingTo) == null ? void 0 : _g.isScrollToEnd) && !state.scrollingTo.animated) {
+        state.pendingMaintainScrollAtEnd = false;
+        ctx.scrollToEnd({ animated: false });
+        didMaintain = true;
+      } else {
+        state.pendingMaintainScrollAtEnd = true;
+        (_h = state.maintainingScrollAtEnd) != null ? _h : state.maintainingScrollAtEnd = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      }
+    } else if (shouldMaintainScrollAtEnd && didContainersLayout) {
+      state.pendingMaintainScrollAtEnd = false;
+      const contentSize = getContentSize(ctx);
+      if (contentSize < state.scrollLength) {
+        state.scroll = 0;
+      }
+      if (!state.maintainingScrollAtEnd || immediate && state.maintainingScrollAtEnd === "pending-instant") {
+        const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+        const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+        const scrollAtRequest = state.scroll;
+        state.maintainingScrollAtEnd = pendingState;
+        const run = () => {
+          var _a4, _b2;
+          if (state.maintainingScrollAtEnd === pendingState) {
+            if (state.isDragging || ((_b2 = (_a4 = state.refScroller.current) == null ? void 0 : _a4.isScrollInRange) == null ? void 0 : _b2.call(_a4)) === false) {
               finishMaintainScrollAtEnd(ctx);
+            } else {
+              const isStillWithinThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+              const didScrollSinceRequest = state.scroll !== scrollAtRequest;
+              if (isReplayingPendingMaintain || isStillWithinThreshold || !didScrollSinceRequest) {
+                if (state.scrollingTo || state.pendingScrollResolve) {
+                  state.pendingMaintainScrollAtEnd = true;
+                } else {
+                  state.maintainingScrollAtEnd = activeState;
+                  const scrollPromise = getScrollRequestTracker(ctx).runNowIfIdle(
+                    () => ctx.scrollToEnd({ animated: maintainScrollAtEnd.animated })
+                  );
+                  void scrollPromise.then(() => {
+                    if (state.maintainingScrollAtEnd === activeState) {
+                      if (state.pendingMaintainScrollAtEnd) {
+                        state.maintainingScrollAtEnd = void 0;
+                        doMaintainScrollAtEnd(ctx);
+                      } else {
+                        finishMaintainScrollAtEnd(ctx);
+                      }
+                    }
+                  });
+                }
+              } else if (state.maintainingScrollAtEnd === pendingState) {
+                finishMaintainScrollAtEnd(ctx);
+              }
             }
-          });
-        } else if (state.maintainingScrollAtEnd === pendingState) {
-          finishMaintainScrollAtEnd(ctx);
+          }
+        };
+        if (immediate) {
+          run();
+        } else {
+          requestAnimationFrame(run);
         }
-      });
+      } else {
+        state.pendingMaintainScrollAtEnd = true;
+      }
+      didMaintain = true;
     } else {
-      state.pendingMaintainScrollAtEnd = true;
+      finishMaintainScrollAtEnd(ctx);
     }
-    return true;
   }
-  finishMaintainScrollAtEnd(ctx);
-  return false;
+  return didMaintain;
 }
 
 // src/core/finishScrollTo.ts
@@ -2213,7 +2254,9 @@ function scrollTo(ctx, params) {
       pinScrollTargetRenderRange(ctx, targetOffset, scrollTarget.index);
     }
   }
-  state.scrollPending = targetOffset;
+  if (!animated || isInitialScroll) {
+    state.scrollPending = targetOffset;
+  }
   syncInitialScrollNativeWatchdog(state, { isInitialScroll, requestedOffset: offset, targetOffset });
   if (!isInitialScroll && !noScrollingTo && Math.abs(state.scroll - targetOffset) > 1) {
     if (animated) {
@@ -2590,13 +2633,13 @@ function rearmBootstrapInitialScroll(ctx, options) {
   queueBootstrapInitialScrollReevaluation(ctx.state);
 }
 function createInitialScrollAtEndTarget(options) {
-  const { dataLength, footerSize, preserveForFooterLayout, stylePaddingEnd } = options;
+  const { dataLength, footerSize, index, preserveForFooterLayout, stylePaddingEnd } = options;
   return {
     contentOffset: void 0,
-    index: Math.max(0, dataLength - 1),
+    index: index != null ? index : Math.max(0, dataLength - 1),
     preserveForBottomPadding: true,
     preserveForFooterLayout,
-    viewOffset: -stylePaddingEnd - footerSize,
+    viewOffset: getEndAlignedViewOffset(stylePaddingEnd, footerSize),
     viewPosition: 1
   };
 }
@@ -2612,13 +2655,14 @@ function isRetargetableBottomAlignedInitialScrollTarget(target) {
 function createRetargetedBottomAlignedInitialScroll(options) {
   const { dataLength, footerSize, initialScrollAtEnd, stylePaddingEnd, target } = options;
   const preserveForFooterLayout = shouldPreserveInitialScrollForFooterLayout(target);
+  const alignsToContentEnd = initialScrollAtEnd || isEndOfContentTarget(target, dataLength);
   return {
     ...target,
     contentOffset: void 0,
     index: initialScrollAtEnd ? Math.max(0, dataLength - 1) : target.index,
     preserveForBottomPadding: true,
     preserveForFooterLayout,
-    viewOffset: -stylePaddingEnd - (preserveForFooterLayout ? footerSize : 0),
+    viewOffset: getEndAlignedViewOffset(stylePaddingEnd, alignsToContentEnd ? footerSize : 0),
     viewPosition: 1
   };
 }
@@ -2632,7 +2676,7 @@ function clearPendingInitialScrollFooterLayout(ctx, options) {
   }
   const clearedFooterTarget = createInitialScrollAtEndTarget({
     dataLength,
-    footerSize: 0,
+    footerSize: peek$(ctx, "footerSize") || 0,
     preserveForFooterLayout: void 0,
     stylePaddingEnd
   });
@@ -2655,13 +2699,12 @@ function getObservedBootstrapInitialScrollOffset(state) {
   return typeof observedOffset === "number" && Number.isFinite(observedOffset) ? observedOffset : (_d = (_c = state.scrollPending) != null ? _c : state.scroll) != null ? _d : 0;
 }
 function getPreservedEndAnchorOffsetDiff(ctx) {
-  var _a3;
   const state = ctx.state;
   const initialScroll = state.initialScroll;
-  if (!state.didFinishInitialScroll || ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) || !initialScroll || initialScroll.viewPosition !== 1 || state.props.data.length === 0 || isOffsetInitialScrollSession(state)) {
+  if (!state.didFinishInitialScroll || state.scrollingTo || state.pendingScrollResolve || state.maintainingScrollAtEnd || state.isDragging || !initialScroll || initialScroll.viewPosition !== 1 || state.props.data.length === 0 || isOffsetInitialScrollSession(state)) {
     return;
   }
-  const currentOffset = typeof state.lastNativeScroll === "number" && Number.isFinite(state.lastNativeScroll) ? state.lastNativeScroll : getObservedBootstrapInitialScrollOffset(state);
+  const currentOffset = getObservedBootstrapInitialScrollOffset(state);
   return resolveInitialScrollOffset(ctx, initialScroll) - currentOffset;
 }
 function schedulePreservedEndAnchorCorrection(ctx) {
@@ -2689,6 +2732,9 @@ function schedulePreservedEndAnchorCorrectionFrame(ctx, correction) {
     const hasObservedNativeScrollAfterRequest = !activeCorrection.lastRequestTime || ((_a3 = state.lastNativeScrollTime) != null ? _a3 : 0) > activeCorrection.lastRequestTime;
     if (hasObservedNativeScrollAfterRequest) {
       activeCorrection.lastRequestTime = Date.now();
+      {
+        state.scroll = getObservedBootstrapInitialScrollOffset(state);
+      }
       requestAdjust(ctx, offsetDiff);
     }
     schedulePreservedEndAnchorCorrectionFrame(ctx, correction);
@@ -2811,10 +2857,10 @@ function handleBootstrapInitialScrollDataChange(ctx, options) {
 function handleBootstrapInitialScrollFooterLayout(ctx, options) {
   const { dataLength, footerSize, initialScrollAtEnd, stylePaddingEnd } = options;
   const state = ctx.state;
-  if (!initialScrollAtEnd) {
+  const initialScroll = state.initialScroll;
+  if (!initialScrollAtEnd && !isEndOfContentTarget(initialScroll, dataLength)) {
     return;
   }
-  const initialScroll = state.initialScroll;
   if (isOffsetInitialScrollSession(state) || dataLength === 0 || !initialScroll) {
     return;
   }
@@ -2832,6 +2878,7 @@ function handleBootstrapInitialScrollFooterLayout(ctx, options) {
     const updatedInitialScroll = createInitialScrollAtEndTarget({
       dataLength,
       footerSize,
+      index: initialScrollAtEnd ? void 0 : initialScroll.index,
       preserveForFooterLayout: shouldPreserveInitialScrollForFooterLayout(initialScroll),
       stylePaddingEnd
     });
@@ -3303,6 +3350,7 @@ function handleInitialScrollDataChange(ctx, options) {
 
 // src/core/resetLayoutCachesForDataChange.ts
 function resetLayoutCachesForDataChange(state) {
+  state.positionsAreCurrent = false;
   state.indexByKey.clear();
   state.idCache.length = 0;
   state.positions.length = 0;
@@ -3583,7 +3631,7 @@ function updateItemPositions(ctx, dataChanged, {
   scrollBottomBuffered: -1,
   startIndex: 0
 }) {
-  var _a3, _b, _c, _d, _e;
+  var _a3, _b, _c, _d, _e, _f;
   const state = ctx.state;
   const hasPositionListeners = ctx.positionListeners.size > 0;
   const {
@@ -3599,6 +3647,11 @@ function updateItemPositions(ctx, dataChanged, {
   const dataLength = data.length;
   const numColumns = (_a3 = peek$(ctx, "numColumns")) != null ? _a3 : 1;
   const hasColumns = numColumns > 1;
+  const canReuseEstimates = !doMVCP || !state.didContainersLayout && Object.keys(state.averageSizes).length === 0;
+  if (state.positionsAreCurrent && !dataChanged && !forceFullUpdate && state.positionRecalculationStartIndex === void 0 && !scrollingTo && !hasColumns && !snapToIndices && positions.length === dataLength && canReuseEstimates) {
+    return;
+  }
+  state.positionsAreCurrent = false;
   const indexByKeyForChecking = IS_DEV ? /* @__PURE__ */ new Map() : void 0;
   const extraData = peek$(ctx, "extraData");
   const layoutConfig = overrideItemLayout ? { span: 1 } : void 0;
@@ -3713,6 +3766,10 @@ function updateItemPositions(ctx, dataChanged, {
   }
   if (!didBreakEarly) {
     updateTotalSize(ctx);
+    state.positionsAreCurrent = !hasColumns;
+    if (startIndex <= ((_f = state.positionRecalculationStartIndex) != null ? _f : -1)) {
+      state.positionRecalculationStartIndex = void 0;
+    }
   }
   if (snapToIndices) {
     updateSnapToOffsets(ctx);
@@ -3981,7 +4038,7 @@ function getExpandedContainerPoolSize(dataLength, numContainers) {
 }
 
 // src/utils/findAvailableContainers.ts
-function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, getRequiredItemType, protectedKeys) {
+function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, protectedKeys, reverseItemOrder = false) {
   var _a3;
   const numNeeded = needNewContainers.length;
   if (numNeeded === 0) {
@@ -3990,16 +4047,27 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
   const numContainers = peek$(ctx, "numContainers");
   const state = ctx.state;
   const { containerItemMetadata, stickyContainerPool } = state;
+  const { data, getItemType } = state.props;
+  const hasItemTypes = !!getItemType;
   const shouldAvoidAssignedContainerReuse = state.props.recycleItems && !!state.props.positionComponentInternal;
   const pendingRemovalSet = pendingRemoval.length > 0 ? new Set(pendingRemoval) : void 0;
-  const requests = needNewContainers.map((itemIndex, order) => ({
-    isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
-    itemIndex,
-    itemType: getRequiredItemType == null ? void 0 : getRequiredItemType(itemIndex),
-    order
-  }));
-  const normalRequests = requests.filter((request) => !request.isSticky);
-  const stickyRequests = requests.filter((request) => request.isSticky);
+  const requests = new Array(numNeeded);
+  const normalRequests = [];
+  const stickyRequests = [];
+  for (let order = 0; order < numNeeded; order++) {
+    const itemIndex = needNewContainers[order];
+    const itemType = getItemType == null ? void 0 : getItemType(data[itemIndex], itemIndex);
+    const request = {
+      isBuffered: itemIndex >= startBuffered && itemIndex <= endBuffered,
+      isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
+      itemIndex,
+      itemType: hasItemTypes ? itemType !== void 0 ? String(itemType) : "" : void 0,
+      order,
+      renderPriority: reverseItemOrder ? -itemIndex : itemIndex
+    };
+    requests[order] = request;
+    (request.isSticky ? stickyRequests : normalRequests).push(request);
+  }
   const normalCandidates = [];
   const stickyCandidates = [];
   for (let containerIndex = 0; containerIndex < numContainers; containerIndex++) {
@@ -4055,7 +4123,7 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
     }
   };
   const assignFromPool = (pendingRequests, candidates, allowCrossType) => {
-    if (getRequiredItemType) {
+    if (hasItemTypes) {
       assignMatching(
         pendingRequests,
         candidates,
@@ -4079,6 +4147,11 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
     }
     assign(request, containerIndex);
   }
+  if (normalRequests.length > 1 || stickyRequests.length > 1) {
+    const containerIndices = [];
+    reorderPoolAssignments(normalRequests, allocations, containerIndices, hasItemTypes);
+    reorderPoolAssignments(stickyRequests, allocations, containerIndices, hasItemTypes);
+  }
   if (pendingRemovalChanged) {
     pendingRemoval.length = 0;
     if (pendingRemovalSet) {
@@ -4108,12 +4181,53 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
 function comparatorByDistance(a, b) {
   return b.distance - a.distance;
 }
+function comparatorByRenderPriority(a, b) {
+  return Number(b.isBuffered) - Number(a.isBuffered) || a.renderPriority - b.renderPriority;
+}
+function comparatorByIndex(a, b) {
+  return a - b;
+}
+function reorderPoolAssignments(requests, allocations, containerIndices, groupByType) {
+  if (requests.length >= 2) {
+    if (groupByType) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const request of requests) {
+        const group = groups.get(request.itemType);
+        if (group) {
+          group.push(request);
+        } else {
+          groups.set(request.itemType, [request]);
+        }
+      }
+      for (const group of groups.values()) {
+        reorderPoolAssignments(group, allocations, containerIndices, false);
+      }
+    } else {
+      containerIndices.length = 0;
+      let indicesSorted = true;
+      for (let i = 0; i < requests.length; i++) {
+        const containerIndex = allocations[requests[i].order].containerIndex;
+        if (i > 0 && containerIndex < containerIndices[i - 1]) {
+          indicesSorted = false;
+        }
+        containerIndices.push(containerIndex);
+      }
+      if (!indicesSorted) {
+        containerIndices.sort(comparatorByIndex);
+      }
+      requests.sort(comparatorByRenderPriority);
+      for (let i = 0; i < requests.length; i++) {
+        allocations[requests[i].order].containerIndex = containerIndices[i];
+      }
+    }
+  }
+}
 
 // src/utils/setDidLayout.ts
 function setDidLayout(ctx) {
   const state = ctx.state;
   state.queuedInitialLayout = true;
-  checkAtBottom(ctx);
+  checkThresholds(ctx);
   setInitialRenderState(ctx, { didLayout: true });
   if (state.pendingMaintainScrollAtEnd) {
     doMaintainScrollAtEnd(ctx);
@@ -4218,7 +4332,7 @@ function handleStickyRecycling(ctx, stickyArray, scroll, drawDistance, currentSt
 }
 function trackVisibleRange(range, i, top, size, scroll, scrollBottom) {
   let didPassVisibleEnd = false;
-  if (range.startNoBuffer === null && top + size > scroll) {
+  if (range.startNoBuffer === null && top + size > scroll && top <= scrollBottom) {
     range.startNoBuffer = i;
   }
   if (range.firstFullyOnScreenIndex === void 0 && top >= scroll - 10 && top <= scrollBottom) {
@@ -4284,7 +4398,7 @@ function findFirstVisibleIndexInCachedRange(ctx, scroll) {
   return null;
 }
 function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, scrollLength, scroll, scrollBottom) {
-  var _a3, _b;
+  var _a3, _b, _c, _d;
   const state = ctx.state;
   const {
     endBuffered,
@@ -4318,14 +4432,14 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
     startNoBuffer: visibleRange.startNoBuffer
   });
   maybeEmitFirstVisibleItemChanged(state, visibleRange.startNoBuffer);
-  if (visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
+  if (state.props.hasExternalScroll || visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
     updateViewableItems(
       state,
       ctx,
       viewabilityConfigCallbackPairs,
       scrollLength,
-      visibleRange.startNoBuffer,
-      visibleRange.endNoBuffer,
+      (_c = visibleRange.startNoBuffer) != null ? _c : 0,
+      (_d = visibleRange.endNoBuffer) != null ? _d : -1,
       startBuffered,
       endBuffered
     );
@@ -4334,16 +4448,16 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
   batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
     const {
       columns,
       containerItemKeys,
       enableScrollForNextCalculateItemsInView,
       idCache,
       indexByKey,
-      minIndexSizeChanged,
+      positionRecalculationStartIndex,
       positions,
-      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, getItemType, keyExtractor, onStickyHeaderChange },
+      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, keyExtractor, onStickyHeaderChange },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -4386,7 +4500,7 @@ function calculateItemsInView(ctx, params = {}) {
       scrollAdjustPending = (_a4 = peek$(ctx, "scrollAdjustPending")) != null ? _a4 : 0;
       scrollAdjustPad = scrollAdjustPending - topPad;
       scroll = Math.round(nextScrollState + scrollExtra + scrollAdjustPad);
-      if (scroll + scrollLength > totalSize) {
+      if (!state.props.hasExternalScroll && scroll + scrollLength > totalSize) {
         scroll = Math.max(0, totalSize - scrollLength);
       }
     };
@@ -4413,7 +4527,11 @@ function calculateItemsInView(ctx, params = {}) {
     let stickyState = dataChanged ? void 0 : resolveStickyState();
     let scrollBufferTop = drawDistance;
     let scrollBufferBottom = drawDistance;
-    if (speed > 0 || speed === 0 && scroll < Math.max(50, drawDistance)) {
+    if (speed !== 0) {
+      state.scrollBufferDirection = speed > 0 ? 1 : -1;
+    }
+    const bufferForward = state.scrollBufferDirection === 1 || state.scrollBufferDirection === void 0 && scroll < Math.max(50, drawDistance);
+    if (bufferForward) {
       scrollBufferTop = drawDistance * 0.5;
       scrollBufferBottom = drawDistance * 1.5;
     } else {
@@ -4423,8 +4541,8 @@ function calculateItemsInView(ctx, params = {}) {
     const shouldProjectRenderRange = !dataChanged && !forceFullItemPositions && !suppressInitialScrollSideEffects && !hasActiveInitialScroll(state) && !state.scrollingTo && !state.pendingNativeMVCPAdjust && !!peek$(ctx, "readyToRender");
     const projectedBufferAdjustment = shouldProjectRenderRange ? getProjectedBufferAdjustment(speed, Math.min(scrollBufferTop, scrollBufferBottom)) : 0;
     const updateScrollRange = () => {
-      const scrollStart = Math.max(0, scroll);
-      const overscrollBeforeContent = Math.max(0, -nativeScrollState);
+      const scrollStart = state.props.hasExternalScroll ? scroll : Math.max(0, scroll);
+      const overscrollBeforeContent = state.props.hasExternalScroll ? 0 : Math.max(0, -nativeScrollState);
       scrollBottom = Math.max(scrollStart, scroll + scrollLength + overscrollBeforeContent);
       scrollTopBuffered = scrollStart - scrollBufferTop + projectedBufferAdjustment;
       scrollBottomBuffered = scrollBottom + scrollBufferBottom + projectedBufferAdjustment;
@@ -4459,21 +4577,21 @@ function calculateItemsInView(ctx, params = {}) {
     if (dataChanged) {
       resetLayoutCachesForDataChange(state);
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _e : 0;
-    const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && minIndexSizeChanged !== void 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = positionRecalculationStartIndex != null ? positionRecalculationStartIndex : state.startBuffered) != null ? _e : 0;
+    const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && positionRecalculationStartIndex !== void 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
       // A changed size shifts every following position. The scrolling early-exit
       // would leave the untouched suffix in the old coordinate space.
-      forceFullUpdate: !!forceFullItemPositions || minIndexSizeChanged !== void 0,
+      forceFullUpdate: !!forceFullItemPositions || positionRecalculationStartIndex !== void 0,
       optimizeForVisibleWindow,
       scrollBottomBuffered,
       scrollVelocity: speed,
       startIndex
     });
     totalSize = getContentSize(ctx);
-    if (minIndexSizeChanged !== void 0) {
-      state.minIndexSizeChanged = void 0;
+    if (positionRecalculationStartIndex !== void 0) {
+      state.positionRecalculationStartIndex = void 0;
     }
     let protectedContainerKeys;
     if (dataChanged && doMVCP && state.props.maintainVisibleContentPosition.data && state.didContainersLayout && state.idsInView.length > 0) {
@@ -4553,7 +4671,7 @@ function calculateItemsInView(ctx, params = {}) {
             nextTop = top;
           }
         }
-        if (visibleRange.startNoBuffer !== null) {
+        if (startBuffered !== null) {
           if (top <= scrollBottomBuffered) {
             endBuffered = i;
             if (scrollBottomBuffered > totalSize) {
@@ -4564,6 +4682,8 @@ function calculateItemsInView(ctx, params = {}) {
           } else {
             foundEnd = true;
           }
+        } else if (top > scrollBottomBuffered) {
+          foundEnd = true;
         }
       }
     }
@@ -4581,6 +4701,12 @@ function calculateItemsInView(ctx, params = {}) {
         bottom: nextBottom,
         top: nextTop
       };
+    } else if (enableScrollForNextCalculateItemsInView && state.props.hasExternalScroll) {
+      if (scrollBottomBuffered < 0) {
+        state.scrollForNextCalculateItemsInView = { bottom: 0, top: null };
+      } else if (scrollTopBuffered > totalSize) {
+        state.scrollForNextCalculateItemsInView = { bottom: null, top: totalSize };
+      }
     }
     let numContainers = prevNumContainers;
     const pendingRemoval = [];
@@ -4604,7 +4730,9 @@ function calculateItemsInView(ctx, params = {}) {
     }
     const hasScrollTargetPinnedRange = scrollTargetPinnedStart <= scrollTargetPinnedEnd;
     const isPinnedRenderIndex = (index) => alwaysRenderIndicesSet.has(index) || hasScrollTargetPinnedRange && index >= scrollTargetPinnedStart && index <= scrollTargetPinnedEnd;
-    if (startBuffered !== null && endBuffered !== null) {
+    if (startBuffered !== null && endBuffered !== null || alwaysRenderIndicesArr.length || hasScrollTargetPinnedRange) {
+      const allocationStart = startBuffered != null ? startBuffered : 0;
+      const allocationEnd = endBuffered != null ? endBuffered : -1;
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
       const addPinnedIndex = (index) => {
@@ -4620,7 +4748,7 @@ function calculateItemsInView(ctx, params = {}) {
           }
         }
       };
-      for (let i = startBuffered; i <= endBuffered; i++) {
+      for (let i = allocationStart; i <= allocationEnd; i++) {
         const id = (_m = idCache[i]) != null ? _m : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainersSet.add(i);
@@ -4642,25 +4770,25 @@ function calculateItemsInView(ctx, params = {}) {
           (_n = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _n : -1,
           needNewContainers,
           needNewContainersSet,
-          startBuffered,
-          endBuffered
+          allocationStart,
+          allocationEnd
         );
       } else if (previousStickyIndex !== -1) {
         set$(ctx, "activeStickyIndex", -1);
       }
       if (needNewContainers.length > 0) {
-        const getRequiredItemType = getItemType ? (i) => {
-          const itemType = getItemType(data[i], i);
-          return itemType !== void 0 ? String(itemType) : "";
-        } : void 0;
         const availableContainerAllocations = findAvailableContainers(
           ctx,
           needNewContainers,
-          startBuffered,
-          endBuffered,
+          allocationStart,
+          allocationEnd,
           pendingRemoval,
-          getRequiredItemType,
-          protectedContainerKeys
+          protectedContainerKeys,
+          // Initial end alignment has no scroll velocity yet. Keep its
+          // target-side rows first until the initial scroll settles.
+          // After a pause velocity can be zero on the first movement;
+          // use its displacement without treating initial insets as motion.
+          hasActiveInitialScroll(state) ? (initialScroll == null ? void 0 : initialScroll.viewPosition) === 1 : (speed || (state.hasScrolled ? state.scroll - state.scrollPrev : 0)) < 0
         );
         for (const allocation of availableContainerAllocations) {
           const i = allocation.itemIndex;
@@ -4780,19 +4908,19 @@ function calculateItemsInView(ctx, params = {}) {
         handleInitialScrollLayoutReady(ctx);
       }
     }
-    if (viewabilityConfigCallbackPairs && visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
+    if (viewabilityConfigCallbackPairs && (state.props.hasExternalScroll || visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null)) {
       updateViewableItems(
         ctx.state,
         ctx,
         viewabilityConfigCallbackPairs,
         scrollLength,
-        visibleRange.startNoBuffer,
-        visibleRange.endNoBuffer,
-        startBuffered != null ? startBuffered : visibleRange.startNoBuffer,
-        endBuffered != null ? endBuffered : visibleRange.endNoBuffer
+        (_u = visibleRange.startNoBuffer) != null ? _u : 0,
+        (_v = visibleRange.endNoBuffer) != null ? _v : -1,
+        (_w = startBuffered != null ? startBuffered : visibleRange.startNoBuffer) != null ? _w : 0,
+        (_x = endBuffered != null ? endBuffered : visibleRange.endNoBuffer) != null ? _x : -1
       );
     }
-    (_u = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _u.call(stickyState);
+    (_y = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _y.call(stickyState);
   });
 }
 
@@ -4943,6 +5071,7 @@ function updateItemSizesBatch(ctx, measurements) {
   var _a3;
   const state = ctx.state;
   const result = {};
+  const previousTotalSize = state.totalSize;
   for (const measurement of measurements) {
     const ownsMeasuredItem = measurement.containerId === void 0 || peek$(ctx, `containerItemKey${measurement.containerId}`) === measurement.itemKey;
     if (ownsMeasuredItem) {
@@ -4953,6 +5082,9 @@ function updateItemSizesBatch(ctx, measurements) {
       mergeItemSizeUpdateResult(result, nextResult);
     }
   }
+  if (state.totalSize !== previousTotalSize) {
+    set$(ctx, "totalSize", state.totalSize);
+  }
   flushItemSizeUpdates(ctx, result);
 }
 function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
@@ -4991,12 +5123,12 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
   }
   let needsRecalculate = !didContainersLayout;
   let shouldMaintainScrollAtEnd = false;
-  let minIndexSizeChanged;
+  let positionRecalculationStartIndex;
   const prevSizeKnown = state.sizesKnown.get(itemKey);
-  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem);
+  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, false);
   const size = roundSize(horizontal ? sizeObj.width : sizeObj.height);
   if (diff !== 0) {
-    minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+    positionRecalculationStartIndex = positionRecalculationStartIndex !== void 0 ? Math.min(positionRecalculationStartIndex, index) : index;
     const { startBuffered, endBuffered } = state;
     needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
     if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
@@ -5013,8 +5145,8 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
       size
     });
   }
-  if (minIndexSizeChanged !== void 0) {
-    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
+  if (positionRecalculationStartIndex !== void 0) {
+    state.positionRecalculationStartIndex = state.positionRecalculationStartIndex !== void 0 ? Math.min(state.positionRecalculationStartIndex, positionRecalculationStartIndex) : positionRecalculationStartIndex;
   }
   updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
   if (didContainersLayout || checkAllSizesKnown(state, state.startBuffered, state.endBuffered)) {
@@ -5031,7 +5163,7 @@ function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     didMeasureUserScrollAnchorResetItem
   };
 }
-function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
+function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, notifyTotalSize = true) {
   var _a3, _b;
   const state = ctx.state;
   const {
@@ -5054,10 +5186,20 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     fixedItemSize,
     itemType
   } : void 0;
-  const prevSize = getItemSize(ctx, itemKey, index, itemData, void 0, void 0, void 0, resolvedItemSize);
+  const prevSize = getItemSize(
+    ctx,
+    itemKey,
+    index,
+    itemData,
+    void 0,
+    void 0,
+    notifyTotalSize,
+    resolvedItemSize
+  );
   const rawSize = horizontal ? sizeObj.width : sizeObj.height;
   const prevSizeKnown = sizesKnown.get(itemKey);
   const size = Math.round(rawSize) ;
+  if (prevSizeKnown !== size) state.positionsAreCurrent = false;
   sizesKnown.set(itemKey, size);
   if (fixedItemSize === void 0 && size > 0) {
     itemType != null ? itemType : itemType = getItemType ? (_b = getItemType(itemData, index)) != null ? _b : "" : "";
@@ -5076,7 +5218,7 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
     }
   }
   if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-    setSize(ctx, itemKey, size);
+    setSize(ctx, itemKey, size, notifyTotalSize);
     return size - prevSize;
   }
   return 0;
@@ -5478,10 +5620,19 @@ function useOnLayoutSync({
   measureInLayoutEffect = true,
   onLayoutProp,
   onLayoutChange,
-  webLayoutResync
+  webLayoutResync,
+  webExternalScroll = false
 }, deps) {
+  const onExternalLayout = useCallback(
+    (event) => {
+      onLayoutChange(event.nativeEvent.layout, false);
+      onLayoutProp == null ? void 0 : onLayoutProp(event);
+    },
+    [onLayoutChange, onLayoutProp]
+  );
   useLayoutEffect(() => {
     var _a3, _b;
+    if (webExternalScroll) return;
     const current = ref.current;
     const scrollableNode = (_b = (_a3 = current == null ? void 0 : current.getScrollableNode) == null ? void 0 : _a3.call(current)) != null ? _b : null;
     const element = scrollableNode || current;
@@ -5519,8 +5670,8 @@ function useOnLayoutSync({
         emit(toLayout(rectObserved), false);
       }
     });
-  }, [measureInLayoutEffect, ...deps || []]);
-  return {};
+  }, [measureInLayoutEffect, webExternalScroll, ...deps || []]);
+  return webExternalScroll ? { onLayout: onExternalLayout } : {};
 }
 function toLayout(rect) {
   if (!rect) {
@@ -6082,94 +6233,121 @@ function useRafCoalescer(callback) {
   return coalescer;
 }
 
-// src/components/webConstants.ts
-var LEGEND_LIST_CONTENT_CONTAINER_CLASS = "legend-list-content-container";
-var LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS = "legend-list-scrollbar-x-hidden";
-var LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS = "legend-list-scrollbar-y-hidden";
-
 // src/components/webScrollUtils.ts
-function getDocumentScrollerNode() {
-  if (typeof document === "undefined") {
-    return null;
-  }
-  return document.scrollingElement || document.documentElement || document.body;
+function isWindowTarget(target) {
+  return typeof window !== "undefined" && target === window;
 }
-function getWindowScrollPosition() {
-  var _a3, _b, _c, _d;
-  if (typeof window === "undefined") {
-    return { x: 0, y: 0 };
+function getScrollPosition(target) {
+  var _a3, _b, _c, _d, _e, _f;
+  if (isWindowTarget(target)) {
+    return { x: (_b = (_a3 = target.scrollX) != null ? _a3 : target.pageXOffset) != null ? _b : 0, y: (_d = (_c = target.scrollY) != null ? _c : target.pageYOffset) != null ? _d : 0 };
   }
-  return {
-    x: (_b = (_a3 = window.scrollX) != null ? _a3 : window.pageXOffset) != null ? _b : 0,
-    y: (_d = (_c = window.scrollY) != null ? _c : window.pageYOffset) != null ? _d : 0
-  };
+  return { x: (_e = target == null ? void 0 : target.scrollLeft) != null ? _e : 0, y: (_f = target == null ? void 0 : target.scrollTop) != null ? _f : 0 };
 }
-function getElementDocumentPosition(element, scroll) {
-  var _a3, _b;
+function getElementScrollPosition(element, target) {
+  var _a3, _b, _c, _d, _e, _f;
   const rect = element == null ? void 0 : element.getBoundingClientRect();
+  const scroll = getScrollPosition(target);
+  const parent = target && !isWindowTarget(target) ? target : null;
+  const parentRect = parent == null ? void 0 : parent.getBoundingClientRect();
   return {
-    left: ((_a3 = rect == null ? void 0 : rect.left) != null ? _a3 : 0) + scroll.x,
-    top: ((_b = rect == null ? void 0 : rect.top) != null ? _b : 0) + scroll.y
+    left: ((_a3 = rect == null ? void 0 : rect.left) != null ? _a3 : 0) - ((_b = parentRect == null ? void 0 : parentRect.left) != null ? _b : 0) - ((_c = parent == null ? void 0 : parent.clientLeft) != null ? _c : 0) + scroll.x,
+    top: ((_d = rect == null ? void 0 : rect.top) != null ? _d : 0) - ((_e = parentRect == null ? void 0 : parentRect.top) != null ? _e : 0) - ((_f = parent == null ? void 0 : parent.clientTop) != null ? _f : 0) + scroll.y
   };
 }
 function getContentSize2(content) {
   var _a3, _b;
-  return {
-    height: (_a3 = content == null ? void 0 : content.scrollHeight) != null ? _a3 : 0,
-    width: (_b = content == null ? void 0 : content.scrollWidth) != null ? _b : 0
-  };
+  return { height: (_a3 = content == null ? void 0 : content.scrollHeight) != null ? _a3 : 0, width: (_b = content == null ? void 0 : content.scrollWidth) != null ? _b : 0 };
 }
-function getScrollContentSize(scrollElement, contentElement, isWindowScroll) {
-  return getContentSize2(isWindowScroll ? contentElement : scrollElement);
+function getScrollContentSize(scrollElement, contentElement, externalTarget) {
+  return getContentSize2(externalTarget !== void 0 ? contentElement : scrollElement);
 }
-function getLayoutMeasurement(scrollElement, isWindowScroll, horizontal) {
-  var _a3, _b, _c, _d, _e, _f;
-  if (isWindowScroll && typeof window !== "undefined") {
+function getLayoutMeasurement(scrollElement, externalTarget, horizontal) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
+  if (externalTarget !== void 0) {
     const rect = scrollElement == null ? void 0 : scrollElement.getBoundingClientRect();
+    const viewport = isWindowTarget(externalTarget) ? { height: externalTarget.innerHeight, width: externalTarget.innerWidth } : { height: (_a3 = externalTarget == null ? void 0 : externalTarget.clientHeight) != null ? _a3 : 0, width: (_b = externalTarget == null ? void 0 : externalTarget.clientWidth) != null ? _b : 0 };
     return {
-      // In window-scroll mode, use viewport size on the scroll axis.
-      height: horizontal ? (_b = (_a3 = rect == null ? void 0 : rect.height) != null ? _a3 : scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _b : window.innerHeight : window.innerHeight,
-      // Keep the cross-axis size list-relative to avoid inflating container measurements.
-      width: horizontal ? window.innerWidth : (_d = (_c = rect == null ? void 0 : rect.width) != null ? _c : scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _d : window.innerWidth
+      height: horizontal ? (_d = (_c = rect == null ? void 0 : rect.height) != null ? _c : scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _d : 0 : viewport.height,
+      width: horizontal ? viewport.width : (_f = (_e = rect == null ? void 0 : rect.width) != null ? _e : scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _f : 0
     };
   }
-  return {
-    height: (_e = scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _e : 0,
-    width: (_f = scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _f : 0
-  };
+  return { height: (_g = scrollElement == null ? void 0 : scrollElement.clientHeight) != null ? _g : 0, width: (_h = scrollElement == null ? void 0 : scrollElement.clientWidth) != null ? _h : 0 };
 }
 function clampOffset(offset, maxOffset) {
   return Math.max(0, Math.min(offset, maxOffset));
 }
-function getAxisSize(size, horizontal) {
-  return horizontal ? size.width : size.height;
-}
 function getMaxOffset(contentSize, layoutMeasurement, horizontal) {
-  return Math.max(0, getAxisSize(contentSize, horizontal) - getAxisSize(layoutMeasurement, horizontal));
+  const axis = horizontal ? "width" : "height";
+  return Math.max(0, contentSize[axis] - layoutMeasurement[axis]);
 }
-function resolveScrollableNode(scrollElement, isWindowScroll) {
-  return isWindowScroll ? getDocumentScrollerNode() || scrollElement : scrollElement;
+function resolveScrollableNode(scrollElement, externalTarget) {
+  if (isWindowTarget(externalTarget)) {
+    return document.scrollingElement || document.documentElement || document.body;
+  }
+  return externalTarget === void 0 ? scrollElement : externalTarget;
 }
-function resolveScrollEventTarget(scrollElement, isWindowScroll) {
-  return isWindowScroll && typeof window !== "undefined" ? window : scrollElement;
+function resolveScrollEventTarget(scrollElement, externalTarget) {
+  return externalTarget === void 0 ? scrollElement : externalTarget;
 }
-function getLayoutRectangle(element, isWindowScroll, horizontal) {
-  const rect = element.getBoundingClientRect();
-  const scroll = getWindowScrollPosition();
-  return {
-    height: isWindowScroll && typeof window !== "undefined" && !horizontal ? window.innerHeight : rect.height,
-    width: isWindowScroll && typeof window !== "undefined" && horizontal ? window.innerWidth : rect.width,
-    x: isWindowScroll ? rect.left + scroll.x : rect.left,
-    y: isWindowScroll ? rect.top + scroll.y : rect.top
-  };
+function getLayoutRectangle(element, externalTarget, horizontal) {
+  if (externalTarget === void 0) {
+    const rect = element.getBoundingClientRect();
+    return { height: rect.height, width: rect.width, x: rect.left, y: rect.top };
+  }
+  const { left, top } = getElementScrollPosition(element, externalTarget);
+  const { height, width } = getLayoutMeasurement(element, externalTarget, horizontal);
+  return { height, width, x: left, y: top };
 }
-function resolveWindowScrollTarget({ clampedOffset, horizontal, listPos, scroll }) {
+function resolveExternalScrollOffset({
+  clampedOffset,
+  horizontal,
+  listPos,
+  scroll
+}) {
   return {
     left: horizontal ? listPos.left + clampedOffset : scroll.x,
     top: horizontal ? scroll.y : listPos.top + clampedOffset
   };
 }
 
+// src/components/observeScrollLayout.ts
+function observeScrollLayout(element, owner, onLayout) {
+  if (owner === null) return;
+  const resizeObserver = new ResizeObserver(onLayout);
+  const mutationObserver = owner === void 0 ? void 0 : new MutationObserver(observe);
+  function observe() {
+    resizeObserver.disconnect();
+    mutationObserver == null ? void 0 : mutationObserver.disconnect();
+    resizeObserver.observe(element);
+    if (owner !== void 0) {
+      for (let node = element; node && node !== owner; node = node.parentElement) {
+        const parent = node.parentElement;
+        if (parent) {
+          resizeObserver.observe(parent);
+          mutationObserver == null ? void 0 : mutationObserver.observe(parent, { childList: true });
+        }
+        for (let sibling = node.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+          resizeObserver.observe(sibling);
+        }
+      }
+    }
+    onLayout();
+  }
+  observe();
+  if (isWindowTarget(owner)) owner.addEventListener("resize", onLayout);
+  return () => {
+    resizeObserver.disconnect();
+    mutationObserver == null ? void 0 : mutationObserver.disconnect();
+    if (isWindowTarget(owner)) owner.removeEventListener("resize", onLayout);
+  };
+}
+
+// src/components/webConstants.ts
+var LEGEND_LIST_CONTENT_CONTAINER_CLASS = "legend-list-content-container";
+var LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS = "legend-list-scrollbar-x-hidden";
+var LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS = "legend-list-scrollbar-y-hidden";
+
 // src/components/ListComponentScrollView.tsx
 var SCROLLBAR_HIDDEN_STYLE_ID = "legend-list-scrollbar-axis-hidden-style";
 var SCROLL_END_FALLBACK_MS = 200;
@@ -6228,6 +6406,7 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
   showsVerticalScrollIndicator = true,
   refreshControl,
   useWindowScroll = false,
+  scrollElement: externalScrollElement,
   onLayout,
   ...props
 }, ref) {
@@ -6236,31 +6415,38 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
   const [anchoredEndSpaceSize] = useArr$(["anchoredEndSpaceSize"]);
   const scrollRef = useRef(null);
   const contentRef = useRef(null);
-  const isWindowScroll = useWindowScroll;
+  const externalTarget = externalScrollElement === void 0 && useWindowScroll ? typeof window === "undefined" ? null : window : externalScrollElement;
+  const isWindowScroll = isWindowTarget(externalTarget);
+  const isExternalScroll = externalTarget !== void 0;
   const getScrollTarget = useCallback(
-    () => resolveScrollEventTarget(scrollRef.current, isWindowScroll),
-    [isWindowScroll]
+    () => resolveScrollEventTarget(scrollRef.current, externalTarget),
+    [externalTarget]
   );
   const getMaxScrollOffset = useCallback(() => {
     const scrollElement = scrollRef.current;
-    const contentSize = getScrollContentSize(scrollElement, contentRef.current, isWindowScroll);
-    const layoutMeasurement = getLayoutMeasurement(scrollElement, isWindowScroll, horizontal);
+    const contentSize = getScrollContentSize(scrollElement, contentRef.current, externalTarget);
+    const layoutMeasurement = getLayoutMeasurement(scrollElement, externalTarget, horizontal);
     return getMaxOffset(contentSize, layoutMeasurement, horizontal);
-  }, [horizontal, isWindowScroll]);
+  }, [externalTarget, horizontal]);
+  const getRawScrollOffset = useCallback(() => {
+    var _a4;
+    const element = scrollRef.current;
+    if (isExternalScroll) {
+      const scroll = getScrollPosition(externalTarget);
+      const listPos = getElementScrollPosition(element, externalTarget);
+      return horizontal ? scroll.x - listPos.left : scroll.y - listPos.top;
+    }
+    return (_a4 = horizontal ? element == null ? void 0 : element.scrollLeft : element == null ? void 0 : element.scrollTop) != null ? _a4 : 0;
+  }, [externalTarget, horizontal, isExternalScroll]);
+  const isScrollInRange = useCallback(() => {
+    if (!isExternalScroll) return true;
+    const offset = getRawScrollOffset();
+    return offset >= -1 && offset <= getMaxScrollOffset() + 1;
+  }, [getMaxScrollOffset, getRawScrollOffset, isExternalScroll]);
   const getCurrentScrollOffset = useCallback(() => {
-    const scrollElement = scrollRef.current;
-    if (isWindowScroll) {
-      const maxOffset = getMaxScrollOffset();
-      const scroll = getWindowScrollPosition();
-      const listPos = getElementDocumentPosition(scrollElement, scroll);
-      const rawOffset = horizontal ? scroll.x - listPos.left : scroll.y - listPos.top;
-      return clampOffset(rawOffset, maxOffset);
-    }
-    if (!scrollElement) {
-      return 0;
-    }
-    return horizontal ? scrollElement.scrollLeft : scrollElement.scrollTop;
-  }, [getMaxScrollOffset, horizontal, isWindowScroll]);
+    const offset = getRawScrollOffset();
+    return isExternalScroll ? clampOffset(offset, getMaxScrollOffset()) : offset;
+  }, [getMaxScrollOffset, getRawScrollOffset, isExternalScroll]);
   const scrollToLocalOffset = useCallback(
     (offset, animated) => {
       const scrollElement = scrollRef.current;
@@ -6272,10 +6458,10 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       const clampedOffset = clampOffset(offset, maxOffset);
       const behavior = animated ? "smooth" : "auto";
       const options = { behavior };
-      if (isWindowScroll) {
-        const scroll = getWindowScrollPosition();
-        const listPos = getElementDocumentPosition(scrollElement, scroll);
-        const { left, top } = resolveWindowScrollTarget({
+      if (isExternalScroll) {
+        const scroll = getScrollPosition(externalTarget);
+        const listPos = getElementScrollPosition(scrollElement, externalTarget);
+        const { left, top } = resolveExternalScrollOffset({
           clampedOffset,
           horizontal,
           listPos,
@@ -6290,7 +6476,7 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       }
       target.scrollTo(options);
     },
-    [getMaxScrollOffset, getScrollTarget, horizontal, isWindowScroll]
+    [externalTarget, getMaxScrollOffset, getScrollTarget, horizontal, isExternalScroll]
   );
   useImperativeHandle(ref, () => {
     const api = {
@@ -6298,11 +6484,14 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
         var _a4;
         return (_a4 = scrollRef.current) == null ? void 0 : _a4.getBoundingClientRect();
       },
+      getContentNode: () => contentRef.current,
       getCurrentScrollOffset,
       getMaxScrollOffset,
-      getScrollableNode: () => resolveScrollableNode(scrollRef.current, isWindowScroll),
-      getScrollEventTarget: () => getScrollTarget(),
-      getScrollResponder: () => resolveScrollableNode(scrollRef.current, isWindowScroll),
+      getRawScrollOffset,
+      getScrollableNode: () => resolveScrollableNode(scrollRef.current, externalTarget),
+      getScrollEventTarget: getScrollTarget,
+      getScrollResponder: () => resolveScrollableNode(scrollRef.current, externalTarget),
+      isScrollInRange,
       isWindowScroll: () => isWindowScroll,
       scrollBy: (x, y) => {
         const target = getScrollTarget();
@@ -6326,14 +6515,24 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       }
     };
     return api;
-  }, [getCurrentScrollOffset, getMaxScrollOffset, getScrollTarget, horizontal, isWindowScroll, scrollToLocalOffset]);
+  }, [
+    externalTarget,
+    getCurrentScrollOffset,
+    getRawScrollOffset,
+    getMaxScrollOffset,
+    isScrollInRange,
+    getScrollTarget,
+    horizontal,
+    isWindowScroll,
+    scrollToLocalOffset
+  ]);
   const emitScroll = useCallback(() => {
     if (!onScroll2 || !scrollRef.current) {
       return;
     }
     const contentSize = getContentSize2(contentRef.current);
-    const layoutMeasurement = getLayoutMeasurement(scrollRef.current, isWindowScroll, horizontal);
-    const offset = getCurrentScrollOffset();
+    const layoutMeasurement = getLayoutMeasurement(scrollRef.current, externalTarget, horizontal);
+    const offset = getRawScrollOffset();
     const scrollEvent = {
       nativeEvent: {
         contentOffset: {
@@ -6351,7 +6550,7 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       }
     };
     onScroll2(scrollEvent);
-  }, [getCurrentScrollOffset, horizontal, isWindowScroll, onScroll2]);
+  }, [externalTarget, getRawScrollOffset, horizontal, onScroll2]);
   const scrollEventCoalescer = useRafCoalescer(emitScroll);
   const scrollEndFallbackRef = useRef(void 0);
   const emitScrollEnd = useCallback(() => {
@@ -6413,14 +6612,14 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       const delta = horizontal ? event.deltaX || (event.shiftKey ? event.deltaY : 0) : event.deltaY;
       if (delta < 0 && !event.ctrlKey && !event.defaultPrevented && (ctx.state.maintainingScrollAtEnd || ctx.state.pendingMaintainScrollAtEnd)) {
         const offset = getCurrentScrollOffset();
-        if (interruptMaintainScrollAtEnd(ctx)) {
+        if (interruptMaintainScrollAtEnd(ctx) && isScrollInRange()) {
           scrollToLocalOffset(offset, false);
         }
       }
     };
     target.addEventListener("wheel", onWheel, { passive: true });
     return () => target.removeEventListener("wheel", onWheel);
-  }, [ctx, getCurrentScrollOffset, getScrollTarget, horizontal, scrollToLocalOffset]);
+  }, [ctx, getCurrentScrollOffset, getScrollTarget, horizontal, isScrollInRange, scrollToLocalOffset]);
   useEffect(() => {
     const doScroll = () => {
       if (contentOffset) {
@@ -6428,44 +6627,28 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       }
     };
     doScroll();
-    requestAnimationFrame(doScroll);
+    const frame = requestAnimationFrame(doScroll);
+    return () => cancelAnimationFrame(frame);
   }, [contentOffset == null ? void 0 : contentOffset.x, contentOffset == null ? void 0 : contentOffset.y, horizontal, scrollToLocalOffset]);
   useLayoutEffect(() => {
-    if (!onLayout || !scrollRef.current) return;
     const element = scrollRef.current;
-    const fireLayout = () => {
-      onLayout({
-        nativeEvent: {
-          layout: getLayoutRectangle(element, isWindowScroll, horizontal)
-        }
-      });
-    };
-    fireLayout();
-    const resizeObserver = new ResizeObserver(() => {
-      fireLayout();
-    });
-    resizeObserver.observe(element);
-    const onWindowResize = () => {
-      fireLayout();
-    };
-    if (isWindowScroll && typeof window !== "undefined" && typeof window.addEventListener === "function") {
-      window.addEventListener("resize", onWindowResize);
-    }
-    return () => {
-      resizeObserver.disconnect();
-      if (isWindowScroll && typeof window !== "undefined" && typeof window.removeEventListener === "function") {
-        window.removeEventListener("resize", onWindowResize);
+    if (!onLayout || !element) return;
+    return observeScrollLayout(element, externalTarget, () => {
+      if (isExternalScroll && !ctx.state.lastLayout && !ctx.state.initialScroll) {
+        ctx.state.scroll = ctx.state.scrollPending = getRawScrollOffset();
       }
-    };
-  }, [isWindowScroll, onLayout]);
-  const hiddenScrollIndicatorClassName = !isWindowScroll && (horizontal ? !showsHorizontalScrollIndicator && LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS : !showsVerticalScrollIndicator && LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS);
+      onLayout({ nativeEvent: { layout: getLayoutRectangle(element, externalTarget, horizontal) } });
+      if (isExternalScroll) emitScroll();
+    });
+  }, [ctx, emitScroll, externalTarget, getRawScrollOffset, horizontal, isExternalScroll, onLayout]);
+  const hiddenScrollIndicatorClassName = !isExternalScroll && (horizontal ? !showsHorizontalScrollIndicator && LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS : !showsVerticalScrollIndicator && LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS);
   useLayoutEffect(() => {
     if (hiddenScrollIndicatorClassName) {
       ensureScrollbarHiddenStyle();
     }
   }, [hiddenScrollIndicatorClassName]);
   const scrollViewStyle = {
-    ...isWindowScroll ? {} : {
+    ...isExternalScroll ? {} : {
       overflow: "auto",
       overflowX: horizontal ? "auto" : showsHorizontalScrollIndicator ? "auto" : "hidden",
       overflowY: horizontal ? showsVerticalScrollIndicator ? "auto" : "hidden" : "auto",
@@ -6500,11 +6683,10 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
     scrollEventThrottle: _scrollEventThrottle,
     ScrollComponent: _ScrollComponent,
     snapToOffsets,
-    useWindowScroll: _useWindowScroll,
     className: scrollViewClassNameProp,
     ...webProps
   } = props;
-  const snapOffsets = !isWindowScroll ? getFiniteSnapOffsets(snapToOffsets) : [];
+  const snapOffsets = !isExternalScroll ? getFiniteSnapOffsets(snapToOffsets) : [];
   if (snapOffsets.length > 0) {
     scrollViewStyle.scrollSnapType = horizontal ? "x mandatory" : "y mandatory";
     contentStyle.position = (_c = contentStyle.position) != null ? _c : "relative";
@@ -6579,12 +6761,12 @@ function getScrollAdjustAxis(horizontal) {
   };
 }
 function getScrollAdjustTarget(ctx, contentNode) {
-  var _a3, _b, _c;
+  var _a3, _b, _c, _d, _e;
   const scrollView = (_a3 = ctx.state) == null ? void 0 : _a3.refScroller.current;
   const scrollElement = (_c = (_b = scrollView == null ? void 0 : scrollView.getScrollableNode) == null ? void 0 : _b.call(scrollView)) != null ? _c : null;
   let resolvedContentNode = null;
   if (scrollElement) {
-    resolvedContentNode = (contentNode == null ? void 0 : contentNode.isConnected) && contentNode.parentElement === scrollElement ? contentNode : scrollElement.querySelector(`:scope > .${LEGEND_LIST_CONTENT_CONTAINER_CLASS}`);
+    resolvedContentNode = (_e = (_d = scrollView == null ? void 0 : scrollView.getContentNode) == null ? void 0 : _d.call(scrollView)) != null ? _e : (contentNode == null ? void 0 : contentNode.isConnected) && contentNode.parentElement === scrollElement ? contentNode : scrollElement.querySelector(`:scope > .${LEGEND_LIST_CONTENT_CONTAINER_CLASS}`);
   }
   return scrollElement ? { contentNode: resolvedContentNode, scrollElement } : null;
 }
@@ -6599,6 +6781,7 @@ function ScrollAdjust() {
   const temporaryPaddingRef = React3.useRef(void 0);
   const contentNodeRef = React3.useRef(null);
   const callback = React3.useCallback(() => {
+    var _a3, _b, _c;
     const scrollAdjust = peek$(ctx, "scrollAdjust");
     const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
     const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
@@ -6609,17 +6792,21 @@ function ScrollAdjust() {
         const horizontal = !!ctx.state.props.horizontal;
         const axis = getScrollAdjustAxis(horizontal);
         const { contentNode, scrollElement: el } = target;
-        const currentScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        const scroller = ctx.state.refScroller.current;
+        const parentScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        const isExternal = ctx.state.props.hasExternalScroll;
+        const currentScroll = (_b = isExternal ? (_a3 = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _a3.call(scroller) : void 0) != null ? _b : parentScroll;
+        const isOutsideList = ((_c = scroller == null ? void 0 : scroller.isScrollInRange) == null ? void 0 : _c.call(scroller)) === false;
         const userOffsetDelta = (scrollAdjustUserOffset || 0) - lastScrollAdjustUserOffsetRef.current;
         const intendedScroll = userOffsetDelta !== 0 ? currentScroll + userOffsetDelta : ctx.state.scroll;
         const scrollDelta = intendedScroll - currentScroll;
-        const shouldScroll = Math.abs(scrollDelta) > 0.01;
+        const shouldScroll = !isOutsideList && Math.abs(scrollDelta) > 0.01;
         const scrollBy = () => scrollAdjustBy(el, axis.x * scrollDelta, axis.y * scrollDelta);
         contentNodeRef.current = contentNode;
         if (shouldScroll && contentNode) {
-          const totalSize = contentNode[axis.contentSizeKey];
+          const totalSize = isExternal ? el[axis.contentSizeKey] : contentNode[axis.contentSizeKey];
           const viewportSize = el[axis.viewportSizeKey];
-          const nextScroll = currentScroll + scrollDelta;
+          const nextScroll = parentScroll + scrollDelta;
           const needsTemporaryPadding = scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + viewportSize;
           if (needsTemporaryPadding) {
             const currentInlinePaddingEnd = contentNode.style[axis.paddingEndProp];
@@ -6777,12 +6964,14 @@ var ListComponent = typedMemo(function ListComponent2({
   renderScrollComponent,
   onLayoutFooter,
   onInternalScrollBeginDrag,
+  onInternalScrollEndDrag,
   onInternalScrollEnd,
   scrollAdjustHandler,
   snapToIndices,
   stickyHeaderConfig,
   stickyHeaderIndices,
   useWindowScroll = false,
+  scrollElement,
   ...rest
 }) {
   const ctx = useStateContext();
@@ -6848,7 +7037,7 @@ var ListComponent = typedMemo(function ListComponent2({
     SnapOrScroll,
     {
       ...rest,
-      ...ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} ,
+      ...ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, scrollElement, useWindowScroll } : {} ,
       contentContainerStyle: [
         horizontal ? { height: "100%" } : {},
         contentContainerStyle,
@@ -6888,7 +7077,15 @@ var WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO = 0.9;
 var WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO = 0.9;
 function useDevChecksImpl(props) {
   const ctx = useStateContext();
-  const { anchoredEndSpace, childrenMode, keyExtractor, numColumns, renderScrollComponent, useWindowScroll } = props;
+  const {
+    anchoredEndSpace,
+    childrenMode,
+    keyExtractor,
+    numColumns,
+    renderScrollComponent,
+    scrollElement,
+    useWindowScroll
+  } = props;
   const hasAnchoredEndSpace = !!anchoredEndSpace;
   useEffect(() => {
     if (hasAnchoredEndSpace && (numColumns != null ? numColumns : 1) > 1) {
@@ -6899,13 +7096,13 @@ function useDevChecksImpl(props) {
     }
   }, [hasAnchoredEndSpace, numColumns]);
   useEffect(() => {
-    if (useWindowScroll && renderScrollComponent) {
+    if ((useWindowScroll || scrollElement !== void 0) && renderScrollComponent) {
       warnDevOnce(
         "useWindowScrollRenderScrollComponent",
-        "useWindowScroll is not supported when renderScrollComponent is provided."
+        "useWindowScroll and scrollElement are not supported when renderScrollComponent is provided."
       );
     }
-  }, [renderScrollComponent, useWindowScroll]);
+  }, [renderScrollComponent, scrollElement, useWindowScroll]);
   useEffect(() => {
     if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
       warnDevOnce(
@@ -6917,8 +7114,8 @@ function useDevChecksImpl(props) {
   useEffect(() => {
     const state = ctx.state;
     const dataLength = state.props.data.length;
-    const useWindowScrollResolved = state.props.useWindowScroll;
-    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+    const usesExternalScroll = state.props.hasExternalScroll;
+    if (usesExternalScroll || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
       return;
     }
     const warnIfUnboundedOuterSize = () => {
@@ -6967,7 +7164,7 @@ function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {})
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
-    state.minIndexSizeChanged = 0;
+    state.positionRecalculationStartIndex = 0;
     state.scrollForNextCalculateItemsInView = void 0;
   }
   calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
@@ -7082,7 +7279,8 @@ function doInitialAllocateContainers(ctx) {
           calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
         });
       } else {
-        calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
+        const reuseInitialPositions = !state.didLoad && state.positionsAreCurrent && !state.didDataChange && !state.didColumnsChange;
+        calculateItemsInView(ctx, { dataChanged: !reuseInitialPositions, doMVCP: true });
       }
     }
     return true;
@@ -7125,17 +7323,15 @@ function handleLayout(ctx, layoutParam, setCanRender) {
     updateContentMetricsState(ctx);
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
-    if (scrollLength > 0) {
-      doInitialAllocateContainers(ctx);
-    }
-    if (needsCalculate) {
+    const didAllocate = scrollLength > 0 && doInitialAllocateContainers(ctx);
+    if (needsCalculate && (!didAllocate || state.initialScroll)) {
       calculateItemsInView(ctx, { doMVCP: true });
     }
     if (didChange || otherAxisSize !== prevOtherAxisSize) {
       set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
     }
     if (maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onLayout) {
-      doMaintainScrollAtEnd(ctx);
+      doMaintainScrollAtEnd(ctx, { immediate: true });
     }
     checkThresholds(ctx);
     if (state) {
@@ -7206,7 +7402,7 @@ function onScroll(ctx, event) {
   state.didFinishInitialScroll && ((_f = state.initialScroll) == null ? void 0 : _f.viewPosition) === 1 && state.scroll > state.scrollLength;
   state.lastNativeScroll = newScroll;
   state.lastNativeScrollTime = Date.now();
-  if (state.scrollingTo && state.scrollingTo.offset >= newScroll) {
+  if (!state.props.hasExternalScroll && state.scrollingTo && state.scrollingTo.offset >= newScroll) {
     const maxOffset = clampScrollOffset(ctx, newScroll, state.scrollingTo);
     if (newScroll !== maxOffset && Math.abs(newScroll - maxOffset) > 1) {
       newScroll = maxOffset;
@@ -7364,12 +7560,12 @@ function scrollToEnd(ctx, options) {
   if (index === -1) {
     return false;
   }
-  const paddingBottom = state.props.stylePaddingBottom || 0;
+  const paddingBottom = getStylePaddingEnd(state.props);
   const footerSize = peek$(ctx, "footerSize") || 0;
   scrollToIndex(ctx, {
     ...options,
     index,
-    viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
+    viewOffset: getEndAlignedViewOffset(paddingBottom, footerSize) + ((options == null ? void 0 : options.viewOffset) || 0),
     viewPosition: 1
   });
   if (state.scrollingTo) {
@@ -7556,7 +7752,7 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
-    state.minIndexSizeChanged = 0;
+    state.positionRecalculationStartIndex = 0;
     state.scrollForNextCalculateItemsInView = void 0;
     state.pendingTotalSize = void 0;
     state.totalSize = 0;
@@ -7950,10 +8146,12 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onMetricsChange,
     onLayout: onLayoutProp,
     onLoad,
+    onReady,
     onMomentumScrollEnd,
     onRefresh,
     onScroll: onScrollProp,
     onScrollBeginDrag,
+    onScrollEndDrag,
     onStartReached,
     onStartReachedThreshold = 0.5,
     onStickyHeaderChange,
@@ -7971,6 +8169,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     stickyHeaderIndices: stickyHeaderIndicesProp,
     style: styleProp,
     useWindowScroll = false,
+    scrollElement,
     viewabilityConfig,
     viewabilityConfigCallbackPairs,
     ...rest
@@ -8022,17 +8221,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const initialScrollProp = initialScrollAtEnd ? {
     index: Math.max(0, dataProp.length - 1),
     preserveForBottomPadding: true,
-    viewOffset: -stylePaddingEndState,
+    viewOffset: getEndAlignedViewOffset(stylePaddingEndState),
     viewPosition: 1
   } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
     index: (_b = initialScrollIndexProp.index) != null ? _b : 0,
     preserveForBottomPadding: initialScrollIndexProp.viewOffset === void 0 && initialScrollIndexProp.viewPosition === 1 ? true : void 0,
-    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 ? -stylePaddingEndState : 0,
+    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
     viewPosition: (_d = initialScrollIndexProp.viewPosition) != null ? _d : 0
   } : {
     index: initialScrollIndexProp != null ? initialScrollIndexProp : 0,
     preserveForBottomPadding: shouldBottomAlignNumericInitialScrollIndex ? true : void 0,
-    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? -stylePaddingEndState : 0,
+    viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
     viewPosition: shouldBottomAlignNumericInitialScrollIndex ? 1 : void 0
   } : initialScrollUsesOffsetOnly ? {
     contentOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0,
@@ -8065,7 +8264,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     dataVersion,
     keyExtractor
   ]);
-  const useWindowScrollResolved = !!useWindowScroll && !renderScrollComponent;
+  const scrollElementResolved = !renderScrollComponent ? scrollElement : void 0;
+  const useWindowScrollResolved = !!useWindowScroll && scrollElementResolved === void 0 && !renderScrollComponent;
+  const hasExternalScroll = useWindowScrollResolved || scrollElementResolved !== void 0;
   const refState = useRef(void 0);
   const hasOverrideItemLayout = !!overrideItemLayout;
   const prevHasOverrideItemLayout = useRef(hasOverrideItemLayout);
@@ -8110,11 +8311,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         lastLayout: void 0,
         lastScrollDelta: 0,
         loadStartTime: Date.now(),
-        minIndexSizeChanged: 0,
         nativeContentInset: void 0,
         nativeMarginTop: 0,
         pendingDataComparison: void 0,
         pendingNativeMVCPAdjust: void 0,
+        positionRecalculationStartIndex: 0,
         positions: [],
         props: {},
         queuedCalculateItemsInView: 0,
@@ -8203,6 +8404,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     estimatedItemSize,
     getFixedItemSize: useWrapIfItem(getFixedItemSize),
     getItemType: useWrapIfItem(getItemType),
+    hasExternalScroll,
     hideItemsUntilMeasured: experimental_hideItemsUntilMeasured,
     horizontal: !!horizontal,
     itemsAreEqual,
@@ -8217,8 +8419,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onItemSizeChanged,
     onLoad,
     onMomentumScrollEnd,
+    onReady,
     onScroll: throttleScrollFn,
     onScrollBeginDrag,
+    onScrollEndDrag,
     onStartReached,
     onStartReachedThreshold,
     onStickyHeaderChange,
@@ -8392,8 +8596,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const { onLayout } = useOnLayoutSync({
     onLayoutChange,
     onLayoutProp,
-    ref: refScroller
+    ref: refScroller,
     // the type of ScrollView doesn't include measure?
+    webExternalScroll: hasExternalScroll
   });
   useLayoutEffect(() => {
     if (snapToIndices) {
@@ -8506,11 +8711,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: (event) => onScroll(ctx, event),
       onScrollBeginDrag: (event) => {
         var _a4, _b2;
+        state.isDragging = true;
         interruptMaintainScrollAtEnd(ctx);
         prepareReachedEdgeForNextUserScroll(ctx);
         (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
       },
-      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx)
+      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx),
+      onScrollEndDrag: (event) => {
+        var _a4, _b2;
+        state.isDragging = false;
+        (_b2 = (_a4 = state.props).onScrollEndDrag) == null ? void 0 : _b2.call(_a4, event);
+      }
     }),
     []
   );
@@ -8534,6 +8745,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ListHeaderComponent,
       onInternalScrollBeginDrag: fns.onScrollBeginDrag,
       onInternalScrollEnd: fns.onScrollEnd,
+      onInternalScrollEndDrag: fns.onScrollEndDrag,
       onLayout,
       onLayoutFooter,
       onMomentumScrollEnd: fns.onMomentumScrollEnd,
@@ -8552,6 +8764,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       refScrollView: combinedRef,
       renderScrollComponent,
       scrollAdjustHandler: (_s = refState.current) == null ? void 0 : _s.scrollAdjustHandler,
+      scrollElement: scrollElementResolved,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,