@legendapp/list 3.7.0 → 3.7.1

package/react.js

@@ -345,27 +345,20 @@ function getContentInsetEnd(ctx, contentInsetEndAdjustmentOverride) {
   const { props } = state;
   const horizontal = props.horizontal;
   const baseInset = state.nativeContentInset;
-  const baseEndInset = (horizontal ? getHorizontalInsetEnd(state, baseInset) : baseInset == null ? void 0 : baseInset.bottom) || 0;
   const contentInsetEndAdjustment = getContentInsetEndAdjustmentEnd(
     contentInsetEndAdjustmentOverride != null ? contentInsetEndAdjustmentOverride : props.contentInsetEndAdjustment
   );
   const anchoredEndSpaceSize = peek$(ctx, "anchoredEndSpaceSize");
   const anchoredEndInset = props.anchoredEndSpace && anchoredEndSpaceSize ? anchoredEndSpaceSize : 0;
   const overrideInset = (_a3 = state.contentInsetOverride) != null ? _a3 : void 0;
-  const adjustedBaseEndInset = baseEndInset + contentInsetEndAdjustment;
-  if (overrideInset) {
-    const mergedInset = { bottom: 0, left: 0, right: 0, ...baseInset, ...overrideInset };
-    return Math.max(
-      ((horizontal ? getHorizontalInsetEnd(state, mergedInset) : mergedInset.bottom) || 0) + contentInsetEndAdjustment,
-      anchoredEndInset
-    );
-  }
-  return Math.max(adjustedBaseEndInset, anchoredEndInset);
+  const mergedInset = overrideInset ? { bottom: 0, left: 0, right: 0, ...baseInset, ...overrideInset } : baseInset;
+  const endInset = ((horizontal ? getHorizontalInsetEnd(state, mergedInset) : mergedInset == null ? void 0 : mergedInset.bottom) || 0) + contentInsetEndAdjustment;
+  return Math.max(endInset, anchoredEndInset);
 }
 
 // src/state/getContentSize.ts
