@legendapp/list 3.0.6 → 3.1.1

package/react-native.web.mjs

@@ -141,6 +141,7 @@ function StateProvider({ children }) {
     mapViewabilityConfigStates: /* @__PURE__ */ new Map(),
     mapViewabilityValues: /* @__PURE__ */ new Map(),
     positionListeners: /* @__PURE__ */ new Map(),
+    scrollAxisGap: 0,
     state: void 0,
     values: /* @__PURE__ */ new Map([
       ["alignItemsAtEndPadding", 0],
@@ -153,6 +154,7 @@ function StateProvider({ children }) {
       ["isNearEnd", false],
       ["isNearStart", false],
       ["isWithinMaintainScrollAtEndThreshold", false],
+      ["adaptiveRender", "light"],
       ["totalSize", 0],
       ["scrollAdjustPending", 0]
     ]),
@@ -533,6 +535,24 @@ var ContextContainer = createContext(null);
 function useContextContainer() {
   return useContext(ContextContainer);
 }
+function useAdaptiveRender() {
+  const [mode] = useArr$(["adaptiveRender"]);
+  return mode;
+}
+function useAdaptiveRenderChange(callback) {
+  const ctx = useStateContext();
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useLayoutEffect(() => {
+    let mode = peek$(ctx, "adaptiveRender");
+    return listen$(ctx, "adaptiveRender", (nextMode) => {
+      if (mode !== nextMode) {
+        mode = nextMode;
+        callbackRef.current(nextMode);
+      }
+    });
+  }, [ctx]);
+}
 function useViewability(callback, configId) {
   const ctx = useStateContext();
   const containerContext = useContextContainer();
@@ -802,6 +822,7 @@ function isInMVCPActiveMode(state) {
 // src/components/Container.tsx
 function getContainerPositionStyle({
   columnWrapperStyle,
+  contentContainerAlignItems,
   horizontal,
   hasItemSeparator,
   isHorizontalRTLList,
@@ -827,13 +848,14 @@ function getContainerPositionStyle({
     }
   }
   return horizontal ? {
+    bottom: contentContainerAlignItems === "flex-end" && numColumns === 1 ? 0 : void 0,
     boxSizing: paddingStyles ? "border-box" : void 0,
     direction: isHorizontalRTLList && Platform.OS === "web" ? "ltr" : void 0,
     flexDirection: hasItemSeparator ? "row" : void 0,
     height: otherAxisSize,
     left: 0,
     position: "absolute",
-    top: otherAxisPos,
+    top: contentContainerAlignItems === "flex-end" && numColumns === 1 ? void 0 : otherAxisPos,
     ...paddingStyles || {}
   } : {
     boxSizing: paddingStyles ? "border-box" : void 0,
@@ -887,6 +909,7 @@ var Container = typedMemo(function Container2({
   const style = useMemo(
     () => getContainerPositionStyle({
       columnWrapperStyle,
+      contentContainerAlignItems: ctx.state.props.contentContainerAlignItems,
       hasItemSeparator: !!ItemSeparatorComponent,
       horizontal,
       isHorizontalRTLList,
@@ -900,6 +923,7 @@ var Container = typedMemo(function Container2({
       otherAxisPos,
       otherAxisSize,
       columnWrapperStyle,
+      ctx.state.props.contentContainerAlignItems,
       numColumns,
       ItemSeparatorComponent
     ]
@@ -1615,7 +1639,12 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
       WebkitOverflowScrolling: "touch"
       // iOS momentum scrolling
     },
-    ...StyleSheet.flatten(style)
+    ...StyleSheet.flatten(style),
+    ...maintainVisibleContentPosition ? {
+      // Chrome's native scroll anchoring can apply after LegendList's MVCP adjustment,
+      // causing the same header/item-size delta to be compensated twice.
+      overflowAnchor: "none"
+    } : {}
   };
   const contentInsetEndAdjustment = getContentInsetEndAdjustmentEnd2(ctx);
   const anchoredEndInset = ((_c = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.props) == null ? void 0 : _b.anchoredEndSpace) == null ? void 0 : _c.includeInEndInset) && anchoredEndSpaceSize ? anchoredEndSpaceSize : 0;
@@ -1626,7 +1655,10 @@ var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
     flexDirection: horizontal ? "row" : void 0,
     minHeight: horizontal ? void 0 : "100%",
     minWidth: horizontal ? "100%" : void 0,
-    ...StyleSheet.flatten(contentContainerStyle)
+    ...StyleSheet.flatten(contentContainerStyle),
+    ...maintainVisibleContentPosition ? {
+      overflowAnchor: "none"
+    } : {}
   };
   const className = contentContainerClassName ? `${LEGEND_LIST_CONTENT_CONTAINER_CLASS} ${contentContainerClassName}` : LEGEND_LIST_CONTENT_CONTAINER_CLASS;
   const {
@@ -1729,6 +1761,7 @@ function scrollAdjustBy(el, left, top) {
 function ScrollAdjust() {
   const ctx = useStateContext();
   const lastScrollOffsetRef = React3.useRef(0);
+  const lastScrollAdjustUserOffsetRef = React3.useRef(0);
   const resetPaddingRafRef = React3.useRef(void 0);
   const resetPaddingBaselineRef = React3.useRef(void 0);
   const contentNodeRef = React3.useRef(null);
@@ -1737,20 +1770,24 @@ function ScrollAdjust() {
     const scrollAdjust = peek$(ctx, "scrollAdjust");
     const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
     const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
-    const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
-    if (scrollDelta !== 0) {
+    const signalScrollDelta = scrollOffset - lastScrollOffsetRef.current;
+    if (signalScrollDelta !== 0) {
       const target = getScrollAdjustTarget(ctx, contentNodeRef.current);
       if (target) {
         const horizontal = !!ctx.state.props.horizontal;
         const axis = getScrollAdjustAxis(horizontal);
         const { contentNode, scrollElement: el } = target;
+        const currentScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        const userOffsetDelta = (scrollAdjustUserOffset || 0) - lastScrollAdjustUserOffsetRef.current;
+        const intendedScroll = userOffsetDelta !== 0 ? currentScroll + userOffsetDelta : ctx.state.scroll;
+        const scrollDelta = intendedScroll - currentScroll;
+        const shouldScroll = Math.abs(scrollDelta) > 0.01;
         const scrollBy = () => scrollAdjustBy(el, axis.x * scrollDelta, axis.y * scrollDelta);
         contentNodeRef.current = contentNode;
-        if (contentNode) {
-          const prevScroll = horizontal ? el.scrollLeft : el.scrollTop;
+        if (shouldScroll && contentNode) {
           const totalSize = contentNode[axis.contentSizeKey];
           const viewportSize = el[axis.viewportSizeKey];
-          const nextScroll = prevScroll + scrollDelta;
+          const nextScroll = currentScroll + scrollDelta;
           const needsTemporaryPadding = scrollDelta > 0 && !ctx.state.adjustingFromInitialMount && totalSize < nextScroll + viewportSize;
           if (needsTemporaryPadding) {
             const previousPaddingEnd = (_a3 = resetPaddingBaselineRef.current) != null ? _a3 : contentNode.style[axis.paddingEndProp];
@@ -1770,11 +1807,12 @@ function ScrollAdjust() {
           } else {
             scrollBy();
           }
-        } else {
+        } else if (shouldScroll) {
           scrollBy();
         }
       }
       lastScrollOffsetRef.current = scrollOffset;
+      lastScrollAdjustUserOffsetRef.current = scrollAdjustUserOffset || 0;
     }
   }, [ctx]);
   useValueListener$("scrollAdjust", callback);
@@ -1796,7 +1834,68 @@ function WebAnchoredEndSpace({ horizontal }) {
   return /* @__PURE__ */ React3.createElement("div", { style }, null);
 }
 
-// src/core/updateContentMetrics.ts
+// src/core/doMaintainScrollAtEnd.ts
+function doMaintainScrollAtEnd(ctx) {
+  const state = ctx.state;
+  const {
+    didContainersLayout,
+    pendingNativeMVCPAdjust,
+    refScroller,
+    props: { maintainScrollAtEnd }
+  } = state;
+  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
+  if (pendingNativeMVCPAdjust) {
+    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
+    return false;
+  }
+  state.pendingMaintainScrollAtEnd = false;
+  if (shouldMaintainScrollAtEnd) {
+    const contentSize = getContentSize(ctx);
+    if (contentSize < state.scrollLength) {
+      state.scroll = 0;
+    }
+    if (!state.maintainingScrollAtEnd) {
+      const pendingState = maintainScrollAtEnd.animated ? "pending-animated" : "pending-instant";
+      const activeState = maintainScrollAtEnd.animated ? "animated" : "instant";
+      state.maintainingScrollAtEnd = pendingState;
+      requestAnimationFrame(() => {
+        if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
+          state.maintainingScrollAtEnd = activeState;
+          const scroller = refScroller.current;
+          if (state.props.horizontal && isHorizontalRTL(state)) {
+            const currentContentSize = getContentSize(ctx);
+            const logicalEndOffset = getLogicalHorizontalMaxOffset(state, currentContentSize);
+            const nativeOffset = toNativeHorizontalOffset(state, logicalEndOffset, currentContentSize);
+            scroller == null ? void 0 : scroller.scrollTo({
+              animated: maintainScrollAtEnd.animated,
+              x: nativeOffset,
+              y: 0
+            });
+          } else {
+            scroller == null ? void 0 : scroller.scrollToEnd({
+              animated: maintainScrollAtEnd.animated
+            });
+          }
+          setTimeout(
+            () => {
+              if (state.maintainingScrollAtEnd === activeState) {
+                state.maintainingScrollAtEnd = void 0;
+              }
+            },
+            maintainScrollAtEnd.animated ? 500 : 0
+          );
+        } else if (state.maintainingScrollAtEnd === pendingState) {
+          state.maintainingScrollAtEnd = void 0;
+        }
+      });
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/core/updateContentMetricsState.ts
 function getRawContentLength(ctx) {
   var _a3, _b, _c;
   const { state, values } = ctx;
@@ -1807,320 +1906,128 @@ function getAlignItemsAtEndPadding(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;
 }
-function updateContentMetrics(ctx) {
+function updateContentMetricsState(ctx) {
+  const previousPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
   const nextPadding = getAlignItemsAtEndPadding(ctx);
-  if (peek$(ctx, "alignItemsAtEndPadding") !== nextPadding) {
+  if (previousPadding !== nextPadding) {
     set$(ctx, "alignItemsAtEndPadding", nextPadding);
   }
 }
-function setContentLengthSignal(ctx, signalName, size) {
-  if (peek$(ctx, signalName) !== size) {
-    set$(ctx, signalName, size);
-    updateContentMetrics(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) {
+    {
+      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);
   }
 }
-function setHeaderSize(ctx, size) {
-  setContentLengthSignal(ctx, "headerSize", size);
+
+// 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 setFooterSize(ctx, size) {
-  setContentLengthSignal(ctx, "footerSize", size);
+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
+      )
+    );
+  }
 }
-function areInsetsEqual(left, right) {
-  var _a3, _b, _c, _d, _e, _f, _g, _h;
-  return ((_a3 = left == null ? void 0 : left.top) != null ? _a3 : 0) === ((_b = right == null ? void 0 : right.top) != null ? _b : 0) && ((_c = left == null ? void 0 : left.bottom) != null ? _c : 0) === ((_d = right == null ? void 0 : right.bottom) != null ? _d : 0) && ((_e = left == null ? void 0 : left.left) != null ? _e : 0) === ((_f = right == null ? void 0 : right.left) != null ? _f : 0) && ((_g = left == null ? void 0 : left.right) != null ? _g : 0) === ((_h = right == null ? void 0 : right.right) != null ? _h : 0);
+
+// 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 setContentInsetOverride(ctx, inset) {
-  const { state } = ctx;
-  const previousInset = state.contentInsetOverride;
-  const nextInset = inset != null ? inset : void 0;
-  const didChange = !areInsetsEqual(previousInset, nextInset);
-  state.contentInsetOverride = nextInset;
-  if (didChange) {
-    updateContentMetrics(ctx);
-  }
-  return didChange;
+function clearInitialScrollSession(state) {
+  state.initialScrollSession = void 0;
+  return void 0;
 }
-function useStableRenderComponent(renderComponent, mapProps) {
-  const renderComponentRef = useLatestRef(renderComponent);
-  const mapPropsRef = useLatestRef(mapProps);
-  return React3.useMemo(
-    () => React3.forwardRef(
-      (props, ref) => {
-        var _a3, _b;
-        return (_b = (_a3 = renderComponentRef.current) == null ? void 0 : _a3.call(renderComponentRef, mapPropsRef.current(props, ref))) != null ? _b : null;
-      }
-    ),
-    [mapPropsRef, renderComponentRef]
-  );
+function createInitialScrollSession(options) {
+  const { bootstrap, completion, kind, previousDataLength } = options;
+  return kind === "offset" ? {
+    completion,
+    kind,
+    previousDataLength
+  } : {
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  };
 }
-var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
-  const localRef = useRef(null);
-  const ref = refView != null ? refView : localRef;
-  useOnLayoutSync({ onLayoutChange, ref });
-  return /* @__PURE__ */ React3.createElement("div", { ...rest, ref }, children);
-};
-
-// src/components/ListComponent.tsx
-var ListComponent = typedMemo(function ListComponent2({
-  canRender,
-  style,
-  contentContainerStyle,
-  horizontal,
-  initialContentOffset,
-  recycleItems,
-  ItemSeparatorComponent,
-  alignItemsAtEnd: _alignItemsAtEnd,
-  onScroll: onScroll2,
-  onLayout,
-  ListHeaderComponent,
-  ListHeaderComponentStyle,
-  ListFooterComponent,
-  ListFooterComponentStyle,
-  ListEmptyComponent,
-  getRenderedItem: getRenderedItem2,
-  updateItemSize: updateItemSize2,
-  refScrollView,
-  renderScrollComponent,
-  onLayoutFooter,
-  scrollAdjustHandler,
-  snapToIndices,
-  stickyHeaderConfig,
-  stickyHeaderIndices,
-  useWindowScroll = false,
-  ...rest
-}) {
-  const ctx = useStateContext();
-  const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
-  const [alignItemsAtEndPadding = 0, otherAxisSize = 0] = useArr$(["alignItemsAtEndPadding", "otherAxisSize"]);
-  const autoOtherAxisStyle = getAutoOtherAxisStyle({
-    horizontal,
-    needsOtherAxisSize: ctx.state.needsOtherAxisSize,
-    otherAxisSize
-  });
-  const CustomScrollComponent = useStableRenderComponent(
-    renderScrollComponent,
-    (props, ref) => ({ ...props, ref })
-  );
-  const ScrollComponent = renderScrollComponent ? CustomScrollComponent : ListComponentScrollView;
-  const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
-  useLayoutEffect(() => {
-    if (!ListHeaderComponent) {
-      setHeaderSize(ctx, 0);
-    }
-    if (!ListFooterComponent) {
-      setFooterSize(ctx, 0);
-    }
-  }, [ListHeaderComponent, ListFooterComponent, ctx]);
-  const onLayoutHeader = useCallback(
-    (rect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      setHeaderSize(ctx, size);
-    },
-    [ctx, horizontal]
-  );
-  const onLayoutFooterInternal = useCallback(
-    (rect, fromLayoutEffect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      setFooterSize(ctx, size);
-      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
-    },
-    [ctx, horizontal, onLayoutFooter]
-  );
-  return /* @__PURE__ */ React3.createElement(
-    SnapOrScroll,
-    {
-      ...rest,
-      ...ScrollComponent === ListComponentScrollView ? { useWindowScroll } : {},
-      contentContainerStyle: [
-        horizontal ? {
-          height: "100%"
-        } : {},
-        contentContainerStyle
-      ],
-      contentOffset: initialContentOffset !== void 0 ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
-      horizontal,
-      maintainVisibleContentPosition: maintainVisibleContentPosition.size || maintainVisibleContentPosition.data ? { minIndexForVisible: 0 } : void 0,
-      onLayout,
-      onScroll: onScroll2,
-      ref: refScrollView,
-      ScrollComponent: snapToIndices ? ScrollComponent : void 0,
-      style: autoOtherAxisStyle ? [autoOtherAxisStyle, style] : style
-    },
-    /* @__PURE__ */ React3.createElement(ScrollAdjust, null),
-    ListHeaderComponent && /* @__PURE__ */ React3.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
-    ListEmptyComponent && getComponent(ListEmptyComponent),
-    alignItemsAtEndPadding > 0 && /* @__PURE__ */ React3.createElement(
-      View,
-      {
-        style: horizontal ? { flexShrink: 0, width: alignItemsAtEndPadding } : { flexShrink: 0, height: alignItemsAtEndPadding }
-      },
-      null
-    ),
-    canRender && !ListEmptyComponent && /* @__PURE__ */ React3.createElement(
-      Containers,
-      {
-        getRenderedItem: getRenderedItem2,
-        horizontal,
-        ItemSeparatorComponent,
-        recycleItems,
-        stickyHeaderConfig,
-        updateItemSize: updateItemSize2
-      }
-    ),
-    ListFooterComponent && /* @__PURE__ */ React3.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
-    /* @__PURE__ */ React3.createElement(WebAnchoredEndSpace, { horizontal }),
-    IS_DEV && ENABLE_DEVMODE
-  );
-});
-var WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH = 100;
-var WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO = 0.9;
-var WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO = 0.9;
-function useDevChecksImpl(props) {
-  const ctx = useStateContext();
-  const { childrenMode, keyExtractor, renderScrollComponent, useWindowScroll } = props;
-  useEffect(() => {
-    if (useWindowScroll && renderScrollComponent) {
-      warnDevOnce(
-        "useWindowScrollRenderScrollComponent",
-        "useWindowScroll is not supported when renderScrollComponent is provided."
-      );
-    }
-  }, [renderScrollComponent, useWindowScroll]);
-  useEffect(() => {
-    if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
-      warnDevOnce(
-        "keyExtractor",
-        "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
-      );
-    }
-  }, [childrenMode, ctx, keyExtractor]);
-  useEffect(() => {
-    const state = ctx.state;
-    const dataLength = state.props.data.length;
-    const useWindowScrollResolved = state.props.useWindowScroll;
-    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
-      return;
-    }
-    const warnIfUnboundedOuterSize = () => {
-      const readyToRender = peek$(ctx, "readyToRender");
-      const numContainers = peek$(ctx, "numContainers") || 0;
-      const totalSize = peek$(ctx, "totalSize") || 0;
-      const scrollLength = ctx.state.scrollLength || 0;
-      if (!readyToRender || totalSize <= 0 || scrollLength <= 0) {
-        return;
-      }
-      const rendersAlmostEverything = numContainers >= Math.ceil(dataLength * WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO);
-      const viewportMatchesContent = scrollLength >= totalSize * WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO;
-      if (rendersAlmostEverything && viewportMatchesContent) {
-        warnDevOnce(
-          "webUnboundedOuterSize",
-          "LegendList appears to have an unbounded outer height on web, so virtualization is effectively disabled. Set a bounded height or flex: 1 on the list container, or use useWindowScroll."
-        );
-      }
-    };
-    warnIfUnboundedOuterSize();
-    const unsubscribe = [
-      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
-      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
-      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
-    ];
-    return () => {
-      for (const unsub of unsubscribe) {
-        unsub();
-      }
-    };
-  }, [ctx]);
-}
-function useDevChecksNoop(_props) {
-}
-var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
-
-// 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/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;
+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;
@@ -2346,6 +2253,66 @@ function recalculateSettledScroll(ctx) {
   checkThresholds(ctx);
 }
 
+// src/core/adaptiveRender.ts
+var DEFAULT_ENTER_VELOCITY = 4;
+var DEFAULT_EXIT_VELOCITY = 1;
+var DEFAULT_EXIT_DELAY = 1e3;
+function scheduleAdaptiveRenderExit(ctx, exitDelay) {
+  const state = ctx.state;
+  const previousTimeout = state.timeoutAdaptiveRender;
+  if (previousTimeout !== void 0) {
+    clearTimeout(previousTimeout);
+    state.timeouts.delete(previousTimeout);
+    state.timeoutAdaptiveRender = void 0;
+  }
+  if (exitDelay <= 0) {
+    setAdaptiveRender(ctx, "normal");
+  } else {
+    const timeout = setTimeout(() => {
+      state.timeouts.delete(timeout);
+      state.timeoutAdaptiveRender = void 0;
+      setAdaptiveRender(ctx, "normal");
+    }, exitDelay);
+    state.timeoutAdaptiveRender = timeout;
+    state.timeouts.add(timeout);
+  }
+}
+function setAdaptiveRender(ctx, mode) {
+  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);
+  }
+}
+function updateAdaptiveRender(ctx, scrollVelocity) {
+  var _a3, _b, _c;
+  const state = ctx.state;
+  const adaptiveRender = state.props.adaptiveRender;
+  const enterVelocity = (_a3 = adaptiveRender == null ? void 0 : adaptiveRender.enterVelocity) != null ? _a3 : DEFAULT_ENTER_VELOCITY;
+  const exitVelocity = (_b = adaptiveRender == null ? void 0 : adaptiveRender.exitVelocity) != null ? _b : DEFAULT_EXIT_VELOCITY;
+  const exitDelay = (_c = adaptiveRender == null ? void 0 : adaptiveRender.exitDelay) != null ? _c : DEFAULT_EXIT_DELAY;
+  const currentMode = peek$(ctx, "adaptiveRender");
+  const threshold = currentMode === "light" ? exitVelocity : enterVelocity;
+  const nextMode = Math.abs(scrollVelocity) > threshold ? "light" : "normal";
+  const previousMode = state.timeoutAdaptiveRender !== void 0 ? "normal" : currentMode;
+  if (nextMode !== previousMode) {
+    if (nextMode === "light") {
+      setAdaptiveRender(ctx, "light");
+      scheduleAdaptiveRenderExit(ctx, exitDelay);
+    } else if (currentMode === "light") {
+      scheduleAdaptiveRenderExit(ctx, exitDelay);
+    }
+  }
+}
+
+// src/utils/getEffectiveDrawDistance.ts
+var INITIAL_DRAW_DISTANCE = 100;
+function getEffectiveDrawDistance(ctx) {
+  const drawDistance = ctx.state.props.drawDistance;
+  return peek$(ctx, "readyToRender") ? drawDistance : Math.min(drawDistance, INITIAL_DRAW_DISTANCE);
+}
+
 // src/utils/setInitialRenderState.ts
 function setInitialRenderState(ctx, {
   didLayout,
@@ -2365,6 +2332,13 @@ function setInitialRenderState(ctx, {
   const isReadyToRender = Boolean(state.didContainersLayout && state.didFinishInitialScroll);
   if (isReadyToRender && !peek$(ctx, "readyToRender")) {
     set$(ctx, "readyToRender", true);
+    setAdaptiveRender(ctx, "normal");
+    if (state.props.drawDistance > INITIAL_DRAW_DISTANCE) {
+      requestAnimationFrame(() => {
+        var _a3;
+        (_a3 = state.triggerCalculateItemsInView) == null ? void 0 : _a3.call(state);
+      });
+    }
     if (onLoad) {
       onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
     }
@@ -2439,10 +2413,420 @@ function finishInitialScroll(ctx, options) {
   complete();
 }
 
-// src/core/calculateOffsetForIndex.ts
-function calculateOffsetForIndex(ctx, index) {
+// src/core/finishScrollTo.ts
+function finishScrollTo(ctx) {
+  var _a3, _b;
   const state = ctx.state;
-  return index !== void 0 ? state.positions[index] || 0 : 0;
+  if (state == null ? void 0 : state.scrollingTo) {
+    const resolvePendingScroll = state.pendingScrollResolve;
+    state.pendingScrollResolve = void 0;
+    const scrollingTo = state.scrollingTo;
+    state.scrollHistory.length = 0;
+    state.scrollingTo = void 0;
+    if (state.pendingTotalSize !== void 0) {
+      addTotalSize(ctx, null, state.pendingTotalSize);
+    }
+    {
+      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
+    }
+    if (scrollingTo.isInitialScroll || state.initialScroll) {
+      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
+      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
+      finishInitialScroll(ctx, {
+        onFinished: () => {
+          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+        },
+        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
+        recalculateItems: true,
+        schedulePreservedTargetClear: shouldPreserveResizeTarget,
+        syncObservedOffset: isOffsetSession,
+        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
+      });
+      return;
+    }
+    recalculateSettledScroll(ctx);
+    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
+  }
+}
+
+// src/core/doScrollTo.ts
+var SCROLL_END_IDLE_MS = 80;
+var SCROLL_END_MAX_MS = 1500;
+var SMOOTH_SCROLL_DURATION_MS = 320;
+var SCROLL_END_TARGET_EPSILON = 1;
+function doScrollTo(ctx, params) {
+  var _a3, _b;
+  const state = ctx.state;
+  const { animated, horizontal, offset } = params;
+  const scroller = state.refScroller.current;
+  const node = scroller == null ? void 0 : scroller.getScrollableNode();
+  if (!scroller || !node) {
+    return;
+  }
+  const isAnimated = !!animated;
+  const isHorizontal = !!horizontal;
+  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
+  const left = isHorizontal ? toNativeHorizontalOffset(state, offset, contentSize) : 0;
+  const top = isHorizontal ? 0 : offset;
+  scroller.scrollTo({ animated: isAnimated, x: left, y: top });
+  if (isAnimated) {
+    const target = (_b = (_a3 = scroller.getScrollEventTarget) == null ? void 0 : _a3.call(scroller)) != null ? _b : null;
+    listenForScrollEnd(ctx, {
+      readOffset: () => scroller.getCurrentScrollOffset(),
+      target,
+      targetOffset: offset
+    });
+  } else {
+    state.scroll = offset;
+    setTimeout(() => {
+      finishScrollTo(ctx);
+    }, 100);
+  }
+}
+function listenForScrollEnd(ctx, params) {
+  const { readOffset, target, targetOffset } = params;
+  if (!target) {
+    finishScrollTo(ctx);
+    return;
+  }
+  const supportsScrollEnd = "onscrollend" in target;
+  let idleTimeout;
+  let settled = false;
+  const targetToken = ctx.state.scrollingTo;
+  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
+  const cleanup = () => {
+    target.removeEventListener("scroll", onScroll2);
+    if (supportsScrollEnd) {
+      target.removeEventListener("scrollend", onScrollEnd);
+    }
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    clearTimeout(maxTimeout);
+  };
+  const finish = (reason) => {
+    if (settled) return;
+    if (targetToken !== ctx.state.scrollingTo) {
+      settled = true;
+      cleanup();
+      return;
+    }
+    const currentOffset = readOffset();
+    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
+    if (reason === "scrollend" && !isNearTarget) {
+      return;
+    }
+    settled = true;
+    cleanup();
+    finishScrollTo(ctx);
+  };
+  const onScroll2 = () => {
+    if (idleTimeout) {
+      clearTimeout(idleTimeout);
+    }
+    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
+  };
+  const onScrollEnd = () => finish("scrollend");
+  target.addEventListener("scroll", onScroll2);
+  if (supportsScrollEnd) {
+    target.addEventListener("scrollend", onScrollEnd);
+  } else {
+    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
+  }
+}
+
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
+  const state = ctx.state;
+  if (Math.abs(positionDiff) > 0.1) {
+    const doit = () => {
+      {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
+      }
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
+    }
+  }
+}
+
+// src/core/updateContentMetrics.ts
+var SCROLL_ADJUST_EPSILON = 0.1;
+function setContentLengthSignal(ctx, signalName, size) {
+  const didChange = peek$(ctx, signalName) !== size;
+  if (didChange) {
+    set$(ctx, signalName, size);
+    updateContentMetricsState(ctx);
+  }
+  return didChange;
+}
+function shouldAdjustForHeaderSizeChange(ctx, previousHeaderSize, nextHeaderSize) {
+  const { didContainersLayout, didFinishInitialScroll, props, scroll, scrollingTo } = ctx.state;
+  const sizeDiff = nextHeaderSize - previousHeaderSize;
+  const leadingPadding = props.horizontal ? props.stylePaddingLeft : props.stylePaddingTop;
+  const previousHeaderEnd = (leadingPadding || 0) + previousHeaderSize;
+  return props.maintainVisibleContentPosition.size && didContainersLayout && didFinishInitialScroll && !scrollingTo && scroll >= previousHeaderEnd - SCROLL_ADJUST_EPSILON && Math.abs(sizeDiff) > SCROLL_ADJUST_EPSILON;
+}
+function setHeaderSize(ctx, size) {
+  const { state } = ctx;
+  const previousHeaderSize = peek$(ctx, "headerSize") || 0;
+  const didChange = previousHeaderSize !== size;
+  const hasMeasuredOrEstimatedHeaderBaseline = state.didMeasureHeader || previousHeaderSize > SCROLL_ADJUST_EPSILON;
+  if (didChange) {
+    set$(ctx, "headerSize", size);
+    updateContentMetricsState(ctx);
+    if (hasMeasuredOrEstimatedHeaderBaseline && shouldAdjustForHeaderSizeChange(ctx, previousHeaderSize, size)) {
+      requestAdjust(ctx, size - previousHeaderSize);
+    }
+  }
+  state.didMeasureHeader = true;
+}
+function setFooterSize(ctx, size) {
+  return setContentLengthSignal(ctx, "footerSize", size);
+}
+function areInsetsEqual(left, right) {
+  var _a3, _b, _c, _d, _e, _f, _g, _h;
+  return ((_a3 = left == null ? void 0 : left.top) != null ? _a3 : 0) === ((_b = right == null ? void 0 : right.top) != null ? _b : 0) && ((_c = left == null ? void 0 : left.bottom) != null ? _c : 0) === ((_d = right == null ? void 0 : right.bottom) != null ? _d : 0) && ((_e = left == null ? void 0 : left.left) != null ? _e : 0) === ((_f = right == null ? void 0 : right.left) != null ? _f : 0) && ((_g = left == null ? void 0 : left.right) != null ? _g : 0) === ((_h = right == null ? void 0 : right.right) != null ? _h : 0);
+}
+function setContentInsetOverride(ctx, inset) {
+  const { state } = ctx;
+  const previousInset = state.contentInsetOverride;
+  const nextInset = inset != null ? inset : void 0;
+  const didChange = !areInsetsEqual(previousInset, nextInset);
+  state.contentInsetOverride = nextInset;
+  if (didChange) {
+    updateContentMetricsState(ctx);
+  }
+  return didChange;
+}
+function useStableRenderComponent(renderComponent, mapProps) {
+  const renderComponentRef = useLatestRef(renderComponent);
+  const mapPropsRef = useLatestRef(mapProps);
+  return React3.useMemo(
+    () => React3.forwardRef(
+      (props, ref) => {
+        var _a3, _b;
+        return (_b = (_a3 = renderComponentRef.current) == null ? void 0 : _a3.call(renderComponentRef, mapPropsRef.current(props, ref))) != null ? _b : null;
+      }
+    ),
+    [mapPropsRef, renderComponentRef]
+  );
+}
+var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
+  const localRef = useRef(null);
+  const ref = refView != null ? refView : localRef;
+  useOnLayoutSync({ onLayoutChange, ref });
+  return /* @__PURE__ */ React3.createElement("div", { ...rest, ref }, children);
+};
+
+// src/components/ListComponent.tsx
+var AlignItemsAtEndSpacer = typedMemo(function AlignItemsAtEndSpacer2({ horizontal }) {
+  const [alignItemsAtEndPadding = 0] = useArr$(["alignItemsAtEndPadding"]);
+  if (alignItemsAtEndPadding <= 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React3.createElement(
+    View,
+    {
+      style: horizontal ? { flexShrink: 0, width: alignItemsAtEndPadding } : { flexShrink: 0, height: alignItemsAtEndPadding }
+    },
+    null
+  );
+});
+var ListComponent = typedMemo(function ListComponent2({
+  canRender,
+  style,
+  contentContainerStyle,
+  horizontal,
+  initialContentOffset,
+  recycleItems,
+  ItemSeparatorComponent,
+  alignItemsAtEnd: _alignItemsAtEnd,
+  onScroll: onScroll2,
+  onLayout,
+  ListHeaderComponent,
+  ListHeaderComponentStyle,
+  ListFooterComponent,
+  ListFooterComponentStyle,
+  ListEmptyComponent,
+  getRenderedItem: getRenderedItem2,
+  updateItemSize: updateItemSize2,
+  refScrollView,
+  renderScrollComponent,
+  onLayoutFooter,
+  scrollAdjustHandler,
+  snapToIndices,
+  stickyHeaderConfig,
+  stickyHeaderIndices,
+  useWindowScroll = false,
+  ...rest
+}) {
+  const ctx = useStateContext();
+  const maintainVisibleContentPosition = ctx.state.props.maintainVisibleContentPosition;
+  const [otherAxisSize = 0] = useArr$(["otherAxisSize"]);
+  const shouldRenderAlignItemsAtEndSpacer = ctx.state.props.alignItemsAtEndPaddingEnabled;
+  const autoOtherAxisStyle = getAutoOtherAxisStyle({
+    horizontal,
+    needsOtherAxisSize: ctx.state.needsOtherAxisSize,
+    otherAxisSize
+  });
+  const CustomScrollComponent = useStableRenderComponent(
+    renderScrollComponent,
+    (props, ref) => ({ ...props, ref })
+  );
+  const ScrollComponent = renderScrollComponent ? CustomScrollComponent : ListComponentScrollView;
+  const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
+  const updateFooterSize = useCallback(
+    (size, afterSizeUpdate) => {
+      var _a3;
+      const didFooterSizeChange = setFooterSize(ctx, size);
+      afterSizeUpdate == null ? void 0 : afterSizeUpdate();
+      if (didFooterSizeChange && ((_a3 = ctx.state.props.maintainScrollAtEnd) == null ? void 0 : _a3.onFooterLayout)) {
+        doMaintainScrollAtEnd(ctx);
+      }
+    },
+    [ctx]
+  );
+  useLayoutEffect(() => {
+    if (!ListHeaderComponent) {
+      setHeaderSize(ctx, 0);
+    }
+    if (!ListFooterComponent) {
+      updateFooterSize(0);
+    }
+  }, [ListHeaderComponent, ListFooterComponent, ctx, updateFooterSize]);
+  const onLayoutHeader = useCallback(
+    (rect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      setHeaderSize(ctx, size);
+    },
+    [ctx, horizontal]
+  );
+  const onLayoutFooterInternal = useCallback(
+    (rect, fromLayoutEffect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      updateFooterSize(size, () => {
+        onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
+      });
+    },
+    [horizontal, onLayoutFooter, updateFooterSize]
+  );
+  return /* @__PURE__ */ React3.createElement(
+    SnapOrScroll,
+    {
+      ...rest,
+      ...ScrollComponent === ListComponentScrollView ? { useWindowScroll } : {},
+      contentContainerStyle: [
+        horizontal ? {
+          height: "100%"
+        } : {},
+        contentContainerStyle
+      ],
+      contentOffset: initialContentOffset !== void 0 ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
+      horizontal,
+      maintainVisibleContentPosition: maintainVisibleContentPosition.size || maintainVisibleContentPosition.data ? { minIndexForVisible: 0 } : void 0,
+      onLayout,
+      onScroll: onScroll2,
+      ref: refScrollView,
+      ScrollComponent: snapToIndices ? ScrollComponent : void 0,
+      style: autoOtherAxisStyle ? [autoOtherAxisStyle, style] : style
+    },
+    /* @__PURE__ */ React3.createElement(ScrollAdjust, null),
+    ListHeaderComponent && /* @__PURE__ */ React3.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
+    ListEmptyComponent && getComponent(ListEmptyComponent),
+    shouldRenderAlignItemsAtEndSpacer && /* @__PURE__ */ React3.createElement(AlignItemsAtEndSpacer, { horizontal }),
+    canRender && !ListEmptyComponent && /* @__PURE__ */ React3.createElement(
+      Containers,
+      {
+        getRenderedItem: getRenderedItem2,
+        horizontal,
+        ItemSeparatorComponent,
+        recycleItems,
+        stickyHeaderConfig,
+        updateItemSize: updateItemSize2
+      }
+    ),
+    ListFooterComponent && /* @__PURE__ */ React3.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
+    /* @__PURE__ */ React3.createElement(WebAnchoredEndSpace, { horizontal }),
+    IS_DEV && ENABLE_DEVMODE
+  );
+});
+var WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH = 100;
+var WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO = 0.9;
+var WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO = 0.9;
+function useDevChecksImpl(props) {
+  const ctx = useStateContext();
+  const { childrenMode, keyExtractor, renderScrollComponent, useWindowScroll } = props;
+  useEffect(() => {
+    if (useWindowScroll && renderScrollComponent) {
+      warnDevOnce(
+        "useWindowScrollRenderScrollComponent",
+        "useWindowScroll is not supported when renderScrollComponent is provided."
+      );
+    }
+  }, [renderScrollComponent, useWindowScroll]);
+  useEffect(() => {
+    if (!keyExtractor && !ctx.state.isFirst && ctx.state.didDataChange && !childrenMode) {
+      warnDevOnce(
+        "keyExtractor",
+        "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
+      );
+    }
+  }, [childrenMode, ctx, keyExtractor]);
+  useEffect(() => {
+    const state = ctx.state;
+    const dataLength = state.props.data.length;
+    const useWindowScrollResolved = state.props.useWindowScroll;
+    if (useWindowScrollResolved || dataLength < WEB_UNBOUNDED_HEIGHT_MIN_DATA_LENGTH) {
+      return;
+    }
+    const warnIfUnboundedOuterSize = () => {
+      const readyToRender = peek$(ctx, "readyToRender");
+      const numContainers = peek$(ctx, "numContainers") || 0;
+      const totalSize = peek$(ctx, "totalSize") || 0;
+      const scrollLength = ctx.state.scrollLength || 0;
+      if (!readyToRender || totalSize <= 0 || scrollLength <= 0) {
+        return;
+      }
+      const rendersAlmostEverything = numContainers >= Math.ceil(dataLength * WEB_UNBOUNDED_HEIGHT_CONTAINER_RATIO);
+      const viewportMatchesContent = scrollLength >= totalSize * WEB_UNBOUNDED_HEIGHT_VIEWPORT_RATIO;
+      if (rendersAlmostEverything && viewportMatchesContent) {
+        warnDevOnce(
+          "webUnboundedOuterSize",
+          "LegendList appears to have an unbounded outer height on web, so virtualization is effectively disabled. Set a bounded height or flex: 1 on the list container, or use useWindowScroll."
+        );
+      }
+    };
+    warnIfUnboundedOuterSize();
+    const unsubscribe = [
+      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
+      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
+      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
+    ];
+    return () => {
+      for (const unsub of unsubscribe) {
+        unsub();
+      }
+    };
+  }, [ctx]);
+}
+function useDevChecksNoop(_props) {
+}
+var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
+
+// src/core/calculateOffsetForIndex.ts
+function calculateOffsetForIndex(ctx, index) {
+  const state = ctx.state;
+  return index !== void 0 ? state.positions[index] || 0 : 0;
 }
 
 // src/core/getTopOffsetAdjustment.ts
@@ -2462,34 +2846,6 @@ function getId(state, index) {
   return id;
 }
 
-// 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) {
-    {
-      state.pendingTotalSize = void 0;
-      state.totalSize = totalSize;
-      if (notifyTotalSize) {
-        set$(ctx, "totalSize", totalSize);
-      }
-      updateContentMetrics(ctx);
-    }
-  } 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;
@@ -2510,8 +2866,9 @@ function getKnownOrFixedSize(ctx, key, index, data, resolved) {
   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 : "" : "";
-    size = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
-    if (size !== void 0) {
+    const fixedSize = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
+    if (fixedSize !== void 0) {
+      size = fixedSize + ctx.scrollAxisGap;
       state.sizesKnown.set(key, size);
     }
   }
@@ -2558,281 +2915,79 @@ function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize, no
   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 (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;
-  }
-  setSize(ctx, key, size, notifyTotalSize);
-  return size;
-}
-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]);
-}
-
-// src/core/calculateOffsetWithOffsetPosition.ts
-function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
-  var _a3;
-  const state = ctx.state;
-  const { index, viewOffset, viewPosition } = params;
-  let offset = offsetParam;
-  if (viewOffset) {
-    offset -= viewOffset;
-  }
-  if (index !== void 0) {
-    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
-    if (topOffsetAdjustment) {
-      offset += topOffsetAdjustment;
-    }
-  }
-  if (viewPosition !== void 0 && index !== void 0) {
-    const dataLength = state.props.data.length;
-    if (dataLength === 0) {
-      return offset;
-    }
-    const isOutOfBounds = index < 0 || index >= dataLength;
-    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
-    const itemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
-    const trailingInset = getContentInsetEnd(ctx);
-    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
-    if (!isOutOfBounds && index === state.props.data.length - 1) {
-      const footerSize = peek$(ctx, "footerSize") || 0;
-      offset += footerSize;
-    }
-  }
-  return offset;
-}
-
-// src/core/clampScrollOffset.ts
-function clampScrollOffset(ctx, offset, scrollTarget) {
-  const state = ctx.state;
-  const contentSize = getContentSize(ctx);
-  let clampedOffset = offset;
-  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
-    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
-    const viewOffset = scrollTarget == null ? void 0 : scrollTarget.viewOffset;
-    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
-    const maxOffset = baseMaxOffset + extraEndOffset;
-    clampedOffset = Math.min(offset, maxOffset);
-  }
-  clampedOffset = Math.max(0, clampedOffset);
-  return clampedOffset;
-}
-
-// src/core/finishScrollTo.ts
-function finishScrollTo(ctx) {
-  var _a3, _b;
-  const state = ctx.state;
-  if (state == null ? void 0 : state.scrollingTo) {
-    const resolvePendingScroll = state.pendingScrollResolve;
-    state.pendingScrollResolve = void 0;
-    const scrollingTo = state.scrollingTo;
-    state.scrollHistory.length = 0;
-    state.scrollingTo = void 0;
-    if (state.pendingTotalSize !== void 0) {
-      addTotalSize(ctx, null, state.pendingTotalSize);
-    }
-    {
-      state.scrollAdjustHandler.commitPendingAdjust(scrollingTo);
-    }
-    if (scrollingTo.isInitialScroll || state.initialScroll) {
-      const isOffsetSession = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "offset";
-      const shouldPreserveResizeTarget = !!scrollingTo.isInitialScroll && !state.clearPreservedInitialScrollOnNextFinish && state.props.data.length > 0 && ((_b = state.initialScroll) == null ? void 0 : _b.viewPosition) === 1;
-      finishInitialScroll(ctx, {
-        onFinished: () => {
-          resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-        },
-        preserveTarget: isOffsetSession && state.props.data.length === 0 || shouldPreserveResizeTarget,
-        recalculateItems: true,
-        schedulePreservedTargetClear: shouldPreserveResizeTarget,
-        syncObservedOffset: isOffsetSession,
-        waitForCompletionFrame: !!scrollingTo.waitForInitialScrollCompletionFrame
-      });
-      return;
-    }
-    recalculateSettledScroll(ctx);
-    resolvePendingScroll == null ? void 0 : resolvePendingScroll();
-  }
-}
-
-// src/core/doScrollTo.ts
-var SCROLL_END_IDLE_MS = 80;
-var SCROLL_END_MAX_MS = 1500;
-var SMOOTH_SCROLL_DURATION_MS = 320;
-var SCROLL_END_TARGET_EPSILON = 1;
-function doScrollTo(ctx, params) {
-  var _a3, _b;
-  const state = ctx.state;
-  const { animated, horizontal, offset } = params;
-  const scroller = state.refScroller.current;
-  const node = scroller == null ? void 0 : scroller.getScrollableNode();
-  if (!scroller || !node) {
-    return;
-  }
-  const isAnimated = !!animated;
-  const isHorizontal = !!horizontal;
-  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
-  const left = isHorizontal ? toNativeHorizontalOffset(state, offset, contentSize) : 0;
-  const top = isHorizontal ? 0 : offset;
-  scroller.scrollTo({ animated: isAnimated, x: left, y: top });
-  if (isAnimated) {
-    const target = (_b = (_a3 = scroller.getScrollEventTarget) == null ? void 0 : _a3.call(scroller)) != null ? _b : null;
-    listenForScrollEnd(ctx, {
-      readOffset: () => scroller.getCurrentScrollOffset(),
-      target,
-      targetOffset: offset
-    });
-  } else {
-    state.scroll = offset;
-    setTimeout(() => {
-      finishScrollTo(ctx);
-    }, 100);
-  }
-}
-function listenForScrollEnd(ctx, params) {
-  const { readOffset, target, targetOffset } = params;
-  if (!target) {
-    finishScrollTo(ctx);
-    return;
-  }
-  const supportsScrollEnd = "onscrollend" in target;
-  let idleTimeout;
-  let settled = false;
-  const targetToken = ctx.state.scrollingTo;
-  const maxTimeout = setTimeout(() => finish("max"), SCROLL_END_MAX_MS);
-  const cleanup = () => {
-    target.removeEventListener("scroll", onScroll2);
-    if (supportsScrollEnd) {
-      target.removeEventListener("scrollend", onScrollEnd);
-    }
-    if (idleTimeout) {
-      clearTimeout(idleTimeout);
-    }
-    clearTimeout(maxTimeout);
-  };
-  const finish = (reason) => {
-    if (settled) return;
-    if (targetToken !== ctx.state.scrollingTo) {
-      settled = true;
-      cleanup();
-      return;
-    }
-    const currentOffset = readOffset();
-    const isNearTarget = Math.abs(currentOffset - targetOffset) <= SCROLL_END_TARGET_EPSILON;
-    if (reason === "scrollend" && !isNearTarget) {
-      return;
-    }
-    settled = true;
-    cleanup();
-    finishScrollTo(ctx);
-  };
-  const onScroll2 = () => {
-    if (idleTimeout) {
-      clearTimeout(idleTimeout);
+      size = roundSize(averageSizeForType);
     }
-    idleTimeout = setTimeout(() => finish("idle"), SCROLL_END_IDLE_MS);
-  };
-  const onScrollEnd = () => finish("scrollend");
-  target.addEventListener("scroll", onScroll2);
-  if (supportsScrollEnd) {
-    target.addEventListener("scrollend", onScrollEnd);
-  } else {
-    idleTimeout = setTimeout(() => finish("idle"), SMOOTH_SCROLL_DURATION_MS);
   }
+  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;
+}
+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]);
 }
 
-// src/core/doMaintainScrollAtEnd.ts
-function doMaintainScrollAtEnd(ctx) {
+// src/core/calculateOffsetWithOffsetPosition.ts
+function calculateOffsetWithOffsetPosition(ctx, offsetParam, params) {
+  var _a3;
   const state = ctx.state;
-  const {
-    didContainersLayout,
-    pendingNativeMVCPAdjust,
-    refScroller,
-    props: { maintainScrollAtEnd }
-  } = state;
-  const isWithinMaintainScrollAtEndThreshold = peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
-  const shouldMaintainScrollAtEnd = !!(isWithinMaintainScrollAtEndThreshold && maintainScrollAtEnd && didContainersLayout);
-  if (pendingNativeMVCPAdjust) {
-    state.pendingMaintainScrollAtEnd = shouldMaintainScrollAtEnd;
-    return false;
+  const { index, viewOffset, viewPosition } = params;
+  let offset = offsetParam;
+  if (viewOffset) {
+    offset -= viewOffset;
   }
-  state.pendingMaintainScrollAtEnd = false;
-  if (shouldMaintainScrollAtEnd) {
-    const contentSize = getContentSize(ctx);
-    if (contentSize < state.scrollLength) {
-      state.scroll = 0;
+  if (index !== void 0) {
+    const topOffsetAdjustment = getTopOffsetAdjustment(ctx);
+    if (topOffsetAdjustment) {
+      offset += topOffsetAdjustment;
     }
-    if (!state.maintainingScrollAtEnd) {
-      state.maintainingScrollAtEnd = true;
-      requestAnimationFrame(() => {
-        if (peek$(ctx, "isWithinMaintainScrollAtEndThreshold")) {
-          const scroller = refScroller.current;
-          if (state.props.horizontal && isHorizontalRTL(state)) {
-            const currentContentSize = getContentSize(ctx);
-            const logicalEndOffset = getLogicalHorizontalMaxOffset(state, currentContentSize);
-            const nativeOffset = toNativeHorizontalOffset(state, logicalEndOffset, currentContentSize);
-            scroller == null ? void 0 : scroller.scrollTo({
-              animated: maintainScrollAtEnd.animated,
-              x: nativeOffset,
-              y: 0
-            });
-          } else {
-            scroller == null ? void 0 : scroller.scrollToEnd({
-              animated: maintainScrollAtEnd.animated
-            });
-          }
-          setTimeout(
-            () => {
-              state.maintainingScrollAtEnd = false;
-            },
-            maintainScrollAtEnd.animated ? 500 : 0
-          );
-        } else {
-          state.maintainingScrollAtEnd = false;
-        }
-      });
+  }
+  if (viewPosition !== void 0 && index !== void 0) {
+    const dataLength = state.props.data.length;
+    if (dataLength === 0) {
+      return offset;
+    }
+    const isOutOfBounds = index < 0 || index >= dataLength;
+    const fallbackEstimatedSize = (_a3 = state.props.estimatedItemSize) != null ? _a3 : 0;
+    const itemSize = isOutOfBounds ? fallbackEstimatedSize : getItemSize(ctx, getId(state, index), index, state.props.data[index]);
+    const trailingInset = getContentInsetEnd(ctx);
+    offset -= viewPosition * (state.scrollLength - trailingInset - itemSize);
+    if (!isOutOfBounds && index === state.props.data.length - 1) {
+      const footerSize = peek$(ctx, "footerSize") || 0;
+      offset += footerSize;
     }
-    return true;
   }
-  return false;
+  return offset;
 }
 
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
+// src/core/clampScrollOffset.ts
+function clampScrollOffset(ctx, offset, scrollTarget) {
   const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    const doit = () => {
-      {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
-        }
-      }
-    };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-    } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
-    }
+  const contentSize = getContentSize(ctx);
+  let clampedOffset = offset;
+  if (Number.isFinite(contentSize) && Number.isFinite(state.scrollLength) && (Platform.OS !== "android")) {
+    const baseMaxOffset = Math.max(0, contentSize - state.scrollLength);
+    const viewOffset = scrollTarget == null ? void 0 : scrollTarget.viewOffset;
+    const extraEndOffset = typeof viewOffset === "number" && viewOffset < 0 ? -viewOffset : 0;
+    const maxOffset = baseMaxOffset + extraEndOffset;
+    clampedOffset = Math.min(offset, maxOffset);
   }
+  clampedOffset = Math.max(0, clampedOffset);
+  return clampedOffset;
 }
 
 // src/core/mvcp.ts
@@ -2980,6 +3135,10 @@ function prepareMVCP(ctx, dataChanged) {
   const now = Date.now();
   const enableMVCPAnchorLock = (!!dataChanged || !!state.mvcpAnchorLock);
   const scrollingTo = state.scrollingTo;
+  if (dataChanged && state.pendingScrollToEnd && scrollingTo === void 0) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
+  }
   const anchorLock = resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) ;
   let prevPosition;
   let targetId;
@@ -3108,7 +3267,7 @@ function prepareMVCP(ctx, dataChanged) {
         return;
       }
       if (Math.abs(positionDiff) > MVCP_POSITION_EPSILON) {
-        const shouldSkipAdjustForMaintainedEnd = state.maintainingScrollAtEnd && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
+        const shouldSkipAdjustForMaintainedEnd = (state.maintainingScrollAtEnd === "pending-animated" || state.maintainingScrollAtEnd === "animated") && peek$(ctx, "isWithinMaintainScrollAtEndThreshold");
         if (!shouldSkipAdjustForMaintainedEnd) {
           requestAdjust(ctx, positionDiff);
         }
@@ -3117,6 +3276,45 @@ function prepareMVCP(ctx, dataChanged) {
   }
 }
 
+// src/utils/getScrollVelocity.ts
+var getScrollVelocity = (state) => {
+  const { scrollHistory } = state;
+  const newestIndex = scrollHistory.length - 1;
+  if (newestIndex < 1) {
+    return 0;
+  }
+  const newest = scrollHistory[newestIndex];
+  const now = Date.now();
+  let direction = 0;
+  for (let i = newestIndex; i > 0; i--) {
+    const delta = scrollHistory[i].scroll - scrollHistory[i - 1].scroll;
+    if (delta !== 0) {
+      direction = Math.sign(delta);
+      break;
+    }
+  }
+  if (direction === 0) {
+    return 0;
+  }
+  let oldest = newest;
+  for (let i = newestIndex - 1; i >= 0; i--) {
+    const current = scrollHistory[i];
+    const next = scrollHistory[i + 1];
+    const delta = next.scroll - current.scroll;
+    const deltaSign = Math.sign(delta);
+    if (deltaSign !== 0 && deltaSign !== direction) {
+      break;
+    }
+    if (now - current.time > 1e3) {
+      break;
+    }
+    oldest = current;
+  }
+  const scrollDiff = newest.scroll - oldest.scroll;
+  const timeDiff = newest.time - oldest.time;
+  return timeDiff > 0 ? scrollDiff / timeDiff : 0;
+};
+
 // src/core/updateScroll.ts
 function updateScroll(ctx, newScroll, forceUpdate, options) {
   var _a3;
@@ -3142,6 +3340,8 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   if (scrollHistory.length > 5) {
     scrollHistory.shift();
   }
+  const scrollVelocity = getScrollVelocity(state);
+  updateAdaptiveRender(ctx, scrollVelocity);
   if (ignoreScrollFromMVCP && !scrollingTo) {
     const { lt, gt } = ignoreScrollFromMVCP;
     if (lt && newScroll < lt || gt && newScroll > gt) {
@@ -3165,7 +3365,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
     state.lastScrollDelta = scrollDelta;
     const runCalculateItems = () => {
       var _a4;
-      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0 });
+      (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, { doMVCP: scrollingTo !== void 0, scrollVelocity });
       checkThresholds(ctx);
     };
     if (scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust) {
@@ -4245,9 +4445,32 @@ function initializeInitialScrollOnMount(ctx, options) {
 }
 function handleInitialScrollDataChange(ctx, options) {
   var _a3, _b, _c;
-  const { dataLength, didDataChange, initialScrollAtEnd, stylePaddingBottom, useBootstrapInitialScroll } = options;
+  const {
+    dataLength,
+    didDataChange,
+    initialScrollAtEnd,
+    latestInitialScroll,
+    latestInitialScrollSessionKind,
+    stylePaddingBottom,
+    useBootstrapInitialScroll
+  } = options;
   const state = ctx.state;
   const previousDataLength = (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.previousDataLength) != null ? _b : 0;
+  const isFirstNonEmptyData = !state.hasHadNonEmptyData && dataLength > 0;
+  if (dataLength > 0) {
+    state.hasHadNonEmptyData = true;
+  }
+  if (isFirstNonEmptyData) {
+    if (latestInitialScroll) {
+      setInitialScrollTarget(state, latestInitialScroll);
+      setInitialScrollSession(state, {
+        kind: latestInitialScrollSessionKind,
+        previousDataLength
+      });
+    } else {
+      clearPreservedInitialScrollTarget(state);
+    }
+  }
   if (state.initialScrollSession) {
     state.initialScrollSession.previousDataLength = dataLength;
   }
@@ -4471,45 +4694,6 @@ function updateTotalSize(ctx) {
   }
 }
 
-// src/utils/getScrollVelocity.ts
-var getScrollVelocity = (state) => {
-  const { scrollHistory } = state;
-  const newestIndex = scrollHistory.length - 1;
-  if (newestIndex < 1) {
-    return 0;
-  }
-  const newest = scrollHistory[newestIndex];
-  const now = Date.now();
-  let direction = 0;
-  for (let i = newestIndex; i > 0; i--) {
-    const delta = scrollHistory[i].scroll - scrollHistory[i - 1].scroll;
-    if (delta !== 0) {
-      direction = Math.sign(delta);
-      break;
-    }
-  }
-  if (direction === 0) {
-    return 0;
-  }
-  let oldest = newest;
-  for (let i = newestIndex - 1; i >= 0; i--) {
-    const current = scrollHistory[i];
-    const next = scrollHistory[i + 1];
-    const delta = next.scroll - current.scroll;
-    const deltaSign = Math.sign(delta);
-    if (deltaSign !== 0 && deltaSign !== direction) {
-      break;
-    }
-    if (now - current.time > 1e3) {
-      break;
-    }
-    oldest = current;
-  }
-  const scrollDiff = newest.scroll - oldest.scroll;
-  const timeDiff = newest.time - oldest.time;
-  return timeDiff > 0 ? scrollDiff / timeDiff : 0;
-};
-
 // src/utils/updateSnapToOffsets.ts
 function updateSnapToOffsets(ctx) {
   const state = ctx.state;
@@ -5245,7 +5429,7 @@ function updateViewabilityForCachedRange(ctx, viewabilityConfigCallbackPairs, sc
 function calculateItemsInView(ctx, params = {}) {
   const state = ctx.state;
   batchedUpdates(() => {
-    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
     const {
       columns,
       containerItemKeys,
@@ -5254,14 +5438,7 @@ function calculateItemsInView(ctx, params = {}) {
       indexByKey,
       minIndexSizeChanged,
       positions,
-      props: {
-        alwaysRenderIndicesArr,
-        alwaysRenderIndicesSet,
-        drawDistance,
-        getItemType,
-        keyExtractor,
-        onStickyHeaderChange
-      },
+      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, getItemType, keyExtractor, onStickyHeaderChange },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -5273,6 +5450,7 @@ function calculateItemsInView(ctx, params = {}) {
     const stickyHeaderIndicesSet = state.props.stickyHeaderIndicesSet || /* @__PURE__ */ new Set();
     const alwaysRenderArr = alwaysRenderIndicesArr || [];
     const alwaysRenderSet = alwaysRenderIndicesSet || /* @__PURE__ */ new Set();
+    const drawDistance = getEffectiveDrawDistance(ctx);
     const { dataChanged, doMVCP, forceFullItemPositions } = params;
     const bootstrapInitialScrollState = ((_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind) === "bootstrap" ? state.initialScrollSession.bootstrap : void 0;
     const suppressInitialScrollSideEffects = !!bootstrapInitialScrollState;
@@ -5283,10 +5461,10 @@ function calculateItemsInView(ctx, params = {}) {
     let totalSize = getContentSize(ctx);
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "alignItemsAtEndPadding") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
-    const speed = getScrollVelocity(state);
+    const speed = (_b = params.scrollVelocity) != null ? _b : getScrollVelocity(state);
     const scrollExtra = 0;
     const { initialScroll, queuedInitialLayout } = state;
-    const scrollState = suppressInitialScrollSideEffects ? (_b = bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.scroll) != null ? _b : state.scroll : !queuedInitialLayout && hasActiveInitialScroll(state) && initialScroll ? (
+    const scrollState = suppressInitialScrollSideEffects ? (_c = bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.scroll) != null ? _c : state.scroll : !queuedInitialLayout && hasActiveInitialScroll(state) && initialScroll ? (
       // Before the initial layout settles, keep viewport math anchored to the
       // current initial-scroll target instead of transient native adjustments.
       resolveInitialScrollOffset(ctx, initialScroll)
@@ -5310,19 +5488,25 @@ function calculateItemsInView(ctx, params = {}) {
     };
     updateScroll2(scrollState);
     const previousStickyIndex = peek$(ctx, "activeStickyIndex");
-    const currentStickyIdx = stickyHeaderIndicesArr.length > 0 ? findCurrentStickyIndex(stickyHeaderIndicesArr, scroll, state) : -1;
-    const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyHeaderIndicesArr[currentStickyIdx] : -1;
-    const stickyIndexDidChange = previousStickyIndex !== nextActiveStickyIndex;
-    if (currentStickyIdx >= 0 || previousStickyIndex >= 0) {
-      set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
-    }
-    const shouldNotifyStickyHeaderChange = !!onStickyHeaderChange && stickyHeaderIndicesArr.length > 0 && stickyIndexDidChange;
-    const finishCalculateItemsInView = shouldNotifyStickyHeaderChange ? () => {
-      const item = data[nextActiveStickyIndex];
-      if (item !== void 0) {
-        onStickyHeaderChange == null ? void 0 : onStickyHeaderChange({ index: nextActiveStickyIndex, item });
+    const resolveStickyState = () => {
+      const currentStickyIdx = stickyHeaderIndicesArr.length > 0 ? findCurrentStickyIndex(stickyHeaderIndicesArr, scroll, state) : -1;
+      const nextActiveStickyIndex = currentStickyIdx >= 0 ? stickyHeaderIndicesArr[currentStickyIdx] : -1;
+      const stickyIndexDidChange = previousStickyIndex !== nextActiveStickyIndex;
+      if (currentStickyIdx >= 0 || previousStickyIndex >= 0) {
+        set$(ctx, "activeStickyIndex", nextActiveStickyIndex);
       }
-    } : void 0;
+      const shouldNotifyStickyHeaderChange = !!onStickyHeaderChange && stickyHeaderIndicesArr.length > 0 && stickyIndexDidChange;
+      return {
+        currentStickyIdx,
+        finishCalculateItemsInView: shouldNotifyStickyHeaderChange ? () => {
+          const item = data[nextActiveStickyIndex];
+          if (item !== void 0) {
+            onStickyHeaderChange == null ? void 0 : onStickyHeaderChange({ index: nextActiveStickyIndex, item });
+          }
+        } : void 0
+      };
+    };
+    let stickyState = dataChanged ? void 0 : resolveStickyState();
     let scrollBufferTop = drawDistance;
     let scrollBufferBottom = drawDistance;
     if (speed > 0 || speed === 0 && scroll < Math.max(50, drawDistance)) {
@@ -5355,7 +5539,7 @@ function calculateItemsInView(ctx, params = {}) {
               scrollBottom
             );
           }
-          finishCalculateItemsInView == null ? void 0 : finishCalculateItemsInView();
+          (_d = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _d.call(stickyState);
           return;
         }
       }
@@ -5364,7 +5548,7 @@ function calculateItemsInView(ctx, params = {}) {
     if (dataChanged) {
       resetLayoutCachesForDataChange(state);
     }
-    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_c = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _c : 0;
+    const startIndex = forceFullItemPositions || dataChanged ? 0 : (_e = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _e : 0;
     const optimizeForVisibleWindow = !forceFullItemPositions && !dataChanged && numColumns > 1 && minIndexSizeChanged !== void 0;
     updateItemPositions(ctx, dataChanged, {
       doMVCP,
@@ -5390,21 +5574,24 @@ function calculateItemsInView(ctx, params = {}) {
       }
     }
     const scrollBeforeMVCP = state.scroll;
-    const scrollAdjustPendingBeforeMVCP = (_d = peek$(ctx, "scrollAdjustPending")) != null ? _d : 0;
+    const scrollAdjustPendingBeforeMVCP = (_f = peek$(ctx, "scrollAdjustPending")) != null ? _f : 0;
     checkMVCP == null ? void 0 : checkMVCP();
-    const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_e = peek$(ctx, "scrollAdjustPending")) != null ? _e : 0) !== scrollAdjustPendingBeforeMVCP);
+    const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_g = peek$(ctx, "scrollAdjustPending")) != null ? _g : 0) !== scrollAdjustPendingBeforeMVCP);
     if (didMVCPAdjustScroll && initialScroll) {
       updateScroll2(state.scroll);
       updateScrollRange();
     }
+    if (dataChanged) {
+      stickyState = resolveStickyState();
+    }
     let startBuffered = null;
     let startBufferedId = null;
     let endBuffered = null;
-    let loopStart = (_f = suppressInitialScrollSideEffects ? bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.targetIndexSeed : void 0) != null ? _f : !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
+    let loopStart = (_h = suppressInitialScrollSideEffects ? bootstrapInitialScrollState == null ? void 0 : bootstrapInitialScrollState.targetIndexSeed : void 0) != null ? _h : !dataChanged && startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
     for (let i = loopStart; i >= 0; i--) {
-      const id = (_g = idCache[i]) != null ? _g : getId(state, i);
+      const id = (_i = idCache[i]) != null ? _i : getId(state, i);
       const top = positions[i];
-      const size = (_h = sizes.get(id)) != null ? _h : getItemSize(ctx, id, i, data[i]);
+      const size = (_j = sizes.get(id)) != null ? _j : getItemSize(ctx, id, i, data[i]);
       const bottom = top + size;
       if (bottom > scrollTopBuffered) {
         loopStart = i;
@@ -5439,8 +5626,8 @@ function calculateItemsInView(ctx, params = {}) {
     };
     const dataLength = data.length;
     for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = (_i = idCache[i]) != null ? _i : getId(state, i);
-      const size = (_j = sizes.get(id)) != null ? _j : getItemSize(ctx, id, i, data[i]);
+      const id = (_k = idCache[i]) != null ? _k : getId(state, i);
+      const size = (_l = sizes.get(id)) != null ? _l : getItemSize(ctx, id, i, data[i]);
       const top = positions[i];
       if (!foundEnd) {
         trackVisibleRange(visibleRange, i, top, size, scroll, scrollBottom);
@@ -5496,7 +5683,7 @@ function calculateItemsInView(ctx, params = {}) {
       const needNewContainers = [];
       const needNewContainersSet = /* @__PURE__ */ new Set();
       for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_k = idCache[i]) != null ? _k : getId(state, i);
+        const id = (_m = idCache[i]) != null ? _m : getId(state, i);
         if (!containerItemKeys.has(id)) {
           needNewContainersSet.add(i);
           needNewContainers.push(i);
@@ -5505,7 +5692,7 @@ function calculateItemsInView(ctx, params = {}) {
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_l = idCache[index]) != null ? _l : getId(state, index);
+          const id = (_n = idCache[index]) != null ? _n : getId(state, index);
           if (id && !containerItemKeys.has(id) && !needNewContainersSet.has(index)) {
             needNewContainersSet.add(index);
             needNewContainers.push(index);
@@ -5516,7 +5703,7 @@ function calculateItemsInView(ctx, params = {}) {
         handleStickyActivation(
           ctx,
           stickyHeaderIndicesArr,
-          currentStickyIdx,
+          (_o = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _o : -1,
           needNewContainers,
           needNewContainersSet,
           startBuffered,
@@ -5542,7 +5729,7 @@ function calculateItemsInView(ctx, params = {}) {
         for (const allocation of availableContainerAllocations) {
           const i = allocation.itemIndex;
           const containerIndex = allocation.containerIndex;
-          const id = (_m = idCache[i]) != null ? _m : getId(state, i);
+          const id = (_p = idCache[i]) != null ? _p : getId(state, i);
           const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
@@ -5553,7 +5740,7 @@ function calculateItemsInView(ctx, params = {}) {
             state.containerItemTypes.set(containerIndex, allocation.itemType);
           }
           containerItemKeys.set(id, containerIndex);
-          (_n = state.userScrollAnchorReset) == null ? void 0 : _n.keys.add(id);
+          (_q = state.userScrollAnchorReset) == null ? void 0 : _q.keys.add(id);
           const containerSticky = `containerSticky${containerIndex}`;
           const isSticky = stickyHeaderIndicesSet.has(i);
           const isAlwaysRender = alwaysRenderSet.has(i);
@@ -5584,14 +5771,12 @@ function calculateItemsInView(ctx, params = {}) {
       if (state.userScrollAnchorReset) {
         if (state.userScrollAnchorReset.keys.size === 0) {
           state.userScrollAnchorReset = void 0;
-        } else {
-          state.userScrollAnchorReset.batchSize = state.userScrollAnchorReset.keys.size;
         }
       }
       if (alwaysRenderArr.length > 0) {
         for (const index of alwaysRenderArr) {
           if (index < 0 || index >= dataLength) continue;
-          const id = (_o = idCache[index]) != null ? _o : getId(state, index);
+          const id = (_r = idCache[index]) != null ? _r : getId(state, index);
           const containerIndex = containerItemKeys.get(id);
           if (containerIndex !== void 0) {
             state.stickyContainerPool.add(containerIndex);
@@ -5605,7 +5790,7 @@ function calculateItemsInView(ctx, params = {}) {
         stickyHeaderIndicesArr,
         scroll,
         drawDistance,
-        currentStickyIdx,
+        (_s = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _s : -1,
         pendingRemoval,
         alwaysRenderSet
       );
@@ -5666,7 +5851,7 @@ function calculateItemsInView(ctx, params = {}) {
         );
       }
     }
-    finishCalculateItemsInView == null ? void 0 : finishCalculateItemsInView();
+    (_t = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _t.call(stickyState);
   });
 }
 
@@ -5749,8 +5934,9 @@ function doInitialAllocateContainers(ctx) {
   const state = ctx.state;
   const {
     scrollLength,
-    props: { data, drawDistance, getFixedItemSize, getItemType, numColumns, estimatedItemSize }
+    props: { data, getFixedItemSize, getItemType, numColumns, estimatedItemSize }
   } = state;
+  const drawDistance = getEffectiveDrawDistance(ctx);
   const hasContainers = peek$(ctx, "numContainers");
   if (scrollLength > 0 && data.length > 0 && !hasContainers) {
     let averageItemSize;
@@ -5761,12 +5947,12 @@ function doInitialAllocateContainers(ctx) {
         const item = data[i];
         if (item !== void 0) {
           const itemType = (_a3 = getItemType == null ? void 0 : getItemType(item, i)) != null ? _a3 : "";
-          totalSize += (_b = getFixedItemSize(item, i, itemType)) != null ? _b : estimatedItemSize;
+          totalSize += ((_b = getFixedItemSize(item, i, itemType)) != null ? _b : estimatedItemSize) + ctx.scrollAxisGap;
         }
       }
       averageItemSize = totalSize / num;
     } else {
-      averageItemSize = estimatedItemSize;
+      averageItemSize = estimatedItemSize + ctx.scrollAxisGap;
     }
     const numContainers = Math.max(
       1,
@@ -5825,7 +6011,7 @@ function handleLayout(ctx, layoutParam, setCanRender) {
   if (didChange) {
     state.scrollLength = scrollLength;
     state.otherAxisSize = otherAxisSize;
-    updateContentMetrics(ctx);
+    updateContentMetricsState(ctx);
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
     if (scrollLength > 0) {
@@ -6062,28 +6248,12 @@ function updateContentInsetEndAdjustment(ctx, previousContentInsetEndAdjustment)
 
 // src/core/updateItemSize.ts
 function runOrScheduleMVCPRecalculate(ctx) {
-  var _a3, _b;
+  var _a3;
   const state = ctx.state;
   if (state.userScrollAnchorReset !== void 0) {
-    const replacementBatchSize = (_a3 = state.userScrollAnchorReset.batchSize) != null ? _a3 : state.userScrollAnchorReset.keys.size;
-    const replacementMeasurementBatchThreshold = 3;
-    const shouldBatchReplacementMeasurements = replacementBatchSize > replacementMeasurementBatchThreshold;
-    if (shouldBatchReplacementMeasurements) {
-      if (state.queuedMVCPRecalculate === void 0) {
-        state.queuedMVCPRecalculate = requestAnimationFrame(() => {
-          var _a4;
-          state.queuedMVCPRecalculate = void 0;
-          calculateItemsInView(ctx);
-          if (((_a4 = state.userScrollAnchorReset) == null ? void 0 : _a4.keys.size) === 0) {
-            state.userScrollAnchorReset = void 0;
-          }
-        });
-      }
-    } else {
-      calculateItemsInView(ctx);
-      if (((_b = state.userScrollAnchorReset) == null ? void 0 : _b.keys.size) === 0) {
-        state.userScrollAnchorReset = void 0;
-      }
+    calculateItemsInView(ctx);
+    if (((_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys.size) === 0) {
+      state.userScrollAnchorReset = void 0;
     }
   } else {
     if (!state.mvcpAnchorLock) {
@@ -6543,6 +6713,9 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
       scrollTo(ctx, params);
       return true;
     }),
+    setItemSize: (itemKey, size) => {
+      updateItemSize(ctx, itemKey, size);
+    },
     setScrollProcessingEnabled: (enabled) => {
       state.scrollProcessingEnabled = enabled;
     },
@@ -6640,12 +6813,13 @@ function getRenderedItem(ctx, key) {
 
 // src/utils/normalizeMaintainScrollAtEnd.ts
 function normalizeMaintainScrollAtEndOn(on, hasExplicitOn) {
-  var _a3, _b, _c;
+  var _a3, _b, _c, _d;
   return {
     animated: false,
     onDataChange: hasExplicitOn ? (_a3 = on == null ? void 0 : on.dataChange) != null ? _a3 : false : true,
-    onItemLayout: hasExplicitOn ? (_b = on == null ? void 0 : on.itemLayout) != null ? _b : false : true,
-    onLayout: hasExplicitOn ? (_c = on == null ? void 0 : on.layout) != null ? _c : false : true
+    onFooterLayout: hasExplicitOn ? (_b = on == null ? void 0 : on.footerLayout) != null ? _b : false : true,
+    onItemLayout: hasExplicitOn ? (_c = on == null ? void 0 : on.itemLayout) != null ? _c : false : true,
+    onLayout: hasExplicitOn ? (_d = on == null ? void 0 : on.layout) != null ? _d : false : true
   };
 }
 function normalizeMaintainScrollAtEnd(value) {
@@ -6767,7 +6941,7 @@ var LegendList = typedMemo(
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a3, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
   const noopOnScroll = useCallback((_event) => {
   }, []);
   if (props.recycleItems === void 0) {
@@ -6798,6 +6972,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
+    experimental_adaptiveRender,
     itemsAreEqual,
     keyExtractor: keyExtractorProp,
     ListEmptyComponent,
@@ -6894,6 +7069,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const [, scheduleImperativeScrollCommit] = React3.useReducer((value) => value + 1, 0);
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
+  const scrollAxisGap = horizontal ? (_f = (_d = ctx.columnWrapperStyle) == null ? void 0 : _d.columnGap) != null ? _f : (_e = ctx.columnWrapperStyle) == null ? void 0 : _e.gap : (_i = (_g = ctx.columnWrapperStyle) == null ? void 0 : _g.rowGap) != null ? _i : (_h = ctx.columnWrapperStyle) == null ? void 0 : _h.gap;
+  const nextScrollAxisGap = typeof scrollAxisGap === "number" && Number.isFinite(scrollAxisGap) ? scrollAxisGap : 0;
   const refScroller = useRef(null);
   const combinedRef = useCombinedRef(refScroller, refScrollView);
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : ((_item, index) => index.toString());
@@ -6907,8 +7084,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,
-    (_d = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _d.join(","),
-    (_e = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _e.join(","),
+    (_j = alwaysRender == null ? void 0 : alwaysRender.indices) == null ? void 0 : _j.join(","),
+    (_k = alwaysRender == null ? void 0 : alwaysRender.keys) == null ? void 0 : _k.join(","),
     dataProp,
     dataVersion,
     keyExtractor
@@ -6936,6 +7113,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         endNoBuffer: -1,
         endReachedSnapshot: void 0,
         firstFullyOnScreenIndex: -1,
+        hasHadNonEmptyData: dataProp.length > 0,
         idCache: [],
         idsInView: [],
         indexByKey: /* @__PURE__ */ new Map(),
@@ -6978,6 +7156,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         startReachedSnapshotDataChangeEpoch: void 0,
         stickyContainerPool: /* @__PURE__ */ new Set(),
         stickyContainers: /* @__PURE__ */ new Map(),
+        timeoutAdaptiveRender: void 0,
         timeouts: /* @__PURE__ */ new Set(),
         totalSize: 0,
         viewabilityConfigCallbackPairs: void 0
@@ -6996,11 +7175,13 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const state = refState.current;
   const isFirstLocal = state.isFirst;
   const previousNumColumnsProp = state.props.numColumns;
-  state.didColumnsChange = numColumnsProp !== previousNumColumnsProp;
+  const didScrollAxisGapChange = !isFirstLocal && ctx.scrollAxisGap !== nextScrollAxisGap;
+  ctx.scrollAxisGap = nextScrollAxisGap;
+  state.didColumnsChange = numColumnsProp !== previousNumColumnsProp || didScrollAxisGapChange;
   const didDataReferenceChangeLocal = state.props.data !== dataProp;
   const didDataVersionChangeLocal = state.props.dataVersion !== dataVersion;
   const didDataChangeLocal = didDataVersionChangeLocal || didDataReferenceChangeLocal && checkStructuralDataChange(state, dataProp, state.props.data);
-  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_f = state.initialScroll) == null ? void 0 : _f.viewPosition) === 1 && state.props.data.length > 0) {
+  if (didDataChangeLocal && !initialScrollAtEnd && state.didFinishInitialScroll && ((_l = state.initialScroll) == null ? void 0 : _l.viewPosition) === 1 && state.props.data.length > 0) {
     clearPreservedInitialScrollTarget(state);
   }
   if (didDataChangeLocal) {
@@ -7012,8 +7193,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const throttledOnScroll = useThrottledOnScroll(onScrollProp != null ? onScrollProp : noopOnScroll, scrollEventThrottle != null ? scrollEventThrottle : 0);
   const throttleScrollFn = scrollEventThrottle && onScrollProp ? throttledOnScroll : onScrollProp;
   const anchoredEndSpaceResolved = anchoredEndSpace ? { ...anchoredEndSpace, includeInEndInset: true } : anchoredEndSpace;
-  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_g = state.props.anchoredEndSpace) == null ? void 0 : _g.anchorIndex) !== (anchoredEndSpaceResolved == null ? void 0 : anchoredEndSpaceResolved.anchorIndex);
+  const didAnchoredEndSpaceAnchorIndexChange = !isFirstLocal && !didDataChangeLocal && ((_m = state.props.anchoredEndSpace) == null ? void 0 : _m.anchorIndex) !== (anchoredEndSpaceResolved == null ? void 0 : anchoredEndSpaceResolved.anchorIndex);
   state.props = {
+    adaptiveRender: experimental_adaptiveRender,
     alignItemsAtEnd,
     alignItemsAtEndPaddingEnabled: useAlignItemsAtEndPadding,
     alwaysRender,
@@ -7021,6 +7203,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     alwaysRenderIndicesSet: alwaysRenderIndices.set,
     anchoredEndSpace: anchoredEndSpaceResolved,
     animatedProps: animatedPropsInternal,
+    contentContainerAlignItems: contentContainerStyle.alignItems,
     contentInset,
     contentInsetEndAdjustment: contentInsetEndAdjustmentResolved,
     data: dataProp,
@@ -7073,7 +7256,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const prevPaddingTop = peek$(ctx, "stylePaddingTop");
     setPaddingTop(ctx, { stylePaddingTop: stylePaddingTopState });
     refState.current.props.stylePaddingBottom = stylePaddingBottomState;
-    updateContentMetrics(ctx);
+    updateContentMetricsState(ctx);
     let paddingDiff = stylePaddingTopState - prevPaddingTop;
     if (shouldAdjustPadding && maintainVisibleContentPositionConfig.size && paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") ;
   };
@@ -7105,7 +7288,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
   }, []);
-  if (isFirstLocal || didDataChangeLocal || numColumnsProp !== peek$(ctx, "numColumns")) {
+  if (isFirstLocal || didDataChangeLocal || state.didColumnsChange) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirstLocal && didDataChangeLocal) {
       refState.current.sizes.clear();
@@ -7122,6 +7305,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       dataLength: dataProp.length,
       didDataChange: didDataChangeLocal,
       initialScrollAtEnd,
+      latestInitialScroll: initialScrollProp,
+      latestInitialScrollSessionKind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
       stylePaddingBottom: stylePaddingBottomState,
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
@@ -7196,6 +7381,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       dataVersion,
       memoizedLastItemKeys.join(","),
       numColumnsProp,
+      nextScrollAxisGap,
       stylePaddingBottomState,
       stylePaddingTopState,
       useAlignItemsAtEndPadding
@@ -7218,7 +7404,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.didColumnsChange = false;
     state.didDataChange = false;
     state.isFirst = false;
-  }, [dataProp, dataVersion, numColumnsProp]);
+  }, [dataProp, dataVersion, numColumnsProp, nextScrollAxisGap]);
   useLayoutEffect(() => {
     var _a4;
     set$(ctx, "extraData", extraData);
@@ -7266,6 +7452,14 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   useInit(() => {
   });
   useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, scheduleImperativeScrollCommit), []);
+  useEffect(() => {
+    return () => {
+      for (const timeout of state.timeouts) {
+        clearTimeout(timeout);
+      }
+      state.timeouts.clear();
+    };
+  }, [state]);
   useLayoutEffect(() => {
     var _a4;
     (_a4 = state.runPendingScrollToEnd) == null ? void 0 : _a4.call(state);
@@ -7313,7 +7507,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React3.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_h = refreshControlElement.props.progressViewOffset) != null ? _h : 0) + stylePaddingTopState
+        progressViewOffset: ((_n = refreshControlElement.props.progressViewOffset) != null ? _n : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React3.createElement(
         RefreshControl,
         {
@@ -7324,7 +7518,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ),
       refScrollView: combinedRef,
       renderScrollComponent,
-      scrollAdjustHandler: (_i = refState.current) == null ? void 0 : _i.scrollAdjustHandler,
+      scrollAdjustHandler: (_o = refState.current) == null ? void 0 : _o.scrollAdjustHandler,
       scrollEventThrottle: 0,
       snapToIndices,
       stickyHeaderIndices,
@@ -7380,4 +7574,4 @@ var internal = {
 var LegendList3 = LegendListRuntime;
 var internal2 = internal;
 
-export { LegendList3 as LegendList, internal2 as internal, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };
+export { LegendList3 as LegendList, internal2 as internal, useAdaptiveRender, useAdaptiveRenderChange, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };