@legendapp/list 2.0.0-next.0 → 2.0.0-next.2

package/index.mjs

@@ -1,2320 +0,0 @@
-import * as React2 from 'react';
-import { useReducer, useEffect, createContext, useMemo, useState, useRef, useCallback, useLayoutEffect, useImperativeHandle, useContext, forwardRef, memo } from 'react';
-import { View, Text, Platform, Animated, ScrollView, StyleSheet, Dimensions, RefreshControl } from 'react-native';
-import { useSyncExternalStore } from 'use-sync-external-store/shim';
-
-// src/LegendList.tsx
-var ContextState = React2.createContext(null);
-function StateProvider({ children }) {
-  const [value] = React2.useState(() => ({
-    listeners: /* @__PURE__ */ new Map(),
-    values: /* @__PURE__ */ new Map([
-      ["alignItemsPaddingTop", 0],
-      ["stylePaddingTop", 0],
-      ["headerSize", 0]
-    ]),
-    mapViewabilityCallbacks: /* @__PURE__ */ new Map(),
-    mapViewabilityValues: /* @__PURE__ */ new Map(),
-    mapViewabilityAmountCallbacks: /* @__PURE__ */ new Map(),
-    mapViewabilityAmountValues: /* @__PURE__ */ new Map(),
-    columnWrapperStyle: void 0,
-    viewRefs: /* @__PURE__ */ new Map()
-  }));
-  return /* @__PURE__ */ React2.createElement(ContextState.Provider, { value }, children);
-}
-function useStateContext() {
-  return React2.useContext(ContextState);
-}
-function createSelectorFunctionsArr(ctx, signalNames) {
-  let lastValues = [];
-  let lastSignalValues = [];
-  return {
-    subscribe: (cb) => {
-      const listeners = [];
-      for (const signalName of signalNames) {
-        listeners.push(listen$(ctx, signalName, cb));
-      }
-      return () => {
-        for (const listener of listeners) {
-          listener();
-        }
-      };
-    },
-    get: () => {
-      const currentValues = [];
-      let hasChanged = false;
-      for (let i = 0; i < signalNames.length; i++) {
-        const value = peek$(ctx, signalNames[i]);
-        currentValues.push(value);
-        if (value !== lastSignalValues[i]) {
-          hasChanged = true;
-        }
-      }
-      lastSignalValues = currentValues;
-      if (hasChanged) {
-        lastValues = currentValues;
-      }
-      return lastValues;
-    }
-  };
-}
-function listen$(ctx, signalName, cb) {
-  const { listeners } = ctx;
-  let setListeners = listeners.get(signalName);
-  if (!setListeners) {
-    setListeners = /* @__PURE__ */ new Set();
-    listeners.set(signalName, setListeners);
-  }
-  setListeners.add(cb);
-  return () => setListeners.delete(cb);
-}
-function peek$(ctx, signalName) {
-  const { values } = ctx;
-  return values.get(signalName);
-}
-function set$(ctx, signalName, value) {
-  const { listeners, values } = ctx;
-  if (values.get(signalName) !== value) {
-    values.set(signalName, value);
-    const setListeners = listeners.get(signalName);
-    if (setListeners) {
-      for (const listener of setListeners) {
-        listener(value);
-      }
-    }
-  }
-}
-function getContentSize(ctx) {
-  const { values } = ctx;
-  const stylePaddingTop = values.get("stylePaddingTop") || 0;
-  const headerSize = values.get("headerSize") || 0;
-  const footerSize = values.get("footerSize") || 0;
-  const totalSize = values.get("totalSize") || 0;
-  return headerSize + footerSize + totalSize + stylePaddingTop;
-}
-function useArr$(signalNames) {
-  const ctx = React2.useContext(ContextState);
-  const { subscribe, get } = React2.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 value = useSyncExternalStore(subscribe, () => selector(get()[0]));
-  return value;
-}
-
-// src/DebugView.tsx
-var DebugRow = ({ children }) => {
-  return /* @__PURE__ */ React2.createElement(View, { style: { flexDirection: "row", alignItems: "center", justifyContent: "space-between" } }, children);
-};
-var DebugView = React2.memo(function DebugView2({ state }) {
-  const ctx = useStateContext();
-  const [totalSize = 0, scrollAdjust = 0, rawScroll = 0, scroll = 0, numContainers = 0, numContainersPooled = 0] = useArr$([
-    "totalSize",
-    "scrollAdjust",
-    "debugRawScroll",
-    "debugComputedScroll",
-    "numContainers",
-    "numContainersPooled"
-  ]);
-  const contentSize = getContentSize(ctx);
-  const [, forceUpdate] = useReducer((x) => x + 1, 0);
-  useInterval(() => {
-    forceUpdate();
-  }, 100);
-  return /* @__PURE__ */ React2.createElement(
-    View,
-    {
-      style: {
-        position: "absolute",
-        top: 0,
-        right: 0,
-        paddingLeft: 4,
-        paddingBottom: 4,
-        // height: 100,
-        backgroundColor: "#FFFFFFCC",
-        padding: 4,
-        borderRadius: 4
-      },
-      pointerEvents: "none"
-    },
-    /* @__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)))
-  );
-});
-function useInterval(callback, delay) {
-  useEffect(() => {
-    const interval = setInterval(callback, delay);
-    return () => clearInterval(interval);
-  }, [delay]);
-}
-
-// src/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 (__DEV__ && !warned.has(id)) {
-    warned.add(id);
-    console.warn(`[legend-list] ${text}`);
-  }
-}
-function isNullOrUndefined(value) {
-  return value === null || value === void 0;
-}
-function comparatorByDistance(a, b) {
-  return b.distance - a.distance;
-}
-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;
-}
-function extractPadding(style, contentContainerStyle, type) {
-  return getPadding(style, type) + getPadding(contentContainerStyle, type);
-}
-var symbolFirst = Symbol();
-function useInit(cb) {
-  const refValue = useRef(symbolFirst);
-  if (refValue.current === symbolFirst) {
-    refValue.current = cb();
-  }
-  return refValue.current;
-}
-
-// src/ContextContainer.ts
-var ContextContainer = createContext(null);
-function useViewability(callback, configId) {
-  const ctx = useStateContext();
-  const { containerId } = useContext(ContextContainer);
-  const key = containerId + (configId != null ? configId : "");
-  useInit(() => {
-    const value = ctx.mapViewabilityValues.get(key);
-    if (value) {
-      callback(value);
-    }
-  });
-  ctx.mapViewabilityCallbacks.set(key, callback);
-  useEffect(
-    () => () => {
-      ctx.mapViewabilityCallbacks.delete(key);
-    },
-    []
-  );
-}
-function useViewabilityAmount(callback) {
-  const ctx = useStateContext();
-  const { containerId } = useContext(ContextContainer);
-  useInit(() => {
-    const value = ctx.mapViewabilityAmountValues.get(containerId);
-    if (value) {
-      callback(value);
-    }
-  });
-  ctx.mapViewabilityAmountCallbacks.set(containerId, callback);
-  useEffect(
-    () => () => {
-      ctx.mapViewabilityAmountCallbacks.delete(containerId);
-    },
-    []
-  );
-}
-function useRecyclingEffect(effect) {
-  const { index, value } = useContext(ContextContainer);
-  const prevValues = useRef({
-    prevIndex: void 0,
-    prevItem: void 0
-  });
-  useEffect(() => {
-    let ret = void 0;
-    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;
-  }, [index, value]);
-}
-function useRecyclingState(valueOrFun) {
-  const { index, value, itemKey, triggerLayout } = useContext(ContextContainer);
-  const refState = useRef({
-    itemKey: null,
-    value: null
-  });
-  const [_, setRenderNum] = useState(0);
-  if (refState.current.itemKey !== itemKey) {
-    refState.current.itemKey = itemKey;
-    refState.current.value = isFunction(valueOrFun) ? valueOrFun({
-      index,
-      item: value,
-      prevIndex: void 0,
-      prevItem: void 0
-    }) : valueOrFun;
-  }
-  const setState = useCallback(
-    (newState) => {
-      refState.current.value = isFunction(newState) ? newState(refState.current.value) : newState;
-      setRenderNum((v) => v + 1);
-      triggerLayout();
-    },
-    [triggerLayout]
-  );
-  return [refState.current.value, setState];
-}
-function useIsLastItem() {
-  const { itemKey } = useContext(ContextContainer);
-  const isLast = useSelector$("lastItemKeys", (lastItemKeys) => (lastItemKeys == null ? void 0 : lastItemKeys.includes(itemKey)) || false);
-  return isLast;
-}
-function useListScrollSize() {
-  const [scrollSize] = useArr$(["scrollSize"]);
-  return scrollSize;
-}
-var LeanViewComponent = React2.forwardRef((props, ref) => {
-  return React2.createElement("RCTView", { ...props, ref });
-});
-LeanViewComponent.displayName = "RCTView";
-var LeanView = Platform.OS === "android" || Platform.OS === "ios" ? LeanViewComponent : View;
-
-// 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;
-
-// src/Container.tsx
-var Container = ({
-  id,
-  recycleItems,
-  horizontal,
-  getRenderedItem,
-  updateItemSize,
-  ItemSeparatorComponent
-}) => {
-  const ctx = useStateContext();
-  const columnWrapperStyle = ctx.columnWrapperStyle;
-  const [column = 0, data, itemKey, position = POSITION_OUT_OF_VIEW, numColumns, lastItemKeys, extraData] = useArr$([
-    `containerColumn${id}`,
-    `containerItemData${id}`,
-    `containerItemKey${id}`,
-    `containerPosition${id}`,
-    "numColumns",
-    "lastItemKeys",
-    "extraData"
-  ]);
-  const refLastSize = useRef();
-  const ref = useRef(null);
-  const [layoutRenderCount, forceLayoutRender] = useState(0);
-  const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
-  const otherAxisSize = numColumns > 1 ? `${1 / numColumns * 100}%` : void 0;
-  const isALastItem = lastItemKeys.includes(itemKey);
-  let didLayout = false;
-  let paddingStyles;
-  if (columnWrapperStyle) {
-    const { columnGap, rowGap, gap } = columnWrapperStyle;
-    if (horizontal) {
-      paddingStyles = {
-        paddingRight: !isALastItem ? columnGap || gap || void 0 : void 0,
-        paddingVertical: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0
-      };
-    } else {
-      paddingStyles = {
-        paddingBottom: !isALastItem ? rowGap || gap || void 0 : void 0,
-        paddingHorizontal: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0
-      };
-    }
-  }
-  const style = horizontal ? {
-    flexDirection: ItemSeparatorComponent ? "row" : void 0,
-    position: "absolute",
-    top: otherAxisPos,
-    height: otherAxisSize,
-    left: position,
-    ...paddingStyles || {}
-  } : {
-    position: "absolute",
-    left: otherAxisPos,
-    right: numColumns > 1 ? null : 0,
-    width: otherAxisSize,
-    top: position,
-    ...paddingStyles || {}
-  };
-  const renderedItemInfo = useMemo(
-    () => itemKey !== void 0 ? getRenderedItem(itemKey) : null,
-    [itemKey, data, extraData]
-  );
-  const { index, renderedItem } = renderedItemInfo || {};
-  const triggerLayout = useCallback(() => {
-    forceLayoutRender((v) => v + 1);
-  }, []);
-  const contextValue = useMemo(() => {
-    ctx.viewRefs.set(id, ref);
-    return { containerId: id, itemKey, index, value: data, triggerLayout };
-  }, [id, itemKey, index, data]);
-  const onLayout = (event) => {
-    var _a, _b;
-    if (!isNullOrUndefined(itemKey)) {
-      didLayout = true;
-      let layout = event.nativeEvent.layout;
-      const size = layout[horizontal ? "width" : "height"];
-      const doUpdate = () => {
-        refLastSize.current = { width: layout.width, height: layout.height };
-        updateItemSize(itemKey, layout);
-      };
-      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 = { width, height };
-          doUpdate();
-        });
-      }
-    }
-  };
-  if (IsNewArchitecture) {
-    useLayoutEffect(() => {
-      var _a, _b;
-      if (!isNullOrUndefined(itemKey)) {
-        const measured = (_b = (_a = ref.current) == null ? void 0 : _a.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a);
-        if (measured) {
-          const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
-          if (size) {
-            updateItemSize(itemKey, measured);
-          }
-        }
-      }
-    }, [itemKey, layoutRenderCount, isALastItem]);
-  } else {
-    useEffect(() => {
-      if (!isNullOrUndefined(itemKey)) {
-        const timeout = setTimeout(() => {
-          if (!didLayout && refLastSize.current) {
-            updateItemSize(itemKey, refLastSize.current);
-          }
-        }, 16);
-        return () => {
-          clearTimeout(timeout);
-        };
-      }
-    }, [itemKey]);
-  }
-  return /* @__PURE__ */ React2.createElement(LeanView, { style, onLayout, ref, key: recycleItems ? void 0 : itemKey }, /* @__PURE__ */ React2.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && !isALastItem && /* @__PURE__ */ React2.createElement(ItemSeparatorComponent, { leadingItem: renderedItemInfo.item })));
-};
-var typedForwardRef = forwardRef;
-var typedMemo = memo;
-var useAnimatedValue = (initialValue) => {
-  return useRef(new Animated.Value(initialValue)).current;
-};
-
-// src/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 = void 0;
-    let prevValue = void 0;
-    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 === 0) {
-            queueMicrotask(fn);
-          } else {
-            setTimeout(fn, delayValue);
-          }
-        }
-      } else {
-        animValue.setValue(newValue);
-      }
-    });
-  }, []);
-  return animValue;
-}
-
-// src/Containers.tsx
-var Containers = typedMemo(function Containers2({
-  horizontal,
-  recycleItems,
-  ItemSeparatorComponent,
-  waitForInitialLayout,
-  updateItemSize,
-  getRenderedItem
-}) {
-  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
-    delay: (value, prevValue) => !prevValue || value - prevValue > 20 ? 0 : 200
-  });
-  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(
-        Container,
-        {
-          id: i,
-          key: i,
-          recycleItems,
-          horizontal,
-          getRenderedItem,
-          updateItemSize,
-          ItemSeparatorComponent
-        }
-      )
-    );
-  }
-  const style = horizontal ? { width: animSize, opacity: animOpacity, minHeight: otherAxisSize } : { height: animSize, opacity: animOpacity, minWidth: otherAxisSize };
-  if (columnWrapperStyle && numColumns > 1) {
-    const { columnGap, rowGap, gap } = columnWrapperStyle;
-    if (horizontal) {
-      const my = (rowGap || gap || 0) / 2;
-      if (my) {
-        style.marginVertical = -my;
-      }
-    } else {
-      const mx = (columnGap || gap || 0) / 2;
-      if (mx) {
-        style.marginHorizontal = -mx;
-      }
-    }
-  }
-  return /* @__PURE__ */ React2.createElement(Animated.View, { style }, containers);
-});
-function ScrollAdjust() {
-  const bias = 1e7;
-  const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
-  const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
-  return /* @__PURE__ */ React2.createElement(
-    View,
-    {
-      style: {
-        position: "absolute",
-        height: 0,
-        width: 0,
-        top: scrollOffset,
-        left: 0
-      }
-    }
-  );
-}
-function useSyncLayout({
-  onChange
-}) {
-  const ref = useRef(null);
-  const onLayout = useCallback(
-    (event) => {
-      onChange(event.nativeEvent.layout, false);
-    },
-    [onChange]
-  );
-  useLayoutEffect(() => {
-    if (ref.current) {
-      ref.current.measure((x, y, width, height) => {
-        onChange({ x, y, width, height }, true);
-      });
-    }
-  }, []);
-  return { onLayout, ref };
-}
-
-// src/ListComponent.tsx
-var getComponent = (Component) => {
-  if (React2.isValidElement(Component)) {
-    return Component;
-  }
-  if (Component) {
-    return /* @__PURE__ */ React2.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: {
-        position: "absolute",
-        top: 0,
-        height: animPaddingTop,
-        left: 0,
-        right: 0,
-        backgroundColor: "green"
-      }
-    }
-  ));
-};
-var ListComponent = typedMemo(function ListComponent2({
-  canRender,
-  style,
-  contentContainerStyle,
-  horizontal,
-  initialContentOffset,
-  recycleItems,
-  ItemSeparatorComponent,
-  alignItemsAtEnd,
-  waitForInitialLayout,
-  handleScroll,
-  onLayout,
-  ListHeaderComponent,
-  ListHeaderComponentStyle,
-  ListFooterComponent,
-  ListFooterComponentStyle,
-  ListEmptyComponent,
-  getRenderedItem,
-  updateItemSize,
-  refScrollView,
-  maintainVisibleContentPosition,
-  renderScrollComponent,
-  scrollAdjustHandler,
-  onLayoutHeader,
-  ...rest
-}) {
-  const ctx = useStateContext();
-  const { onLayout: onLayoutHeaderSync, ref: refHeader } = useSyncLayout({
-    onChange: onLayoutHeader
-  });
-  const ScrollComponent = renderScrollComponent ? useMemo(
-    () => React2.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
-    [renderScrollComponent]
-  ) : ScrollView;
-  React2.useEffect(() => {
-    if (canRender) {
-      setTimeout(() => {
-        scrollAdjustHandler.setMounted();
-      }, 0);
-    }
-  }, [canRender]);
-  return /* @__PURE__ */ React2.createElement(
-    ScrollComponent,
-    {
-      ...rest,
-      style,
-      maintainVisibleContentPosition: maintainVisibleContentPosition && !ListEmptyComponent ? { minIndexForVisible: 0 } : void 0,
-      contentContainerStyle: [
-        contentContainerStyle,
-        horizontal ? {
-          height: "100%"
-        } : {}
-      ],
-      onScroll: handleScroll,
-      onLayout,
-      horizontal,
-      contentOffset: initialContentOffset ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
-      ref: refScrollView
-    },
-    maintainVisibleContentPosition && /* @__PURE__ */ React2.createElement(ScrollAdjust, null),
-    ENABLE_DEVMODE ? /* @__PURE__ */ React2.createElement(PaddingDevMode, null) : /* @__PURE__ */ React2.createElement(Padding, null),
-    ListHeaderComponent && /* @__PURE__ */ React2.createElement(View, { style: ListHeaderComponentStyle, onLayout: onLayoutHeaderSync, ref: refHeader }, getComponent(ListHeaderComponent)),
-    ListEmptyComponent && getComponent(ListEmptyComponent),
-    canRender && /* @__PURE__ */ React2.createElement(
-      Containers,
-      {
-        horizontal,
-        recycleItems,
-        waitForInitialLayout,
-        getRenderedItem,
-        ItemSeparatorComponent,
-        updateItemSize
-      }
-    ),
-    ListFooterComponent && /* @__PURE__ */ React2.createElement(
-      View,
-      {
-        style: ListFooterComponentStyle,
-        onLayout: (event) => {
-          const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
-          set$(ctx, "footerSize", size);
-        }
-      },
-      getComponent(ListFooterComponent)
-    )
-  );
-});
-
-// src/ScrollAdjustHandler.ts
-var ScrollAdjustHandler = class {
-  constructor(ctx) {
-    this.appliedAdjust = 0;
-    this.mounted = false;
-    this.context = ctx;
-  }
-  requestAdjust(add) {
-    const oldAdjustTop = peek$(this.context, "scrollAdjust") || 0;
-    this.appliedAdjust = add + oldAdjustTop;
-    const set = () => set$(this.context, "scrollAdjust", this.appliedAdjust);
-    if (this.mounted) {
-      set();
-    } else {
-      requestAnimationFrame(set);
-    }
-  }
-  setMounted() {
-    this.mounted = true;
-  }
-};
-var useCombinedRef = (...refs) => {
-  const callback = useCallback((element) => {
-    for (const ref of refs) {
-      if (!ref) {
-        continue;
-      }
-      if (isFunction(ref)) {
-        ref(element);
-      } else {
-        ref.current = element;
-      }
-    }
-  }, refs);
-  return callback;
-};
-
-// src/viewability.ts
-var mapViewabilityConfigCallbackPairs = /* @__PURE__ */ new Map();
-function setupViewability(props) {
-  let { viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged } = props;
-  if (viewabilityConfig || onViewableItemsChanged) {
-    viewabilityConfigCallbackPairs = [
-      ...viewabilityConfigCallbackPairs || [],
-      {
-        viewabilityConfig: viewabilityConfig || {
-          viewAreaCoveragePercentThreshold: 0
-        },
-        onViewableItemsChanged
-      }
-    ];
-  }
-  if (viewabilityConfigCallbackPairs) {
-    for (const pair of viewabilityConfigCallbackPairs) {
-      mapViewabilityConfigCallbackPairs.set(pair.viewabilityConfig.id, {
-        viewableItems: [],
-        start: -1,
-        end: -1,
-        previousStart: -1,
-        previousEnd: -1
-      });
-    }
-  }
-  return viewabilityConfigCallbackPairs;
-}
-function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, getId, scrollSize, start, end) {
-  for (const viewabilityConfigCallbackPair of viewabilityConfigCallbackPairs) {
-    const viewabilityState = mapViewabilityConfigCallbackPairs.get(
-      viewabilityConfigCallbackPair.viewabilityConfig.id
-    );
-    viewabilityState.start = start;
-    viewabilityState.end = end;
-    if (viewabilityConfigCallbackPair.viewabilityConfig.minimumViewTime) {
-      const timer = setTimeout(() => {
-        state.timeouts.delete(timer);
-        updateViewableItemsWithConfig(state.data, viewabilityConfigCallbackPair, getId, state, ctx, scrollSize);
-      }, viewabilityConfigCallbackPair.viewabilityConfig.minimumViewTime);
-      state.timeouts.add(timer);
-    } else {
-      updateViewableItemsWithConfig(state.data, viewabilityConfigCallbackPair, getId, state, ctx, scrollSize);
-    }
-  }
-}
-function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, getId, state, ctx, scrollSize) {
-  const { viewabilityConfig, onViewableItemsChanged } = viewabilityConfigCallbackPair;
-  const configId = viewabilityConfig.id;
-  const viewabilityState = mapViewabilityConfigCallbackPairs.get(configId);
-  const { viewableItems: previousViewableItems, start, end } = viewabilityState;
-  const viewabilityTokens = /* @__PURE__ */ new Map();
-  for (const [containerId, value] of ctx.mapViewabilityAmountValues) {
-    viewabilityTokens.set(
-      containerId,
-      computeViewability(
-        state,
-        ctx,
-        viewabilityConfig,
-        containerId,
-        value.key,
-        scrollSize,
-        value.item,
-        value.index
-      )
-    );
-  }
-  const changed = [];
-  if (previousViewableItems) {
-    for (const viewToken of previousViewableItems) {
-      const containerId = findContainerId(ctx, viewToken.key);
-      if (!isViewable(
-        state,
-        ctx,
-        viewabilityConfig,
-        containerId,
-        viewToken.key,
-        scrollSize,
-        viewToken.item,
-        viewToken.index
-      )) {
-        viewToken.isViewable = false;
-        changed.push(viewToken);
-      }
-    }
-  }
-  const viewableItems = [];
-  for (let i = start; i <= end; i++) {
-    const item = data[i];
-    if (item) {
-      const key = getId(i);
-      const containerId = findContainerId(ctx, key);
-      if (isViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, i)) {
-        const viewToken = {
-          item,
-          key,
-          index: i,
-          isViewable: true,
-          containerId
-        };
-        viewableItems.push(viewToken);
-        if (!(previousViewableItems == null ? void 0 : previousViewableItems.find((v) => v.key === viewToken.key))) {
-          changed.push(viewToken);
-        }
-      }
-    }
-  }
-  Object.assign(viewabilityState, {
-    viewableItems,
-    previousStart: start,
-    previousEnd: end
-  });
-  if (changed.length > 0) {
-    viewabilityState.viewableItems = viewableItems;
-    for (let i = 0; i < changed.length; i++) {
-      const change = changed[i];
-      maybeUpdateViewabilityCallback(ctx, configId, change.containerId, change);
-    }
-    if (onViewableItemsChanged) {
-      onViewableItemsChanged({ viewableItems, changed });
-    }
-  }
-  for (const [containerId, value] of ctx.mapViewabilityAmountValues) {
-    if (value.sizeVisible < 0) {
-      ctx.mapViewabilityAmountValues.delete(containerId);
-    }
-  }
-}
-function computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
-  const { sizes, positions, scroll: scrollState } = state;
-  const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
-  const { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = viewabilityConfig;
-  const viewAreaMode = viewAreaCoveragePercentThreshold != null;
-  const viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
-  const scroll = scrollState - topPad;
-  const top = positions.get(key) - scroll;
-  const size = sizes.get(key) || 0;
-  const bottom = top + size;
-  const isEntirelyVisible = top >= 0 && bottom <= scrollSize && bottom > top;
-  const sizeVisible = isEntirelyVisible ? size : Math.min(bottom, scrollSize) - Math.max(top, 0);
-  const percentVisible = size ? isEntirelyVisible ? 100 : 100 * (sizeVisible / size) : 0;
-  const percentOfScroller = size ? 100 * (sizeVisible / scrollSize) : 0;
-  const percent = isEntirelyVisible ? 100 : viewAreaMode ? percentOfScroller : percentVisible;
-  const isViewable2 = percent >= viewablePercentThreshold;
-  const value = {
-    index,
-    isViewable: isViewable2,
-    item,
-    key,
-    percentVisible,
-    percentOfScroller,
-    sizeVisible,
-    size,
-    scrollSize,
-    containerId
-  };
-  if (JSON.stringify(value) !== JSON.stringify(ctx.mapViewabilityAmountValues.get(containerId))) {
-    ctx.mapViewabilityAmountValues.set(containerId, value);
-    const cb = ctx.mapViewabilityAmountCallbacks.get(containerId);
-    if (cb) {
-      cb(value);
-    }
-  }
-  return value;
-}
-function isViewable(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
-  const value = ctx.mapViewabilityAmountValues.get(containerId) || computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index);
-  return value.isViewable;
-}
-function findContainerId(ctx, key) {
-  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;
-}
-function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
-  const key = containerId + configId;
-  ctx.mapViewabilityValues.set(key, viewToken);
-  const cb = ctx.mapViewabilityCallbacks.get(key);
-  cb == null ? void 0 : cb(viewToken);
-}
-
-// src/LegendList.tsx
-var DEFAULT_DRAW_DISTANCE = 250;
-var DEFAULT_ITEM_SIZE = 100;
-function createColumnWrapperStyle(contentContainerStyle) {
-  const { gap, columnGap, rowGap } = contentContainerStyle;
-  if (gap || columnGap || rowGap) {
-    contentContainerStyle.gap = void 0;
-    contentContainerStyle.columnGap = void 0;
-    contentContainerStyle.rowGap = void 0;
-    return {
-      gap,
-      columnGap,
-      rowGap
-    };
-  }
-}
-var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
-  return /* @__PURE__ */ React2.createElement(StateProvider, null, /* @__PURE__ */ React2.createElement(LegendListInner, { ...props, ref: forwardedRef }));
-});
-var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a;
-  const {
-    data: dataProp = [],
-    initialScrollIndex: initialScrollIndexProp,
-    initialScrollOffset,
-    horizontal,
-    drawDistance = 250,
-    recycleItems = false,
-    onEndReachedThreshold = 0.5,
-    onStartReachedThreshold = 0.5,
-    maintainScrollAtEnd = false,
-    maintainScrollAtEndThreshold = 0.1,
-    alignItemsAtEnd = false,
-    maintainVisibleContentPosition = false,
-    onScroll: onScrollProp,
-    onMomentumScrollEnd,
-    numColumns: numColumnsProp = 1,
-    columnWrapperStyle,
-    keyExtractor: keyExtractorProp,
-    renderItem: renderItem2,
-    estimatedListSize,
-    estimatedItemSize: estimatedItemSizeProp,
-    getEstimatedItemSize,
-    suggestEstimatedItemSize,
-    ListHeaderComponent,
-    ListEmptyComponent,
-    onItemSizeChanged,
-    refScrollView,
-    waitForInitialLayout = true,
-    extraData,
-    contentContainerStyle: contentContainerStyleProp,
-    style: styleProp,
-    onLayout: onLayoutProp,
-    onRefresh,
-    refreshing,
-    progressViewOffset,
-    refreshControl,
-    initialContainerPoolRatio = 2,
-    viewabilityConfig,
-    viewabilityConfigCallbackPairs,
-    onViewableItemsChanged,
-    ...rest
-  } = props;
-  const [renderNum, setRenderNum] = useState(0);
-  const initialScroll = typeof initialScrollIndexProp === "number" ? { index: initialScrollIndexProp } : initialScrollIndexProp;
-  const initialScrollIndex = initialScroll == null ? void 0 : initialScroll.index;
-  const refLoadStartTime = useRef(Date.now());
-  const [canRender, setCanRender] = React2.useState(!IsNewArchitecture);
-  const callbacks = useRef({
-    onStartReached: rest.onStartReached,
-    onEndReached: rest.onEndReached
-  });
-  callbacks.current.onStartReached = rest.onStartReached;
-  callbacks.current.onEndReached = rest.onEndReached;
-  const contentContainerStyle = { ...StyleSheet.flatten(contentContainerStyleProp) };
-  const style = { ...StyleSheet.flatten(styleProp) };
-  const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
-  const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
-  const ctx = useStateContext();
-  ctx.columnWrapperStyle = columnWrapperStyle || (contentContainerStyle ? createColumnWrapperStyle(contentContainerStyle) : void 0);
-  const refScroller = useRef(null);
-  const combinedRef = useCombinedRef(refScroller, refScrollView);
-  const estimatedItemSize = estimatedItemSizeProp != null ? estimatedItemSizeProp : DEFAULT_ITEM_SIZE;
-  const scrollBuffer = (drawDistance != null ? drawDistance : DEFAULT_DRAW_DISTANCE) || 1;
-  const keyExtractor = keyExtractorProp != null ? keyExtractorProp : (item, index) => index.toString();
-  const refState = useRef();
-  const getId = (index) => {
-    const state = refState.current;
-    if (!(state == null ? void 0 : state.data)) {
-      return "";
-    }
-    const data = state.data;
-    const ret = index < data.length ? keyExtractor ? keyExtractor(data[index], index) : index : null;
-    const id = ret;
-    state.idCache.set(index, id);
-    return id;
-  };
-  const getItemSize = (key, index, data, useAverageSize = false) => {
-    const state = refState.current;
-    const sizeKnown = state.sizesKnown.get(key);
-    if (sizeKnown !== void 0) {
-      return sizeKnown;
-    }
-    const sizePrevious = state.sizes.get(key);
-    if (sizePrevious !== void 0) {
-      return sizePrevious;
-    }
-    const size = getEstimatedItemSize ? getEstimatedItemSize(index, data) : estimatedItemSize;
-    state.sizes.set(key, size);
-    return size;
-  };
-  const calculateOffsetForIndex = (index) => {
-    var _a2;
-    let position = 0;
-    if (index !== void 0) {
-      position = ((_a2 = refState.current) == null ? void 0 : _a2.positions.get(getId(index))) || 0;
-    }
-    const paddingTop = peek$(ctx, "stylePaddingTop");
-    if (paddingTop) {
-      position += paddingTop;
-    }
-    const headerSize = peek$(ctx, "headerSize");
-    if (headerSize) {
-      position += headerSize;
-    }
-    return position;
-  };
-  const calculateOffsetWithOffsetPosition = (offsetParam, params) => {
-    const { index, viewOffset, viewPosition } = params;
-    let offset = offsetParam;
-    const state = refState.current;
-    if (viewOffset) {
-      offset -= viewOffset;
-    }
-    if (viewPosition !== void 0 && index !== void 0) {
-      offset -= viewPosition * (state.scrollLength - getItemSize(getId(index), index, state.data[index]));
-    }
-    return offset;
-  };
-  if (!refState.current) {
-    const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { width: 0, height: 0 } : Dimensions.get("window"))[horizontal ? "width" : "height"];
-    refState.current = {
-      sizes: /* @__PURE__ */ new Map(),
-      positions: /* @__PURE__ */ new Map(),
-      columns: /* @__PURE__ */ new Map(),
-      pendingAdjust: 0,
-      isStartReached: false,
-      isEndReached: false,
-      isAtEnd: false,
-      isAtStart: false,
-      data: dataProp,
-      scrollLength: initialScrollLength,
-      startBuffered: -1,
-      startNoBuffer: -1,
-      endBuffered: -1,
-      endNoBuffer: -1,
-      firstFullyOnScreenIndex: -1,
-      scroll: 0,
-      totalSize: 0,
-      timeouts: /* @__PURE__ */ new Set(),
-      viewabilityConfigCallbackPairs: void 0,
-      renderItem: void 0,
-      scrollAdjustHandler: new ScrollAdjustHandler(ctx),
-      nativeMarginTop: 0,
-      scrollPrev: 0,
-      scrollPrevTime: 0,
-      scrollTime: 0,
-      scrollPending: 0,
-      indexByKey: /* @__PURE__ */ new Map(),
-      scrollHistory: [],
-      sizesKnown: /* @__PURE__ */ new Map(),
-      timeoutSizeMessage: 0,
-      startReachedBlockedByTimer: false,
-      endReachedBlockedByTimer: false,
-      scrollForNextCalculateItemsInView: void 0,
-      enableScrollForNextCalculateItemsInView: true,
-      minIndexSizeChanged: 0,
-      queuedCalculateItemsInView: 0,
-      lastBatchingAction: Date.now(),
-      averageSizes: {},
-      onScroll: onScrollProp,
-      idsInView: [],
-      containerItemKeys: /* @__PURE__ */ new Set(),
-      idCache: /* @__PURE__ */ new Map()
-    };
-    set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
-    set$(ctx, "extraData", extraData);
-  }
-  const didDataChange = refState.current.data !== dataProp;
-  refState.current.data = dataProp;
-  refState.current.onScroll = onScrollProp;
-  const getScrollVelocity = () => {
-    const { scrollHistory } = refState.current;
-    let velocity = 0;
-    if (scrollHistory.length >= 1) {
-      const newest = scrollHistory[scrollHistory.length - 1];
-      let oldest;
-      for (let i = 0; i < scrollHistory.length - 1; i++) {
-        const entry = scrollHistory[i];
-        const nextEntry = scrollHistory[i + 1];
-        if (i > 0) {
-          const prevEntry = scrollHistory[i - 1];
-          const prevDirection = entry.scroll - prevEntry.scroll;
-          const currentDirection = nextEntry.scroll - entry.scroll;
-          if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
-            break;
-          }
-        }
-      }
-      for (let i = 0; i < scrollHistory.length - 1; i++) {
-        const entry = scrollHistory[i];
-        if (newest.time - entry.time <= 1e3) {
-          oldest = entry;
-          break;
-        }
-      }
-      if (oldest) {
-        const scrollDiff = newest.scroll - oldest.scroll;
-        const timeDiff = newest.time - oldest.time;
-        velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
-      }
-    }
-    return velocity;
-  };
-  const updateAllPositions = (dataChanged) => {
-    var _a2, _b, _c;
-    const { columns, data, indexByKey, positions, firstFullyOnScreenIndex, idCache, sizes } = refState.current;
-    const numColumns = (_a2 = peek$(ctx, "numColumns")) != null ? _a2 : numColumnsProp;
-    const indexByKeyForChecking = __DEV__ ? /* @__PURE__ */ new Map() : void 0;
-    const scrollVelocity = getScrollVelocity();
-    if (dataChanged) {
-      indexByKey.clear();
-      idCache.clear();
-    }
-    const shouldUseBackwards = !dataChanged && scrollVelocity < 0 && firstFullyOnScreenIndex > 5 && firstFullyOnScreenIndex < data.length;
-    if (shouldUseBackwards && firstFullyOnScreenIndex !== void 0) {
-      const anchorId = getId(firstFullyOnScreenIndex);
-      const anchorPosition = positions.get(anchorId);
-      if (anchorPosition !== void 0) {
-        let currentRowTop2 = anchorPosition;
-        let maxSizeInRow2 = 0;
-        let bailout = false;
-        for (let i = firstFullyOnScreenIndex - 1; i >= 0; i--) {
-          const id = getId(i);
-          const size = getItemSize(id, i, data[i], false);
-          const itemColumn = columns.get(id);
-          maxSizeInRow2 = Math.max(maxSizeInRow2, size);
-          if (itemColumn === 1) {
-            currentRowTop2 -= maxSizeInRow2;
-            maxSizeInRow2 = 0;
-          }
-          if (currentRowTop2 < -2e3) {
-            bailout = true;
-            break;
-          }
-          positions.set(id, currentRowTop2);
-        }
-        if (!bailout) {
-          updateTotalSize();
-          return;
-        }
-      }
-    }
-    let currentRowTop = 0;
-    let column = 1;
-    let maxSizeInRow = 0;
-    const hasColumns = numColumns > 1;
-    const needsIndexByKey = dataChanged || indexByKey.size === 0;
-    const dataLength = data.length;
-    for (let i = 0; i < dataLength; i++) {
-      const id = (_b = idCache.get(i)) != null ? _b : getId(i);
-      const size = (_c = sizes.get(id)) != null ? _c : getItemSize(id, i, data[i], false);
-      if (__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.`
-          );
-        }
-        indexByKeyForChecking.set(id, i);
-      }
-      positions.set(id, currentRowTop);
-      if (needsIndexByKey) {
-        indexByKey.set(id, i);
-      }
-      columns.set(id, column);
-      if (hasColumns) {
-        if (size > maxSizeInRow) {
-          maxSizeInRow = size;
-        }
-        column++;
-        if (column > numColumns) {
-          currentRowTop += maxSizeInRow;
-          column = 1;
-          maxSizeInRow = 0;
-        }
-      } else {
-        currentRowTop += size;
-      }
-    }
-    updateTotalSize();
-  };
-  const scrollToIndex = ({
-    index,
-    viewOffset = 0,
-    animated = true,
-    viewPosition
-  }) => {
-    const state = refState.current;
-    if (index >= state.data.length) {
-      index = state.data.length - 1;
-    } else if (index < 0) {
-      index = 0;
-    }
-    const firstIndexOffset = calculateOffsetForIndex(index);
-    const isLast = index === state.data.length - 1;
-    if (isLast && viewPosition === void 0) {
-      viewPosition = 1;
-    }
-    const firstIndexScrollPostion = firstIndexOffset - viewOffset;
-    state.scrollForNextCalculateItemsInView = void 0;
-    scrollTo({ offset: firstIndexScrollPostion, animated, index, viewPosition: viewPosition != null ? viewPosition : 0, viewOffset });
-  };
-  const setDidLayout = () => {
-    refState.current.queuedInitialLayout = true;
-    checkAtBottom();
-    set$(ctx, "containersDidLayout", true);
-    if (props.onLoad) {
-      props.onLoad({ elapsedTimeInMs: Date.now() - refLoadStartTime.current });
-    }
-  };
-  const addTotalSize = useCallback((key, add) => {
-    const state = refState.current;
-    if (key === null) {
-      state.totalSize = add;
-    } else {
-      state.totalSize += add;
-    }
-    set$(ctx, "totalSize", state.totalSize);
-    if (alignItemsAtEnd) {
-      updateAlignItemsPaddingTop();
-    }
-  }, []);
-  const checkAllSizesKnown = useCallback(() => {
-    const { startBuffered, endBuffered, sizesKnown } = refState.current;
-    if (endBuffered !== null) {
-      let areAllKnown = true;
-      for (let i = startBuffered; areAllKnown && i <= endBuffered; i++) {
-        const key = getId(i);
-        areAllKnown && (areAllKnown = sizesKnown.has(key));
-      }
-      return areAllKnown;
-    }
-    return false;
-  }, []);
-  const requestAdjust = (positionDiff) => {
-    if (Math.abs(positionDiff) > 0.1) {
-      const state = refState.current;
-      const doit = () => {
-        state.scrollAdjustHandler.requestAdjust(positionDiff);
-      };
-      state.scroll += positionDiff;
-      state.scrollForNextCalculateItemsInView = void 0;
-      if (peek$(ctx, "containersDidLayout")) {
-        doit();
-      } else {
-        requestAnimationFrame(doit);
-      }
-      const threshold = state.scroll - positionDiff / 2;
-      if (!state.ignoreScrollFromMVCP) {
-        state.ignoreScrollFromMVCP = {};
-      }
-      if (positionDiff > 0) {
-        state.ignoreScrollFromMVCP.lt = threshold;
-      } else {
-        state.ignoreScrollFromMVCP.gt = threshold;
-      }
-      if (state.ignoreScrollFromMVCPTimeout) {
-        clearTimeout(state.ignoreScrollFromMVCPTimeout);
-      }
-      state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
-        state.ignoreScrollFromMVCP = void 0;
-      }, 100);
-    }
-  };
-  const prepareMVCP = useCallback(() => {
-    const state = refState.current;
-    const { positions, scrollingTo } = state;
-    let prevPosition;
-    let targetId;
-    let targetIndex;
-    const scrollTarget = scrollingTo == null ? void 0 : scrollingTo.index;
-    if (maintainVisibleContentPosition) {
-      const indexByKey = state.indexByKey;
-      if (scrollTarget !== void 0) {
-        targetId = getId(scrollTarget);
-        targetIndex = scrollTarget;
-      } else if (state.idsInView.length > 0 && peek$(ctx, "containersDidLayout")) {
-        targetId = state.idsInView.find((id) => indexByKey.get(id) !== void 0);
-        targetIndex = indexByKey.get(targetId);
-      }
-      if (targetId !== void 0 && targetIndex !== void 0) {
-        prevPosition = positions.get(targetId);
-      }
-    }
-    return () => {
-      if (targetId !== void 0 && prevPosition !== void 0) {
-        const newPosition = positions.get(targetId);
-        if (newPosition !== void 0) {
-          const positionDiff = newPosition - prevPosition;
-          if (Math.abs(positionDiff) > 0.1) {
-            requestAdjust(positionDiff);
-          }
-        }
-      }
-    };
-  }, []);
-  const calculateItemsInView = useCallback((params = {}) => {
-    var _a2, _b, _c, _d, _e, _f, _g, _h;
-    const state = refState.current;
-    const {
-      data,
-      scrollLength,
-      startBufferedId: startBufferedIdOrig,
-      positions,
-      columns,
-      containerItemKeys,
-      idCache,
-      sizes,
-      indexByKey,
-      scrollForNextCalculateItemsInView,
-      enableScrollForNextCalculateItemsInView,
-      minIndexSizeChanged
-    } = state;
-    if (!data || scrollLength === 0) {
-      return;
-    }
-    const totalSize = peek$(ctx, "totalSize");
-    const topPad = peek$(ctx, "stylePaddingTop") + peek$(ctx, "headerSize");
-    const numColumns = peek$(ctx, "numColumns");
-    const previousScrollAdjust = 0;
-    const { dataChanged, doMVCP } = params;
-    const speed = getScrollVelocity();
-    if (doMVCP || dataChanged) {
-      const checkMVCP = doMVCP ? prepareMVCP() : void 0;
-      updateAllPositions(dataChanged);
-      checkMVCP == null ? void 0 : checkMVCP();
-    }
-    const scrollExtra = 0;
-    const useAverageSize = false;
-    const { queuedInitialLayout } = state;
-    let { scroll: scrollState } = state;
-    if (!queuedInitialLayout && initialScroll) {
-      const updatedOffset = calculateOffsetWithOffsetPosition(
-        calculateOffsetForIndex(initialScroll.index),
-        initialScroll
-      );
-      scrollState = updatedOffset;
-    }
-    const scrollAdjustPad = -previousScrollAdjust - topPad;
-    let scroll = scrollState + scrollExtra + scrollAdjustPad;
-    if (scroll + scrollLength > totalSize) {
-      scroll = totalSize - scrollLength;
-    }
-    if (ENABLE_DEBUG_VIEW) {
-      set$(ctx, "debugRawScroll", scrollState);
-      set$(ctx, "debugComputedScroll", scroll);
-    }
-    let scrollBufferTop = scrollBuffer;
-    let scrollBufferBottom = scrollBuffer;
-    if (speed > 0) {
-      scrollBufferTop = scrollBuffer * 0.5;
-      scrollBufferBottom = scrollBuffer * 1.5;
-    } else {
-      scrollBufferTop = scrollBuffer * 1.5;
-      scrollBufferBottom = scrollBuffer * 0.5;
-    }
-    const scrollTopBuffered = scroll - scrollBufferTop;
-    const scrollBottom = scroll + scrollLength;
-    const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
-    if (scrollForNextCalculateItemsInView) {
-      const { top, bottom } = scrollForNextCalculateItemsInView;
-      if (scrollTopBuffered > top && scrollBottomBuffered < bottom) {
-        return;
-      }
-    }
-    let startNoBuffer = null;
-    let startBuffered = null;
-    let startBufferedId = null;
-    let endNoBuffer = null;
-    let endBuffered = null;
-    let loopStart = startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
-    if (minIndexSizeChanged !== void 0) {
-      loopStart = Math.min(minIndexSizeChanged, loopStart);
-      state.minIndexSizeChanged = void 0;
-    }
-    for (let i = loopStart; i >= 0; i--) {
-      const id = (_a2 = idCache.get(i)) != null ? _a2 : getId(i);
-      const top = positions.get(id);
-      const size = (_b = sizes.get(id)) != null ? _b : getItemSize(id, i, data[i], useAverageSize);
-      const bottom = top + size;
-      if (bottom > scroll - scrollBuffer) {
-        loopStart = i;
-      } else {
-        break;
-      }
-    }
-    const loopStartMod = loopStart % numColumns;
-    if (loopStartMod > 0) {
-      loopStart -= loopStartMod;
-    }
-    let foundEnd = false;
-    let nextTop;
-    let nextBottom;
-    const prevNumContainers = ctx.values.get("numContainers");
-    let maxIndexRendered = 0;
-    for (let i = 0; i < prevNumContainers; i++) {
-      const key = peek$(ctx, `containerItemKey${i}`);
-      if (key !== void 0) {
-        const index = indexByKey.get(key);
-        maxIndexRendered = Math.max(maxIndexRendered, index);
-      }
-    }
-    let firstFullyOnScreenIndex;
-    const dataLength = data.length;
-    for (let i = Math.max(0, loopStart); i < dataLength && (!foundEnd || i <= maxIndexRendered); i++) {
-      const id = (_c = idCache.get(i)) != null ? _c : getId(i);
-      const size = (_d = sizes.get(id)) != null ? _d : getItemSize(id, i, data[i], useAverageSize);
-      const top = positions.get(id);
-      if (!foundEnd) {
-        if (startNoBuffer === null && top + size > scroll) {
-          startNoBuffer = i;
-        }
-        if (firstFullyOnScreenIndex === void 0 && top >= scroll - 10) {
-          firstFullyOnScreenIndex = i;
-        }
-        if (startBuffered === null && top + size > scrollTopBuffered) {
-          startBuffered = i;
-          startBufferedId = id;
-          nextTop = top;
-        }
-        if (startNoBuffer !== null) {
-          if (top <= scrollBottom) {
-            endNoBuffer = i;
-          }
-          if (top <= scrollBottomBuffered) {
-            endBuffered = i;
-            nextBottom = top + size;
-          } else {
-            foundEnd = true;
-          }
-        }
-      }
-    }
-    const idsInView = [];
-    for (let i = firstFullyOnScreenIndex; i <= endNoBuffer; i++) {
-      const id = (_e = idCache.get(i)) != null ? _e : getId(i);
-      idsInView.push(id);
-    }
-    Object.assign(state, {
-      startBuffered,
-      startBufferedId,
-      startNoBuffer,
-      endBuffered,
-      endNoBuffer,
-      idsInView,
-      firstFullyOnScreenIndex
-    });
-    if (enableScrollForNextCalculateItemsInView && nextTop !== void 0 && nextBottom !== void 0) {
-      state.scrollForNextCalculateItemsInView = nextTop !== void 0 && nextBottom !== void 0 ? {
-        top: nextTop,
-        bottom: nextBottom
-      } : void 0;
-    }
-    const numContainers = peek$(ctx, "numContainers");
-    const pendingRemoval = [];
-    if (dataChanged) {
-      for (let i = 0; i < numContainers; i++) {
-        const itemKey = peek$(ctx, `containerItemKey${i}`);
-        if (!keyExtractorProp || itemKey && indexByKey.get(itemKey) === void 0) {
-          pendingRemoval.push(i);
-        }
-      }
-    }
-    if (startBuffered !== null && endBuffered !== null) {
-      let numContainers2 = prevNumContainers;
-      const needNewContainers = [];
-      for (let i = startBuffered; i <= endBuffered; i++) {
-        const id = (_f = idCache.get(i)) != null ? _f : getId(i);
-        if (!containerItemKeys.has(id)) {
-          needNewContainers.push(i);
-        }
-      }
-      if (needNewContainers.length > 0) {
-        const availableContainers = findAvailableContainers(
-          needNewContainers.length,
-          startBuffered,
-          endBuffered,
-          pendingRemoval
-        );
-        for (let idx = 0; idx < needNewContainers.length; idx++) {
-          const i = needNewContainers[idx];
-          const containerIndex = availableContainers[idx];
-          const id = (_g = idCache.get(i)) != null ? _g : getId(i);
-          const oldKey = peek$(ctx, `containerItemKey${containerIndex}`);
-          if (oldKey && oldKey !== id) {
-            containerItemKeys.delete(oldKey);
-          }
-          set$(ctx, `containerItemKey${containerIndex}`, id);
-          set$(ctx, `containerItemData${containerIndex}`, data[i]);
-          containerItemKeys.add(id);
-          if (containerIndex >= numContainers2) {
-            numContainers2 = containerIndex + 1;
-          }
-        }
-        if (numContainers2 !== prevNumContainers) {
-          set$(ctx, "numContainers", numContainers2);
-          if (numContainers2 > peek$(ctx, "numContainersPooled")) {
-            set$(ctx, "numContainersPooled", Math.ceil(numContainers2 * 1.5));
-          }
-        }
-      }
-      for (let i = 0; i < numContainers2; i++) {
-        const itemKey = peek$(ctx, `containerItemKey${i}`);
-        if (pendingRemoval.includes(i)) {
-          if (itemKey) {
-            containerItemKeys.delete(itemKey);
-          }
-          set$(ctx, `containerItemKey${i}`, void 0);
-          set$(ctx, `containerItemData${i}`, void 0);
-          set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
-          set$(ctx, `containerColumn${i}`, -1);
-        } else {
-          const itemIndex = indexByKey.get(itemKey);
-          const item = data[itemIndex];
-          if (item !== void 0) {
-            const id = (_h = idCache.get(itemIndex)) != null ? _h : getId(itemIndex);
-            const position = positions.get(id);
-            if (position === void 0) {
-              set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
-            } else {
-              const pos = positions.get(id);
-              const column = columns.get(id) || 1;
-              const prevPos = peek$(ctx, `containerPosition${i}`);
-              const prevColumn = peek$(ctx, `containerColumn${i}`);
-              const prevData = peek$(ctx, `containerItemData${i}`);
-              if (!prevPos || pos > POSITION_OUT_OF_VIEW && pos !== prevPos) {
-                set$(ctx, `containerPosition${i}`, pos);
-              }
-              if (column >= 0 && column !== prevColumn) {
-                set$(ctx, `containerColumn${i}`, column);
-              }
-              if (prevData !== item) {
-                set$(ctx, `containerItemData${i}`, data[itemIndex]);
-              }
-            }
-          }
-        }
-      }
-    }
-    if (!queuedInitialLayout && endBuffered !== null) {
-      if (checkAllSizesKnown()) {
-        setDidLayout();
-      }
-    }
-    if (viewabilityConfigCallbackPairs) {
-      updateViewableItems(
-        state,
-        ctx,
-        viewabilityConfigCallbackPairs,
-        getId,
-        scrollLength,
-        startNoBuffer,
-        endNoBuffer
-      );
-    }
-  }, []);
-  const setPaddingTop = ({
-    stylePaddingTop,
-    alignItemsPaddingTop
-  }) => {
-    if (stylePaddingTop !== void 0) {
-      const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
-      if (stylePaddingTop < prevStylePaddingTop) {
-        const prevTotalSize = peek$(ctx, "totalSize") || 0;
-        set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
-        setTimeout(() => {
-          set$(ctx, "totalSize", prevTotalSize);
-        }, 16);
-      }
-      set$(ctx, "stylePaddingTop", stylePaddingTop);
-    }
-    if (alignItemsPaddingTop !== void 0) {
-      set$(ctx, "alignItemsPaddingTop", alignItemsPaddingTop);
-    }
-  };
-  const updateAlignItemsPaddingTop = () => {
-    if (alignItemsAtEnd) {
-      const { data, scrollLength } = refState.current;
-      let alignItemsPaddingTop = 0;
-      if ((data == null ? void 0 : data.length) > 0) {
-        const contentSize = getContentSize(ctx);
-        alignItemsPaddingTop = Math.max(0, Math.floor(scrollLength - contentSize));
-      }
-      setPaddingTop({ alignItemsPaddingTop });
-    }
-  };
-  const finishScrollTo = () => {
-    const state = refState.current;
-    if (state) {
-      state.scrollingTo = void 0;
-      state.scrollHistory.length = 0;
-    }
-  };
-  const scrollTo = (params = {}) => {
-    var _a2;
-    const state = refState.current;
-    const { animated } = params;
-    const offset = calculateOffsetWithOffsetPosition(params.offset, params);
-    state.scrollHistory.length = 0;
-    state.scrollingTo = params;
-    state.scrollPending = offset;
-    (_a2 = refScroller.current) == null ? void 0 : _a2.scrollTo({
-      x: horizontal ? offset : 0,
-      y: horizontal ? 0 : offset,
-      animated: !!animated
-    });
-    if (!animated) {
-      refState.current.scroll = offset;
-      setTimeout(finishScrollTo, 100);
-    }
-  };
-  const doMaintainScrollAtEnd = (animated) => {
-    const state = refState.current;
-    if ((state == null ? void 0 : state.isAtEnd) && maintainScrollAtEnd && peek$(ctx, "containersDidLayout")) {
-      const paddingTop = peek$(ctx, "alignItemsPaddingTop");
-      if (paddingTop > 0) {
-        state.scroll = 0;
-      }
-      requestAnimationFrame(() => {
-        var _a2;
-        state.maintainingScrollAtEnd = true;
-        (_a2 = refScroller.current) == null ? void 0 : _a2.scrollToEnd({
-          animated
-        });
-        setTimeout(
-          () => {
-            state.maintainingScrollAtEnd = false;
-          },
-          0
-        );
-      });
-      return true;
-    }
-  };
-  const 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) {
-        return false;
-      }
-    }
-    return isReached;
-  };
-  const checkAtBottom = () => {
-    if (!refState.current) {
-      return;
-    }
-    const { queuedInitialLayout, scrollLength, scroll, maintainingScrollAtEnd } = refState.current;
-    const contentSize = getContentSize(ctx);
-    if (contentSize > 0 && queuedInitialLayout && !maintainingScrollAtEnd) {
-      const distanceFromEnd = contentSize - scroll - scrollLength;
-      const isContentLess = contentSize < scrollLength;
-      refState.current.isAtEnd = isContentLess || distanceFromEnd < scrollLength * maintainScrollAtEndThreshold;
-      refState.current.isEndReached = checkThreshold(
-        distanceFromEnd,
-        isContentLess,
-        onEndReachedThreshold * scrollLength,
-        refState.current.isEndReached,
-        refState.current.endReachedBlockedByTimer,
-        (distance) => {
-          var _a2, _b;
-          return (_b = (_a2 = callbacks.current).onEndReached) == null ? void 0 : _b.call(_a2, { distanceFromEnd: distance });
-        },
-        (block) => {
-          refState.current.endReachedBlockedByTimer = block;
-        }
-      );
-    }
-  };
-  const checkAtTop = () => {
-    if (!refState.current) {
-      return;
-    }
-    const { scrollLength, scroll } = refState.current;
-    const distanceFromTop = scroll;
-    refState.current.isAtStart = distanceFromTop <= 0;
-    refState.current.isStartReached = checkThreshold(
-      distanceFromTop,
-      false,
-      onStartReachedThreshold * scrollLength,
-      refState.current.isStartReached,
-      refState.current.startReachedBlockedByTimer,
-      (distance) => {
-        var _a2, _b;
-        return (_b = (_a2 = callbacks.current).onStartReached) == null ? void 0 : _b.call(_a2, { distanceFromStart: distance });
-      },
-      (block) => {
-        refState.current.startReachedBlockedByTimer = block;
-      }
-    );
-  };
-  const checkResetContainers = (isFirst2) => {
-    const state = refState.current;
-    if (state) {
-      state.data = dataProp;
-      if (!isFirst2) {
-        calculateItemsInView({ dataChanged: true, doMVCP: true });
-        const didMaintainScrollAtEnd = doMaintainScrollAtEnd(false);
-        if (!didMaintainScrollAtEnd && dataProp.length > state.data.length) {
-          state.isEndReached = false;
-        }
-        if (!didMaintainScrollAtEnd) {
-          checkAtTop();
-          checkAtBottom();
-        }
-      }
-    }
-  };
-  const updateTotalSize = () => {
-    const { data, positions } = refState.current;
-    if (data.length === 0) {
-      addTotalSize(null, 0);
-    } else {
-      const lastId = getId(data.length - 1);
-      if (lastId !== void 0) {
-        const lastPosition = positions.get(lastId);
-        if (lastPosition !== void 0) {
-          const lastSize = getItemSize(lastId, data.length - 1, data[dataProp.length - 1]);
-          if (lastSize !== void 0) {
-            const totalSize = lastPosition + lastSize;
-            addTotalSize(null, totalSize);
-          }
-        }
-      }
-    }
-  };
-  const findAvailableContainers = (numNeeded, startBuffered, endBuffered, pendingRemoval) => {
-    const state = refState.current;
-    const numContainers = peek$(ctx, "numContainers");
-    const result = [];
-    const availableContainers = [];
-    for (let u = 0; u < numContainers; u++) {
-      const key = peek$(ctx, `containerItemKey${u}`);
-      let isOk = key === void 0;
-      if (!isOk) {
-        const index = pendingRemoval.indexOf(u);
-        if (index !== -1) {
-          pendingRemoval.splice(index, 1);
-          isOk = true;
-        }
-      }
-      if (isOk) {
-        result.push(u);
-        if (result.length >= numNeeded) {
-          return result;
-        }
-      }
-    }
-    for (let u = 0; u < numContainers; u++) {
-      const key = peek$(ctx, `containerItemKey${u}`);
-      if (key === void 0) continue;
-      const index = state.indexByKey.get(key);
-      if (index < startBuffered) {
-        availableContainers.push({ index: u, distance: startBuffered - index });
-      } else if (index > endBuffered) {
-        availableContainers.push({ index: u, distance: index - endBuffered });
-      }
-    }
-    const remaining = numNeeded - result.length;
-    if (remaining > 0) {
-      if (availableContainers.length > 0) {
-        if (availableContainers.length > remaining) {
-          availableContainers.sort(comparatorByDistance);
-          availableContainers.length = remaining;
-        }
-        for (const container of availableContainers) {
-          result.push(container.index);
-        }
-      }
-      const stillNeeded = numNeeded - result.length;
-      if (stillNeeded > 0) {
-        for (let i = 0; i < stillNeeded; i++) {
-          result.push(numContainers + i);
-        }
-        if (__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.",
-            {
-              debugInfo: {
-                numContainers,
-                numNeeded,
-                stillNeeded,
-                numContainersPooled: peek$(ctx, "numContainersPooled")
-              }
-            }
-          );
-        }
-      }
-    }
-    return result.sort(comparatorDefault);
-  };
-  const isFirst = !refState.current.renderItem;
-  const memoizedLastItemKeys = useMemo(() => {
-    if (!dataProp.length) return [];
-    return Array.from(
-      { length: Math.min(numColumnsProp, dataProp.length) },
-      (_, i) => getId(dataProp.length - 1 - i)
-    );
-  }, [dataProp, numColumnsProp]);
-  const initalizeStateVars = () => {
-    set$(ctx, "lastItemKeys", memoizedLastItemKeys);
-    set$(ctx, "numColumns", numColumnsProp);
-    const prevPaddingTop = peek$(ctx, "stylePaddingTop");
-    setPaddingTop({ stylePaddingTop: stylePaddingTopState });
-    refState.current.stylePaddingBottom = stylePaddingBottomState;
-    const paddingDiff = stylePaddingTopState - prevPaddingTop;
-    if (paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") {
-      requestAdjust(paddingDiff);
-    }
-  };
-  if (isFirst) {
-    initalizeStateVars();
-    updateAllPositions();
-  }
-  const initialContentOffset = useMemo(() => {
-    const initialContentOffset2 = initialScrollOffset || calculateOffsetForIndex(initialScrollIndex);
-    refState.current.isStartReached = initialContentOffset2 < refState.current.scrollLength * onStartReachedThreshold;
-    if (initialContentOffset2 > 0) {
-      scrollTo({ offset: initialContentOffset2, animated: false, index: initialScrollIndex });
-    }
-    return initialContentOffset2;
-  }, [renderNum]);
-  if (isFirst || didDataChange || numColumnsProp !== peek$(ctx, "numColumns")) {
-    refState.current.lastBatchingAction = Date.now();
-    if (!keyExtractorProp && !isFirst && didDataChange) {
-      __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."
-      );
-      refState.current.sizes.clear();
-      refState.current.positions.clear();
-    }
-  }
-  useLayoutEffect(() => {
-    var _a2, _b;
-    if (IsNewArchitecture) {
-      const measured = (_b = (_a2 = refScroller.current) == null ? void 0 : _a2.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a2);
-      if (measured) {
-        const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
-        if (size) {
-          handleLayout(measured);
-        }
-      }
-    }
-    if (!isFirst) {
-      calculateItemsInView({ doMVCP: true });
-    }
-  }, [dataProp]);
-  const onLayoutHeader = useCallback((rect, fromLayoutEffect) => {
-    const size = rect[horizontal ? "width" : "height"];
-    set$(ctx, "headerSize", size);
-    if (initialScroll) {
-      if (IsNewArchitecture && Platform.OS !== "android") {
-        if (fromLayoutEffect) {
-          setRenderNum((v) => v + 1);
-        }
-      } else {
-        setTimeout(() => {
-          scrollToIndex({ ...initialScroll, animated: false });
-        }, 17);
-      }
-    }
-  }, []);
-  useLayoutEffect(() => {
-    const didAllocateContainers = doInitialAllocateContainers();
-    if (!didAllocateContainers) {
-      checkResetContainers(
-        /*isFirst*/
-        isFirst
-      );
-    }
-  }, [dataProp, numColumnsProp]);
-  useLayoutEffect(() => {
-    set$(ctx, "extraData", extraData);
-  }, [extraData]);
-  refState.current.renderItem = renderItem2;
-  useLayoutEffect(initalizeStateVars, [
-    memoizedLastItemKeys.join(","),
-    numColumnsProp,
-    stylePaddingTopState,
-    stylePaddingBottomState
-  ]);
-  const getRenderedItem = useCallback((key) => {
-    const state = refState.current;
-    if (!state) {
-      return null;
-    }
-    const { data, indexByKey } = state;
-    const index = indexByKey.get(key);
-    if (index === void 0) {
-      return null;
-    }
-    const renderItemProp = refState.current.renderItem;
-    let renderedItem = null;
-    if (renderItemProp) {
-      const itemProps = {
-        item: data[index],
-        index,
-        extraData: peek$(ctx, "extraData")
-      };
-      renderedItem = React2.createElement(renderItemProp, itemProps);
-    }
-    return { index, item: data[index], renderedItem };
-  }, []);
-  const doInitialAllocateContainers = () => {
-    const state = refState.current;
-    const { scrollLength, data } = state;
-    if (scrollLength > 0 && data.length > 0 && !peek$(ctx, "numContainers")) {
-      const averageItemSize = getEstimatedItemSize ? getEstimatedItemSize(0, data[0]) : estimatedItemSize;
-      const Extra = 1.5;
-      const numContainers = Math.ceil(
-        (scrollLength + scrollBuffer * 2) / averageItemSize * numColumnsProp * Extra
-      );
-      for (let i = 0; i < numContainers; i++) {
-        set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
-        set$(ctx, `containerColumn${i}`, -1);
-      }
-      set$(ctx, "numContainers", numContainers);
-      set$(ctx, "numContainersPooled", numContainers * initialContainerPoolRatio);
-      if (!IsNewArchitecture) {
-        if (initialScroll) {
-          requestAnimationFrame(() => {
-            calculateItemsInView();
-          });
-        } else {
-          calculateItemsInView();
-        }
-      }
-      return true;
-    }
-  };
-  useEffect(() => {
-    const state = refState.current;
-    const viewability = setupViewability({
-      viewabilityConfig,
-      viewabilityConfigCallbackPairs,
-      onViewableItemsChanged
-    });
-    state.viewabilityConfigCallbackPairs = viewability;
-    state.enableScrollForNextCalculateItemsInView = !viewability;
-  }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  if (!IsNewArchitecture) {
-    useInit(() => {
-      doInitialAllocateContainers();
-    });
-  }
-  const updateOneItemSize = useCallback((itemKey, sizeObj) => {
-    const state = refState.current;
-    const { sizes, indexByKey, sizesKnown, data, averageSizes } = state;
-    if (!data) return 0;
-    const index = indexByKey.get(itemKey);
-    const prevSize = getItemSize(itemKey, index, data);
-    const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
-    sizesKnown.set(itemKey, size);
-    const itemType = "";
-    let averages = averageSizes[itemType];
-    if (!averages) {
-      averages = averageSizes[itemType] = { num: 0, avg: 0 };
-    }
-    averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
-    averages.num++;
-    if (!prevSize || Math.abs(prevSize - size) > 0.1) {
-      sizes.set(itemKey, size);
-      return size - prevSize;
-    }
-    return 0;
-  }, []);
-  const updateItemSizes = useCallback(
-    (itemUpdates) => {
-      var _a2;
-      const state = refState.current;
-      if (!state.data) return;
-      let needsRecalculate = false;
-      let shouldMaintainScrollAtEnd = false;
-      let minIndexSizeChanged;
-      let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
-      for (const { itemKey, sizeObj } of itemUpdates) {
-        const index = state.indexByKey.get(itemKey);
-        const prevSizeKnown = state.sizesKnown.get(itemKey);
-        const diff = updateOneItemSize(itemKey, sizeObj);
-        const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
-        if (diff !== 0) {
-          minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
-          if (((_a2 = state.scrollingTo) == null ? void 0 : _a2.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index) {
-            requestAdjust(diff * state.scrollingTo.viewPosition);
-          }
-          const { startBuffered, endBuffered } = state;
-          needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
-          if (!needsRecalculate) {
-            const numContainers = ctx.values.get("numContainers");
-            for (let i = 0; i < numContainers; i++) {
-              if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
-                needsRecalculate = true;
-                break;
-              }
-            }
-          }
-          if (state.needsOtherAxisSize) {
-            const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
-            maxOtherAxisSize = Math.max(maxOtherAxisSize, otherAxisSize);
-          }
-          if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
-            shouldMaintainScrollAtEnd = true;
-          }
-          onItemSizeChanged == null ? void 0 : onItemSizeChanged({
-            size,
-            previous: size - diff,
-            index,
-            itemKey,
-            itemData: state.data[index]
-          });
-        }
-      }
-      if (minIndexSizeChanged !== void 0) {
-        state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
-      }
-      if (__DEV__ && suggestEstimatedItemSize && minIndexSizeChanged !== void 0) {
-        if (state.timeoutSizeMessage) clearTimeout(state.timeoutSizeMessage);
-        state.timeoutSizeMessage = setTimeout(() => {
-          var _a3;
-          state.timeoutSizeMessage = void 0;
-          const num = state.sizesKnown.size;
-          const avg = (_a3 = state.averageSizes[""]) == null ? void 0 : _a3.avg;
-          console.warn(
-            `[legend-list] Based on the ${num} items rendered so far, the optimal estimated size is ${avg}.`
-          );
-        }, 1e3);
-      }
-      const cur = peek$(ctx, "otherAxisSize");
-      if (!cur || maxOtherAxisSize > cur) {
-        set$(ctx, "otherAxisSize", maxOtherAxisSize);
-      }
-      const containersDidLayout = peek$(ctx, "containersDidLayout");
-      if (containersDidLayout || checkAllSizesKnown()) {
-        if (needsRecalculate) {
-          state.scrollForNextCalculateItemsInView = void 0;
-          calculateItemsInView({ doMVCP: true });
-        }
-        if (shouldMaintainScrollAtEnd) {
-          doMaintainScrollAtEnd(false);
-        }
-      }
-    },
-    []
-  );
-  const updateItemSize = useCallback((itemKey, sizeObj) => {
-    var _a2, _b;
-    if (IsNewArchitecture) {
-      const { sizesKnown } = refState.current;
-      const numContainers = ctx.values.get("numContainers");
-      const changes = [];
-      for (let i = 0; i < numContainers; i++) {
-        const containerItemKey = peek$(ctx, `containerItemKey${i}`);
-        if (itemKey === containerItemKey) {
-          changes.push({ itemKey, sizeObj });
-        } else if (!sizesKnown.has(containerItemKey) && containerItemKey !== void 0) {
-          const containerRef = ctx.viewRefs.get(i);
-          if (containerRef) {
-            const measured = (_b = (_a2 = containerRef.current) == null ? void 0 : _a2.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a2);
-            if (measured) {
-              changes.push({ itemKey: containerItemKey, sizeObj: measured });
-            }
-          }
-        }
-      }
-      if (changes.length > 0) {
-        updateItemSizes(changes);
-      }
-    } else {
-      updateItemSizes([{ itemKey, sizeObj }]);
-    }
-  }, []);
-  const handleLayout = useCallback((size) => {
-    const scrollLength = size[horizontal ? "width" : "height"];
-    const otherAxisSize = size[horizontal ? "height" : "width"];
-    const state = refState.current;
-    const didChange = scrollLength !== state.scrollLength;
-    const prevOtherAxisSize = state.otherAxisSize;
-    state.scrollLength = scrollLength;
-    state.otherAxisSize = otherAxisSize;
-    state.lastBatchingAction = Date.now();
-    state.scrollForNextCalculateItemsInView = void 0;
-    doInitialAllocateContainers();
-    if (didChange) {
-      calculateItemsInView({ doMVCP: true });
-    }
-    if (didChange || otherAxisSize !== prevOtherAxisSize) {
-      set$(ctx, "scrollSize", { width: size.width, height: size.height });
-    }
-    doMaintainScrollAtEnd(false);
-    updateAlignItemsPaddingTop();
-    checkAtBottom();
-    checkAtTop();
-    if (refState.current) {
-      refState.current.needsOtherAxisSize = otherAxisSize - (stylePaddingTopState || 0) < 10;
-    }
-    if (__DEV__ && scrollLength === 0) {
-      warnDevOnce(
-        "height0",
-        `List ${horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
-      );
-    }
-    calculateItemsInView({ doMVCP: true });
-    setCanRender(true);
-  }, []);
-  const onLayout = useCallback((event) => {
-    const layout = event.nativeEvent.layout;
-    handleLayout(layout);
-    if (onLayoutProp) {
-      onLayoutProp(event);
-    }
-  }, []);
-  const handleScroll = useCallback(
-    (event) => {
-      var _a2, _b, _c, _d;
-      if (((_b = (_a2 = event.nativeEvent) == null ? void 0 : _a2.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
-        return;
-      }
-      const state = refState.current;
-      const newScroll = event.nativeEvent.contentOffset[horizontal ? "x" : "y"];
-      const ignoreScrollFromMVCP = state.ignoreScrollFromMVCP;
-      if (ignoreScrollFromMVCP && !state.scrollingTo) {
-        const { lt, gt } = ignoreScrollFromMVCP;
-        if (lt && newScroll < lt || gt && newScroll > gt) {
-          return;
-        }
-      }
-      state.scrollPending = newScroll;
-      updateScroll(newScroll);
-      (_d = state.onScroll) == null ? void 0 : _d.call(state, event);
-    },
-    []
-  );
-  const updateScroll = useCallback((newScroll) => {
-    const state = refState.current;
-    const scrollingTo = state.scrollingTo;
-    state.hasScrolled = true;
-    state.lastBatchingAction = Date.now();
-    const currentTime = performance.now();
-    if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
-      state.scrollHistory.push({ scroll: newScroll, time: currentTime });
-    }
-    if (state.scrollHistory.length > 5) {
-      state.scrollHistory.shift();
-    }
-    state.scrollPrev = state.scroll;
-    state.scrollPrevTime = state.scrollTime;
-    state.scroll = newScroll;
-    state.scrollTime = currentTime;
-    calculateItemsInView();
-    checkAtBottom();
-    checkAtTop();
-  }, []);
-  useImperativeHandle(
-    forwardedRef,
-    () => {
-      const scrollIndexIntoView = (options) => {
-        if (refState.current) {
-          const { index, ...rest2 } = options;
-          const { startNoBuffer, endNoBuffer } = refState.current;
-          if (index < startNoBuffer || index > endNoBuffer) {
-            const viewPosition = index < startNoBuffer ? 0 : 1;
-            scrollToIndex({
-              ...rest2,
-              viewPosition,
-              index
-            });
-          }
-        }
-      };
-      return {
-        flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
-        getNativeScrollRef: () => refScroller.current,
-        getScrollableNode: () => refScroller.current.getScrollableNode(),
-        getScrollResponder: () => refScroller.current.getScrollResponder(),
-        getState: () => {
-          const state = refState.current;
-          return state ? {
-            contentLength: state.totalSize,
-            end: state.endNoBuffer,
-            endBuffered: state.endBuffered,
-            isAtEnd: state.isAtEnd,
-            isAtStart: state.isAtStart,
-            scroll: state.scroll,
-            scrollLength: state.scrollLength,
-            start: state.startNoBuffer,
-            startBuffered: state.startBuffered,
-            sizes: state.sizesKnown,
-            sizeAtIndex: (index) => state.sizesKnown.get(getId(index))
-          } : {};
-        },
-        scrollIndexIntoView,
-        scrollItemIntoView: ({ item, ...props2 }) => {
-          const { data } = refState.current;
-          const index = data.indexOf(item);
-          if (index !== -1) {
-            scrollIndexIntoView({ index, ...props2 });
-          }
-        },
-        scrollToIndex,
-        scrollToItem: ({ item, ...props2 }) => {
-          const { data } = refState.current;
-          const index = data.indexOf(item);
-          if (index !== -1) {
-            scrollToIndex({ index, ...props2 });
-          }
-        },
-        scrollToOffset: (params) => scrollTo(params),
-        scrollToEnd: (options) => {
-          const { data, stylePaddingBottom } = refState.current;
-          const index = data.length - 1;
-          if (index !== -1) {
-            const paddingBottom = stylePaddingBottom || 0;
-            const footerSize = peek$(ctx, "footerSize") || 0;
-            scrollToIndex({
-              index,
-              viewPosition: 1,
-              viewOffset: -paddingBottom - footerSize,
-              ...options
-            });
-          }
-        },
-        setVisibleContentAnchorOffset: (value) => {
-          const val = typeof value === "function" ? value(peek$(ctx, "scrollAdjustUserOffset") || 0) : value;
-          set$(ctx, "scrollAdjustUserOffset", val);
-        }
-      };
-    },
-    []
-  );
-  if (Platform.OS === "web") {
-    useEffect(() => {
-      if (initialContentOffset) {
-        scrollTo({ offset: initialContentOffset, animated: false });
-      }
-    }, []);
-  }
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(
-    ListComponent,
-    {
-      ...rest,
-      canRender,
-      horizontal,
-      refScrollView: combinedRef,
-      initialContentOffset,
-      getRenderedItem,
-      updateItemSize,
-      handleScroll,
-      onMomentumScrollEnd: (event) => {
-        requestAnimationFrame(() => {
-          finishScrollTo();
-        });
-        if (onMomentumScrollEnd) {
-          onMomentumScrollEnd(event);
-        }
-      },
-      onLayout,
-      recycleItems,
-      alignItemsAtEnd,
-      ListEmptyComponent: dataProp.length === 0 ? ListEmptyComponent : void 0,
-      ListHeaderComponent,
-      maintainVisibleContentPosition,
-      scrollEventThrottle: Platform.OS === "web" ? 16 : void 0,
-      waitForInitialLayout,
-      refreshControl: refreshControl ? stylePaddingTopState > 0 ? React2.cloneElement(refreshControl, {
-        progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState
-      }) : refreshControl : onRefresh && /* @__PURE__ */ React2.createElement(
-        RefreshControl,
-        {
-          refreshing: !!refreshing,
-          onRefresh,
-          progressViewOffset: (progressViewOffset || 0) + stylePaddingTopState
-        }
-      ),
-      style,
-      contentContainerStyle,
-      scrollAdjustHandler: (_a = refState.current) == null ? void 0 : _a.scrollAdjustHandler,
-      onLayoutHeader
-    }
-  ), __DEV__ && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React2.createElement(DebugView, { state: refState.current }));
-});
-var typedForwardRef2 = forwardRef;
-var renderItem = ({ item }) => item;
-var LazyLegendList = typedForwardRef2(function LazyLegendList2(props, forwardedRef) {
-  const { LegendList: LegendListProp, children, ...rest } = props;
-  const LegendListComponent = LegendListProp != null ? LegendListProp : LegendList;
-  const data = (isArray(children) ? children : React2.Children.toArray(children)).flat(1);
-  return (
-    // @ts-expect-error TODO: Fix this type
-    /* @__PURE__ */ React2.createElement(LegendListComponent, { ...rest, data, renderItem, ref: forwardedRef })
-  );
-});
-
-export { LazyLegendList, LegendList, useIsLastItem, useListScrollSize, useRecyclingEffect, useRecyclingState, useViewability, useViewabilityAmount };