-function getContentSize(ctx) {
-  var _a3, _b;
+function getContentSize(ctx, includeContentContainerMinSize = true) {
+  var _a3, _b, _c;
   const { values, state } = ctx;
   const stylePaddingStart = state.props.horizontal ? state.props.stylePaddingLeft || 0 : values.get("stylePaddingTop") || 0;
   const stylePaddingEnd = state.props.horizontal ? state.props.stylePaddingRight || 0 : state.props.stylePaddingBottom || 0;
@@ -375,7 +368,10 @@ function getContentSize(ctx) {
   const contentInsetEnd = getContentInsetEnd(ctx);
   const totalSize = (_b = (_a3 = state.pendingTotalSize) != null ? _a3 : state.totalSize) != null ? _b : values.get("totalSize");
   const layoutSize = Math.max(0, totalSize - (state.props.data.length > 0 ? ctx.scrollAxisGap : 0));
-  return headerSize + footerSize + layoutSize + stylePaddingStart + alignItemsAtEndPadding + stylePaddingEnd + (contentInsetEnd || 0);
+  const contentSize = headerSize + footerSize + layoutSize + stylePaddingStart + alignItemsAtEndPadding + stylePaddingEnd;
+  const inContentInset = contentInsetEnd ;
+  const containerSize = contentSize + inContentInset;
+  return (includeContentContainerMinSize ? Math.max(containerSize, (_c = state.props.contentContainerMinSize) != null ? _c : 0) : containerSize) + contentInsetEnd - inContentInset;
 }
 
 // src/components/DebugView.tsx
@@ -491,6 +487,33 @@ function cancelImperativeScroll(state) {
   settlePendingImperativeScroll(state);
 }
 
+// src/core/clampScrollOffset.ts
+function getContentInsetTop(ctx) {
+  ctx.state;
+  {
+    return 0;
+  }
+}
+function getScrollRangeEnd(ctx, contentSize = getContentSize(ctx)) {
+  return Math.max(0 - getContentInsetTop(ctx), contentSize - ctx.state.scrollLength);
+}
+function clampScrollOffset(ctx, offset, scrollTarget) {
+  var _a3;
+  const state = ctx.state;
+  const minOffset = 0 - getContentInsetTop(ctx);
+  const contentSize = getContentSize(ctx, !scrollTarget || !!scrollTarget.clampToContentContainerMinSize);
+  let clampedOffset = offset;
+  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
+    const baseMaxOffset = getScrollRangeEnd(ctx, contentSize);
+    const viewOffset = (scrollTarget == null ? void 0 : scrollTarget.isInitialScroll) ? void 0 : scrollTarget == null ? void 0 : scrollTarget.viewOffset;
+    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
+    const isRawOffset = (scrollTarget == null ? void 0 : scrollTarget.offset) !== void 0 && (scrollTarget.index === void 0 || scrollTarget.isInitialScroll && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset");
+    const maxOffset = Math.max(isRawOffset ? 0 : minOffset, baseMaxOffset + extraEndOffset);
+    clampedOffset = Math.min(offset, maxOffset);
+  }
+  return Math.max(minOffset, clampedOffset);
+}
+
 // src/core/doScrollParams.ts
 function getNativeScrollPoint(ctx, offset, horizontal = ctx.state.props.horizontal) {
   var _a3;
@@ -668,23 +691,6 @@ function getObservedScrollOffset(ctx, fallbackOffset = ctx.state.scroll) {
   return state.props.horizontal ? peekLogicalHorizontalOffset(state, observed, (_c = scroller.getMaxScrollOffset) == null ? void 0 : _c.call(scroller)) : observed;
 }
 
-// src/core/clampScrollOffset.ts
-function clampScrollOffset(ctx, offset, scrollTarget) {
-  const state = ctx.state;
-  const minSize = (scrollTarget == null ? void 0 : scrollTarget.clampToContentContainerMinSize) ? state.props.contentContainerMinSize : void 0;
-  const contentSize = minSize === void 0 ? getContentSize(ctx) : Math.max(getContentSize(ctx), minSize);
-  let clampedOffset = offset;
-  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
-    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
-    const viewOffset = (scrollTarget == null ? void 0 : scrollTarget.isInitialScroll) ? void 0 : scrollTarget == null ? void 0 : scrollTarget.viewOffset;
-    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
-    const maxOffset = baseMaxOffset + extraEndOffset;
-    clampedOffset = Math.min(offset, maxOffset);
-  }
-  clampedOffset = Math.max(0, clampedOffset);
-  return clampedOffset;
-}
-
 // src/core/updateContentMetricsState.ts
 function getRawContentLength(ctx) {
   var _a3, _b, _c;
@@ -694,7 +700,7 @@ function getRawContentLength(ctx) {
 function getAlignItemsAtEndPadding(ctx) {
   const { state } = ctx;
   const shouldPad = !!state.props.alignItemsAtEndPaddingEnabled && !state.props.horizontal && state.props.data.length > 0 && state.scrollLength > 0;
-  return shouldPad ? Math.max(0, state.scrollLength - getRawContentLength(ctx) - getContentInsetEnd(ctx)) : 0;
+  return shouldPad ? Math.max(0, state.scrollLength - getRawContentLength(ctx) - getContentInsetTop(ctx) - getContentInsetEnd(ctx)) : 0;
 }
 function updateContentMetricsState(ctx) {
   var _a3;
@@ -801,70 +807,66 @@ function isOutsideThresholdHysteresis(distance, atThreshold, threshold) {
   const absDistance = Math.abs(distance);
   return !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
 }
+function didThresholdDataChange(snapshot, context) {
+  return !!snapshot && (snapshot.dataLength !== context.dataLength || snapshot.data !== context.data && snapshot.contentSize !== context.contentSize);
+}
 var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot) => {
   const absDistance = Math.abs(distance);
-  const within = atThreshold || threshold > 0 && absDistance <= threshold;
-  const updateSnapshot = () => {
-    setSnapshot({
-      atThreshold,
-      contentSize: context.contentSize,
-      dataLength: context.dataLength,
-      scrollPosition: context.scrollPosition
-    });
-  };
-  let reached = !!wasReached;
-  if (!wasReached) {
-    if (within && onReached(distance)) {
-      updateSnapshot();
-      reached = true;
-    }
-  } else {
-    const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
-    if (reset) {
+  const within = context.dataLength !== 0 && (atThreshold || threshold > 0 && absDistance <= threshold);
+  const didScroll = (snapshot == null ? void 0 : snapshot.scroll) !== context.scroll;
+  if (snapshot) snapshot.scroll = context.scroll;
+  if (!within) {
+    if ((context.dataLength === 0 || didScroll && isOutsideThresholdHysteresis(distance, atThreshold, threshold)) && (wasReached || snapshot)) {
       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 false;
   }
-  return reached;
+  if ((!wasReached || didThresholdDataChange(snapshot, context)) && onReached(distance)) {
+    return true;
+  }
+  return !!wasReached;
 };
 
 // src/utils/edgeReachedGate.ts
-function resetEdgeLatch(ctx, edge) {
-  const state = ctx.state;
-  if (edge === "start") {
-    state.isStartReached = false;
-    state.startReachedSnapshot = void 0;
-  } else {
-    state.isEndReached = false;
-    state.endReachedSnapshot = void 0;
-  }
+function getDistanceFromStart(ctx) {
+  return ctx.state.scroll + getContentInsetTop(ctx);
 }
 function resetSharedEdgeGateIfOutsideHysteresis(ctx) {
   const state = ctx.state;
-  if (!state.edgeReachedGate) {
+  if (!state.edgeReachedGate || state.edgeReachedGateScroll === state.scroll) {
     return;
   }
+  state.edgeReachedGateScroll = state.scroll;
   const contentSize = getContentSize(ctx);
   const endDistance = contentSize - state.scroll - state.scrollLength;
   const isContentLess = contentSize < state.scrollLength;
   const startThreshold = state.props.onStartReachedThreshold * state.scrollLength;
   const endThreshold = state.props.onEndReachedThreshold * state.scrollLength;
-  const isOutsideStart = isOutsideThresholdHysteresis(state.scroll, false, startThreshold);
+  const isOutsideStart = isOutsideThresholdHysteresis(getDistanceFromStart(ctx), false, startThreshold);
   const isOutsideEnd = isOutsideThresholdHysteresis(endDistance, isContentLess, endThreshold);
   if (isOutsideStart && isOutsideEnd) {
     state.edgeReachedGate = void 0;
   }
 }
 function canDispatchReachedEdge(ctx, edge, allowedEdge, allowGateCreatedInCurrentCheck) {
-  return !ctx.state.edgeReachedGate || allowedEdge === edge || !!allowGateCreatedInCurrentCheck;
+  const state = ctx.state;
+  return !state.edgeReachedGate || allowedEdge === edge || !!allowGateCreatedInCurrentCheck || didThresholdDataChange(
+    edge === "start" ? state.startReachedSnapshot : state.endReachedSnapshot,
+    getThresholdSnapshot(ctx)
+  );
 }
-function markReachedEdge(ctx) {
-  ctx.state.edgeReachedGate = "closed";
+function markReachedEdge(ctx, edge) {
+  const state = ctx.state;
+  state.edgeReachedGate = "closed";
+  state.edgeReachedGateScroll = state.scroll;
+  const snapshotKey = edge === "start" ? "startReachedSnapshot" : "endReachedSnapshot";
+  const snapshot = getThresholdSnapshot(ctx);
+  snapshot.didRearmForData = didThresholdDataChange(state[snapshotKey], snapshot);
+  state[snapshotKey] = snapshot;
+}
+function getThresholdSnapshot(ctx) {
+  const { data } = ctx.state.props;
+  return { contentSize: getContentSize(ctx), data, dataLength: data.length, scroll: ctx.state.scroll };
 }
 function prepareReachedEdgeForNextUserScroll(ctx) {
   if (ctx.state.edgeReachedGate) {
@@ -873,11 +875,19 @@ function prepareReachedEdgeForNextUserScroll(ctx) {
 }
 function beginReachedEdgeUserScroll(ctx, scrollDelta) {
   const state = ctx.state;
-  if (state.edgeReachedGate !== "prepared") {
+  const allowedEdge = scrollDelta < 0 ? "start" : "end";
+  if (state.edgeReachedGate !== "prepared" && state.edgeReachedGate !== (allowedEdge === "start" ? "consumed-end" : "consumed-start")) {
     return void 0;
   }
-  const allowedEdge = scrollDelta < 0 ? "start" : "end";
-  resetEdgeLatch(ctx, allowedEdge);
+  const snapshotKey = allowedEdge === "start" ? "startReachedSnapshot" : "endReachedSnapshot";
+  const snapshot = state[snapshotKey];
+  if ((snapshot == null ? void 0 : snapshot.didRearmForData) && snapshot.data === state.props.data) {
+    snapshot.didRearmForData = false;
+    state.edgeReachedGate = state.edgeReachedGate === "prepared" ? `consumed-${allowedEdge}` : "closed";
+    return void 0;
+  }
+  state[allowedEdge === "start" ? "isStartReached" : "isEndReached"] = false;
+  state[snapshotKey] = void 0;
   return allowedEdge;
 }
 
@@ -888,7 +898,6 @@ function hasActiveInitialScroll(state) {
 
 // src/utils/checkAtBottom.ts
 function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
-  var _a3;
   const state = ctx.state;
   if (!state) {
     return;
@@ -928,19 +937,14 @@ function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
         onEndReachedThreshold * scrollLength,
         state.isEndReached,
         state.endReachedSnapshot,
-        {
-          contentSize,
-          dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length,
-          scrollPosition: scroll
-        },
+        { contentSize, data: state.props.data, dataLength: state.props.data.length, scroll },
         (distance) => {
-          let dispatched = false;
           if (state.props.onEndReached && canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
-            markReachedEdge(ctx);
+            markReachedEdge(ctx, "end");
             state.props.onEndReached({ distanceFromEnd: distance });
-            dispatched = true;
+            return true;
           }
-          return dispatched;
+          return false;
         },
         (snapshot) => {
           state.endReachedSnapshot = snapshot;
@@ -957,43 +961,30 @@ function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
     return;
   }
   const {
-    isStartReached,
     props: { data, onStartReachedThreshold },
-    scroll,
-    scrollLength,
-    startReachedSnapshot,
-    totalSize
+    scrollLength
   } = state;
-  const dataLength = data.length;
   const threshold = onStartReachedThreshold * scrollLength;
+  const distanceFromStart = getDistanceFromStart(ctx);
   resetSharedEdgeGateIfOutsideHysteresis(ctx);
-  if (isStartReached && threshold > 0 && scroll > threshold && startReachedSnapshot && (startReachedSnapshot.contentSize !== totalSize || startReachedSnapshot.dataLength !== dataLength)) {
-    state.isStartReached = false;
-    state.startReachedSnapshot = void 0;
-  }
-  set$(ctx, "isAtStart", scroll <= EDGE_POSITION_EPSILON);
-  set$(ctx, "isNearStart", scroll <= threshold);
+  set$(ctx, "isAtStart", distanceFromStart <= EDGE_POSITION_EPSILON);
+  set$(ctx, "isNearStart", distanceFromStart <= threshold);
   const shouldSkipThresholdChecks = !state.queuedInitialLayout || hasActiveInitialScroll(state) || !!state.scrollingTo;
   if (!shouldSkipThresholdChecks) {
     state.isStartReached = checkThreshold(
-      scroll,
+      distanceFromStart,
       false,
       threshold,
       state.isStartReached,
-      startReachedSnapshot,
-      {
-        contentSize: totalSize,
-        dataLength,
-        scrollPosition: scroll
-      },
+      state.startReachedSnapshot,
+      { contentSize: getContentSize(ctx), data, dataLength: data.length, scroll: state.scroll },
       (distance) => {
-        let dispatched = false;
         if (state.props.onStartReached && canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
-          markReachedEdge(ctx);
+          markReachedEdge(ctx, "start");
           state.props.onStartReached({ distanceFromStart: distance });
-          dispatched = true;
+          return true;
         }
-        return dispatched;
+        return false;
       },
       (snapshot) => {
         state.startReachedSnapshot = snapshot;
@@ -1463,11 +1454,9 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
   if (viewOffset) {
     offset -= viewOffset;
   }
+  const leadingInset = index !== void 0 ? getContentInsetTop(ctx) : 0;
   if (index !== void 0) {
-    const startOffsetAdjustment = getStartOffsetAdjustment(ctx);
-    if (startOffsetAdjustment) {
-      offset += startOffsetAdjustment;
-    }
+    offset += getStartOffsetAdjustment(ctx) - leadingInset;
   }
   if (viewPosition !== void 0 && index !== void 0) {
     const dataLength = state.props.data.length;
@@ -1479,9 +1468,12 @@ function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
     const measuredItemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
     const itemSize = Math.max(0, measuredItemSize - (isOutOfBounds ? 0 : ctx.scrollAxisGap));
     const trailingInset = getContentInsetEnd(ctx);
-    const availableSpace = state.scrollLength - trailingInset - itemSize;
+    const availableSpace = state.scrollLength - leadingInset - trailingInset - itemSize;
     offset += getViewPositionOffset(availableSpace, viewPosition, viewPositionFallback);
   }
+  if (index !== void 0 && params.clampToContentContainerMinSize) {
+    offset += getContentSize(ctx) - getContentSize(ctx, false);
+  }
   return offset;
 }
 
@@ -1534,11 +1526,12 @@ function shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotal
     return false;
   }
 }
-function getPredictedNativeClamp(state, unresolvedAmount, totalSize) {
+function getPredictedNativeClamp(ctx, unresolvedAmount, totalSize) {
   if (Math.abs(unresolvedAmount) <= MVCP_POSITION_EPSILON) {
     return 0;
   }
-  const maxScroll = Math.max(0, totalSize - state.scrollLength);
+  const state = ctx.state;
+  const maxScroll = getScrollRangeEnd(ctx, totalSize);
   const clampDelta = maxScroll - state.scroll;
   if (unresolvedAmount < 0) {
     return Math.max(unresolvedAmount, Math.min(0, clampDelta));
@@ -1566,7 +1559,7 @@ function maybeApplyPredictedNativeMVCPAdjust(ctx) {
     return;
   }
   const totalSize = getContentSize(ctx);
-  const predictedNativeClamp = getPredictedNativeClamp(state, pending.amount, totalSize);
+  const predictedNativeClamp = getPredictedNativeClamp(ctx, pending.amount, totalSize);
   if (Math.abs(predictedNativeClamp) <= MVCP_POSITION_EPSILON) {
     return;
   }
@@ -1600,7 +1593,7 @@ function resolvePendingNativeMVCPAdjust(ctx, newScroll) {
     settlePendingNativeMVCPAdjust(ctx, remainingAfterManual, nativeDelta);
     return true;
   }
-  const expectedNativeClampScroll = Math.max(0, getContentSize(ctx) - state.scrollLength);
+  const expectedNativeClampScroll = getScrollRangeEnd(ctx);
   const distanceToClamp = Math.abs(newScroll - expectedNativeClampScroll);
   const isAtExpectedNativeClamp = distanceToClamp <= NATIVE_END_CLAMP_EPSILON;
   if (isAtExpectedNativeClamp) {
@@ -1741,7 +1734,7 @@ function prepareMVCP(ctx, dataChanged, adjustmentSource) {
             if (diff > 0) {
               diff = Math.max(0, totalSize - state.scroll - state.scrollLength);
             } else {
-              const maxScroll = Math.max(0, totalSize - state.scrollLength);
+              const maxScroll = getScrollRangeEnd(ctx, totalSize);
               state.scroll = maxScroll;
               state.scrollPending = maxScroll;
               diff = 0;
@@ -1758,7 +1751,7 @@ function prepareMVCP(ctx, dataChanged, adjustmentSource) {
         const prevSize = scrollingTo.itemSize;
         if (prevSize !== void 0 && newSize !== prevSize) {
           if (scrollingTo.viewPositionFallback) {
-            const viewport = state.scrollLength - getContentInsetEnd(ctx);
+            const viewport = state.scrollLength - getContentInsetTop(ctx) - getContentInsetEnd(ctx);
             const previousSpace = viewport - Math.max(0, prevSize - ctx.scrollAxisGap);
             const nextSpace = viewport - Math.max(0, newSize - ctx.scrollAxisGap);
             positionDiff += getViewPositionOffset(
@@ -1965,27 +1958,31 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
 }
 
 // src/core/cancelScroll.ts
-function cancelScroll(ctx, stopAnimation = true, commitAdjust = true) {
+function cancelScroll(ctx, stopAnimation = true, commitAdjust = true, inputDelta = 0) {
   var _a3, _b;
   const { state } = ctx;
   const observed = getObservedScrollOffset(ctx, peek$(ctx, "scrollAdjustPending") ? state.scrollPending : void 0);
   const wasAnimating = !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.animated) || !!((_b = ctx.scrollRequestTracker) == null ? void 0 : _b.cancel());
+  const stopped = wasAnimating && stopAnimation;
+  const stopOffset = stopped && inputDelta ? clampScrollOffset(ctx, observed + inputDelta) : observed;
   releaseScrollOwners(ctx, true);
-  state.scrollPending = observed;
+  state.scrollPending = stopOffset;
   const ignoreScrollFromMVCP = state.ignoreScrollFromMVCP;
   if (peek$(ctx, "scrollAdjustPending")) state.ignoreScrollFromMVCP = void 0;
-  updateScroll(ctx, observed, true, { markHasScrolled: false });
+  updateScroll(ctx, stopOffset, true, { markHasScrolled: false });
   state.ignoreScrollFromMVCP = ignoreScrollFromMVCP;
-  if (wasAnimating && stopAnimation) stopScrollAnimation(ctx, observed);
+  if (stopped) stopScrollAnimation(ctx, observed, inputDelta);
   if (commitAdjust) state.scrollAdjustHandler.commitPendingAdjust();
   else state.scrollAdjustHandler.supersedePendingAdjust();
+  return stopped;
 }
-function stopScrollAnimation(ctx, observed = getObservedScrollOffset(ctx)) {
+function stopScrollAnimation(ctx, observed = getObservedScrollOffset(ctx), inputDelta = 0) {
   var _a3, _b;
   const { state } = ctx;
   const scroller = state.refScroller.current;
-  const x = state.props.horizontal ? (_b = (_a3 = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _a3.call(scroller)) != null ? _b : getNativeScrollPoint(ctx, observed).x : 0;
-  scroller == null ? void 0 : scroller.scrollTo({ animated: false, x, y: state.props.horizontal ? 0 : observed });
+  const offset = observed + inputDelta;
+  const x = !state.props.horizontal ? 0 : inputDelta ? getNativeScrollPoint(ctx, offset).x : (_b = (_a3 = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _a3.call(scroller)) != null ? _b : getNativeScrollPoint(ctx, observed).x;
+  scroller == null ? void 0 : scroller.scrollTo({ animated: false, x, y: state.props.horizontal ? 0 : offset });
 }
 function releaseScrollOwners(ctx, supersedeInitial) {
   var _a3;
@@ -1999,12 +1996,39 @@ function releaseScrollOwners(ctx, supersedeInitial) {
   clearPreservedInitialScrollTarget(state);
   syncScrollActive(ctx);
 }
-function interruptUserScroll(ctx) {
-  if (ctx.state.scrollingTo || ctx.state.initialScroll && !ctx.state.didFinishInitialScroll) {
-    cancelScroll(ctx, Platform.OS === "web");
-  } else {
-    releaseScrollOwners(ctx, false);
+function interruptUserScroll(ctx, inputDelta = 0) {
+  var _a3;
+  if (ctx.state.scrollingTo || ((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun()) || ctx.state.initialScroll && !ctx.state.didFinishInitialScroll) {
+    return cancelScroll(ctx, Platform.OS === "web", true, inputDelta) && inputDelta !== 0;
+  }
+  releaseScrollOwners(ctx, false);
+  return false;
+}
+
+// src/utils/clampScrollIndex.ts
+function clampScrollIndex(index, dataLength) {
+  if (dataLength <= 0) {
+    return -1;
+  }
+  if (index >= dataLength) {
+    return dataLength - 1;
   }
+  if (index < 0) {
+    return 0;
+  }
+  return index;
+}
+
+// src/core/getCurrentTargetOffset.ts
+function isEndAlignedLastItemTarget(ctx, scrollingTo) {
+  return (scrollingTo.isScrollToEnd || scrollingTo.index === ctx.state.props.data.length - 1) && scrollingTo.viewPosition === 1;
+}
+function getCurrentTargetOffset(ctx, scrollingTo) {
+  var _a3, _b;
+  const index = scrollingTo.isScrollToEnd ? ctx.state.props.data.length - 1 : scrollingTo.index === void 0 ? void 0 : clampScrollIndex(scrollingTo.index, ctx.state.props.data.length);
+  const isRetargetingWebScroll = (!scrollingTo.isInitialScroll || ((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap");
+  const requestedTargetOffset = index !== void 0 && (isRetargetingWebScroll || isEndAlignedLastItemTarget(ctx, scrollingTo)) ? calculateOffsetWithOffsetPosition(ctx, calculateOffsetForIndex(ctx, index), { ...scrollingTo, index }) : isRetargetingWebScroll ? calculateOffsetWithOffsetPosition(ctx, scrollingTo.offset, scrollingTo) : (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset - (scrollingTo.viewOffset || 0);
+  return clampScrollOffset(ctx, requestedTargetOffset, scrollingTo);
 }
 
 // src/core/scrollRequestTracker.ts
@@ -2048,7 +2072,7 @@ function getScrollRequestTracker(ctx) {
           state.scrollAdjustHandler.commitPendingAdjust();
         }
       }
-      if (didStartScroll === "unreachable") {
+      if (didStartScroll === "unreachable" || !didStartScroll && state.scrollingTo) {
         cancelScroll(ctx);
         return;
       }
@@ -2089,6 +2113,18 @@ function getScrollRequestTracker(ctx) {
 }
 
 // src/core/doMaintainScrollAtEnd.ts
+function reissueClampedNativeEndScroll(ctx) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const target = state.scrollingTo;
+  if ((target == null ? void 0 : target.isScrollToEnd) && !target.animated && !((_a3 = ctx.scrollRequestTracker) == null ? void 0 : _a3.isWaitingToRun())) {
+    const targetOffset = getCurrentTargetOffset(ctx, target);
+    const distanceToTarget = targetOffset - ((_b = state.lastNativeScroll) != null ? _b : state.scroll);
+    if (distanceToTarget > 1 || state.lastNativeScroll === void 0 && distanceToTarget < -1) {
+      (_c = state.refScroller.current) == null ? void 0 : _c.scrollTo({ animated: false, ...getNativeScrollPoint(ctx, targetOffset) });
+    }
+  }
+}
 function doMaintainScrollAtEnd(ctx, options) {
   var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   const state = ctx.state;
@@ -2137,7 +2173,7 @@ function doMaintainScrollAtEnd(ctx, options) {
     return false;
   }
   if (state.scrollingTo || state.pendingScrollResolve) {
-    if (immediate && ((_k = state.scrollingTo) == null ? void 0 : _k.isScrollToEnd) && !state.scrollingTo.animated) {
+    if ((options == null ? void 0 : options.immediate) && !maintainScrollAtEnd.animated && ((_k = state.scrollingTo) == null ? void 0 : _k.isScrollToEnd) && !state.scrollingTo.animated) {
       state.pendingMaintainScrollAtEnd = false;
       ctx.scrollToEnd({ animated: false });
       return true;
@@ -2148,7 +2184,7 @@ function doMaintainScrollAtEnd(ctx, options) {
   state.pendingMaintainScrollAtEnd = false;
   const contentSize = getContentSize(ctx);
   if (contentSize < state.scrollLength) {
-    state.scroll = 0;
+    state.scroll = clampScrollOffset(ctx, 0);
   }
   if (!state.maintainingScrollAtEnd || immediate && (state.maintainingScrollAtEnd === "pending-instant" || state.maintainingScrollAtEnd === "instant")) {
     const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
@@ -2241,20 +2277,6 @@ function finishScrollTo(ctx) {
   }
 }
 
-// src/utils/clampScrollIndex.ts
-function clampScrollIndex(index, dataLength) {
-  if (dataLength <= 0) {
-    return -1;
-  }
-  if (index >= dataLength) {
-    return dataLength - 1;
-  }
-  if (index < 0) {
-    return 0;
-  }
-  return index;
-}
-
 // src/core/checkFinishedScroll.ts
 var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
 var INITIAL_SCROLL_COMPLETION_TARGET_EPSILON = 1;
@@ -2302,16 +2324,6 @@ function shouldFinishInitialZeroTargetScroll(ctx) {
   const { state } = ctx;
   return !!((_a3 = state.scrollingTo) == null ? void 0 : _a3.isInitialScroll) && state.props.data.length > 0 && getContentSize(ctx) <= state.scrollLength && state.scrollPending <= INITIAL_SCROLL_ZERO_TARGET_EPSILON;
 }
-function isEndAlignedLastItemTarget(ctx, scrollingTo) {
-  return (scrollingTo.isScrollToEnd || scrollingTo.index === ctx.state.props.data.length - 1) && scrollingTo.viewPosition === 1;
-}
-function getCurrentTargetOffset(ctx, scrollingTo) {
-  var _a3, _b;
-  const index = scrollingTo.isScrollToEnd ? ctx.state.props.data.length - 1 : scrollingTo.index === void 0 ? void 0 : clampScrollIndex(scrollingTo.index, ctx.state.props.data.length);
-  const isRetargetingWebScroll = (!scrollingTo.isInitialScroll || ((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap");
-  const requestedTargetOffset = index !== void 0 && (isRetargetingWebScroll || isEndAlignedLastItemTarget(ctx, scrollingTo)) ? calculateOffsetWithOffsetPosition(ctx, calculateOffsetForIndex(ctx, index), { ...scrollingTo, index }) : isRetargetingWebScroll ? calculateOffsetWithOffsetPosition(ctx, scrollingTo.offset, scrollingTo) : (_b = scrollingTo.targetOffset) != null ? _b : scrollingTo.offset - (scrollingTo.viewOffset || 0);
-  return clampScrollOffset(ctx, requestedTargetOffset, scrollingTo);
-}
 function getResolvedScrollCompletionState(ctx, scrollingTo) {
   const { state } = ctx;
   const isWebInitialScroll = scrollingTo.isInitialScroll;
@@ -2323,9 +2335,10 @@ function getResolvedScrollCompletionState(ctx, scrollingTo) {
   const adjustedTargetOffset = clampedTargetOffset + adjust;
   const diff2 = Math.abs(scroll - adjustedTargetOffset);
   const canUseAdjustedCompletion = !isWebInitialScroll && (!scrollingTo.animated || Platform.OS === "ios");
+  const isWaitingForNativeEnd = Platform.OS !== "web";
   return {
     clampedTargetOffset,
-    isAtResolvedTarget: Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || canUseAdjustedCompletion && diff2 < 1)
+    isAtResolvedTarget: !isWaitingForNativeEnd && Math.abs(scroll - maxOffset) < 1 && (diff1 < 1 || canUseAdjustedCompletion && diff2 < 1)
   };
 }
 function checkFinishedScrollFrame(ctx) {
@@ -2709,18 +2722,20 @@ function scrollTo(ctx, params) {
   if (forceScroll || !isInitialScroll || Platform.OS === "android") {
     doScrollTo(ctx, { animated, horizontal, offset });
   } else {
-    state.scroll = offset;
+    state.scroll = targetOffset;
   }
 }
 
 // src/core/initialScroll.ts
 function dispatchInitialScroll(ctx, params) {
+  var _a3;
   const { forceScroll, resolvedOffset, target, waitForCompletionFrame } = params;
   const requestedIndex = target.index;
   const index = requestedIndex !== void 0 ? clampScrollIndex(requestedIndex, ctx.state.props.data.length) : void 0;
   const itemSize = getItemSizeAtIndex(ctx, index);
   scrollTo(ctx, {
     animated: false,
+    clampToContentContainerMinSize: ((_a3 = ctx.state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset" || isEndOfContentTarget(target, ctx.state.props.data.length),
     forceScroll,
     index: index !== void 0 && index >= 0 ? index : void 0,
     isInitialScroll: true,
@@ -2753,8 +2768,12 @@ function resolveInitialScrollOffset(ctx, initialScroll) {
     return (_b = initialScroll.contentOffset) != null ? _b : 0;
   }
   const baseOffset = initialScroll.index !== void 0 ? calculateOffsetForIndex(ctx, initialScroll.index) : 0;
-  const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, initialScroll);
-  return clampScrollOffset(ctx, resolvedOffset, initialScroll);
+  const target = {
+    ...initialScroll,
+    clampToContentContainerMinSize: isEndOfContentTarget(initialScroll, state.props.data.length)
+  };
+  const resolvedOffset = calculateOffsetWithOffsetPosition(ctx, baseOffset, target);
+  return clampScrollOffset(ctx, resolvedOffset, target);
 }
 function getAdvanceableInitialScrollState(state, options) {
   const { didFinishInitialScroll, queuedInitialLayout, scrollingTo } = state;
@@ -3573,7 +3592,7 @@ function updateSnapToOffsets(ctx) {
   const {
     props: { snapToIndices }
   } = state;
-  const contentSize = state.props.horizontal ? getContentSize(ctx) : void 0;
+  const contentSize = state.props.horizontal ? getContentSize(ctx, false) : void 0;
   const snapToOffsets = Array(snapToIndices.length);
   for (let i = 0; i < snapToIndices.length; i++) {
     const idx = snapToIndices[i];
@@ -4632,31 +4651,7 @@ function maybeEmitFirstVisibleItemChanged(state, index) {
   state.lastFirstVisibleItemCallback = { index, key };
   onFirstVisibleItemChanged({ index, item: state.props.data[index], key });
 }
-function findFirstVisibleIndexInCachedRange(ctx, scroll) {
-  var _a3, _b;
-  const state = ctx.state;
-  const {
-    endBuffered,
-    idCache,
-    positions,
-    props: { data },
-    sizes,
-    startBuffered
-  } = state;
-  if (startBuffered === null || endBuffered === null || startBuffered < 0 || endBuffered < startBuffered) {
-    return null;
-  }
-  for (let i = startBuffered; i <= endBuffered && i < data.length; i++) {
-    const id = (_a3 = idCache[i]) != null ? _a3 : getId(state, i);
-    const size = (_b = sizes.get(id)) != null ? _b : getItemSize(ctx, id, i, data[i]);
-    const top = positions[i];
-    if (top + size > scroll) {
-      return i;
-    }
-  }
-  return null;
-}
-function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, scrollLength, scroll, scrollBottom) {
+function updateVisibleRangeForCachedRange(ctx, viewabilityConfigCallbackPairs, scrollLength, scroll, scrollBottom) {
   var _a3, _b, _c, _d;
   const state = ctx.state;
   const {
@@ -4684,14 +4679,11 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
       break;
     }
   }
-  Object.assign(state, {
-    endNoBuffer: visibleRange.endNoBuffer,
-    firstFullyOnScreenIndex: visibleRange.firstFullyOnScreenIndex,
-    idsInView: getIdsInVisibleRange(state, visibleRange),
-    startNoBuffer: visibleRange.startNoBuffer
+  Object.assign(state, visibleRange, {
+    idsInView: getIdsInVisibleRange(state, visibleRange)
   });
   maybeEmitFirstVisibleItemChanged(state, visibleRange.startNoBuffer);
-  if (state.props.hasExternalScroll || visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
+  if (viewabilityConfigCallbackPairs && (state.props.hasExternalScroll || visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null)) {
     updateViewableItems(
       state,
       ctx,
@@ -4734,7 +4726,8 @@ function calculateItemsInView(ctx, params = {}) {
     if (!data || scrollLength === 0 || !prevNumContainers) {
       return;
     }
-    let totalSize = getContentSize(ctx);
+    const includeContentContainerMinSize = Platform.OS === "web";
+    let totalSize = getContentSize(ctx, includeContentContainerMinSize);
     let changedContainerIds;
     const topPad = getStartOffsetAdjustment(ctx);
     const numColumns = peek$(ctx, "numColumns");
@@ -4801,8 +4794,9 @@ function calculateItemsInView(ctx, params = {}) {
       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);
+      const unusedTopBuffer = state.props.hasExternalScroll ? 0 : Math.max(0, scrollBufferTop - scroll);
       scrollTopBuffered = scrollStart - scrollBufferTop + projectedBufferAdjustment;
-      scrollBottomBuffered = scrollBottom + scrollBufferBottom + projectedBufferAdjustment;
+      scrollBottomBuffered = scrollBottom + scrollBufferBottom + unusedTopBuffer + projectedBufferAdjustment;
     };
     updateScrollRange();
     if (projectedBufferAdjustment !== 0) {
@@ -4814,17 +4808,13 @@ function calculateItemsInView(ctx, params = {}) {
         state.scrollForNextCalculateItemsInView = void 0;
       } else if ((top === null || scrollTopBuffered > top) && (bottom === null || scrollBottomBuffered < bottom)) {
         if (!isInMVCPActiveMode(state)) {
-          if (viewabilityConfigCallbackPairs) {
-            updateViewabilityForCachedRange(
-              ctx,
-              viewabilityConfigCallbackPairs,
-              scrollLength,
-              scroll,
-              scrollBottom
-            );
-          } else if (state.props.onFirstVisibleItemChanged) {
-            maybeEmitFirstVisibleItemChanged(state, findFirstVisibleIndexInCachedRange(ctx, scroll));
-          }
+          updateVisibleRangeForCachedRange(
+            ctx,
+            viewabilityConfigCallbackPairs,
+            scrollLength,
+            scroll,
+            scrollBottom
+          );
           (_d = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _d.call(stickyState);
           return;
         }
@@ -4846,7 +4836,7 @@ function calculateItemsInView(ctx, params = {}) {
       scrollVelocity: speed,
       startIndex
     });
-    totalSize = getContentSize(ctx);
+    totalSize = getContentSize(ctx, includeContentContainerMinSize);
     if (positionRecalculationStartIndex !== void 0) {
       state.positionRecalculationStartIndex = void 0;
     }
@@ -4944,14 +4934,11 @@ function calculateItemsInView(ctx, params = {}) {
         }
       }
     }
-    Object.assign(state, {
+    Object.assign(state, visibleRange, {
       endBuffered,
-      endNoBuffer: visibleRange.endNoBuffer,
-      firstFullyOnScreenIndex: visibleRange.firstFullyOnScreenIndex,
       idsInView: getIdsInVisibleRange(state, visibleRange),
       startBuffered,
-      startBufferedId,
-      startNoBuffer: visibleRange.startNoBuffer
+      startBufferedId
     });
     if (enableScrollForNextCalculateItemsInView && nextTop !== void 0 && nextBottom !== void 0) {
       state.scrollForNextCalculateItemsInView = isNullOrUndefined(nextTop) && isNullOrUndefined(nextBottom) ? void 0 : {
@@ -5214,7 +5201,11 @@ function maybeUpdateAnchoredEndSpace(ctx) {
       contentBelowAnchor = Math.max(0, contentBelowAnchor - ctx.scrollAxisGap);
       contentBelowAnchor += (ctx.values.get("footerSize") || 0) + getStylePaddingEnd(state.props);
       isReady = !hasUnknownTailSize;
-      const knownSizeBound = Math.max(0, state.scrollLength - contentBelowAnchor - anchorOffset);
+      const externalEndInset = 0;
+      const knownSizeBound = Math.max(
+        0,
+        state.scrollLength - contentBelowAnchor - anchorOffset - externalEndInset
+      );
       nextSize = hasUnknownTailSize ? Math.min(previousSize || 0, knownSizeBound) : knownSizeBound;
     } else if (anchorIndex >= 0) {
       isReady = false;
@@ -5331,13 +5322,27 @@ function updateItemSizes(ctx, measurement) {
     updateItemSizesBatch(ctx, [measurement]);
   }
 }
+function isContainerItemCurrent(ctx, containerId, itemKey) {
+  if (peek$(ctx, `containerItemKey${containerId}`) !== itemKey) return false;
+  const state = ctx.state;
+  const index = state.indexByKey.get(itemKey);
+  if (index !== void 0 && index < state.props.data.length && getId(state, index) === itemKey) return true;
+  state.scheduledWork.microtask(
+    () => {
+      var _a3;
+      return (_a3 = ctx.containerLayoutTriggers.get(containerId)) == null ? void 0 : _a3();
+    },
+    `containerMeasurementRetry${containerId}`
+  );
+  return false;
+}
 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;
+    const ownsMeasuredItem = measurement.containerId === void 0 || isContainerItemCurrent(ctx, measurement.containerId, measurement.itemKey);
     if (ownsMeasuredItem) {
       const index = state.indexByKey.get(measurement.itemKey);
       const itemData = index === void 0 ? void 0 : (_a3 = state.props.data) == null ? void 0 : _a3[index];
@@ -5496,7 +5501,7 @@ function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
     const viewRef = ctx.viewRefs.get(containerId);
     const itemKey = peek$(ctx, `containerItemKey${containerId}`);
     const element = viewRef == null ? void 0 : viewRef.current;
-    if (itemKey !== void 0 && element) {
+    if (itemKey !== void 0 && element && isContainerItemCurrent(ctx, containerId, itemKey)) {
       const generation = (_b = ctx.state.containerItemGenerations[containerId]) != null ? _b : 0;
       const rect = element.getBoundingClientRect();
       setContainerLayoutBaseline(element, rect);
@@ -5530,7 +5535,7 @@ function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
           return index === void 0 || index < state.startBuffered || index > state.endBuffered || measuredKeys.has(key);
         });
         const physicalMax = (_e = (_d = state.refScroller.current) == null ? void 0 : _d.getMaxScrollOffset) == null ? void 0 : _e.call(_d);
-        const layoutMax = Math.max(0, getContentSize(ctx) - state.scrollLength);
+        const layoutMax = getScrollRangeEnd(ctx);
         if (isCurrentViewportMeasured && isCurrentBufferMeasured && physicalMax !== void 0 && Math.abs(physicalMax - layoutMax) <= 1) {
           evaluateBootstrapInitialScroll(ctx);
         }
@@ -6985,7 +6990,8 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
           if (isWheel && !wheelAccepted) wheelStartedNested = true;
           return false;
         }
-        if (explicit ? !keepsExplicitOwner : direction <= 0) interruptUserScroll(ctx);
+        if ((explicit ? !keepsExplicitOwner : direction <= 0) && interruptUserScroll(ctx, isWheel && event.cancelable ? direction : 0) && event.cancelable)
+          event.preventDefault();
         if (isNew) (_b2 = (_a4 = state.props).onUserScroll) == null ? void 0 : _b2.call(_a4);
         return true;
       }
@@ -6997,11 +7003,15 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     const inputDirection = (delta) => isHorizontalRTL(ctx.state) && getNativeHorizontalRTLScrollType(ctx.state) !== "normal" ? -delta : delta;
     const onWheel = (nativeEvent) => {
       const event = nativeEvent;
-      const delta = horizontal ? event.deltaX || (event.shiftKey ? event.deltaY : 0) : event.deltaY;
+      const delta = normalizeWheelDelta(
+        horizontal ? event.deltaX || (event.shiftKey ? event.deltaY : 0) : event.deltaY,
+        event.deltaMode,
+        ctx.state.scrollLength
+      );
       if (delta !== 0 && !event.ctrlKey && !event.defaultPrevented) {
         wheelGesture = getWheelGesture(
           wheelGesture,
-          normalizeWheelDelta(delta, event.deltaMode, ctx.state.scrollLength),
+          delta,
           event.timeStamp,
           event.momentum
         );
@@ -7071,7 +7081,15 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       scrollbarPressOffset = void 0;
       if (offset !== void 0 && getCurrentScrollOffset() === offset) rearmEndFollowIfSettled(ctx);
     };
-    target.addEventListener("wheel", onWheel, { passive: true });
+    let wheelPassive;
+    const setWheelPassive = (passive) => {
+      if (passive === wheelPassive) return;
+      if (wheelPassive !== void 0) target.removeEventListener("wheel", onWheel);
+      target.addEventListener("wheel", onWheel, { passive });
+      wheelPassive = passive;
+    };
+    setWheelPassive(!peek$(ctx, "isScrollActive"));
+    const unlistenScrollActive = listen$(ctx, "isScrollActive", (active) => setWheelPassive(!active));
     target.addEventListener("touchstart", onTouchStart, { passive: true });
     target.addEventListener("touchmove", onTouchMove, { passive: true });
     target.addEventListener("keydown", onKeyDown);
@@ -7079,6 +7097,7 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     target.addEventListener("pointerup", onPointerRelease);
     target.addEventListener("pointercancel", onPointerRelease);
     return () => {
+      unlistenScrollActive();
       target.removeEventListener("wheel", onWheel);
       target.removeEventListener("touchstart", onTouchStart);
       target.removeEventListener("touchmove", onTouchMove);
@@ -7501,6 +7520,14 @@ var ListComponent = typedMemo(function ListComponent2({
     },
     [ctx, onScrollToTop]
   );
+  const { onContentSizeChange } = rest;
+  React3.useCallback(
+    (width, height) => {
+      reissueClampedNativeEndScroll(ctx);
+      onContentSizeChange == null ? void 0 : onContentSizeChange(width, height);
+    },
+    [ctx, onContentSizeChange]
+  );
   const onLayoutHeader = React3.useCallback(
     (rect) => {
       const size = rect[horizontal ? "width" : "height"];
@@ -7656,6 +7683,7 @@ function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {})
     state.positionRecalculationStartIndex = 0;
     state.scrollForNextCalculateItemsInView = void 0;
   }
+  state.positionsAreCurrent = false;
   calculateItemsInView(ctx, { dataChanged: true, doMVCP: true });
   if ((_a3 = state.pendingEndMeasurements) == null ? void 0 : _a3.size) {
     const removedMeasurements = new Set(state.pendingEndMeasurements);
@@ -7678,9 +7706,6 @@ function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {})
   if (!didMaintainScrollAtEnd && !state.pendingMaintainScrollAtEnd) {
     state.pendingEndMeasurements = void 0;
   }
-  if (!didMaintainScrollAtEnd && previousData && dataProp.length > previousData.length) {
-    state.isEndReached = false;
-  }
   if (!didMaintainScrollAtEnd) {
     checkThresholds(ctx);
   }
@@ -7803,6 +7828,7 @@ function scrollToIndex(ctx, {
   animated = true,
   forceScroll,
   isInitialScroll,
+  clampToContentContainerMinSize,
   viewPosition,
   viewPositionFallback
 }) {
@@ -7818,6 +7844,7 @@ function scrollToIndex(ctx, {
   state.scrollForNextCalculateItemsInView = void 0;
   scrollTo(ctx, {
     animated,
+    clampToContentContainerMinSize,
     forceScroll,
     index,
     isInitialScroll,
@@ -8106,7 +8133,7 @@ var ScrollAdjustHandler = class {
           targetScroll = clampScrollOffset(this.ctx, targetScroll, scrollTarget);
         } else {
           targetScroll = clampScrollOffset(this.ctx, state.scroll + pending - superseded, {
-            clampToContentContainerMinSize: scrollTarget == null ? void 0 : scrollTarget.clampToContentContainerMinSize
+            clampToContentContainerMinSize: !scrollTarget || scrollTarget.clampToContentContainerMinSize
           });
         }
         const adjustment = targetScroll - state.scroll;
@@ -8135,6 +8162,7 @@ function scrollToEnd(ctx, options) {
   const footerSize = peek$(ctx, "footerSize") || 0;
   scrollToIndex(ctx, {
     ...options,
+    clampToContentContainerMinSize: true,
     index,
     viewOffset: getEndAlignedViewOffset(paddingBottom, footerSize) + ((options == null ? void 0 : options.viewOffset) || 0),
     viewPosition: 1
@@ -8354,9 +8382,10 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     const observed = getObservedScrollOffset(ctx);
     const position = calculateOffsetForIndex(ctx, index) + getStartOffsetAdjustment(ctx) + (itemOffset != null ? itemOffset : 0);
     const size = hasRegion ? itemLength != null ? itemLength : 0 : ((_a3 = getItemSizeAtIndex(ctx, index)) != null ? _a3 : 0) - ctx.scrollAxisGap;
-    const viewportLength = state.scrollLength - getContentInsetEnd(ctx);
-    const viewportStart = observed + ((_b = viewportMargin == null ? void 0 : viewportMargin.start) != null ? _b : 0);
-    const viewportEnd = observed + viewportLength - ((_c = viewportMargin == null ? void 0 : viewportMargin.end) != null ? _c : 0);
+    const insetTop = getContentInsetTop(ctx);
+    const viewportLength = state.scrollLength - insetTop - getContentInsetEnd(ctx);
+    const viewportStart = observed + insetTop + ((_b = viewportMargin == null ? void 0 : viewportMargin.start) != null ? _b : 0);
+    const viewportEnd = observed + insetTop + viewportLength - ((_c = viewportMargin == null ? void 0 : viewportMargin.end) != null ? _c : 0);
     if (!hasRegion && position <= viewportStart && position + size >= viewportEnd) return false;
     const above = position < viewportStart;
     const below = position + size > viewportEnd;
@@ -8791,7 +8820,7 @@ var LegendList = typedMemo(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+  var _a3, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
   React3.useEffect(subscribeScreenReader, []);
   const noopOnScroll = React3.useCallback((_event) => {
   }, []);
@@ -8916,7 +8945,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const hasInitialScrollIndex = initialScrollIndexProp !== void 0 && initialScrollIndexProp !== null;
   const hasInitialScrollOffset = initialScrollOffsetProp !== void 0 && initialScrollOffsetProp !== null;
   const shouldInitializeHorizontalRTL = !initialScrollAtEnd && !hasInitialScrollIndex && !hasInitialScrollOffset && isHorizontalRTLProps({ horizontal, rtl });
-  const initialScrollUsesOffsetOnly = !initialScrollAtEnd && !hasInitialScrollIndex && (hasInitialScrollOffset || shouldInitializeHorizontalRTL);
+  const initialInsetTop = 0;
+  const initialScrollUsesOffsetOnly = !initialScrollAtEnd && !hasInitialScrollIndex && (hasInitialScrollOffset || shouldInitializeHorizontalRTL || initialInsetTop > 0);
   const usesBootstrapInitialScroll = initialScrollAtEnd || hasInitialScrollIndex;
   const shouldBottomAlignNumericInitialScrollIndex = typeof initialScrollIndexProp === "number" && !hasInitialScrollOffset && dataProp.length > 1 && initialScrollIndexProp >= dataProp.length - 1;
   const initialScrollProp = initialScrollAtEnd ? {
@@ -8925,10 +8955,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     viewOffset: getEndAlignedViewOffset(stylePaddingEndState),
     viewPosition: 1
   } : hasInitialScrollIndex ? typeof initialScrollIndexProp === "object" ? {
-    index: (_b = initialScrollIndexProp.index) != null ? _b : 0,
+    index: (_c = initialScrollIndexProp.index) != null ? _c : 0,
     preserveForBottomPadding: initialScrollIndexProp.viewOffset === void 0 && initialScrollIndexProp.viewPosition === 1 && initialScrollIndexProp.viewPositionFallback === void 0 ? true : void 0,
-    viewOffset: (_c = initialScrollIndexProp.viewOffset) != null ? _c : initialScrollIndexProp.viewPosition === 1 && initialScrollIndexProp.viewPositionFallback === void 0 ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
-    viewPosition: (_d = initialScrollIndexProp.viewPosition) != null ? _d : 0,
+    viewOffset: (_d = initialScrollIndexProp.viewOffset) != null ? _d : initialScrollIndexProp.viewPosition === 1 && initialScrollIndexProp.viewPositionFallback === void 0 ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
+    viewPosition: (_e = initialScrollIndexProp.viewPosition) != null ? _e : 0,
     viewPositionFallback: initialScrollIndexProp.viewPositionFallback
   } : {
     index: initialScrollIndexProp != null ? initialScrollIndexProp : 0,
@@ -8936,7 +8966,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     viewOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : shouldBottomAlignNumericInitialScrollIndex ? getEndAlignedViewOffset(stylePaddingEndState) : 0,
     viewPosition: shouldBottomAlignNumericInitialScrollIndex ? 1 : void 0
   } : initialScrollUsesOffsetOnly ? {
-    contentOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : 0,
+    contentOffset: initialScrollOffsetProp != null ? initialScrollOffsetProp : -initialInsetTop,
     index: 0,
     viewOffset: 0
   } : void 0;
@@ -8944,7 +8974,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const [, scheduleImperativeScrollCommit] = React3__namespace.useReducer((value) => value + 1, 0);
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
-  const scrollAxisGap = horizontal ? (_g = (_e = ctx.columnWrapperStyle) == null ? void 0 : _e.columnGap) != null ? _g : (_f = ctx.columnWrapperStyle) == null ? void 0 : _f.gap : (_j = (_h = ctx.columnWrapperStyle) == null ? void 0 : _h.rowGap) != null ? _j : (_i = ctx.columnWrapperStyle) == null ? void 0 : _i.gap;
+  const scrollAxisGap = horizontal ? (_h = (_f = ctx.columnWrapperStyle) == null ? void 0 : _f.columnGap) != null ? _h : (_g = ctx.columnWrapperStyle) == null ? void 0 : _g.gap : (_k = (_i = ctx.columnWrapperStyle) == null ? void 0 : _i.rowGap) != null ? _k : (_j = ctx.columnWrapperStyle) == null ? void 0 : _j.gap;
   const nextScrollAxisGap = typeof scrollAxisGap === "number" && Number.isFinite(scrollAxisGap) ? scrollAxisGap : 0;
   const refScroller = React3.useRef(null);
   const combinedRef = useCombinedRef(refScroller, refScrollView);
@@ -8959,8 +8989,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex,
     alwaysRender == null ? void 0 : alwaysRender.top,
     alwaysRender == null ? void 0 : alwaysRender.bottom,
-    (_k = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _k.join(","),
-    (_l = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _l.join(","),
+    (_l = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _l.join(","),
+    (_m = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _m.join(","),
     dataProp,
     dataKey,
     dataVersion,
@@ -8975,7 +9005,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   if (!refState.current) {
     if (!ctx.state) {
       const initialScrollLength = (estimatedListSize != null ? estimatedListSize : { height: 0, width: 0 } )[horizontal ? "width" : "height"];
-      ctx.values.set("adaptiveRender", (_m = experimental_adaptiveRender == null ? void 0 : experimental_adaptiveRender.initialMode) != null ? _m : "normal");
+      ctx.values.set("adaptiveRender", (_n = experimental_adaptiveRender == null ? void 0 : experimental_adaptiveRender.initialMode) != null ? _n : "normal");
       ctx.state = {
         averageSizes: {},
         columnSpans: [],
@@ -9067,13 +9097,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const didScrollAxisGapChange = !isFirstLocal && ctx.scrollAxisGap !== nextScrollAxisGap;
   ctx.scrollAxisGap = nextScrollAxisGap;
   state.didColumnsChange = numColumnsProp !== previousNumColumnsProp || didScrollAxisGapChange;
-  const previousDataLength = (_o = (_n = state.props.data) == null ? void 0 : _n.length) != null ? _o : 0;
+  const previousDataLength = (_p = (_o = state.props.data) == null ? void 0 : _o.length) != null ? _p : 0;
   const didDataReferenceChangeLocal = state.props.data !== dataProp;
   const didDataKeyChangeLocal = state.props.dataKey !== dataKey;
   const didDataVersionChangeLocal = state.props.dataVersion !== dataVersion;
   const didDataChangeLocal = didDataKeyChangeLocal || didDataVersionChangeLocal || didDataReferenceChangeLocal && checkStructuralDataChange(state, dataProp, state.props.data);
   const shouldResetFreshDataLayout = !isFirstLocal && didDataChangeLocal && state.hasHadNonEmptyData && (didDataKeyChangeLocal || previousDataLength === 0) && dataProp.length > 0;
-  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_p = state.initialScroll) == null ? void 0 : _p.viewPosition) === 1 && state.props.data.length > 0) {
+  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_q = state.initialScroll) == null ? void 0 : _q.viewPosition) === 1 && state.props.data.length > 0) {
     clearPreservedInitialScrollTarget(state);
   }
   if (didDataChangeLocal) {
@@ -9089,7 +9119,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
   const throttledOnScroll = useThrottledOnScroll(onScrollProp != null ? onScrollProp : noopOnScroll, scrollEventThrottle != null ? scrollEventThrottle : 0);
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? throttledOnScroll : onScrollProp;
-  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_q = state.props.anchoredEndSpace) == null ? void 0 : _q.anchorIndex) !== (anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex);
+  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_r = state.props.anchoredEndSpace) == null ? void 0 : _r.anchorIndex) !== (anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex);
   state.props = {
     adaptiveRender: experimental_adaptiveRender,
     alignItemsAtEnd,
@@ -9272,6 +9302,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorIndex,
     anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorMaxSize,
     anchoredEndSpace == null ? void 0 : anchoredEndSpace.anchorOffset,
+    anchoredEndSpaceOwner,
+    contentInset == null ? void 0 : contentInset.bottom,
+    contentInset == null ? void 0 : contentInset.left,
+    contentInset == null ? void 0 : contentInset.right,
     didAnchoredEndSpaceAnchorIndexChange,
     horizontal,
     numColumnsProp,
@@ -9331,6 +9365,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   React3.useLayoutEffect(
     () => initializeStateVars(true),
     [
+      contentInset == null ? void 0 : contentInset.bottom,
+      contentInset == null ? void 0 : contentInset.top,
       dataKey,
       dataVersion,
       memoizedLastItemKeys.join(","),
@@ -9341,6 +9377,16 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       useAlignItemsAtEndPadding
     ]
   );
+  const previousContentInsetTop = React3.useRef(contentInset == null ? void 0 : contentInset.top);
+  React3.useLayoutEffect(() => {
+    var _a4;
+    Math.max(0, (_a4 = previousContentInsetTop.current) != null ? _a4 : 0);
+    previousContentInsetTop.current !== (contentInset == null ? void 0 : contentInset.top);
+    previousContentInsetTop.current = contentInset == null ? void 0 : contentInset.top;
+  }, [contentInset == null ? void 0 : contentInset.top]);
+  React3.useLayoutEffect(() => {
+    checkThresholds(ctx);
+  }, [maintainScrollAtEndThreshold]);
   React3.useLayoutEffect(() => {
     if (!maintainScrollAtEndConfig) {
       finishMaintainScrollAtEnd(ctx);
@@ -9516,7 +9562,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React3__namespace.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_r = refreshControlElement.props.progressViewOffset) != null ? _r : 0) + stylePaddingTopState
+        progressViewOffset: ((_s = refreshControlElement.props.progressViewOffset) != null ? _s : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React3__namespace.createElement(
         RefreshControl,
         {
@@ -9527,7 +9573,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       renderScrollComponent,
-      scrollAdjustHandler: (_s = refState.current) == null ? void 0 : _s.scrollAdjustHandler,
+      scrollAdjustHandler: (_t = refState.current) == null ? void 0 : _t.scrollAdjustHandler,
       scrollElement: scrollElementResolved,
       scrollEventThrottle: 0,
       snapToIndices,