@legendapp/list 3.3.1 → 3.3.3

package/react.js

@@ -148,6 +148,7 @@ var createAnimatedValue = (value) => value;
 
 // src/state/state.tsx
 var ContextState = React3__namespace.createContext(null);
+var SIGNAL_NAMES_SEPARATOR = "\0";
 var contextNum = 0;
 function StateProvider({ children }) {
   const [value] = React3__namespace.useState(() => ({
@@ -161,11 +162,13 @@ function StateProvider({ children }) {
     mapViewabilityCallbacks: /* @__PURE__ */ new Map(),
     mapViewabilityConfigStates: /* @__PURE__ */ new Map(),
     mapViewabilityValues: /* @__PURE__ */ new Map(),
+    pendingContainerIds: void 0,
     positionListeners: /* @__PURE__ */ new Map(),
     scrollAxisGap: 0,
     state: void 0,
     values: /* @__PURE__ */ new Map([
       ["alignItemsAtEndPadding", 0],
+      ["containerLayoutEpoch", 0],
       ["stylePaddingTop", 0],
       ["headerSize", 0],
       ["numContainers", 0],
@@ -219,6 +222,12 @@ function createSelectorFunctionsArr(ctx, signalNames) {
     }
   };
 }
+function getSignalNamesKey(signalNames) {
+  return signalNames.length === 1 ? signalNames[0] : signalNames.join(SIGNAL_NAMES_SEPARATOR);
+}
+function getSignalNamesFromKey(signalNamesKey) {
+  return signalNamesKey.split(SIGNAL_NAMES_SEPARATOR);
+}
 function listen$(ctx, signalName, cb) {
   const { listeners } = ctx;
   let setListeners = listeners.get(signalName);
@@ -266,7 +275,11 @@ function notifyPosition$(ctx, key, value) {
 }
 function useArr$(signalNames) {
   const ctx = React3__namespace.useContext(ContextState);
-  const { subscribe, get } = React3__namespace.useMemo(() => createSelectorFunctionsArr(ctx, signalNames), [ctx, signalNames]);
+  const signalNamesKey = getSignalNamesKey(signalNames);
+  const { subscribe, get } = React3__namespace.useMemo(
+    () => createSelectorFunctionsArr(ctx, getSignalNamesFromKey(signalNamesKey)),
+    [ctx, signalNamesKey]
+  );
   const value = shim.useSyncExternalStore(subscribe, get, get);
   return value;
 }
@@ -380,6 +393,18 @@ function useInterval(callback, delay) {
   }, [delay]);
 }
 
+// src/constants-platform.ts
+var IsNewArchitecture = true;
+
+// src/core/containerLayoutBaseline.ts
+var containerLayoutBaselines = /* @__PURE__ */ new WeakMap();
+function getContainerLayoutBaseline(element) {
+  return containerLayoutBaselines.get(element);
+}
+function setContainerLayoutBaseline(element, size) {
+  containerLayoutBaselines.set(element, size);
+}
+
 // src/utils/devEnvironment.ts
 var metroDev = typeof __DEV__ !== "undefined" ? __DEV__ : void 0;
 var _a;
@@ -393,528 +418,247 @@ var POSITION_OUT_OF_VIEW = -1e7;
 var EDGE_POSITION_EPSILON = 1;
 var ENABLE_DEVMODE = IS_DEV && false;
 var ENABLE_DEBUG_VIEW = IS_DEV && false;
-var typedForwardRef = React3__namespace.forwardRef;
-var typedMemo = React3__namespace.memo;
-var getComponent = (Component) => {
-  if (React3__namespace.isValidElement(Component)) {
-    return Component;
-  }
-  if (Component) {
-    return /* @__PURE__ */ React3__namespace.createElement(Component, null);
-  }
-  return null;
-};
 
-// src/utils/helpers.ts
-function isFunction(obj) {
-  return typeof obj === "function";
-}
-function isArray(obj) {
-  return Array.isArray(obj);
+// 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 }
+    }
+  };
 }
-var warned = /* @__PURE__ */ new Set();
-function warnDevOnce(id, text) {
-  if (IS_DEV && !warned.has(id)) {
-    warned.add(id);
-    console.warn(`[legend-list] ${text}`);
+function releaseDeferredPublicOnScroll(ctx, resolvedOffset) {
+  var _a3, _b, _c, _d;
+  const state = ctx.state;
+  const deferredEvent = state.deferredPublicOnScrollEvent;
+  state.deferredPublicOnScrollEvent = void 0;
+  if (deferredEvent) {
+    (_d = (_c = state.props).onScroll) == null ? void 0 : _d.call(
+      _c,
+      withResolvedContentOffset(
+        state,
+        deferredEvent,
+        (_b = (_a3 = resolvedOffset != null ? resolvedOffset : state.scrollPending) != null ? _a3 : state.scroll) != null ? _b : 0
+      )
+    );
   }
 }
-function roundSize(size) {
-  return Math.floor(size * 8) / 8;
+
+// 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 isNullOrUndefined(value) {
-  return value === null || value === void 0;
+function clearInitialScrollSession(state) {
+  state.initialScrollSession = void 0;
+  return void 0;
 }
-function getPadding(s, type) {
-  var _a3, _b, _c;
-  const axisPadding = type === "Left" || type === "Right" ? s.paddingHorizontal : s.paddingVertical;
-  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : axisPadding) != null ? _b : s.padding) != null ? _c : 0;
+function createInitialScrollSession(options) {
+  const { bootstrap, completion, kind, previousDataLength } = options;
+  return kind === "offset" ? {
+    completion,
+    kind,
+    previousDataLength
+  } : {
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  };
 }
-function extractPadding(style, contentContainerStyle, type) {
-  return getPadding(style, type) + getPadding(contentContainerStyle, type);
+function ensureInitialScrollSessionCompletion(state, kind = ((_b) => (_b = ((_a3) => (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind)()) != null ? _b : "bootstrap")()) {
+  var _a4, _b2;
+  if (!state.initialScrollSession) {
+    state.initialScrollSession = createInitialScrollSession({
+      completion: {},
+      kind,
+      previousDataLength: 0
+    });
+  } else if (state.initialScrollSession.kind !== kind) {
+    state.initialScrollSession = createInitialScrollSession({
+      bootstrap: state.initialScrollSession.kind === "bootstrap" ? state.initialScrollSession.bootstrap : void 0,
+      completion: state.initialScrollSession.completion,
+      kind,
+      previousDataLength: state.initialScrollSession.previousDataLength
+    });
+  }
+  (_b2 = (_a4 = state.initialScrollSession).completion) != null ? _b2 : _a4.completion = {};
+  return state.initialScrollSession.completion;
 }
-function findContainerId(ctx, key) {
-  var _a3, _b;
-  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
-  if (directMatch !== void 0) {
-    return directMatch;
+var initialScrollCompletion = {
+  didDispatchNativeScroll(state) {
+    var _a3, _b;
+    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didDispatchNativeScroll);
+  },
+  didRetrySilentInitialScroll(state) {
+    var _a3, _b;
+    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didRetrySilentInitialScroll);
+  },
+  markInitialScrollNativeDispatch(state) {
+    ensureInitialScrollSessionCompletion(state).didDispatchNativeScroll = true;
+  },
+  markSilentInitialScrollRetry(state) {
+    ensureInitialScrollSessionCompletion(state).didRetrySilentInitialScroll = true;
+  },
+  resetFlags(state) {
+    if (!state.initialScrollSession) {
+      return;
+    }
+    const completion = ensureInitialScrollSessionCompletion(state, state.initialScrollSession.kind);
+    completion.didDispatchNativeScroll = void 0;
+    completion.didRetrySilentInitialScroll = void 0;
   }
-  const numContainers = peek$(ctx, "numContainers");
-  for (let i = 0; i < numContainers; i++) {
-    const itemKey = peek$(ctx, `containerItemKey${i}`);
-    if (itemKey === key) {
-      return i;
+};
+var initialScrollWatchdog = {
+  clear(state) {
+    initialScrollWatchdog.set(state, void 0);
+  },
+  didReachTarget(newScroll, watchdog) {
+    const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
+    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  get(state) {
+    var _a3, _b;
+    return (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog;
+  },
+  hasNonZeroTargetOffset(targetOffset) {
+    return targetOffset !== void 0 && targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  isAtZeroTargetOffset(targetOffset) {
+    return targetOffset <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
+  },
+  set(state, watchdog) {
+    var _a3, _b;
+    if (!watchdog && !((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog)) {
+      return;
     }
+    const completion = ensureInitialScrollSessionCompletion(state);
+    completion.watchdog = watchdog ? {
+      startScroll: watchdog.startScroll,
+      targetOffset: watchdog.targetOffset
+    } : void 0;
   }
-  return -1;
+};
+function setInitialScrollSession(state, options = {}) {
+  var _a3, _b, _c, _d;
+  const existingSession = state.initialScrollSession;
+  const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
+  const completion = existingSession == null ? void 0 : existingSession.completion;
+  const existingBootstrap = (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0;
+  const bootstrap = kind === "bootstrap" ? options.bootstrap === null ? void 0 : (_b = options.bootstrap) != null ? _b : existingBootstrap : void 0;
+  if (!kind) {
+    return clearInitialScrollSession(state);
+  }
+  if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
+    return clearInitialScrollSession(state);
+  }
+  const previousDataLength = (_d = (_c = options.previousDataLength) != null ? _c : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _d : 0;
+  state.initialScrollSession = createInitialScrollSession({
+    bootstrap,
+    completion,
+    kind,
+    previousDataLength
+  });
+  return state.initialScrollSession;
 }
 
-// src/components/PositionView.tsx
-var isRNWeb = typeof document !== "undefined" && !!document.getElementById("react-native-stylesheet");
-var baseCss = {
-  contain: "paint layout style",
-  ...isRNWeb ? {
-    display: "flex",
-    flexDirection: "column"
-  } : {}
+// src/utils/checkThreshold.ts
+var HYSTERESIS_MULTIPLIER = 1.3;
+function isOutsideThresholdHysteresis(distance, atThreshold, threshold) {
+  const absDistance = Math.abs(distance);
+  return !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
+}
+var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot) => {
+  const absDistance = Math.abs(distance);
+  const within = atThreshold || threshold > 0 && absDistance <= threshold;
+  const updateSnapshot = () => {
+    setSnapshot({
+      atThreshold,
+      contentSize: context.contentSize,
+      dataLength: context.dataLength,
+      scrollPosition: context.scrollPosition
+    });
+  };
+  if (!wasReached) {
+    if (!within) {
+      return false;
+    }
+    onReached(distance);
+    updateSnapshot();
+    return true;
+  }
+  const reset = isOutsideThresholdHysteresis(distance, atThreshold, threshold);
+  if (reset) {
+    setSnapshot(void 0);
+    return false;
+  }
+  if (within) {
+    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
+    if (changed) {
+      updateSnapshot();
+    }
+  }
+  return true;
 };
-var PositionViewState = typedMemo(function PositionViewState2({
-  id,
-  horizontal,
-  style,
-  refView,
-  ...props
-}) {
-  const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
-  const composed = isArray(style) ? Object.assign({}, ...style) : style;
-  const combinedStyle = horizontal ? { ...baseCss, ...composed, left: position } : { ...baseCss, ...composed, top: position };
-  const {
-    animatedScrollY: _animatedScrollY,
-    index,
-    onLayout: _onLayout,
-    onLayoutChange: _onLayoutChange,
-    stickyHeaderConfig: _stickyHeaderConfig,
-    ...webProps
-  } = props;
-  return /* @__PURE__ */ React3__namespace.createElement("div", { "data-index": index, ref: refView, ...webProps, style: combinedStyle });
-});
-var PositionViewSticky = typedMemo(function PositionViewSticky2({
-  id,
-  horizontal,
-  style,
-  refView,
-  index,
-  animatedScrollY: _animatedScrollY,
-  stickyHeaderConfig,
-  onLayout: _onLayout,
-  onLayoutChange: _onLayoutChange,
-  children,
-  ...webProps
-}) {
-  const [position = POSITION_OUT_OF_VIEW, activeStickyIndex] = useArr$([
-    `containerPosition${id}`,
-    "activeStickyIndex"
-  ]);
-  const composed = React3__namespace.useMemo(
-    () => {
-      var _a3;
-      return (_a3 = isArray(style) ? Object.assign({}, ...style) : style) != null ? _a3 : {};
-    },
-    [style]
-  );
-  const viewStyle = React3__namespace.useMemo(() => {
-    var _a3;
-    const styleBase = { ...baseCss, ...composed };
-    delete styleBase.transform;
-    const offset = (_a3 = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a3 : 0;
-    const isActive = activeStickyIndex === index;
-    styleBase.position = isActive ? "sticky" : "absolute";
-    styleBase.zIndex = index + 1e3;
-    if (horizontal) {
-      styleBase.left = isActive ? offset : position;
-    } else {
-      styleBase.top = isActive ? offset : position;
-    }
-    return styleBase;
-  }, [composed, horizontal, position, index, activeStickyIndex, stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset]);
-  const renderStickyHeaderBackdrop = React3__namespace.useMemo(
-    () => (stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent) ? /* @__PURE__ */ React3__namespace.createElement(
-      "div",
-      {
-        style: {
-          inset: 0,
-          pointerEvents: "none",
-          position: "absolute"
-        }
-      },
-      getComponent(stickyHeaderConfig.backdropComponent)
-    ) : null,
-    [stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent]
-  );
-  return /* @__PURE__ */ React3__namespace.createElement(
-    "div",
-    {
-      "data-index": index,
-      ref: refView,
-      style: viewStyle,
-      ...webProps
-    },
-    renderStickyHeaderBackdrop,
-    children
-  );
-});
-var PositionView = PositionViewState;
 
-// src/constants-platform.ts
-var IsNewArchitecture = true;
-function useInit(cb) {
-  React3.useState(() => cb());
-}
-
-// src/state/ContextContainer.ts
-var ContextContainer = React3.createContext(null);
-function useContextContainer() {
-  return React3.useContext(ContextContainer);
-}
-function useAdaptiveRender() {
-  const [mode] = useArr$(["adaptiveRender"]);
-  return mode;
-}
-function useAdaptiveRenderChange(callback) {
-  const ctx = useStateContext();
-  const callbackRef = React3.useRef(callback);
-  callbackRef.current = callback;
-  React3.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();
-  useInit(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    const key = containerId + (configId != null ? configId : "");
-    const value = ctx.mapViewabilityValues.get(key);
-    if (value) {
-      callback(value);
-    }
-  });
-  React3.useEffect(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    const key = containerId + (configId != null ? configId : "");
-    ctx.mapViewabilityCallbacks.set(key, callback);
-    return () => {
-      ctx.mapViewabilityCallbacks.delete(key);
-    };
-  }, [ctx, callback, configId, containerContext]);
-}
-function useViewabilityAmount(callback) {
-  const ctx = useStateContext();
-  const containerContext = useContextContainer();
-  useInit(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    const value = ctx.mapViewabilityAmountValues.get(containerId);
-    if (value) {
-      callback(value);
-    }
-  });
-  React3.useEffect(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { containerId } = containerContext;
-    ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
-    return () => {
-      ctx.mapViewabilityAmountCallbacks.delete(containerId);
-    };
-  }, [ctx, callback, containerContext]);
-}
-function useRecyclingEffect(effect) {
-  const containerContext = useContextContainer();
-  const prevValues = React3.useRef({
-    prevIndex: void 0,
-    prevItem: void 0
-  });
-  React3.useEffect(() => {
-    if (!containerContext) {
-      return;
-    }
-    const { index, value } = containerContext;
-    let ret;
-    if (prevValues.current.prevIndex !== void 0 && prevValues.current.prevItem !== void 0) {
-      ret = effect({
-        index,
-        item: value,
-        prevIndex: prevValues.current.prevIndex,
-        prevItem: prevValues.current.prevItem
-      });
-    }
-    prevValues.current = {
-      prevIndex: index,
-      prevItem: value
-    };
-    return ret;
-  }, [effect, containerContext]);
-}
-function useRecyclingState(valueOrFun) {
-  var _a3, _b;
-  const containerContext = useContextContainer();
-  const computeValue = (ctx) => {
-    if (isFunction(valueOrFun)) {
-      const initializer = valueOrFun;
-      return ctx ? initializer({
-        index: ctx.index,
-        item: ctx.value,
-        prevIndex: void 0,
-        prevItem: void 0
-      }) : initializer();
-    }
-    return valueOrFun;
-  };
-  const [stateValue, setStateValue] = React3.useState(() => {
-    return computeValue(containerContext);
-  });
-  const prevItemKeyRef = React3.useRef((_a3 = containerContext == null ? void 0 : containerContext.itemKey) != null ? _a3 : null);
-  const currentItemKey = (_b = containerContext == null ? void 0 : containerContext.itemKey) != null ? _b : null;
-  if (currentItemKey !== null && prevItemKeyRef.current !== currentItemKey) {
-    prevItemKeyRef.current = currentItemKey;
-    setStateValue(computeValue(containerContext));
-  }
-  const triggerLayout = containerContext == null ? void 0 : containerContext.triggerLayout;
-  const setState = React3.useCallback(
-    (newState) => {
-      if (!triggerLayout) {
-        return;
-      }
-      setStateValue((prevValue) => {
-        return isFunction(newState) ? newState(prevValue) : newState;
-      });
-      triggerLayout();
-    },
-    [triggerLayout]
-  );
-  return [stateValue, setState];
-}
-function useIsLastItem() {
-  const containerContext = useContextContainer();
-  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => {
-    if (containerContext) {
-      const { itemKey } = containerContext;
-      if (!isNullOrUndefined(itemKey)) {
-        return (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false;
-      }
-    }
-    return false;
-  });
-  return isLast;
-}
-function useListScrollSize() {
-  const [scrollSize] = useArr$(["scrollSize"]);
-  return scrollSize;
-}
-var noop = () => {
-};
-function useSyncLayout() {
-  const containerContext = useContextContainer();
-  if (containerContext) {
-    const { triggerLayout: syncLayout } = containerContext;
-    return syncLayout;
+// src/utils/edgeReachedGate.ts
+function resetEdgeLatch(ctx, edge) {
+  const state = ctx.state;
+  if (edge === "start") {
+    state.isStartReached = false;
+    state.startReachedSnapshot = void 0;
   } else {
-    return noop;
+    state.isEndReached = false;
+    state.endReachedSnapshot = void 0;
   }
 }
-
-// src/components/Separator.tsx
-function Separator({ ItemSeparatorComponent, leadingItem }) {
-  const isLastItem = useIsLastItem();
-  return isLastItem ? null : /* @__PURE__ */ React3__namespace.createElement(ItemSeparatorComponent, { leadingItem });
-}
-
-// 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;
+function resetSharedEdgeGateIfOutsideHysteresis(ctx) {
   const state = ctx.state;
-  const deferredEvent = state.deferredPublicOnScrollEvent;
-  state.deferredPublicOnScrollEvent = void 0;
-  if (deferredEvent) {
-    (_d = (_c = state.props).onScroll) == null ? void 0 : _d.call(
-      _c,
-      withResolvedContentOffset(
-        state,
-        deferredEvent,
-        (_b = (_a3 = resolvedOffset != null ? resolvedOffset : state.scrollPending) != null ? _a3 : state.scroll) != null ? _b : 0
-      )
-    );
+  if (!state.edgeReachedGate) {
+    return;
+  }
+  const contentSize = getContentSize(ctx);
+  const endDistance = contentSize - state.scroll - state.scrollLength - getContentInsetEnd(ctx);
+  const isContentLess = contentSize < state.scrollLength;
+  const startThreshold = state.props.onStartReachedThreshold * state.scrollLength;
+  const endThreshold = state.props.onEndReachedThreshold * state.scrollLength;
+  const isOutsideStart = isOutsideThresholdHysteresis(state.scroll, false, startThreshold);
+  const isOutsideEnd = isOutsideThresholdHysteresis(endDistance, isContentLess, endThreshold);
+  if (isOutsideStart && isOutsideEnd) {
+    state.edgeReachedGate = void 0;
   }
 }
-
-// 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 canDispatchReachedEdge(ctx, edge, allowedEdge, allowGateCreatedInCurrentCheck) {
+  return !ctx.state.edgeReachedGate || allowedEdge === edge || !!allowGateCreatedInCurrentCheck;
 }
-function clearInitialScrollSession(state) {
-  state.initialScrollSession = void 0;
-  return void 0;
+function markReachedEdge(ctx) {
+  ctx.state.edgeReachedGate = "closed";
 }
-function createInitialScrollSession(options) {
-  const { bootstrap, completion, kind, previousDataLength } = options;
-  return kind === "offset" ? {
-    completion,
-    kind,
-    previousDataLength
-  } : {
-    bootstrap,
-    completion,
-    kind,
-    previousDataLength
-  };
-}
-function ensureInitialScrollSessionCompletion(state, kind = ((_b) => (_b = ((_a3) => (_a3 = state.initialScrollSession) == null ? void 0 : _a3.kind)()) != null ? _b : "bootstrap")()) {
-  var _a4, _b2;
-  if (!state.initialScrollSession) {
-    state.initialScrollSession = createInitialScrollSession({
-      completion: {},
-      kind,
-      previousDataLength: 0
-    });
-  } else if (state.initialScrollSession.kind !== kind) {
-    state.initialScrollSession = createInitialScrollSession({
-      bootstrap: state.initialScrollSession.kind === "bootstrap" ? state.initialScrollSession.bootstrap : void 0,
-      completion: state.initialScrollSession.completion,
-      kind,
-      previousDataLength: state.initialScrollSession.previousDataLength
-    });
+function prepareReachedEdgeForNextUserScroll(ctx) {
+  if (ctx.state.edgeReachedGate) {
+    ctx.state.edgeReachedGate = "prepared";
   }
-  (_b2 = (_a4 = state.initialScrollSession).completion) != null ? _b2 : _a4.completion = {};
-  return state.initialScrollSession.completion;
 }
-var initialScrollCompletion = {
-  didDispatchNativeScroll(state) {
-    var _a3, _b;
-    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didDispatchNativeScroll);
-  },
-  didRetrySilentInitialScroll(state) {
-    var _a3, _b;
-    return !!((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.didRetrySilentInitialScroll);
-  },
-  markInitialScrollNativeDispatch(state) {
-    ensureInitialScrollSessionCompletion(state).didDispatchNativeScroll = true;
-  },
-  markSilentInitialScrollRetry(state) {
-    ensureInitialScrollSessionCompletion(state).didRetrySilentInitialScroll = true;
-  },
-  resetFlags(state) {
-    if (!state.initialScrollSession) {
-      return;
-    }
-    const completion = ensureInitialScrollSessionCompletion(state, state.initialScrollSession.kind);
-    completion.didDispatchNativeScroll = void 0;
-    completion.didRetrySilentInitialScroll = void 0;
-  }
-};
-var initialScrollWatchdog = {
-  clear(state) {
-    initialScrollWatchdog.set(state, void 0);
-  },
-  didReachTarget(newScroll, watchdog) {
-    const nextDistance = Math.abs(newScroll - watchdog.targetOffset);
-    return nextDistance <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  get(state) {
-    var _a3, _b;
-    return (_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog;
-  },
-  hasNonZeroTargetOffset(targetOffset) {
-    return targetOffset !== void 0 && targetOffset > INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  isAtZeroTargetOffset(targetOffset) {
-    return targetOffset <= INITIAL_SCROLL_MIN_TARGET_OFFSET;
-  },
-  set(state, watchdog) {
-    var _a3, _b;
-    if (!watchdog && !((_b = (_a3 = state.initialScrollSession) == null ? void 0 : _a3.completion) == null ? void 0 : _b.watchdog)) {
-      return;
-    }
-    const completion = ensureInitialScrollSessionCompletion(state);
-    completion.watchdog = watchdog ? {
-      startScroll: watchdog.startScroll,
-      targetOffset: watchdog.targetOffset
-    } : void 0;
-  }
-};
-function setInitialScrollSession(state, options = {}) {
-  var _a3, _b, _c, _d;
-  const existingSession = state.initialScrollSession;
-  const kind = (_a3 = options.kind) != null ? _a3 : existingSession == null ? void 0 : existingSession.kind;
-  const completion = existingSession == null ? void 0 : existingSession.completion;
-  const existingBootstrap = (existingSession == null ? void 0 : existingSession.kind) === "bootstrap" ? existingSession.bootstrap : void 0;
-  const bootstrap = kind === "bootstrap" ? options.bootstrap === null ? void 0 : (_b = options.bootstrap) != null ? _b : existingBootstrap : void 0;
-  if (!kind) {
-    return clearInitialScrollSession(state);
-  }
-  if (!state.initialScroll && !bootstrap && !hasInitialScrollSessionCompletion(completion)) {
-    return clearInitialScrollSession(state);
+function beginReachedEdgeUserScroll(ctx, scrollDelta) {
+  const state = ctx.state;
+  if (state.edgeReachedGate !== "prepared") {
+    return void 0;
   }
-  const previousDataLength = (_d = (_c = options.previousDataLength) != null ? _c : existingSession == null ? void 0 : existingSession.previousDataLength) != null ? _d : 0;
-  state.initialScrollSession = createInitialScrollSession({
-    bootstrap,
-    completion,
-    kind,
-    previousDataLength
-  });
-  return state.initialScrollSession;
+  const allowedEdge = scrollDelta < 0 ? "start" : "end";
+  state.edgeReachedGate = "closed";
+  resetEdgeLatch(ctx, allowedEdge);
+  return allowedEdge;
 }
 
-// src/utils/checkThreshold.ts
-var HYSTERESIS_MULTIPLIER = 1.3;
-var checkThreshold = (distance, atThreshold, threshold, wasReached, snapshot, context, onReached, setSnapshot, allowReentryOnChange) => {
-  const absDistance = Math.abs(distance);
-  const within = atThreshold || threshold > 0 && absDistance <= threshold;
-  const updateSnapshot = () => {
-    setSnapshot({
-      atThreshold,
-      contentSize: context.contentSize,
-      dataLength: context.dataLength,
-      scrollPosition: context.scrollPosition
-    });
-  };
-  if (!wasReached) {
-    if (!within) {
-      return false;
-    }
-    onReached(distance);
-    updateSnapshot();
-    return true;
-  }
-  const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
-  if (reset) {
-    setSnapshot(void 0);
-    return false;
-  }
-  if (within) {
-    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
-    if (changed) {
-      if (allowReentryOnChange) {
-        onReached(distance);
-      }
-      updateSnapshot();
-    }
-  }
-  return true;
-};
-
 // src/utils/hasActiveInitialScroll.ts
 function hasActiveInitialScroll(state) {
   return !!(state == null ? void 0 : state.initialScroll) && !state.didFinishInitialScroll;
 }
 
 // src/utils/checkAtBottom.ts
-function checkAtBottom(ctx) {
+function checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   var _a3;
   const state = ctx.state;
   if (!state) {
@@ -928,6 +672,7 @@ function checkAtBottom(ctx) {
     props: { maintainScrollAtEndThreshold, onEndReachedThreshold }
   } = state;
   const contentSize = getContentSize(ctx);
+  resetSharedEdgeGateIfOutsideHysteresis(ctx);
   if (contentSize > 0 && queuedInitialLayout) {
     const insetEnd = getContentInsetEnd(ctx);
     const distanceFromEnd = contentSize - scroll - scrollLength - insetEnd;
@@ -954,72 +699,50 @@ function checkAtBottom(ctx) {
         },
         (distance) => {
           var _a4, _b;
-          return (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+          if (canDispatchReachedEdge(ctx, "end", allowedEdge, allowGateCreatedInCurrentCheck)) {
+            markReachedEdge(ctx);
+            (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
+          }
         },
         (snapshot) => {
           state.endReachedSnapshot = snapshot;
-        },
-        true
+        }
       );
     }
   }
 }
 
-// src/utils/hasActiveMVCPAnchorLock.ts
-function hasActiveMVCPAnchorLock(state) {
-  const lock = state.mvcpAnchorLock;
-  if (!lock) {
-    return false;
-  }
-  if (Date.now() > lock.expiresAt) {
-    state.mvcpAnchorLock = void 0;
-    return false;
-  }
-  return true;
-}
-
-// src/utils/isInMVCPActiveMode.ts
-function isInMVCPActiveMode(state) {
-  return state.dataChangeNeedsScrollUpdate || hasActiveMVCPAnchorLock(state);
-}
-
 // src/utils/checkAtTop.ts
-function checkAtTop(ctx) {
+function checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck) {
   const state = ctx == null ? void 0 : ctx.state;
   if (!state) {
     return;
   }
   const {
-    dataChangeEpoch,
     isStartReached,
     props: { data, onStartReachedThreshold },
     scroll,
     scrollLength,
     startReachedSnapshot,
-    startReachedSnapshotDataChangeEpoch,
     totalSize
   } = state;
   const dataLength = data.length;
   const threshold = onStartReachedThreshold * scrollLength;
-  const dataChanged = startReachedSnapshotDataChangeEpoch !== dataChangeEpoch;
-  const withinThreshold = threshold > 0 && Math.abs(scroll) <= threshold;
-  const allowReentryOnDataChange = !!isStartReached && withinThreshold && !!dataChanged && !isInMVCPActiveMode(state);
-  if (isStartReached && threshold > 0 && scroll > threshold && startReachedSnapshot && (dataChanged || startReachedSnapshot.contentSize !== totalSize || startReachedSnapshot.dataLength !== dataLength)) {
+  resetSharedEdgeGateIfOutsideHysteresis(ctx);
+  if (isStartReached && threshold > 0 && scroll > threshold && startReachedSnapshot && (startReachedSnapshot.contentSize !== totalSize || startReachedSnapshot.dataLength !== dataLength)) {
     state.isStartReached = false;
     state.startReachedSnapshot = void 0;
-    state.startReachedSnapshotDataChangeEpoch = void 0;
   }
   set$(ctx, "isAtStart", scroll <= EDGE_POSITION_EPSILON);
   set$(ctx, "isNearStart", scroll <= threshold);
   const shouldSkipThresholdChecks = hasActiveInitialScroll(state) || !!state.scrollingTo;
-  const shouldDeferDataChangeRefire = isStartReached && withinThreshold && dataChanged && !allowReentryOnDataChange;
-  if (!shouldSkipThresholdChecks && !shouldDeferDataChangeRefire) {
+  if (!shouldSkipThresholdChecks) {
     state.isStartReached = checkThreshold(
       scroll,
       false,
       threshold,
       state.isStartReached,
-      allowReentryOnDataChange ? void 0 : startReachedSnapshot,
+      startReachedSnapshot,
       {
         contentSize: totalSize,
         dataLength,
@@ -1027,21 +750,23 @@ function checkAtTop(ctx) {
       },
       (distance) => {
         var _a3, _b;
-        return (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+        if (canDispatchReachedEdge(ctx, "start", allowedEdge, allowGateCreatedInCurrentCheck)) {
+          markReachedEdge(ctx);
+          (_b = (_a3 = state.props).onStartReached) == null ? void 0 : _b.call(_a3, { distanceFromStart: distance });
+        }
       },
       (snapshot) => {
         state.startReachedSnapshot = snapshot;
-        state.startReachedSnapshotDataChangeEpoch = snapshot ? dataChangeEpoch : void 0;
-      },
-      allowReentryOnDataChange
+      }
     );
   }
 }
 
 // src/utils/checkThresholds.ts
-function checkThresholds(ctx) {
-  checkAtBottom(ctx);
-  checkAtTop(ctx);
+function checkThresholds(ctx, allowedEdge) {
+  const allowGateCreatedInCurrentCheck = !ctx.state.edgeReachedGate;
+  checkAtBottom(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
+  checkAtTop(ctx, allowedEdge, allowGateCreatedInCurrentCheck);
 }
 
 // src/core/recalculateSettledScroll.ts
@@ -1339,7 +1064,51 @@ function setSize(ctx, itemKey, size, notifyTotalSize = true) {
   if (diff !== 0) {
     addTotalSize(ctx, itemKey, diff, notifyTotalSize);
   }
-  sizes.set(itemKey, size);
+  sizes.set(itemKey, size);
+}
+
+// src/utils/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+function isArray(obj) {
+  return Array.isArray(obj);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnDevOnce(id, text) {
+  if (IS_DEV && !warned.has(id)) {
+    warned.add(id);
+    console.warn(`[legend-list] ${text}`);
+  }
+}
+function roundSize(size) {
+  return Math.floor(size * 8) / 8;
+}
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function getPadding(s, type) {
+  var _a3, _b, _c;
+  const axisPadding = type === "Left" || type === "Right" ? s.paddingHorizontal : s.paddingVertical;
+  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : axisPadding) != null ? _b : s.padding) != null ? _c : 0;
+}
+function extractPadding(style, contentContainerStyle, type) {
+  return getPadding(style, type) + getPadding(contentContainerStyle, type);
+}
+function findContainerId(ctx, key) {
+  var _a3, _b;
+  const directMatch = (_b = (_a3 = ctx.state) == null ? void 0 : _a3.containerItemKeys) == null ? void 0 : _b.get(key);
+  if (directMatch !== void 0) {
+    return directMatch;
+  }
+  const numContainers = peek$(ctx, "numContainers");
+  for (let i = 0; i < numContainers; i++) {
+    const itemKey = peek$(ctx, `containerItemKey${i}`);
+    if (itemKey === key) {
+      return i;
+    }
+  }
+  return -1;
 }
 
 // src/utils/getItemSize.ts
@@ -2020,6 +1789,24 @@ var getScrollVelocity = (state) => {
   return totalWeight > 0 ? weightedVelocity / totalWeight : 0;
 };
 
+// src/utils/hasActiveMVCPAnchorLock.ts
+function hasActiveMVCPAnchorLock(state) {
+  const lock = state.mvcpAnchorLock;
+  if (!lock) {
+    return false;
+  }
+  if (Date.now() > lock.expiresAt) {
+    state.mvcpAnchorLock = void 0;
+    return false;
+  }
+  return true;
+}
+
+// src/utils/isInMVCPActiveMode.ts
+function isInMVCPActiveMode(state) {
+  return state.dataChangeNeedsScrollUpdate || hasActiveMVCPAnchorLock(state);
+}
+
 // src/core/updateScroll.ts
 function updateScroll(ctx, newScroll, forceUpdate, options) {
   var _a3;
@@ -2057,6 +1844,8 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   state.scroll = newScroll;
   state.scrollTime = currentTime;
   const scrollDelta = Math.abs(newScroll - prevScroll);
+  const isUserScrollEvent = !!(options == null ? void 0 : options.fromNativeScrollEvent) && scrollDelta > 0.1 && !adjustChanged && scrollingTo === void 0 && !state.pendingNativeMVCPAdjust;
+  const allowedEdge = isUserScrollEvent ? beginReachedEdgeUserScroll(ctx, newScroll - prevScroll) : void 0;
   const didResolvePendingNativeMVCPAdjust = resolvePendingNativeMVCPAdjust(ctx, newScroll);
   const scrollLength = state.scrollLength;
   const isLargeUserScrollJump = scrollLength > 0 && scrollingTo === void 0 && scrollDelta > scrollLength && !state.pendingNativeMVCPAdjust;
@@ -2064,7 +1853,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
   updateAdaptiveRender(ctx, scrollVelocity, { forceLight: isLargeUserScrollJump });
   const lastCalculated = state.scrollLastCalculate;
   const useAggressiveItemRecalculation = isInMVCPActiveMode(state);
-  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
+  const shouldUpdate = useAggressiveItemRecalculation || didResolvePendingNativeMVCPAdjust || allowedEdge !== void 0 || forceUpdate || lastCalculated === void 0 || Math.abs(state.scroll - lastCalculated) > 2;
   if (shouldUpdate) {
     state.scrollLastCalculate = state.scroll;
     state.ignoreScrollFromMVCPIgnored = false;
@@ -2079,7 +1868,7 @@ function updateScroll(ctx, newScroll, forceUpdate, options) {
         calculateItemsParams.drawDistanceMode = "visible-first";
       }
       (_a4 = state.triggerCalculateItemsInView) == null ? void 0 : _a4.call(state, calculateItemsParams);
-      checkThresholds(ctx);
+      checkThresholds(ctx, allowedEdge);
     };
     if (isLargeUserScrollJump) {
       state.mvcpAnchorLock = void 0;
@@ -3040,6 +2829,47 @@ function abortBootstrapInitialScroll(ctx) {
   }
 }
 
+// src/core/containerItemMetadata.ts
+function createContainerItemMetadata(state, itemIndex, itemData, itemType) {
+  return {
+    dataChangeEpoch: state.dataChangeEpoch,
+    getFixedItemSize: state.props.getFixedItemSize,
+    getItemType: state.props.getItemType,
+    itemData,
+    itemIndex,
+    itemType
+  };
+}
+function resolveContainerItemMetadata(state, containerId, itemIndex, itemData) {
+  var _a3, _b;
+  const { getFixedItemSize, getItemType } = state.props;
+  const previousMetadata = state.containerItemMetadata.get(containerId);
+  let metadata;
+  if ((previousMetadata == null ? void 0 : previousMetadata.dataChangeEpoch) === state.dataChangeEpoch && previousMetadata.getItemType === getItemType && previousMetadata.itemData === itemData && previousMetadata.itemIndex === itemIndex) {
+    metadata = previousMetadata;
+  } else {
+    const itemType = getItemType ? (_a3 = getItemType(itemData, itemIndex)) != null ? _a3 : "" : void 0;
+    metadata = createContainerItemMetadata(state, itemIndex, itemData, itemType);
+    state.containerItemMetadata.set(containerId, metadata);
+  }
+  if (metadata.getFixedItemSize !== getFixedItemSize) {
+    metadata.didResolveFixedItemSize = false;
+    metadata.fixedItemSize = void 0;
+    metadata.getFixedItemSize = getFixedItemSize;
+  }
+  if (getFixedItemSize && !metadata.didResolveFixedItemSize) {
+    metadata.fixedItemSize = getFixedItemSize(itemData, itemIndex, (_b = metadata.itemType) != null ? _b : "");
+    metadata.didResolveFixedItemSize = true;
+  }
+  return metadata;
+}
+function invalidateContainerFixedItemSizes(state) {
+  for (const metadata of state.containerItemMetadata.values()) {
+    metadata.didResolveFixedItemSize = false;
+    metadata.fixedItemSize = void 0;
+  }
+}
+
 // src/core/checkFinishedScroll.ts
 var INITIAL_SCROLL_MAX_FALLBACK_CHECKS = 20;
 var INITIAL_SCROLL_COMPLETION_TARGET_EPSILON = 1;
@@ -3313,6 +3143,52 @@ function resetLayoutCachesForDataChange(state) {
   state.columnSpans.length = 0;
 }
 
+// src/core/scheduleContainerLayout.ts
+function getContainerLayoutEffectScope(ctx) {
+  var _a3;
+  const scheduledIds = ctx.pendingContainerIds;
+  ctx.pendingContainerIds = void 0;
+  if (scheduledIds === void 0) {
+    return void 0;
+  }
+  const state = ctx.state;
+  let targetContainerIds = scheduledIds;
+  if (targetContainerIds && ((_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys.size)) {
+    targetContainerIds = new Set(targetContainerIds);
+    for (const itemKey of state.userScrollAnchorReset.keys) {
+      const containerId = state.containerItemKeys.get(itemKey);
+      if (containerId !== void 0) {
+        targetContainerIds.add(containerId);
+      }
+    }
+  }
+  return targetContainerIds;
+}
+function scheduleContainerLayout(ctx, target) {
+  var _a3;
+  const isAlreadyScheduled = ctx.pendingContainerIds !== void 0;
+  const previousIds = ctx.pendingContainerIds;
+  if (target === void 0) {
+    ctx.pendingContainerIds = null;
+  } else if (previousIds !== null) {
+    let nextIds = previousIds;
+    if (!nextIds) {
+      nextIds = typeof target === "number" ? /* @__PURE__ */ new Set([target]) : new Set(target);
+    } else if (typeof target === "number") {
+      nextIds.add(target);
+    } else {
+      for (const containerId of target) {
+        nextIds.add(containerId);
+      }
+    }
+    ctx.pendingContainerIds = nextIds;
+  }
+  if (!isAlreadyScheduled) {
+    const nextEpoch = ((_a3 = peek$(ctx, "containerLayoutEpoch")) != null ? _a3 : 0) + 1;
+    set$(ctx, "containerLayoutEpoch", nextEpoch);
+  }
+}
+
 // src/core/syncMountedContainer.ts
 function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
   var _a3, _b, _c, _d, _e, _f, _g, _h, _i;
@@ -3356,22 +3232,27 @@ function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
       set$(ctx, `containerSpan${containerIndex}`, span);
     }
   }
+  const prevIndex = peek$(ctx, `containerItemIndex${containerIndex}`);
+  if (prevIndex !== itemIndex) {
+    set$(ctx, `containerItemIndex${containerIndex}`, itemIndex);
+  }
   const prevData = peek$(ctx, `containerItemData${containerIndex}`);
+  const updateData = () => {
+    set$(ctx, `containerItemData${containerIndex}`, item);
+    didRefreshData = true;
+  };
   if (prevData !== item) {
     const pendingDataComparison = ((_e = state.pendingDataComparison) == null ? void 0 : _e.previousData) === state.previousData && ((_f = state.pendingDataComparison) == null ? void 0 : _f.nextData) === data ? state.pendingDataComparison : void 0;
     const cachedComparison = (_g = pendingDataComparison == null ? void 0 : pendingDataComparison.byIndex[itemIndex]) != null ? _g : 0;
     if (cachedComparison === 2) {
-      set$(ctx, `containerItemData${containerIndex}`, item);
-      didRefreshData = true;
+      updateData();
     } else if (cachedComparison !== 1) {
       const nextItemKey = (_h = peek$(ctx, `containerItemKey${containerIndex}`)) != null ? _h : itemKey;
       const prevKey = keyExtractor == null ? void 0 : keyExtractor(prevData, itemIndex);
       if (prevData === void 0 || !keyExtractor || prevKey !== nextItemKey) {
-        set$(ctx, `containerItemData${containerIndex}`, item);
-        didRefreshData = true;
+        updateData();
       } else if (!itemsAreEqual) {
-        set$(ctx, `containerItemData${containerIndex}`, item);
-        didRefreshData = true;
+        updateData();
       } else {
         const isEqual = itemsAreEqual(prevData, item, itemIndex, data);
         if (!state.pendingDataComparison || state.pendingDataComparison.previousData !== state.previousData || state.pendingDataComparison.nextData !== data) {
@@ -3387,8 +3268,7 @@ function syncMountedContainer(ctx, containerIndex, itemIndex, options) {
           state.pendingDataComparison.byIndex[itemIndex] = isEqual ? 1 : 2;
         }
         if (!isEqual) {
-          set$(ctx, `containerItemData${containerIndex}`, item);
-          didRefreshData = true;
+          updateData();
         }
       }
     }
@@ -3757,19 +3637,29 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, stat
   if (previousViewableItems) {
     for (const viewToken of previousViewableItems) {
       previousViewableKeys.add(viewToken.key);
+      const currentIndex = state.indexByKey.get(viewToken.key);
+      const currentItem = currentIndex !== void 0 ? data[currentIndex] : void 0;
       const containerId = findContainerId(ctx, viewToken.key);
-      if (!checkIsViewable(
-        state,
-        ctx,
-        viewabilityConfig,
-        containerId,
-        viewToken.key,
-        scrollSize,
-        viewToken.item,
-        viewToken.index
-      )) {
-        viewToken.isViewable = false;
-        changed.push(viewToken);
+      let isStillViewable = false;
+      if (currentIndex !== void 0 && currentItem !== void 0) {
+        isStillViewable = checkIsViewable(
+          state,
+          ctx,
+          viewabilityConfig,
+          containerId,
+          viewToken.key,
+          scrollSize,
+          currentItem,
+          currentIndex
+        );
+      }
+      if (!isStillViewable) {
+        changed.push({
+          ...viewToken,
+          index: currentIndex != null ? currentIndex : viewToken.index,
+          isViewable: false,
+          item: currentItem != null ? currentItem : viewToken.item
+        });
       }
     }
   }
@@ -3926,128 +3816,102 @@ function getExpandedContainerPoolSize(dataLength, numContainers) {
 
 // src/utils/findAvailableContainers.ts
 function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffered, pendingRemoval, getRequiredItemType, protectedKeys) {
+  var _a3;
   const numNeeded = needNewContainers.length;
   if (numNeeded === 0) {
     return [];
   }
   const numContainers = peek$(ctx, "numContainers");
   const state = ctx.state;
-  const { stickyContainerPool, containerItemTypes } = state;
+  const { containerItemMetadata, stickyContainerPool } = state;
   const shouldAvoidAssignedContainerReuse = state.props.recycleItems && !!state.props.positionComponentInternal;
-  const allocations = [];
   const pendingRemovalSet = pendingRemoval.length > 0 ? new Set(pendingRemoval) : void 0;
-  let pendingRemovalChanged = false;
+  const requests = needNewContainers.map((itemIndex, order) => ({
+    isSticky: state.props.stickyHeaderIndicesSet.has(itemIndex),
+    itemIndex,
+    itemType: getRequiredItemType == null ? void 0 : getRequiredItemType(itemIndex),
+    order
+  }));
+  const normalRequests = requests.filter((request) => !request.isSticky);
+  const stickyRequests = requests.filter((request) => request.isSticky);
+  const normalCandidates = [];
+  const stickyCandidates = [];
+  for (let containerIndex = 0; containerIndex < numContainers; containerIndex++) {
+    const key = peek$(ctx, `containerItemKey${containerIndex}`);
+    const isPendingRemoval = !!(pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(containerIndex));
+    const isProtected = !!key && !!(protectedKeys == null ? void 0 : protectedKeys.has(key)) && state.indexByKey.has(key);
+    if (isProtected) {
+      continue;
+    }
+    if (stickyContainerPool.has(containerIndex)) {
+      if (key === void 0 || isPendingRemoval) {
+        stickyCandidates.push({ containerIndex, distance: Number.POSITIVE_INFINITY });
+      }
+    } else if (key === void 0 || isPendingRemoval) {
+      normalCandidates.push({ containerIndex, distance: Number.POSITIVE_INFINITY });
+    } else if (!shouldAvoidAssignedContainerReuse) {
+      const index = state.indexByKey.get(key);
+      if (index !== void 0 && (index < startBuffered || index > endBuffered)) {
+        const distance = index < startBuffered ? startBuffered - index : index - endBuffered;
+        normalCandidates.push({ containerIndex, distance });
+      }
+    }
+  }
+  normalCandidates.sort(comparatorByDistance);
+  const allocations = new Array(numNeeded);
   let nextNewContainerIndex = numContainers;
-  const usedContainers = /* @__PURE__ */ new Set();
-  let availableContainers;
-  const stickyHeaderIndicesSet = state.props.stickyHeaderIndicesSet;
-  const canReuseContainer = (containerIndex, requiredType) => {
-    if (!requiredType) return true;
-    const existingType = containerItemTypes.get(containerIndex);
-    if (!existingType) return true;
-    return existingType === requiredType;
-  };
-  const pushAllocation = (itemIndex, itemType, containerIndex) => {
-    allocations.push({
+  let pendingRemovalChanged = false;
+  const assign = (request, containerIndex) => {
+    allocations[request.order] = {
       containerIndex,
-      itemIndex,
-      itemType
-    });
-    usedContainers.add(containerIndex);
+      itemIndex: request.itemIndex,
+      itemType: request.itemType
+    };
     if (pendingRemovalSet == null ? void 0 : pendingRemovalSet.delete(containerIndex)) {
       pendingRemovalChanged = true;
     }
   };
-  const pushNewContainer = (itemIndex, itemType, isSticky) => {
-    const newContainerIndex = nextNewContainerIndex++;
-    pushAllocation(itemIndex, itemType, newContainerIndex);
-    if (isSticky) {
-      stickyContainerPool.add(newContainerIndex);
-    }
-    return newContainerIndex;
-  };
-  const canUseContainer = (containerIndex, itemType) => {
-    if (usedContainers.has(containerIndex) || stickyContainerPool.has(containerIndex)) {
-      return false;
-    }
-    const key = peek$(ctx, `containerItemKey${containerIndex}`);
-    const isPending = !!(pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(containerIndex));
-    return (key === void 0 || isPending) && canReuseContainer(containerIndex, itemType);
-  };
-  const findStickyContainer = (itemType) => {
-    let foundContainer;
-    for (const containerIndex of stickyContainerPool) {
-      if (!usedContainers.has(containerIndex)) {
-        const key = peek$(ctx, `containerItemKey${containerIndex}`);
-        const isPendingRemoval = !!(pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(containerIndex));
-        if ((key === void 0 || isPendingRemoval) && canReuseContainer(containerIndex, itemType)) {
-          foundContainer = containerIndex;
-          break;
-        }
-      }
-    }
-    return foundContainer;
-  };
-  const findUnassignedOrPendingContainer = (itemType) => {
-    let foundContainer;
-    for (let containerIndex = 0; containerIndex < numContainers && foundContainer === void 0; containerIndex++) {
-      if (canUseContainer(containerIndex, itemType)) {
-        foundContainer = containerIndex;
+  const assignMatching = (pendingRequests, candidates, matches) => {
+    for (const request of pendingRequests) {
+      if (allocations[request.order]) {
+        continue;
       }
-    }
-    return foundContainer;
-  };
-  const getAvailableContainers = () => {
-    if (!availableContainers) {
-      availableContainers = [];
-      if (!shouldAvoidAssignedContainerReuse) {
-        for (let containerIndex = 0; containerIndex < numContainers; containerIndex++) {
-          if (usedContainers.has(containerIndex) || stickyContainerPool.has(containerIndex)) {
-            continue;
-          }
-          const key = peek$(ctx, `containerItemKey${containerIndex}`);
-          if (key === void 0) continue;
-          if ((protectedKeys == null ? void 0 : protectedKeys.has(key)) && state.indexByKey.has(key)) continue;
-          const index = state.indexByKey.get(key);
-          const isOutOfView = index < startBuffered || index > endBuffered;
-          if (isOutOfView) {
-            const distance = index < startBuffered ? startBuffered - index : index - endBuffered;
-            availableContainers.push({ distance, index: containerIndex });
-          }
+      const candidateIndex = candidates.findIndex(
+        (candidate) => {
+          var _a4;
+          return matches((_a4 = containerItemMetadata.get(candidate.containerIndex)) == null ? void 0 : _a4.itemType, request.itemType);
         }
-        availableContainers.sort(comparatorByDistance);
+      );
+      if (candidateIndex !== -1) {
+        const [candidate] = candidates.splice(candidateIndex, 1);
+        assign(request, candidate.containerIndex);
       }
     }
-    return availableContainers;
   };
-  const findAvailableContainer = (itemType) => {
-    const containers = getAvailableContainers();
-    let matchIndex = -1;
-    for (let i = 0; i < containers.length && matchIndex === -1; i++) {
-      const containerIndex = containers[i].index;
-      if (!usedContainers.has(containerIndex) && canReuseContainer(containerIndex, itemType)) {
-        matchIndex = i;
-      }
+  const assignFromPool = (pendingRequests, candidates, allowCrossType) => {
+    if (getRequiredItemType) {
+      assignMatching(
+        pendingRequests,
+        candidates,
+        (containerType, requestType) => requestType !== void 0 && containerType === requestType
+      );
+    }
+    assignMatching(pendingRequests, candidates, (containerType) => containerType === void 0);
+    if (allowCrossType) {
+      assignMatching(pendingRequests, candidates, () => true);
     }
-    return matchIndex === -1 ? void 0 : containers.splice(matchIndex, 1)[0].index;
   };
-  for (const itemIndex of needNewContainers) {
-    const itemType = getRequiredItemType == null ? void 0 : getRequiredItemType(itemIndex);
-    const isSticky = stickyHeaderIndicesSet.has(itemIndex);
-    let containerIndex;
-    if (isSticky) {
-      containerIndex = findStickyContainer(itemType);
-    } else {
-      containerIndex = findUnassignedOrPendingContainer(itemType);
-      if (containerIndex === void 0) {
-        containerIndex = findAvailableContainer(itemType);
-      }
+  assignFromPool(normalRequests, normalCandidates, true);
+  assignFromPool(stickyRequests, stickyCandidates, false);
+  for (const request of requests) {
+    if (allocations[request.order]) {
+      continue;
     }
-    if (containerIndex !== void 0) {
-      pushAllocation(itemIndex, itemType, containerIndex);
-    } else {
-      pushNewContainer(itemIndex, itemType, isSticky);
+    const containerIndex = nextNewContainerIndex++;
+    if (request.isSticky) {
+      stickyContainerPool.add(containerIndex);
     }
+    assign(request, containerIndex);
   }
   if (pendingRemovalChanged) {
     pendingRemoval.length = 0;
@@ -4057,18 +3921,21 @@ function findAvailableContainers(ctx, needNewContainers, startBuffered, endBuffe
       }
     }
   }
-  if (IS_DEV && nextNewContainerIndex > peek$(ctx, "numContainersPooled")) {
-    console.warn(
-      "[legend-list] No unused container available, so creating one on demand. This can be a minor performance issue and is likely caused by the estimatedItemSize being too large. Consider decreasing estimatedItemSize.",
-      {
-        debugInfo: {
-          numContainers,
-          numContainersPooled: peek$(ctx, "numContainersPooled"),
-          numNeeded,
-          stillNeeded: nextNewContainerIndex - numContainers
+  if (IS_DEV) {
+    const numContainersPooled = (_a3 = peek$(ctx, "numContainersPooled")) != null ? _a3 : Number.POSITIVE_INFINITY;
+    if (nextNewContainerIndex > numContainersPooled) {
+      console.warn(
+        "[legend-list] No unused container available, so creating one on demand. This can be a minor performance issue and is likely caused by the estimatedItemSize being too large. Consider decreasing estimatedItemSize.",
+        {
+          debugInfo: {
+            numContainers,
+            numContainersPooled,
+            numNeeded,
+            stillNeeded: nextNewContainerIndex - numContainers
+          }
         }
-      }
-    );
+      );
+    }
   }
   return allocations;
 }
@@ -4303,7 +4170,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, _p, _q, _r, _s, _t;
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
     const {
       columns,
       containerItemKeys,
@@ -4331,6 +4198,7 @@ function calculateItemsInView(ctx, params = {}) {
       return;
     }
     let totalSize = getContentSize(ctx);
+    let changedContainerIds;
     const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "alignItemsAtEndPadding") + peek$(ctx, "headerSize");
     const numColumns = peek$(ctx, "numColumns");
     const speed = (_b = params.scrollVelocity) != null ? _b : getScrollVelocity(state);
@@ -4456,7 +4324,7 @@ function calculateItemsInView(ctx, params = {}) {
     const scrollAdjustPendingBeforeMVCP = (_f = peek$(ctx, "scrollAdjustPending")) != null ? _f : 0;
     checkMVCP == null ? void 0 : checkMVCP();
     const didMVCPAdjustScroll = !!checkMVCP && (state.scroll !== scrollBeforeMVCP || ((_g = peek$(ctx, "scrollAdjustPending")) != null ? _g : 0) !== scrollAdjustPendingBeforeMVCP);
-    if (didMVCPAdjustScroll && (initialScroll || state.scrollingTo)) {
+    if (didMVCPAdjustScroll) {
       updateScroll2(state.scroll);
       updateScrollRange();
     }
@@ -4636,17 +4504,20 @@ function calculateItemsInView(ctx, params = {}) {
           if (oldKey && oldKey !== id) {
             containerItemKeys.delete(oldKey);
           }
+          if (oldKey !== id) {
+            changedContainerIds != null ? changedContainerIds : changedContainerIds = /* @__PURE__ */ new Set();
+            changedContainerIds.add(containerIndex);
+            state.containerItemGenerations[containerIndex] = ((_p = state.containerItemGenerations[containerIndex]) != null ? _p : 0) + 1;
+          }
           set$(ctx, `containerItemKey${containerIndex}`, id);
+          set$(ctx, `containerItemIndex${containerIndex}`, i);
           set$(ctx, `containerItemData${containerIndex}`, data[i]);
-          if (allocation.itemType !== void 0) {
-            state.containerItemTypes.set(containerIndex, allocation.itemType);
-          }
+          state.containerItemMetadata.set(
+            containerIndex,
+            createContainerItemMetadata(state, i, data[i], allocation.itemType)
+          );
           containerItemKeys.set(id, containerIndex);
-          (_p = state.userScrollAnchorReset) == null ? void 0 : _p.keys.add(id);
-          {
-            (_q = state.pendingLayoutEffectMeasurements) != null ? _q : state.pendingLayoutEffectMeasurements = /* @__PURE__ */ new Set();
-            state.pendingLayoutEffectMeasurements.add(id);
-          }
+          (_q = state.userScrollAnchorReset) == null ? void 0 : _q.keys.add(id);
           const containerSticky = `containerSticky${containerIndex}`;
           const isSticky = stickyHeaderIndicesSet.has(i);
           const isPinnedRender = isPinnedRenderIndex(i);
@@ -4696,13 +4567,17 @@ function calculateItemsInView(ctx, params = {}) {
       if (pendingRemovalSet == null ? void 0 : pendingRemovalSet.has(i)) {
         if (itemKey !== void 0) {
           containerItemKeys.delete(itemKey);
+          changedContainerIds != null ? changedContainerIds : changedContainerIds = /* @__PURE__ */ new Set();
+          changedContainerIds.add(i);
+          state.containerItemGenerations[i] = ((_t = state.containerItemGenerations[i]) != null ? _t : 0) + 1;
         }
-        state.containerItemTypes.delete(i);
+        state.containerItemMetadata.delete(i);
         if (state.stickyContainerPool.has(i)) {
           set$(ctx, `containerSticky${i}`, false);
           state.stickyContainerPool.delete(i);
         }
         set$(ctx, `containerItemKey${i}`, void 0);
+        set$(ctx, `containerItemIndex${i}`, void 0);
         set$(ctx, `containerItemData${i}`, void 0);
         set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
         set$(ctx, `containerColumn${i}`, -1);
@@ -4717,6 +4592,9 @@ function calculateItemsInView(ctx, params = {}) {
         }
       }
     }
+    if (changedContainerIds && (IsNewArchitecture)) {
+      scheduleContainerLayout(ctx, changedContainerIds);
+    }
     if (didChangePositions) {
       set$(ctx, "lastPositionUpdate", Date.now());
     }
@@ -4733,20 +4611,18 @@ function calculateItemsInView(ctx, params = {}) {
       }
     }
     if (viewabilityConfigCallbackPairs && visibleRange.startNoBuffer !== null && visibleRange.endNoBuffer !== null) {
-      if (!didMVCPAdjustScroll) {
-        updateViewableItems(
-          ctx.state,
-          ctx,
-          viewabilityConfigCallbackPairs,
-          scrollLength,
-          visibleRange.startNoBuffer,
-          visibleRange.endNoBuffer,
-          startBuffered != null ? startBuffered : visibleRange.startNoBuffer,
-          endBuffered != null ? endBuffered : visibleRange.endNoBuffer
-        );
-      }
+      updateViewableItems(
+        ctx.state,
+        ctx,
+        viewabilityConfigCallbackPairs,
+        scrollLength,
+        visibleRange.startNoBuffer,
+        visibleRange.endNoBuffer,
+        startBuffered != null ? startBuffered : visibleRange.startNoBuffer,
+        endBuffered != null ? endBuffered : visibleRange.endNoBuffer
+      );
     }
-    (_t = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _t.call(stickyState);
+    (_u = stickyState == null ? void 0 : stickyState.finishCalculateItemsInView) == null ? void 0 : _u.call(stickyState);
   });
 }
 
@@ -4838,228 +4714,516 @@ function updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal) {
       set$(ctx, "otherAxisSize", otherAxisSize);
     }
   }
-}
-function mergeItemSizeUpdateResult(result, next) {
-  result.didChange || (result.didChange = next.didChange);
-  result.didMeasureUserScrollAnchorResetItem || (result.didMeasureUserScrollAnchorResetItem = next.didMeasureUserScrollAnchorResetItem);
-  result.needsRecalculate || (result.needsRecalculate = next.needsRecalculate);
-  result.shouldMaintainScrollAtEnd || (result.shouldMaintainScrollAtEnd = next.shouldMaintainScrollAtEnd);
-}
-var batchedItemSizeRecalculates = /* @__PURE__ */ new WeakMap();
-function flushBatchedItemSizeRecalculate(ctx, didFallback = false, expectedResult) {
-  const result = batchedItemSizeRecalculates.get(ctx);
-  if (!result || expectedResult && result !== expectedResult) {
-    return;
-  }
-  batchedItemSizeRecalculates.delete(ctx);
-  if (didFallback) {
-    ctx.state.pendingLayoutEffectMeasurements = void 0;
+}
+var activeItemSizeBatches;
+function batchItemSizeUpdates(runUpdates) {
+  const isOuterBatch = activeItemSizeBatches === void 0;
+  activeItemSizeBatches != null ? activeItemSizeBatches : activeItemSizeBatches = /* @__PURE__ */ new Map();
+  try {
+    runUpdates();
+  } finally {
+    if (isOuterBatch) {
+      const batches = activeItemSizeBatches;
+      activeItemSizeBatches = void 0;
+      for (const [ctx, measurements] of batches) {
+        updateItemSizesBatch(ctx, measurements);
+      }
+    }
+  }
+}
+function mergeItemSizeUpdateResult(result, next) {
+  result.didChange || (result.didChange = next.didChange);
+  result.didMeasureUserScrollAnchorResetItem || (result.didMeasureUserScrollAnchorResetItem = next.didMeasureUserScrollAnchorResetItem);
+  result.needsRecalculate || (result.needsRecalculate = next.needsRecalculate);
+  result.shouldMaintainScrollAtEnd || (result.shouldMaintainScrollAtEnd = next.shouldMaintainScrollAtEnd);
+}
+function flushItemSizeUpdates(ctx, result) {
+  var _a3;
+  const state = ctx.state;
+  if (result.needsRecalculate) {
+    state.scrollForNextCalculateItemsInView = void 0;
+    runOrScheduleMVCPRecalculate(ctx);
+  } else if (result.didMeasureUserScrollAnchorResetItem && ((_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys.size) === 0) {
+    state.userScrollAnchorReset = void 0;
+  }
+  if (result.didChange && result.shouldMaintainScrollAtEnd) {
+    doMaintainScrollAtEnd(ctx);
+  }
+}
+function updateItemSizes(ctx, measurement) {
+  if (activeItemSizeBatches) {
+    const measurements = activeItemSizeBatches.get(ctx);
+    if (measurements) {
+      measurements.push(measurement);
+    } else {
+      activeItemSizeBatches.set(ctx, [measurement]);
+    }
+  } else {
+    updateItemSizesBatch(ctx, [measurement]);
+  }
+}
+function updateItemSizesBatch(ctx, measurements) {
+  var _a3;
+  const state = ctx.state;
+  const result = {};
+  for (const measurement of measurements) {
+    const ownsMeasuredItem = measurement.containerId === void 0 || peek$(ctx, `containerItemKey${measurement.containerId}`) === measurement.itemKey;
+    if (ownsMeasuredItem) {
+      const index = state.indexByKey.get(measurement.itemKey);
+      const itemData = index === void 0 ? void 0 : (_a3 = state.props.data) == null ? void 0 : _a3[index];
+      const metadata = measurement.containerId !== void 0 && index !== void 0 && itemData !== void 0 ? resolveContainerItemMetadata(state, measurement.containerId, index, itemData) : void 0;
+      const nextResult = applyItemSize(ctx, measurement.itemKey, measurement.size, metadata);
+      mergeItemSizeUpdateResult(result, nextResult);
+    }
+  }
+  flushItemSizeUpdates(ctx, result);
+}
+function applyItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
+  var _a3, _b;
+  const state = ctx.state;
+  const userScrollAnchorReset = state.userScrollAnchorReset;
+  const didMeasureUserScrollAnchorResetItem = !!(userScrollAnchorReset == null ? void 0 : userScrollAnchorReset.keys.delete(itemKey));
+  const {
+    didContainersLayout,
+    sizesKnown,
+    props: { getFixedItemSize, getItemType, horizontal, onItemSizeChanged, data, maintainScrollAtEnd }
+  } = state;
+  if (!data) return { didMeasureUserScrollAnchorResetItem };
+  const index = state.indexByKey.get(itemKey);
+  if (getFixedItemSize) {
+    if (index === void 0) {
+      return { didMeasureUserScrollAnchorResetItem };
+    }
+    const itemData = state.props.data[index];
+    if (itemData === void 0) {
+      return { didMeasureUserScrollAnchorResetItem };
+    }
+    if (!(resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize)) {
+      const type = (_b = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemType) != null ? _b : getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
+      resolvedMeasurementItem = {
+        didResolveFixedItemSize: true,
+        fixedItemSize: getFixedItemSize(itemData, index, type),
+        itemType: type
+      };
+    }
+    const size2 = resolvedMeasurementItem.fixedItemSize;
+    if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
+      updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
+      return { didMeasureUserScrollAnchorResetItem };
+    }
+  }
+  let needsRecalculate = !didContainersLayout;
+  let shouldMaintainScrollAtEnd = false;
+  let minIndexSizeChanged;
+  const prevSizeKnown = state.sizesKnown.get(itemKey);
+  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem);
+  const size = roundSize(horizontal ? sizeObj.width : sizeObj.height);
+  if (diff !== 0) {
+    minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+    const { startBuffered, endBuffered } = state;
+    needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
+    if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
+      needsRecalculate = true;
+    }
+    if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
+      shouldMaintainScrollAtEnd = true;
+    }
+    onItemSizeChanged == null ? void 0 : onItemSizeChanged({
+      index,
+      itemData: state.props.data[index],
+      itemKey,
+      previous: size - diff,
+      size
+    });
+    maybeUpdateAnchoredEndSpace(ctx);
+  }
+  if (minIndexSizeChanged !== void 0) {
+    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
+  }
+  updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
+  if (didContainersLayout || checkAllSizesKnown(state, state.startBuffered, state.endBuffered)) {
+    const canMaintainScrollAtEnd = shouldMaintainScrollAtEnd && !!(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onItemLayout);
+    return {
+      didChange: diff !== 0,
+      didMeasureUserScrollAnchorResetItem,
+      needsRecalculate,
+      shouldMaintainScrollAtEnd: canMaintainScrollAtEnd
+    };
+  }
+  return {
+    didChange: diff !== 0,
+    didMeasureUserScrollAnchorResetItem
+  };
+}
+function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
+  var _a3, _b;
+  const state = ctx.state;
+  const {
+    indexByKey,
+    sizesKnown,
+    averageSizes,
+    props: { data, horizontal, getItemType, getFixedItemSize }
+  } = state;
+  if (!data) return 0;
+  const index = indexByKey.get(itemKey);
+  const itemData = data[index];
+  let itemType = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemType;
+  let fixedItemSize = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.fixedItemSize;
+  if (getFixedItemSize && !(resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize)) {
+    itemType = getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
+    fixedItemSize = getFixedItemSize(itemData, index, itemType);
+  }
+  const resolvedItemSize = (resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize) || itemType !== void 0 || fixedItemSize !== void 0 ? {
+    didResolveFixedItemSize: resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize,
+    fixedItemSize,
+    itemType
+  } : void 0;
+  const prevSize = getItemSize(ctx, itemKey, index, itemData, void 0, void 0, void 0, resolvedItemSize);
+  const rawSize = horizontal ? sizeObj.width : sizeObj.height;
+  const prevSizeKnown = sizesKnown.get(itemKey);
+  const size = Math.round(rawSize) ;
+  sizesKnown.set(itemKey, size);
+  if (fixedItemSize === void 0 && size > 0) {
+    itemType != null ? itemType : itemType = getItemType ? (_b = getItemType(itemData, index)) != null ? _b : "" : "";
+    let averages = averageSizes[itemType];
+    if (!averages) {
+      averages = averageSizes[itemType] = { avg: 0, num: 0 };
+    }
+    if (averages.num === 0) {
+      averages.avg = size;
+      averages.num++;
+    } else if (prevSizeKnown !== void 0 && prevSizeKnown > 0) {
+      averages.avg += (size - prevSizeKnown) / averages.num;
+    } else {
+      averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
+      averages.num++;
+    }
+  }
+  if (!prevSize || Math.abs(prevSize - size) > 0.1) {
+    setSize(ctx, itemKey, size);
+    return size - prevSize;
   }
-  flushItemSizeUpdates(ctx, result);
+  return 0;
 }
-function queueItemSizeRecalculate(ctx, result) {
-  var _a3, _b;
-  const batch = batchedItemSizeRecalculates.get(ctx);
-  if (batch) {
-    mergeItemSizeUpdateResult(batch, result);
-  } else {
-    const nextBatch = { ...result };
-    batchedItemSizeRecalculates.set(ctx, nextBatch);
-    if ((_a3 = ctx.state.pendingLayoutEffectMeasurements) == null ? void 0 : _a3.size) {
-      requestAnimationFrame(() => {
-        flushBatchedItemSizeRecalculate(ctx, true, nextBatch);
+
+// src/core/measureContainersInLayoutEffect.ts
+function measureContainersInLayoutEffect(ctx, targetContainerIds = null) {
+  const measurements = [];
+  const containerIds = targetContainerIds != null ? targetContainerIds : ctx.viewRefs.keys();
+  for (const containerId of containerIds) {
+    const viewRef = ctx.viewRefs.get(containerId);
+    const itemKey = peek$(ctx, `containerItemKey${containerId}`);
+    const element = viewRef == null ? void 0 : viewRef.current;
+    if (itemKey !== void 0 && element) {
+      const rect = element.getBoundingClientRect();
+      setContainerLayoutBaseline(element, rect);
+      measurements.push({
+        containerId,
+        itemKey,
+        size: { height: rect.height, width: rect.width }
       });
     }
   }
-  if (!((_b = ctx.state.pendingLayoutEffectMeasurements) == null ? void 0 : _b.size)) {
-    flushBatchedItemSizeRecalculate(ctx);
-  }
-}
-function flushItemSizeUpdates(ctx, result) {
-  var _a3;
-  const state = ctx.state;
-  if (result.needsRecalculate) {
-    state.scrollForNextCalculateItemsInView = void 0;
-    runOrScheduleMVCPRecalculate(ctx);
-  } else if (result.didMeasureUserScrollAnchorResetItem && ((_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys.size) === 0) {
-    state.userScrollAnchorReset = void 0;
-  }
-  if (result.didChange && result.shouldMaintainScrollAtEnd) {
-    doMaintainScrollAtEnd(ctx);
+  if (measurements.length > 0) {
+    updateItemSizesBatch(ctx, measurements);
   }
 }
-function updateItemSizes(ctx, measurement) {
-  var _a3, _b, _c, _d;
-  const state = ctx.state;
-  let didDrainLayoutEffectMeasurements = false;
-  if (measurement.fromLayoutEffect) {
-    const pendingLayoutEffectMeasurements = state.pendingLayoutEffectMeasurements;
-    if ((pendingLayoutEffectMeasurements == null ? void 0 : pendingLayoutEffectMeasurements.delete(measurement.itemKey)) && pendingLayoutEffectMeasurements.size === 0) {
-      state.pendingLayoutEffectMeasurements = void 0;
-      didDrainLayoutEffectMeasurements = true;
-    }
-  }
-  const pendingKeys = (_a3 = state.userScrollAnchorReset) == null ? void 0 : _a3.keys;
-  const shouldBatchPendingMeasurements = measurement.fromLayoutEffect && !!(pendingKeys == null ? void 0 : pendingKeys.size);
-  const shouldQueueRecalculate = !!measurement.fromLayoutEffect;
-  let result;
-  if (!shouldBatchPendingMeasurements) {
-    result = applyItemSize(ctx, measurement.itemKey, measurement.size);
-  } else {
-    result = {};
-    const updateContainerItemSize = (itemKey, containerId, size) => {
-      if (containerId !== void 0 && peek$(ctx, `containerItemKey${containerId}`) === itemKey) {
-        mergeItemSizeUpdateResult(result, applyItemSize(ctx, itemKey, size));
-      }
-    };
-    updateContainerItemSize(measurement.itemKey, measurement.containerId, measurement.size);
-    const keys = Array.from(pendingKeys);
-    for (const itemKey of keys) {
-      const containerId = state.containerItemKeys.get(itemKey);
-      if (containerId !== void 0) {
-        (_d = (_c = (_b = ctx.viewRefs.get(containerId)) == null ? void 0 : _b.current) == null ? void 0 : _c.measure) == null ? void 0 : _d.call(_c, (_x, _y, width, height) => {
-          if (pendingKeys.has(itemKey)) {
-            updateContainerItemSize(itemKey, containerId, { height, width });
-          }
-        });
+var typedForwardRef = React3__namespace.forwardRef;
+var typedMemo = React3__namespace.memo;
+
+// src/components/ContainerLayoutCoordinator.tsx
+var ContainerLayoutCoordinator = typedMemo(function ContainerLayoutCoordinatorComponent({
+  children
+}) {
+  const ctx = useStateContext();
+  const [containerLayoutEpoch] = useArr$(["containerLayoutEpoch"]);
+  React3__namespace.useLayoutEffect(() => {
+    {
+      const targetContainerIds = getContainerLayoutEffectScope(ctx);
+      if (targetContainerIds !== void 0) {
+        measureContainersInLayoutEffect(ctx, targetContainerIds);
       }
     }
+  }, [ctx, containerLayoutEpoch]);
+  return children;
+});
+var getComponent = (Component) => {
+  if (React3__namespace.isValidElement(Component)) {
+    return Component;
   }
-  if (shouldQueueRecalculate && result.needsRecalculate) {
-    queueItemSizeRecalculate(ctx, result);
-  } else {
-    flushItemSizeUpdates(ctx, result);
-  }
-  if (didDrainLayoutEffectMeasurements) {
-    flushBatchedItemSizeRecalculate(ctx);
+  if (Component) {
+    return /* @__PURE__ */ React3__namespace.createElement(Component, null);
   }
+  return null;
+};
+
+// src/components/PositionView.tsx
+var isRNWeb = typeof document !== "undefined" && !!document.getElementById("react-native-stylesheet");
+var baseCss = {
+  contain: "paint layout style",
+  ...isRNWeb ? {
+    display: "flex",
+    flexDirection: "column"
+  } : {}
+};
+var PositionViewState = typedMemo(function PositionViewState2({
+  id,
+  horizontal,
+  style,
+  refView,
+  ...props
+}) {
+  const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
+  const composed = isArray(style) ? Object.assign({}, ...style) : style;
+  const combinedStyle = horizontal ? { ...baseCss, ...composed, left: position } : { ...baseCss, ...composed, top: position };
+  const {
+    animatedScrollY: _animatedScrollY,
+    onLayout: _onLayout,
+    onLayoutChange: _onLayoutChange,
+    stickyHeaderConfig: _stickyHeaderConfig,
+    ...webProps
+  } = props;
+  return /* @__PURE__ */ React3__namespace.createElement("div", { ref: refView, ...webProps, style: combinedStyle });
+});
+var PositionViewSticky = typedMemo(function PositionViewSticky2({
+  id,
+  horizontal,
+  style,
+  refView,
+  animatedScrollY: _animatedScrollY,
+  stickyHeaderConfig,
+  onLayout: _onLayout,
+  onLayoutChange: _onLayoutChange,
+  children,
+  ...webProps
+}) {
+  const [position = POSITION_OUT_OF_VIEW, activeStickyIndex, itemIndex] = useArr$([
+    `containerPosition${id}`,
+    "activeStickyIndex",
+    `containerItemIndex${id}`
+  ]);
+  const composed = React3__namespace.useMemo(
+    () => {
+      var _a3;
+      return (_a3 = isArray(style) ? Object.assign({}, ...style) : style) != null ? _a3 : {};
+    },
+    [style]
+  );
+  const viewStyle = React3__namespace.useMemo(() => {
+    var _a3;
+    const styleBase = { ...baseCss, ...composed };
+    delete styleBase.transform;
+    const offset = (_a3 = stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset) != null ? _a3 : 0;
+    const isActive = activeStickyIndex === itemIndex;
+    styleBase.position = isActive ? "sticky" : "absolute";
+    styleBase.zIndex = itemIndex + 1e3;
+    if (horizontal) {
+      styleBase.left = isActive ? offset : position;
+    } else {
+      styleBase.top = isActive ? offset : position;
+    }
+    return styleBase;
+  }, [composed, horizontal, position, itemIndex, activeStickyIndex, stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.offset]);
+  const renderStickyHeaderBackdrop = React3__namespace.useMemo(
+    () => (stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent) ? /* @__PURE__ */ React3__namespace.createElement(
+      "div",
+      {
+        style: {
+          inset: 0,
+          pointerEvents: "none",
+          position: "absolute"
+        }
+      },
+      getComponent(stickyHeaderConfig.backdropComponent)
+    ) : null,
+    [stickyHeaderConfig == null ? void 0 : stickyHeaderConfig.backdropComponent]
+  );
+  return /* @__PURE__ */ React3__namespace.createElement("div", { ref: refView, style: viewStyle, ...webProps }, renderStickyHeaderBackdrop, children);
+});
+var PositionView = PositionViewState;
+function useInit(cb) {
+  React3.useState(() => cb());
+}
+
+// src/state/ContextContainer.ts
+var ContextContainer = React3.createContext(null);
+var NO_CONTAINER_ID = -1;
+function useContextContainer() {
+  return React3.useContext(ContextContainer);
 }
-function applyItemSize(ctx, itemKey, sizeObj) {
+function useContainerItemSignals(containerContext) {
   var _a3;
-  const state = ctx.state;
-  const userScrollAnchorReset = state.userScrollAnchorReset;
-  const didMeasureUserScrollAnchorResetItem = !!(userScrollAnchorReset == null ? void 0 : userScrollAnchorReset.keys.delete(itemKey));
-  const {
-    didContainersLayout,
-    sizesKnown,
-    props: { getFixedItemSize, getItemType, horizontal, onItemSizeChanged, data, maintainScrollAtEnd }
-  } = state;
-  if (!data) return { didMeasureUserScrollAnchorResetItem };
-  const index = state.indexByKey.get(itemKey);
-  let resolvedMeasurementItem;
-  if (getFixedItemSize) {
-    if (index === void 0) {
-      return { didMeasureUserScrollAnchorResetItem };
+  const containerId = (_a3 = containerContext == null ? void 0 : containerContext.containerId) != null ? _a3 : NO_CONTAINER_ID;
+  const [itemKey, itemIndex, item] = useArr$([
+    `containerItemKey${containerId}`,
+    `containerItemIndex${containerId}`,
+    `containerItemData${containerId}`
+  ]);
+  return {
+    hasItemInfo: !!containerContext && itemKey !== void 0 && itemIndex !== void 0,
+    item,
+    itemIndex,
+    itemKey
+  };
+}
+function useAdaptiveRender() {
+  const [mode] = useArr$(["adaptiveRender"]);
+  return mode;
+}
+function useAdaptiveRenderChange(callback) {
+  const ctx = useStateContext();
+  const callbackRef = React3.useRef(callback);
+  callbackRef.current = callback;
+  React3.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();
+  useInit(() => {
+    if (!containerContext) {
+      return;
     }
-    const itemData = state.props.data[index];
-    if (itemData === void 0) {
-      return { didMeasureUserScrollAnchorResetItem };
+    const { containerId } = containerContext;
+    const key = containerId + (configId != null ? configId : "");
+    const value = ctx.mapViewabilityValues.get(key);
+    if (value) {
+      callback(value);
+    }
+  });
+  React3.useEffect(() => {
+    if (!containerContext) {
+      return;
     }
-    const type = getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
-    const size2 = getFixedItemSize(itemData, index, type);
-    resolvedMeasurementItem = {
-      didResolveFixedItemSize: true,
-      fixedItemSize: size2,
-      itemData,
-      itemType: type
+    const { containerId } = containerContext;
+    const key = containerId + (configId != null ? configId : "");
+    ctx.mapViewabilityCallbacks.set(key, callback);
+    return () => {
+      ctx.mapViewabilityCallbacks.delete(key);
     };
-    if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
-      updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
-      return { didMeasureUserScrollAnchorResetItem };
+  }, [ctx, callback, configId, containerContext]);
+}
+function useViewabilityAmount(callback) {
+  const ctx = useStateContext();
+  const containerContext = useContextContainer();
+  useInit(() => {
+    if (!containerContext) {
+      return;
     }
-  }
-  let needsRecalculate = !didContainersLayout;
-  let shouldMaintainScrollAtEnd = false;
-  let minIndexSizeChanged;
-  const prevSizeKnown = state.sizesKnown.get(itemKey);
-  const diff = updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem);
-  const size = roundSize(horizontal ? sizeObj.width : sizeObj.height);
-  if (diff !== 0) {
-    minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
-    const { startBuffered, endBuffered } = state;
-    needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
-    if (!needsRecalculate && state.containerItemKeys.has(itemKey)) {
-      needsRecalculate = true;
+    const { containerId } = containerContext;
+    const value = ctx.mapViewabilityAmountValues.get(containerId);
+    if (value) {
+      callback(value);
+    }
+  });
+  React3.useEffect(() => {
+    if (!containerContext) {
+      return;
+    }
+    const { containerId } = containerContext;
+    ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
+    return () => {
+      ctx.mapViewabilityAmountCallbacks.delete(containerId);
+    };
+  }, [ctx, callback, containerContext]);
+}
+function useRecyclingEffect(effect) {
+  const containerContext = useContextContainer();
+  const { hasItemInfo, item, itemIndex, itemKey } = useContainerItemSignals(containerContext);
+  const prevInfo = React3.useRef(void 0);
+  React3.useEffect(() => {
+    if (!hasItemInfo) {
+      return;
     }
-    if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
-      shouldMaintainScrollAtEnd = true;
+    let ret;
+    if (prevInfo.current) {
+      ret = effect({
+        index: itemIndex,
+        item,
+        prevIndex: prevInfo.current.index,
+        prevItem: prevInfo.current.item
+      });
     }
-    onItemSizeChanged == null ? void 0 : onItemSizeChanged({
-      index,
-      itemData: state.props.data[index],
-      itemKey,
-      previous: size - diff,
-      size
-    });
-    maybeUpdateAnchoredEndSpace(ctx);
-  }
-  if (minIndexSizeChanged !== void 0) {
-    state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
-  }
-  updateOtherAxisSizeIfNeeded(ctx, sizeObj, horizontal);
-  if (didContainersLayout || checkAllSizesKnown(state, state.startBuffered, state.endBuffered)) {
-    const canMaintainScrollAtEnd = shouldMaintainScrollAtEnd && !!(maintainScrollAtEnd == null ? void 0 : maintainScrollAtEnd.onItemLayout);
-    return {
-      didChange: diff !== 0,
-      didMeasureUserScrollAnchorResetItem,
-      needsRecalculate,
-      shouldMaintainScrollAtEnd: canMaintainScrollAtEnd
+    prevInfo.current = {
+      index: itemIndex,
+      item
     };
-  }
-  return {
-    didChange: diff !== 0,
-    didMeasureUserScrollAnchorResetItem
-  };
+    return ret;
+  }, [effect, hasItemInfo, itemIndex, item, itemKey]);
 }
-function updateOneItemSize(ctx, itemKey, sizeObj, resolvedMeasurementItem) {
-  var _a3, _b, _c;
-  const state = ctx.state;
-  const {
-    indexByKey,
-    sizesKnown,
-    averageSizes,
-    props: { data, horizontal, getItemType, getFixedItemSize }
-  } = state;
-  if (!data) return 0;
-  const index = indexByKey.get(itemKey);
-  const itemData = (_a3 = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemData) != null ? _a3 : data[index];
-  let itemType = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.itemType;
-  let fixedItemSize = resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.fixedItemSize;
-  if (getFixedItemSize && !(resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize)) {
-    itemType = getItemType ? (_b = getItemType(itemData, index)) != null ? _b : "" : "";
-    fixedItemSize = getFixedItemSize(itemData, index, itemType);
-  }
-  const resolvedItemSize = (resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize) || itemType !== void 0 || fixedItemSize !== void 0 ? {
-    didResolveFixedItemSize: resolvedMeasurementItem == null ? void 0 : resolvedMeasurementItem.didResolveFixedItemSize,
-    fixedItemSize,
-    itemType
-  } : void 0;
-  const prevSize = getItemSize(ctx, itemKey, index, itemData, void 0, void 0, void 0, resolvedItemSize);
-  const rawSize = horizontal ? sizeObj.width : sizeObj.height;
-  const prevSizeKnown = sizesKnown.get(itemKey);
-  const size = Math.round(rawSize) ;
-  sizesKnown.set(itemKey, size);
-  if (fixedItemSize === void 0 && size > 0) {
-    itemType != null ? itemType : itemType = getItemType ? (_c = getItemType(itemData, index)) != null ? _c : "" : "";
-    let averages = averageSizes[itemType];
-    if (!averages) {
-      averages = averageSizes[itemType] = { avg: 0, num: 0 };
-    }
-    if (averages.num === 0) {
-      averages.avg = size;
-      averages.num++;
-    } else if (prevSizeKnown !== void 0 && prevSizeKnown > 0) {
-      averages.avg += (size - prevSizeKnown) / averages.num;
-    } else {
-      averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
-      averages.num++;
+function useRecyclingState(valueOrFun) {
+  const containerContext = useContextContainer();
+  const { hasItemInfo, item, itemIndex, itemKey } = useContainerItemSignals(containerContext);
+  const computeValue = () => {
+    if (isFunction(valueOrFun)) {
+      const initializer = valueOrFun;
+      return hasItemInfo ? initializer({
+        index: itemIndex,
+        item,
+        prevIndex: void 0,
+        prevItem: void 0
+      }) : initializer();
     }
+    return valueOrFun;
+  };
+  const [stateValue, setStateValue] = React3.useState(() => {
+    return computeValue();
+  });
+  const prevItemKeyRef = React3.useRef(hasItemInfo ? itemKey : null);
+  if (hasItemInfo && prevItemKeyRef.current !== itemKey) {
+    prevItemKeyRef.current = itemKey;
+    setStateValue(computeValue());
   }
-  if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-    setSize(ctx, itemKey, size);
-    return size - prevSize;
-  }
-  return 0;
+  const triggerLayout = containerContext == null ? void 0 : containerContext.triggerLayout;
+  const setState = React3.useCallback(
+    (newState) => {
+      if (!triggerLayout) {
+        return;
+      }
+      setStateValue((prevValue) => {
+        return isFunction(newState) ? newState(prevValue) : newState;
+      });
+      triggerLayout();
+    },
+    [triggerLayout]
+  );
+  return [stateValue, setState];
+}
+function useIsLastItem() {
+  var _a3;
+  const containerContext = useContextContainer();
+  const containerId = (_a3 = containerContext == null ? void 0 : containerContext.containerId) != null ? _a3 : NO_CONTAINER_ID;
+  const [itemKey] = useArr$([`containerItemKey${containerId}`]);
+  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => {
+    if (containerContext && !isNullOrUndefined(itemKey)) {
+      return (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false;
+    }
+    return false;
+  });
+  return isLast;
+}
+function useListScrollSize() {
+  const [scrollSize] = useArr$(["scrollSize"]);
+  return scrollSize;
+}
+var noop = () => {
+};
+function useSyncLayout() {
+  const containerContext = useContextContainer();
+  return containerContext ? containerContext.triggerLayout : noop;
+}
+
+// src/components/Separator.tsx
+function Separator({ ItemSeparatorComponent, leadingItem }) {
+  const isLastItem = useIsLastItem();
+  return isLastItem ? null : /* @__PURE__ */ React3__namespace.createElement(ItemSeparatorComponent, { leadingItem });
 }
 
 // src/hooks/createResizeObserver.ts
@@ -5067,43 +5231,39 @@ var globalResizeObserver = null;
 function getGlobalResizeObserver() {
   if (!globalResizeObserver) {
     globalResizeObserver = new ResizeObserver((entries) => {
-      for (const entry of entries) {
-        const callbacks = callbackMap.get(entry.target);
-        if (callbacks) {
-          for (const callback of callbacks) {
-            callback(entry);
+      batchItemSizeUpdates(() => {
+        for (const entry of entries) {
+          const callbacks = callbackMap.get(entry.target);
+          if (callbacks) {
+            for (const callback of callbacks) {
+              callback(entry);
+            }
           }
         }
-      }
+      });
     });
   }
   return globalResizeObserver;
 }
 var callbackMap = /* @__PURE__ */ new WeakMap();
 function createResizeObserver(element, callback) {
-  if (typeof ResizeObserver === "undefined") {
-    return () => {
-    };
-  }
-  if (!element) {
+  var _a3;
+  if (typeof ResizeObserver === "undefined" || !element) {
     return () => {
     };
   }
   const observer = getGlobalResizeObserver();
-  let callbacks = callbackMap.get(element);
-  if (!callbacks) {
-    callbacks = /* @__PURE__ */ new Set();
+  const callbacks = (_a3 = callbackMap.get(element)) != null ? _a3 : /* @__PURE__ */ new Set();
+  if (callbacks.size === 0) {
     callbackMap.set(element, callbacks);
-    observer.observe(element);
+    observer.observe(element, { box: "border-box" });
   }
   callbacks.add(callback);
   return () => {
-    if (callbacks) {
-      callbacks.delete(callback);
-      if (callbacks.size === 0) {
-        callbackMap.delete(element);
-        observer.unobserve(element);
-      }
+    callbacks.delete(callback);
+    if (callbacks.size === 0) {
+      callbackMap.delete(element);
+      observer.unobserve(element);
     }
   };
 }
@@ -5111,6 +5271,7 @@ function createResizeObserver(element, callback) {
 // src/hooks/useOnLayoutSync.tsx
 function useOnLayoutSync({
   ref,
+  measureInLayoutEffect = true,
   onLayoutProp,
   onLayoutChange,
   webLayoutResync
@@ -5130,21 +5291,31 @@ function useOnLayoutSync({
       onLayoutChange(layout, fromLayoutEffect);
       onLayoutProp == null ? void 0 : onLayoutProp({ nativeEvent: { layout } });
     };
-    const rect = element.getBoundingClientRect();
-    emit(toLayout(rect), true);
-    let prevRect = rect;
+    let prevRect;
+    if (measureInLayoutEffect) {
+      const rect = element.getBoundingClientRect();
+      emit(toLayout(rect), true);
+      prevRect = rect;
+    }
     return createResizeObserver(element, (entry) => {
       var _a4;
       const target = entry.target instanceof HTMLElement ? entry.target : void 0;
-      const rectObserved = (_a4 = entry.contentRect) != null ? _a4 : target == null ? void 0 : target.getBoundingClientRect();
-      const didSizeChange = rectObserved.width !== prevRect.width || rectObserved.height !== prevRect.height;
+      const borderBoxSize = Array.isArray(entry.borderBoxSize) ? entry.borderBoxSize[0] : entry.borderBoxSize;
+      const rectObserved = borderBoxSize ? {
+        height: borderBoxSize.blockSize,
+        left: entry.contentRect.left,
+        top: entry.contentRect.top,
+        width: borderBoxSize.inlineSize
+      } : (_a4 = target == null ? void 0 : target.getBoundingClientRect()) != null ? _a4 : entry.contentRect;
+      const previousRect = prevRect != null ? prevRect : getContainerLayoutBaseline(element);
+      const didSizeChange = previousRect === void 0 || rectObserved.width !== previousRect.width || rectObserved.height !== previousRect.height;
+      prevRect = rectObserved;
       const shouldResyncLayout = !!(webLayoutResync == null ? void 0 : webLayoutResync());
       if (didSizeChange || shouldResyncLayout) {
-        prevRect = rectObserved;
         emit(toLayout(rectObserved), false);
       }
     });
-  }, deps || []);
+  }, [measureInLayoutEffect, ...deps || []]);
   return {};
 }
 function toLayout(rect) {
@@ -5159,6 +5330,121 @@ function toLayout(rect) {
   };
 }
 
+// src/hooks/useContainerMeasurement.tsx
+var pendingWebShrinkMeasurements = /* @__PURE__ */ new Map();
+var pendingWebShrinkFrame;
+function cancelWebShrinkMeasurement(state) {
+  pendingWebShrinkMeasurements.delete(state);
+}
+function scheduleWebShrinkMeasurement(state, confirmMeasurement) {
+  pendingWebShrinkMeasurements.set(state, confirmMeasurement);
+  if (pendingWebShrinkFrame === void 0) {
+    pendingWebShrinkFrame = requestAnimationFrame(() => {
+      const callbacks = Array.from(pendingWebShrinkMeasurements.values());
+      pendingWebShrinkMeasurements.clear();
+      pendingWebShrinkFrame = void 0;
+      batchItemSizeUpdates(() => {
+        for (const callback of callbacks) {
+          callback();
+        }
+      });
+    });
+  }
+}
+function processContainerLayout({ containerId, ctx, rectangle, ref, state }) {
+  const listState = ctx.state;
+  const currentItemKey = state.itemKey;
+  state.didLayout = true;
+  let layout = rectangle;
+  const axis = state.horizontal ? "width" : "height";
+  const size = roundSize(rectangle[axis]);
+  state.lastSize ? roundSize(state.lastSize[axis]) : void 0;
+  const coreKnownSize = listState.sizesKnown.get(currentItemKey);
+  const previousSize = coreKnownSize ;
+  const applyLayout = () => {
+    state.lastSize = layout;
+    updateItemSizes(ctx, {
+      containerId,
+      itemKey: currentItemKey,
+      size: layout
+    });
+  };
+  const shouldDeferWebShrinkLayoutUpdate = !isInMVCPActiveMode(listState) && previousSize !== void 0 && size + 1 < previousSize;
+  if (shouldDeferWebShrinkLayoutUpdate) {
+    scheduleWebShrinkMeasurement(state, () => {
+      var _a4;
+      if (state.itemKey === currentItemKey) {
+        const element = ref.current;
+        const rect = (_a4 = element == null ? void 0 : element.getBoundingClientRect) == null ? void 0 : _a4.call(element);
+        if (rect) {
+          layout = { height: rect.height, width: rect.width };
+        }
+        applyLayout();
+      }
+    });
+  } else {
+    {
+      cancelWebShrinkMeasurement(state);
+    }
+    {
+      applyLayout();
+    }
+  }
+}
+function useContainerMeasurement({
+  containerId,
+  ctx,
+  horizontal,
+  itemKey,
+  ref
+}) {
+  const stateRef = React3.useRef({
+    didLayout: false,
+    horizontal,
+    itemKey
+  });
+  stateRef.current.horizontal = horizontal;
+  stateRef.current.itemKey = itemKey;
+  const [layoutRenderCount, forceLayoutRender] = React3.useState(0);
+  const onLayoutChange = React3.useCallback(
+    (rectangle) => {
+      processContainerLayout({ containerId, ctx, rectangle, ref, state: stateRef.current });
+    },
+    [containerId, ctx, ref]
+  );
+  const triggerLayout = React3.useCallback(() => {
+    {
+      scheduleContainerLayout(ctx, containerId);
+    }
+  }, [containerId, ctx]);
+  React3.useLayoutEffect(() => {
+    ctx.containerLayoutTriggers.set(containerId, triggerLayout);
+    return () => {
+      cancelWebShrinkMeasurement(stateRef.current);
+      if (ctx.containerLayoutTriggers.get(containerId) === triggerLayout) {
+        ctx.containerLayoutTriggers.delete(containerId);
+      }
+    };
+  }, [containerId, ctx, triggerLayout]);
+  React3.useLayoutEffect(() => {
+    {
+      scheduleContainerLayout(ctx, containerId);
+    }
+  });
+  const { onLayout } = useOnLayoutSync(
+    {
+      measureInLayoutEffect: !IsNewArchitecture,
+      onLayoutChange,
+      ref,
+      webLayoutResync: () => isInMVCPActiveMode(ctx.state)
+    },
+    [itemKey, layoutRenderCount]
+  );
+  React3.useEffect(() => {
+  }, [containerId, ctx, itemKey]);
+  return { onLayout, triggerLayout };
+}
+
 // src/components/Container.tsx
 function getContainerPositionStyle({
   columnWrapperStyle,
@@ -5229,16 +5515,14 @@ var Container = typedMemo(function Container2({
     "extraData",
     `containerSticky${id}`
   ]);
-  const itemLayoutRef = React3.useRef({
-    didLayout: false,
+  const ref = React3.useRef(null);
+  const { onLayout, triggerLayout } = useContainerMeasurement({
+    containerId: id,
+    ctx,
     horizontal,
     itemKey,
-    pendingShrinkToken: 0
+    ref
   });
-  itemLayoutRef.current.horizontal = horizontal;
-  itemLayoutRef.current.itemKey = itemKey;
-  const ref = React3.useRef(null);
-  const [layoutRenderCount, forceLayoutRender] = React3.useState(0);
   const resolvedColumn = column > 0 ? column : 1;
   const resolvedSpan = Math.min(Math.max(span || 1, 1), numColumns);
   const otherAxisPos = numColumns > 1 ? `${(resolvedColumn - 1) / numColumns * 100}%` : 0;
@@ -5269,83 +5553,14 @@ var Container = typedMemo(function Container2({
     () => itemKey !== void 0 ? getRenderedItem2(itemKey) : null,
     [itemKey, data, extraData]
   );
-  const { index, renderedItem } = renderedItemInfo || {};
-  const onLayoutChange = React3.useCallback((rectangle, fromLayoutEffect) => {
-    const {
-      horizontal: currentHorizontal,
-      itemKey: currentItemKey,
-      lastSize,
-      pendingShrinkToken
-    } = itemLayoutRef.current;
-    if (isNullOrUndefined(currentItemKey)) {
-      return;
-    }
-    itemLayoutRef.current.didLayout = true;
-    let layout = rectangle;
-    const axis = currentHorizontal ? "width" : "height";
-    const size = roundSize(rectangle[axis]);
-    const prevSize = lastSize ? roundSize(lastSize[axis]) : void 0;
-    const doUpdate = () => {
-      itemLayoutRef.current.lastSize = layout;
-      updateItemSizes(ctx, {
-        containerId: id,
-        fromLayoutEffect,
-        itemKey: currentItemKey,
-        size: layout
-      });
-      itemLayoutRef.current.didLayout = true;
-    };
-    const shouldDeferWebShrinkLayoutUpdate = !isInMVCPActiveMode(ctx.state) && prevSize !== void 0 && size + 1 < prevSize;
-    if (shouldDeferWebShrinkLayoutUpdate) {
-      const token = pendingShrinkToken + 1;
-      itemLayoutRef.current.pendingShrinkToken = token;
-      requestAnimationFrame(() => {
-        var _a4;
-        if (itemLayoutRef.current.pendingShrinkToken !== token) {
-          return;
-        }
-        const element = ref.current;
-        const rect = (_a4 = element == null ? void 0 : element.getBoundingClientRect) == null ? void 0 : _a4.call(element);
-        if (rect) {
-          layout = { height: rect.height, width: rect.width };
-        }
-        doUpdate();
-      });
-      return;
-    }
-    {
-      doUpdate();
-    }
-  }, []);
-  const triggerLayout = React3.useCallback(() => {
-    forceLayoutRender((v) => v + 1);
-  }, []);
+  const { renderedItem } = renderedItemInfo || {};
   const contextValue = React3.useMemo(() => {
     ctx.viewRefs.set(id, ref);
     return {
       containerId: id,
-      index,
-      itemKey,
-      triggerLayout,
-      value: data
-    };
-  }, [id, itemKey, index, data, triggerLayout]);
-  React3.useLayoutEffect(() => {
-    ctx.containerLayoutTriggers.set(id, triggerLayout);
-    return () => {
-      if (ctx.containerLayoutTriggers.get(id) === triggerLayout) {
-        ctx.containerLayoutTriggers.delete(id);
-      }
+      triggerLayout
     };
-  }, [ctx, id, triggerLayout]);
-  const { onLayout } = useOnLayoutSync(
-    {
-      onLayoutChange,
-      ref,
-      webLayoutResync: () => isInMVCPActiveMode(ctx.state)
-    },
-    [itemKey, layoutRenderCount]
-  );
+  }, [id, triggerLayout]);
   const PositionComponent = isSticky ? stickyPositionComponentInternal ? stickyPositionComponentInternal : PositionViewSticky : positionComponentInternal ? positionComponentInternal : PositionView;
   return /* @__PURE__ */ React3__namespace.createElement(
     PositionComponent,
@@ -5353,7 +5568,6 @@ var Container = typedMemo(function Container2({
       animatedScrollY: isSticky ? animatedScrollY : void 0,
       horizontal,
       id,
-      index,
       key: recycleItems ? void 0 : itemKey,
       onLayout,
       refView: ref,
@@ -5396,18 +5610,13 @@ var ContainerSlot = typedMemo(function ContainerSlot2(props) {
 });
 
 // src/utils/reordering.ts
-var mapFn = (element) => {
-  const indexStr = element.getAttribute("data-index");
-  if (indexStr === null) {
-    return [element, null];
-  }
-  const index = Number.parseInt(indexStr, 10);
-  return [element, Number.isNaN(index) ? null : index];
-};
-function sortDOMElements(container) {
+function sortDOMElements(container, indexByElement) {
   const elements = Array.from(container.children);
   if (elements.length <= 1) return elements;
-  const items = elements.map(mapFn);
+  const items = elements.map((element) => {
+    var _a3;
+    return [element, (_a3 = indexByElement.get(element)) != null ? _a3 : null];
+  });
   items.sort((a, b) => {
     const aKey = a[1];
     const bKey = b[1];
@@ -5495,7 +5704,15 @@ function useDOMOrder(ref) {
       debounceRef.current = setTimeout(() => {
         const parent = ref.current;
         if (parent) {
-          sortDOMElements(parent);
+          const indexByElement = /* @__PURE__ */ new Map();
+          for (const [containerId, viewRef] of ctx.viewRefs) {
+            const element = viewRef.current;
+            const index = peek$(ctx, `containerItemIndex${containerId}`);
+            if (element && index !== void 0) {
+              indexByElement.set(element, index);
+            }
+          }
+          sortDOMElements(parent, indexByElement);
         }
         debounceRef.current = void 0;
       }, 500);
@@ -5519,6 +5736,7 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
   useDOMOrder(ref);
   const style = horizontal ? {
     direction: isHorizontalRTLList ? "ltr" : void 0,
+    flexShrink: 0,
     minHeight: otherAxisSize,
     opacity: readyToRender ? 1 : 0,
     position: "relative",
@@ -5544,7 +5762,7 @@ var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColum
       }
     }
   }
-  return /* @__PURE__ */ React3__namespace.createElement("div", { ref, style }, children);
+  return /* @__PURE__ */ React3__namespace.createElement("div", { ref, style }, /* @__PURE__ */ React3__namespace.createElement(ContainerLayoutCoordinator, null, children));
 });
 var Containers = typedMemo(function Containers2({
   horizontal,
@@ -5723,6 +5941,7 @@ function resolveWindowScrollTarget({ clampedOffset, horizontal, listPos, scroll
 
 // src/components/ListComponentScrollView.tsx
 var SCROLLBAR_HIDDEN_STYLE_ID = "legend-list-scrollbar-axis-hidden-style";
+var SCROLL_END_FALLBACK_MS = 200;
 var SCROLLBAR_HIDDEN_STYLE = `.${LEGEND_LIST_SCROLLBAR_Y_HIDDEN_CLASS}::-webkit-scrollbar:vertical{width:0;display:none;}.${LEGEND_LIST_SCROLLBAR_X_HIDDEN_CLASS}::-webkit-scrollbar:horizontal{height:0;display:none;}`;
 function ensureScrollbarHiddenStyle() {
   if (typeof document === "undefined" || document.getElementById(SCROLLBAR_HIDDEN_STYLE_ID)) {
@@ -5772,6 +5991,7 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
   contentOffset,
   maintainVisibleContentPosition,
   onScroll: onScroll2,
+  onInternalScrollEnd,
   onMomentumScrollEnd: _onMomentumScrollEnd,
   showsHorizontalScrollIndicator = true,
   showsVerticalScrollIndicator = true,
@@ -5901,6 +6121,16 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
     onScroll2(scrollEvent);
   }, [getCurrentScrollOffset, horizontal, isWindowScroll, onScroll2]);
   const scrollEventCoalescer = useRafCoalescer(emitScroll);
+  const scrollEndFallbackRef = React3.useRef(void 0);
+  const emitScrollEnd = React3.useCallback(() => {
+    const timeout = scrollEndFallbackRef.current;
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+      scrollEndFallbackRef.current = void 0;
+    }
+    scrollEventCoalescer.flush();
+    onInternalScrollEnd == null ? void 0 : onInternalScrollEnd();
+  }, [onInternalScrollEnd, scrollEventCoalescer]);
   const handleScroll = React3.useCallback(
     (_event) => {
       if (!onScroll2) {
@@ -5913,18 +6143,36 @@ var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView
       } else {
         scrollEventCoalescer.schedule();
       }
+      if (onInternalScrollEnd) {
+        const timeout = scrollEndFallbackRef.current;
+        if (timeout !== void 0) {
+          clearTimeout(timeout);
+        }
+        scrollEndFallbackRef.current = setTimeout(emitScrollEnd, SCROLL_END_FALLBACK_MS);
+      }
     },
-    [ctx.state, onScroll2, scrollEventCoalescer]
+    [ctx.state, emitScrollEnd, onInternalScrollEnd, onScroll2, scrollEventCoalescer]
   );
   React3.useLayoutEffect(() => {
     const target = getScrollTarget();
     if (!target) return;
     target.addEventListener("scroll", handleScroll, { passive: true });
+    if ("onscrollend" in target) {
+      target.addEventListener("scrollend", emitScrollEnd);
+    }
     return () => {
       target.removeEventListener("scroll", handleScroll);
+      if ("onscrollend" in target) {
+        target.removeEventListener("scrollend", emitScrollEnd);
+      }
+      const timeout = scrollEndFallbackRef.current;
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+        scrollEndFallbackRef.current = void 0;
+      }
       scrollEventCoalescer.cancel();
     };
-  }, [getScrollTarget, handleScroll, scrollEventCoalescer]);
+  }, [emitScrollEnd, getScrollTarget, handleScroll, scrollEventCoalescer]);
   React3.useEffect(() => {
     const doScroll = () => {
       if (contentOffset) {
@@ -6274,6 +6522,8 @@ var ListComponent = typedMemo(function ListComponent2({
   refScrollView,
   renderScrollComponent,
   onLayoutFooter,
+  onInternalScrollBeginDrag,
+  onInternalScrollEnd,
   scrollAdjustHandler,
   snapToIndices,
   stickyHeaderConfig,
@@ -6335,7 +6585,7 @@ var ListComponent = typedMemo(function ListComponent2({
     SnapOrScroll,
     {
       ...rest,
-      ...ScrollComponent === ListComponentScrollView ? { useWindowScroll } : {},
+      ...ScrollComponent === ListComponentScrollView ? { onInternalScrollEnd, useWindowScroll } : {} ,
       contentContainerStyle: [
         horizontal ? {
           height: "100%"
@@ -6441,6 +6691,7 @@ function checkResetContainers(ctx, dataProp, { didColumnsChange = false } = {})
   if (didColumnsChange) {
     state.sizes.clear();
     state.sizesKnown.clear();
+    invalidateContainerFixedItemSizes(state);
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
@@ -6687,7 +6938,7 @@ function onScroll(ctx, event) {
     }
   }
   state.scrollPending = newScroll;
-  updateScroll(ctx, newScroll, insetChanged);
+  updateScroll(ctx, newScroll, insetChanged, { fromNativeScrollEvent: true });
   trackInitialScrollNativeProgress(state, newScroll);
   clearFinishedBootstrapInitialScrollTargetIfMovedAway(ctx);
   if (state.scrollingTo) {
@@ -6850,8 +7101,8 @@ function getAverageItemSizes(state) {
   return averageItemSizes;
 }
 function triggerMountedContainerLayouts(ctx) {
-  for (const triggerLayout of ctx.containerLayoutTriggers.values()) {
-    triggerLayout();
+  {
+    scheduleContainerLayout(ctx);
   }
 }
 function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
@@ -6964,6 +7215,7 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
     const mode = (_a3 = options == null ? void 0 : options.mode) != null ? _a3 : "sizes";
     state.sizes.clear();
     state.sizesKnown.clear();
+    invalidateContainerFixedItemSizes(state);
     for (const key in state.averageSizes) {
       delete state.averageSizes[key];
     }
@@ -6985,6 +7237,10 @@ function createImperativeHandle(ctx, scheduleImperativeScrollCommit) {
   return {
     clearCaches,
     flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
+    getAnimatableRef: () => {
+      var _a3, _b, _c;
+      return (_c = (_b = (_a3 = refScroller.current).getNativeScrollRef) == null ? void 0 : _b.call(_a3)) != null ? _c : refScroller.current;
+    },
     getNativeScrollRef: () => refScroller.current,
     getScrollableNode: () => refScroller.current.getScrollableNode(),
     getScrollResponder: () => refScroller.current.getScrollResponder(),
@@ -7355,6 +7611,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onMomentumScrollEnd,
     onRefresh,
     onScroll: onScrollProp,
+    onScrollBeginDrag,
     onStartReached,
     onStartReachedThreshold = 0.5,
     onStickyHeaderChange,
@@ -7466,8 +7723,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         averageSizes: {},
         columnSpans: [],
         columns: [],
+        containerItemGenerations: [],
         containerItemKeys: /* @__PURE__ */ new Map(),
-        containerItemTypes: /* @__PURE__ */ new Map(),
+        containerItemMetadata: /* @__PURE__ */ new Map(),
         contentInsetOverride: void 0,
         dataChangeEpoch: 0,
         dataChangeNeedsScrollUpdate: false,
@@ -7520,7 +7778,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         startBuffered: -1,
         startNoBuffer: -1,
         startReachedSnapshot: void 0,
-        startReachedSnapshotDataChangeEpoch: void 0,
         stickyContainerPool: /* @__PURE__ */ new Set(),
         stickyContainers: /* @__PURE__ */ new Map(),
         timeoutAdaptiveRender: void 0,
@@ -7596,7 +7853,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onFirstVisibleItemChanged,
     onItemSizeChanged,
     onLoad,
+    onMomentumScrollEnd,
     onScroll: throttleScrollFn,
+    onScrollBeginDrag,
     onStartReached,
     onStartReachedThreshold,
     onStickyHeaderChange,
@@ -7871,11 +8130,17 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       getRenderedItem: (key) => getRenderedItem(ctx, key),
       onMomentumScrollEnd: (event) => {
         checkFinishedScrollFallback(ctx);
-        if (onMomentumScrollEnd) {
-          onMomentumScrollEnd(event);
+        if (state.props.onMomentumScrollEnd) {
+          state.props.onMomentumScrollEnd(event);
         }
       },
-      onScroll: (event) => onScroll(ctx, event)
+      onScroll: (event) => onScroll(ctx, event),
+      onScrollBeginDrag: (event) => {
+        var _a4, _b2;
+        prepareReachedEdgeForNextUserScroll(ctx);
+        (_b2 = (_a4 = state.props).onScrollBeginDrag) == null ? void 0 : _b2.call(_a4, event);
+      },
+      onScrollEnd: () => prepareReachedEdgeForNextUserScroll(ctx)
     }),
     []
   );
@@ -7896,6 +8161,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       ListFooterComponent,
       ListFooterComponentStyle,
       ListHeaderComponent,
+      onInternalScrollBeginDrag: fns.onScrollBeginDrag,
+      onInternalScrollEnd: fns.onScrollEnd,
       onLayout,
       onLayoutFooter,
       onMomentumScrollEnd: fns.onMomentumScrollEnd,