@rific/scroll-view 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2709 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/CustomList.tsx
+import { memo, useCallback as useCallback2, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { Dimensions, View } from "react-native";
+import { Gesture, GestureDetector } from "react-native-gesture-handler";
+
+// src/internal/RefreshControl.tsx
+import { RefreshControl as RNRefreshControl } from "react-native";
+import { jsx } from "react/jsx-runtime";
+var RefreshControl = (props) => /* @__PURE__ */ jsx(RNRefreshControl, { refreshing: false, ...props });
+
+// src/internal/ScrollViewChip.tsx
+import { StyleSheet } from "react-native";
+import { Chip } from "react-native-paper";
+import Animated from "react-native-reanimated";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ScrollViewChip = ({ isHorizontal, onPress, style }) => /* @__PURE__ */ jsx2(Animated.View, { style: [styles.chip, style], children: /* @__PURE__ */ jsx2(Chip, { compact: true, icon: isHorizontal ? "chevron-left" : "chevron-up", onPress, style: styles.chipInner, children: isHorizontal ? "Start" : "Top" }) });
+var styles = StyleSheet.create({
+  chip: { alignItems: "center", left: 0, position: "absolute", right: 0, zIndex: 3 },
+  chipInner: { elevation: 2, shadowColor: "#000", shadowOffset: { width: 0, height: 1 }, shadowOpacity: 0.15, shadowRadius: 2 }
+});
+
+// src/internal/useScrollHandler.ts
+import { useContext } from "react";
+import { runOnJS, useAnimatedScrollHandler, useSharedValue, withTiming } from "react-native-reanimated";
+
+// src/ScrollViewContext.ts
+import { createContext } from "react";
+var ScrollViewContext = createContext({
+  blur: true,
+  footerHeight: 0,
+  footerHeightShared: null,
+  footerFixed: false,
+  footerOffset: null,
+  headerHeight: 0,
+  headerHeightShared: null,
+  headerFixed: false,
+  headerOffset: null,
+  progress: null,
+  progressing: false,
+  pullSearchHeightShared: null,
+  scrollHeight: 0,
+  scrollPosition: null,
+  setFooterHeight: () => {
+  },
+  setHeaderHeight: () => {
+  },
+  setProgress: () => {
+  },
+  setProgressing: () => {
+  },
+  snapBackFooterShared: null,
+  snapBackHeaderShared: null,
+  tabBarHeight: 60
+});
+
+// src/internal/useScrollHandler.ts
+function useScrollHandler({ chipHidden, footerFixed, headerFixed, isHorizontal, onPullSearchZoneEnter }) {
+  const { footerHeightShared, footerOffset, headerHeightShared, headerOffset, pullSearchHeightShared, scrollPosition, snapBackFooterShared, snapBackHeaderShared } = useContext(ScrollViewContext);
+  const snapUpAccum = useSharedValue(0);
+  const fromBottomBounce = useSharedValue(false);
+  const isMomentum = useSharedValue(false);
+  const momentumPullSearchFired = useSharedValue(false);
+  return useAnimatedScrollHandler(
+    {
+      onScroll: ({ contentOffset: { x, y }, contentSize: { height: contentHeight }, layoutMeasurement: { height: layoutHeight } }) => {
+        "worklet";
+        if (isHorizontal) {
+          scrollPosition.value = x;
+          chipHidden.value = x < 100 ? 1 : 0;
+          return;
+        }
+        const delta = y - scrollPosition.value;
+        scrollPosition.value = y;
+        chipHidden.value = y < 100 ? 1 : 0;
+        const maxScroll = contentHeight - layoutHeight;
+        if (maxScroll > 0 && y >= maxScroll) {
+          fromBottomBounce.value = true;
+          snapUpAccum.value = 0;
+        } else if (fromBottomBounce.value) {
+          fromBottomBounce.value = false;
+        }
+        if (isMomentum.value && pullSearchHeightShared.value > 0 && !momentumPullSearchFired.value) {
+          const hideY = -headerHeightShared.value + pullSearchHeightShared.value;
+          if (y < hideY) {
+            momentumPullSearchFired.value = true;
+            if (onPullSearchZoneEnter) runOnJS(onPullSearchZoneEnter)();
+          }
+        }
+        const snapHeader = snapBackHeaderShared.value && !headerFixed;
+        const snapFooter = snapBackFooterShared.value && !footerFixed;
+        if (snapHeader || snapFooter) {
+          if (y <= -headerHeightShared.value) {
+            snapUpAccum.value = 0;
+            if (snapHeader) headerOffset.value = 0;
+            if (snapFooter) footerOffset.value = 0;
+          } else if (delta > 0) {
+            snapUpAccum.value = 0;
+            if (y >= -headerHeightShared.value + pullSearchHeightShared.value) {
+              if (snapHeader) headerOffset.value = Math.max(-headerHeightShared.value, Math.min(0, headerOffset.value - delta));
+              if (snapFooter) footerOffset.value = Math.max(0, Math.min(footerHeightShared.value, footerOffset.value + delta));
+            }
+          } else if (delta < 0 && !fromBottomBounce.value) {
+            if (y >= -headerHeightShared.value + pullSearchHeightShared.value) snapUpAccum.value -= delta;
+            if (snapUpAccum.value >= 10) {
+              snapUpAccum.value = 999;
+              if (snapHeader) headerOffset.value = withTiming(0, { duration: 200 });
+              if (snapFooter) footerOffset.value = withTiming(0, { duration: 200 });
+            }
+          }
+        }
+      },
+      onBeginDrag: () => {
+        "worklet";
+        isMomentum.value = false;
+        momentumPullSearchFired.value = false;
+        fromBottomBounce.value = false;
+        snapUpAccum.value = 0;
+      },
+      onMomentumBegin: () => {
+        "worklet";
+        isMomentum.value = true;
+        momentumPullSearchFired.value = false;
+      },
+      onEndDrag: ({ contentOffset: { y }, contentSize: { height: contentHeight }, layoutMeasurement: { height: layoutHeight } }) => {
+        "worklet";
+        if (isHorizontal) return;
+        if (y >= contentHeight - layoutHeight - 10) {
+          fromBottomBounce.value = true;
+          snapUpAccum.value = 0;
+        }
+      },
+      onMomentumEnd: () => {
+        "worklet";
+        isMomentum.value = false;
+        momentumPullSearchFired.value = false;
+        fromBottomBounce.value = false;
+        snapUpAccum.value = 0;
+      }
+    },
+    [headerFixed, footerFixed, isHorizontal, onPullSearchZoneEnter]
+  );
+}
+
+// src/internal/useScrollList.ts
+import { useContext as useContext2, useEffect, useMemo } from "react";
+import { StyleSheet as StyleSheet2 } from "react-native";
+import { useAnimatedStyle, useSharedValue as useSharedValue2, withTiming as withTiming2 } from "react-native-reanimated";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+// src/useKeyboardInset.ts
+import { useState } from "react";
+import { useKeyboardHandler } from "react-native-keyboard-controller";
+import { runOnJS as runOnJS2 } from "react-native-reanimated";
+var useKeyboardInset = () => {
+  const [keyboardHeight, setKeyboardHeight] = useState(0);
+  useKeyboardHandler(
+    {
+      onMove: (e) => {
+        "worklet";
+        runOnJS2(setKeyboardHeight)(e.height);
+      },
+      onEnd: (e) => {
+        "worklet";
+        runOnJS2(setKeyboardHeight)(e.height);
+      }
+    },
+    []
+  );
+  return keyboardHeight;
+};
+
+// src/internal/useScrollList.ts
+var CHIP_SLIDE = 48;
+function useScrollList({ footerFixed: footerFixedProp, headerFixed: headerFixedProp, isHorizontal, keyboardAware, pullSearchHeight, style } = {}) {
+  const insets = useSafeAreaInsets();
+  const keyboardHeight = useKeyboardInset();
+  const { footerHeight, footerFixed: contextFooterFixed, headerHeight, headerFixed: contextHeaderFixed, headerOffset, pullSearchHeightShared, scrollPosition, snapBackHeaderShared } = useContext2(ScrollViewContext);
+  const headerFixed = isHorizontal ? true : headerFixedProp ?? contextHeaderFixed;
+  const footerFixed = isHorizontal ? true : footerFixedProp ?? contextFooterFixed;
+  useEffect(() => {
+    pullSearchHeightShared.value = pullSearchHeight ?? 0;
+  }, [pullSearchHeight, pullSearchHeightShared]);
+  const containerStyle = useMemo(() => headerHeight === 0 ? [{ flex: 1 }, style] : [StyleSheet2.absoluteFill, style], [headerHeight, style]);
+  const contentInset = useMemo(() => ({ bottom: (footerFixed ? footerHeight || insets.bottom : insets.bottom) + (keyboardAware ? keyboardHeight : 0), top: headerHeight }), [footerFixed, footerHeight, insets.bottom, headerHeight, keyboardAware, keyboardHeight]);
+  const contentOffset = useMemo(() => ({ x: 0, y: -contentInset.top }), [contentInset.top]);
+  const chipHidden = useSharedValue2(1);
+  const chipStyle = useAnimatedStyle(() => {
+    const pointerEvents = chipHidden.value ? "none" : "box-none";
+    if (isHorizontal) {
+      return {
+        opacity: chipHidden.value ? withTiming2(0) : withTiming2(1),
+        pointerEvents,
+        top: Math.max(headerHeight, insets.top) + 4,
+        transform: [{ translateX: chipHidden.value ? withTiming2(-CHIP_SLIDE) : withTiming2(0) }]
+      };
+    }
+    const slide = headerFixed ? 0 : snapBackHeaderShared.value ? -headerOffset.value : Math.max(0, scrollPosition.value + headerHeight - pullSearchHeightShared.value);
+    const top = Math.max(headerHeight - slide, insets.top) + 4;
+    return {
+      opacity: chipHidden.value ? withTiming2(0) : withTiming2(1),
+      pointerEvents,
+      top,
+      transform: [{ translateY: chipHidden.value ? withTiming2(-CHIP_SLIDE) : withTiming2(0) }]
+    };
+  }, [isHorizontal, headerFixed, headerHeight, insets.top]);
+  return { chipHidden, chipStyle, containerStyle, contentInset, contentOffset, footerFixed, headerFixed, headerHeight, insets, isHorizontal: isHorizontal ?? false };
+}
+
+// src/useScrollInit.ts
+import { createElement, useCallback, useContext as useContext3, useEffect as useEffect2, useLayoutEffect, useRef, useState as useState2 } from "react";
+function useScrollInit({ listHeaderComponent, onMomentumScrollEnd: externalMomentumScrollEnd, onRefresh, onScrollBeginDrag: externalScrollBeginDrag, onScrollEndDrag: externalScrollEndDrag, pullSearchHeight, scrollTo }) {
+  const { headerHeight, scrollPosition, setProgressing } = useContext3(ScrollViewContext);
+  const hasPullSearch = pullSearchHeight !== void 0;
+  const [phase, setPhase] = useState2(hasPullSearch ? "measuring" : "ready");
+  const [refreshing, setRefreshing] = useState2(false);
+  const dragStartY = useRef(null);
+  const deliberatelyOpened = useRef(false);
+  useEffect2(() => {
+    if (phase === "ready" || !headerHeight || !pullSearchHeight) return;
+    scrollPosition.value = -headerHeight + pullSearchHeight;
+    setPhase("ready");
+  }, [phase, headerHeight, pullSearchHeight, scrollPosition]);
+  const headerInitialized = useRef(false);
+  useLayoutEffect(() => {
+    if (!headerHeight || headerInitialized.current) return;
+    headerInitialized.current = true;
+    scrollPosition.value = -headerHeight;
+    scrollTo(-headerHeight, false);
+  }, [headerHeight, scrollPosition, scrollTo]);
+  const pullSearchInitialized = useRef(false);
+  useLayoutEffect(() => {
+    if (!hasPullSearch || phase !== "ready" || pullSearchInitialized.current || !headerHeight || !pullSearchHeight) return;
+    pullSearchInitialized.current = true;
+    scrollPosition.value = -headerHeight + pullSearchHeight;
+    scrollTo(-headerHeight + pullSearchHeight, false);
+  }, [hasPullSearch, phase, headerHeight, pullSearchHeight, scrollPosition, scrollTo]);
+  useEffect2(() => {
+    if (pullSearchHeight) setProgressing(refreshing);
+  }, [pullSearchHeight, refreshing, setProgressing]);
+  const handleScrollBeginDrag = useCallback(
+    (e) => {
+      deliberatelyOpened.current = false;
+      if (pullSearchHeight) dragStartY.current = e.nativeEvent.contentOffset.y;
+      externalScrollBeginDrag?.(e);
+    },
+    [externalScrollBeginDrag, pullSearchHeight]
+  );
+  const handleScrollEndDrag = useCallback(
+    (e) => {
+      if (pullSearchHeight && headerHeight) {
+        const y = e.nativeEvent.contentOffset.y;
+        const showY = -headerHeight;
+        const hideY = -headerHeight + pullSearchHeight;
+        const pulledDown = (dragStartY.current ?? hideY) <= hideY;
+        dragStartY.current = null;
+        if (pulledDown && y <= showY + pullSearchHeight * 0.5) {
+          deliberatelyOpened.current = true;
+          if (y <= showY && !refreshing && onRefresh) {
+            setRefreshing(true);
+            Promise.resolve(onRefresh()).finally(() => setRefreshing(false));
+          }
+          scrollTo(showY, true);
+        } else if (y < hideY) {
+          scrollTo(hideY, true);
+        }
+      }
+      externalScrollEndDrag?.(e);
+    },
+    [externalScrollEndDrag, headerHeight, onRefresh, pullSearchHeight, refreshing, scrollTo]
+  );
+  const handleMomentumScrollEnd = useCallback(
+    (e) => {
+      if (pullSearchHeight && headerHeight && !deliberatelyOpened.current && !refreshing) {
+        const y = e.nativeEvent.contentOffset.y;
+        const hideY = -headerHeight + pullSearchHeight;
+        if (y < hideY - 1) scrollTo(hideY, true);
+      }
+      deliberatelyOpened.current = false;
+      externalMomentumScrollEnd?.(e);
+    },
+    [externalMomentumScrollEnd, headerHeight, pullSearchHeight, refreshing, scrollTo]
+  );
+  const activeListHeader = hasPullSearch && phase === "measuring" ? null : listHeaderComponent;
+  const hiddenHeader = phase === "measuring" && listHeaderComponent != null ? typeof listHeaderComponent === "function" ? createElement(listHeaderComponent) : listHeaderComponent : null;
+  return { activeListHeader, handleMomentumScrollEnd, handleScrollBeginDrag, handleScrollEndDrag, hiddenHeader, pullSearchMinHeight: pullSearchHeight ?? 0 };
+}
+
+// src/CustomList.tsx
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var CustomListInner = ({ component: List, renderFilters, footerFixed: footerFixedProp, gesture, headerFixed: headerFixedProp, keyboardAware, onMomentumScrollEnd: externalMomentumScrollEnd, onRefresh, onScrollBeginDrag: externalScrollBeginDrag, onScrollEndDrag: externalScrollEndDrag, pullSearchHeight, scrollRef, style, ...props }) => {
+  const { ListHeaderComponent: listHeaderComponent, contentContainerStyle: externalContentContainerStyle, ...restProps } = props;
+  const { chipHidden, chipStyle, containerStyle, contentInset, contentOffset, footerFixed, headerFixed } = useScrollList({ footerFixed: footerFixedProp, headerFixed: headerFixedProp, keyboardAware, pullSearchHeight, style });
+  const scrollViewInternal = useRef2(null);
+  const handleRef = useCallback2(
+    (el) => {
+      scrollViewInternal.current = el;
+      if (scrollRef) scrollRef.current = el;
+    },
+    [scrollRef]
+  );
+  const scrollTo = useCallback2((offset, animated) => {
+    scrollViewInternal.current?.scrollToOffset({ offset, animated });
+  }, []);
+  const {
+    activeListHeader: pullSearchHeader,
+    handleMomentumScrollEnd,
+    handleScrollBeginDrag,
+    handleScrollEndDrag,
+    hiddenHeader,
+    pullSearchMinHeight
+  } = useScrollInit({
+    listHeaderComponent,
+    onMomentumScrollEnd: externalMomentumScrollEnd,
+    onRefresh: pullSearchHeight ? onRefresh : void 0,
+    onScrollBeginDrag: externalScrollBeginDrag,
+    onScrollEndDrag: externalScrollEndDrag,
+    pullSearchHeight,
+    scrollTo
+  });
+  const activeListHeader = useMemo2(() => {
+    if (!renderFilters) return pullSearchHeader;
+    const Inner = pullSearchHeader;
+    return () => /* @__PURE__ */ jsxs(Fragment, { children: [
+      Inner ? typeof Inner === "function" ? /* @__PURE__ */ jsx3(Inner, {}) : Inner : null,
+      renderFilters
+    ] });
+  }, [pullSearchHeader, renderFilters]);
+  const contentContainerStyle = useMemo2(() => [{ minHeight: Dimensions.get("window").height - contentInset.top - contentInset.bottom + pullSearchMinHeight }, externalContentContainerStyle], [contentInset.bottom, contentInset.top, externalContentContainerStyle, pullSearchMinHeight]);
+  const onPullSearchZoneEnter = useCallback2(() => {
+    if (!pullSearchHeight) return;
+    scrollViewInternal.current?.scrollToOffset({ offset: -contentInset.top + pullSearchHeight, animated: true });
+  }, [contentInset.top, pullSearchHeight]);
+  const onScroll = useScrollHandler({ chipHidden, footerFixed, headerFixed, onPullSearchZoneEnter: pullSearchHeight ? onPullSearchZoneEnter : void 0 });
+  const handleScrollToTop = useCallback2(() => {
+    const offset = pullSearchHeight ? -contentInset.top + pullSearchHeight : -contentInset.top;
+    scrollViewInternal.current?.scrollToOffset({ offset, animated: true });
+  }, [contentInset.top, pullSearchHeight]);
+  const refreshControl = useMemo2(() => /* @__PURE__ */ jsx3(RefreshControl, {}), []);
+  const nativeGesture = useMemo2(() => Gesture.Native(), []);
+  const combinedGesture = useMemo2(() => gesture !== void 0 ? Gesture.Simultaneous(gesture, nativeGesture) : nativeGesture, [gesture, nativeGesture]);
+  const detectorGesture = gesture !== void 0 ? combinedGesture : void 0;
+  const TypedList = List;
+  const content = /* @__PURE__ */ jsxs(View, { style: containerStyle, children: [
+    /* @__PURE__ */ jsx3(TypedList, { ...restProps, contentContainerStyle, contentInset, contentOffset, ListHeaderComponent: activeListHeader, onMomentumScrollEnd: handleMomentumScrollEnd, onScroll, onScrollBeginDrag: handleScrollBeginDrag, onScrollEndDrag: handleScrollEndDrag, ref: handleRef, refreshControl, scrollEventThrottle: 16 }),
+    hiddenHeader && /* @__PURE__ */ jsx3(View, { pointerEvents: "none", style: styles2.measureContainer, children: hiddenHeader }),
+    /* @__PURE__ */ jsx3(ScrollViewChip, { onPress: handleScrollToTop, style: chipStyle })
+  ] });
+  return detectorGesture ? /* @__PURE__ */ jsx3(GestureDetector, { gesture: detectorGesture, children: content }) : content;
+};
+var styles2 = { measureContainer: { left: 0, opacity: 0, position: "absolute", right: 0, top: -9999 } };
+var CustomList = memo(CustomListInner);
+
+// src/FlatList.tsx
+import { memo as memo2, useCallback as useCallback3, useMemo as useMemo3, useRef as useRef3 } from "react";
+import { Dimensions as Dimensions2, View as View3 } from "react-native";
+import { Gesture as Gesture2, GestureDetector as GestureDetector2 } from "react-native-gesture-handler";
+import Animated3 from "react-native-reanimated";
+
+// src/internal/HorizontalDots.tsx
+import { BlurView } from "@rific/auto-paper";
+import { useContext as useContext4 } from "react";
+import { StyleSheet as StyleSheet3, useWindowDimensions, View as View2 } from "react-native";
+import { useTheme } from "react-native-paper";
+import Animated2, { interpolateColor, useAnimatedStyle as useAnimatedStyle2 } from "react-native-reanimated";
+import { useSafeAreaInsets as useSafeAreaInsets2 } from "react-native-safe-area-context";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var DOT_FULL = 8;
+var DOT_SMALL = 3;
+var DOT_GAP = 6;
+var DOT_STEP = DOT_FULL + DOT_GAP;
+var CLIP_COUNT = 5;
+var CLIP_WIDTH = CLIP_COUNT * DOT_STEP - DOT_GAP;
+var PILL_PAD_H = 10;
+var PILL_PAD_V = 6;
+var PILL_HEIGHT = DOT_FULL + PILL_PAD_V * 2;
+var PILL_RADIUS = PILL_HEIGHT / 2;
+var PILL_WIDTH = CLIP_WIDTH + PILL_PAD_H * 2;
+var Dot = ({ activeColor, index, inactiveColor, pageWidth, scrollPosition }) => {
+  const circleStyle = useAnimatedStyle2(() => {
+    const page = scrollPosition.value / pageWidth;
+    const distance = Math.abs(index - page);
+    const t = Math.max(0, Math.min((distance - 0.5) / 2, 1));
+    const size = DOT_FULL + (DOT_SMALL - DOT_FULL) * t;
+    const backgroundColor = interpolateColor(t, [0, 1], [activeColor, inactiveColor]);
+    return { backgroundColor, borderRadius: size / 2, height: size, width: size };
+  });
+  return /* @__PURE__ */ jsx4(View2, { style: styles3.dotContainer, children: /* @__PURE__ */ jsx4(Animated2.View, { style: circleStyle }) });
+};
+var HorizontalDots = ({ total }) => {
+  const { blur, footerHeightShared, scrollPosition } = useContext4(ScrollViewContext);
+  const { width } = useWindowDimensions();
+  const insets = useSafeAreaInsets2();
+  const theme = useTheme();
+  const insetsBottom = insets.bottom;
+  const activeColor = theme.colors.primary;
+  const inactiveColor = theme.colors.outlineVariant;
+  const pillContainerStyle = useAnimatedStyle2(() => ({
+    bottom: Math.max(footerHeightShared.value, insetsBottom) + 8
+  }));
+  const rowStyle = useAnimatedStyle2(() => {
+    const page = scrollPosition.value / width;
+    const maxOffset = Math.max(0, (total - CLIP_COUNT) * DOT_STEP);
+    const offset = Math.max(0, Math.min((page - (CLIP_COUNT - 1) / 2) * DOT_STEP, maxOffset));
+    return { transform: [{ translateX: -offset }] };
+  });
+  return /* @__PURE__ */ jsx4(Animated2.View, { pointerEvents: "none", style: [styles3.pillContainer, pillContainerStyle], children: /* @__PURE__ */ jsxs2(View2, { style: styles3.pill, children: [
+    /* @__PURE__ */ jsx4(BlurView, { blur, style: StyleSheet3.absoluteFill }),
+    /* @__PURE__ */ jsx4(View2, { style: styles3.dotsClip, children: /* @__PURE__ */ jsx4(Animated2.View, { style: [styles3.dotsRow, rowStyle], children: Array.from({ length: total }).map((_, i) => /* @__PURE__ */ jsx4(Dot, { activeColor, index: i, inactiveColor, pageWidth: width, scrollPosition }, i)) }) })
+  ] }) });
+};
+var styles3 = StyleSheet3.create({
+  dotContainer: { alignItems: "center", height: DOT_FULL, justifyContent: "center", width: DOT_FULL },
+  dotsClip: { overflow: "hidden", width: CLIP_WIDTH },
+  dotsRow: { flexDirection: "row", gap: DOT_GAP },
+  pill: {
+    alignItems: "center",
+    borderRadius: PILL_RADIUS,
+    height: PILL_HEIGHT,
+    justifyContent: "center",
+    overflow: "hidden",
+    width: PILL_WIDTH
+  },
+  pillContainer: { alignItems: "center", left: 0, position: "absolute", right: 0, zIndex: 3 }
+});
+
+// src/FlatList.tsx
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var FlatListInner = ({ contentContainerStyle: externalContentContainerStyle, data, initialNumToRender = 20, maxToRenderPerBatch = 50, renderFilters, footerFixed: footerFixedProp, gesture, headerFixed: headerFixedProp, horizontal, keyboardAware, ListHeaderComponent: externalListHeaderComponent, onMomentumScrollEnd: externalMomentumScrollEnd, onRefresh, onScrollBeginDrag: externalScrollBeginDrag, onScrollEndDrag: externalScrollEndDrag, pagingEnabled, pullSearchHeight, removeClippedSubviews = false, showsHorizontalScrollIndicator, showsVerticalScrollIndicator, style, onContentSizeChange, ref: externalRef, windowSize = 100, ...props }) => {
+  const scrollView = useRef3(null);
+  const isHorizontal = horizontal === true;
+  const showDots = isHorizontal && pagingEnabled === true && (data?.length ?? 0) > 1;
+  const { chipHidden, chipStyle, containerStyle, contentInset, contentOffset, footerFixed, headerFixed } = useScrollList({ footerFixed: footerFixedProp, headerFixed: headerFixedProp, isHorizontal, keyboardAware, pullSearchHeight, style });
+  const scrollTo = useCallback3((offset, animated) => {
+    scrollView.current?.scrollToOffset({ offset, animated });
+  }, []);
+  const {
+    activeListHeader: pullSearchHeader,
+    handleMomentumScrollEnd,
+    handleScrollBeginDrag,
+    handleScrollEndDrag,
+    hiddenHeader,
+    pullSearchMinHeight
+  } = useScrollInit({
+    listHeaderComponent: externalListHeaderComponent,
+    onMomentumScrollEnd: externalMomentumScrollEnd,
+    onRefresh: pullSearchHeight ? onRefresh : void 0,
+    onScrollBeginDrag: externalScrollBeginDrag,
+    onScrollEndDrag: externalScrollEndDrag,
+    pullSearchHeight,
+    scrollTo
+  });
+  const activeListHeader = useMemo3(() => {
+    if (!renderFilters) return pullSearchHeader;
+    const Inner = pullSearchHeader;
+    return () => /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      Inner ? typeof Inner === "function" ? /* @__PURE__ */ jsx5(Inner, {}) : Inner : null,
+      renderFilters
+    ] });
+  }, [pullSearchHeader, renderFilters]);
+  const contentContainerStyle = useMemo3(() => isHorizontal ? externalContentContainerStyle : [{ minHeight: Dimensions2.get("window").height - contentInset.top - contentInset.bottom + pullSearchMinHeight }, externalContentContainerStyle], [isHorizontal, contentInset.bottom, contentInset.top, externalContentContainerStyle, pullSearchMinHeight]);
+  const onPullSearchZoneEnter = useCallback3(() => {
+    if (!pullSearchHeight) return;
+    scrollView.current?.scrollToOffset({ offset: -contentInset.top + pullSearchHeight, animated: true });
+  }, [contentInset.top, pullSearchHeight]);
+  const handleScroll = useScrollHandler({ chipHidden, footerFixed, headerFixed, isHorizontal, onPullSearchZoneEnter: pullSearchHeight ? onPullSearchZoneEnter : void 0 });
+  const handleScrollToTop = useCallback3(() => {
+    if (isHorizontal) {
+      scrollView.current?.scrollToOffset({ offset: 0, animated: true });
+      return;
+    }
+    const offset = pullSearchHeight ? -contentInset.top + pullSearchHeight : -contentInset.top;
+    scrollView.current?.scrollToOffset({ offset, animated: true });
+  }, [isHorizontal, contentInset.top, pullSearchHeight]);
+  const handleContentSizeChange = useCallback3(
+    (w, h) => {
+      if (onContentSizeChange) onContentSizeChange(w, h);
+    },
+    [onContentSizeChange]
+  );
+  const refreshControl = useMemo3(() => /* @__PURE__ */ jsx5(RefreshControl, {}), []);
+  const nativeGesture = useMemo3(() => Gesture2.Native(), []);
+  const combinedGesture = useMemo3(() => gesture !== void 0 ? Gesture2.Simultaneous(gesture, nativeGesture) : nativeGesture, [gesture, nativeGesture]);
+  const detectorGesture = gesture !== void 0 ? combinedGesture : void 0;
+  const content = /* @__PURE__ */ jsxs3(View3, { style: containerStyle, children: [
+    /* @__PURE__ */ jsx5(
+      Animated3.FlatList,
+      {
+        ...props,
+        contentContainerStyle,
+        contentInset,
+        contentOffset,
+        data,
+        horizontal: isHorizontal,
+        initialNumToRender,
+        ListHeaderComponent: activeListHeader,
+        maxToRenderPerBatch,
+        onContentSizeChange: handleContentSizeChange,
+        onMomentumScrollEnd: handleMomentumScrollEnd,
+        onScroll: handleScroll,
+        onScrollBeginDrag: handleScrollBeginDrag,
+        onScrollEndDrag: handleScrollEndDrag,
+        pagingEnabled,
+        ref: (el) => {
+          if (externalRef) externalRef.current = el;
+          scrollView.current = el;
+        },
+        refreshControl,
+        removeClippedSubviews,
+        scrollEventThrottle: 16,
+        showsHorizontalScrollIndicator: showsHorizontalScrollIndicator ?? isHorizontal,
+        showsVerticalScrollIndicator: showsVerticalScrollIndicator ?? !isHorizontal,
+        windowSize
+      }
+    ),
+    hiddenHeader && /* @__PURE__ */ jsx5(View3, { pointerEvents: "none", style: styles4.measureContainer, children: hiddenHeader }),
+    /* @__PURE__ */ jsx5(ScrollViewChip, { isHorizontal, onPress: handleScrollToTop, style: chipStyle }),
+    showDots && /* @__PURE__ */ jsx5(HorizontalDots, { total: data?.length ?? 0 })
+  ] });
+  return detectorGesture ? /* @__PURE__ */ jsx5(GestureDetector2, { gesture: detectorGesture, children: content }) : content;
+};
+var styles4 = { measureContainer: { left: 0, opacity: 0, position: "absolute", right: 0, top: -9999 } };
+var FlatList = memo2(FlatListInner);
+
+// src/PullSearch.tsx
+import { forwardRef, useCallback as useCallback4, useContext as useContext5, useEffect as useEffect3, useImperativeHandle, useRef as useRef4, useState as useState3 } from "react";
+import { StyleSheet as StyleSheet4 } from "react-native";
+import { Searchbar, useTheme as useTheme2 } from "react-native-paper";
+import Animated4, { Extrapolation, interpolate, runOnJS as runOnJS3, useAnimatedReaction, useAnimatedStyle as useAnimatedStyle3 } from "react-native-reanimated";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var PullSearch = forwardRef(function PullSearch2({ debounce, onChangeText, onHeightChange, placeholder, value: propValue }, ref) {
+  const { headerHeight, scrollPosition } = useContext5(ScrollViewContext);
+  const theme = useTheme2();
+  const inputRef = useRef4(null);
+  const [barHeight, setBarHeight] = useState3(0);
+  const [value, setValue] = useState3(propValue ?? "");
+  const prevPropValueRef = useRef4(propValue);
+  useEffect3(() => {
+    if (prevPropValueRef.current === propValue) return;
+    prevPropValueRef.current = propValue;
+    setValue(propValue ?? "");
+  }, [propValue]);
+  useImperativeHandle(ref, () => ({
+    blur: () => inputRef.current?.blur(),
+    focus: () => inputRef.current?.focus()
+  }));
+  const blurInput = useCallback4(() => inputRef.current?.blur(), []);
+  useAnimatedReaction(
+    () => {
+      if (barHeight === 0) return false;
+      return scrollPosition.value >= -headerHeight + barHeight;
+    },
+    (isHidden, wasHidden) => {
+      if (isHidden && !wasHidden) runOnJS3(blurInput)();
+    },
+    [barHeight, headerHeight, blurInput]
+  );
+  const handleClear = useCallback4(() => {
+    setValue("");
+    onChangeText("");
+  }, [onChangeText]);
+  const handleLayout = useCallback4(
+    ({
+      nativeEvent: {
+        layout: { height }
+      }
+    }) => {
+      setBarHeight(height);
+      onHeightChange(height);
+    },
+    [onHeightChange]
+  );
+  useEffect3(() => {
+    const normalizedValue = value.trim();
+    if (debounce) {
+      const timeout = setTimeout(() => onChangeText(normalizedValue), 500);
+      return () => clearTimeout(timeout);
+    }
+    onChangeText(normalizedValue);
+  }, [debounce, onChangeText, value]);
+  const animatedStyle = useAnimatedStyle3(() => {
+    if (barHeight === 0) return { opacity: 0 };
+    const showY = -headerHeight;
+    const hideY = -headerHeight + barHeight;
+    return { opacity: interpolate(scrollPosition.value, [showY, hideY], [1, 0], Extrapolation.CLAMP) };
+  }, [barHeight, headerHeight]);
+  return /* @__PURE__ */ jsx6(Animated4.View, { onLayout: handleLayout, style: [styles5.container, animatedStyle], children: /* @__PURE__ */ jsx6(Searchbar, { autoCorrect: false, onChangeText: (text) => setValue((text || "").trimStart()), onClearIconPress: handleClear, placeholder, placeholderTextColor: theme.colors.onSurfaceVariant, ref: inputRef, spellCheck: false, style: styles5.input, value }) });
+});
+var styles5 = StyleSheet4.create({
+  container: { paddingVertical: 8 },
+  input: { margin: 0 }
+});
+
+// node_modules/redux/dist/redux.mjs
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+};
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
+}
+function compose(...funcs) {
+  if (funcs.length === 0) {
+    return (arg) => arg;
+  }
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
+}
+function isAction(action) {
+  return isPlainObject(action) && "type" in action && typeof action.type === "string";
+}
+
+// node_modules/immer/dist/immer.mjs
+var NOTHING = /* @__PURE__ */ Symbol.for("immer-nothing");
+var DRAFTABLE = /* @__PURE__ */ Symbol.for("immer-draftable");
+var DRAFT_STATE = /* @__PURE__ */ Symbol.for("immer-state");
+var errors = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(plugin) {
+    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+  },
+  function(thing) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(data) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(thing) {
+    return `'current' expects a draft, got: ${thing}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(thing) {
+    return `'original' expects a draft, got: ${thing}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function die(error, ...args) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = errors[error];
+    const msg = isFunction(e) ? e.apply(null, args) : e;
+    throw new Error(`[Immer] ${msg}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var O = Object;
+var getPrototypeOf = O.getPrototypeOf;
+var CONSTRUCTOR = "constructor";
+var PROTOTYPE = "prototype";
+var CONFIGURABLE = "configurable";
+var ENUMERABLE = "enumerable";
+var WRITABLE = "writable";
+var VALUE = "value";
+var isDraft = (value) => !!value && !!value[DRAFT_STATE];
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject2(value) || isArray(value) || !!value[DRAFTABLE] || !!value[CONSTRUCTOR]?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = O[PROTOTYPE][CONSTRUCTOR].toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
+function isPlainObject2(value) {
+  if (!value || !isObjectish(value))
+    return false;
+  const proto = getPrototypeOf(value);
+  if (proto === null || proto === O[PROTOTYPE])
+    return true;
+  const Ctor = O.hasOwnProperty.call(proto, CONSTRUCTOR) && proto[CONSTRUCTOR];
+  if (Ctor === Object)
+    return true;
+  if (!isFunction(Ctor))
+    return false;
+  let ctorString = cachedCtorStrings.get(Ctor);
+  if (ctorString === void 0) {
+    ctorString = Function.toString.call(Ctor);
+    cachedCtorStrings.set(Ctor, ctorString);
+  }
+  return ctorString === objectCtorString;
+}
+function each(obj, iter, strict = true) {
+  if (getArchtype(obj) === 0) {
+    const keys = strict ? Reflect.ownKeys(obj) : O.keys(obj);
+    keys.forEach((key) => {
+      iter(key, obj[key], obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
+  }
+}
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+}
+var has = (thing, prop, type = getArchtype(thing)) => type === 2 ? thing.has(prop) : O[PROTOTYPE].hasOwnProperty.call(thing, prop);
+var get = (thing, prop, type = getArchtype(thing)) => (
+  // @ts-ignore
+  type === 2 ? thing.get(prop) : thing[prop]
+);
+var set = (thing, propOrOldValue, value, type = getArchtype(thing)) => {
+  if (type === 2)
+    thing.set(propOrOldValue, value);
+  else if (type === 3) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+};
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+var isArray = Array.isArray;
+var isMap = (target) => target instanceof Map;
+var isSet = (target) => target instanceof Set;
+var isObjectish = (target) => typeof target === "object";
+var isFunction = (target) => typeof target === "function";
+var isBoolean = (target) => typeof target === "boolean";
+function isArrayIndex(value) {
+  const n = +value;
+  return Number.isInteger(n) && String(n) === value;
+}
+var latest = (state) => state.copy_ || state.base_;
+var getFinalValue = (state) => state.modified_ ? state.copy_ : state.base_;
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (isArray(base))
+    return Array[PROTOTYPE].slice.call(base);
+  const isPlain = isPlainObject2(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const descriptors = O.getOwnPropertyDescriptors(base);
+    delete descriptors[DRAFT_STATE];
+    let keys = Reflect.ownKeys(descriptors);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = descriptors[key];
+      if (desc[WRITABLE] === false) {
+        desc[WRITABLE] = true;
+        desc[CONFIGURABLE] = true;
+      }
+      if (desc.get || desc.set)
+        descriptors[key] = {
+          [CONFIGURABLE]: true,
+          [WRITABLE]: true,
+          // could live with !!desc.set as well here...
+          [ENUMERABLE]: desc[ENUMERABLE],
+          [VALUE]: base[key]
+        };
+    }
+    return O.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto = getPrototypeOf(base);
+    if (proto !== null && isPlain) {
+      return { ...base };
+    }
+    const obj = O.create(proto);
+    return O.assign(obj, base);
+  }
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    O.defineProperties(obj, {
+      set: dontMutateMethodOverride,
+      add: dontMutateMethodOverride,
+      clear: dontMutateMethodOverride,
+      delete: dontMutateMethodOverride
+    });
+  }
+  O.freeze(obj);
+  if (deep)
+    each(
+      obj,
+      (_key, value) => {
+        freeze(value, true);
+      },
+      false
+    );
+  return obj;
+}
+function dontMutateFrozenCollections() {
+  die(2);
+}
+var dontMutateMethodOverride = {
+  [VALUE]: dontMutateFrozenCollections
+};
+function isFrozen(obj) {
+  if (obj === null || !isObjectish(obj))
+    return true;
+  return O.isFrozen(obj);
+}
+var PluginMapSet = "MapSet";
+var PluginPatches = "Patches";
+var PluginArrayMethods = "ArrayMethods";
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
+}
+var isPluginLoaded = (pluginKey) => !!plugins[pluginKey];
+var currentScope;
+var getCurrentScope = () => currentScope;
+var createScope = (parent_, immer_) => ({
+  drafts_: [],
+  parent_,
+  immer_,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: true,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: isPluginLoaded(PluginMapSet) ? getPlugin(PluginMapSet) : void 0,
+  arrayMethodsPlugin_: isPluginLoaded(PluginArrayMethods) ? getPlugin(PluginArrayMethods) : void 0
+});
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    scope.patchPlugin_ = getPlugin(PluginPatches);
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
+  }
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
+  }
+}
+var enterScope = (immer2) => currentScope = createScope(currentScope, immer2);
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 || state.type_ === 1)
+    state.revoke_();
+  else
+    state.revoked_ = true;
+}
+function processResult(result, scope) {
+  scope.unfinalizedDrafts_ = scope.drafts_.length;
+  const baseDraft = scope.drafts_[0];
+  const isReplaced = result !== void 0 && result !== baseDraft;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+    }
+    const { patchPlugin_ } = scope;
+    if (patchPlugin_) {
+      patchPlugin_.generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft);
+  }
+  maybeFreeze(scope, result, true);
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value) {
+  if (isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    const finalValue = handleValue(value, rootScope.handledSet_, rootScope);
+    return finalValue;
+  }
+  if (!isSameScope(state, rootScope)) {
+    return value;
+  }
+  if (!state.modified_) {
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    const { callbacks_ } = state;
+    if (callbacks_) {
+      while (callbacks_.length > 0) {
+        const callback = callbacks_.pop();
+        callback(rootScope);
+      }
+    }
+    generatePatchesAndFinalize(state, rootScope);
+  }
+  return state.copy_;
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+function markStateFinalized(state) {
+  state.finalized_ = true;
+  state.scope_.unfinalizedDrafts_--;
+}
+var isSameScope = (state, rootScope) => state.scope_ === rootScope;
+var EMPTY_LOCATIONS_RESULT = [];
+function updateDraftInParent(parent, draftValue, finalizedValue, originalKey) {
+  const parentCopy = latest(parent);
+  const parentType = parent.type_;
+  if (originalKey !== void 0) {
+    const currentValue = get(parentCopy, originalKey, parentType);
+    if (currentValue === draftValue) {
+      set(parentCopy, originalKey, finalizedValue, parentType);
+      return;
+    }
+  }
+  if (!parent.draftLocations_) {
+    const draftLocations = parent.draftLocations_ = /* @__PURE__ */ new Map();
+    each(parentCopy, (key, value) => {
+      if (isDraft(value)) {
+        const keys = draftLocations.get(value) || [];
+        keys.push(key);
+        draftLocations.set(value, keys);
+      }
+    });
+  }
+  const locations = parent.draftLocations_.get(draftValue) ?? EMPTY_LOCATIONS_RESULT;
+  for (const location of locations) {
+    set(parentCopy, location, finalizedValue, parentType);
+  }
+}
+function registerChildFinalizationCallback(parent, child, key) {
+  parent.callbacks_.push(function childCleanup(rootScope) {
+    const state = child;
+    if (!state || !isSameScope(state, rootScope)) {
+      return;
+    }
+    rootScope.mapSetPlugin_?.fixSetContents(state);
+    const finalizedValue = getFinalValue(state);
+    updateDraftInParent(parent, state.draft_ ?? state, finalizedValue, key);
+    generatePatchesAndFinalize(state, rootScope);
+  });
+}
+function generatePatchesAndFinalize(state, rootScope) {
+  const shouldFinalize = state.modified_ && !state.finalized_ && (state.type_ === 3 || state.type_ === 1 && state.allIndicesReassigned_ || (state.assigned_?.size ?? 0) > 0);
+  if (shouldFinalize) {
+    const { patchPlugin_ } = rootScope;
+    if (patchPlugin_) {
+      const basePath = patchPlugin_.getPath(state);
+      if (basePath) {
+        patchPlugin_.generatePatches_(state, basePath, rootScope);
+      }
+    }
+    markStateFinalized(state);
+  }
+}
+function handleCrossReference(target, key, value) {
+  const { scope_ } = target;
+  if (isDraft(value)) {
+    const state = value[DRAFT_STATE];
+    if (isSameScope(state, scope_)) {
+      state.callbacks_.push(function crossReferenceCleanup() {
+        prepareCopy(target);
+        const finalizedValue = getFinalValue(state);
+        updateDraftInParent(target, value, finalizedValue, key);
+      });
+    }
+  } else if (isDraftable(value)) {
+    target.callbacks_.push(function nestedDraftCleanup() {
+      const targetCopy = latest(target);
+      if (target.type_ === 3) {
+        if (targetCopy.has(value)) {
+          handleValue(value, scope_.handledSet_, scope_);
+        }
+      } else {
+        if (get(targetCopy, key, target.type_) === value) {
+          if (scope_.drafts_.length > 1 && (target.assigned_.get(key) ?? false) === true && target.copy_) {
+            handleValue(
+              get(target.copy_, key, target.type_),
+              scope_.handledSet_,
+              scope_
+            );
+          }
+        }
+      }
+    });
+  }
+}
+function handleValue(target, handledSet, rootScope) {
+  if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+    return target;
+  }
+  if (isDraft(target) || handledSet.has(target) || !isDraftable(target) || isFrozen(target)) {
+    return target;
+  }
+  handledSet.add(target);
+  each(target, (key, value) => {
+    if (isDraft(value)) {
+      const state = value[DRAFT_STATE];
+      if (isSameScope(state, rootScope)) {
+        const updatedValue = getFinalValue(state);
+        set(target, key, updatedValue, target.type_);
+        markStateFinalized(state);
+      }
+    } else if (isDraftable(value)) {
+      handleValue(value, handledSet, rootScope);
+    }
+  });
+  return target;
+}
+function createProxyProxy(base, parent) {
+  const baseIsArray = isArray(base);
+  const state = {
+    type_: baseIsArray ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: parent ? parent.scope_ : getCurrentScope(),
+    // True for both shallow and deep changes.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (baseIsArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return [proxy, state];
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    let arrayPlugin = state.scope_.arrayMethodsPlugin_;
+    const isArrayWithStringProp = state.type_ === 1 && typeof prop === "string";
+    if (isArrayWithStringProp) {
+      if (arrayPlugin?.isArrayOperationMethod(prop)) {
+        return arrayPlugin.createMethodInterceptor(state, prop);
+      }
+    }
+    const source = latest(state);
+    if (!has(source, prop, state.type_)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (isArrayWithStringProp && state.operationMethod && arrayPlugin?.isMutatingArrayMethod(
+      state.operationMethod
+    ) && isArrayIndex(prop)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      const childKey = state.type_ === 1 ? +prop : prop;
+      const childDraft = createProxy(state.scope_, value, state, childKey);
+      return state.copy_[childKey] = childDraft;
+    }
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc?.set) {
+      desc.set.call(state.draft_, value);
+      return true;
+    }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = current2?.[DRAFT_STATE];
+      if (currentState && currentState.base_ === value) {
+        state.copy_[prop] = value;
+        state.assigned_.set(prop, false);
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
+        return true;
+      prepareCopy(state);
+      markChanged(state);
+    }
+    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+    (value !== void 0 || prop in state.copy_) || // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
+      return true;
+    state.copy_[prop] = value;
+    state.assigned_.set(prop, true);
+    handleCrossReference(state, prop, value);
+    return true;
+  },
+  deleteProperty(state, prop) {
+    prepareCopy(state);
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_.set(prop, false);
+      markChanged(state);
+    } else {
+      state.assigned_.delete(prop);
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(state, prop) {
+    const owner = latest(state);
+    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc)
+      return desc;
+    return {
+      [WRITABLE]: true,
+      [CONFIGURABLE]: state.type_ !== 1 || prop !== "length",
+      [ENUMERABLE]: desc[ENUMERABLE],
+      [VALUE]: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
+  }
+};
+var arrayTraps = {};
+for (let key in objectTraps) {
+  let fn = objectTraps[key];
+  arrayTraps[key] = function() {
+    const args = arguments;
+    args[0] = args[0][0];
+    return fn.apply(this, args);
+  };
+}
+arrayTraps.deleteProperty = function(state, prop) {
+  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
+    die(13);
+  return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
+    die(14);
+  return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+  const state = draft[DRAFT_STATE];
+  const source = state ? latest(state) : draft;
+  return source[prop];
+}
+function readPropFromProto(state, source, prop) {
+  const desc = getDescriptorFromProto(source, prop);
+  return desc ? VALUE in desc ? desc[VALUE] : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    desc.get?.call(state.draft_)
+  ) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto = getPrototypeOf(source);
+  while (proto) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc)
+      return desc;
+    proto = getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
+    }
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.assigned_ = /* @__PURE__ */ new Map();
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
+}
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    this.useStrictIteration_ = false;
+    this.produce = (base, recipe, patchListener) => {
+      if (isFunction(base) && !isFunction(recipe)) {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
+      }
+      if (!isFunction(recipe))
+        die(6);
+      if (patchListener !== void 0 && !isFunction(patchListener))
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(scope, base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
+        }
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } else if (!base || !isObjectish(base)) {
+        result = recipe(base);
+        if (result === void 0)
+          result = base;
+        if (result === NOTHING)
+          result = void 0;
+        if (this.autoFreeze_)
+          freeze(result, true);
+        if (patchListener) {
+          const p = [];
+          const ip = [];
+          getPlugin(PluginPatches).generateReplacementPatches_(base, result, {
+            patches_: p,
+            inversePatches_: ip
+          });
+          patchListener(p, ip);
+        }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (isFunction(base)) {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+      }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (p, ip) => {
+        patches = p;
+        inversePatches = ip;
+      });
+      return [result, patches, inversePatches];
+    };
+    if (isBoolean(config?.autoFreeze))
+      this.setAutoFreeze(config.autoFreeze);
+    if (isBoolean(config?.useStrictShallowCopy))
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+    if (isBoolean(config?.useStrictIteration))
+      this.setUseStrictIteration(config.useStrictIteration);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(scope, base, void 0);
+    proxy[DRAFT_STATE].isManual_ = true;
+    leaveScope(scope);
+    return proxy;
+  }
+  finishDraft(draft, patchListener) {
+    const state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual_)
+      die(9);
+    const { scope_: scope } = state;
+    usePatchesInScope(scope, patchListener);
+    return processResult(void 0, scope);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(value) {
+    this.autoFreeze_ = value;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(value) {
+    this.useStrictShallowCopy_ = value;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(value) {
+    this.useStrictIteration_ = value;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(base, patches) {
+    let i;
+    for (i = patches.length - 1; i >= 0; i--) {
+      const patch = patches[i];
+      if (patch.path.length === 0 && patch.op === "replace") {
+        base = patch.value;
+        break;
+      }
+    }
+    if (i > -1) {
+      patches = patches.slice(i + 1);
+    }
+    const applyPatchesImpl = getPlugin(PluginPatches).applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(rootScope, value, parent, key) {
+  const [draft, state] = isMap(value) ? getPlugin(PluginMapSet).proxyMap_(value, parent) : isSet(value) ? getPlugin(PluginMapSet).proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent?.scope_ ?? getCurrentScope();
+  scope.drafts_.push(draft);
+  state.callbacks_ = parent?.callbacks_ ?? [];
+  state.key_ = key;
+  if (parent && key !== void 0) {
+    registerChildFinalizationCallback(parent, state, key);
+  } else {
+    state.callbacks_.push(function rootDraftCleanup(rootScope2) {
+      rootScope2.mapSetPlugin_?.fixSetContents(state);
+      const { patchPlugin_ } = rootScope2;
+      if (state.modified_ && patchPlugin_) {
+        patchPlugin_.generatePatches_(state, [], rootScope2);
+      }
+    });
+  }
+  return draft;
+}
+function current(value) {
+  if (!isDraft(value))
+    die(10, value);
+  return currentImpl(value);
+}
+function currentImpl(value) {
+  if (!isDraftable(value) || isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  let copy;
+  let strict = true;
+  if (state) {
+    if (!state.modified_)
+      return state.base_;
+    state.finalized_ = true;
+    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+    strict = state.scope_.immer_.shouldUseStrictIteration();
+  } else {
+    copy = shallowCopy(value, true);
+  }
+  each(
+    copy,
+    (key, childValue) => {
+      set(copy, key, currentImpl(childValue));
+    },
+    strict
+  );
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+var immer = new Immer2();
+var produce = immer.produce;
+
+// node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs
+var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
+  if (arguments.length === 0) return void 0;
+  if (typeof arguments[0] === "object") return compose;
+  return compose.apply(null, arguments);
+};
+var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
+  return function(noop3) {
+    return noop3;
+  };
+};
+var hasMatchFunction = (v) => {
+  return v && typeof v.match === "function";
+};
+function createAction(type, prepareAction) {
+  function actionCreator(...args) {
+    if (prepareAction) {
+      let prepared = prepareAction(...args);
+      if (!prepared) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "prepareAction did not return an object");
+      }
+      return {
+        type,
+        payload: prepared.payload,
+        ..."meta" in prepared && {
+          meta: prepared.meta
+        },
+        ..."error" in prepared && {
+          error: prepared.error
+        }
+      };
+    }
+    return {
+      type,
+      payload: args[0]
+    };
+  }
+  actionCreator.toString = () => `${type}`;
+  actionCreator.type = type;
+  actionCreator.match = (action) => isAction(action) && action.type === type;
+  return actionCreator;
+}
+function freezeDraftable(val) {
+  return isDraftable(val) ? produce(val, () => {
+  }) : val;
+}
+function getOrInsertComputed(map, key, compute) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, compute(key)).get(key);
+}
+function executeReducerBuilderCallback(builderCallback) {
+  const actionsMap = {};
+  const actionMatchers = [];
+  let defaultCaseReducer;
+  const builder = {
+    addCase(typeOrActionCreator, reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (actionMatchers.length > 0) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        }
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+      if (!type) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(28) : "`builder.addCase` cannot be called with an empty action type");
+      }
+      if (type in actionsMap) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
+      }
+      actionsMap[type] = reducer;
+      return builder;
+    },
+    addAsyncThunk(asyncThunk, reducers) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      if (reducers.pending) actionsMap[asyncThunk.pending.type] = reducers.pending;
+      if (reducers.rejected) actionsMap[asyncThunk.rejected.type] = reducers.rejected;
+      if (reducers.fulfilled) actionsMap[asyncThunk.fulfilled.type] = reducers.fulfilled;
+      if (reducers.settled) actionMatchers.push({
+        matcher: asyncThunk.settled,
+        reducer: reducers.settled
+      });
+      return builder;
+    },
+    addMatcher(matcher, reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      actionMatchers.push({
+        matcher,
+        reducer
+      });
+      return builder;
+    },
+    addDefaultCase(reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(31) : "`builder.addDefaultCase` can only be called once");
+        }
+      }
+      defaultCaseReducer = reducer;
+      return builder;
+    }
+  };
+  builderCallback(builder);
+  return [actionsMap, actionMatchers, defaultCaseReducer];
+}
+function isStateFunction(x) {
+  return typeof x === "function";
+}
+function createReducer(initialState, mapOrBuilderCallback) {
+  if (process.env.NODE_ENV !== "production") {
+    if (typeof mapOrBuilderCallback === "object") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
+    }
+  }
+  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
+  let getInitialState;
+  if (isStateFunction(initialState)) {
+    getInitialState = () => freezeDraftable(initialState());
+  } else {
+    const frozenInitialState = freezeDraftable(initialState);
+    getInitialState = () => frozenInitialState;
+  }
+  function reducer(state = getInitialState(), action) {
+    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
+      matcher
+    }) => matcher(action)).map(({
+      reducer: reducer2
+    }) => reducer2)];
+    if (caseReducers.filter((cr) => !!cr).length === 0) {
+      caseReducers = [finalDefaultCaseReducer];
+    }
+    return caseReducers.reduce((previousState, caseReducer) => {
+      if (caseReducer) {
+        if (isDraft(previousState)) {
+          const draft = previousState;
+          const result = caseReducer(draft, action);
+          if (result === void 0) {
+            return previousState;
+          }
+          return result;
+        } else if (!isDraftable(previousState)) {
+          const result = caseReducer(previousState, action);
+          if (result === void 0) {
+            if (previousState === null) {
+              return previousState;
+            }
+            throw Error("A case reducer on a non-draftable value must not return undefined");
+          }
+          return result;
+        } else {
+          return produce(previousState, (draft) => {
+            return caseReducer(draft, action);
+          });
+        }
+      }
+      return previousState;
+    }, state);
+  }
+  reducer.getInitialState = getInitialState;
+  return reducer;
+}
+var matches = (matcher, action) => {
+  if (hasMatchFunction(matcher)) {
+    return matcher.match(action);
+  } else {
+    return matcher(action);
+  }
+};
+function isAnyOf(...matchers) {
+  return (action) => {
+    return matchers.some((matcher) => matches(matcher, action));
+  };
+}
+var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
+var nanoid = (size = 21) => {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
+var commonProperties = ["name", "message", "stack", "code"];
+var RejectWithValue = class {
+  constructor(payload, meta) {
+    __publicField(this, "payload");
+    __publicField(this, "meta");
+    /*
+    type-only property to distinguish between RejectWithValue and FulfillWithMeta
+    does not exist at runtime
+    */
+    __publicField(this, "_type");
+    this.payload = payload;
+    this.meta = meta;
+  }
+};
+var FulfillWithMeta = class {
+  constructor(payload, meta) {
+    __publicField(this, "payload");
+    __publicField(this, "meta");
+    /*
+    type-only property to distinguish between RejectWithValue and FulfillWithMeta
+    does not exist at runtime
+    */
+    __publicField(this, "_type");
+    this.payload = payload;
+    this.meta = meta;
+  }
+};
+var miniSerializeError = (value) => {
+  if (typeof value === "object" && value !== null) {
+    const simpleError = {};
+    for (const property of commonProperties) {
+      if (typeof value[property] === "string") {
+        simpleError[property] = value[property];
+      }
+    }
+    return simpleError;
+  }
+  return {
+    message: String(value)
+  };
+};
+var externalAbortMessage = "External signal was aborted";
+var createAsyncThunk = /* @__PURE__ */ (() => {
+  function createAsyncThunk2(typePrefix, payloadCreator, options) {
+    const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
+      payload,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "fulfilled"
+      }
+    }));
+    const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
+      payload: void 0,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "pending"
+      }
+    }));
+    const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
+      payload,
+      error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        rejectedWithValue: !!payload,
+        requestStatus: "rejected",
+        aborted: error?.name === "AbortError",
+        condition: error?.name === "ConditionError"
+      }
+    }));
+    function actionCreator(arg, {
+      signal
+    } = {}) {
+      return (dispatch, getState, extra) => {
+        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
+        const abortController = new AbortController();
+        let abortHandler;
+        let abortReason;
+        function abort(reason) {
+          abortReason = reason;
+          abortController.abort();
+        }
+        if (signal) {
+          if (signal.aborted) {
+            abort(externalAbortMessage);
+          } else {
+            signal.addEventListener("abort", () => abort(externalAbortMessage), {
+              once: true
+            });
+          }
+        }
+        const promise = (async function() {
+          let finalAction;
+          try {
+            let conditionResult = options?.condition?.(arg, {
+              getState,
+              extra
+            });
+            if (isThenable(conditionResult)) {
+              conditionResult = await conditionResult;
+            }
+            if (conditionResult === false || abortController.signal.aborted) {
+              throw {
+                name: "ConditionError",
+                message: "Aborted due to condition callback returning false."
+              };
+            }
+            const abortedPromise = new Promise((_, reject) => {
+              abortHandler = () => {
+                reject({
+                  name: "AbortError",
+                  message: abortReason || "Aborted"
+                });
+              };
+              abortController.signal.addEventListener("abort", abortHandler, {
+                once: true
+              });
+            });
+            dispatch(pending(requestId, arg, options?.getPendingMeta?.({
+              requestId,
+              arg
+            }, {
+              getState,
+              extra
+            })));
+            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
+              dispatch,
+              getState,
+              extra,
+              requestId,
+              signal: abortController.signal,
+              abort,
+              rejectWithValue: ((value, meta) => {
+                return new RejectWithValue(value, meta);
+              }),
+              fulfillWithValue: ((value, meta) => {
+                return new FulfillWithMeta(value, meta);
+              })
+            })).then((result) => {
+              if (result instanceof RejectWithValue) {
+                throw result;
+              }
+              if (result instanceof FulfillWithMeta) {
+                return fulfilled(result.payload, requestId, arg, result.meta);
+              }
+              return fulfilled(result, requestId, arg);
+            })]);
+          } catch (err) {
+            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
+          } finally {
+            if (abortHandler) {
+              abortController.signal.removeEventListener("abort", abortHandler);
+            }
+          }
+          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
+          if (!skipDispatch) {
+            dispatch(finalAction);
+          }
+          return finalAction;
+        })();
+        return Object.assign(promise, {
+          abort,
+          requestId,
+          arg,
+          unwrap() {
+            return promise.then(unwrapResult);
+          }
+        });
+      };
+    }
+    return Object.assign(actionCreator, {
+      pending,
+      rejected,
+      fulfilled,
+      settled: isAnyOf(rejected, fulfilled),
+      typePrefix
+    });
+  }
+  createAsyncThunk2.withTypes = () => createAsyncThunk2;
+  return createAsyncThunk2;
+})();
+function unwrapResult(action) {
+  if (action.meta && action.meta.rejectedWithValue) {
+    throw action.payload;
+  }
+  if (action.error) {
+    throw action.error;
+  }
+  return action.payload;
+}
+function isThenable(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+var asyncThunkCreator = {
+  [asyncThunkSymbol]: createAsyncThunk
+};
+function getType(slice2, actionKey) {
+  return `${slice2}/${actionKey}`;
+}
+function buildCreateSlice({
+  creators
+} = {}) {
+  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
+  return function createSlice2(options) {
+    const {
+      name,
+      reducerPath = name
+    } = options;
+    if (!name) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "`name` is a required option for createSlice");
+    }
+    if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+      if (options.initialState === void 0) {
+        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+      }
+    }
+    const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
+    const reducerNames = Object.keys(reducers);
+    const context = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    };
+    const contextMethods = {
+      addCase(typeOrActionCreator, reducer2) {
+        const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+        if (!type) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : "`context.addCase` cannot be called with an empty action type");
+        }
+        if (type in context.sliceCaseReducersByType) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
+        }
+        context.sliceCaseReducersByType[type] = reducer2;
+        return contextMethods;
+      },
+      addMatcher(matcher, reducer2) {
+        context.sliceMatchers.push({
+          matcher,
+          reducer: reducer2
+        });
+        return contextMethods;
+      },
+      exposeAction(name2, actionCreator) {
+        context.actionCreators[name2] = actionCreator;
+        return contextMethods;
+      },
+      exposeCaseReducer(name2, reducer2) {
+        context.sliceCaseReducersByName[name2] = reducer2;
+        return contextMethods;
+      }
+    };
+    reducerNames.forEach((reducerName) => {
+      const reducerDefinition = reducers[reducerName];
+      const reducerDetails = {
+        reducerName,
+        type: getType(name, reducerName),
+        createNotation: typeof options.reducers === "function"
+      };
+      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
+        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
+      } else {
+        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
+      }
+    });
+    function buildReducer() {
+      if (process.env.NODE_ENV !== "production") {
+        if (typeof options.extraReducers === "object") {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
+        }
+      }
+      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
+      const finalCaseReducers = {
+        ...extraReducers,
+        ...context.sliceCaseReducersByType
+      };
+      return createReducer(options.initialState, (builder) => {
+        for (let key in finalCaseReducers) {
+          builder.addCase(key, finalCaseReducers[key]);
+        }
+        for (let sM of context.sliceMatchers) {
+          builder.addMatcher(sM.matcher, sM.reducer);
+        }
+        for (let m of actionMatchers) {
+          builder.addMatcher(m.matcher, m.reducer);
+        }
+        if (defaultCaseReducer) {
+          builder.addDefaultCase(defaultCaseReducer);
+        }
+      });
+    }
+    const selectSelf = (state) => state;
+    const injectedSelectorCache = /* @__PURE__ */ new Map();
+    const injectedStateCache = /* @__PURE__ */ new WeakMap();
+    let _reducer;
+    function reducer(state, action) {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer(state, action);
+    }
+    function getInitialState() {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer.getInitialState();
+    }
+    function makeSelectorProps(reducerPath2, injected = false) {
+      function selectSlice(state) {
+        let sliceState = state[reducerPath2];
+        if (typeof sliceState === "undefined") {
+          if (injected) {
+            sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
+          } else if (process.env.NODE_ENV !== "production") {
+            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "selectSlice returned undefined for an uninjected slice reducer");
+          }
+        }
+        return sliceState;
+      }
+      function getSelectors(selectState = selectSelf) {
+        const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
+        return getOrInsertComputed(selectorCache, selectState, () => {
+          const map = {};
+          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
+            map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
+          }
+          return map;
+        });
+      }
+      return {
+        reducerPath: reducerPath2,
+        getSelectors,
+        get selectors() {
+          return getSelectors(selectSlice);
+        },
+        selectSlice
+      };
+    }
+    const slice2 = {
+      name,
+      reducer,
+      actions: context.actionCreators,
+      caseReducers: context.sliceCaseReducersByName,
+      getInitialState,
+      ...makeSelectorProps(reducerPath),
+      injectInto(injectable, {
+        reducerPath: pathOpt,
+        ...config
+      } = {}) {
+        const newReducerPath = pathOpt ?? reducerPath;
+        injectable.inject({
+          reducerPath: newReducerPath,
+          reducer
+        }, config);
+        return {
+          ...slice2,
+          ...makeSelectorProps(newReducerPath, true)
+        };
+      }
+    };
+    return slice2;
+  };
+}
+function wrapSelector(selector, selectState, getInitialState, injected) {
+  function wrapper(rootState, ...args) {
+    let sliceState = selectState(rootState);
+    if (typeof sliceState === "undefined") {
+      if (injected) {
+        sliceState = getInitialState();
+      } else if (process.env.NODE_ENV !== "production") {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "selectState returned undefined for an uninjected slice reducer");
+      }
+    }
+    return selector(sliceState, ...args);
+  }
+  wrapper.unwrapped = selector;
+  return wrapper;
+}
+var createSlice = /* @__PURE__ */ buildCreateSlice();
+function buildReducerCreators() {
+  function asyncThunk(payloadCreator, config) {
+    return {
+      _reducerDefinitionType: "asyncThunk",
+      payloadCreator,
+      ...config
+    };
+  }
+  asyncThunk.withTypes = () => asyncThunk;
+  return {
+    reducer(caseReducer) {
+      return Object.assign({
+        // hack so the wrapping function has the same name as the original
+        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
+        [caseReducer.name](...args) {
+          return caseReducer(...args);
+        }
+      }[caseReducer.name], {
+        _reducerDefinitionType: "reducer"
+        /* reducer */
+      });
+    },
+    preparedReducer(prepare, reducer) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare",
+        prepare,
+        reducer
+      };
+    },
+    asyncThunk
+  };
+}
+function handleNormalReducerDefinition({
+  type,
+  reducerName,
+  createNotation
+}, maybeReducerWithPrepare, context) {
+  let caseReducer;
+  let prepareCallback;
+  if ("reducer" in maybeReducerWithPrepare) {
+    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    }
+    caseReducer = maybeReducerWithPrepare.reducer;
+    prepareCallback = maybeReducerWithPrepare.prepare;
+  } else {
+    caseReducer = maybeReducerWithPrepare;
+  }
+  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
+}
+function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "asyncThunk";
+}
+function isCaseReducerWithPrepareDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "reducerWithPrepare";
+}
+function handleThunkCaseReducerDefinition({
+  type,
+  reducerName
+}, reducerDefinition, context, cAT) {
+  if (!cAT) {
+    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  }
+  const {
+    payloadCreator,
+    fulfilled,
+    pending,
+    rejected,
+    settled,
+    options
+  } = reducerDefinition;
+  const thunk = cAT(type, payloadCreator, options);
+  context.exposeAction(reducerName, thunk);
+  if (fulfilled) {
+    context.addCase(thunk.fulfilled, fulfilled);
+  }
+  if (pending) {
+    context.addCase(thunk.pending, pending);
+  }
+  if (rejected) {
+    context.addCase(thunk.rejected, rejected);
+  }
+  if (settled) {
+    context.addMatcher(thunk.settled, settled);
+  }
+  context.exposeCaseReducer(reducerName, {
+    fulfilled: fulfilled || noop,
+    pending: pending || noop,
+    rejected: rejected || noop,
+    settled: settled || noop
+  });
+}
+function noop() {
+}
+var listener = "listener";
+var completed = "completed";
+var cancelled = "cancelled";
+var taskCancelled = `task-${cancelled}`;
+var taskCompleted = `task-${completed}`;
+var listenerCancelled = `${listener}-${cancelled}`;
+var listenerCompleted = `${listener}-${completed}`;
+var {
+  assign
+} = Object;
+var alm = "listenerMiddleware";
+var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
+  withTypes: () => addListener
+});
+var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
+var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
+  withTypes: () => removeListener
+});
+function formatProdErrorMessage(code) {
+  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+
+// src/ScrollViewSettingsContext.ts
+import { createContext as createContext2 } from "react";
+var defaultScrollViewSettings = {
+  backActionFixed: true,
+  footerFixed: false,
+  headerFixed: false,
+  snapBack: false
+};
+var ScrollViewSettingsContext = createContext2({
+  settings: defaultScrollViewSettings,
+  set: () => {
+  }
+});
+
+// src/redux/scrollViewSlice.ts
+var slice = createSlice({
+  name: "scrollView",
+  initialState: defaultScrollViewSettings,
+  reducers: {
+    initialize: (_state, action) => action.payload
+  }
+});
+var scrollViewActions = slice.actions;
+var scrollViewReducer = slice.reducer;
+
+// src/ScrollView.tsx
+import { memo as memo3, useCallback as useCallback5, useMemo as useMemo4, useRef as useRef5 } from "react";
+import { View as View4 } from "react-native";
+import { Gesture as Gesture3, GestureDetector as GestureDetector3 } from "react-native-gesture-handler";
+import Animated5 from "react-native-reanimated";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var ScrollViewInner = ({ children, footerFixed: footerFixedProp, gesture, headerFixed: headerFixedProp, horizontal, keyboardAware, onMomentumScrollEnd: externalMomentumScrollEnd, onRefresh, onScrollBeginDrag: externalScrollBeginDrag, onScrollEndDrag: externalScrollEndDrag, pullSearchHeight, refreshing, style, ...props }) => {
+  const scrollView = useRef5(null);
+  const isHorizontal = horizontal === true;
+  const { chipHidden, chipStyle, containerStyle, contentInset, contentOffset, footerFixed, headerFixed } = useScrollList({ footerFixed: footerFixedProp, headerFixed: headerFixedProp, isHorizontal, keyboardAware, pullSearchHeight, style });
+  const scrollTo = useCallback5((offset, animated) => {
+    scrollView.current?.scrollTo({ y: offset, animated });
+  }, []);
+  const { handleMomentumScrollEnd, handleScrollBeginDrag, handleScrollEndDrag } = useScrollInit({
+    onMomentumScrollEnd: externalMomentumScrollEnd,
+    onScrollBeginDrag: externalScrollBeginDrag,
+    onScrollEndDrag: externalScrollEndDrag,
+    pullSearchHeight,
+    scrollTo
+  });
+  const onPullSearchZoneEnter = useCallback5(() => {
+    if (!pullSearchHeight) return;
+    scrollTo(-contentInset.top + pullSearchHeight, true);
+  }, [contentInset.top, pullSearchHeight, scrollTo]);
+  const handleScroll = useScrollHandler({ chipHidden, footerFixed, headerFixed, isHorizontal, onPullSearchZoneEnter: pullSearchHeight ? onPullSearchZoneEnter : void 0 });
+  const handleScrollToTop = useCallback5(() => {
+    if (isHorizontal) {
+      scrollView.current?.scrollTo({ x: 0, animated: true });
+      return;
+    }
+    const offset = pullSearchHeight ? -contentInset.top + pullSearchHeight : -contentInset.top;
+    scrollView.current?.scrollTo({ y: offset, animated: true });
+  }, [isHorizontal, contentInset.top, pullSearchHeight]);
+  const refreshControl = useMemo4(() => onRefresh ? /* @__PURE__ */ jsx7(RefreshControl, { onRefresh, refreshing: refreshing ?? false }) : /* @__PURE__ */ jsx7(RefreshControl, {}), [onRefresh, refreshing]);
+  const nativeGesture = useMemo4(() => Gesture3.Native(), []);
+  const combinedGesture = useMemo4(() => gesture !== void 0 ? Gesture3.Simultaneous(gesture, nativeGesture) : nativeGesture, [gesture, nativeGesture]);
+  const detectorGesture = gesture !== void 0 ? combinedGesture : void 0;
+  const content = /* @__PURE__ */ jsxs4(View4, { style: containerStyle, children: [
+    /* @__PURE__ */ jsx7(
+      Animated5.ScrollView,
+      {
+        ...props,
+        contentInset,
+        contentOffset,
+        onMomentumScrollEnd: handleMomentumScrollEnd,
+        onScroll: handleScroll,
+        onScrollBeginDrag: handleScrollBeginDrag,
+        onScrollEndDrag: handleScrollEndDrag,
+        ref: (el) => {
+          if (props.ref) props.ref.current = el;
+          scrollView.current = el;
+        },
+        refreshControl,
+        scrollEventThrottle: 16,
+        children
+      }
+    ),
+    /* @__PURE__ */ jsx7(ScrollViewChip, { isHorizontal, onPress: handleScrollToTop, style: chipStyle })
+  ] });
+  return detectorGesture ? /* @__PURE__ */ jsx7(GestureDetector3, { gesture: detectorGesture, children: content }) : content;
+};
+var ScrollView = memo3(ScrollViewInner);
+
+// src/ScrollViewFooter.tsx
+import { BlurView as BlurView2 } from "@rific/auto-paper";
+import { useContext as useContext6, useEffect as useEffect4 } from "react";
+import { StyleSheet as StyleSheet5, View as View5 } from "react-native";
+import Animated6, { useAnimatedStyle as useAnimatedStyle4 } from "react-native-reanimated";
+import { useSafeAreaInsets as useSafeAreaInsets3 } from "react-native-safe-area-context";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+var ScrollViewFooter = ({ children, style }) => {
+  const { blur, footerHeight, footerFixed, footerOffset, headerHeightShared, pullSearchHeightShared, scrollPosition, setFooterHeight, snapBackFooterShared } = useContext6(ScrollViewContext);
+  const insets = useSafeAreaInsets3();
+  useEffect4(
+    () => () => {
+      setFooterHeight(0);
+    },
+    [setFooterHeight]
+  );
+  const handleLayout = ({
+    nativeEvent: {
+      layout: { height }
+    }
+  }) => {
+    if (footerHeight !== height) setFooterHeight(height);
+  };
+  const footerStyle = useAnimatedStyle4(() => {
+    if (footerFixed) return { transform: [{ translateY: 0 }] };
+    if (snapBackFooterShared.value) return { transform: [{ translateY: footerOffset.value }] };
+    const effective = scrollPosition.value + headerHeightShared.value - pullSearchHeightShared.value;
+    if (effective <= 0) return { transform: [{ translateY: 0 }] };
+    return { transform: [{ translateY: Math.min(effective, footerHeight) }] };
+  }, [footerHeight, footerFixed]);
+  return /* @__PURE__ */ jsxs5(Animated6.View, { onLayout: handleLayout, pointerEvents: "box-none", style: [styles6.footer, footerStyle], children: [
+    footerHeight > 0 && /* @__PURE__ */ jsx8(BlurView2, { blur, style: StyleSheet5.absoluteFill }),
+    /* @__PURE__ */ jsx8(View5, { style: [styles6.row, { paddingBottom: insets.bottom }, style], children })
+  ] });
+};
+var styles6 = StyleSheet5.create({
+  footer: { bottom: 0, left: 0, position: "absolute", right: 0, zIndex: 2 },
+  row: { alignItems: "center", flexDirection: "row", zIndex: 1 }
+});
+
+// src/ScrollViewHeader.tsx
+import { BlurView as BlurView3 } from "@rific/auto-paper";
+import { useContext as useContext7 } from "react";
+import { StyleSheet as StyleSheet6, Text, View as View6 } from "react-native";
+import { Appbar, ProgressBar, Surface, useTheme as useTheme3 } from "react-native-paper";
+import Animated7, { useAnimatedStyle as useAnimatedStyle5 } from "react-native-reanimated";
+import { useSafeAreaInsets as useSafeAreaInsets4 } from "react-native-safe-area-context";
+import { Fragment as Fragment3, jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+var ActionBg = ({ blur, style }) => blur ? /* @__PURE__ */ jsx9(View6, { style: [StyleSheet6.absoluteFill, styles7.actionBg, style], children: /* @__PURE__ */ jsx9(BlurView3, { blur: true, style: StyleSheet6.absoluteFill }) }) : /* @__PURE__ */ jsx9(View6, { style: [StyleSheet6.absoluteFill, styles7.actionBg, style], pointerEvents: "none", children: /* @__PURE__ */ jsx9(Surface, { style: StyleSheet6.absoluteFill, elevation: 1, children: null }) });
+var ScrollViewHeader = ({ actionSize = 48, actionStyle, backAction, backActionFixed, caption, centerContent, children, iconSize, style, title, topInset = true, trailingAction, trailingActionFixed = true }) => {
+  const { blur, headerHeight, headerFixed, headerOffset, progress, progressing, pullSearchHeightShared, scrollPosition, setHeaderHeight, snapBackHeaderShared } = useContext7(ScrollViewContext);
+  const { settings } = useContext7(ScrollViewSettingsContext);
+  const effectiveBackActionFixed = backActionFixed ?? settings.backActionFixed;
+  const insets = useSafeAreaInsets4();
+  const theme = useTheme3();
+  const top = topInset ? insets.top : 0;
+  const handleLayout = ({
+    nativeEvent: {
+      layout: { height }
+    }
+  }) => {
+    if (headerHeight !== height) setHeaderHeight(height);
+  };
+  const translateStyle = useAnimatedStyle5(() => {
+    if (headerFixed) return { transform: [{ translateY: 0 }] };
+    if (snapBackHeaderShared.value) return { transform: [{ translateY: headerOffset.value }] };
+    const effective = scrollPosition.value + headerHeight - pullSearchHeightShared.value;
+    if (effective <= 0) return { transform: [{ translateY: 0 }] };
+    return { transform: [{ translateY: -effective }] };
+  }, [headerFixed, headerHeight]);
+  const blurStyle = useAnimatedStyle5(() => {
+    if (!headerHeight) return { height: 0 };
+    if (headerFixed) return { height: headerHeight };
+    const translateY = snapBackHeaderShared.value ? headerOffset.value : -Math.max(0, scrollPosition.value + headerHeight - pullSearchHeightShared.value);
+    return { height: Math.max(headerHeight + translateY, top) };
+  }, [headerFixed, headerHeight, top]);
+  const progressStyle = useAnimatedStyle5(() => {
+    if (headerFixed) return { top: headerHeight };
+    const slide = snapBackHeaderShared.value ? -headerOffset.value : Math.max(0, scrollPosition.value + headerHeight - pullSearchHeightShared.value);
+    return { top: Math.max(headerHeight - slide, top) };
+  }, [headerFixed, headerHeight, top]);
+  const actionMargin = 4;
+  const contentMinHeight = actionSize + 2 * actionMargin;
+  const actionTop = top + actionMargin;
+  const buttonStyle = { borderRadius: actionSize, height: actionSize, margin: 0, width: actionSize };
+  const actionShadow = { borderRadius: actionSize / 2, elevation: 2, shadowColor: "#000", shadowOffset: { width: 0, height: 1 }, shadowOpacity: 0.15, shadowRadius: 2 };
+  const leadingStyle = { alignItems: "center", height: actionSize, justifyContent: "center", left: actionMargin, position: "absolute", top: actionTop, width: actionSize, zIndex: 3, ...actionShadow };
+  const trailingStyle = { alignItems: "center", height: actionSize, justifyContent: "center", position: "absolute", right: actionMargin, top: actionTop, width: actionSize, zIndex: 3, ...actionShadow };
+  return /* @__PURE__ */ jsxs6(Fragment3, { children: [
+    /* @__PURE__ */ jsx9(Animated7.View, { pointerEvents: "none", style: [styles7.blur, blurStyle], children: headerHeight > 0 && /* @__PURE__ */ jsx9(BlurView3, { blur, style: [styles7.blurInner, { height: headerHeight }] }) }),
+    /* @__PURE__ */ jsxs6(Animated7.View, { onLayout: handleLayout, pointerEvents: "box-none", style: [headerHeight === 0 ? styles7.headerInit : styles7.header, translateStyle], children: [
+      /* @__PURE__ */ jsx9(View6, { style: [{ paddingTop: top }, style], children: /* @__PURE__ */ jsxs6(View6, { style: [styles7.content, { minHeight: contentMinHeight }], children: [
+        /* @__PURE__ */ jsx9(View6, { style: styles7.side }),
+        /* @__PURE__ */ jsx9(View6, { style: styles7.spacer }),
+        /* @__PURE__ */ jsx9(View6, { style: styles7.side, children }),
+        (centerContent || title || caption) && /* @__PURE__ */ jsx9(View6, { style: [StyleSheet6.absoluteFill, styles7.titleContainer], pointerEvents: centerContent ? "box-none" : "none", children: centerContent ?? /* @__PURE__ */ jsxs6(Fragment3, { children: [
+          title && /* @__PURE__ */ jsx9(Text, { numberOfLines: 1, style: [styles7.title, { color: theme.colors.onSurface }], children: title }),
+          caption && /* @__PURE__ */ jsx9(Text, { numberOfLines: 1, style: [styles7.caption, { color: theme.colors.onSurfaceVariant }], children: caption })
+        ] }) })
+      ] }) }),
+      !blur && /* @__PURE__ */ jsx9(View6, { style: [styles7.divider, { backgroundColor: theme.colors.outlineVariant }] })
+    ] }),
+    /* @__PURE__ */ jsx9(Animated7.View, { pointerEvents: "none", style: [styles7.progress, progressStyle], children: /* @__PURE__ */ jsx9(ProgressBar, { indeterminate: progress === null, visible: progressing, progress: progress ?? void 0 }) }),
+    backAction && (effectiveBackActionFixed ? /* @__PURE__ */ jsxs6(Animated7.View, { style: leadingStyle, children: [
+      /* @__PURE__ */ jsx9(ActionBg, { blur, style: actionStyle }),
+      /* @__PURE__ */ jsx9(Appbar.BackAction, { onPress: backAction, size: iconSize ?? actionSize / 2, style: buttonStyle })
+    ] }) : /* @__PURE__ */ jsxs6(Animated7.View, { style: [leadingStyle, translateStyle], children: [
+      /* @__PURE__ */ jsx9(ActionBg, { blur, style: actionStyle }),
+      /* @__PURE__ */ jsx9(Appbar.BackAction, { onPress: backAction, size: iconSize ?? actionSize / 2, style: buttonStyle })
+    ] })),
+    trailingAction && (trailingActionFixed ? /* @__PURE__ */ jsxs6(View6, { style: trailingStyle, children: [
+      /* @__PURE__ */ jsx9(ActionBg, { blur, style: actionStyle }),
+      trailingAction
+    ] }) : /* @__PURE__ */ jsxs6(Animated7.View, { style: [trailingStyle, translateStyle], children: [
+      /* @__PURE__ */ jsx9(ActionBg, { blur, style: actionStyle }),
+      trailingAction
+    ] }))
+  ] });
+};
+var styles7 = StyleSheet6.create({
+  actionBg: { borderRadius: 100, overflow: "hidden" },
+  divider: { bottom: 0, height: StyleSheet6.hairlineWidth, left: 0, position: "absolute", right: 0 },
+  caption: { fontSize: 12, fontWeight: "400", textAlign: "center" },
+  content: { alignItems: "center", flexDirection: "row", width: "100%" },
+  blur: { left: 0, overflow: "hidden", position: "absolute", right: 0, top: 0, zIndex: 2 },
+  blurInner: { left: 0, position: "absolute", right: 0, top: 0 },
+  header: { left: 0, overflow: "hidden", position: "absolute", right: 0, top: 0, zIndex: 2 },
+  headerInit: { left: 0, overflow: "hidden", right: 0, zIndex: 2 },
+  progress: { left: 0, position: "absolute", right: 0, zIndex: 3 },
+  side: { alignItems: "center", flexDirection: "row" },
+  spacer: { flex: 1 },
+  title: { fontSize: 20, fontWeight: "400", textAlign: "center" },
+  titleContainer: { alignItems: "center", justifyContent: "center" }
+});
+
+// src/ScrollViewProvider.tsx
+import { useBlur } from "@rific/auto-paper";
+import { useCallback as useCallback6, useContext as useContext8, useEffect as useEffect5, useMemo as useMemo5, useState as useState4 } from "react";
+import { Dimensions as Dimensions3 } from "react-native";
+import { useSharedValue as useSharedValue3 } from "react-native-reanimated";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var ScrollViewProvider = ({ blur, children, fixed = false, footerFixed, headerFixed, snapBack, snapBackFooter, snapBackHeader, tabBarHeight = 60 }) => {
+  const { settings } = useContext8(ScrollViewSettingsContext);
+  const effectiveBlur = useBlur(blur);
+  const effectiveSnapBack = snapBack ?? settings.snapBack;
+  const effectiveSnapBackHeader = snapBackHeader ?? settings.snapBackHeader;
+  const effectiveSnapBackFooter = snapBackFooter ?? settings.snapBackFooter;
+  const [headerHeight, setHeaderHeightState] = useState4(0);
+  const [footerHeight, setFooterHeightState] = useState4(0);
+  const [progress, setProgress] = useState4(null);
+  const [progressing, setProgressing] = useState4(false);
+  const scrollPosition = useSharedValue3(0);
+  const headerHeightShared = useSharedValue3(0);
+  const footerHeightShared = useSharedValue3(0);
+  const headerOffset = useSharedValue3(0);
+  const footerOffset = useSharedValue3(0);
+  const pullSearchHeightShared = useSharedValue3(0);
+  const snapBackHeaderShared = useSharedValue3(false);
+  const snapBackFooterShared = useSharedValue3(false);
+  useEffect5(() => {
+    snapBackHeaderShared.value = effectiveSnapBackHeader ?? effectiveSnapBack;
+    snapBackFooterShared.value = effectiveSnapBackFooter ?? effectiveSnapBack;
+  }, [effectiveSnapBack, effectiveSnapBackFooter, effectiveSnapBackHeader, snapBackFooterShared, snapBackHeaderShared]);
+  const setHeaderHeight = useCallback6(
+    (h) => {
+      setHeaderHeightState(h);
+      headerHeightShared.value = h;
+    },
+    [headerHeightShared]
+  );
+  const setFooterHeight = useCallback6(
+    (h) => {
+      setFooterHeightState(h);
+      footerHeightShared.value = h;
+    },
+    [footerHeightShared]
+  );
+  const scrollHeight = useMemo5(() => Dimensions3.get("window").height - headerHeight - footerHeight, [headerHeight, footerHeight]);
+  const effectiveHeaderFixed = fixed || (headerFixed ?? settings.headerFixed);
+  const effectiveFooterFixed = fixed || (footerFixed ?? settings.footerFixed);
+  const value = useMemo5(() => ({ blur: effectiveBlur, footerHeight, footerHeightShared, footerFixed: effectiveFooterFixed, footerOffset, headerHeight, headerHeightShared, headerFixed: effectiveHeaderFixed, headerOffset, progress, pullSearchHeightShared, progressing, scrollHeight, scrollPosition, setFooterHeight, setHeaderHeight, setProgress, setProgressing, snapBackFooterShared, snapBackHeaderShared, tabBarHeight }), [effectiveBlur, effectiveFooterFixed, effectiveHeaderFixed, footerHeight, footerHeightShared, footerOffset, headerHeight, headerHeightShared, headerOffset, progress, pullSearchHeightShared, progressing, scrollHeight, scrollPosition, setFooterHeight, setHeaderHeight, snapBackFooterShared, snapBackHeaderShared, tabBarHeight]);
+  return /* @__PURE__ */ jsx10(ScrollViewContext.Provider, { value, children });
+};
+
+// src/ScrollViewSettingsProvider.tsx
+import { useCallback as useCallback7, useMemo as useMemo6, useState as useState5 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var ScrollViewSettingsProvider = ({ children, onChange, value }) => {
+  const [settings, setSettings] = useState5(() => ({
+    ...defaultScrollViewSettings,
+    ...value
+  }));
+  const set2 = useCallback7(
+    (patch) => {
+      setSettings((prev) => {
+        const next = { ...prev, ...patch };
+        onChange?.(next);
+        return next;
+      });
+    },
+    [onChange]
+  );
+  const ctx = useMemo6(() => ({ settings, set: set2 }), [settings, set2]);
+  return /* @__PURE__ */ jsx11(ScrollViewSettingsContext.Provider, { value: ctx, children });
+};
+
+// src/SectionList.tsx
+import { memo as memo4, useCallback as useCallback9, useEffect as useEffect6, useLayoutEffect as useLayoutEffect3, useMemo as useMemo7, useRef as useRef7 } from "react";
+import { Dimensions as Dimensions4, SectionList as RNSectionList, View as View7 } from "react-native";
+import { Gesture as Gesture4, GestureDetector as GestureDetector4 } from "react-native-gesture-handler";
+import Animated8, { createAnimatedComponent } from "react-native-reanimated";
+
+// src/internal/useStickyHeaders.ts
+import { useCallback as useCallback8, useContext as useContext9, useLayoutEffect as useLayoutEffect2, useRef as useRef6, useState as useState6 } from "react";
+import { runOnJS as runOnJS4, useAnimatedReaction as useAnimatedReaction2, useAnimatedStyle as useAnimatedStyle6, useSharedValue as useSharedValue4 } from "react-native-reanimated";
+import { useSafeAreaInsets as useSafeAreaInsets5 } from "react-native-safe-area-context";
+function useStickyHeaders(headerFixed, enabled) {
+  const { headerHeightShared, headerOffset, pullSearchHeightShared, scrollPosition, snapBackHeaderShared } = useContext9(ScrollViewContext);
+  const insetsTop = useSafeAreaInsets5().top;
+  const sectionYPositions = useSharedValue4([]);
+  const sectionHeights = useSharedValue4([]);
+  const [activeIndex, setActiveIndex] = useState6(-1);
+  const contentIndexShared = useSharedValue4(-1);
+  useLayoutEffect2(() => {
+    contentIndexShared.value = activeIndex;
+  }, [activeIndex, contentIndexShared]);
+  const positionsCache = useRef6([]);
+  const heightsCache = useRef6([]);
+  useAnimatedReaction2(
+    () => {
+      if (!enabled) return -1;
+      const positions = sectionYPositions.value;
+      if (positions.length === 0) return -1;
+      const hHeight = headerHeightShared.value;
+      const scrollPos = scrollPosition.value;
+      let stickyTop;
+      if (headerFixed) {
+        stickyTop = hHeight;
+      } else if (snapBackHeaderShared.value) {
+        stickyTop = Math.max(insetsTop, hHeight + headerOffset.value);
+      } else {
+        const effective = scrollPos + hHeight - pullSearchHeightShared.value;
+        stickyTop = effective <= 0 ? hHeight : Math.max(insetsTop, hHeight - effective);
+      }
+      const threshold = scrollPos + stickyTop;
+      let active = -1;
+      for (let i = 0; i < positions.length; i++) {
+        if (positions[i] >= 0 && positions[i] < threshold) active = i;
+        else if (positions[i] >= 0) break;
+      }
+      return active;
+    },
+    (curr, prev) => {
+      if (curr !== prev) runOnJS4(setActiveIndex)(curr);
+    },
+    [enabled, headerFixed, insetsTop]
+  );
+  const clipStyle = useAnimatedStyle6(() => {
+    const hHeight = headerHeightShared.value;
+    const scrollPos = scrollPosition.value;
+    let stickyTop;
+    if (!enabled || headerFixed) {
+      stickyTop = hHeight;
+    } else if (snapBackHeaderShared.value) {
+      stickyTop = Math.max(insetsTop, hHeight + headerOffset.value);
+    } else {
+      const effective = scrollPos + hHeight - pullSearchHeightShared.value;
+      stickyTop = effective <= 0 ? hHeight : Math.max(insetsTop, hHeight - effective);
+    }
+    return { top: stickyTop };
+  }, [enabled, headerFixed, insetsTop]);
+  const overlayStyle = useAnimatedStyle6(() => {
+    const hidden = { opacity: 0, top: 0, transform: [{ translateY: 0 }] };
+    if (!enabled) return hidden;
+    const index = contentIndexShared.value;
+    const positions = sectionYPositions.value;
+    if (index < 0 || index >= positions.length) return hidden;
+    const hHeight = headerHeightShared.value;
+    const scrollPos = scrollPosition.value;
+    let stickyTop;
+    if (headerFixed) {
+      stickyTop = hHeight;
+    } else if (snapBackHeaderShared.value) {
+      stickyTop = Math.max(insetsTop, hHeight + headerOffset.value);
+    } else {
+      const effective = scrollPos + hHeight - pullSearchHeightShared.value;
+      stickyTop = effective <= 0 ? hHeight : Math.max(insetsTop, hHeight - effective);
+    }
+    if (positions[index] - scrollPos >= stickyTop) return hidden;
+    const currentHeight = Math.max(0, sectionHeights.value[index] ?? 0);
+    const nextIndex = index + 1;
+    let translateY = 0;
+    if (currentHeight > 0 && nextIndex < positions.length && positions[nextIndex] >= 0) {
+      const nextScreenY = positions[nextIndex] - scrollPos;
+      const pushThreshold = stickyTop + currentHeight;
+      if (nextScreenY < pushThreshold) translateY = nextScreenY - pushThreshold;
+    }
+    return { opacity: 1, top: 0, transform: [{ translateY }] };
+  }, [enabled, headerFixed, insetsTop]);
+  const measureHeader = useCallback8(
+    (index, pageY, height) => {
+      const contentY = pageY + scrollPosition.value;
+      positionsCache.current[index] = contentY;
+      sectionYPositions.value = positionsCache.current.slice();
+      heightsCache.current[index] = height;
+      sectionHeights.value = heightsCache.current.slice();
+    },
+    [scrollPosition, sectionHeights, sectionYPositions]
+  );
+  const resetPositions = useCallback8(
+    (count) => {
+      positionsCache.current = Array.from({ length: count }, () => -1);
+      sectionYPositions.value = positionsCache.current.slice();
+      heightsCache.current = Array.from({ length: count }, () => -1);
+      sectionHeights.value = heightsCache.current.slice();
+    },
+    [sectionHeights, sectionYPositions]
+  );
+  return { activeIndex, clipStyle, measureHeader, overlayStyle, resetPositions };
+}
+
+// src/SectionList.tsx
+import { Fragment as Fragment4, jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+var AnimatedSectionList = createAnimatedComponent(RNSectionList);
+var SectionListInner = ({ contentContainerStyle: externalContentContainerStyle, initialNumToRender = 20, maxToRenderPerBatch = 50, renderFilters, footerFixed: footerFixedProp, gesture, headerFixed: headerFixedProp, keyboardAware, ListHeaderComponent: externalListHeaderComponent, onMomentumScrollEnd: externalMomentumScrollEnd, onRefresh, onContentSizeChange, onScrollBeginDrag: externalScrollBeginDrag, onScrollEndDrag: externalScrollEndDrag, pullSearchHeight, refreshing, removeClippedSubviews = false, sections, showsVerticalScrollIndicator, style, ref: externalRef, windowSize = 100, ...props }) => {
+  const scrollView = useRef7(null);
+  const { stickySectionHeadersEnabled = true, renderSectionHeader, ...passThroughProps } = props;
+  const { chipHidden, chipStyle, containerStyle, contentInset, contentOffset, footerFixed, headerFixed, headerHeight } = useScrollList({ footerFixed: footerFixedProp, headerFixed: headerFixedProp, keyboardAware, pullSearchHeight, style });
+  const usesCustomSticky = stickySectionHeadersEnabled && renderSectionHeader != null;
+  const { activeIndex, clipStyle, measureHeader, overlayStyle, resetPositions } = useStickyHeaders(headerFixed, usesCustomSticky);
+  useLayoutEffect3(() => {
+    if (usesCustomSticky) resetPositions(sections.length);
+  }, [sections, usesCustomSticky, resetPositions, headerHeight]);
+  const sectionViewRefs = useRef7(/* @__PURE__ */ new Map());
+  const wrappedRenderSectionHeader = useMemo7(() => {
+    if (!usesCustomSticky) return renderSectionHeader ?? void 0;
+    return (info) => {
+      const idx = sections.findIndex((s) => s === info.section);
+      return /* @__PURE__ */ jsx12(
+        View7,
+        {
+          ref: (el) => {
+            sectionViewRefs.current.set(idx, el);
+          },
+          onLayout: () => {
+            const el = sectionViewRefs.current.get(idx);
+            el?.measure((_x, _y, _w, h, _px, pageY) => {
+              if (idx >= 0 && sectionViewRefs.current.get(idx) === el) measureHeader(idx, pageY, h);
+            });
+          },
+          children: renderSectionHeader(info)
+        }
+      );
+    };
+  }, [usesCustomSticky, renderSectionHeader, sections, measureHeader]);
+  const scrollTo = useCallback9((offset, animated) => {
+    scrollView.current?.getScrollResponder()?.scrollTo({ y: offset, animated });
+  }, []);
+  const {
+    activeListHeader: pullSearchHeader,
+    handleMomentumScrollEnd,
+    handleScrollBeginDrag,
+    handleScrollEndDrag,
+    hiddenHeader,
+    pullSearchMinHeight
+  } = useScrollInit({
+    listHeaderComponent: externalListHeaderComponent,
+    onMomentumScrollEnd: externalMomentumScrollEnd,
+    onScrollBeginDrag: externalScrollBeginDrag,
+    onScrollEndDrag: externalScrollEndDrag,
+    pullSearchHeight,
+    scrollTo
+  });
+  const activeListHeader = useMemo7(() => {
+    if (!renderFilters) return pullSearchHeader;
+    const Inner = pullSearchHeader;
+    return () => /* @__PURE__ */ jsxs7(Fragment4, { children: [
+      Inner ? typeof Inner === "function" ? /* @__PURE__ */ jsx12(Inner, {}) : Inner : null,
+      renderFilters
+    ] });
+  }, [pullSearchHeader, renderFilters]);
+  const pullSearchSettled = useRef7(false);
+  useEffect6(() => {
+    if (!usesCustomSticky || activeListHeader == null || pullSearchSettled.current) return;
+    pullSearchSettled.current = true;
+    const handle = requestAnimationFrame(() => {
+      sectionViewRefs.current.forEach((el, idx) => {
+        el?.measure((_x, _y, _w, h, _px, pageY) => {
+          if (sectionViewRefs.current.get(idx) === el) measureHeader(idx, pageY, h);
+        });
+      });
+    });
+    return () => cancelAnimationFrame(handle);
+  }, [activeListHeader, usesCustomSticky, measureHeader]);
+  const contentContainerStyle = useMemo7(() => [{ minHeight: Dimensions4.get("window").height - contentInset.top - contentInset.bottom + pullSearchMinHeight }, externalContentContainerStyle], [contentInset.bottom, contentInset.top, externalContentContainerStyle, pullSearchMinHeight]);
+  const onPullSearchZoneEnter = useCallback9(() => {
+    if (!pullSearchHeight) return;
+    scrollTo(-contentInset.top + pullSearchHeight, true);
+  }, [contentInset.top, pullSearchHeight, scrollTo]);
+  const handleScroll = useScrollHandler({ chipHidden, footerFixed, headerFixed, onPullSearchZoneEnter: pullSearchHeight ? onPullSearchZoneEnter : void 0 });
+  const handleScrollToTop = useCallback9(() => {
+    const offset = pullSearchHeight ? -contentInset.top + pullSearchHeight : -contentInset.top;
+    scrollView.current?.getScrollResponder()?.scrollTo({ y: offset, animated: true });
+  }, [contentInset.top, pullSearchHeight]);
+  const handleContentSizeChange = useCallback9(
+    (w, h) => {
+      if (onContentSizeChange) onContentSizeChange(w, h);
+    },
+    [onContentSizeChange]
+  );
+  const refreshControl = useMemo7(() => onRefresh ? /* @__PURE__ */ jsx12(RefreshControl, { onRefresh, refreshing: refreshing ?? false }) : /* @__PURE__ */ jsx12(RefreshControl, {}), [onRefresh, refreshing]);
+  const nativeGesture = useMemo7(() => Gesture4.Native(), []);
+  const combinedGesture = useMemo7(() => gesture !== void 0 ? Gesture4.Simultaneous(gesture, nativeGesture) : nativeGesture, [gesture, nativeGesture]);
+  const detectorGesture = gesture !== void 0 ? combinedGesture : void 0;
+  const content = /* @__PURE__ */ jsxs7(View7, { style: containerStyle, children: [
+    /* @__PURE__ */ jsx12(
+      AnimatedSectionList,
+      {
+        ...passThroughProps,
+        contentContainerStyle,
+        contentInset,
+        contentOffset,
+        initialNumToRender,
+        ListHeaderComponent: activeListHeader,
+        maxToRenderPerBatch,
+        onContentSizeChange: handleContentSizeChange,
+        onMomentumScrollEnd: handleMomentumScrollEnd,
+        onScroll: handleScroll,
+        onScrollBeginDrag: handleScrollBeginDrag,
+        onScrollEndDrag: handleScrollEndDrag,
+        ref: (el) => {
+          if (externalRef) externalRef.current = el;
+          scrollView.current = el;
+        },
+        refreshControl,
+        removeClippedSubviews,
+        renderSectionHeader: wrappedRenderSectionHeader,
+        scrollEventThrottle: 16,
+        sections,
+        showsVerticalScrollIndicator: showsVerticalScrollIndicator ?? true,
+        stickySectionHeadersEnabled: false,
+        windowSize
+      },
+      headerHeight > 0 ? 1 : 0
+    ),
+    hiddenHeader && /* @__PURE__ */ jsx12(View7, { pointerEvents: "none", style: styles8.measureContainer, children: hiddenHeader }),
+    /* @__PURE__ */ jsx12(ScrollViewChip, { onPress: handleScrollToTop, style: chipStyle }),
+    usesCustomSticky && /* @__PURE__ */ jsx12(Animated8.View, { pointerEvents: "none", style: [styles8.stickyClip, clipStyle], children: activeIndex >= 0 && activeIndex < sections.length && /* @__PURE__ */ jsx12(Animated8.View, { style: [styles8.stickyOverlay, overlayStyle], children: renderSectionHeader({ section: sections[activeIndex] }) }) })
+  ] });
+  return detectorGesture ? /* @__PURE__ */ jsx12(GestureDetector4, { gesture: detectorGesture, children: content }) : content;
+};
+var styles8 = {
+  measureContainer: { left: 0, opacity: 0, position: "absolute", right: 0, top: -9999 },
+  stickyClip: { bottom: 0, left: 0, overflow: "hidden", position: "absolute", right: 0, zIndex: 2 },
+  stickyOverlay: { left: 0, position: "absolute", right: 0 }
+};
+var SectionList = memo4(SectionListInner);
+
+// src/useScrollView.ts
+import { useContext as useContext10 } from "react";
+var useScrollView = () => {
+  const { progress, progressing, scrollHeight, scrollPosition, setProgress, setProgressing } = useContext10(ScrollViewContext);
+  return { progress, progressing, scrollHeight, scrollPosition, setProgress, setProgressing };
+};
+
+// src/useScrollViewSettings.ts
+import { useContext as useContext11 } from "react";
+var useScrollViewSettings = () => useContext11(ScrollViewSettingsContext);
+export {
+  CustomList,
+  FlatList,
+  PullSearch,
+  ScrollView,
+  ScrollViewContext,
+  ScrollViewFooter,
+  ScrollViewHeader,
+  ScrollViewProvider,
+  ScrollViewSettingsContext,
+  ScrollViewSettingsProvider,
+  SectionList,
+  defaultScrollViewSettings,
+  scrollViewActions,
+  scrollViewReducer,
+  useKeyboardInset,
+  useScrollView,
+  useScrollViewSettings
+};