@legendapp/list 3.0.5 → 3.1.0

package/react-native.js

@@ -152,8 +152,10 @@ 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],
       ["stylePaddingTop", 0],
       ["headerSize", 0],
       ["numContainers", 0],
@@ -163,6 +165,7 @@ function StateProvider({ children }) {
       ["isNearEnd", false],
       ["isNearStart", false],
       ["isWithinMaintainScrollAtEndThreshold", false],
+      ["adaptiveRender", "light"],
       ["totalSize", 0],
       ["scrollAdjustPending", 0]
     ]),
@@ -296,15 +299,16 @@ function getContentInsetEnd(ctx, contentInsetEndAdjustmentOverride) {
 
 // src/state/getContentSize.ts
 function getContentSize(ctx) {
-  var _a3;
+  var _a3, _b;
   const { values, state } = ctx;
   const stylePaddingTop = values.get("stylePaddingTop") || 0;
   const stylePaddingBottom = state.props.stylePaddingBottom || 0;
+  const alignItemsAtEndPadding = values.get("alignItemsAtEndPadding") || 0;
   const headerSize = values.get("headerSize") || 0;
   const footerSize = values.get("footerSize") || 0;
   const contentInsetBottom = getContentInsetEnd(ctx);
-  const totalSize = (_a3 = state.pendingTotalSize) != null ? _a3 : values.get("totalSize");
-  return headerSize + footerSize + totalSize + stylePaddingTop + stylePaddingBottom + (contentInsetBottom || 0);
+  const totalSize = (_b = (_a3 = state.pendingTotalSize) != null ? _a3 : state.totalSize) != null ? _b : values.get("totalSize");
+  return headerSize + footerSize + totalSize + stylePaddingTop + alignItemsAtEndPadding + stylePaddingBottom + (contentInsetBottom || 0);
 }
 
 // src/components/DebugView.tsx
@@ -479,8 +483,16 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
   ...rest
 }) {
   const ctx = useStateContext();
-  const [position = POSITION_OUT_OF_VIEW, headerSize = 0, stylePaddingTop = 0, itemKey, _totalSize = 0] = useArr$([
+  const [
+    position = POSITION_OUT_OF_VIEW,
+    alignItemsAtEndPadding = 0,
+    headerSize = 0,
+    stylePaddingTop = 0,
+    itemKey,
+    _totalSize = 0
+  ] = useArr$([
     `containerPosition${id}`,
+    "alignItemsAtEndPadding",
     "headerSize",
     "stylePaddingTop",
     `containerItemKey${id}`,
@@ -494,7 +506,7 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
     var _a3;
     if (animatedScrollY) {
       const stickyConfigOffset = (_a3 = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a3 : 0;
-      const stickyStart = position + headerSize + stylePaddingTop - stickyConfigOffset;
+      const stickyStart = position + headerSize + stylePaddingTop + alignItemsAtEndPadding - stickyConfigOffset;
       let nextStickyPosition;
       if (pushLimit !== void 0) {
         if (pushLimit <= position) {
@@ -517,7 +529,15 @@ var PositionViewSticky = typedMemo(function PositionViewSticky2({
       }
       return horizontal ? [{ translateX: nextStickyPosition }] : [{ translateY: nextStickyPosition }];
     }
-  }, [animatedScrollY, headerSize, position, pushLimit, stylePaddingTop, stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset]);
+  }, [
+    alignItemsAtEndPadding,
+    animatedScrollY,
+    headerSize,
+    position,
+    pushLimit,
+    stylePaddingTop,
+    stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset
+  ]);
   const viewStyle = React2__namespace.useMemo(() => [style, { zIndex: index + 1e3 }, { transform }], [style, transform]);
   const renderStickyHeaderBackdrop = React2__namespace.useMemo(() => {
     if (!(stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent)) {
@@ -591,6 +611,24 @@ var ContextContainer = React2.createContext(null);
 function useContextContainer() {
   return React2.useContext(ContextContainer);
 }
+function useAdaptiveRender() {
+  const [mode] = useArr$(["adaptiveRender"]);
+  return mode;
+}
+function useAdaptiveRenderChange(callback) {
+  const ctx = useStateContext();
+  const callbackRef = React2.useRef(callback);
+  callbackRef.current = callback;
+  React2.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();
@@ -807,6 +845,7 @@ function isInMVCPActiveMode(state) {
 // src/components/Container.tsx
 function getContainerPositionStyle({
   columnWrapperStyle,
+  contentContainerAlignItems,
   horizontal,
   hasItemSeparator,
   isHorizontalRTLList,
@@ -832,13 +871,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,
@@ -892,6 +932,7 @@ var Container = typedMemo(function Container2({
   const style = React2.useMemo(
     () => getContainerPositionStyle({
       columnWrapperStyle,
+      contentContainerAlignItems: ctx.state.props.contentContainerAlignItems,
       hasItemSeparator: !!ItemSeparatorComponent,
       horizontal,
       isHorizontalRTLList,
@@ -905,6 +946,7 @@ var Container = typedMemo(function Container2({
       otherAxisPos,
       otherAxisSize,
       columnWrapperStyle,
+      ctx.state.props.contentContainerAlignItems,
       numColumns,
       ItemSeparatorComponent
     ]
@@ -1174,245 +1216,267 @@ function WebAnchoredEndSpace({ horizontal }) {
   const style = horizontal ? { height: "100%", width: anchoredEndSpaceSize || 0 } : { height: anchoredEndSpaceSize || 0 };
   return /* @__PURE__ */ React2__namespace.createElement("div", { style }, null);
 }
-function useLatestRef(value) {
-  const ref = React2__namespace.useRef(value);
-  ref.current = value;
-  return ref;
-}
 
-// src/hooks/useStableRenderComponent.tsx
-function useStableRenderComponent(renderComponent, mapProps) {
-  const renderComponentRef = useLatestRef(renderComponent);
-  const mapPropsRef = useLatestRef(mapProps);
-  return React2__namespace.useMemo(
-    () => React2__namespace.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]
-  );
+// src/core/calculateOffsetForIndex.ts
+function calculateOffsetForIndex(ctx, index) {
+  const state = ctx.state;
+  return index !== void 0 ? state.positions[index] || 0 : 0;
 }
-var LayoutView = ({ onLayoutChange, refView, ...rest }) => {
-  const localRef = React2.useRef(null);
-  const ref = refView != null ? refView : localRef;
-  const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
-  return /* @__PURE__ */ React2__namespace.createElement(ReactNative.View, { ...rest, onLayout, ref });
-};
 
-// 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 [otherAxisSize = 0] = useArr$(["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;
-  React2.useLayoutEffect(() => {
-    if (!ListHeaderComponent) {
-      set$(ctx, "headerSize", 0);
-    }
-    if (!ListFooterComponent) {
-      set$(ctx, "footerSize", 0);
-    }
-  }, [ListHeaderComponent, ListFooterComponent, ctx]);
-  const onLayoutHeader = React2.useCallback(
-    (rect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      set$(ctx, "headerSize", size);
-    },
-    [ctx, horizontal]
-  );
-  const onLayoutFooterInternal = React2.useCallback(
-    (rect, fromLayoutEffect) => {
-      const size = rect[horizontal ? "width" : "height"];
-      set$(ctx, "footerSize", size);
-      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
-    },
-    [ctx, horizontal, onLayoutFooter]
-  );
-  return /* @__PURE__ */ React2__namespace.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__ */ React2__namespace.createElement(ScrollAdjust, null),
-    ListHeaderComponent && /* @__PURE__ */ React2__namespace.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
-    ListEmptyComponent && getComponent(ListEmptyComponent),
-    canRender && !ListEmptyComponent && /* @__PURE__ */ React2__namespace.createElement(
-      Containers,
-      {
-        getRenderedItem: getRenderedItem2,
-        horizontal,
-        ItemSeparatorComponent,
-        recycleItems,
-        stickyHeaderConfig,
-        updateItemSize: updateItemSize2
-      }
-    ),
-    ListFooterComponent && /* @__PURE__ */ React2__namespace.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
-    Platform.OS === "web" && /* @__PURE__ */ React2__namespace.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;
-  React2.useEffect(() => {
-    if (useWindowScroll && renderScrollComponent) {
-      warnDevOnce(
-        "useWindowScrollRenderScrollComponent",
-        "useWindowScroll is not supported when renderScrollComponent is provided."
-      );
-    }
-  }, [renderScrollComponent, useWindowScroll]);
-  React2.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]);
-  React2.useEffect(() => {
-    const state = ctx.state;
-    const dataLength = state.props.data.length;
-    const useWindowScrollResolved = state.props.useWindowScroll;
-    if (Platform.OS !== "web" || 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) {
+// src/core/getTopOffsetAdjustment.ts
+function getTopOffsetAdjustment(ctx) {
+  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "alignItemsAtEndPadding") || 0) + (peek$(ctx, "headerSize") || 0);
 }
-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/utils/getId.ts
+function getId(state, index) {
+  const { data, keyExtractor } = state.props;
+  if (!data) {
+    return "";
   }
+  const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
+  const id = ret;
+  state.idCache[index] = id;
+  return id;
 }
 
-// src/core/initialScrollSession.ts
-var INITIAL_SCROLL_MIN_TARGET_OFFSET = 1;
-function hasInitialScrollSessionCompletion(completion) {
-  return !!((completion == null ? void 0 : completion.didDispatchNativeScroll) || (completion == null ? void 0 : completion.didRetrySilentInitialScroll) || (completion == null ? void 0 : completion.watchdog));
+// src/core/updateContentMetricsState.ts
+function getRawContentLength(ctx) {
+  var _a3, _b, _c;
+  const { state, values } = ctx;
+  return (values.get("headerSize") || 0) + (values.get("footerSize") || 0) + ((_c = (_b = (_a3 = state.pendingTotalSize) != null ? _a3 : state.totalSize) != null ? _b : values.get("totalSize")) != null ? _c : 0) + (state.props.stylePaddingTop || 0) + (state.props.stylePaddingBottom || 0);
 }
-function clearInitialScrollSession(state) {
-  state.initialScrollSession = void 0;
-  return void 0;
+function getAlignItemsAtEndPadding(ctx) {
+  const { state } = ctx;
+  const shouldPad = !!state.props.alignItemsAtEndPaddingEnabled && !state.props.horizontal && state.props.data.length > 0 && state.scrollLength > 0;
+  return shouldPad ? Math.max(0, state.scrollLength - getRawContentLength(ctx) - getContentInsetEnd(ctx)) : 0;
 }
-function createInitialScrollSession(options) {
-  const { bootstrap, completion, kind, previousDataLength } = options;
-  return kind === "offset" ? {
-    completion,
-    kind,
-    previousDataLength
-  } : {
-    bootstrap,
+function updateContentMetricsState(ctx) {
+  const previousPadding = peek$(ctx, "alignItemsAtEndPadding") || 0;
+  const nextPadding = getAlignItemsAtEndPadding(ctx);
+  if (previousPadding !== nextPadding) {
+    set$(ctx, "alignItemsAtEndPadding", nextPadding);
+  }
+}
+
+// src/core/addTotalSize.ts
+function addTotalSize(ctx, key, add, notifyTotalSize = true) {
+  const state = ctx.state;
+  const prevTotalSize = state.totalSize;
+  let totalSize = state.totalSize;
+  if (key === null) {
+    totalSize = add;
+    if (state.timeoutSetPaddingTop) {
+      clearTimeout(state.timeoutSetPaddingTop);
+      state.timeoutSetPaddingTop = void 0;
+    }
+  } else {
+    totalSize += add;
+  }
+  if (prevTotalSize !== totalSize) {
+    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
+      state.pendingTotalSize = totalSize;
+    } else {
+      state.pendingTotalSize = void 0;
+      state.totalSize = totalSize;
+      if (notifyTotalSize) {
+        set$(ctx, "totalSize", totalSize);
+      }
+      updateContentMetricsState(ctx);
+    }
+  } else if (notifyTotalSize && ctx.values.get("totalSize") !== totalSize) {
+    set$(ctx, "totalSize", totalSize);
+  }
+}
+
+// src/core/setSize.ts
+function setSize(ctx, itemKey, size, notifyTotalSize = true) {
+  const state = ctx.state;
+  const { sizes } = state;
+  const previousSize = sizes.get(itemKey);
+  const diff = previousSize !== void 0 ? size - previousSize : size;
+  if (diff !== 0) {
+    addTotalSize(ctx, itemKey, diff, notifyTotalSize);
+  }
+  sizes.set(itemKey, size);
+}
+
+// src/utils/getItemSize.ts
+function getKnownOrFixedSize(ctx, key, index, data, resolved) {
+  var _a3, _b;
+  const state = ctx.state;
+  const { getFixedItemSize, getItemType } = state.props;
+  let size = key ? state.sizesKnown.get(key) : void 0;
+  if (size === void 0 && key && getFixedItemSize) {
+    const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+    const fixedSize = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
+    if (fixedSize !== void 0) {
+      size = fixedSize + ctx.scrollAxisGap;
+      state.sizesKnown.set(key, size);
+    }
+  }
+  return size;
+}
+function getKnownOrFixedItemSize(ctx, index) {
+  const key = getId(ctx.state, index);
+  return getKnownOrFixedSize(ctx, key, index, ctx.state.props.data[index]);
+}
+function areKnownOrFixedItemSizesAvailable(ctx, startIndex, endIndex) {
+  for (let index = startIndex; index <= endIndex; index++) {
+    if (getKnownOrFixedItemSize(ctx, index) === void 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize, notifyTotalSize, resolved) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
+  const {
+    sizes,
+    averageSizes,
+    props: { estimatedItemSize, getItemType },
+    scrollingTo
+  } = state;
+  const sizeKnown = state.sizesKnown.get(key);
+  if (sizeKnown !== void 0) {
+    return sizeKnown;
+  }
+  let size;
+  const renderedSize = sizes.get(key);
+  if (preferCachedSize) {
+    if (renderedSize !== void 0) {
+      return renderedSize;
+    }
+  }
+  size = getKnownOrFixedSize(ctx, key, index, data, resolved);
+  if (size !== void 0) {
+    setSize(ctx, key, size, notifyTotalSize);
+    return size;
+  }
+  const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
+  if (useAverageSize && !scrollingTo) {
+    const averageSizeForType = (_c = averageSizes[itemType]) == null ? void 0 : _c.avg;
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
+    }
+  }
+  if (size === void 0 && renderedSize !== void 0) {
+    return renderedSize;
+  }
+  if (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/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" || state.lastLayout)) {
+    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/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
@@ -1680,6 +1744,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,
@@ -1699,6 +1823,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 });
     }
@@ -1773,204 +1904,9 @@ function finishInitialScroll(ctx, options) {
   complete();
 }
 
-// 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
-function getTopOffsetAdjustment(ctx) {
-  return (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
-}
-
-// src/utils/getId.ts
-function getId(state, index) {
-  const { data, keyExtractor } = state.props;
-  if (!data) {
-    return "";
-  }
-  const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
-  const id = ret;
-  state.idCache[index] = id;
-  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) {
-    if (!IsNewArchitecture && state.initialScroll && totalSize < prevTotalSize) {
-      state.pendingTotalSize = totalSize;
-    } else {
-      state.pendingTotalSize = void 0;
-      state.totalSize = totalSize;
-      if (notifyTotalSize) {
-        set$(ctx, "totalSize", totalSize);
-      }
-    }
-  } else if (notifyTotalSize && ctx.values.get("totalSize") !== totalSize) {
-    set$(ctx, "totalSize", totalSize);
-  }
-}
-
-// src/core/setSize.ts
-function setSize(ctx, itemKey, size, notifyTotalSize = true) {
-  const state = ctx.state;
-  const { sizes } = state;
-  const previousSize = sizes.get(itemKey);
-  const diff = previousSize !== void 0 ? size - previousSize : size;
-  if (diff !== 0) {
-    addTotalSize(ctx, itemKey, diff, notifyTotalSize);
-  }
-  sizes.set(itemKey, size);
-}
-
-// src/utils/getItemSize.ts
-function getKnownOrFixedSize(ctx, key, index, data, resolved) {
-  var _a3, _b;
-  const state = ctx.state;
-  const { getFixedItemSize, getItemType } = state.props;
-  let size = key ? state.sizesKnown.get(key) : void 0;
-  if (size === void 0 && key && getFixedItemSize) {
-    const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-    size = (resolved == null ? void 0 : resolved.didResolveFixedItemSize) ? resolved.fixedItemSize : getFixedItemSize(data, index, itemType);
-    if (size !== void 0) {
-      state.sizesKnown.set(key, size);
-    }
-  }
-  return size;
-}
-function getKnownOrFixedItemSize(ctx, index) {
-  const key = getId(ctx.state, index);
-  return getKnownOrFixedSize(ctx, key, index, ctx.state.props.data[index]);
-}
-function areKnownOrFixedItemSizesAvailable(ctx, startIndex, endIndex) {
-  for (let index = startIndex; index <= endIndex; index++) {
-    if (getKnownOrFixedItemSize(ctx, index) === void 0) {
-      return false;
-    }
-  }
-  return true;
-}
-function getItemSize(ctx, key, index, data, useAverageSize, preferCachedSize, notifyTotalSize, resolved) {
-  var _a3, _b, _c, _d;
-  const state = ctx.state;
-  const {
-    sizes,
-    averageSizes,
-    props: { estimatedItemSize, getItemType },
-    scrollingTo
-  } = state;
-  const sizeKnown = state.sizesKnown.get(key);
-  if (sizeKnown !== void 0) {
-    return sizeKnown;
-  }
-  let size;
-  const renderedSize = sizes.get(key);
-  if (preferCachedSize) {
-    if (renderedSize !== void 0) {
-      return renderedSize;
-    }
-  }
-  size = getKnownOrFixedSize(ctx, key, index, data, resolved);
-  if (size !== void 0) {
-    setSize(ctx, key, size, notifyTotalSize);
-    return size;
-  }
-  const itemType = (_b = resolved == null ? void 0 : resolved.itemType) != null ? _b : getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
-  if (useAverageSize && !scrollingTo) {
-    const averageSizeForType = (_c = averageSizes[itemType]) == null ? void 0 : _c.avg;
-    if (averageSizeForType !== void 0) {
-      size = roundSize(averageSizeForType);
-    }
-  }
-  if (size === void 0 && renderedSize !== void 0) {
-    return renderedSize;
-  }
-  if (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" || state.lastLayout)) {
-    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;
+// 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;
@@ -2133,65 +2069,374 @@ function checkFinishedScrollFallback(ctx) {
           state,
           isStillScrollingTo
         );
-        const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
-        const canFinishAfterSilentNativeDispatch = Platform.OS === "android" && silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
-        const shouldRetrySilentInitialNativeScroll = Platform.OS === "android" && canFinishAfterSilentNativeDispatch && !initialScrollCompletion.didRetrySilentInitialScroll(state);
-        const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
-        const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
-        const shouldRetryUnalignedEndScroll = Platform.OS === "ios" && !isStillScrollingTo.isInitialScroll && isEndAlignedLastItemTarget(ctx, isStillScrollingTo) && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
-        if (shouldRetrySilentInitialNativeScroll) {
-          const targetOffset = (_b = (_a3 = getInitialScrollWatchdogTargetOffset(state)) != null ? _a3 : isStillScrollingTo.targetOffset) != null ? _b : 0;
-          const jiggleOffset = targetOffset >= SILENT_INITIAL_SCROLL_TARGET_EPSILON ? targetOffset - SILENT_INITIAL_SCROLL_TARGET_EPSILON : targetOffset + SILENT_INITIAL_SCROLL_TARGET_EPSILON;
-          initialScrollCompletion.markSilentInitialScrollRetry(state);
-          scrollToFallbackOffset(ctx, jiggleOffset);
-          requestAnimationFrame(() => {
-            scrollToFallbackOffset(ctx, targetOffset);
-          });
-          scheduleFallbackCheck(SILENT_INITIAL_SCROLL_RETRY_DELAY_MS);
-        } else if (shouldRetryUnalignedEndScroll) {
-          scrollToFallbackOffset(ctx, completionState.clampedTargetOffset);
-          scheduleFallbackCheck(100);
-        } else if (shouldFinishZeroTarget || shouldFinishAfterObservedScroll || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
-          finishScrollTo(ctx);
-        } else if ((isNativeInitialPending || shouldRetryUnalignedInitialScroll) && numChecks <= maxChecks) {
-          const targetOffset = (_d = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : isStillScrollingTo.targetOffset) != null ? _d : state.scrollPending;
-          scrollToFallbackOffset(ctx, targetOffset);
-          scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
-        } else {
-          scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
-        }
+        const completionState = getResolvedScrollCompletionState(ctx, isStillScrollingTo);
+        const canFinishAfterSilentNativeDispatch = Platform.OS === "android" && silentInitialDispatch && completionState.isAtResolvedTarget && numChecks >= 1;
+        const shouldRetrySilentInitialNativeScroll = Platform.OS === "android" && canFinishAfterSilentNativeDispatch && !initialScrollCompletion.didRetrySilentInitialScroll(state);
+        const shouldFinishAfterObservedScroll = state.hasScrolled && (!isStillScrollingTo.isInitialScroll || completionState.isAtResolvedTarget);
+        const shouldRetryUnalignedInitialScroll = isStillScrollingTo.isInitialScroll && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
+        const shouldRetryUnalignedEndScroll = Platform.OS === "ios" && !isStillScrollingTo.isInitialScroll && isEndAlignedLastItemTarget(ctx, isStillScrollingTo) && !completionState.isAtResolvedTarget && numChecks <= maxChecks;
+        if (shouldRetrySilentInitialNativeScroll) {
+          const targetOffset = (_b = (_a3 = getInitialScrollWatchdogTargetOffset(state)) != null ? _a3 : isStillScrollingTo.targetOffset) != null ? _b : 0;
+          const jiggleOffset = targetOffset >= SILENT_INITIAL_SCROLL_TARGET_EPSILON ? targetOffset - SILENT_INITIAL_SCROLL_TARGET_EPSILON : targetOffset + SILENT_INITIAL_SCROLL_TARGET_EPSILON;
+          initialScrollCompletion.markSilentInitialScrollRetry(state);
+          scrollToFallbackOffset(ctx, jiggleOffset);
+          requestAnimationFrame(() => {
+            scrollToFallbackOffset(ctx, targetOffset);
+          });
+          scheduleFallbackCheck(SILENT_INITIAL_SCROLL_RETRY_DELAY_MS);
+        } else if (shouldRetryUnalignedEndScroll) {
+          scrollToFallbackOffset(ctx, completionState.clampedTargetOffset);
+          scheduleFallbackCheck(100);
+        } else if (shouldFinishZeroTarget || shouldFinishAfterObservedScroll || canFinishInitialScrollWithoutNativeProgress || canFinishAfterSilentNativeDispatch || numChecks > maxChecks) {
+          finishScrollTo(ctx);
+        } else if ((isNativeInitialPending || shouldRetryUnalignedInitialScroll) && numChecks <= maxChecks) {
+          const targetOffset = (_d = (_c = getInitialScrollWatchdogTargetOffset(state)) != null ? _c : isStillScrollingTo.targetOffset) != null ? _d : state.scrollPending;
+          scrollToFallbackOffset(ctx, targetOffset);
+          scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+        } else {
+          scheduleFallbackCheck(silentInitialDispatch ? SILENT_INITIAL_SCROLL_RETRY_DELAY_MS : 100);
+        }
+      }
+    };
+    checkHasScrolled();
+  }, initialDelay);
+}
+
+// src/core/doScrollTo.native.ts
+function doScrollTo(ctx, params) {
+  const state = ctx.state;
+  const { animated, horizontal, isInitialScroll, offset } = params;
+  const isAnimated = !!animated;
+  const { refScroller } = state;
+  const scroller = refScroller.current;
+  if (!scroller) {
+    return;
+  }
+  const isHorizontal = !!horizontal;
+  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
+  const nativeOffset = toNativeHorizontalOffset(state, offset, contentSize);
+  scroller.scrollTo({
+    animated: isAnimated,
+    x: isHorizontal ? nativeOffset : 0,
+    y: isHorizontal ? 0 : offset
+  });
+  if (isInitialScroll) {
+    initialScrollCompletion.markInitialScrollNativeDispatch(state);
+  }
+  if (!isAnimated) {
+    state.scroll = offset;
+    checkFinishedScrollFallback(ctx);
+  }
+}
+
+// src/utils/requestAdjust.ts
+function requestAdjust(ctx, positionDiff, dataChanged) {
+  const state = ctx.state;
+  if (Math.abs(positionDiff) > 0.1) {
+    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
+    const doit = () => {
+      if (needsScrollWorkaround) {
+        doScrollTo(ctx, { horizontal: state.props.horizontal, offset: state.scroll });
+      } else {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+        if (state.adjustingFromInitialMount) {
+          state.adjustingFromInitialMount--;
+        }
+      }
+    };
+    state.scroll += positionDiff;
+    state.scrollForNextCalculateItemsInView = void 0;
+    const readyToRender = peek$(ctx, "readyToRender");
+    if (readyToRender) {
+      doit();
+      if (Platform.OS !== "web") {
+        const threshold = state.scroll - positionDiff / 2;
+        if (!state.ignoreScrollFromMVCP) {
+          state.ignoreScrollFromMVCP = {};
+        }
+        if (positionDiff > 0) {
+          state.ignoreScrollFromMVCP.lt = threshold;
+        } else {
+          state.ignoreScrollFromMVCP.gt = threshold;
+        }
+        if (state.ignoreScrollFromMVCPTimeout) {
+          clearTimeout(state.ignoreScrollFromMVCPTimeout);
+        }
+        const delay = needsScrollWorkaround ? 250 : 100;
+        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
+          var _a3;
+          state.ignoreScrollFromMVCP = void 0;
+          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
+          if (shouldForceUpdate) {
+            state.ignoreScrollFromMVCPIgnored = false;
+            state.scrollPending = state.scroll;
+            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
+          }
+        }, delay);
+      }
+    } else {
+      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
+      requestAnimationFrame(doit);
+    }
+  }
+}
+
+// src/core/updateContentMetrics.ts
+var SCROLL_ADJUST_EPSILON = 0.1;
+function setContentLengthSignal(ctx, signalName, size) {
+  if (peek$(ctx, signalName) !== size) {
+    set$(ctx, signalName, size);
+    updateContentMetricsState(ctx);
+  }
+}
+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 Platform.OS === "web" && 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) {
+  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 useLatestRef(value) {
+  const ref = React2__namespace.useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+// src/hooks/useStableRenderComponent.tsx
+function useStableRenderComponent(renderComponent, mapProps) {
+  const renderComponentRef = useLatestRef(renderComponent);
+  const mapPropsRef = useLatestRef(mapProps);
+  return React2__namespace.useMemo(
+    () => React2__namespace.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, ...rest }) => {
+  const localRef = React2.useRef(null);
+  const ref = refView != null ? refView : localRef;
+  const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
+  return /* @__PURE__ */ React2__namespace.createElement(ReactNative.View, { ...rest, onLayout, ref });
+};
+
+// src/components/ListComponent.tsx
+var AlignItemsAtEndSpacer = typedMemo(function AlignItemsAtEndSpacer2({ horizontal }) {
+  const [alignItemsAtEndPadding = 0] = useArr$(["alignItemsAtEndPadding"]);
+  if (alignItemsAtEndPadding <= 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React2__namespace.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;
+  React2.useLayoutEffect(() => {
+    if (!ListHeaderComponent) {
+      setHeaderSize(ctx, 0);
+    }
+    if (!ListFooterComponent) {
+      setFooterSize(ctx, 0);
+    }
+  }, [ListHeaderComponent, ListFooterComponent, ctx]);
+  const onLayoutHeader = React2.useCallback(
+    (rect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      setHeaderSize(ctx, size);
+    },
+    [ctx, horizontal]
+  );
+  const onLayoutFooterInternal = React2.useCallback(
+    (rect, fromLayoutEffect) => {
+      const size = rect[horizontal ? "width" : "height"];
+      setFooterSize(ctx, size);
+      onLayoutFooter == null ? void 0 : onLayoutFooter(rect, fromLayoutEffect);
+    },
+    [ctx, horizontal, onLayoutFooter]
+  );
+  return /* @__PURE__ */ React2__namespace.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__ */ React2__namespace.createElement(ScrollAdjust, null),
+    ListHeaderComponent && /* @__PURE__ */ React2__namespace.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
+    ListEmptyComponent && getComponent(ListEmptyComponent),
+    shouldRenderAlignItemsAtEndSpacer && /* @__PURE__ */ React2__namespace.createElement(AlignItemsAtEndSpacer, { horizontal }),
+    canRender && !ListEmptyComponent && /* @__PURE__ */ React2__namespace.createElement(
+      Containers,
+      {
+        getRenderedItem: getRenderedItem2,
+        horizontal,
+        ItemSeparatorComponent,
+        recycleItems,
+        stickyHeaderConfig,
+        updateItemSize: updateItemSize2
+      }
+    ),
+    ListFooterComponent && /* @__PURE__ */ React2__namespace.createElement(LayoutView, { onLayoutChange: onLayoutFooterInternal, style: ListFooterComponentStyle }, getComponent(ListFooterComponent)),
+    Platform.OS === "web" && /* @__PURE__ */ React2__namespace.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;
+  React2.useEffect(() => {
+    if (useWindowScroll && renderScrollComponent) {
+      warnDevOnce(
+        "useWindowScrollRenderScrollComponent",
+        "useWindowScroll is not supported when renderScrollComponent is provided."
+      );
+    }
+  }, [renderScrollComponent, useWindowScroll]);
+  React2.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]);
+  React2.useEffect(() => {
+    const state = ctx.state;
+    const dataLength = state.props.data.length;
+    const useWindowScrollResolved = state.props.useWindowScroll;
+    if (Platform.OS !== "web" || 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."
+        );
       }
     };
-    checkHasScrolled();
-  }, initialDelay);
+    warnIfUnboundedOuterSize();
+    const unsubscribe = [
+      listen$(ctx, "numContainers", warnIfUnboundedOuterSize),
+      listen$(ctx, "readyToRender", warnIfUnboundedOuterSize),
+      listen$(ctx, "totalSize", warnIfUnboundedOuterSize)
+    ];
+    return () => {
+      for (const unsub of unsubscribe) {
+        unsub();
+      }
+    };
+  }, [ctx]);
 }
-
-// src/core/doScrollTo.native.ts
-function doScrollTo(ctx, params) {
-  const state = ctx.state;
-  const { animated, horizontal, isInitialScroll, offset } = params;
-  const isAnimated = !!animated;
-  const { refScroller } = state;
-  const scroller = refScroller.current;
-  if (!scroller) {
-    return;
-  }
-  const isHorizontal = !!horizontal;
-  const contentSize = isHorizontal ? getContentSize(ctx) : void 0;
-  const nativeOffset = toNativeHorizontalOffset(state, offset, contentSize);
-  scroller.scrollTo({
-    animated: isAnimated,
-    x: isHorizontal ? nativeOffset : 0,
-    y: isHorizontal ? 0 : offset
-  });
-  if (isInitialScroll) {
-    initialScrollCompletion.markInitialScrollNativeDispatch(state);
-  }
-  if (!isAnimated) {
-    state.scroll = offset;
-    checkFinishedScrollFallback(ctx);
-  }
+function useDevChecksNoop(_props) {
 }
+var useDevChecks = IS_DEV ? useDevChecksImpl : useDevChecksNoop;
 
 // src/core/doMaintainScrollAtEnd.ts
 function doMaintainScrollAtEnd(ctx) {
@@ -2215,9 +2460,12 @@ function doMaintainScrollAtEnd(ctx) {
       state.scroll = 0;
     }
     if (!state.maintainingScrollAtEnd) {
-      state.maintainingScrollAtEnd = true;
+      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);
@@ -2235,12 +2483,14 @@ function doMaintainScrollAtEnd(ctx) {
           }
           setTimeout(
             () => {
-              state.maintainingScrollAtEnd = false;
+              if (state.maintainingScrollAtEnd === activeState) {
+                state.maintainingScrollAtEnd = void 0;
+              }
             },
             maintainScrollAtEnd.animated ? 500 : 0
           );
-        } else {
-          state.maintainingScrollAtEnd = false;
+        } else if (state.maintainingScrollAtEnd === pendingState) {
+          state.maintainingScrollAtEnd = void 0;
         }
       });
     }
@@ -2249,58 +2499,6 @@ function doMaintainScrollAtEnd(ctx) {
   return false;
 }
 
-// src/utils/requestAdjust.ts
-function requestAdjust(ctx, positionDiff, dataChanged) {
-  const state = ctx.state;
-  if (Math.abs(positionDiff) > 0.1) {
-    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
-    const doit = () => {
-      if (needsScrollWorkaround) {
-        doScrollTo(ctx, { horizontal: state.props.horizontal, offset: state.scroll });
-      } else {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-        if (state.adjustingFromInitialMount) {
-          state.adjustingFromInitialMount--;
-        }
-      }
-    };
-    state.scroll += positionDiff;
-    state.scrollForNextCalculateItemsInView = void 0;
-    const readyToRender = peek$(ctx, "readyToRender");
-    if (readyToRender) {
-      doit();
-      if (Platform.OS !== "web") {
-        const threshold = state.scroll - positionDiff / 2;
-        if (!state.ignoreScrollFromMVCP) {
-          state.ignoreScrollFromMVCP = {};
-        }
-        if (positionDiff > 0) {
-          state.ignoreScrollFromMVCP.lt = threshold;
-        } else {
-          state.ignoreScrollFromMVCP.gt = threshold;
-        }
-        if (state.ignoreScrollFromMVCPTimeout) {
-          clearTimeout(state.ignoreScrollFromMVCPTimeout);
-        }
-        const delay = needsScrollWorkaround ? 250 : 100;
-        state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
-          var _a3;
-          state.ignoreScrollFromMVCP = void 0;
-          const shouldForceUpdate = state.ignoreScrollFromMVCPIgnored && state.scrollProcessingEnabled !== false;
-          if (shouldForceUpdate) {
-            state.ignoreScrollFromMVCPIgnored = false;
-            state.scrollPending = state.scroll;
-            (_a3 = state.reprocessCurrentScroll) == null ? void 0 : _a3.call(state);
-          }
-        }, delay);
-      }
-    } else {
-      state.adjustingFromInitialMount = (state.adjustingFromInitialMount || 0) + 1;
-      requestAnimationFrame(doit);
-    }
-  }
-}
-
 // src/core/mvcp.ts
 var MVCP_POSITION_EPSILON = 0.1;
 var MVCP_ANCHOR_LOCK_TTL_MS = 300;
@@ -2449,6 +2647,10 @@ function prepareMVCP(ctx, dataChanged) {
   const now = Date.now();
   const enableMVCPAnchorLock = isWeb && (!!dataChanged || !!state.mvcpAnchorLock);
   const scrollingTo = state.scrollingTo;
+  if (isWeb && dataChanged && state.pendingScrollToEnd && scrollingTo === void 0) {
+    state.mvcpAnchorLock = void 0;
+    return void 0;
+  }
   const anchorLock = isWeb ? resolveAnchorLock(state, enableMVCPAnchorLock, mvcpData, now) : void 0;
   let prevPosition;
   let targetId;
@@ -2584,7 +2786,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, dataChanged && mvcpData);
         }
@@ -2598,6 +2800,45 @@ var flushSync = (fn) => {
   fn();
 };
 
+// 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;
@@ -2623,6 +2864,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) {
@@ -2646,7 +2889,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) {
@@ -3581,9 +3824,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;
   }
@@ -3807,45 +4073,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;
@@ -4166,7 +4393,7 @@ function areViewabilityAmountTokensEqual(prev, next) {
 }
 function computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
   const { sizes, scroll: scrollState } = state;
-  const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
+  const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "alignItemsAtEndPadding") || 0) + (peek$(ctx, "headerSize") || 0);
   const { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = viewabilityConfig;
   const viewAreaMode = viewAreaCoveragePercentThreshold != null;
   const viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
@@ -4581,7 +4808,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,
@@ -4590,14 +4817,7 @@ function calculateItemsInView(ctx, params = {}) {
       indexByKey,
       minIndexSizeChanged,
       positions,
-      props: {
-        alwaysRenderIndicesArr,
-        alwaysRenderIndicesSet,
-        drawDistance,
-        getItemType,
-        keyExtractor,
-        onStickyHeaderChange
-      },
+      props: { alwaysRenderIndicesArr, alwaysRenderIndicesSet, getItemType, keyExtractor, onStickyHeaderChange },
       scrollForNextCalculateItemsInView,
       scrollLength,
       sizes,
@@ -4609,6 +4829,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;
@@ -4617,12 +4838,12 @@ function calculateItemsInView(ctx, params = {}) {
       return;
     }
     let totalSize = getContentSize(ctx);
-    const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
+    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)
@@ -4646,19 +4867,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)) {
@@ -4691,7 +4918,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;
         }
       }
@@ -4700,7 +4927,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,
@@ -4726,21 +4953,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;
@@ -4775,8 +5005,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);
@@ -4832,7 +5062,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);
@@ -4841,7 +5071,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);
@@ -4852,7 +5082,7 @@ function calculateItemsInView(ctx, params = {}) {
         handleStickyActivation(
           ctx,
           stickyHeaderIndicesArr,
-          currentStickyIdx,
+          (_o = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _o : -1,
           needNewContainers,
           needNewContainersSet,
           startBuffered,
@@ -4878,7 +5108,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);
@@ -4889,7 +5119,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);
@@ -4920,14 +5150,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);
@@ -4941,7 +5169,7 @@ function calculateItemsInView(ctx, params = {}) {
         stickyHeaderIndicesArr,
         scroll,
         drawDistance,
-        currentStickyIdx,
+        (_s = stickyState == null ? void 0 : stickyState.currentStickyIdx) != null ? _s : -1,
         pendingRemoval,
         alwaysRenderSet
       );
@@ -5002,7 +5230,7 @@ function calculateItemsInView(ctx, params = {}) {
         );
       }
     }
