@legendapp/list 3.7.0 → 3.7.1

package/react-native.js

@@ -336,27 +336,20 @@ function getContentInsetEnd(ctx, contentInsetEndAdjustmentOverride) {
   const horizontal = props.horizontal;
   const contentInset = Platform.OS === "ios" ? props.contentInset : void 0;
   const baseInset = contentInset != null ? contentInset : 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 Platform.OS !== "web" && props.anchoredEndSpaceOwner === "list" && !isHorizontalRTL(state) ? endInset + anchoredEndInset : 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;
@@ -366,7 +359,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 = Platform.OS === "web" || isHorizontalRTL(state) ? contentInsetEnd : state.props.anchoredEndSpace && state.props.anchoredEndSpaceOwner === "list" ? values.get("anchoredEndSpaceSize") || 0 : 0;
+  const containerSize = contentSize + inContentInset;
+  return (includeContentContainerMinSize ? Math.max(containerSize, (_c = state.props.contentContainerMinSize) != null ? _c : 0) : containerSize) + contentInsetEnd - inContentInset;
 }
 
 // src/components/DebugView.tsx
@@ -521,20 +517,240 @@ var USER_MOMENTUM_STALL_TIMEOUT_MS = 500;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
 
-// src/core/calculateOffsetForIndex.ts
-function calculateOffsetForIndex(ctx, index) {
+// src/core/cancelImperativeScroll.ts
+function cancelScrollCompletionChecks({ scheduledWork }) {
+  scheduledWork.cancel("checkFinishedScrollFrame");
+  scheduledWork.cancel("checkFinishedScrollRetryFrame");
+  scheduledWork.cancel("checkFinishedScrollFallback");
+  scheduledWork.cancel("platformScrollCompletion");
+}
+function syncScrollActive(ctx) {
+  const { state } = ctx;
+  set$(
+    ctx,
+    "isScrollActive",
+    !!state.isDragging || !!state.isMomentumScrolling || !!state.scrollingTo || !!state.pendingScrollResolve
+  );
+}
+function settlePendingImperativeScroll(state) {
+  const resolvePendingScroll = state.pendingScrollResolve;
+  state.pendingScrollResolve = void 0;
+  state.pendingScrollToEnd = void 0;
+  resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+}
+function cancelImperativeScroll(state) {
+  cancelScrollCompletionChecks(state);
+  state.scheduledWork.cancel("imperativeScrollReady");
+  state.scrollingTo = void 0;
+  state.scrollTargetPinnedRange = void 0;
+  settlePendingImperativeScroll(state);
+}
+
+// src/core/clampScrollOffset.ts
+function getContentInsetTop(ctx) {
+  var _a3, _b, _c, _d;
   const state = ctx.state;
-  return index !== void 0 ? state.positions[index] || 0 : 0;
+  if (Platform.OS !== "ios" || state.props.horizontal) {
+    return 0;
+  }
+  const baseInset = (_a3 = state.props.contentInset) != null ? _a3 : state.nativeContentInset;
+  return Math.max(0, (_d = (_c = (_b = state.contentInsetOverride) == null ? void 0 : _b.top) != null ? _c : baseInset == null ? void 0 : baseInset.top) != null ? _d : 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" || state.lastLayout)) {
+    const baseMaxOffset = getScrollRangeEnd(ctx, contentSize);
+    const viewOffset = Platform.OS === "web" && (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/getStartOffsetAdjustment.ts
-function getStartOffsetAdjustment(ctx) {
+// src/core/doScrollParams.ts
+function getNativeScrollPoint(ctx, offset, horizontal = ctx.state.props.horizontal) {
+  var _a3;
   const { state } = ctx;
-  const stylePaddingStart = state.props.horizontal ? (isHorizontalRTL(state) ? state.props.stylePaddingRight : state.props.stylePaddingLeft) || 0 : peek$(ctx, "stylePaddingTop") || 0;
-  return stylePaddingStart + (peek$(ctx, "alignItemsAtEndPadding") || 0) + (peek$(ctx, "headerSize") || 0);
+  return horizontal ? {
+    x: toNativeHorizontalOffset(
+      state,
+      offset,
+      Math.max(getContentSize(ctx), (_a3 = state.props.contentContainerMinSize) != null ? _a3 : 0)
+    ),
+    y: 0
+  } : { x: 0, y: offset };
 }
-function getItemSpaceOffset(ctx, scrollOffset, pending = ((_a3) => (_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0)(), startOffset = getStartOffsetAdjustment(ctx)) {
-  return Math.round(scrollOffset + (pending - startOffset));
+
+// src/core/deferredPublicOnScroll.ts
+function withResolvedContentOffset(state, event, resolvedOffset) {
+  return {
+    ...event,
+    nativeEvent: {
+      ...event.nativeEvent,
+      contentOffset: state.props.horizontal ? { x: resolvedOffset, y: 0 } : { x: 0, y: resolvedOffset }
+    }
+  };
+}
+function releaseDeferredPublicOnScroll(ctx, resolvedOffset) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
+  const deferredEvent = state.deferredPublicOnScrollEvent;
+  state.deferredPublicOnScrollEvent = void 0;
+  if (deferredEvent) {
+    (_d = (_c = state.props).onScroll) == null ? void 0 : _d.call(
+      _c,
+      withResolvedContentOffset(
+        state,
+        deferredEvent,
+        (_b = (_a3 = resolvedOffset != null ? resolvedOffset : state.scrollPending) != null ? _a3 : state.scroll) != null ? _b : 0
+      )
+    );
+  }
+}
+
+// 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/initialScrollSession.ts
+var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
+function hasInitialScrollSessionCompletion(completion) {
+  return !!((completion == null ? void 0 : completion.didDispatchNativeScroll) || (completion == null ? void 0 : completion.didRetrySilentInitialScroll) || (completion == null ? void 0 : completion.watchdog));
+}
+function clearInitialScrollSession(state) {
+  state.initialScrollSession = void 0;
+  return void 0;
+}
+function createInitialScrollSession(options) {
+  const { bootstrap, completion, kind, previousDataLength } = options;
+  return kind === "offset" ? {
+    completion,
+    kind,
+    previousDataLength
+  } : {
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  };
+}
+function ensureInitialScrollSessionCompletion(state, kind = ((_b) => (_b = ((_a3) => (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind)()) != null ? _b : "bootstrap")()) {
+  var _a4, _b2;
+  if (!state.initialScrollSession) {
+    state.initialScrollSession = createInitialScrollSession({
+      completion: {},
+      kind,
+      previousDataLength: 0
+    });
+  } else if (state.initialScrollSession.kind !== kind) {
+    state.initialScrollSession = createInitialScrollSession({
+      bootstrap: state.initialScrollSession.kind === "bootstrap" ? state.initialScrollSession.bootstrap : void 0,
+      completion: state.initialScrollSession.completion,
+      kind,
+      previousDataLength: state.initialScrollSession.previousDataLength
+    });
+  }
+  (_b2 = (_a4 = state.initialScrollSession).completion) != null ? _b2 : _a4.completion = {};
+  return state.initialScrollSession.completion;
+}
+var initialScrollCompletion = {
+  didDispatchNativeScroll(state) {
+    var _a3, _b;
+    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didDispatchNativeScroll);
+  },
+  didRetrySilentInitialScroll(state) {
+    var _a3, _b;
+    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didRetrySilentInitialScroll);
+  },
+  markInitialScrollNativeDispatch(state) {
+    ensureInitialScrollSessionCompletion(state).didDispatchNativeScroll = true;
+  },
+  markSilentInitialScrollRetry(state) {
+    ensureInitialScrollSessionCompletion(state).didRetrySilentInitialScroll = true;
+  },
+  resetFlags(state) {
+    if (!state.initialScrollSession) {
+      return;
+    }
+    const completion = ensureInitialScrollSessionCompletion(state, state.initialScrollSession.kind);
+    completion.didDispatchNativeScroll = void 0;
+    completion.didRetrySilentInitialScroll = void 0;
+  }
+};
+var initialScrollWatchdog = {
+  clear(state) {
+    initialScrollWatchdog.set(state, void 0);
+  },
+  didReachTarget(newScroll, watchdog) {
+    const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
+    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  get(state) {
+    var _a3, _b;
+    return (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog;
+  },
+  hasNonZeroTargetOffset(targetOffset) {
+    return targetOffset !== void 0 && targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  isAtZeroTargetOffset(targetOffset) {
+    return targetOffset <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  set(state, watchdog) {
+    var _a3, _b;
+    if (!watchdog && !((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog)) {
+      return;
+    }
+    const completion = ensureInitialScrollSessionCompletion(state);
+    completion.watchdog = watchdog ? {
+      startScroll: watchdog.startScroll,
+      targetOffset: watchdog.targetOffset
+    } : void 0;
+  }
+};
+function setInitialScrollSession(state, options = {}) {
+  var _a3, _b, _c, _d;
+  const existingSession = state.initialScrollSession;
+  const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
+  const completion = existingSession == null ? void 0 : existingSession.completion;
+  const existingBootstrap = (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0;
+  const bootstrap = kind === "bootstrap" ? options.bootstrap === null ? void 0 : (_b = options.bootstrap) != null ? _b : existingBootstrap : void 0;
+  if (!kind) {
+    return clearInitialScrollSession(state);
+  }
+  if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
+    return clearInitialScrollSession(state);
+  }
+  const previousDataLength = (_d = (_c = options.previousDataLength) != null ? _c : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _d : 0;
+  state.initialScrollSession = createInitialScrollSession({
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  });
+  return state.initialScrollSession;
+}
+
+// src/core/observedScroll.ts
+function getObservedScrollOffset(ctx, fallbackOffset = ctx.state.scroll) {
+  var _a3, _b, _c;
+  const { state } = ctx;
+  const scroller = state.refScroller.current;
+  const observed = (_a3 = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _a3.call(scroller);
+  if (observed === void 0) return (_b = state.lastNativeScroll) != null ? _b : fallbackOffset;
+  return state.props.horizontal ? peekLogicalHorizontalOffset(state, observed, (_c = scroller.getMaxScrollOffset) == null ? void 0 : _c.call(scroller)) : observed;
 }
 
 // src/core/updateContentMetricsState.ts
@@ -546,7 +762,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;
@@ -568,1012 +784,785 @@ function updateContentMetricsState(ctx) {
   }
 }
 
-// src/core/addTotalSize.ts
-function addTotalSize(ctx, key, add, notifyTotalSize = true) {
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, source) {
+  var _a3;
   const state = ctx.state;
-  const prevTotalSize = state.totalSize;
-  let totalSize = state.totalSize;
-  if (key === null) {
-    totalSize = add;
-    if (state.timeoutSetPaddingTop) {
-      clearTimeout(state.timeoutSetPaddingTop);
-      state.timeoutSetPaddingTop = void 0;
-    }
-  } else {
-    totalSize += add;
-  }
-  if (prevTotalSize !== totalSize) {
-    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
-      state.pendingTotalSize = totalSize;
-    } else {
-      state.pendingTotalSize = void 0;
-      state.totalSize = totalSize;
-      if (notifyTotalSize) {
-        set$(ctx, "totalSize", totalSize);
-      }
-      updateContentMetricsState(ctx);
+  if (Math.abs(positionDiff) > 0.1) {
+    state.layoutAdjustmentEpoch = ((_a3 = state.layoutAdjustmentEpoch) != null ? _a3 : 0) + 1;
+    const dataChanged = source === "data";
+    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
+    const doit = () => {
+      if (needsScrollWorkaround) {
+        ctx.doScrollTo({ horizontal: state.props.horizontal, isAdjustment: true, offset: state.scroll });
+      } else {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
+      }
+    };
+    state.scroll += positionDiff;
+    if (state.userScrollContentSize !== void 0) {
+      state.userScrollContentSize += positionDiff;
+    }
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+      if (Platform.OS !== "web" && source !== "item-size") {
+        const threshold = state.scroll - positionDiff / 2;
+        if (!state.ignoreScrollFromMVCP) {
+          state.ignoreScrollFromMVCP = {};
+        }
+        if (positionDiff > 0) {
+          state.ignoreScrollFromMVCP.lt = threshold;
+        } else {
+          state.ignoreScrollFromMVCP.gt = threshold;
+        }
+        const delay = needsScrollWorkaround ? 250 : 100;
+        state.scheduledWork.timeout(
+          () => {
+            var _a4;
+            state.ignoreScrollFromMVCP = void 0;
+            const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
+            if (shouldForceUpdate) {
+              state.ignoreScrollFromMVCPIgnored = false;
+              state.scrollPending = state.scroll;
+              (_a4 = state.reprocessCurrentScroll) == null ? void 0 : _a4.call(state);
+            }
+          },
+          delay,
+          "ignoreScrollFromMVCP"
+        );
+      }
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
     }
-  } else if (notifyTotalSize && ctx.values.get("totalSize") !== totalSize) {
-    set$(ctx, "totalSize", totalSize);
   }
 }
 
-// src/core/setSize.ts
-function setSize(ctx, itemKey, size, notifyTotalSize = true) {
-  const state = ctx.state;
-  const { sizes } = state;
-  const previousSize = sizes.get(itemKey);
-  const diff = previousSize !== void 0 ? size - previousSize : size;
-  if (diff !== 0) {
-    state.positionsAreCurrent = false;
-    addTotalSize(ctx, itemKey, diff, notifyTotalSize);
+// src/core/finishMaintainScrollAtEnd.ts
+function interruptMaintainScrollAtEnd(ctx) {
+  var _a3;
+  const { state } = ctx;
+  const maintaining = state.maintainingScrollAtEnd;
+  state.endFollowInterrupted = true;
+  set$(ctx, "isFollowingEnd", false);
+  if (maintaining === "animated" || maintaining === "instant" || maintaining && ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isScrollToEnd)) {
+    cancelImperativeScroll(state);
+    syncScrollActive(ctx);
   }
-  sizes.set(itemKey, size);
-}
-
-// src/utils/helpers.ts
-function isFunction(obj) {
-  return typeof obj === "function";
-}
-function isArray(obj) {
-  return Array.isArray(obj);
-}
-var warned = /* @__PURE__ */ new Set();
-function warnDevOnce(id, text) {
-  if (IS_DEV && !warned.has(id)) {
-    warned.add(id);
-    console.warn(`[legend-list] ${text}`);
+  if (maintaining || state.pendingMaintainScrollAtEnd) {
+    finishMaintainScrollAtEnd(ctx);
   }
 }
-function roundSize(size) {
-  return Math.floor(size * 8) / 8;
-}
-function isNullOrUndefined(value) {
-  return value === null || value === void 0;
-}
-function getPadding(s, type) {
-  var _a3, _b, _c;
-  const axisPadding = type === "Left" || type === "Right" ? s.paddingHorizontal : s.paddingVertical;
-  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : axisPadding) != null ? _b : s.padding) != null ? _c : 0;
+function armAppScrollRearm(ctx) {
+  ctx.state.scheduledWork.timeout(
+    () => rearmEndFollowIfSettled(ctx),
+    USER_MOMENTUM_STALL_TIMEOUT_MS,
+    "appScrollRearm"
+  );
 }
-function extractPadding(style, contentContainerStyle, type) {
-  return getPadding(style, type) + getPadding(contentContainerStyle, type);
+function rearmEndFollowIfSettled(ctx) {
+  const { state } = ctx;
+  if (state.endFollowInterrupted && (!state.visibleContentAnchor || state.visibleContentAnchor.sizeOnly) && !state.isDragging && state.userScrollContentSize === void 0 && !state.scheduledWork.has("appScrollRearm") && !state.scrollingTo && !state.pendingScrollResolve && peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
+    state.endFollowInterrupted = false;
+    if (state.props.maintainScrollAtEnd) set$(ctx, "isFollowingEnd", true);
+  }
 }
-function findContainerId(ctx, key) {
+function finishMaintainScrollAtEnd(ctx) {
   var _a3, _b;
-  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
-  if (directMatch !== void 0) {
-    return directMatch;
+  const { state } = ctx;
+  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
+  const nextPadding = getAlignItemsAtEndPadding(ctx);
+  state.maintainingScrollAtEnd = void 0;
+  state.pendingMaintainScrollAtEnd = false;
+  for (const key of (_a3 = state.pendingEndMeasurements) != null ? _a3 : []) {
+    if (!state.containerItemKeys.has(key)) state.pendingEndMeasurements.delete(key);
   }
-  const numContainers = peek$(ctx, "numContainers");
-  for (let i = 0; i < numContainers; i++) {
-    const itemKey = peek$(ctx, `containerItemKey${i}`);
-    if (itemKey === key) {
-      return i;
-    }
+  if (currentPadding !== nextPadding) {
+    set$(ctx, "alignItemsAtEndPadding", nextPadding);
+    state.scrollForNextCalculateItemsInView = void 0;
+    (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
+    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
+    const nativeScroll = Platform.OS === "ios" ? clampScrollOffset(ctx, state.scroll) : state.scroll;
+    state.scroll = nativeScroll;
+    requestAdjust(ctx, nextScroll - nativeScroll);
   }
-  return -1;
 }
 
-// src/utils/getItemSize.ts
-function getKnownOrFixedSize(ctx, key, index, data, resolved) {
-  var _a3, _b, _c, _d;
-  const state = ctx.state;
-  const { getFixedItemSize, getItemType } = state.props;
-  let size = key ? state.sizesKnown.get(key) : void 0;
-  if (size === void 0 && key && getFixedItemSize) {
-    const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-    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.positionRecalculationStartIndex = Math.min((_c = state.positionRecalculationStartIndex) != null ? _c : index, index);
-      state.scrollForNextCalculateItemsInView = void 0;
-      state.sizesKnown.set(key, size);
-      (_d = state.fixedItemSizeKeys) != null ? _d : state.fixedItemSizeKeys = /* @__PURE__ */ new Set();
-      state.fixedItemSizeKeys.add(key);
-    }
-  }
-  return size;
+// src/utils/checkThreshold.ts
+var HYSTERESIS_MULTIPLIER = 1.3;
+function isOutsideThresholdHysteresis(distance, atThreshold, threshold) {
+  const absDistance = Math.abs(distance);
+  return !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
 }
-function getKnownOrFixedItemSize(ctx, index) {
-  const key = getId(ctx.state, index);
-  return getKnownOrFixedSize(ctx, key, index, ctx.state.props.data[index]);
+function didThresholdDataChange(snapshot, context) {
+  return !!snapshot && (snapshot.dataLength !== context.dataLength || snapshot.data !== context.data && snapshot.contentSize !== context.contentSize);
 }
-function areKnownOrFixedItemSizesAvailable(ctx, startIndex, endIndex) {
-  for (let index = startIndex; index <= endIndex; index++) {
-    if (getKnownOrFixedItemSize(ctx, index) === void 0) {
-      return false;
+var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot) => {
+  const absDistance = Math.abs(distance);
+  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);
     }
+    return false;
   }
-  return true;
+  if ((!wasReached || didThresholdDataChange(snapshot, context)) && onReached(distance)) {
+    return true;
+  }
+  return !!wasReached;
+};
+
+// src/utils/edgeReachedGate.ts
+function getDistanceFromStart(ctx) {
+  return ctx.state.scroll + getContentInsetTop(ctx);
 }
-function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize, notifyTotalSize, resolved) {
-  var _a3, _b, _c, _d;
+function resetSharedEdgeGateIfOutsideHysteresis(ctx) {
   const state = ctx.state;
-  const {
-    sizes,
-    averageSizes,
-    props: { estimatedItemSize, getItemType },
-    scrollingTo
-  } = state;
-  const sizeKnown = state.sizesKnown.get(key);
-  if (sizeKnown !== void 0) {
-    return sizeKnown;
-  }
-  const renderedSize = sizes.get(key);
-  let size = getKnownOrFixedSize(ctx, key, index, data, resolved);
-  if (size !== void 0) {
-    setSize(ctx, key, size, notifyTotalSize);
-    return size;
-  }
-  if (preferCachedSize && renderedSize !== void 0) {
-    return renderedSize;
-  }
-  const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-  if (useAverageSize && !scrollingTo) {
-    const averageSizeForType = (_c = averageSizes[itemType]) == null ? void 0 : _c.avg;
-    if (averageSizeForType !== void 0) {
-      size = roundSize(averageSizeForType);
-    }
-  }
-  if (size === void 0 && renderedSize !== void 0) {
-    return renderedSize;
+  if (!state.edgeReachedGate || state.edgeReachedGateScroll === state.scroll) {
+    return;
   }
-  if (size === void 0 && useAverageSize && scrollingTo) {
-    const averageSizeForType = (_d = scrollingTo.averageSizeSnapshot) == null ? void 0 : _d[itemType];
-    if (averageSizeForType !== void 0) {
-      size = roundSize(averageSizeForType);
-    }
+  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(getDistanceFromStart(ctx), false, startThreshold);
+  const isOutsideEnd = isOutsideThresholdHysteresis(endDistance, isContentLess, endThreshold);
+  if (isOutsideStart && isOutsideEnd) {
+    state.edgeReachedGate = void 0;
   }
-  if (size === void 0) {
-    size = estimatedItemSize + ctx.scrollAxisGap;
+}
+function canDispatchReachedEdge(ctx, edge, allowedEdge, allowGateCreatedInCurrentCheck) {
+  const state = ctx.state;
+  return !state.edgeReachedGate || allowedEdge === edge || !!allowGateCreatedInCurrentCheck || didThresholdDataChange(
+    edge === "start" ? state.startReachedSnapshot : state.endReachedSnapshot,
+    getThresholdSnapshot(ctx)
+  );
+}
+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) {
+    ctx.state.edgeReachedGate = "prepared";
   }
-  setSize(ctx, key, size, notifyTotalSize);
-  return size;
 }
-function getItemSizeAtIndex(ctx, index) {
-  if (index === void 0 || index < 0) {
+function beginReachedEdgeUserScroll(ctx, scrollDelta) {
+  const state = ctx.state;
+  const allowedEdge = scrollDelta < 0 ? "start" : "end";
+  if (state.edgeReachedGate !== "prepared" && state.edgeReachedGate !== (allowedEdge === "start" ? "consumed-end" : "consumed-start")) {
     return void 0;
   }
-  const targetId = getId(ctx.state, index);
-  return getItemSize(ctx, targetId, index, ctx.state.props.data[index]);
+  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;
 }
 
-// src/core/calculateOffsetWithOffsetPosition.ts
-function getViewPositionOffset(availableSpace, viewPosition, viewPositionFallback) {
-  let alignment = viewPosition;
-  if (availableSpace < 0 && viewPositionFallback !== void 0) {
-    alignment = viewPositionFallback === "start" ? 0 : 1;
-  }
-  return -alignment * availableSpace;
+// src/utils/hasActiveInitialScroll.ts
+function hasActiveInitialScroll(state) {
+  return !!(state == null ? void 0 : state.initialScroll) && !state.didFinishInitialScroll;
 }
-function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
-  var _a3;
+
+// src/utils/checkAtBottom.ts
+function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   const state = ctx.state;
-  const { index, viewOffset, viewPosition, viewPositionFallback } = params;
-  let offset = offsetParam;
-  if (viewOffset) {
-    offset -= viewOffset;
+  if (!state) {
+    return;
   }
-  if (index !== void 0) {
-    const startOffsetAdjustment = getStartOffsetAdjustment(ctx);
-    if (startOffsetAdjustment) {
-      offset += startOffsetAdjustment;
-    }
+  const {
+    queuedInitialLayout,
+    scrollLength,
+    scroll,
+    maintainingScrollAtEnd,
+    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
+  } = state;
+  const contentSize = getContentSize(ctx);
+  const distanceFromEnd = contentSize - scroll - scrollLength;
+  resetSharedEdgeGateIfOutsideHysteresis(ctx);
+  if (state.props.data.length === 0 && scrollLength > 0 && contentSize <= scrollLength) {
+    set$(ctx, "isAtEnd", true);
+    set$(ctx, "isNearEnd", true);
+    set$(ctx, "isWithinMaintainScrollAtEndThreshold", true);
+    return;
   }
-  if (viewPosition !== void 0 && index !== void 0) {
-    const dataLength = state.props.data.length;
-    if (dataLength === 0) {
-      return offset;
+  if (contentSize > 0 && queuedInitialLayout) {
+    const isContentLess = contentSize < scrollLength;
+    set$(ctx, "isAtEnd", isContentLess || distanceFromEnd <= EDGE_POSITION_EPSILON);
+    set$(ctx, "isNearEnd", isContentLess || distanceFromEnd <= onEndReachedThreshold * scrollLength);
+    set$(
+      ctx,
+      "isWithinMaintainScrollAtEndThreshold",
+      isContentLess || // A zero threshold still includes fractional offsets considered
+      // at the end; otherwise following can stop after rounding/layout.
+      distanceFromEnd <= Math.max(EDGE_POSITION_EPSILON, maintainScrollAtEndThreshold * scrollLength) || state.pendingMaintainScrollAtEnd || !!maintainingScrollAtEnd || !!peek$(ctx, "isFollowingEnd")
+    );
+    const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || maintainingScrollAtEnd;
+    if (!shouldSkipThresholdChecks) {
+      state.isEndReached = checkThreshold(
+        distanceFromEnd,
+        isContentLess,
+        onEndReachedThreshold * scrollLength,
+        state.isEndReached,
+        state.endReachedSnapshot,
+        { contentSize, data: state.props.data, dataLength: state.props.data.length, scroll },
+        (distance) => {
+          if (state.props.onEndReached && canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
+            markReachedEdge(ctx, "end");
+            state.props.onEndReached({ distanceFromEnd: distance });
+            return true;
+          }
+          return false;
+        },
+        (snapshot) => {
+          state.endReachedSnapshot = snapshot;
+        }
+      );
     }
-    const isOutOfBounds = index < 0 || index >= dataLength;
-    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
-    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;
-    offset += getViewPositionOffset(availableSpace, viewPosition, viewPositionFallback);
   }
-  return offset;
 }
 
-// src/core/cancelImperativeScroll.ts
-function cancelScrollCompletionChecks({ scheduledWork }) {
-  scheduledWork.cancel("checkFinishedScrollFrame");
-  scheduledWork.cancel("checkFinishedScrollRetryFrame");
-  scheduledWork.cancel("checkFinishedScrollFallback");
-  scheduledWork.cancel("platformScrollCompletion");
-}
-function syncScrollActive(ctx) {
-  const { state } = ctx;
-  set$(
-    ctx,
-    "isScrollActive",
-    !!state.isDragging || !!state.isMomentumScrolling || !!state.scrollingTo || !!state.pendingScrollResolve
-  );
-}
-function settlePendingImperativeScroll(state) {
-  const resolvePendingScroll = state.pendingScrollResolve;
-  state.pendingScrollResolve = void 0;
-  state.pendingScrollToEnd = void 0;
-  resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-}
-function cancelImperativeScroll(state) {
-  cancelScrollCompletionChecks(state);
-  state.scheduledWork.cancel("imperativeScrollReady");
-  state.scrollingTo = void 0;
-  state.scrollTargetPinnedRange = void 0;
-  settlePendingImperativeScroll(state);
+// src/utils/checkAtTop.ts
+function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
+  const state = ctx == null ? void 0 : ctx.state;
+  if (!state) {
+    return;
+  }
+  const {
+    props: { data, onStartReachedThreshold },
+    scrollLength
+  } = state;
+  const threshold = onStartReachedThreshold * scrollLength;
+  const distanceFromStart = getDistanceFromStart(ctx);
+  resetSharedEdgeGateIfOutsideHysteresis(ctx);
+  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(
+      distanceFromStart,
+      false,
+      threshold,
+      state.isStartReached,
+      state.startReachedSnapshot,
+      { contentSize: getContentSize(ctx), data, dataLength: data.length, scroll: state.scroll },
+      (distance) => {
+        if (state.props.onStartReached && canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
+          markReachedEdge(ctx, "start");
+          state.props.onStartReached({ distanceFromStart: distance });
+          return true;
+        }
+        return false;
+      },
+      (snapshot) => {
+        state.startReachedSnapshot = snapshot;
+      }
+    );
+  }
 }
 
-// src/core/doScrollParams.ts
-function getNativeScrollPoint(ctx, offset, horizontal = ctx.state.props.horizontal) {
-  var _a3;
-  const { state } = ctx;
-  return horizontal ? {
-    x: toNativeHorizontalOffset(
-      state,
-      offset,
-      Math.max(getContentSize(ctx), (_a3 = state.props.contentContainerMinSize) != null ? _a3 : 0)
-    ),
-    y: 0
-  } : { x: 0, y: offset };
+// src/utils/checkThresholds.ts
+function checkThresholds(ctx, allowedEdge) {
+  const allowGateCreatedInCurrentCheck = !ctx.state.edgeReachedGate;
+  checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
+  checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
+  rearmEndFollowIfSettled(ctx);
 }
 
-// src/core/deferredPublicOnScroll.ts
-function withResolvedContentOffset(state, event, resolvedOffset) {
-  return {
-    ...event,
-    nativeEvent: {
-      ...event.nativeEvent,
-      contentOffset: state.props.horizontal ? { x: resolvedOffset, y: 0 } : { x: 0, y: resolvedOffset }
-    }
-  };
-}
-function releaseDeferredPublicOnScroll(ctx, resolvedOffset) {
-  var _a3, _b, _c, _d;
+// src/core/recalculateSettledScroll.ts
+function recalculateSettledScroll(ctx) {
+  var _a3, _b;
   const state = ctx.state;
-  const deferredEvent = state.deferredPublicOnScrollEvent;
-  state.deferredPublicOnScrollEvent = void 0;
-  if (deferredEvent) {
-    (_d = (_c = state.props).onScroll) == null ? void 0 : _d.call(
-      _c,
-      withResolvedContentOffset(
-        state,
-        deferredEvent,
-        (_b = (_a3 = resolvedOffset != null ? resolvedOffset : state.scrollPending) != null ? _a3 : state.scroll) != null ? _b : 0
-      )
-    );
+  if ((_a3 = state.props) == null ? void 0 : _a3.data) {
+    (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
   }
+  checkThresholds(ctx);
 }
 
-// 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/initialScrollSession.ts
-var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
-function hasInitialScrollSessionCompletion(completion) {
-  return !!((completion == null ? void 0 : completion.didDispatchNativeScroll) || (completion == null ? void 0 : completion.didRetrySilentInitialScroll) || (completion == null ? void 0 : completion.watchdog));
+// src/core/adaptiveRender.ts
+var DEFAULT_ADAPTIVE_RENDER_ENTER_VELOCITY = 3;
+var DEFAULT_ADAPTIVE_RENDER_EXIT_VELOCITY = 1;
+var DEFAULT_ADAPTIVE_RENDER_EXIT_DELAY = 250;
+var DEFAULT_WEB_ADAPTIVE_RENDER_ENTER_VELOCITY = 6;
+var DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_VELOCITY = 3;
+var DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_DELAY = 250;
+function clearAdaptiveRenderExitTimeout(ctx) {
+  ctx.state.scheduledWork.cancel("adaptiveRender");
 }
-function clearInitialScrollSession(state) {
-  state.initialScrollSession = void 0;
-  return void 0;
+function scheduleAdaptiveRenderExit(ctx, exitDelay) {
+  const state = ctx.state;
+  clearAdaptiveRenderExitTimeout(ctx);
+  if (exitDelay <= 0) {
+    setAdaptiveRender(ctx, "normal", "scroll");
+  } else {
+    state.scheduledWork.timeout(() => setAdaptiveRender(ctx, "normal", "scroll"), exitDelay, "adaptiveRender");
+  }
 }
-function createInitialScrollSession(options) {
-  const { bootstrap, completion, kind, previousDataLength } = options;
-  return kind === "offset" ? {
-    completion,
-    kind,
-    previousDataLength
-  } : {
-    bootstrap,
-    completion,
-    kind,
-    previousDataLength
-  };
+function setAdaptiveRender(ctx, mode, reason) {
+  var _a3, _b;
+  const previousMode = peek$(ctx, "adaptiveRender");
+  if (previousMode !== mode) {
+    set$(ctx, "adaptiveRender", mode);
+    (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.onChange) == null ? void 0 : _b.call(_a3, mode, reason);
+  }
 }
-function ensureInitialScrollSessionCompletion(state, kind = ((_b) => (_b = ((_a3) => (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind)()) != null ? _b : "bootstrap")()) {
-  var _a4, _b2;
-  if (!state.initialScrollSession) {
-    state.initialScrollSession = createInitialScrollSession({
-      completion: {},
-      kind,
-      previousDataLength: 0
-    });
-  } else if (state.initialScrollSession.kind !== kind) {
-    state.initialScrollSession = createInitialScrollSession({
-      bootstrap: state.initialScrollSession.kind === "bootstrap" ? state.initialScrollSession.bootstrap : void 0,
-      completion: state.initialScrollSession.completion,
-      kind,
-      previousDataLength: state.initialScrollSession.previousDataLength
-    });
+function resetAdaptiveRender(ctx) {
+  var _a3, _b;
+  clearAdaptiveRenderExitTimeout(ctx);
+  const mode = (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.initialMode) != null ? _b : "normal";
+  if (peek$(ctx, "adaptiveRender") !== mode) {
+    setAdaptiveRender(ctx, mode, "initial");
   }
-  (_b2 = (_a4 = state.initialScrollSession).completion) != null ? _b2 : _a4.completion = {};
-  return state.initialScrollSession.completion;
 }
-var initialScrollCompletion = {
-  didDispatchNativeScroll(state) {
-    var _a3, _b;
-    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didDispatchNativeScroll);
-  },
-  didRetrySilentInitialScroll(state) {
-    var _a3, _b;
-    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didRetrySilentInitialScroll);
-  },
-  markInitialScrollNativeDispatch(state) {
-    ensureInitialScrollSessionCompletion(state).didDispatchNativeScroll = true;
-  },
-  markSilentInitialScrollRetry(state) {
-    ensureInitialScrollSessionCompletion(state).didRetrySilentInitialScroll = true;
-  },
-  resetFlags(state) {
-    if (!state.initialScrollSession) {
-      return;
-    }
-    const completion = ensureInitialScrollSessionCompletion(state, state.initialScrollSession.kind);
-    completion.didDispatchNativeScroll = void 0;
-    completion.didRetrySilentInitialScroll = void 0;
-  }
-};
-var initialScrollWatchdog = {
-  clear(state) {
-    initialScrollWatchdog.set(state, void 0);
-  },
-  didReachTarget(newScroll, watchdog) {
-    const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
-    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  get(state) {
-    var _a3, _b;
-    return (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog;
-  },
-  hasNonZeroTargetOffset(targetOffset) {
-    return targetOffset !== void 0 && targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  isAtZeroTargetOffset(targetOffset) {
-    return targetOffset <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  set(state, watchdog) {
-    var _a3, _b;
-    if (!watchdog && !((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog)) {
-      return;
-    }
-    const completion = ensureInitialScrollSessionCompletion(state);
-    completion.watchdog = watchdog ? {
-      startScroll: watchdog.startScroll,
-      targetOffset: watchdog.targetOffset
-    } : void 0;
-  }
-};
-function setInitialScrollSession(state, options = {}) {
-  var _a3, _b, _c, _d;
-  const existingSession = state.initialScrollSession;
-  const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
-  const completion = existingSession == null ? void 0 : existingSession.completion;
-  const existingBootstrap = (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0;
-  const bootstrap = kind === "bootstrap" ? options.bootstrap === null ? void 0 : (_b = options.bootstrap) != null ? _b : existingBootstrap : void 0;
-  if (!kind) {
-    return clearInitialScrollSession(state);
-  }
-  if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
-    return clearInitialScrollSession(state);
-  }
-  const previousDataLength = (_d = (_c = options.previousDataLength) != null ? _c : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _d : 0;
-  state.initialScrollSession = createInitialScrollSession({
-    bootstrap,
-    completion,
-    kind,
-    previousDataLength
-  });
-  return state.initialScrollSession;
-}
-
-// src/core/observedScroll.ts
-function getObservedScrollOffset(ctx, fallbackOffset = ctx.state.scroll) {
+function updateAdaptiveRender(ctx, scrollVelocity, options) {
   var _a3, _b, _c;
-  const { state } = ctx;
-  const scroller = state.refScroller.current;
-  const observed = (_a3 = scroller == null ? void 0 : scroller.getCurrentScrollOffset) == null ? void 0 : _a3.call(scroller);
-  if (observed === void 0) return (_b = state.lastNativeScroll) != null ? _b : fallbackOffset;
-  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" || state.lastLayout)) {
-    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
-    const viewOffset = Platform.OS === "web" && (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/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, source) {
-  var _a3;
   const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    state.layoutAdjustmentEpoch = ((_a3 = state.layoutAdjustmentEpoch) != null ? _a3 : 0) + 1;
-    const dataChanged = source === "data";
-    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
-    const doit = () => {
-      if (needsScrollWorkaround) {
-        ctx.doScrollTo({ horizontal: state.props.horizontal, isAdjustment: true, offset: state.scroll });
-      } else {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
-        }
-      }
-    };
-    state.scroll += positionDiff;
-    if (state.userScrollContentSize !== void 0) {
-      state.userScrollContentSize += positionDiff;
-    }
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-      if (Platform.OS !== "web" && source !== "item-size") {
-        const threshold = state.scroll - positionDiff / 2;
-        if (!state.ignoreScrollFromMVCP) {
-          state.ignoreScrollFromMVCP = {};
-        }
-        if (positionDiff > 0) {
-          state.ignoreScrollFromMVCP.lt = threshold;
-        } else {
-          state.ignoreScrollFromMVCP.gt = threshold;
+  const adaptiveRender = state.props.adaptiveRender;
+  const currentMode = peek$(ctx, "adaptiveRender");
+  if (peek$(ctx, "readyToRender")) {
+    if (adaptiveRender) {
+      const isWeb = Platform.OS === "web";
+      const enterVelocity = (_a3 = adaptiveRender.enterVelocity) != null ? _a3 : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_ENTER_VELOCITY : DEFAULT_ADAPTIVE_RENDER_ENTER_VELOCITY;
+      const exitVelocity = (_b = adaptiveRender.exitVelocity) != null ? _b : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_VELOCITY : DEFAULT_ADAPTIVE_RENDER_EXIT_VELOCITY;
+      const exitDelay = (_c = adaptiveRender.exitDelay) != null ? _c : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_DELAY : DEFAULT_ADAPTIVE_RENDER_EXIT_DELAY;
+      const threshold = currentMode === "light" ? exitVelocity : enterVelocity;
+      const nextMode = (options == null ? void 0 : options.forceLight) || Math.abs(scrollVelocity) > threshold ? "light" : "normal";
+      const previousMode = state.scheduledWork.has("adaptiveRender") ? "normal" : currentMode;
+      if (nextMode !== previousMode) {
+        if (nextMode === "light") {
+          setAdaptiveRender(ctx, "light", "scroll");
+          scheduleAdaptiveRenderExit(ctx, exitDelay);
+        } else if (currentMode === "light") {
+          scheduleAdaptiveRenderExit(ctx, exitDelay);
         }
-        const delay = needsScrollWorkaround ? 250 : 100;
-        state.scheduledWork.timeout(
-          () => {
-            var _a4;
-            state.ignoreScrollFromMVCP = void 0;
-            const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
-            if (shouldForceUpdate) {
-              state.ignoreScrollFromMVCPIgnored = false;
-              state.scrollPending = state.scroll;
-              (_a4 = state.reprocessCurrentScroll) == null ? void 0 : _a4.call(state);
-            }
-          },
-          delay,
-          "ignoreScrollFromMVCP"
-        );
       }
     } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
+      resetAdaptiveRender(ctx);
     }
   }
 }
 
-// src/core/finishMaintainScrollAtEnd.ts
-function interruptMaintainScrollAtEnd(ctx) {
+// src/utils/getEffectiveDrawDistance.ts
+var INITIAL_DRAW_DISTANCE = 50;
+function getEffectiveDrawDistance(ctx, mode) {
   var _a3;
+  const drawDistance = ctx.state.props.drawDistance;
+  const initialScroll = ctx.state.initialScroll;
+  const needsFullInitialDrawDistance = initialScroll !== void 0 && ((_a3 = initialScroll.viewPosition) != null ? _a3 : 0) > 0;
+  const shouldCapDrawDistance = mode === "visible-first" || mode !== "full" && !peek$(ctx, "readyToRender") && !needsFullInitialDrawDistance;
+  return shouldCapDrawDistance ? Math.min(drawDistance, INITIAL_DRAW_DISTANCE) : drawDistance;
+}
+function scheduleFullDrawDistancePrewarm(ctx) {
   const { state } = ctx;
-  const maintaining = state.maintainingScrollAtEnd;
-  state.endFollowInterrupted = true;
-  set$(ctx, "isFollowingEnd", false);
-  if (maintaining === "animated" || maintaining === "instant" || maintaining && ((_a3 = state.scrollingTo) == null ? void 0 : _a3.isScrollToEnd)) {
-    cancelImperativeScroll(state);
-    syncScrollActive(ctx);
-  }
-  if (maintaining || state.pendingMaintainScrollAtEnd) {
-    finishMaintainScrollAtEnd(ctx);
+  if (state.props.drawDistance <= INITIAL_DRAW_DISTANCE || state.scheduledWork.has("fullDrawDistancePrewarm")) {
+    return;
   }
+  state.scheduledWork.frame(() => {
+    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");
 }
-function armAppScrollRearm(ctx) {
-  ctx.state.scheduledWork.timeout(
-    () => rearmEndFollowIfSettled(ctx),
-    USER_MOMENTUM_STALL_TIMEOUT_MS,
-    "appScrollRearm"
-  );
-}
-function rearmEndFollowIfSettled(ctx) {
+
+// src/utils/setInitialRenderState.ts
+function resetInitialRenderState(ctx, {
+  resetLayout,
+  resetInitialScroll
+}) {
   const { state } = ctx;
-  if (state.endFollowInterrupted && (!state.visibleContentAnchor || state.visibleContentAnchor.sizeOnly) && !state.isDragging && state.userScrollContentSize === void 0 && !state.scheduledWork.has("appScrollRearm") && !state.scrollingTo && !state.pendingScrollResolve && peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
-    state.endFollowInterrupted = false;
-    if (state.props.maintainScrollAtEnd) set$(ctx, "isFollowingEnd", true);
+  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;
   }
+  set$(ctx, "readyToRender", false);
+  resetAdaptiveRender(ctx);
 }
-function finishMaintainScrollAtEnd(ctx) {
-  var _a3, _b;
+function setInitialRenderState(ctx, {
+  didLayout,
+  didInitialScroll
+}) {
   const { state } = ctx;
-  const currentPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
-  const nextPadding = getAlignItemsAtEndPadding(ctx);
-  state.maintainingScrollAtEnd = void 0;
-  state.pendingMaintainScrollAtEnd = false;
-  for (const key of (_a3 = state.pendingEndMeasurements) != null ? _a3 : []) {
-    if (!state.containerItemKeys.has(key)) state.pendingEndMeasurements.delete(key);
+  const {
+    loadStartTime,
+    props: { onLoad, onReady }
+  } = state;
+  if (didLayout) {
+    state.didContainersLayout = true;
   }
-  if (currentPadding !== nextPadding) {
-    set$(ctx, "alignItemsAtEndPadding", nextPadding);
-    state.scrollForNextCalculateItemsInView = void 0;
-    (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
-    const nextScroll = clampScrollOffset(ctx, state.scroll + nextPadding - currentPadding);
-    const nativeScroll = Platform.OS === "ios" ? clampScrollOffset(ctx, state.scroll) : state.scroll;
-    state.scroll = nativeScroll;
-    requestAdjust(ctx, nextScroll - nativeScroll);
+  if (didInitialScroll) {
+    state.didFinishInitialScroll = true;
   }
-}
-
-// src/utils/checkThreshold.ts
-var HYSTERESIS_MULTIPLIER = 1.3;
-function isOutsideThresholdHysteresis(distance, atThreshold, threshold) {
-  const absDistance = Math.abs(distance);
-  return !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
-}
-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;
+  const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
+  if (isReadyToRender && !peek$(ctx, "readyToRender")) {
+    set$(ctx, "readyToRender", true);
+    setAdaptiveRender(ctx, "normal", "ready");
+    if (state.props.drawDistance > INITIAL_DRAW_DISTANCE) {
+      scheduleFullDrawDistancePrewarm(ctx);
     }
-  } 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();
+    if (!state.didLoad) {
+      state.didLoad = true;
+      if (onLoad) {
+        onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
       }
     }
-  }
-  return reached;
-};
-
-// 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 resetSharedEdgeGateIfOutsideHysteresis(ctx) {
-  const state = ctx.state;
-  if (!state.edgeReachedGate) {
-    return;
-  }
-  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 isOutsideEnd = isOutsideThresholdHysteresis(endDistance, isContentLess, endThreshold);
-  if (isOutsideStart && isOutsideEnd) {
-    state.edgeReachedGate = void 0;
+    onReady == null ? void 0 : onReady();
   }
 }
-function canDispatchReachedEdge(ctx, edge, allowedEdge, allowGateCreatedInCurrentCheck) {
-  return !ctx.state.edgeReachedGate || allowedEdge === edge || !!allowGateCreatedInCurrentCheck;
-}
-function markReachedEdge(ctx) {
-  ctx.state.edgeReachedGate = "closed";
+
+// src/core/finishInitialScroll.ts
+var PRESERVED_INITIAL_SCROLL_FALLBACK_CLEAR_DELAY_MS = 2e3;
+function syncInitialScrollOffset(state, offset) {
+  state.scroll = offset;
+  state.scrollPending = offset;
+  state.scrollPrev = offset;
 }
-function prepareReachedEdgeForNextUserScroll(ctx) {
-  if (ctx.state.edgeReachedGate) {
-    ctx.state.edgeReachedGate = "prepared";
-  }
+function clearPreservedInitialScrollTarget(state) {
+  state.scheduledWork.cancel("preservedInitialScroll");
+  state.clearPreservedInitialScrollOnNextFinish = void 0;
+  state.initialScroll = void 0;
+  state.preservedEndAnchorCorrection = void 0;
+  setInitialScrollSession(state);
 }
-function beginReachedEdgeUserScroll(ctx, scrollDelta) {
+function supersedeInitialScroll(ctx) {
+  var _a3, _b, _c;
   const state = ctx.state;
-  if (state.edgeReachedGate !== "prepared") {
-    return void 0;
+  const bootstrapInitialScroll = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
+  if (state.initialScroll || bootstrapInitialScroll || ((_b = state.scrollingTo) == null ? void 0 : _b.isInitialScroll)) {
+    if ((bootstrapInitialScroll == null ? void 0 : bootstrapInitialScroll.frameHandle) !== void 0 && typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(bootstrapInitialScroll.frameHandle);
+    }
+    if ((_c = state.scrollingTo) == null ? void 0 : _c.isInitialScroll) {
+      cancelScrollCompletionChecks(state);
+      state.scrollingTo = void 0;
+      state.scrollTargetPinnedRange = void 0;
+    }
+    initialScrollCompletion.resetFlags(state);
+    setInitialScrollSession(state, { bootstrap: null });
+    finishInitialScroll(ctx);
   }
-  const allowedEdge = scrollDelta < 0 ? "start" : "end";
-  resetEdgeLatch(ctx, allowedEdge);
-  return allowedEdge;
-}
-
-// src/utils/hasActiveInitialScroll.ts
-function hasActiveInitialScroll(state) {
-  return !!(state == null ? void 0 : state.initialScroll) && !state.didFinishInitialScroll;
 }
-
-// src/utils/checkAtBottom.ts
-function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
+function finishInitialScroll(ctx, options) {
   var _a3;
   const state = ctx.state;
-  if (!state) {
-    return;
-  }
-  const {
-    queuedInitialLayout,
-    scrollLength,
-    scroll,
-    maintainingScrollAtEnd,
-    props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
-  } = state;
-  const contentSize = getContentSize(ctx);
-  const distanceFromEnd = contentSize - scroll - scrollLength;
-  resetSharedEdgeGateIfOutsideHysteresis(ctx);
-  if (state.props.data.length === 0 && scrollLength > 0 && contentSize <= scrollLength) {
-    set$(ctx, "isAtEnd", true);
-    set$(ctx, "isNearEnd", true);
-    set$(ctx, "isWithinMaintainScrollAtEndThreshold", true);
-    return;
+  const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
+  if ((options == null ? void 0 : options.resolvedOffset) !== void 0) {
+    syncInitialScrollOffset(state, options.resolvedOffset);
+  } else if ((options == null ? void 0 : options.syncObservedOffset) && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
+    const observedOffset = getObservedScrollOffset(ctx);
+    if (Number.isFinite(observedOffset)) {
+      syncInitialScrollOffset(state, observedOffset);
+    }
   }
-  if (contentSize > 0 && queuedInitialLayout) {
-    const isContentLess = contentSize < scrollLength;
-    set$(ctx, "isAtEnd", isContentLess || distanceFromEnd <= EDGE_POSITION_EPSILON);
-    set$(ctx, "isNearEnd", isContentLess || distanceFromEnd <= onEndReachedThreshold * scrollLength);
-    set$(
-      ctx,
-      "isWithinMaintainScrollAtEndThreshold",
-      isContentLess || // A zero threshold still includes fractional offsets considered
-      // at the end; otherwise following can stop after rounding/layout.
-      distanceFromEnd <= Math.max(EDGE_POSITION_EPSILON, maintainScrollAtEndThreshold * scrollLength) || state.pendingMaintainScrollAtEnd || !!maintainingScrollAtEnd || !!peek$(ctx, "isFollowingEnd")
-    );
-    const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || maintainingScrollAtEnd;
-    if (!shouldSkipThresholdChecks) {
-      state.isEndReached = checkThreshold(
-        distanceFromEnd,
-        isContentLess,
-        onEndReachedThreshold * scrollLength,
-        state.isEndReached,
-        state.endReachedSnapshot,
-        {
-          contentSize,
-          dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length,
-          scrollPosition: scroll
-        },
-        (distance) => {
-          let dispatched = false;
-          if (state.props.onEndReached && canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
-            markReachedEdge(ctx);
-            state.props.onEndReached({ distanceFromEnd: distance });
-            dispatched = true;
-          }
-          return dispatched;
-        },
-        (snapshot) => {
-          state.endReachedSnapshot = snapshot;
-        }
-      );
+  const complete = () => {
+    var _a4, _b, _c, _d;
+    if (state.isUnmounted) {
+      return;
+    }
+    if (freshDataTransitionEpoch !== state.freshDataTransitionEpoch) {
+      (_a4 = options == null ? void 0 : options.onFinished) == null ? void 0 : _a4.call(options);
+      return;
+    }
+    const shouldReleaseDeferredPublicOnScroll = Platform.OS === "web" && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) === "bootstrap";
+    if (isEndOfContentTarget(state.initialScroll, state.props.data.length) && state.props.maintainScrollAtEnd && !state.endFollowInterrupted) {
+      set$(ctx, "isFollowingEnd", true);
     }
+    const finalScrollOffset = (_c = options == null ? void 0 : options.resolvedOffset) != null ? _c : state.scrollPending;
+    initialScrollWatchdog.clear(state);
+    if ((options == null ? void 0 : options.preserveTarget) && state.initialScroll) {
+      state.clearPreservedInitialScrollOnNextFinish = void 0;
+      setInitialScrollSession(state);
+      state.scheduledWork.cancel("preservedInitialScroll");
+      if (options == null ? void 0 : options.schedulePreservedTargetClear) {
+        state.scheduledWork.timeout(
+          () => {
+            var _a5;
+            if (!state.didFinishInitialScroll || ((_a5 = state.scrollingTo) == null ? void 0 : _a5.isInitialScroll) || !state.initialScroll) {
+              return;
+            }
+            clearPreservedInitialScrollTarget(state);
+          },
+          PRESERVED_INITIAL_SCROLL_FALLBACK_CLEAR_DELAY_MS,
+          "preservedInitialScroll"
+        );
+      }
+    } else {
+      clearPreservedInitialScrollTarget(state);
+    }
+    if (options == null ? void 0 : options.recalculateItems) {
+      recalculateSettledScroll(ctx);
+    }
+    setInitialRenderState(ctx, { didInitialScroll: true });
+    if (shouldReleaseDeferredPublicOnScroll) {
+      releaseDeferredPublicOnScroll(ctx, finalScrollOffset);
+    }
+    (_d = options == null ? void 0 : options.onFinished) == null ? void 0 : _d.call(options);
+  };
+  if (options == null ? void 0 : options.waitForCompletionFrame) {
+    requestAnimationFrame(complete);
+    return;
   }
+  complete();
 }
 
-// src/utils/checkAtTop.ts
-function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
-  const state = ctx == null ? void 0 : ctx.state;
-  if (!state) {
-    return;
-  }
-  const {
-    isStartReached,
-    props: { data, onStartReachedThreshold },
-    scroll,
-    scrollLength,
-    startReachedSnapshot,
-    totalSize
-  } = state;
-  const dataLength = data.length;
-  const threshold = onStartReachedThreshold * scrollLength;
-  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);
-  const shouldSkipThresholdChecks = !state.queuedInitialLayout || hasActiveInitialScroll(state) || !!state.scrollingTo;
-  if (!shouldSkipThresholdChecks) {
-    state.isStartReached = checkThreshold(
-      scroll,
-      false,
-      threshold,
-      state.isStartReached,
-      startReachedSnapshot,
-      {
-        contentSize: totalSize,
-        dataLength,
-        scrollPosition: scroll
-      },
-      (distance) => {
-        let dispatched = false;
-        if (state.props.onStartReached && canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
-          markReachedEdge(ctx);
-          state.props.onStartReached({ distanceFromStart: distance });
-          dispatched = true;
-        }
-        return dispatched;
-      },
-      (snapshot) => {
-        state.startReachedSnapshot = snapshot;
-      }
-    );
-  }
+// src/core/getStartOffsetAdjustment.ts
+function getStartOffsetAdjustment(ctx) {
+  const { state } = ctx;
+  const stylePaddingStart = state.props.horizontal ? (isHorizontalRTL(state) ? state.props.stylePaddingRight : state.props.stylePaddingLeft) || 0 : peek$(ctx, "stylePaddingTop") || 0;
+  return stylePaddingStart + (peek$(ctx, "alignItemsAtEndPadding") || 0) + (peek$(ctx, "headerSize") || 0);
+}
+function getItemSpaceOffset(ctx, scrollOffset, pending = ((_a3) => (_a3 = peek$(ctx, "scrollAdjustPending")) != null ? _a3 : 0)(), startOffset = getStartOffsetAdjustment(ctx)) {
+  return Math.round(scrollOffset + (pending - startOffset));
 }
 
-// src/utils/checkThresholds.ts
-function checkThresholds(ctx, allowedEdge) {
-  const allowGateCreatedInCurrentCheck = !ctx.state.edgeReachedGate;
-  checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
-  checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
-  rearmEndFollowIfSettled(ctx);
+// src/core/addTotalSize.ts
+function addTotalSize(ctx, key, add, notifyTotalSize = true) {
+  const state = ctx.state;
+  const prevTotalSize = state.totalSize;
+  let totalSize = state.totalSize;
+  if (key === null) {
+    totalSize = add;
+    if (state.timeoutSetPaddingTop) {
+      clearTimeout(state.timeoutSetPaddingTop);
+      state.timeoutSetPaddingTop = void 0;
+    }
+  } else {
+    totalSize += add;
+  }
+  if (prevTotalSize !== totalSize) {
+    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
+      state.pendingTotalSize = totalSize;
+    } else {
+      state.pendingTotalSize = void 0;
+      state.totalSize = totalSize;
+      if (notifyTotalSize) {
+        set$(ctx, "totalSize", totalSize);
+      }
+      updateContentMetricsState(ctx);
+    }
+  } else if (notifyTotalSize && ctx.values.get("totalSize") !== totalSize) {
+    set$(ctx, "totalSize", totalSize);
+  }
 }
 
-// src/core/recalculateSettledScroll.ts
-function recalculateSettledScroll(ctx) {
-  var _a3, _b;
+// src/core/setSize.ts
+function setSize(ctx, itemKey, size, notifyTotalSize = true) {
   const state = ctx.state;
-  if ((_a3 = state.props) == null ? void 0 : _a3.data) {
-    (_b = state.triggerCalculateItemsInView) == null ? void 0 : _b.call(state, { forceFullItemPositions: true });
+  const { sizes } = state;
+  const previousSize = sizes.get(itemKey);
+  const diff = previousSize !== void 0 ? size - previousSize : size;
+  if (diff !== 0) {
+    state.positionsAreCurrent = false;
+    addTotalSize(ctx, itemKey, diff, notifyTotalSize);
   }
-  checkThresholds(ctx);
+  sizes.set(itemKey, size);
 }
 
-// src/core/adaptiveRender.ts
-var DEFAULT_ADAPTIVE_RENDER_ENTER_VELOCITY = 3;
-var DEFAULT_ADAPTIVE_RENDER_EXIT_VELOCITY = 1;
-var DEFAULT_ADAPTIVE_RENDER_EXIT_DELAY = 250;
-var DEFAULT_WEB_ADAPTIVE_RENDER_ENTER_VELOCITY = 6;
-var DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_VELOCITY = 3;
-var DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_DELAY = 250;
-function clearAdaptiveRenderExitTimeout(ctx) {
-  ctx.state.scheduledWork.cancel("adaptiveRender");
+// src/utils/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
 }
-function scheduleAdaptiveRenderExit(ctx, exitDelay) {
-  const state = ctx.state;
-  clearAdaptiveRenderExitTimeout(ctx);
-  if (exitDelay <= 0) {
-    setAdaptiveRender(ctx, "normal", "scroll");
-  } else {
-    state.scheduledWork.timeout(() => setAdaptiveRender(ctx, "normal", "scroll"), exitDelay, "adaptiveRender");
-  }
+function isArray(obj) {
+  return Array.isArray(obj);
 }
-function setAdaptiveRender(ctx, mode, reason) {
-  var _a3, _b;
-  const previousMode = peek$(ctx, "adaptiveRender");
-  if (previousMode !== mode) {
-    set$(ctx, "adaptiveRender", mode);
-    (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.onChange) == null ? void 0 : _b.call(_a3, mode, reason);
+var warned = /* @__PURE__ */ new Set();
+function warnDevOnce(id, text) {
+  if (IS_DEV && !warned.has(id)) {
+    warned.add(id);
+    console.warn(`[legend-list] ${text}`);
   }
 }
-function resetAdaptiveRender(ctx) {
-  var _a3, _b;
-  clearAdaptiveRenderExitTimeout(ctx);
-  const mode = (_b = (_a3 = ctx.state.props.adaptiveRender) == null ? void 0 : _a3.initialMode) != null ? _b : "normal";
-  if (peek$(ctx, "adaptiveRender") !== mode) {
-    setAdaptiveRender(ctx, mode, "initial");
-  }
+function roundSize(size) {
+  return Math.floor(size * 8) / 8;
 }
-function updateAdaptiveRender(ctx, scrollVelocity, options) {
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function getPadding(s, type) {
   var _a3, _b, _c;
-  const state = ctx.state;
-  const adaptiveRender = state.props.adaptiveRender;
-  const currentMode = peek$(ctx, "adaptiveRender");
-  if (peek$(ctx, "readyToRender")) {
-    if (adaptiveRender) {
-      const isWeb = Platform.OS === "web";
-      const enterVelocity = (_a3 = adaptiveRender.enterVelocity) != null ? _a3 : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_ENTER_VELOCITY : DEFAULT_ADAPTIVE_RENDER_ENTER_VELOCITY;
-      const exitVelocity = (_b = adaptiveRender.exitVelocity) != null ? _b : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_VELOCITY : DEFAULT_ADAPTIVE_RENDER_EXIT_VELOCITY;
-      const exitDelay = (_c = adaptiveRender.exitDelay) != null ? _c : isWeb ? DEFAULT_WEB_ADAPTIVE_RENDER_EXIT_DELAY : DEFAULT_ADAPTIVE_RENDER_EXIT_DELAY;
-      const threshold = currentMode === "light" ? exitVelocity : enterVelocity;
-      const nextMode = (options == null ? void 0 : options.forceLight) || Math.abs(scrollVelocity) > threshold ? "light" : "normal";
-      const previousMode = state.scheduledWork.has("adaptiveRender") ? "normal" : currentMode;
-      if (nextMode !== previousMode) {
-        if (nextMode === "light") {
-          setAdaptiveRender(ctx, "light", "scroll");
-          scheduleAdaptiveRenderExit(ctx, exitDelay);
-        } else if (currentMode === "light") {
-          scheduleAdaptiveRenderExit(ctx, exitDelay);
-        }
-      }
-    } else {
-      resetAdaptiveRender(ctx);
-    }
-  }
+  const axisPadding = type === "Left" || type === "Right" ? s.paddingHorizontal : s.paddingVertical;
+  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : axisPadding) != null ? _b : s.padding) != null ? _c : 0;
 }
-
-// src/utils/getEffectiveDrawDistance.ts
-var INITIAL_DRAW_DISTANCE = 50;
-function getEffectiveDrawDistance(ctx, mode) {
-  var _a3;
-  const drawDistance = ctx.state.props.drawDistance;
-  const initialScroll = ctx.state.initialScroll;
-  const needsFullInitialDrawDistance = initialScroll !== void 0 && ((_a3 = initialScroll.viewPosition) != null ? _a3 : 0) > 0;
-  const shouldCapDrawDistance = mode === "visible-first" || mode !== "full" && !peek$(ctx, "readyToRender") && !needsFullInitialDrawDistance;
-  return shouldCapDrawDistance ? Math.min(drawDistance, INITIAL_DRAW_DISTANCE) : drawDistance;
+function extractPadding(style, contentContainerStyle, type) {
+  return getPadding(style, type) + getPadding(contentContainerStyle, type);
 }
-function scheduleFullDrawDistancePrewarm(ctx) {
-  const { state } = ctx;
-  if (state.props.drawDistance <= INITIAL_DRAW_DISTANCE || state.scheduledWork.has("fullDrawDistancePrewarm")) {
-    return;
+function findContainerId(ctx, key) {
+  var _a3, _b;
+  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
+  if (directMatch !== void 0) {
+    return directMatch;
   }
-  state.scheduledWork.frame(() => {
-    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;
-      }
+  const numContainers = peek$(ctx, "numContainers");
+  for (let i = 0; i < numContainers; i++) {
+    const itemKey = peek$(ctx, `containerItemKey${i}`);
+    if (itemKey === key) {
+      return i;
     }
-    (_c = state.triggerCalculateItemsInView) == null ? void 0 : _c.call(state);
-  }, "fullDrawDistancePrewarm");
+  }
+  return -1;
 }
 
-// src/utils/setInitialRenderState.ts
-function resetInitialRenderState(ctx, {
-  resetLayout,
-  resetInitialScroll
-}) {
-  const { state } = 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;
+// src/utils/getItemSize.ts
+function getKnownOrFixedSize(ctx, key, index, data, resolved) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
+  const { getFixedItemSize, getItemType } = state.props;
+  let size = key ? state.sizesKnown.get(key) : void 0;
+  if (size === void 0 && key && getFixedItemSize) {
+    const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+    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.positionRecalculationStartIndex = Math.min((_c = state.positionRecalculationStartIndex) != null ? _c : index, index);
+      state.scrollForNextCalculateItemsInView = void 0;
+      state.sizesKnown.set(key, size);
+      (_d = state.fixedItemSizeKeys) != null ? _d : state.fixedItemSizeKeys = /* @__PURE__ */ new Set();
+      state.fixedItemSizeKeys.add(key);
+    }
   }
-  if (resetInitialScroll) {
-    state.didFinishInitialScroll = false;
+  return size;
+}
+function getKnownOrFixedItemSize(ctx, index) {
+  const key = getId(ctx.state, index);
+  return getKnownOrFixedSize(ctx, key, index, ctx.state.props.data[index]);
+}
+function areKnownOrFixedItemSizesAvailable(ctx, startIndex, endIndex) {
+  for (let index = startIndex; index <= endIndex; index++) {
+    if (getKnownOrFixedItemSize(ctx, index) === void 0) {
+      return false;
+    }
   }
-  set$(ctx, "readyToRender", false);
-  resetAdaptiveRender(ctx);
+  return true;
 }
-function setInitialRenderState(ctx, {
-  didLayout,
-  didInitialScroll
-}) {
-  const { state } = ctx;
+function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize, notifyTotalSize, resolved) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
   const {
-    loadStartTime,
-    props: { onLoad, onReady }
+    sizes,
+    averageSizes,
+    props: { estimatedItemSize, getItemType },
+    scrollingTo
   } = state;
-  if (didLayout) {
-    state.didContainersLayout = true;
+  const sizeKnown = state.sizesKnown.get(key);
+  if (sizeKnown !== void 0) {
+    return sizeKnown;
   }
-  if (didInitialScroll) {
-    state.didFinishInitialScroll = true;
+  const renderedSize = sizes.get(key);
+  let size = getKnownOrFixedSize(ctx, key, index, data, resolved);
+  if (size !== void 0) {
+    setSize(ctx, key, size, notifyTotalSize);
+    return size;
   }
-  const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
-  if (isReadyToRender && !peek$(ctx, "readyToRender")) {
-    set$(ctx, "readyToRender", true);
-    setAdaptiveRender(ctx, "normal", "ready");
-    if (state.props.drawDistance > INITIAL_DRAW_DISTANCE) {
-      scheduleFullDrawDistancePrewarm(ctx);
-    }
-    if (!state.didLoad) {
-      state.didLoad = true;
-      if (onLoad) {
-        onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
-      }
+  if (preferCachedSize && renderedSize !== void 0) {
+    return renderedSize;
+  }
+  const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+  if (useAverageSize && !scrollingTo) {
+    const averageSizeForType = (_c = averageSizes[itemType]) == null ? void 0 : _c.avg;
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
     }
-    onReady == null ? void 0 : onReady();
   }
+  if (size === void 0 && renderedSize !== void 0) {
+    return renderedSize;
+  }
+  if (size === void 0 && useAverageSize && scrollingTo) {
+    const averageSizeForType = (_d = scrollingTo.averageSizeSnapshot) == null ? void 0 : _d[itemType];
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
+    }
+  }
+  if (size === void 0) {
+    size = estimatedItemSize + ctx.scrollAxisGap;
+  }
+  setSize(ctx, key, size, notifyTotalSize);
+  return size;
 }
-
-// src/core/finishInitialScroll.ts
-var PRESERVED_INITIAL_SCROLL_FALLBACK_CLEAR_DELAY_MS = 2e3;
-function syncInitialScrollOffset(state, offset) {
-  state.scroll = offset;
-  state.scrollPending = offset;
-  state.scrollPrev = offset;
-}
-function clearPreservedInitialScrollTarget(state) {
-  state.scheduledWork.cancel("preservedInitialScroll");
-  state.clearPreservedInitialScrollOnNextFinish = void 0;
-  state.initialScroll = void 0;
-  state.preservedEndAnchorCorrection = void 0;
-  setInitialScrollSession(state);
+function getItemSizeAtIndex(ctx, index) {
+  if (index === void 0 || index < 0) {
+    return void 0;
+  }
+  const targetId = getId(ctx.state, index);
+  return getItemSize(ctx, targetId, index, ctx.state.props.data[index]);
 }
-function supersedeInitialScroll(ctx) {
-  var _a3, _b, _c;
-  const state = ctx.state;
-  const bootstrapInitialScroll = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
-  if (state.initialScroll || bootstrapInitialScroll || ((_b = state.scrollingTo) == null ? void 0 : _b.isInitialScroll)) {
-    if ((bootstrapInitialScroll == null ? void 0 : bootstrapInitialScroll.frameHandle) !== void 0 && typeof cancelAnimationFrame === "function") {
-      cancelAnimationFrame(bootstrapInitialScroll.frameHandle);
-    }
-    if ((_c = state.scrollingTo) == null ? void 0 : _c.isInitialScroll) {
-      cancelScrollCompletionChecks(state);
-      state.scrollingTo = void 0;
-      state.scrollTargetPinnedRange = void 0;
-    }
-    initialScrollCompletion.resetFlags(state);
-    setInitialScrollSession(state, { bootstrap: null });
-    finishInitialScroll(ctx);
+
+// src/core/calculateOffsetWithOffsetPosition.ts
+function getViewPositionOffset(availableSpace, viewPosition, viewPositionFallback) {
+  let alignment = viewPosition;
+  if (availableSpace < 0 && viewPositionFallback !== void 0) {
+    alignment = viewPositionFallback === "start" ? 0 : 1;
   }
+  return -alignment * availableSpace;
 }
-function finishInitialScroll(ctx, options) {
+function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
   var _a3;
   const state = ctx.state;
-  const freshDataTransitionEpoch = state.freshDataTransitionEpoch;
-  if ((options == null ? void 0 : options.resolvedOffset) !== void 0) {
-    syncInitialScrollOffset(state, options.resolvedOffset);
-  } else if ((options == null ? void 0 : options.syncObservedOffset) && ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset") {
-    const observedOffset = getObservedScrollOffset(ctx);
-    if (Number.isFinite(observedOffset)) {
-      syncInitialScrollOffset(state, observedOffset);
-    }
+  const { index, viewOffset, viewPosition, viewPositionFallback } = params;
+  let offset = offsetParam;
+  if (viewOffset) {
+    offset -= viewOffset;
   }
-  const complete = () => {
-    var _a4, _b, _c, _d;
-    if (state.isUnmounted) {
-      return;
-    }
-    if (freshDataTransitionEpoch !== state.freshDataTransitionEpoch) {
-      (_a4 = options == null ? void 0 : options.onFinished) == null ? void 0 : _a4.call(options);
-      return;
-    }
-    const shouldReleaseDeferredPublicOnScroll = Platform.OS === "web" && ((_b = state.initialScrollSession) == null ? void 0 : _b.kind) === "bootstrap";
-    if (isEndOfContentTarget(state.initialScroll, state.props.data.length) && state.props.maintainScrollAtEnd && !state.endFollowInterrupted) {
-      set$(ctx, "isFollowingEnd", true);
-    }
-    const finalScrollOffset = (_c = options == null ? void 0 : options.resolvedOffset) != null ? _c : state.scrollPending;
-    initialScrollWatchdog.clear(state);
-    if ((options == null ? void 0 : options.preserveTarget) && state.initialScroll) {
-      state.clearPreservedInitialScrollOnNextFinish = void 0;
-      setInitialScrollSession(state);
-      state.scheduledWork.cancel("preservedInitialScroll");
-      if (options == null ? void 0 : options.schedulePreservedTargetClear) {
-        state.scheduledWork.timeout(
-          () => {
-            var _a5;
-            if (!state.didFinishInitialScroll || ((_a5 = state.scrollingTo) == null ? void 0 : _a5.isInitialScroll) || !state.initialScroll) {
-              return;
-            }
-            clearPreservedInitialScrollTarget(state);
-          },
-          PRESERVED_INITIAL_SCROLL_FALLBACK_CLEAR_DELAY_MS,
-          "preservedInitialScroll"
-        );
-      }
-    } else {
-      clearPreservedInitialScrollTarget(state);
-    }
-    if (options == null ? void 0 : options.recalculateItems) {
-      recalculateSettledScroll(ctx);
-    }
-    setInitialRenderState(ctx, { didInitialScroll: true });
-    if (shouldReleaseDeferredPublicOnScroll) {
-      releaseDeferredPublicOnScroll(ctx, finalScrollOffset);
+  const leadingInset = index !== void 0 ? getContentInsetTop(ctx) : 0;
+  if (index !== void 0) {
+    offset += getStartOffsetAdjustment(ctx) - leadingInset;
+  }
+  if (viewPosition !== void 0 && index !== void 0) {
+    const dataLength = state.props.data.length;
+    if (dataLength === 0) {
+      return offset;
     }
-    (_d = options == null ? void 0 : options.onFinished) == null ? void 0 : _d.call(options);
-  };
-  if (options == null ? void 0 : options.waitForCompletionFrame) {
-    requestAnimationFrame(complete);
-    return;
+    const isOutOfBounds = index < 0 || index >= dataLength;
+    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
+    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 - leadingInset - trailingInset - itemSize;
+    offset += getViewPositionOffset(availableSpace, viewPosition, viewPositionFallback);
   }
-  complete();
+  if (index !== void 0 && params.clampToContentContainerMinSize) {
+    offset += getContentSize(ctx) - getContentSize(ctx, false);
+  }
+  return offset;
 }
 
 // src/core/mvcp.ts
@@ -1627,11 +1616,12 @@ function shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotal
   const distanceFromEnd = prevTotalSize - prevScroll - state.scrollLength;
   return distanceFromEnd < Math.abs(positionDiff) - MVCP_POSITION_EPSILON;
 }
-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));
@@ -1659,7 +1649,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;
   }
@@ -1693,7 +1683,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) {
@@ -1842,7 +1832,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;
@@ -1859,7 +1849,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(
@@ -1884,6 +1874,15 @@ function prepareMVCP(ctx, dataChanged, adjustmentSource) {
         now,
         positionDiff
       });
+      if (Platform.OS === "android" && !dataChanged && scrollTarget === void 0) {
+        const maxScroll = getScrollRangeEnd(ctx);
+        if (state.scroll > maxScroll + MVCP_POSITION_EPSILON) {
+          const targetScroll = Math.max(0, Math.min(state.scroll + positionDiff, maxScroll));
+          state.scroll = maxScroll;
+          state.scrollPending = maxScroll;
+          positionDiff = targetScroll - maxScroll;
+        }
+      }
       if (shouldQueueNativeMVCPAdjust(dataChanged, state, positionDiff, prevTotalSize, prevScroll, scrollTarget)) {
         state.pendingNativeMVCPAdjust = {
           amount: positionDiff,
@@ -2063,27 +2062,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;
@@ -2097,12 +2100,45 @@ 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/core/calculateOffsetForIndex.ts
+function calculateOffsetForIndex(ctx, index) {
+  const state = ctx.state;
+  return index !== void 0 ? state.positions[index] || 0 : 0;
+}
+
+// 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 = Platform.OS === "web" && (!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
@@ -2146,7 +2182,7 @@ function getScrollRequestTracker(ctx) {
           state.scrollAdjustHandler.commitPendingAdjust();
         }
       }
-      if (didStartScroll === "unreachable") {
+      if (didStartScroll === "unreachable" || !didStartScroll && state.scrollingTo) {
         cancelScroll(ctx);
         return;
       }
@@ -2187,6 +2223,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;
@@ -2235,7 +2283,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;
@@ -2246,7 +2294,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";
@@ -2339,20 +2387,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;
@@ -2401,16 +2435,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 = Platform.OS === "web" && (!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 = Platform.OS === "web" && scrollingTo.isInitialScroll;
@@ -2422,9 +2446,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" && scrollingTo.isScrollToEnd && !state.maintainingScrollAtEnd && !scrollingTo.isInitialScroll && !scrollingTo.animated && state.lastNativeScroll !== void 0 && state.lastNativeScroll < Math.min(clampedTargetOffset, adjustedTargetOffset) - 1;
   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) {
@@ -2699,18 +2724,20 @@ function scrollTo(ctx, params) {
   if (forceScroll || !isInitialScroll || Platform.OS === "android") {
     doScrollTo(ctx, { animated, horizontal, isInitialScroll, 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,
@@ -2743,8 +2770,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;
@@ -3496,7 +3527,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];
@@ -4555,31 +4586,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 {
@@ -4607,14 +4614,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,
@@ -4657,7 +4661,8 @@ function calculateItemsInView(ctx, params = {}) {
     if (!data || scrollLength === 0 || !prevNumContainers) {
       return;
     }
-    let totalSize = getContentSize(ctx);
+    const includeContentContainerMinSize = Platform.OS === "web" || !isHorizontalRTL(state);
+    let totalSize = getContentSize(ctx, includeContentContainerMinSize);
     let changedContainerIds;
     const topPad = getStartOffsetAdjustment(ctx);
     const numColumns = peek$(ctx, "numColumns");
@@ -4724,8 +4729,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) {
@@ -4737,17 +4743,13 @@ function calculateItemsInView(ctx, params = {}) {
         state.scrollForNextCalculateItemsInView = void 0;
       } else if ((top === null || scrollTopBuffered > top) && (bottom === null || scrollBottomBuffered < bottom)) {
         if (Platform.OS !== "web" || !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;
         }
@@ -4769,7 +4771,7 @@ function calculateItemsInView(ctx, params = {}) {
       scrollVelocity: speed,
       startIndex
     });
-    totalSize = getContentSize(ctx);
+    totalSize = getContentSize(ctx, includeContentContainerMinSize);
     if (positionRecalculationStartIndex !== void 0) {
       state.positionRecalculationStartIndex = void 0;
     }
@@ -4867,14 +4869,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 : {
@@ -5137,7 +5136,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 = Platform.OS !== "web" && state.props.anchoredEndSpaceOwner === "list" && !isHorizontalRTL(state) ? getContentInsetEnd(ctx) - (previousSize || 0) : 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;
@@ -5268,13 +5271,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];
@@ -5427,20 +5444,6 @@ function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem, notif
 }
 
 // src/core/measureContainersInLayoutEffect.native.ts
-function resolveFixedItemSize(ctx, containerId, itemKey) {
-  var _a3;
-  const state = ctx.state;
-  const { data, getFixedItemSize } = state.props;
-  const index = state.indexByKey.get(itemKey);
-  let fixedItemSize;
-  if (data && getFixedItemSize && index !== void 0) {
-    const itemData = data[index];
-    if (itemData !== void 0) {
-      fixedItemSize = (_a3 = resolveContainerItemMetadata(state, containerId, index, itemData)) == null ? void 0 : _a3.fixedItemSize;
-    }
-  }
-  return fixedItemSize;
-}
 function resolveSkippedAnchorReset(ctx, itemKey) {
   const state = ctx.state;
   const anchorReset = state.userScrollAnchorReset;
@@ -5460,7 +5463,7 @@ function revealMeasuredGeneration(ctx, containerId, itemKey, generation) {
   }
 }
 function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
-  var _a3, _b;
+  var _a3, _b, _c;
   const state = ctx.state;
   const measurements = [];
   const measuredGenerations = state.props.hideItemsUntilMeasured ? [] : void 0;
@@ -5472,7 +5475,10 @@ function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
     if (itemKey !== void 0) {
       const generation = ((_b = state.containerItemGenerations[containerId]) != null ? _b : 0) + 1;
       state.containerItemGenerations[containerId] = generation;
-      const fixedItemSize = resolveFixedItemSize(ctx, containerId, itemKey);
+      if (!isContainerItemCurrent(ctx, containerId, itemKey)) continue;
+      const index = state.indexByKey.get(itemKey);
+      const itemData = state.props.data[index];
+      const fixedItemSize = state.props.getFixedItemSize && itemData !== void 0 ? (_c = resolveContainerItemMetadata(state, containerId, index, itemData)) == null ? void 0 : _c.fixedItemSize : void 0;
       const canSkipMeasurement = !state.needsOtherAxisSize && fixedItemSize !== void 0 && state.sizesKnown.get(itemKey) === fixedItemSize + ctx.scrollAxisGap;
       if (canSkipMeasurement) {
         resolveSkippedAnchorReset(ctx, itemKey);
@@ -6434,6 +6440,9 @@ function setContentInsetOverride(ctx, inset) {
   const didChange = !areInsetsEqual(previousInset, nextInset);
   state.contentInsetOverride = nextInset;
   if (didChange) {
+    if (Platform.OS !== "web" && state.props.anchoredEndSpaceOwner === "list") {
+      maybeUpdateAnchoredEndSpace(ctx);
+    }
     updateContentMetricsState(ctx);
   }
   return didChange;
@@ -6592,6 +6601,14 @@ var ListComponent = typedMemo(function ListComponent2({
     },
     [ctx, onScrollToTop]
   );
+  const { onContentSizeChange } = rest;
+  const onContentSizeChangeInternal = React2.useCallback(
+    (width, height) => {
+      reissueClampedNativeEndScroll(ctx);
+      onContentSizeChange == null ? void 0 : onContentSizeChange(width, height);
+    },
+    [ctx, onContentSizeChange]
+  );
   const onLayoutHeader = React2.useCallback(
     (rect) => {
       const size = rect[horizontal ? "width" : "height"];
@@ -6613,6 +6630,7 @@ var ListComponent = typedMemo(function ListComponent2({
     {
       ...rest,
       ...Platform.OS === "web" ? ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, scrollElement, useWindowScroll } : {} : {
+        onContentSizeChange: onContentSizeChangeInternal,
         onScrollBeginDrag: onInternalScrollBeginDrag,
         onScrollEndDrag: onInternalScrollEndDrag,
         onScrollToTop: onScrollToTopInternal
@@ -6751,6 +6769,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);
@@ -6773,9 +6792,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);
   }
@@ -6898,6 +6914,7 @@ function scrollToIndex(ctx, {
   animated = true,
   forceScroll,
   isInitialScroll,
+  clampToContentContainerMinSize,
   viewPosition,
   viewPositionFallback
 }) {
@@ -6913,6 +6930,7 @@ function scrollToIndex(ctx, {
   state.scrollForNextCalculateItemsInView = void 0;
   scrollTo(ctx, {
     animated,
+    clampToContentContainerMinSize,
     forceScroll,
     index,
     isInitialScroll,
@@ -7032,6 +7050,9 @@ function onScroll(ctx, event, notify = true) {
     if (!prevInset || prevInset.top !== contentInset.top || prevInset.bottom !== contentInset.bottom || prevInset.left !== contentInset.left || prevInset.right !== contentInset.right) {
       state.nativeContentInset = contentInset;
       insetChanged = true;
+      if (Platform.OS !== "web" && state.props.anchoredEndSpaceOwner === "list") {
+        maybeUpdateAnchoredEndSpace(ctx);
+      }
     }
   }
   let newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
@@ -7238,7 +7259,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;
@@ -7267,6 +7288,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
@@ -7502,9 +7524,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;
@@ -7940,7 +7963,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, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
   React2.useEffect(subscribeScreenReader, []);
   const noopOnScroll = React2.useCallback((_event) => {
   }, []);
@@ -8065,7 +8088,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 = Platform.OS === "ios" && !horizontal ? Math.max(0, (_b = contentInset == null ? void 0 : contentInset.top) != null ? _b : 0) : 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 ? {
@@ -8074,10 +8098,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,
@@ -8085,7 +8109,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;
@@ -8093,7 +8117,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const [, scheduleImperativeScrollCommit] = React2__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 = React2.useRef(null);
   const combinedRef = useCombinedRef(refScroller, refScrollView);
@@ -8108,8 +8132,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,
@@ -8124,7 +8148,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   if (!refState.current) {
     if (!ctx.state) {
       const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { height: 0, width: 0 } : getWindowSize())[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: [],
@@ -8216,13 +8240,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) {
@@ -8238,7 +8262,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,
@@ -8323,8 +8347,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     updateContentMetricsState(ctx);
     let paddingDiff = stylePaddingTopState - prevPaddingTop;
     if (shouldAdjustPadding && maintainVisibleContentPositionConfig.size && paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") {
-      if (state.scroll < 0) {
-        paddingDiff += state.scroll;
+      const distanceFromStart = state.scroll + getContentInsetTop(ctx);
+      if (distanceFromStart < 0) {
+        paddingDiff += distanceFromStart;
       }
       requestAdjust(ctx, paddingDiff);
     }
@@ -8426,6 +8451,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,
@@ -8482,6 +8511,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   React2.useLayoutEffect(
     () => initializeStateVars(true),
     [
+      contentInset == null ? void 0 : contentInset.bottom,
+      contentInset == null ? void 0 : contentInset.top,
       dataKey,
       dataVersion,
       memoizedLastItemKeys.join(","),
@@ -8492,6 +8523,25 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       useAlignItemsAtEndPadding
     ]
   );
+  const previousContentInsetTop = React2.useRef(contentInset == null ? void 0 : contentInset.top);
+  React2.useLayoutEffect(() => {
+    var _a4, _b2;
+    const prevTop = Math.max(0, (_a4 = previousContentInsetTop.current) != null ? _a4 : 0);
+    const didChange = previousContentInsetTop.current !== (contentInset == null ? void 0 : contentInset.top);
+    previousContentInsetTop.current = contentInset == null ? void 0 : contentInset.top;
+    if (didChange && Platform.OS === "ios" && !horizontal && !state.contentInsetOverride && !state.isDragging && !state.isMomentumScrolling) {
+      const offset = -getContentInsetTop(ctx);
+      if (!state.didFinishInitialScroll && !initialScrollAtEnd && !hasInitialScrollIndex && !hasInitialScrollOffset && ((_b2 = state.initialScrollSession) == null ? void 0 : _b2.kind) === "offset" && state.initialScroll && (!state.scrollingTo || state.scrollingTo.isInitialScroll)) {
+        state.initialScroll.contentOffset = offset;
+        advanceCurrentInitialScrollSession(ctx, { forceScroll: true });
+      } else if (state.didFinishInitialScroll && !state.scrollingTo && Math.abs(state.scroll + prevTop) < 1) {
+        scrollTo(ctx, { animated: false, offset });
+      }
+    }
+  }, [contentInset == null ? void 0 : contentInset.top]);
+  React2.useLayoutEffect(() => {
+    checkThresholds(ctx);
+  }, [maintainScrollAtEndThreshold]);
   React2.useLayoutEffect(() => {
     if (!maintainScrollAtEndConfig) {
       finishMaintainScrollAtEnd(ctx);
@@ -8670,7 +8720,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2__namespace.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_r = refreshControlElement.props.progressViewOffset) != null ? _r : 0) + stylePaddingTopState
+        progressViewOffset: ((_s = refreshControlElement.props.progressViewOffset) != null ? _s : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2__namespace.createElement(
         ReactNative.RefreshControl,
         {
@@ -8681,7 +8731,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,