@legendapp/list 2.0.13 → 2.1.0-beta.1

package/index.mjs

@@ -1,13 +1,25 @@
-import * as React2 from 'react';
-import React2__default, { useReducer, useEffect, createContext, useRef, useState, useMemo, useCallback, useLayoutEffect, useImperativeHandle, forwardRef, memo, useContext } from 'react';
-import { View, Text, Platform, Animated, StyleSheet, Dimensions, RefreshControl, unstable_batchedUpdates } from 'react-native';
+import * as React3 from 'react';
+import React3__default, { forwardRef, useReducer, useEffect, createContext, useRef, useState, useMemo, useCallback, useImperativeHandle, useLayoutEffect, memo, useContext } from 'react';
 import { useSyncExternalStore } from 'use-sync-external-store/shim';
+import { unstable_batchedUpdates } from 'react-dom';
 
 // src/components/LegendList.tsx
-var ContextState = React2.createContext(null);
+forwardRef(function AnimatedView2(props, ref) {
+  return /* @__PURE__ */ React3.createElement("div", { ref, ...props });
+});
+var View = forwardRef(function View2(props, ref) {
+  return /* @__PURE__ */ React3.createElement("div", { ref, ...props });
+});
+var Text = View;
+
+// src/platform/Animated.tsx
+var createAnimatedValue = (value) => value;
+
+// src/state/state.tsx
+var ContextState = React3.createContext(null);
 function StateProvider({ children }) {
-  const [value] = React2.useState(() => ({
-    animatedScrollY: new Animated.Value(0),
+  const [value] = React3.useState(() => ({
+    animatedScrollY: createAnimatedValue(0),
     columnWrapperStyle: void 0,
     internalState: void 0,
     listeners: /* @__PURE__ */ new Map(),
@@ -25,10 +37,10 @@ function StateProvider({ children }) {
     ]),
     viewRefs: /* @__PURE__ */ new Map()
   }));
-  return /* @__PURE__ */ React2.createElement(ContextState.Provider, { value }, children);
+  return /* @__PURE__ */ React3.createElement(ContextState.Provider, { value }, children);
 }
 function useStateContext() {
-  return React2.useContext(ContextState);
+  return React3.useContext(ContextState);
 }
 function createSelectorFunctionsArr(ctx, signalNames) {
   let lastValues = [];
@@ -98,23 +110,23 @@ function getContentSize(ctx) {
   return headerSize + footerSize + totalSize + stylePaddingTop;
 }
 function useArr$(signalNames) {
-  const ctx = React2.useContext(ContextState);
-  const { subscribe, get } = React2.useMemo(() => createSelectorFunctionsArr(ctx, signalNames), [ctx, signalNames]);
+  const ctx = React3.useContext(ContextState);
+  const { subscribe, get } = React3.useMemo(() => createSelectorFunctionsArr(ctx, signalNames), [ctx, signalNames]);
   const value = useSyncExternalStore(subscribe, get);
   return value;
 }
 function useSelector$(signalName, selector) {
-  const ctx = React2.useContext(ContextState);
-  const { subscribe, get } = React2.useMemo(() => createSelectorFunctionsArr(ctx, [signalName]), [ctx, signalName]);
+  const ctx = React3.useContext(ContextState);
+  const { subscribe, get } = React3.useMemo(() => createSelectorFunctionsArr(ctx, [signalName]), [ctx, signalName]);
   const value = useSyncExternalStore(subscribe, () => selector(get()[0]));
   return value;
 }
 
 // src/components/DebugView.tsx
 var DebugRow = ({ children }) => {
-  return /* @__PURE__ */ React2.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
+  return /* @__PURE__ */ React3.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
 };
-var DebugView = React2.memo(function DebugView2({ state }) {
+var DebugView = React3.memo(function DebugView2({ state }) {
   const ctx = useStateContext();
   const [totalSize = 0, scrollAdjust = 0, rawScroll = 0, scroll = 0, _numContainers = 0, _numContainersPooled = 0] = useArr$([
     "totalSize",
@@ -129,7 +141,7 @@ var DebugView = React2.memo(function DebugView2({ state }) {
   useInterval(() => {
     forceUpdate();
   }, 100);
-  return /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(
     View,
     {
       pointerEvents: "none",
@@ -145,14 +157,12 @@ var DebugView = React2.memo(function DebugView2({ state }) {
         top: 0
       }
     },
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "TotalSize:"), /* @__PURE__ */ React2.createElement(Text, null, totalSize.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ContentSize:"), /* @__PURE__ */ React2.createElement(Text, null, contentSize.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "At end:"), /* @__PURE__ */ React2.createElement(Text, null, String(state.isAtEnd))),
-    /* @__PURE__ */ React2.createElement(Text, null),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React2.createElement(Text, null, scrollAdjust.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(Text, null),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React2.createElement(Text, null, rawScroll.toFixed(2))),
-    /* @__PURE__ */ React2.createElement(DebugRow, null, /* @__PURE__ */ React2.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React2.createElement(Text, null, scroll.toFixed(2)))
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "TotalSize:"), /* @__PURE__ */ React3.createElement(Text, null, totalSize.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "ContentSize:"), /* @__PURE__ */ React3.createElement(Text, null, contentSize.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "At end:"), /* @__PURE__ */ React3.createElement(Text, null, String(state.isAtEnd))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React3.createElement(Text, null, scrollAdjust.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React3.createElement(Text, null, rawScroll.toFixed(2))),
+    /* @__PURE__ */ React3.createElement(DebugRow, null, /* @__PURE__ */ React3.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React3.createElement(Text, null, scroll.toFixed(2)))
   );
 });
 function useInterval(callback, delay) {
@@ -162,53 +172,18 @@ function useInterval(callback, delay) {
   }, [delay]);
 }
 
+// src/utils/devEnvironment.ts
+var metroDev = typeof __DEV__ !== "undefined" ? __DEV__ : void 0;
+var _a;
+var envMode = typeof process !== "undefined" && typeof process.env === "object" && process.env ? (_a = process.env.NODE_ENV) != null ? _a : process.env.MODE : void 0;
+var processDev = typeof envMode === "string" ? envMode.toLowerCase() !== "production" : void 0;
+var _a2;
+var IS_DEV = (_a2 = metroDev != null ? metroDev : processDev) != null ? _a2 : false;
+
 // src/constants.ts
 var POSITION_OUT_OF_VIEW = -1e7;
-var ENABLE_DEVMODE = __DEV__ && false;
-var ENABLE_DEBUG_VIEW = __DEV__ && false;
-var IsNewArchitecture = global.nativeFabricUIManager != null;
-var useAnimatedValue = (initialValue) => {
-  return useRef(new Animated.Value(initialValue)).current;
-};
-
-// src/hooks/useValue$.ts
-function useValue$(key, params) {
-  var _a;
-  const { getValue, delay } = params || {};
-  const ctx = useStateContext();
-  const animValue = useAnimatedValue((_a = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a : 0);
-  useMemo(() => {
-    let newValue;
-    let prevValue;
-    let didQueueTask = false;
-    listen$(ctx, key, (v) => {
-      newValue = getValue ? getValue(v) : v;
-      if (delay !== void 0) {
-        const fn = () => {
-          didQueueTask = false;
-          if (newValue !== void 0) {
-            animValue.setValue(newValue);
-          }
-        };
-        const delayValue = typeof delay === "function" ? delay(newValue, prevValue) : delay;
-        prevValue = newValue;
-        if (!didQueueTask) {
-          didQueueTask = true;
-          if (delayValue === void 0) {
-            fn();
-          } else if (delayValue === 0) {
-            queueMicrotask(fn);
-          } else {
-            setTimeout(fn, delayValue);
-          }
-        }
-      } else {
-        animValue.setValue(newValue);
-      }
-    });
-  }, []);
-  return animValue;
-}
+var ENABLE_DEVMODE = IS_DEV && false;
+var ENABLE_DEBUG_VIEW = IS_DEV && false;
 var typedForwardRef = forwardRef;
 var typedMemo = memo;
 
@@ -221,61 +196,34 @@ var PositionViewState = typedMemo(function PositionView({
   ...rest
 }) {
   const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
-  return /* @__PURE__ */ React2.createElement(
-    View,
-    {
-      ref: refView,
-      style: [
-        style,
-        horizontal ? { transform: [{ translateX: position }] } : { transform: [{ translateY: position }] }
-      ],
-      ...rest
-    }
-  );
-});
-var PositionViewAnimated = typedMemo(function PositionView2({
-  id,
-  horizontal,
-  style,
-  refView,
-  ...rest
-}) {
-  const position$ = useValue$(`containerPosition${id}`, {
-    getValue: (v) => v != null ? v : POSITION_OUT_OF_VIEW
-  });
-  let position;
-  if (Platform.OS === "ios" || Platform.OS === "android") {
-    position = horizontal ? { transform: [{ translateX: position$ }] } : { transform: [{ translateY: position$ }] };
-  } else {
-    position = horizontal ? { left: position$ } : { top: position$ };
-  }
-  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: [style, position], ...rest });
+  const base = Array.isArray(style) ? Object.assign({}, ...style) : style;
+  const combinedStyle = horizontal ? { ...base, left: position } : { ...base, top: position };
+  return /* @__PURE__ */ React3.createElement("div", { ref: refView, style: combinedStyle, ...rest });
 });
 var PositionViewSticky = typedMemo(function PositionViewSticky2({
   id,
   horizontal,
   style,
   refView,
-  animatedScrollY,
-  stickyOffset,
   index,
   ...rest
 }) {
-  const [position = POSITION_OUT_OF_VIEW, headerSize] = useArr$([`containerPosition${id}`, "headerSize"]);
-  const transform = React2.useMemo(() => {
-    if (animatedScrollY && stickyOffset !== void 0) {
-      const stickyPosition = animatedScrollY.interpolate({
-        extrapolate: "clamp",
-        inputRange: [position + headerSize, position + 5e3 + headerSize],
-        outputRange: [position, position + 5e3]
-      });
-      return horizontal ? [{ translateX: stickyPosition }] : [{ translateY: stickyPosition }];
-    }
-  }, [animatedScrollY, headerSize, horizontal, stickyOffset, position]);
-  const viewStyle = React2.useMemo(() => [style, { zIndex: index + 1e3 }, { transform }], [style, transform]);
-  return /* @__PURE__ */ React2.createElement(Animated.View, { ref: refView, style: viewStyle, ...rest });
+  const [position = POSITION_OUT_OF_VIEW, _headerSize] = useArr$([`containerPosition${id}`, "headerSize"]);
+  const viewStyle = React3.useMemo(() => {
+    const base = Array.isArray(style) ? Object.assign({}, ...style) : style;
+    const axisStyle = horizontal ? { transform: `translateX(${position}px)` } : { top: position };
+    return {
+      ...base,
+      zIndex: index + 1e3,
+      ...axisStyle
+    };
+  }, [style, position, horizontal, index]);
+  return /* @__PURE__ */ React3.createElement("div", { ref: refView, style: viewStyle, ...rest });
 });
-var PositionView3 = IsNewArchitecture ? PositionViewState : PositionViewAnimated;
+var PositionView2 = PositionViewState;
+
+// src/constants-platform.ts
+var IsNewArchitecture = true;
 var symbolFirst = Symbol();
 function useInit(cb) {
   const refValue = useRef(symbolFirst);
@@ -294,7 +242,7 @@ function isArray(obj) {
 }
 var warned = /* @__PURE__ */ new Set();
 function warnDevOnce(id, text) {
-  if (__DEV__ && !warned.has(id)) {
+  if (IS_DEV && !warned.has(id)) {
     warned.add(id);
     console.warn(`[legend-list] ${text}`);
   }
@@ -309,8 +257,8 @@ function comparatorDefault(a, b) {
   return a - b;
 }
 function getPadding(s, type) {
-  var _a, _b, _c;
-  return (_c = (_b = (_a = s[`padding${type}`]) != null ? _a : s.paddingVertical) != null ? _b : s.padding) != null ? _c : 0;
+  var _a3, _b, _c;
+  return (_c = (_b = (_a3 = s[`padding${type}`]) != null ? _a3 : s.paddingVertical) != null ? _b : s.padding) != null ? _c : 0;
 }
 function extractPadding(style, contentContainerStyle, type) {
   return getPadding(style, type) + getPadding(contentContainerStyle, type);
@@ -412,44 +360,101 @@ function useListScrollSize() {
   const [scrollSize] = useArr$(["scrollSize"]);
   return scrollSize;
 }
-var noop = () => {
-};
 function useSyncLayout() {
-  if (IsNewArchitecture) {
+  {
     const { triggerLayout: syncLayout } = useContext(ContextContainer);
     return syncLayout;
-  } else {
-    return noop;
   }
 }
 
 // src/components/Separator.tsx
 function Separator({ ItemSeparatorComponent, leadingItem }) {
   const isLastItem = useIsLastItem();
-  return isLastItem ? null : /* @__PURE__ */ React2.createElement(ItemSeparatorComponent, { leadingItem });
+  return isLastItem ? null : /* @__PURE__ */ React3.createElement(ItemSeparatorComponent, { leadingItem });
+}
+
+// src/hooks/createResizeObserver.ts
+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);
+          }
+        }
+      }
+    });
+  }
+  return globalResizeObserver;
 }
+var callbackMap = /* @__PURE__ */ new WeakMap();
+function createResizeObserver(element, callback) {
+  if (!element) {
+    return () => {
+    };
+  }
+  const observer = getGlobalResizeObserver();
+  let callbacks = callbackMap.get(element);
+  if (!callbacks) {
+    callbacks = /* @__PURE__ */ new Set();
+    callbackMap.set(element, callbacks);
+    observer.observe(element);
+  }
+  callbacks.add(callback);
+  return () => {
+    const callbacks2 = callbackMap.get(element);
+    if (callbacks2) {
+      callbacks2.delete(callback);
+      if (callbacks2.size === 0) {
+        callbackMap.delete(element);
+        observer.unobserve(element);
+      }
+    }
+  };
+}
+
+// src/hooks/useOnLayoutSync.tsx
 function useOnLayoutSync({
   ref,
   onLayoutProp,
   onLayoutChange
-}, deps = []) {
-  const onLayout = useCallback(
-    (event) => {
-      onLayoutChange(event.nativeEvent.layout, false);
-      onLayoutProp == null ? void 0 : onLayoutProp(event);
-    },
-    [onLayoutChange]
-  );
-  if (IsNewArchitecture) {
-    useLayoutEffect(() => {
-      if (ref.current) {
-        ref.current.measure((x, y, width, height) => {
-          onLayoutChange({ height, width, x, y }, true);
-        });
+}, deps) {
+  useLayoutEffect(() => {
+    var _a3, _b;
+    const current = ref.current;
+    const scrollableNode = (_b = (_a3 = current == null ? void 0 : current.getScrollableNode) == null ? void 0 : _a3.call(current)) != null ? _b : null;
+    const element = scrollableNode || current;
+    if (!element || !(element instanceof HTMLElement)) {
+      return;
+    }
+    const emit = (layout, fromLayoutEffect) => {
+      if (layout.height === 0 && layout.width === 0) {
+        return;
       }
-    }, deps);
-  }
-  return { onLayout };
+      onLayoutChange(layout, fromLayoutEffect);
+      onLayoutProp == null ? void 0 : onLayoutProp({ nativeEvent: { layout } });
+    };
+    const rect = element.getBoundingClientRect();
+    emit(toLayout(rect), true);
+    return createResizeObserver(element, (entry) => {
+      var _a4;
+      const target = entry.target instanceof HTMLElement ? entry.target : void 0;
+      const rect2 = (_a4 = entry.contentRect) != null ? _a4 : target == null ? void 0 : target.getBoundingClientRect();
+      emit(toLayout(rect2), false);
+    });
+  }, deps);
+  return {};
+}
+function toLayout(rect) {
+  return {
+    height: rect.height,
+    width: rect.width,
+    x: rect.left,
+    y: rect.top
+  };
 }
 
 // src/components/Container.tsx
@@ -472,7 +477,14 @@ var Container = typedMemo(function Container2({
     `containerSticky${id}`,
     `containerStickyOffset${id}`
   ]);
-  const refLastSize = useRef();
+  const itemLayoutRef = useRef({
+    horizontal,
+    itemKey,
+    updateItemSize: updateItemSize2
+  });
+  itemLayoutRef.current.horizontal = horizontal;
+  itemLayoutRef.current.itemKey = itemKey;
+  itemLayoutRef.current.updateItemSize = updateItemSize2;
   const ref = useRef(null);
   const [layoutRenderCount, forceLayoutRender] = useState(0);
   const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
@@ -527,27 +539,27 @@ var Container = typedMemo(function Container2({
       value: data
     };
   }, [id, itemKey, index, data]);
-  const onLayoutChange = (rectangle) => {
-    var _a, _b;
-    if (!isNullOrUndefined(itemKey)) {
+  const onLayoutChange = useCallback((rectangle) => {
+    const {
+      horizontal: currentHorizontal,
+      itemKey: currentItemKey,
+      updateItemSize: updateItemSizeFn
+    } = itemLayoutRef.current;
+    if (isNullOrUndefined(currentItemKey)) {
+      return;
+    }
+    didLayoutRef.current = true;
+    let layout = rectangle;
+    Math.floor(rectangle[currentHorizontal ? "width" : "height"] * 8) / 8;
+    const doUpdate = () => {
+      itemLayoutRef.current.lastSize = { height: layout.height, width: layout.width };
+      updateItemSizeFn(currentItemKey, layout);
       didLayoutRef.current = true;
-      let layout = rectangle;
-      const size = Math.floor(rectangle[horizontal ? "width" : "height"] * 8) / 8;
-      const doUpdate = () => {
-        refLastSize.current = { height: layout.height, width: layout.width };
-        updateItemSize2(itemKey, layout);
-        didLayoutRef.current = true;
-      };
-      if (IsNewArchitecture || size > 0) {
-        doUpdate();
-      } else {
-        (_b = (_a = ref.current) == null ? void 0 : _a.measure) == null ? void 0 : _b.call(_a, (_x, _y, width, height) => {
-          layout = { height, width };
-          doUpdate();
-        });
-      }
+    };
+    {
+      doUpdate();
     }
-  };
+  }, []);
   const { onLayout } = useOnLayoutSync(
     {
       onLayoutChange,
@@ -555,23 +567,8 @@ var Container = typedMemo(function Container2({
     },
     [itemKey, layoutRenderCount]
   );
-  if (!IsNewArchitecture) {
-    useEffect(() => {
-      if (!isNullOrUndefined(itemKey)) {
-        const timeout = setTimeout(() => {
-          if (!didLayoutRef.current && refLastSize.current) {
-            updateItemSize2(itemKey, refLastSize.current);
-            didLayoutRef.current = true;
-          }
-        }, 16);
-        return () => {
-          clearTimeout(timeout);
-        };
-      }
-    }, [itemKey]);
-  }
-  const PositionComponent = isSticky ? PositionViewSticky : PositionView3;
-  return /* @__PURE__ */ React2.createElement(
+  const PositionComponent = isSticky ? PositionViewSticky : PositionView2;
+  return /* @__PURE__ */ React3.createElement(
     PositionComponent,
     {
       animatedScrollY: isSticky ? animatedScrollY : void 0,
@@ -584,11 +581,156 @@ var Container = typedMemo(function Container2({
       stickyOffset: isSticky ? stickyOffset : void 0,
       style
     },
-    /* @__PURE__ */ React2.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React2.createElement(Separator, { ItemSeparatorComponent, leadingItem: renderedItemInfo.item }))
+    /* @__PURE__ */ React3.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React3.createElement(Separator, { ItemSeparatorComponent, leadingItem: renderedItemInfo.item }))
   );
 });
 
+// src/platform/Platform.ts
+var Platform = {
+  // Widen the type to avoid unreachable-branch lints in cross-platform code that compares against other OSes
+  OS: "web"
+};
+
+// src/utils/reordering.ts
+var mapFn = (element) => {
+  const indexStr = element.getAttribute("index");
+  return [element, indexStr === null ? null : parseInt(indexStr)];
+};
+function sortDOMElements(container) {
+  const elements = Array.from(container.children);
+  if (elements.length <= 1) return elements;
+  const items = elements.map(mapFn);
+  items.sort((a, b) => {
+    const aKey = a[1];
+    const bKey = b[1];
+    if (aKey === null) {
+      return 1;
+    }
+    if (bKey === null) {
+      return -1;
+    }
+    return aKey - bKey;
+  });
+  const targetPositions = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    targetPositions.set(item[0], index);
+  });
+  const currentPositions = elements.map((el) => targetPositions.get(el));
+  const lis = findLIS(currentPositions);
+  const stableIndices = new Set(lis);
+  for (let targetPos = 0; targetPos < items.length; targetPos++) {
+    const element = items[targetPos][0];
+    const currentPos = elements.indexOf(element);
+    if (!stableIndices.has(currentPos)) {
+      let nextStableElement = null;
+      for (let i = targetPos + 1; i < items.length; i++) {
+        const nextEl = items[i][0];
+        const nextCurrentPos = elements.indexOf(nextEl);
+        if (stableIndices.has(nextCurrentPos)) {
+          nextStableElement = nextEl;
+          break;
+        }
+      }
+      if (nextStableElement) {
+        container.insertBefore(element, nextStableElement);
+      } else {
+        container.appendChild(element);
+      }
+    }
+  }
+}
+function findLIS(arr) {
+  const n = arr.length;
+  const tails = [];
+  const predecessors = new Array(n).fill(-1);
+  const indices = [];
+  for (let i = 0; i < n; i++) {
+    const num = arr[i];
+    let left = 0, right = tails.length;
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2);
+      if (arr[indices[mid]] < num) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    if (left === tails.length) {
+      tails.push(num);
+      indices.push(i);
+    } else {
+      tails[left] = num;
+      indices[left] = i;
+    }
+    if (left > 0) {
+      predecessors[i] = indices[left - 1];
+    }
+  }
+  const result = [];
+  let k = indices[indices.length - 1];
+  while (k !== -1) {
+    result.unshift(k);
+    k = predecessors[k];
+  }
+  return result;
+}
+
+// src/hooks/useDOMOrder.ts
+function useDOMOrder(ref) {
+  const ctx = useStateContext();
+  const debounceRef = useRef(void 0);
+  useEffect(() => {
+    const unsubscribe = listen$(ctx, "lastPositionUpdate", () => {
+      if (debounceRef.current !== void 0) {
+        clearTimeout(debounceRef.current);
+      }
+      debounceRef.current = setTimeout(() => {
+        const parent = ref.current;
+        if (parent) {
+          sortDOMElements(parent);
+        }
+        debounceRef.current = void 0;
+      }, 500);
+    });
+    return () => {
+      unsubscribe();
+      if (debounceRef.current !== void 0) {
+        clearTimeout(debounceRef.current);
+      }
+    };
+  }, [ctx]);
+}
+
 // src/components/Containers.tsx
+var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColumns, children }) {
+  const ref = useRef(null);
+  const ctx = useStateContext();
+  const columnWrapperStyle = ctx.columnWrapperStyle;
+  const [totalSize, otherAxisSize] = useArr$(["totalSize", "otherAxisSize"]);
+  useDOMOrder(ref);
+  const style = horizontal ? { minHeight: otherAxisSize, width: totalSize } : { height: totalSize, minWidth: otherAxisSize };
+  if (columnWrapperStyle && numColumns > 1) {
+    const { columnGap, rowGap, gap } = columnWrapperStyle;
+    const gapX = columnGap || gap || 0;
+    const gapY = rowGap || gap || 0;
+    if (horizontal) {
+      if (gapY) {
+        style.marginTop = style.marginBottom = -gapY / 2;
+      }
+      if (gapX) {
+        style.marginRight = -gapX;
+      }
+    } else {
+      if (gapX) {
+        style.marginLeft = style.marginRight = -gapX;
+      }
+      if (gapY) {
+        style.marginBottom = -gapY;
+      }
+    }
+  }
+  return /* @__PURE__ */ React3.createElement("div", { ref, style }, children);
+});
 var Containers = typedMemo(function Containers2({
   horizontal,
   recycleItems,
@@ -597,23 +739,11 @@ var Containers = typedMemo(function Containers2({
   updateItemSize: updateItemSize2,
   getRenderedItem: getRenderedItem2
 }) {
-  const ctx = useStateContext();
-  const columnWrapperStyle = ctx.columnWrapperStyle;
   const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
-  const animSize = useValue$("totalSize", {
-    // Use a microtask if increasing the size significantly, otherwise use a timeout
-    // If this is the initial scroll, we don't want to delay because we want to update the size immediately
-    delay: (value, prevValue) => {
-      var _a;
-      return !((_a = ctx.internalState) == null ? void 0 : _a.initialScroll) ? !prevValue || value - prevValue > 20 ? 0 : 200 : void 0;
-    }
-  });
-  const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("containersDidLayout", { getValue: (value) => value ? 1 : 0 }) : void 0;
-  const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
     containers.push(
-      /* @__PURE__ */ React2.createElement(
+      /* @__PURE__ */ React3.createElement(
         Container,
         {
           getRenderedItem: getRenderedItem2,
@@ -627,86 +757,268 @@ var Containers = typedMemo(function Containers2({
       )
     );
   }
-  const style = horizontal ? { minHeight: otherAxisSize, opacity: animOpacity, width: animSize } : { height: animSize, minWidth: otherAxisSize, opacity: animOpacity };
-  if (columnWrapperStyle && numColumns > 1) {
-    const { columnGap, rowGap, gap } = columnWrapperStyle;
-    const gapX = columnGap || gap || 0;
-    const gapY = rowGap || gap || 0;
-    if (horizontal) {
-      if (gapY) {
-        style.marginVertical = -gapY / 2;
+  return /* @__PURE__ */ React3.createElement(ContainersInner, { horizontal, numColumns, waitForInitialLayout }, containers);
+});
+function DevNumbers() {
+  return IS_DEV && React3.memo(function DevNumbers2() {
+    return Array.from({ length: 100 }).map((_, index) => /* @__PURE__ */ React3.createElement(
+      "div",
+      {
+        key: index,
+        style: {
+          height: 100,
+          pointerEvents: "none",
+          position: "absolute",
+          top: index * 100,
+          width: "100%"
+        }
+      },
+      /* @__PURE__ */ React3.createElement("div", { style: { color: "red" } }, index * 100)
+    ));
+  });
+}
+
+// src/platform/StyleSheet.tsx
+function flattenStyles(styles) {
+  if (Array.isArray(styles)) {
+    return Object.assign({}, ...styles.filter(Boolean));
+  }
+  return styles;
+}
+var StyleSheet = {
+  create: (styles) => styles,
+  flatten: (style) => flattenStyles(style)
+};
+
+// src/components/ListComponentScrollView.tsx
+var ListComponentScrollView = forwardRef(function ListComponentScrollView2({
+  children,
+  style,
+  contentContainerStyle,
+  horizontal = false,
+  contentOffset,
+  maintainVisibleContentPosition,
+  onScroll: onScroll2,
+  onMomentumScrollEnd,
+  showsHorizontalScrollIndicator = true,
+  showsVerticalScrollIndicator = true,
+  refreshControl,
+  onLayout,
+  ...props
+}, ref) {
+  const scrollRef = useRef(null);
+  const contentRef = useRef(null);
+  const momentumTimeout = useRef(null);
+  useImperativeHandle(ref, () => {
+    const api = {
+      getBoundingClientRect: () => {
+        var _a3;
+        return (_a3 = scrollRef.current) == null ? void 0 : _a3.getBoundingClientRect();
+      },
+      getScrollableNode: () => scrollRef.current,
+      getScrollResponder: () => scrollRef.current,
+      scrollBy: (x, y) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        el.scrollBy(x, y);
+      },
+      scrollTo: (options) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        const { x = 0, y = 0, animated = true } = options;
+        el.scrollTo({ behavior: animated ? "smooth" : "auto", left: x, top: y });
+      },
+      scrollToEnd: (options = {}) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        const { animated = true } = options;
+        if (horizontal) {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", left: el.scrollWidth });
+        } else {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", top: el.scrollHeight });
+        }
+      },
+      scrollToOffset: (params) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        const { offset, animated = true } = params;
+        if (horizontal) {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", left: offset });
+        } else {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", top: offset });
+        }
       }
-      if (gapX) {
-        style.marginRight = -gapX;
+    };
+    return api;
+  }, [horizontal]);
+  const handleScroll = useCallback(
+    (event) => {
+      if (!onScroll2 || !(event == null ? void 0 : event.target)) {
+        return;
       }
-    } else {
-      if (gapX) {
-        style.marginHorizontal = -gapX;
+      const target = event.target;
+      const scrollEvent = {
+        nativeEvent: {
+          contentOffset: {
+            x: target.scrollLeft,
+            y: target.scrollTop
+          },
+          contentSize: {
+            height: target.scrollHeight,
+            width: target.scrollWidth
+          },
+          layoutMeasurement: {
+            height: target.clientHeight,
+            width: target.clientWidth
+          }
+        }
+      };
+      onScroll2(scrollEvent);
+      if (onMomentumScrollEnd) {
+        if (momentumTimeout.current != null) clearTimeout(momentumTimeout.current);
+        momentumTimeout.current = setTimeout(() => {
+          onMomentumScrollEnd({
+            nativeEvent: {
+              contentOffset: scrollEvent.nativeEvent.contentOffset
+            }
+          });
+        }, 100);
       }
-      if (gapY) {
-        style.marginBottom = -gapY;
+    },
+    [onScroll2, onMomentumScrollEnd]
+  );
+  useLayoutEffect(() => {
+    const element = scrollRef.current;
+    if (!element) return;
+    element.addEventListener("scroll", handleScroll);
+    return () => {
+      element.removeEventListener("scroll", handleScroll);
+    };
+  }, [handleScroll]);
+  useEffect(() => {
+    const doScroll = () => {
+      if (contentOffset && scrollRef.current) {
+        scrollRef.current.scrollLeft = contentOffset.x || 0;
+        scrollRef.current.scrollTop = contentOffset.y || 0;
       }
-    }
-  }
-  return /* @__PURE__ */ React2.createElement(Animated.View, { style }, containers);
+    };
+    doScroll();
+    requestAnimationFrame(doScroll);
+  }, [contentOffset == null ? void 0 : contentOffset.x, contentOffset == null ? void 0 : contentOffset.y]);
+  useLayoutEffect(() => {
+    if (!onLayout || !scrollRef.current) return;
+    const element = scrollRef.current;
+    const fireLayout = () => {
+      const rect = element.getBoundingClientRect();
+      onLayout({
+        nativeEvent: {
+          layout: {
+            height: rect.height,
+            width: rect.width,
+            x: rect.left,
+            y: rect.top
+          }
+        }
+      });
+    };
+    fireLayout();
+    const resizeObserver = new ResizeObserver(() => {
+      fireLayout();
+    });
+    resizeObserver.observe(element);
+    return () => resizeObserver.disconnect();
+  }, [onLayout]);
+  const scrollViewStyle = {
+    overflow: "auto",
+    overflowX: horizontal ? "auto" : showsHorizontalScrollIndicator ? "auto" : "hidden",
+    overflowY: horizontal ? showsVerticalScrollIndicator ? "auto" : "hidden" : "auto",
+    position: "relative",
+    // Ensure proper positioning context
+    WebkitOverflowScrolling: "touch",
+    // iOS momentum scrolling
+    ...StyleSheet.flatten(style)
+  };
+  const contentStyle = {
+    display: horizontal ? "flex" : "block",
+    flexDirection: horizontal ? "row" : void 0,
+    minHeight: horizontal ? void 0 : "100%",
+    minWidth: horizontal ? "100%" : void 0,
+    ...StyleSheet.flatten(contentContainerStyle)
+  };
+  return /* @__PURE__ */ React3.createElement("div", { ref: scrollRef, style: scrollViewStyle, ...props }, refreshControl, /* @__PURE__ */ React3.createElement("div", { ref: contentRef, style: contentStyle }, children));
 });
-var LayoutView = ({ onLayoutChange, refView, ...rest }) => {
-  const ref = refView != null ? refView : useRef();
-  const { onLayout } = useOnLayoutSync({ onLayoutChange, ref });
-  return /* @__PURE__ */ React2.createElement(View, { ...rest, onLayout, ref });
-};
-function ScrollAdjust() {
-  const bias = 1e7;
-  const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
-  const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
-  return /* @__PURE__ */ React2.createElement(
-    View,
+function Padding() {
+  const [paddingTop] = useArr$(["alignItemsPaddingTop"]);
+  return /* @__PURE__ */ React3.createElement("div", { style: { paddingTop } });
+}
+function PaddingDevMode() {
+  const [paddingTop] = useArr$(["alignItemsPaddingTop"]);
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement("div", { style: { paddingTop } }), /* @__PURE__ */ React3.createElement(
+    "div",
     {
       style: {
-        height: 0,
+        backgroundColor: "green",
+        height: paddingTop,
         left: 0,
         position: "absolute",
-        top: scrollOffset,
-        width: 0
+        right: 0,
+        top: 0
       }
     }
-  );
+  ));
+}
+function useValueListener$(key, callback) {
+  const ctx = useStateContext();
+  useLayoutEffect(() => {
+    listen$(ctx, key, (value) => {
+      callback(value);
+    });
+  }, []);
+}
+
+// src/components/ScrollAdjust.tsx
+function ScrollAdjust() {
+  const ctx = useStateContext();
+  const lastScrollOffsetRef = React3.useRef(0);
+  const callback = React3.useCallback(() => {
+    var _a3;
+    const scrollAdjust = peek$(ctx, "scrollAdjust");
+    const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
+    const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
+    const scrollView = (_a3 = ctx.internalState) == null ? void 0 : _a3.refScroller.current;
+    if (scrollView && scrollOffset !== lastScrollOffsetRef.current) {
+      const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
+      if (scrollDelta !== 0) {
+        scrollView.scrollBy(0, scrollDelta);
+        console.log("ScrollAdjust (web scrollBy)", scrollDelta, "total offset:", scrollOffset);
+      }
+      lastScrollOffsetRef.current = scrollOffset;
+    }
+  }, []);
+  useValueListener$("scrollAdjust", callback);
+  useValueListener$("scrollAdjustUserOffset", callback);
+  return null;
 }
 function SnapWrapper({ ScrollComponent, ...props }) {
   const [snapToOffsets] = useArr$(["snapToOffsets"]);
-  return /* @__PURE__ */ React2.createElement(ScrollComponent, { ...props, snapToOffsets });
+  return /* @__PURE__ */ React3.createElement(ScrollComponent, { ...props, snapToOffsets });
 }
+var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
+  const ref = refView != null ? refView : useRef();
+  useOnLayoutSync({ onLayoutChange, ref });
+  return /* @__PURE__ */ React3.createElement("div", { ...rest, ref }, children);
+};
 
 // src/components/ListComponent.tsx
 var getComponent = (Component) => {
-  if (React2.isValidElement(Component)) {
+  if (React3.isValidElement(Component)) {
     return Component;
   }
   if (Component) {
-    return /* @__PURE__ */ React2.createElement(Component, null);
+    return /* @__PURE__ */ React3.createElement(Component, null);
   }
   return null;
 };
-var Padding = () => {
-  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React2.createElement(Animated.View, { style: { paddingTop: animPaddingTop } });
-};
-var PaddingDevMode = () => {
-  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React2.createElement(
-    Animated.View,
-    {
-      style: {
-        backgroundColor: "green",
-        height: animPaddingTop,
-        left: 0,
-        position: "absolute",
-        right: 0,
-        top: 0
-      }
-    }
-  ));
-};
 var ListComponent = typedMemo(function ListComponent2({
   canRender,
   style,
@@ -737,10 +1049,10 @@ var ListComponent = typedMemo(function ListComponent2({
 }) {
   const ctx = useStateContext();
   const ScrollComponent = renderScrollComponent ? useMemo(
-    () => React2.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
+    () => React3.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
     [renderScrollComponent]
-  ) : Animated.ScrollView;
-  React2.useEffect(() => {
+  ) : ListComponentScrollView;
+  React3.useEffect(() => {
     if (canRender) {
       setTimeout(() => {
         scrollAdjustHandler.setMounted();
@@ -748,7 +1060,7 @@ var ListComponent = typedMemo(function ListComponent2({
     }
   }, [canRender]);
   const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
-  return /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React3.createElement(
     SnapOrScroll,
     {
       ...rest,
@@ -767,11 +1079,11 @@ var ListComponent = typedMemo(function ListComponent2({
       ScrollComponent: snapToIndices ? ScrollComponent : void 0,
       style
     },
-    maintainVisibleContentPosition && /* @__PURE__ */ React2.createElement(ScrollAdjust, null),
-    ENABLE_DEVMODE ? /* @__PURE__ */ React2.createElement(PaddingDevMode, null) : /* @__PURE__ */ React2.createElement(Padding, null),
-    ListHeaderComponent && /* @__PURE__ */ React2.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
+    maintainVisibleContentPosition && /* @__PURE__ */ React3.createElement(ScrollAdjust, null),
+    ENABLE_DEVMODE ? /* @__PURE__ */ React3.createElement(PaddingDevMode, null) : /* @__PURE__ */ React3.createElement(Padding, null),
+    ListHeaderComponent && /* @__PURE__ */ React3.createElement(LayoutView, { onLayoutChange: onLayoutHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
     ListEmptyComponent && getComponent(ListEmptyComponent),
-    canRender && !ListEmptyComponent && /* @__PURE__ */ React2.createElement(
+    canRender && !ListEmptyComponent && /* @__PURE__ */ React3.createElement(
       Containers,
       {
         getRenderedItem: getRenderedItem2,
@@ -782,7 +1094,7 @@ var ListComponent = typedMemo(function ListComponent2({
         waitForInitialLayout
       }
     ),
-    ListFooterComponent && /* @__PURE__ */ React2.createElement(
+    ListFooterComponent && /* @__PURE__ */ React3.createElement(
       LayoutView,
       {
         onLayoutChange: (layout) => {
@@ -793,25 +1105,9 @@ var ListComponent = typedMemo(function ListComponent2({
       },
       getComponent(ListFooterComponent)
     ),
-    __DEV__ && ENABLE_DEVMODE && /* @__PURE__ */ React2.createElement(DevNumbers, null)
+    IS_DEV && ENABLE_DEVMODE && /* @__PURE__ */ React3.createElement(DevNumbers, null)
   );
 });
-var DevNumbers = __DEV__ && React2.memo(function DevNumbers2() {
-  return Array.from({ length: 100 }).map((_, index) => /* @__PURE__ */ React2.createElement(
-    View,
-    {
-      key: index,
-      style: {
-        height: 100,
-        pointerEvents: "none",
-        position: "absolute",
-        top: index * 100,
-        width: "100%"
-      }
-    },
-    /* @__PURE__ */ React2.createElement(Text, { style: { color: "red" } }, index * 100)
-  ));
-});
 
 // src/utils/getId.ts
 function getId(state, index) {
@@ -844,7 +1140,7 @@ function calculateOffsetForIndex(ctx, state, index) {
 
 // src/utils/getItemSize.ts
 function getItemSize(state, key, index, data, useAverageSize) {
-  var _a, _b;
+  var _a3, _b;
   const {
     sizesKnown,
     sizes,
@@ -857,7 +1153,7 @@ function getItemSize(state, key, index, data, useAverageSize) {
     return sizeKnown;
   }
   let size;
-  const itemType = getItemType ? (_a = getItemType(data, index)) != null ? _a : "" : "";
+  const itemType = getItemType ? (_a3 = getItemType(data, index)) != null ? _a3 : "" : "";
   if (getFixedItemSize) {
     size = getFixedItemSize(index, data, itemType);
     if (size !== void 0) {
@@ -906,7 +1202,7 @@ var finishScrollTo = (state) => {
 
 // src/core/scrollTo.ts
 function scrollTo(state, params = {}) {
-  var _a;
+  var _a3;
   const { animated, noScrollingTo, isInitialScroll } = params;
   const {
     refScroller,
@@ -919,7 +1215,7 @@ function scrollTo(state, params = {}) {
   }
   state.scrollPending = offset;
   if (!params.isInitialScroll || Platform.OS === "android") {
-    (_a = refScroller.current) == null ? void 0 : _a.scrollTo({
+    (_a3 = refScroller.current) == null ? void 0 : _a3.scrollTo({
       animated: !!animated,
       x: horizontal ? offset : 0,
       y: horizontal ? 0 : offset
@@ -939,14 +1235,8 @@ function scrollTo(state, params = {}) {
 // src/utils/requestAdjust.ts
 function requestAdjust(ctx, state, positionDiff, dataChanged) {
   if (Math.abs(positionDiff) > 0.1) {
-    const needsScrollWorkaround = Platform.OS === "android" && !IsNewArchitecture && dataChanged && state.scroll <= positionDiff;
     const doit = () => {
-      if (needsScrollWorkaround) {
-        scrollTo(state, {
-          noScrollingTo: true,
-          offset: state.scroll
-        });
-      } else {
+      {
         state.scrollAdjustHandler.requestAdjust(positionDiff);
       }
     };
@@ -971,7 +1261,7 @@ function requestAdjust(ctx, state, positionDiff, dataChanged) {
         () => {
           state.ignoreScrollFromMVCP = void 0;
         },
-        needsScrollWorkaround ? 250 : 100
+        100
       );
     } else {
       requestAnimationFrame(doit);
@@ -1040,14 +1330,14 @@ function prepareMVCP(ctx, state, dataChanged) {
       }
     }
     if (positionDiff !== void 0 && Math.abs(positionDiff) > 0.1) {
-      requestAdjust(ctx, state, positionDiff, dataChanged);
+      requestAdjust(ctx, state, positionDiff);
     }
   };
 }
 
 // src/core/prepareColumnStartState.ts
 function prepareColumnStartState(ctx, state, startIndex, useAverageSize) {
-  var _a;
+  var _a3;
   const numColumns = peek$(ctx, "numColumns");
   let rowStartIndex = startIndex;
   const columnAtStart = state.columns.get(state.idCache[startIndex]);
@@ -1060,7 +1350,7 @@ function prepareColumnStartState(ctx, state, startIndex, useAverageSize) {
   if (rowStartIndex > 0) {
     const prevIndex = rowStartIndex - 1;
     const prevId = state.idCache[prevIndex];
-    const prevPosition = (_a = state.positions.get(prevId)) != null ? _a : 0;
+    const prevPosition = (_a3 = state.positions.get(prevId)) != null ? _a3 : 0;
     const prevRowStart = findRowStartIndex(state, numColumns, prevIndex);
     const prevRowHeight = calculateRowMaxSize(state, prevRowStart, prevIndex, useAverageSize);
     currentRowTop = prevPosition + prevRowHeight;
@@ -1201,7 +1491,7 @@ function updateSnapToOffsets(ctx, state) {
 
 // src/core/updateItemPositions.ts
 function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottomBuffered } = { scrollBottomBuffered: -1, startIndex: 0 }) {
-  var _a, _b, _c, _d;
+  var _a3, _b, _c, _d;
   const {
     columns,
     indexByKey,
@@ -1214,7 +1504,7 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
   const dataLength = data.length;
   const numColumns = peek$(ctx, "numColumns");
   const hasColumns = numColumns > 1;
-  const indexByKeyForChecking = __DEV__ ? /* @__PURE__ */ new Map() : void 0;
+  const indexByKeyForChecking = IS_DEV ? /* @__PURE__ */ new Map() : void 0;
   const maxVisibleArea = scrollBottomBuffered + 1e3;
   const useAverageSize = enableAverages && !getEstimatedItemSize;
   let currentRowTop = 0;
@@ -1233,7 +1523,7 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
     } else if (startIndex < dataLength) {
       const prevIndex = startIndex - 1;
       const prevId = getId(state, prevIndex);
-      const prevPosition = (_a = positions.get(prevId)) != null ? _a : 0;
+      const prevPosition = (_a3 = positions.get(prevId)) != null ? _a3 : 0;
       const prevSize = (_b = sizesKnown.get(prevId)) != null ? _b : getItemSize(state, prevId, prevIndex, data[prevIndex], useAverageSize);
       currentRowTop = prevPosition + prevSize;
     }
@@ -1252,7 +1542,7 @@ function updateItemPositions(ctx, state, dataChanged, { startIndex, scrollBottom
     }
     const id = (_c = idCache[i]) != null ? _c : getId(state, i);
     const size = (_d = sizesKnown.get(id)) != null ? _d : getItemSize(state, id, i, data[i], useAverageSize);
-    if (__DEV__ && needsIndexByKey) {
+    if (IS_DEV && needsIndexByKey) {
       if (indexByKeyForChecking.has(id)) {
         console.error(
           `[legend-list] Error: Detected overlapping key (${id}) which causes missing items and gaps and other terrrible things. Check that keyExtractor returns unique values.`
@@ -1485,7 +1775,6 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
   const cb = ctx.mapViewabilityCallbacks.get(key);
   cb == null ? void 0 : cb(viewToken);
 }
-var batchedUpdates = unstable_batchedUpdates || ((callback) => callback());
 
 // src/utils/checkAllSizesKnown.ts
 function isNullOrUndefined2(value) {
@@ -1598,7 +1887,7 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
       for (let i = 0; i < stillNeeded; i++) {
         result.push(numContainers + i);
       }
-      if (__DEV__ && numContainers + stillNeeded > peek$(ctx, "numContainersPooled")) {
+      if (IS_DEV && numContainers + stillNeeded > 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 or increasing initialContainerPoolRatio.",
           {
@@ -1686,28 +1975,44 @@ function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, vie
 }
 
 // src/utils/checkThreshold.ts
-var checkThreshold = (distance, atThreshold, threshold, isReached, isBlockedByTimer, onReached, blockTimer) => {
-  const distanceAbs = Math.abs(distance);
-  const isAtThreshold = atThreshold || distanceAbs < threshold;
-  if (!isReached && !isBlockedByTimer) {
-    if (isAtThreshold) {
-      onReached == null ? void 0 : onReached(distance);
-      blockTimer == null ? void 0 : blockTimer(true);
-      setTimeout(() => {
-        blockTimer == null ? void 0 : blockTimer(false);
-      }, 700);
-      return true;
-    }
-  } else {
-    if (distance >= 1.3 * threshold) {
+var HYSTERESIS_MULTIPLIER = 1.3;
+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 == null ? void 0 : setSnapshot({
+      atThreshold,
+      contentSize: context.contentSize,
+      dataLength: context.dataLength,
+      scrollPosition: context.scrollPosition
+    });
+  };
+  if (!wasReached) {
+    if (!within) {
       return false;
     }
+    onReached == null ? void 0 : onReached(distance);
+    updateSnapshot();
+    return true;
+  }
+  const reset = !atThreshold && threshold > 0 && absDistance >= threshold * HYSTERESIS_MULTIPLIER || !atThreshold && threshold <= 0 && absDistance > 0;
+  if (reset) {
+    setSnapshot == null ? void 0 : setSnapshot(void 0);
+    return false;
+  }
+  if (within) {
+    const changed = !snapshot || snapshot.atThreshold !== atThreshold || snapshot.contentSize !== context.contentSize || snapshot.dataLength !== context.dataLength;
+    if (changed) {
+      onReached == null ? void 0 : onReached(distance);
+      updateSnapshot();
+    }
   }
-  return isReached;
+  return true;
 };
 
 // src/utils/checkAtBottom.ts
 function checkAtBottom(ctx, state) {
+  var _a3;
   if (!state) {
     return;
   }
@@ -1728,13 +2033,18 @@ function checkAtBottom(ctx, state) {
       isContentLess,
       onEndReachedThreshold * scrollLength,
       state.isEndReached,
-      state.endReachedBlockedByTimer,
+      state.endReachedSnapshot,
+      {
+        scrollPosition: scroll,
+        contentSize,
+        dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length
+      },
       (distance) => {
-        var _a, _b;
-        return (_b = (_a = state.props).onEndReached) == null ? void 0 : _b.call(_a, { distanceFromEnd: distance });
+        var _a4, _b;
+        return (_b = (_a4 = state.props).onEndReached) == null ? void 0 : _b.call(_a4, { distanceFromEnd: distance });
       },
-      (block) => {
-        state.endReachedBlockedByTimer = block;
+      (snapshot) => {
+        state.endReachedSnapshot = snapshot;
       }
     );
   }
@@ -1755,30 +2065,19 @@ function setDidLayout(ctx, state) {
       onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
     }
   };
-  if (Platform.OS === "android" && initialScroll) {
-    if (IsNewArchitecture) {
-      scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-      requestAnimationFrame(() => {
-        scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-        setIt();
-      });
-    } else {
-      scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-      setIt();
-    }
-  } else {
+  {
     setIt();
   }
 }
 
 // src/core/calculateItemsInView.ts
 function findCurrentStickyIndex(stickyArray, scroll, state) {
-  var _a;
+  var _a3;
   const idCache = state.idCache;
   const positions = state.positions;
   for (let i = stickyArray.length - 1; i >= 0; i--) {
     const stickyIndex = stickyArray[i];
-    const stickyId = (_a = idCache[stickyIndex]) != null ? _a : getId(state, stickyIndex);
+    const stickyId = (_a3 = idCache[stickyIndex]) != null ? _a3 : getId(state, stickyIndex);
     const stickyPos = stickyId ? positions.get(stickyId) : void 0;
     if (stickyPos !== void 0 && scroll >= stickyPos) {
       return i;
@@ -1792,21 +2091,21 @@ function getActiveStickyIndices(ctx, state, stickyIndices) {
   );
 }
 function handleStickyActivation(ctx, state, stickyIndices, stickyArray, currentStickyIdx, needNewContainers, startBuffered, endBuffered) {
-  var _a;
+  var _a3;
   const activeIndices = getActiveStickyIndices(ctx, state, stickyIndices);
   state.activeStickyIndex = currentStickyIdx >= 0 ? stickyArray[currentStickyIdx] : void 0;
   for (let offset = 0; offset <= 1; offset++) {
     const idx = currentStickyIdx - offset;
     if (idx < 0 || activeIndices.has(stickyArray[idx])) continue;
     const stickyIndex = stickyArray[idx];
-    const stickyId = (_a = state.idCache[stickyIndex]) != null ? _a : getId(state, stickyIndex);
+    const stickyId = (_a3 = state.idCache[stickyIndex]) != null ? _a3 : getId(state, stickyIndex);
     if (stickyId && !state.containerItemKeys.has(stickyId) && (stickyIndex < startBuffered || stickyIndex > endBuffered)) {
       needNewContainers.push(stickyIndex);
     }
   }
 }
 function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, currentStickyIdx, pendingRemoval) {
-  var _a, _b, _c;
+  var _a3, _b, _c;
   for (const containerIndex of state.stickyContainerPool) {
     const itemKey = peek$(ctx, `containerItemKey${containerIndex}`);
     const itemIndex = itemKey ? state.indexByKey.get(itemKey) : void 0;
@@ -1823,7 +2122,7 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
     const nextIndex = stickyArray[arrayIdx + 1];
     let shouldRecycle = false;
     if (nextIndex) {
-      const nextId = (_a = state.idCache[nextIndex]) != null ? _a : getId(state, nextIndex);
+      const nextId = (_a3 = state.idCache[nextIndex]) != null ? _a3 : getId(state, nextIndex);
       const nextPos = nextId ? state.positions.get(nextId) : void 0;
       shouldRecycle = nextPos !== void 0 && scroll > nextPos + scrollBuffer * 2;
     } else {
@@ -1840,8 +2139,8 @@ function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, cu
   }
 }
 function calculateItemsInView(ctx, state, params = {}) {
-  batchedUpdates(() => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  unstable_batchedUpdates(() => {
+    var _a3, _b, _c, _d, _e, _f, _g, _h, _i;
     const {
       columns,
       containerItemKeys,
@@ -1917,7 +2216,7 @@ function calculateItemsInView(ctx, state, params = {}) {
       idCache.length = 0;
       positions.clear();
     }
-    const startIndex = dataChanged ? 0 : (_a = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _a : 0;
+    const startIndex = dataChanged ? 0 : (_a3 = minIndexSizeChanged != null ? minIndexSizeChanged : state.startBuffered) != null ? _a3 : 0;
     updateItemPositions(ctx, state, dataChanged, { scrollBottomBuffered, startIndex });
     if (minIndexSizeChanged !== void 0) {
       state.minIndexSizeChanged = void 0;
@@ -2092,6 +2391,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     if (stickyIndicesArr.length > 0) {
       handleStickyRecycling(ctx, state, stickyIndicesArr, scroll, scrollBuffer, currentStickyIdx, pendingRemoval);
     }
+    let didChangePositions = false;
     for (let i = 0; i < numContainers; i++) {
       const itemKey = peek$(ctx, `containerItemKey${i}`);
       if (pendingRemoval.includes(i)) {
@@ -2123,6 +2423,7 @@ function calculateItemsInView(ctx, state, params = {}) {
             const prevData = peek$(ctx, `containerItemData${i}`);
             if (position > POSITION_OUT_OF_VIEW && position !== prevPos) {
               set$(ctx, `containerPosition${i}`, position);
+              didChangePositions = true;
             }
             if (column >= 0 && column !== prevColumn) {
               set$(ctx, `containerColumn${i}`, column);
@@ -2134,6 +2435,9 @@ function calculateItemsInView(ctx, state, params = {}) {
         }
       }
     }
+    if (didChangePositions) {
+      set$(ctx, "lastPositionUpdate", Date.now());
+    }
     if (!queuedInitialLayout && endBuffered !== null) {
       if (checkAllSizesKnown(state)) {
         setDidLayout(ctx, state);
@@ -2163,10 +2467,10 @@ function doMaintainScrollAtEnd(ctx, state, animated) {
       state.scroll = 0;
     }
     requestAnimationFrame(() => {
-      var _a;
+      var _a3;
       if (state == null ? void 0 : state.isAtEnd) {
         state.maintainingScrollAtEnd = true;
-        (_a = refScroller.current) == null ? void 0 : _a.scrollToEnd({
+        (_a3 = refScroller.current) == null ? void 0 : _a3.scrollToEnd({
           animated
         });
         setTimeout(
@@ -2183,6 +2487,7 @@ function doMaintainScrollAtEnd(ctx, state, animated) {
 
 // src/utils/checkAtTop.ts
 function checkAtTop(state) {
+  var _a3;
   if (!state) {
     return;
   }
@@ -2198,20 +2503,25 @@ function checkAtTop(state) {
     false,
     onStartReachedThreshold * scrollLength,
     state.isStartReached,
-    state.startReachedBlockedByTimer,
+    state.startReachedSnapshot,
+    {
+      scrollPosition: scroll,
+      contentSize: state.totalSize,
+      dataLength: (_a3 = state.props.data) == null ? void 0 : _a3.length
+    },
     (distance) => {
-      var _a, _b;
-      return (_b = (_a = state.props).onStartReached) == null ? void 0 : _b.call(_a, { distanceFromStart: distance });
+      var _a4, _b;
+      return (_b = (_a4 = state.props).onStartReached) == null ? void 0 : _b.call(_a4, { distanceFromStart: distance });
     },
-    (block) => {
-      state.startReachedBlockedByTimer = block;
+    (snapshot) => {
+      state.startReachedSnapshot = snapshot;
     }
   );
 }
 
 // src/utils/updateAveragesOnDataChange.ts
 function updateAveragesOnDataChange(state, oldData, newData) {
-  var _a;
+  var _a3;
   const {
     averageSizes,
     sizesKnown,
@@ -2237,7 +2547,7 @@ function updateAveragesOnDataChange(state, oldData, newData) {
       const oldItem = oldData[oldIndex];
       const areEqual = itemsAreEqual(oldItem, newItem, newIndex, newData);
       if (areEqual) {
-        const itemType = getItemType ? (_a = getItemType(newItem, newIndex)) != null ? _a : "" : "";
+        const itemType = getItemType ? (_a3 = getItemType(newItem, newIndex)) != null ? _a3 : "" : "";
         let typeData = itemTypesToPreserve[itemType];
         if (!typeData) {
           typeData = itemTypesToPreserve[itemType] = { count: 0, totalSize: 0 };
@@ -2285,7 +2595,7 @@ function checkResetContainers(ctx, state, isFirst, dataProp) {
 
 // src/core/doInitialAllocateContainers.ts
 function doInitialAllocateContainers(ctx, state) {
-  var _a, _b, _c;
+  var _a3, _b, _c;
   const {
     scrollLength,
     props: {
@@ -2306,7 +2616,7 @@ function doInitialAllocateContainers(ctx, state) {
       const num = Math.min(20, data.length);
       for (let i = 0; i < num; i++) {
         const item = data[i];
-        const itemType = getItemType ? (_a = getItemType(item, i)) != null ? _a : "" : "";
+        const itemType = getItemType ? (_a3 = getItemType(item, i)) != null ? _a3 : "" : "";
         totalSize += (_c = (_b = getFixedItemSize == null ? void 0 : getFixedItemSize(i, item, itemType)) != null ? _b : getEstimatedItemSize == null ? void 0 : getEstimatedItemSize(i, item, itemType)) != null ? _c : estimatedItemSize;
       }
       averageItemSize = totalSize / num;
@@ -2320,7 +2630,7 @@ function doInitialAllocateContainers(ctx, state) {
     }
     set$(ctx, "numContainers", numContainers);
     set$(ctx, "numContainersPooled", numContainers * state.props.initialContainerPoolRatio);
-    if (!IsNewArchitecture || state.lastLayout) {
+    if (state.lastLayout) {
       if (state.props.initialScroll) {
         requestAnimationFrame(() => {
           calculateItemsInView(ctx, state, { dataChanged: true, doMVCP: true });
@@ -2367,7 +2677,7 @@ function handleLayout(ctx, state, layout, setCanRender) {
     if (state) {
       state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
     }
-    if (__DEV__ && measuredLength === 0) {
+    if (IS_DEV && measuredLength === 0) {
       warnDevOnce(
         "height0",
         `List ${state.props.horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
@@ -2379,7 +2689,7 @@ function handleLayout(ctx, state, layout, setCanRender) {
 
 // src/core/onScroll.ts
 function onScroll(ctx, state, event) {
-  var _a, _b, _c;
+  var _a3, _b, _c;
   const {
     scrollProcessingEnabled,
     props: { onScroll: onScrollProp }
@@ -2387,7 +2697,7 @@ function onScroll(ctx, state, event) {
   if (scrollProcessingEnabled === false) {
     return;
   }
-  if (((_b = (_a = event.nativeEvent) == null ? void 0 : _a.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
+  if (((_b = (_a3 = event.nativeEvent) == null ? void 0 : _a3.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
     return;
   }
   const newScroll = event.nativeEvent.contentOffset[state.props.horizontal ? "x" : "y"];
@@ -2461,7 +2771,7 @@ var ScrollAdjustHandler = class {
 
 // src/core/updateItemSize.ts
 function updateItemSize(ctx, state, itemKey, sizeObj) {
-  var _a;
+  var _a3;
   const {
     sizesKnown,
     props: {
@@ -2484,7 +2794,7 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
     if (itemData === void 0) {
       return;
     }
-    const type = getItemType ? (_a = getItemType(itemData, index)) != null ? _a : "" : "";
+    const type = getItemType ? (_a3 = getItemType(itemData, index)) != null ? _a3 : "" : "";
     const size2 = getFixedItemSize(index, itemData, type);
     if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
       return;
@@ -2530,13 +2840,13 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
   if (minIndexSizeChanged !== void 0) {
     state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
   }
-  if (__DEV__ && suggestEstimatedItemSize && minIndexSizeChanged !== void 0) {
+  if (IS_DEV && suggestEstimatedItemSize && minIndexSizeChanged !== void 0) {
     if (state.timeoutSizeMessage) clearTimeout(state.timeoutSizeMessage);
     state.timeoutSizeMessage = setTimeout(() => {
-      var _a2;
+      var _a4;
       state.timeoutSizeMessage = void 0;
       const num = state.sizesKnown.size;
-      const avg = (_a2 = state.averageSizes[""]) == null ? void 0 : _a2.avg;
+      const avg = (_a4 = state.averageSizes[""]) == null ? void 0 : _a4.avg;
       console.warn(
         `[legend-list] Based on the ${num} items rendered so far, the optimal estimated size is ${avg}.`
       );
@@ -2559,7 +2869,7 @@ function updateItemSize(ctx, state, itemKey, sizeObj) {
   }
 }
 function updateOneItemSize(state, itemKey, sizeObj) {
-  var _a;
+  var _a3;
   const {
     sizes,
     indexByKey,
@@ -2570,10 +2880,11 @@ function updateOneItemSize(state, itemKey, sizeObj) {
   if (!data) return 0;
   const index = indexByKey.get(itemKey);
   const prevSize = getItemSize(state, itemKey, index, data[index]);
-  const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+  const rawSize = horizontal ? sizeObj.width : sizeObj.height;
+  const size = Math.round(rawSize) ;
   sizesKnown.set(itemKey, size);
   if (!getEstimatedItemSize && !getFixedItemSize && size > 0) {
-    const itemType = getItemType ? (_a = getItemType(data[index], index)) != null ? _a : "" : "";
+    const itemType = getItemType ? (_a3 = getItemType(data[index], index)) != null ? _a3 : "" : "";
     let averages = averageSizes[itemType];
     if (!averages) {
       averages = averageSizes[itemType] = { avg: 0, num: 0 };
@@ -2603,6 +2914,16 @@ var useCombinedRef = (...refs) => {
   return callback;
 };
 
+// src/platform/RefreshControl.tsx
+function RefreshControl(_props) {
+  return null;
+}
+
+// src/platform/useStickyScrollHandler.ts
+function useStickyScrollHandler(_stickyIndices, _horizontal, _ctx, onScroll2) {
+  return onScroll2;
+}
+
 // src/utils/createColumnWrapperStyle.ts
 function createColumnWrapperStyle(contentContainerStyle) {
   const { gap, columnGap, rowGap } = contentContainerStyle;
@@ -2618,7 +2939,7 @@ function createColumnWrapperStyle(contentContainerStyle) {
   }
 }
 function getRenderedItem(ctx, state, key) {
-  var _a;
+  var _a3;
   if (!state) {
     return null;
   }
@@ -2639,9 +2960,9 @@ function getRenderedItem(ctx, state, key) {
       extraData,
       index,
       item,
-      type: getItemType ? (_a = getItemType(item, index)) != null ? _a : "" : ""
+      type: getItemType ? (_a3 = getItemType(item, index)) != null ? _a3 : "" : ""
     };
-    renderedItem = isFunction(renderItem) ? renderItem(itemProps) : React2__default.createElement(renderItem, itemProps);
+    renderedItem = isFunction(renderItem) ? renderItem(itemProps) : React3__default.createElement(renderItem, itemProps);
   }
   return { index, item: data[index], renderedItem };
 }
@@ -2700,18 +3021,18 @@ var LegendList = typedMemo(
     const isChildrenMode = children !== void 0 && dataProp === void 0;
     const processedProps = isChildrenMode ? {
       ...restProps,
-      data: (isArray(children) ? children : React2.Children.toArray(children)).flat(1),
+      data: (isArray(children) ? children : React3.Children.toArray(children)).flat(1),
       renderItem: ({ item }) => item
     } : {
       ...restProps,
       data: dataProp || [],
       renderItem: renderItemProp
     };
-    return /* @__PURE__ */ React2.createElement(StateProvider, null, /* @__PURE__ */ React2.createElement(LegendListInner, { ...processedProps, ref: forwardedRef }));
+    return /* @__PURE__ */ React3.createElement(StateProvider, null, /* @__PURE__ */ React3.createElement(LegendListInner, { ...processedProps, ref: forwardedRef }));
   })
 );
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a;
+  var _a3;
   const {
     alignItemsAtEnd = false,
     columnWrapperStyle,
@@ -2767,7 +3088,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   } = props;
   const [renderNum, setRenderNum] = useState(0);
   const initialScroll = initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? { index: initialScrollIndexProp.index || 0, viewOffset: initialScrollIndexProp.viewOffset || 0 } : { index: initialScrollIndexProp || 0, viewOffset: initialScrollOffsetProp || 0 } : void 0;
-  const [canRender, setCanRender] = React2.useState(!IsNewArchitecture);
+  const [canRender, setCanRender] = React3.useState(!IsNewArchitecture);
   const contentContainerStyle = { ...StyleSheet.flatten(contentContainerStyleProp) };
   const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
@@ -2782,7 +3103,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const refState = useRef();
   if (!refState.current) {
     if (!ctx.internalState) {
-      const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { height: 0, width: 0 } : Dimensions.get("window"))[horizontal ? "width" : "height"];
+      const initialScrollLength = (estimatedListSize != null ? estimatedListSize : { height: 0, width: 0 } )[horizontal ? "width" : "height"];
       ctx.internalState = {
         activeStickyIndex: void 0,
         averageSizes: {},
@@ -2793,7 +3114,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         enableScrollForNextCalculateItemsInView: true,
         endBuffered: -1,
         endNoBuffer: -1,
-        endReachedBlockedByTimer: false,
+        endReachedSnapshot: void 0,
         firstFullyOnScreenIndex: -1,
         idCache: [],
         idsInView: [],
@@ -2826,7 +3147,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         sizesKnown: /* @__PURE__ */ new Map(),
         startBuffered: -1,
         startNoBuffer: -1,
-        startReachedBlockedByTimer: false,
+        startReachedSnapshot: void 0,
         stickyContainerPool: /* @__PURE__ */ new Set(),
         stickyContainers: /* @__PURE__ */ new Map(),
         timeoutSizeMessage: 0,
@@ -2936,7 +3257,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   if (isFirst || didDataChange || numColumnsProp !== peek$(ctx, "numColumns")) {
     refState.current.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirst && didDataChange) {
-      __DEV__ && warnDevOnce(
+      IS_DEV && warnDevOnce(
         "keyExtractor",
         "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
       );
@@ -2948,14 +3269,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     const size = rect[horizontal ? "width" : "height"];
     set$(ctx, "headerSize", size);
     if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
-      if (IsNewArchitecture && Platform.OS !== "android") {
+      {
         if (fromLayoutEffect) {
           setRenderNum((v) => v + 1);
         }
-      } else {
-        setTimeout(() => {
-          scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-        }, 17);
       }
     }
   }, []);
@@ -2994,11 +3311,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     state.viewabilityConfigCallbackPairs = viewability;
     state.enableScrollForNextCalculateItemsInView = !viewability;
   }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  if (!IsNewArchitecture) {
-    useInit(() => {
-      doInitialAllocateContainers(ctx, state);
-    });
-  }
   const onLayoutChange = useCallback((layout) => {
     handleLayout(ctx, state, layout, setCanRender);
   }, []);
@@ -3090,10 +3402,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       }
     };
   }, []);
-  if (Platform.OS === "web") {
+  {
     useEffect(() => {
       if (initialContentOffset) {
-        scrollTo(state, { animated: false, offset: initialContentOffset });
+        scrollTo(state, { animated: false, offset: initialContentOffset, ...initialScroll || {} });
       }
     }, []);
   }
@@ -3105,18 +3417,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }),
     []
   );
-  const onScrollHandler = useMemo(() => {
-    const onScrollFn = fns.onScroll;
-    if (stickyIndices == null ? void 0 : stickyIndices.length) {
-      const { animatedScrollY } = ctx;
-      return Animated.event([{ nativeEvent: { contentOffset: { [horizontal ? "x" : "y"]: animatedScrollY } } }], {
-        listener: onScrollFn,
-        useNativeDriver: true
-      });
-    }
-    return onScrollFn;
-  }, [stickyIndices == null ? void 0 : stickyIndices.length, horizontal, scrollEventThrottle]);
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(
+  const onScrollHandler = useStickyScrollHandler(stickyIndices, horizontal, ctx, fns.onScroll);
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(
     ListComponent,
     {
       ...rest,
@@ -3132,14 +3434,10 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onLayout,
       onLayoutHeader,
       onMomentumScrollEnd: (event) => {
-        if (IsNewArchitecture) {
+        {
           requestAnimationFrame(() => {
             finishScrollTo(refState.current);
           });
-        } else {
-          setTimeout(() => {
-            finishScrollTo(refState.current);
-          }, 1e3);
         }
         if (onMomentumScrollEnd) {
           onMomentumScrollEnd(event);
@@ -3147,9 +3445,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       },
       onScroll: onScrollHandler,
       recycleItems,
-      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React2.cloneElement(refreshControl, {
+      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React3.cloneElement(refreshControl, {
         progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState
-      }) : refreshControl : onRefresh && /* @__PURE__ */ React2.createElement(
+      }) : refreshControl : onRefresh && /* @__PURE__ */ React3.createElement(
         RefreshControl,
         {
           onRefresh,
@@ -3158,15 +3456,15 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         }
       ),
       refScrollView: combinedRef,
-      scrollAdjustHandler: (_a = refState.current) == null ? void 0 : _a.scrollAdjustHandler,
-      scrollEventThrottle: Platform.OS === "web" ? 16 : void 0,
+      scrollAdjustHandler: (_a3 = refState.current) == null ? void 0 : _a3.scrollAdjustHandler,
+      scrollEventThrottle: 16 ,
       snapToIndices,
       stickyIndices,
       style,
       updateItemSize: fns.updateItemSize,
       waitForInitialLayout
     }
-  ), __DEV__ && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React2.createElement(DebugView, { state: refState.current }));
+  ), IS_DEV && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React3.createElement(DebugView, { state: refState.current }));
 });
 
 export { LegendList, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useSyncLayout, useViewability, useViewabilityAmount };