-    finishCalculateItemsInView == null ? void 0 : finishCalculateItemsInView();
+    (_t = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _t.call(stickyState);
   });
 }
 
@@ -5085,8 +5313,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;
@@ -5097,12 +5326,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,
@@ -5157,6 +5386,7 @@ function handleLayout(ctx, layoutParam, setCanRender) {
   if (didChange) {
     state.scrollLength = scrollLength;
     state.otherAxisSize = otherAxisSize;
+    updateContentMetricsState(ctx);
     state.lastBatchingAction = Date.now();
     state.scrollForNextCalculateItemsInView = void 0;
     if (scrollLength > 0) {
@@ -5397,28 +5627,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 (Platform.OS === "web") {
     if (!state.mvcpAnchorLock) {
@@ -5844,10 +6058,7 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
       startBuffered: state.startBuffered
     }),
     reportContentInset: (inset) => {
-      var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-      const previousInset = state.contentInsetOverride;
-      state.contentInsetOverride = inset != null ? inset : void 0;
-      const didChange = ((_a3 = previousInset == null ? void 0 : previousInset.top) != null ? _a3 : 0) !== ((_c = (_b = state.contentInsetOverride) == null ? void 0 : _b.top) != null ? _c : 0) || ((_d = previousInset == null ? void 0 : previousInset.bottom) != null ? _d : 0) !== ((_f = (_e = state.contentInsetOverride) == null ? void 0 : _e.bottom) != null ? _f : 0) || ((_g = previousInset == null ? void 0 : previousInset.left) != null ? _g : 0) !== ((_i = (_h = state.contentInsetOverride) == null ? void 0 : _h.left) != null ? _i : 0) || ((_j = previousInset == null ? void 0 : previousInset.right) != null ? _j : 0) !== ((_l = (_k = state.contentInsetOverride) == null ? void 0 : _k.right) != null ? _l : 0);
+      const didChange = setContentInsetOverride(ctx, inset);
       updateScroll(ctx, state.scroll, true, { markHasScrolled: false });
       if (didChange) {
         retargetActiveInitialScrollAtEnd(ctx);
@@ -5899,6 +6110,9 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
       scrollTo(ctx, params);
       return true;
     }),
+    setItemSize: (itemKey, size) => {
+      updateItemSize(ctx, itemKey, size);
+    },
     setScrollProcessingEnabled: (enabled) => {
       state.scrollProcessingEnabled = enabled;
     },
@@ -6123,7 +6337,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 = React2.useCallback((_event) => {
   }, []);
   if (props.recycleItems === void 0) {
@@ -6154,6 +6368,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     initialScrollAtEnd = false,
     initialScrollIndex: initialScrollIndexProp,
     initialScrollOffset: initialScrollOffsetProp,
+    experimental_adaptiveRender,
     itemsAreEqual,
     keyExtractor: keyExtractorProp,
     ListEmptyComponent,
@@ -6203,10 +6418,11 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     ...restProps
   } = rest;
   const contentContainerStyleBase = StyleSheet.flatten(contentContainerStyleProp);
-  const shouldFlexGrow = alignItemsAtEnd && (horizontal ? (contentContainerStyleBase == null ? void 0 : contentContainerStyleBase.minWidth) == null : (contentContainerStyleBase == null ? void 0 : contentContainerStyleBase.minHeight) == null);
+  const useAlignItemsAtEndPadding = alignItemsAtEnd && !horizontal && (contentContainerStyleBase == null ? void 0 : contentContainerStyleBase.minHeight) == null && dataProp.length > 0;
+  const shouldFlexGrow = alignItemsAtEnd && !useAlignItemsAtEndPadding && (horizontal ? (contentContainerStyleBase == null ? void 0 : contentContainerStyleBase.minWidth) == null : (contentContainerStyleBase == null ? void 0 : contentContainerStyleBase.minHeight) == null);
   const contentContainerStyle = {
     ...contentContainerStyleBase,
-    ...alignItemsAtEnd ? {
+    ...alignItemsAtEnd && !useAlignItemsAtEndPadding ? {
       display: "flex",
       flexDirection: horizontal ? "row" : "column",
       ...shouldFlexGrow ? { flexGrow: 1 } : {},
@@ -6249,6 +6465,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const [, scheduleImperativeScrollCommit] = React2__namespace.useReducer((value) => value + 1, 0);
   const ctx = useStateContext();
   ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
+  const scrollAxisGap = horizontal ? (_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 = React2.useRef(null);
   const combinedRef = useCombinedRef(refScroller, refScrollView);
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : ((_item, index) => index.toString());
@@ -6262,8 +6480,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
@@ -6291,6 +6509,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(),
@@ -6333,6 +6552,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
@@ -6351,11 +6571,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) {
@@ -6367,14 +6589,17 @@ 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 = Platform.OS === "web" && 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,
     alwaysRenderIndicesArr: alwaysRenderIndices.arr,
     alwaysRenderIndicesSet: alwaysRenderIndices.set,
     anchoredEndSpace: anchoredEndSpaceResolved,
     animatedProps: animatedPropsInternal,
+    contentContainerAlignItems: contentContainerStyle.alignItems,
     contentInset,
     contentInsetEndAdjustment: contentInsetEndAdjustmentResolved,
     data: dataProp,
@@ -6427,6 +6652,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const prevPaddingTop = peek$(ctx, "stylePaddingTop");
     setPaddingTop(ctx, { stylePaddingTop: stylePaddingTopState });
     refState.current.props.stylePaddingBottom = stylePaddingBottomState;
+    updateContentMetricsState(ctx);
     let paddingDiff = stylePaddingTopState - prevPaddingTop;
     if (shouldAdjustPadding && maintainVisibleContentPositionConfig.size && paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") {
       if (state.scroll < 0) {
@@ -6463,7 +6689,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();
@@ -6480,6 +6706,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       dataLength: dataProp.length,
       didDataChange: didDataChangeLocal,
       initialScrollAtEnd,
+      latestInitialScroll: initialScrollProp,
+      latestInitialScrollSessionKind: initialScrollUsesOffsetOnly ? "offset" : "bootstrap",
       stylePaddingBottom: stylePaddingBottomState,
       useBootstrapInitialScroll: usesBootstrapInitialScroll
     });
@@ -6550,7 +6778,15 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   }, [snapToIndices]);
   React2.useLayoutEffect(
     () => initializeStateVars(true),
-    [dataVersion, memoizedLastItemKeys.join(","), numColumnsProp, stylePaddingBottomState, stylePaddingTopState]
+    [
+      dataVersion,
+      memoizedLastItemKeys.join(","),
+      numColumnsProp,
+      nextScrollAxisGap,
+      stylePaddingBottomState,
+      stylePaddingTopState,
+      useAlignItemsAtEndPadding
+    ]
   );
   React2.useLayoutEffect(() => {
     const {
@@ -6569,7 +6805,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.didColumnsChange = false;
     state.didDataChange = false;
     state.isFirst = false;
-  }, [dataProp, dataVersion, numColumnsProp]);
+  }, [dataProp, dataVersion, numColumnsProp, nextScrollAxisGap]);
   React2.useLayoutEffect(() => {
     var _a4;
     set$(ctx, "extraData", extraData);
@@ -6620,6 +6856,14 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
   });
   React2.useImperativeHandle(forwardedRef, () => createImperativeHandle(ctx, scheduleImperativeScrollCommit), []);
+  React2.useEffect(() => {
+    return () => {
+      for (const timeout of state.timeouts) {
+        clearTimeout(timeout);
+      }
+      state.timeouts.clear();
+    };
+  }, [state]);
   React2.useLayoutEffect(() => {
     var _a4;
     (_a4 = state.runPendingScrollToEnd) == null ? void 0 : _a4.call(state);
@@ -6667,7 +6911,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControlElement ? stylePaddingTopState > 0 ? React2__namespace.cloneElement(refreshControlElement, {
-        progressViewOffset: ((_h = refreshControlElement.props.progressViewOffset) != null ? _h : 0) + stylePaddingTopState
+        progressViewOffset: ((_n = refreshControlElement.props.progressViewOffset) != null ? _n : 0) + stylePaddingTopState
       }) : refreshControlElement : onRefresh && /* @__PURE__ */ React2__namespace.createElement(
         ReactNative.RefreshControl,
         {
@@ -6678,7 +6922,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,
@@ -6712,6 +6956,8 @@ var internal2 = internal;
 
 exports.LegendList = LegendList3;
 exports.internal = internal2;
+exports.useAdaptiveRender = useAdaptiveRender;
+exports.useAdaptiveRenderChange = useAdaptiveRenderChange;
 exports.useIsLastItem = useIsLastItem;
 exports.useListScrollSize = useListScrollSize;
 exports.useRecyclingEffect = useRecyclingEffect;