yeet

modules/main_tabs_v2/native/panels/ChannelScreenAnimatedFrame.tsx

@@ -0,0 +1,72 @@
+// Metro module 14923 (f14924).
+import { View } from "react-native";
+import * as _MainTabsV2Constants from "../shared_components/MainTabsV2Constants";
+import { ThemeTypes } from "../../../../Constants";
+import { createStyles } from "../../../../design/components/Styles/native/createStyles";
+import Module712 from "../../../../_bundle/Module712";
+import useTheme from "../../../../hooks/useTheme";
+import { useMobileVisualRefreshConfig } from "../../../themes/experiments/MobileVisualRefreshExperiment";
+import ReanimatedRexport, { useAnimatedStyle } from "../../../reanimated/ReanimatedRexport";
+import * as _timing from "../../../../design/animation/reanimated/timing/timing";
+import * as _native from "../../../../design/void/native";
+import * as _PanelsConfig from "../../../panels/native/PanelsConfig";
+import { useGradientTop } from "../../../client_themes/native/ClientThemesOverrides";
+import { SafeAreaPaddingView } from "../../../../components_native/common/SafeAreaView";
+const { HEADER_CORNER_RADIUS, MIDNIGHT_BORDER_WIDTH } = _MainTabsV2Constants;
+const useStyles = createStyles({
+  container: {
+    position: "absolute",
+    zIndex: 1,
+    top: 0,
+    width: "100%",
+    backgroundColor: Module712.colors.BACKGROUND_BASE_LOW
+  },
+  midnightContainer: {
+    borderLeftColor: Module712.colors.APP_FRAME_BORDER,
+    borderLeftWidth: MIDNIGHT_BORDER_WIDTH
+  },
+  splitDivider: {
+    borderLeftColor: Module712.colors.APP_FRAME_BORDER,
+    borderLeftWidth: Module712.modules.mobile.CHANNEL_DRAWER_DIVIDER_WIDTH
+  },
+  additionalHeight: {
+    height: HEADER_CORNER_RADIUS
+  }
+});
+const __initData = {
+  code: "function ChannelScreenAnimatedFrameTsx1(){const{translateX,maxWidth,isChatLockedOpen,withTiming,STANDARD_EASING,SIDE_PANEL_CLOSE_DURATION_MS,SIDE_PANEL_OPEN_DURATION_MS}=this.__closure;const hide=translateX.get()===maxWidth||isChatLockedOpen;return{opacity:withTiming(hide?0:1,{easing:STANDARD_EASING,duration:hide?SIDE_PANEL_CLOSE_DURATION_MS:SIDE_PANEL_OPEN_DURATION_MS})};}"
+};
+export default function ChannelScreenAnimatedFrame(props) {
+  const { translateX, maxWidth, isChatLockedOpen } = props;
+  const styles = useStyles();
+  const theme = useTheme();
+  const MIDNIGHT = ThemeTypes.MIDNIGHT;
+  const chatInputFloating = useMobileVisualRefreshConfig({
+    location: "ChannelScreenAnimatedFrame"
+  }).chatInputFloating;
+  const E = function E() {
+    const r7 = translateX.get() === maxWidth || isChatLockedOpen;
+    return {
+      opacity: _timing.withTiming(r7 ? 0 : 1, {
+        easing: _native.STANDARD_EASING,
+        duration: r7 ? _PanelsConfig.SIDE_PANEL_CLOSE_DURATION_MS : _PanelsConfig.SIDE_PANEL_OPEN_DURATION_MS
+      })
+    };
+  };
+  E.__closure = {
+    translateX,
+    maxWidth,
+    isChatLockedOpen,
+    withTiming: _timing.withTiming,
+    STANDARD_EASING: _native.STANDARD_EASING,
+    SIDE_PANEL_CLOSE_DURATION_MS: _PanelsConfig.SIDE_PANEL_CLOSE_DURATION_MS,
+    SIDE_PANEL_OPEN_DURATION_MS: _PanelsConfig.SIDE_PANEL_OPEN_DURATION_MS
+  };
+  E.__workletHash = 9063010717249;
+  E.__initData = __initData;
+  const animatedStyle = useAnimatedStyle(E);
+  return <ReanimatedRexport.View pointerEvents="none" style={[styles.container, styles.splitDivider, theme === MIDNIGHT ? chatInputFloating ? void 0 : styles.midnightContainer : void 0, useGradientTop(), animatedStyle]}>
+    <SafeAreaPaddingView top />
+    <View style={styles.additionalHeight} />
+  </ReanimatedRexport.View>;
+};

modules/main_tabs_v2/native/panels/MainTabsChannelScreenStack.tsx

@@ -0,0 +1,461 @@
+// Metro module 15399 (f15400).
+import { memo, useEffect, useRef, useCallback, useContext, useState, useMemo } from "react";
+import { NativeModules, StyleSheet, View } from "react-native";
+import { MIDNIGHT_BORDER_WIDTH } from "../shared_components/MainTabsV2Constants";
+import { AnalyticsObjectTypes, AnalyticsObjects, AnalyticsSections } from "../../../../Constants";
+import { ThemeTypes } from "../../../../_bundle/Module505";
+import { createStyles } from "../../../../design/components/Styles/native/createStyles";
+import HideCoveredChannelsExperiment from "../HideCoveredChannelsExperiment";
+import * as _ReanimatedRexport from "../../../reanimated/ReanimatedRexport";
+import { useAnimatedReaction, useDerivedValue, useSharedValue } from "../../../reanimated/ReanimatedRexport";
+import { useUnmountEffect } from "../../../../hooks/useMountEffect";
+import useTheme from "../../../../hooks/useTheme";
+import { useMobileVisualRefreshConfig } from "../../../themes/experiments/MobileVisualRefreshExperiment";
+import { useOrientation, OrientationType } from "../../../device/native/DeviceOrientation";
+import { useMainTabsChannelScreenStyles } from "./useMainTabsChannelScreenStyles";
+import { TransitionStates, TransitionGroup } from "../../../../design/components/TransitionGroup/TransitionGroup";
+import REAWorkaroundView from "../../../reanimated/native/REAWorkaroundView";
+import { Freeze } from "../../../../_bundle/Suspender";
+import StandaloneChannelScreen from "../channel/StandaloneChannelScreen";
+import { useNavigation } from "../../../../_bundle/Module1481";
+import useMainTabsPanelsGesture from "./useMainTabsPanelsGesture";
+import { dismissKeyboard } from "../../../../utils/native/ChatInputUtils";
+import MainTabsNavigatorPanelContext, { MainTabsChannelScreenStackContext } from "./MainTabsNavigatorPanelContext";
+import { GestureDetector } from "../../../../_bundle/Module5273";
+import useColorThemeBackground from "../../../client_themes/native/useColorThemeBackground";
+import { ChannelScreenType } from "./useChannelScreensFromNavigation";
+import { getChatLayout } from "../../../chat/native/useChatLayout";
+import Dispatcher from "../../../../Dispatcher";
+import { freezeScreenIndex } from "../../../channel/native/ScreenIndexFrozen";
+import { ThemeContextProvider } from "../../../../_bundle/Module3901";
+function $mk96369($env) {
+  return () => $env[2].get() > 0;
+}
+function $mk96370($env) {
+  return function l(a0, a1) {
+    if (a0 !== a1) {
+      const r4 = $env;
+      const r3 = r4[1];
+      const r7 = r3.get();
+      const r8 = r4[0];
+      if (a0) {
+        if (r7 >= r8) {
+          r3.set(r8 - 1);
+        }
+      } else if (r7 < r8) {
+        r3.set(r8);
+      }
+    }
+  };
+}
+function $mk96371($env) {
+  return () => {
+    const r4 = $env;
+    const r3 = r4[1];
+    const r5 = r3.get();
+    const r6 = r4[0];
+    if (r5 >= r6) {
+      r3.set(r6 - 1);
+    }
+  };
+}
+function $mk96372($env) {
+  return function() {
+    const r2 = $env;
+    return r2[3] && r2[1].get() > r2[0];
+  };
+}
+let useStyles, __initData, __initData2, __initData3, FirstChannelScreen, __initData4, __initData5, ChannelScreen, __initData6, __initData7;
+const getKey = function getKey(a0) {
+  return String(a0.Index);
+};
+useStyles = createStyles({
+  midnightContainerStyles: {
+    marginTop: -MIDNIGHT_BORDER_WIDTH,
+    marginLeft: -MIDNIGHT_BORDER_WIDTH
+  }
+});
+__initData = {
+  code: "function MainTabsChannelScreenStackTsx1(){const{translateX}=this.__closure;return translateX.get()>0;}"
+};
+__initData2 = {
+  code: "function MainTabsChannelScreenStackTsx2(isVisibleBeneath,wasVisibleBeneath){const{highestFullyRenderedScreenIndex,Index}=this.__closure;if(isVisibleBeneath===wasVisibleBeneath)return;if(isVisibleBeneath){if(highestFullyRenderedScreenIndex.get()>=Index){highestFullyRenderedScreenIndex.set(Index-1);}return;}if(highestFullyRenderedScreenIndex.get()<Index){highestFullyRenderedScreenIndex.set(Index);}}"
+};
+__initData3 = {
+  code: "function MainTabsChannelScreenStackTsx3(){const{enabled,highestFullyRenderedScreenIndex,Index}=this.__closure;return enabled&&highestFullyRenderedScreenIndex.get()>Index;}"
+};
+FirstChannelScreen = memo(function FirstChannelScreen(props) {
+  let r93;
+  let env21960;
+  const { guildId, channelId, showCreateThread, frame, Index: index2, freeze, isDragging: isDragging2, translateX: translateX3, containerWidth, isActive, maxWidth: maxWidth2, focusChatPressableComponent: focusChatPressableComponent2, transitionState, cleanup, parentFreezeValue, highestFullyRenderedScreenIndex: highestFullyRenderedScreenIndex2 } = props;
+  const theme = useTheme();
+  const styles = useStyles();
+  const chatInputFloating = useMobileVisualRefreshConfig({
+    location: "MainTabsChannelScreenStack"
+  }).chatInputFloating;
+  const orientation = useOrientation();
+  const r51 = env21960 = {};
+  env21960[0] = index2;
+  env21960[1] = highestFullyRenderedScreenIndex2;
+  env21960[2] = translateX3;
+  env21960[3] = void 0;
+  const enabled = HideCoveredChannelsExperiment.useConfig({
+    location: "MainTabsChannelScreenStack"
+  }).enabled;
+  env21960[3] = enabled;
+  const r58 = $mk96369(r51);
+  r58.__closure = {
+    translateX: translateX3
+  };
+  r58.__workletHash = 10608377273080;
+  r58.__initData = __initData;
+  const r61 = $mk96370(r51);
+  r61.__closure = {
+    highestFullyRenderedScreenIndex: highestFullyRenderedScreenIndex2,
+    Index: index2
+  };
+  r61.__workletHash = 10137919010401;
+  r61.__initData = __initData2;
+  useAnimatedReaction(r58, r61);
+  useUnmountEffect($mk96371(r51));
+  const r73 = $mk96372(r51);
+  r73.__closure = {
+    enabled,
+    highestFullyRenderedScreenIndex: highestFullyRenderedScreenIndex2,
+    Index: index2
+  };
+  r73.__workletHash = 1648562234730;
+  r73.__initData = __initData3;
+  const styles2 = useMainTabsChannelScreenStyles(isDragging2, translateX3, maxWidth2, useDerivedValue(r73), parentFreezeValue);
+  useEffect(() => {
+    if (transitionState === TransitionStates.YEETED) {
+      cleanup();
+    }
+  }, [cleanup, transitionState]);
+  const style = [styles2, , ,];
+  const r89 = containerWidth != null ? {
+    width: containerWidth
+  } : null;
+  L7: {
+    style[1] = r89;
+    const MIDNIGHT = ThemeTypes.MIDNIGHT;
+    r93 = void 0;
+    if (theme === MIDNIGHT) {
+      if (chatInputFloating) {
+        const PORTRAIT = OrientationType.PORTRAIT;
+        r93 = void 0;
+        if (orientation !== PORTRAIT) {
+          break L7;
+        }
+        const r98 = frame != null;
+        r93 = void 0;
+        if (r98) {
+          break L7;
+        }
+      }
+      r93 = styles.midnightContainerStyles;
+    }
+  }
+  style[2] = r93;
+  return <REAWorkaroundView style={style}>
+    <Freeze freeze={freeze}>
+      <View collapsable={false} style={StyleSheet.absoluteFill} pointerEvents={isActive ? "auto" : "box-only"} accessibilityElementsHidden={isActive ? void 0 : !isActive} importantForAccessibility={isActive ? void 0 : "no-hide-descendants"}>
+        <StandaloneChannelScreen guildId={guildId} channelId={channelId} showCreateThread={showCreateThread} isNavigationScreen={containerWidth == null} frame={frame} screenIndex={index2} />
+      </View>
+    </Freeze>
+    {focusChatPressableComponent2}
+  </REAWorkaroundView>;
+});
+__initData4 = {
+  code: "function MainTabsChannelScreenStackTsx4(){const{translateX}=this.__closure;return translateX.get()===0;}"
+};
+__initData5 = {
+  code: "function MainTabsChannelScreenStackTsx5(isFullyOpen,prev){const{Index,mainTabsDisallowGesture}=this.__closure;if(isFullyOpen===prev)return;if(Index!==1)return;mainTabsDisallowGesture.set(isFullyOpen);}"
+};
+ChannelScreen = memo(function ChannelScreen(props) {
+  let r138, r144, Provider, channelId, freeze, guildId, isActive, props2, showCreateThread, style;
+  let transitionState2, cleanup2, Index, navigation, ref, translateX, disallowGesture, current, ref2;
+  let env21962;
+  L4: {
+    guildId = props.guildId;
+    channelId = props.channelId;
+    showCreateThread = props.showCreateThread;
+    transitionState2 = props.transitionState;
+    cleanup2 = props.cleanup;
+    isActive = props.isActive;
+    freeze = props.freeze;
+    const parentFreezeValue = props.parentFreezeValue;
+    Index = props.Index;
+    const highestFullyRenderedScreenIndex2 = props.highestFullyRenderedScreenIndex;
+    navigation = void 0;
+    ref = void 0;
+    translateX = void 0;
+    disallowGesture = void 0;
+    current = void 0;
+    ref2 = void 0;
+    const theme = useTheme();
+    const styles = useStyles();
+    const chatInputFloating = useMobileVisualRefreshConfig({
+      location: "MainTabsChannelScreenStack"
+    }).chatInputFloating;
+    const orientation = useOrientation();
+    navigation = useNavigation();
+    ref = useRef(false);
+    const mainTabsPanelsGesture = useMainTabsPanelsGesture({
+      canDrag: transitionState2 !== TransitionStates.YEETED,
+      onVisibilityChange: useCallback((a0) => {
+        if (!a0) {
+          if (ref.current) {
+            cleanup2();
+          } else {
+            ref.current = true;
+            navigation.goBack();
+          }
+        }
+      }, [cleanup2, navigation]),
+      onDragStart: dismissKeyboard,
+      startShown: false
+    });
+    const { gesture, panelGestureContext, isDragging: isDragging2 } = mainTabsPanelsGesture;
+    translateX = mainTabsPanelsGesture.translateX;
+    const { movePanel, maxWidth: maxWidth2 } = mainTabsPanelsGesture;
+    const r74 = env21962 = {};
+    env21962[0] = Index;
+    env21962[1] = highestFullyRenderedScreenIndex2;
+    env21962[2] = translateX;
+    env21962[3] = void 0;
+    const enabled = HideCoveredChannelsExperiment.useConfig({
+      location: "MainTabsChannelScreenStack"
+    }).enabled;
+    env21962[3] = enabled;
+    const r79 = $mk96369(r74);
+    r79.__closure = {
+      translateX
+    };
+    r79.__workletHash = 10608377273080;
+    r79.__initData = __initData;
+    const r82 = $mk96370(r74);
+    r82.__closure = {
+      highestFullyRenderedScreenIndex: highestFullyRenderedScreenIndex2,
+      Index
+    };
+    r82.__workletHash = 10137919010401;
+    r82.__initData = __initData2;
+    useAnimatedReaction(r79, r82);
+    useUnmountEffect($mk96371(r74));
+    const r94 = $mk96372(r74);
+    r94.__closure = {
+      enabled,
+      highestFullyRenderedScreenIndex: highestFullyRenderedScreenIndex2,
+      Index
+    };
+    r94.__workletHash = 1648562234730;
+    r94.__initData = __initData3;
+    const derivedValue = useDerivedValue(r94);
+    disallowGesture = useContext(MainTabsNavigatorPanelContext).disallowGesture;
+    const I = () => translateX.get() === 0;
+    I.__closure = {
+      translateX
+    };
+    I.__workletHash = 1803281708382;
+    I.__initData = __initData4;
+    const y = function y(a0, a1) {
+      if (a0 !== a1 && Index === 1) {
+        disallowGesture.set(a0);
+      }
+    };
+    y.__closure = {
+      Index,
+      mainTabsDisallowGesture: disallowGesture
+    };
+    y.__workletHash = 4369586160197;
+    y.__initData = __initData5;
+    useAnimatedReaction(I, y);
+    current = {
+      cleanup: cleanup2,
+      movePanel
+    };
+    ref2 = useRef(current);
+    useEffect(() => {
+      ref2.current = current;
+    });
+    useEffect(() => {
+      L6: {
+        const current2 = ref2.current;
+        const { cleanup: cleanup3, movePanel } = current2;
+        if (transitionState2 !== TransitionStates.MOUNTED && transitionState2 !== TransitionStates.ENTERED) {
+          if (ref.current) {
+            cleanup3();
+            break L6;
+          }
+          ref.current = true;
+          movePanel(false, false, 0, true);
+        } else {
+          movePanel(true, false, 0, false);
+        }
+      }
+    }, [transitionState2]);
+    const styles2 = useMainTabsChannelScreenStyles(isDragging2, translateX, maxWidth2, derivedValue, parentFreezeValue);
+    props2 = {
+      gesture,
+      children: null
+    };
+    Provider = MainTabsChannelScreenStackContext.Provider;
+    r138 = {
+      value: panelGestureContext,
+      children: null
+    };
+    style = [styles2, ,];
+    const MIDNIGHT = ThemeTypes.MIDNIGHT;
+    r144 = void 0;
+    if (theme === MIDNIGHT) {
+      if (chatInputFloating) {
+        const PORTRAIT = OrientationType.PORTRAIT;
+        r144 = void 0;
+        if (orientation !== PORTRAIT) {
+          break L4;
+        }
+      }
+      r144 = styles.midnightContainerStyles;
+    }
+  }
+  style[1] = r144;
+  r138.children = <REAWorkaroundView style={style} accessibilityElementsHidden={isActive ? void 0 : !isActive} importantForAccessibility={isActive ? void 0 : "no-hide-descendants"}>
+    <Freeze freeze={freeze}>
+      <StandaloneChannelScreen guildId={guildId} channelId={channelId} showCreateThread={showCreateThread} isNavigationScreen frame={null} screenIndex={Index} />
+    </Freeze>
+  </REAWorkaroundView>;
+  props2.children = <Provider {...r138} />;
+  return <GestureDetector {...props2} />;
+});
+__initData6 = {
+  code: "function MainTabsChannelScreenStackTsx6(){const{translateX,maxWidth}=this.__closure;return translateX.get()===maxWidth;}"
+};
+__initData7 = {
+  code: "function MainTabsChannelScreenStackTsx7(value,prev){const{runOnJS,setIsHidden}=this.__closure;if(value===prev)return;runOnJS(setIsHidden)(value);}"
+};
+const r61 = memo(function MainTabsChannelScreenStack(props) {
+  let c21963_10, sharedValue, ref3, ref4;
+  const { screens, screenStackActive, translateX: translateX2, isDragging, maxWidth, highestFullyRenderedScreenIndex } = props;
+  let shouldFreeze = props.shouldFreeze;
+  const { focusChatPressableComponent, firstScreenWidth, firstScreenFrame } = props;
+  c21963_10 = void 0;
+  sharedValue = void 0;
+  ref3 = void 0;
+  ref4 = void 0;
+  const colorThemeBackground = useColorThemeBackground();
+  const [state, setState] = useState(translateX2.get() === maxWidth);
+  const D = () => translateX2.get() === maxWidth;
+  D.__closure = {
+    translateX: translateX2,
+    maxWidth
+  };
+  D.__workletHash = 9963940499904;
+  D.__initData = __initData6;
+  const E = function E(a0, a1) {
+    if (a0 !== a1) {
+      _ReanimatedRexport.runOnJS(setState)(a0);
+    }
+  };
+  E.__closure = {
+    runOnJS: _ReanimatedRexport.runOnJS,
+    setIsHidden: setState
+  };
+  E.__workletHash = 10167608718442;
+  E.__initData = __initData7;
+  useAnimatedReaction(D, E);
+  useEffect(() => {
+    const MediaPlayerManager = NativeModules.MediaPlayerManager;
+    if (MediaPlayerManager != null) {
+      const pauseAllMediaPlayers = MediaPlayerManager.pauseAllMediaPlayers;
+      if (pauseAllMediaPlayers != null) {
+        pauseAllMediaPlayers.call(MediaPlayerManager);
+      }
+    }
+  }, [useMemo(() => {
+    const r9 = screens.at(-1);
+    return r9?.type === ChannelScreenType.DEFAULT ? r9.channelId : null;
+  }, [screens])]);
+  const r55 = screens[0];
+  c21963_10 = r55;
+  if (shouldFreeze) {
+    shouldFreeze = state;
+  }
+  if (shouldFreeze) {
+    shouldFreeze = r55 == null || r55.type !== ChannelScreenType.DEFAULT;
+  }
+  sharedValue = useSharedValue(0);
+  useEffect(() => {
+    let c28018_0 = setTimeout(() => {
+      sharedValue.set(sharedValue.get() + 1);
+    }, 10);
+    return () => clearTimeout(c28018_0);
+  }, [shouldFreeze, sharedValue]);
+  const callback = useCallback((a0, a1, a2, a3) => {
+    let r29;
+    const index2 = Number(a0);
+    if (index2 === 0) {
+      let showCreateThread2 = a1.showCreateThread;
+      if (showCreateThread2 == null) {
+        showCreateThread2 = false;
+      }
+      let isActive = screenStackActive;
+      if (screenStackActive) {
+        isActive = index2 === screens.length - 1;
+      }
+      r29 = <FirstChannelScreen key={a0} guildId={a1.guildId} channelId={a1.channelId} showCreateThread={showCreateThread2} focusChatPressableComponent={focusChatPressableComponent} Index={index2} transitionState={a2} cleanup={a3} isDragging={isDragging} translateX={translateX2} isActive={isActive} freeze={index2 < screens.length - 2} containerWidth={firstScreenWidth} frame={firstScreenFrame} parentFreezeValue={sharedValue} maxWidth={maxWidth} highestFullyRenderedScreenIndex={highestFullyRenderedScreenIndex} />;
+    } else {
+      let showCreateThread = a1.showCreateThread;
+      if (showCreateThread == null) {
+        showCreateThread = false;
+      }
+      r29 = <ChannelScreen key={a0} guildId={a1.guildId} channelId={a1.channelId} showCreateThread={showCreateThread} Index={index2} transitionState={a2} parentFreezeValue={sharedValue} cleanup={a3} isActive={index2 === screens.length - 1} freeze={index2 < screens.length - 2} highestFullyRenderedScreenIndex={highestFullyRenderedScreenIndex} />;
+    }
+    return r29;
+  }, [screens.length, focusChatPressableComponent, isDragging, translateX2, firstScreenWidth, firstScreenFrame, maxWidth, sharedValue, screenStackActive, highestFullyRenderedScreenIndex]);
+  let r79 = r55?.channelId;
+  if (r79 == null) {
+    r79 = null;
+  }
+  ref3 = useRef(r79);
+  ref4 = useRef(null);
+  const r86 = [r55?.type, ,];
+  const channelId = r55?.channelId;
+  const r89 = () => {
+    if (c21963_10?.type != null && ref4.current !== c21963_10.type) {
+      ref4.current = c21963_10.type;
+      if (c21963_10.channelId === ref3.current) {
+        if (!(c21963_10.type !== ChannelScreenType.DEFAULT || getChatLayout().isChatLockedOpen)) {
+          Dispatcher.dispatch({
+            type: "TRY_ACK",
+            location: {
+              section: AnalyticsSections.CHANNEL,
+              object: AnalyticsObjects.ACK_CHANNEL_SELECT_SAME_CHANNEL_DISPATCH,
+              objectType: AnalyticsObjectTypes.ACK_AUTOMATIC
+            },
+            channelId: c21963_10.channelId
+          });
+        }
+      } else {
+        ref3.current = c21963_10.channelId;
+      }
+    }
+  };
+  r86[1] = channelId;
+  useEffect(r89, r86);
+  freezeScreenIndex(shouldFreeze, 0);
+  return shouldFreeze ? r55?.showCreateThread ? null : <Freeze freeze={shouldFreeze}>
+    <View collapsable={false} style={StyleSheet.absoluteFill} pointerEvents="box-none" accessibilityElementsHidden={screenStackActive ? void 0 : !screenStackActive} importantForAccessibility={screenStackActive ? void 0 : "no-hide-descendants"}>
+      <ThemeContextProvider gradient={colorThemeBackground}>
+        <TransitionGroup items={screens} renderItem={callback} getItemKey={getKey} />
+      </ThemeContextProvider>
+    </View>
+  </Freeze> : <Freeze freeze={shouldFreeze}>
+    <View collapsable={false} style={StyleSheet.absoluteFill} pointerEvents="box-none" accessibilityElementsHidden={screenStackActive ? void 0 : !screenStackActive} importantForAccessibility={screenStackActive ? void 0 : "no-hide-descendants"}>
+      <ThemeContextProvider gradient={colorThemeBackground}>
+        <TransitionGroup items={screens} renderItem={callback} getItemKey={getKey} />
+      </ThemeContextProvider>
+    </View>
+  </Freeze>;
+});
+export default r61;

modules/main_tabs_v2/native/panels/MainTabsContentScrim.tsx

@@ -0,0 +1,34 @@
+// Metro module 15397 (f15398).
+import { StyleSheet } from "react-native";
+import { createStyles } from "../../../../design/components/Styles/native/createStyles";
+import Module712 from "../../../../_bundle/Module712";
+import * as _ReanimatedRexport from "../../../reanimated/ReanimatedRexport";
+import ReanimatedRexport, { useAnimatedStyle } from "../../../reanimated/ReanimatedRexport";
+const useStyles = createStyles({
+  scrim: {
+    ...StyleSheet.absoluteFillObject,
+    zIndex: 5,
+    backgroundColor: Module712.colors.BACKGROUND_SCRIM
+  }
+});
+const __initData = {
+  code: "function MainTabsContentScrimTsx1(){const{interpolate,translateX,maxWidth,Extrapolation}=this.__closure;return{opacity:interpolate(translateX.get(),[maxWidth,0],[0,0.5],Extrapolation.CLAMP)};}"
+};
+export function MainTabsContentScrim(props) {
+  const { translateX, maxWidth } = props;
+  const styles = useStyles();
+  const c = function c() {
+    return {
+      opacity: _ReanimatedRexport.interpolate(translateX.get(), [maxWidth, 0], [0, 0.5], _ReanimatedRexport.Extrapolation.CLAMP)
+    };
+  };
+  c.__closure = {
+    interpolate: _ReanimatedRexport.interpolate,
+    translateX,
+    maxWidth,
+    Extrapolation: _ReanimatedRexport.Extrapolation
+  };
+  c.__workletHash = 7933670426250;
+  c.__initData = __initData;
+  return <ReanimatedRexport.View style={[styles.scrim, useAnimatedStyle(c)]} pointerEvents="none" />;
+}

modules/main_tabs_v2/native/panels/MainTabsNavigatorPanel.tsx

@@ -0,0 +1,257 @@
+// Metro module 14917 (f14918).
+import * as Module19 from "react";
+import { useRef, useLayoutEffect, useState, useEffect, useCallback, useMemo } from "react";
+import { Pressable, StyleSheet, View } from "react-native";
+import { ComponentActions, ME } from "../../../../Constants";
+import Logger from "../../../debug/Logger";
+import { createStyles } from "../../../../design/components/Styles/native/createStyles";
+import Module712 from "../../../../_bundle/Module712";
+import { useNavigation } from "../../../../_bundle/Module1481";
+import useChatLayout from "../../../chat/native/useChatLayout";
+import { useDrawerWidth } from "../../../screen/native/drawer/useDrawerWidth";
+import useChatWidth from "../../../chat/native/useChatWidth";
+import { convertPortraitToLandscapeScreens, convertLandscapeToPortraitScreens } from "./PanelsNavigationUtils";
+import { dismissKeyboard } from "../../../../utils/native/ChatInputUtils";
+import useChannelScreensFromNavigation, { ChannelScreenType, isActiveTabsGuilds } from "./useChannelScreensFromNavigation";
+import { getRootNavigationRef } from "../../RootNavigationRef.native";
+import { transitionToChannel } from "../../../routing/transitionToChannel";
+import { ComponentDispatch } from "../../../../utils/ComponentDispatchUtils";
+import useMainTabsPanelsGesture from "./useMainTabsPanelsGesture";
+import ChannelActionCreators from "../../../../actions/ChannelActionCreators";
+import ChannelScreenAnimatedFrame from "./ChannelScreenAnimatedFrame";
+import ReanimatedRexport, { useSharedValue, useAnimatedStyle } from "../../../reanimated/ReanimatedRexport";
+import useDesignToggle from "../../../devtools/design_toggles/useDesignToggle";
+import { useIsCustomThemeActive } from "../../../client_themes/native/useActiveTheme";
+import MainTabsNavigatorPanelContext from "./MainTabsNavigatorPanelContext";
+import { GestureDetector } from "../../../../_bundle/Module5273";
+import { SidebarCoachmarkOverlay } from "./SidebarCoachmarkOverlay.native";
+import YouBarStackNavigator from "../you_bar/YouBarStackNavigator";
+import { MainTabsContentScrim } from "./MainTabsContentScrim";
+import ThemedHeaderBackgroundGradient from "./ThemedHeaderBackgroundGradient";
+import MainTabsChannelScreenStack from "./MainTabsChannelScreenStack";
+let c10548_12 = new Logger("MainTabsNavigatorPanel");
+const useStyles = createStyles({
+  container: {
+    flex: 1
+  },
+  containerBackground: {
+    backgroundColor: Module712.colors.BACKGROUND_BASE_LOWEST
+  },
+  tabsContainer: {
+    flex: 1
+  }
+});
+const __initData = {
+  code: "function MainTabsNavigatorPanelTsx1(){const{translateX,highestFullyRenderedScreenIndex}=this.__closure;return{opacity:translateX.get()>0&&highestFullyRenderedScreenIndex.get()<1?1:0};}"
+};
+const r54 = Module19.memo(function MainTabsNavigatorPanel() {
+  let c21452_5, state, current, ref3, callback, isChatBesideChannelList, ref4, c21452_16, translateX, movePanel, maxWidth, isDraggingRef, current2, ref5, callback2, sharedValue;
+  const styles = useStyles();
+  const navigation = useNavigation();
+  const chatLayout = useChatLayout();
+  const { isChatBesideChannelList: isChatBesideChannelList2, isChatLockedOpen } = chatLayout;
+  const drawerWidth = useDrawerWidth();
+  const chatWidth = useChatWidth();
+  const ref = useRef(isChatLockedOpen);
+  const ref2 = useRef(false);
+  useLayoutEffect(() => {
+    if (ref.current !== isChatLockedOpen) {
+      ref.current = isChatLockedOpen;
+      if (isChatLockedOpen) {
+        convertPortraitToLandscapeScreens();
+      } else {
+        dismissKeyboard();
+        convertLandscapeToPortraitScreens();
+      }
+      ref2.current = true;
+    }
+  }, [isChatLockedOpen]);
+  const channelScreensFromNavigation = useChannelScreensFromNavigation(navigation);
+  c21452_5 = channelScreensFromNavigation;
+  let [screenStackActive, setState] = useState(() => c21452_5[0]?.type === ChannelScreenType.DEFAULT);
+  state = screenStackActive;
+  current = channelScreensFromNavigation[0];
+  ref3 = useRef(current);
+  useEffect(() => {
+    ref3.current = current;
+  }, [current]);
+  callback = useCallback(() => {
+    let r24;
+    setState(false);
+    const state3 = navigation.getState();
+    let index = state3.index;
+    const name = state3.routes[index]?.name;
+    let r0 = 0;
+    let r4 = 0;
+    if (name === "channel") {
+      do {
+        const r1 = index - 1;
+        const r14 = state3.routes[r1];
+        const r23 = r14 == null;
+        const r3 = r0;
+        r24 = r23 ? void 0 : r14.name;
+        r0 = r3 + 1;
+        index = r1;
+        r4 = r0;
+      } while (r24 === "channel");
+    }
+    if (0 < r4) {
+      navigation.pop(r4);
+    }
+  }, [navigation]);
+  const [state2, setState2] = useState(() => isActiveTabsGuilds(navigation.getState()));
+  let [state3, setState3] = useState(() => state2);
+  useEffect(() => {
+    const handleStateChange2 = function handleStateChange(a0) {
+      setState2(isActiveTabsGuilds(a0.data.state));
+    };
+    navigation.addListener("state", handleStateChange2);
+    return () => {
+      navigation.removeListener("state", handleStateChange2);
+    };
+  }, [navigation]);
+  useEffect(() => {
+    setState3(state2);
+  }, [state2]);
+  if (state3) {
+    state3 = isChatBesideChannelList2;
+  }
+  isChatBesideChannelList = state3;
+  ref4 = useRef(false);
+  const callback3 = useCallback((a0) => {
+    setState(a0);
+    ref4.current = false;
+    if (a0) {
+      if (ref3.current != null && navigation.getState().routes[navigation.getState().index].name !== "channel") {
+        const rootNavigationRef = getRootNavigationRef();
+        const r2 = rootNavigationRef == null;
+        let r32 = void 0;
+        if (!r2) {
+          const state3 = rootNavigationRef.getState();
+          r32 = state3 == null ? void 0 : state3.routes[rootNavigationRef == null ? void 0 : rootNavigationRef.getState()?.index]?.name;
+        }
+        if (r32 !== "modal") {
+          ref4.current = true;
+          transitionToChannel(ref3.current.channelId);
+        }
+      }
+    } else {
+      callback();
+    }
+  }, [navigation, callback]);
+  const callback4 = useCallback(() => {
+    ComponentDispatch.dispatch(ComponentActions.BOTTOM_CHANNEL_SCREEN_DRAG_START);
+    dismissKeyboard();
+  }, []);
+  const r100 = current != null && current.type !== ChannelScreenType.FALLBACK_RENDERED;
+  c21452_16 = r100;
+  const r108 = isChatBesideChannelList ? isChatLockedOpen : isChatBesideChannelList;
+  const mainTabsPanelsGesture = useMainTabsPanelsGesture({
+    canDrag: r108 ? !r108 : r100,
+    onVisibilityChange: callback3,
+    onDragStart: callback4,
+    startShown: channelScreensFromNavigation[0]?.type === ChannelScreenType.DEFAULT,
+    openWidth: isChatBesideChannelList ? drawerWidth : void 0
+  });
+  const { gesture, panelGestureContext, isDragging } = mainTabsPanelsGesture;
+  translateX = mainTabsPanelsGesture.translateX;
+  movePanel = mainTabsPanelsGesture.movePanel;
+  maxWidth = mainTabsPanelsGesture.maxWidth;
+  isDraggingRef = mainTabsPanelsGesture.isDraggingRef;
+  useEffect(() => {
+    c10548_12.log("Chat Layout Changed", {
+      isNavigatorPanelsBesideChannelList: isChatBesideChannelList,
+      drawerWidth
+    });
+  }, [isChatBesideChannelList, drawerWidth]);
+  current2 = {
+    handleExit: callback,
+    maxWidth,
+    movePanel,
+    screens: channelScreensFromNavigation,
+    firstScreen: current
+  };
+  ref5 = useRef(current2);
+  useEffect(() => {
+    ref5.current = current2;
+  });
+  useEffect(() => {
+    if (!isDraggingRef.current) {
+      const current3 = ref5.current;
+      const { handleExit, maxWidth: maxWidth2, movePanel: movePanel2, screens } = current3;
+      const r29 = current?.type === ChannelScreenType.DEFAULT;
+      if (screens.length >= 2) {
+        translateX.set(r29 ? 0 : maxWidth2);
+        setState(r29);
+        return void 0;
+      }
+      if (r29) {
+        if (ref4.current) {
+          ref4.current = false;
+          if (translateX.get() === maxWidth2) {
+            handleExit();
+          }
+          return void 0;
+        }
+        movePanel2(true, false, 0, true);
+      } else if (movePanel2(false, false, 0, false)) {
+        dismissKeyboard();
+      }
+    }
+  }, [current?.type, translateX, isDraggingRef]);
+  useEffect(() => {
+    const firstScreen = ref5.current.firstScreen;
+    if (firstScreen?.type === ChannelScreenType.BACKGROUND_SAVED) {
+      let guildId = firstScreen.guildId;
+      if (guildId == null) {
+        guildId = ME;
+      }
+      ChannelActionCreators.preload(guildId, firstScreen.channelId);
+    }
+  }, [current?.channelId]);
+  callback2 = useCallback(() => {
+    if (c21452_16) {
+      movePanel(true, false, 0, false);
+    }
+  }, [movePanel, r100]);
+  const memo = useMemo(() => isChatBesideChannelList ? isChatLockedOpen ? null : state ? null : <Pressable style={StyleSheet.absoluteFill} onPress={callback2} /> : null, [callback2, state, isChatLockedOpen, isChatBesideChannelList]);
+  const r152 = isChatBesideChannelList && isChatLockedOpen ? channelScreensFromNavigation.length <= 1 : !state;
+  const memo2 = useMemo(() => isChatBesideChannelList ? <ChannelScreenAnimatedFrame translateX={translateX} maxWidth={maxWidth} isChatLockedOpen={isChatLockedOpen} /> : null, [isChatLockedOpen, isChatBesideChannelList, maxWidth, translateX]);
+  sharedValue = useSharedValue(translateX.get() > 0 ? -1 : 0);
+  const re = function re() {
+    return {
+      opacity: translateX.get() > 0 ? sharedValue.get() < 1 ? 1 : 0 : 0
+    };
+  };
+  re.__closure = {
+    translateX,
+    highestFullyRenderedScreenIndex: sharedValue
+  };
+  re.__workletHash = 10839500061449;
+  re.__initData = __initData;
+  const animatedStyle = useAnimatedStyle(re);
+  const designToggle = useDesignToggle("channel_list_scrim");
+  const isCustomThemeActive = useIsCustomThemeActive();
+  const style = [styles.container, isCustomThemeActive ? !isCustomThemeActive : styles.containerBackground];
+  const r216 = [<ReanimatedRexport.View style={[styles.tabsContainer, animatedStyle]} accessibilityElementsHidden={r152 ? void 0 : !r152} importantForAccessibility={r152 ? void 0 : "no-hide-descendants"}>
+    <YouBarStackNavigator />
+    {designToggle ? <MainTabsContentScrim translateX={translateX} maxWidth={maxWidth} /> : void 0}
+  </ReanimatedRexport.View>, <ThemedHeaderBackgroundGradient />, ,];
+  const r222 = channelScreensFromNavigation.length > 0;
+  let r223 = null;
+  if (r222) {
+    if (!state) {
+      screenStackActive = isChatBesideChannelList ? isChatLockedOpen : isChatBesideChannelList;
+    }
+    r223 = <MainTabsChannelScreenStack screens={channelScreensFromNavigation} screenStackActive={screenStackActive} translateX={translateX} isDragging={isDragging} maxWidth={maxWidth} highestFullyRenderedScreenIndex={sharedValue} shouldFreeze={!isChatBesideChannelList} focusChatPressableComponent={memo} firstScreenWidth={isChatBesideChannelList ? isChatLockedOpen ? chatWidth : void 0 : void 0} firstScreenFrame={memo2} />;
+  }
+  r216[2] = r223;
+  return <MainTabsNavigatorPanelContext.Provider value={panelGestureContext}>
+    <GestureDetector gesture={gesture}>
+      <View style={style} collapsable={false}>
+        <SidebarCoachmarkOverlay enabled={isChatBesideChannelList}>{r216}</SidebarCoachmarkOverlay>
+      </View>
+    </GestureDetector>
+  </MainTabsNavigatorPanelContext.Provider>;
+});
+export default r54;

modules/main_tabs_v2/native/panels/MainTabsNavigatorPanelContext.tsx

@@ -0,0 +1,12 @@
+// Metro module 14924 (f14925).
+import { createContext } from "react";
+import { Gesture } from "../../../../_bundle/Module5273";
+import { createFakeSharedValue } from "../../../reanimated/ReanimatedHelperTypes";
+const context = createContext({
+  gesture: Gesture.Pan(),
+  disallowGesture: createFakeSharedValue(false),
+  translateX: createFakeSharedValue(0)
+});
+const context2 = createContext(void 0);
+export default context;
+export { context2 as MainTabsChannelScreenStackContext };

modules/main_tabs_v2/native/panels/PanelsNavigationUtils.tsx

@@ -0,0 +1,91 @@
+// Metro module 14918 (f14919).
+import { getRootNavigationRef } from "../../RootNavigationRef.native";
+import { coerceMainRoute, coerceChannelRoute, coerceTabsRoute, coerceGuildsRoute } from "../../helpers/NavigationRouteUtils.native";
+import { CommonActions } from "../../../../_bundle/Module1485";
+import { v4 } from "../../../../_bundle/Module514";
+import { HermesBuiltin } from "../../../../_hermes/prelude";
+export function convertPortraitToLandscapeScreens() {
+  const rootNavigationRef = getRootNavigationRef();
+  if (rootNavigationRef != null) {
+    const state = rootNavigationRef.getState();
+    if (state != null) {
+      const r27 = coerceMainRoute(state.routes[0]);
+      if (r27 != null) {
+        const state2 = r27.state;
+        if (state2 != null && state2.index !== 0 && coerceChannelRoute(state2.routes[1]) != null) {
+          const r14 = coerceTabsRoute(state2.routes[0]);
+          if (r14 != null) {
+            const state3 = r14.state;
+            if (coerceGuildsRoute(state3 == null ? void 0 : state3.routes[r14.state?.index]) != null) {
+              r27.state = {
+                ...state2,
+                index: state2.index - 1,
+                routes: [state2.routes[0], ...state2.routes.slice(2)]
+              };
+              const routes = [r27, ...state.routes.slice(1)];
+              rootNavigationRef.dispatch(CommonActions.reset({
+                ...state,
+                routes,
+                index: routes.length - 1
+              }));
+            }
+          }
+        }
+      }
+    }
+  }
+}
+export function convertLandscapeToPortraitScreens() {
+  const rootNavigationRef = getRootNavigationRef();
+  if (rootNavigationRef != null) {
+    const state = rootNavigationRef.getState();
+    if (state != null) {
+      const r28 = coerceMainRoute(state.routes[0]);
+      if (r28 != null) {
+        const state2 = r28.state;
+        if (state2 != null) {
+          if (state.index === 0) {
+            if (state2.index === 0) {
+              return void 0;
+            }
+            if (coerceChannelRoute(state2.routes[1]) == null) {
+              return void 0;
+            }
+          }
+          const r14 = coerceTabsRoute(state2.routes[0]);
+          if (r14 != null) {
+            const state3 = r14.state;
+            const r48 = coerceGuildsRoute(state3 == null ? void 0 : state3.routes[r14.state?.index]);
+            if (r48 != null) {
+              const routes = [state2.routes[0], ,];
+              let key = r48.params?.channelId;
+              if (key == null) {
+                key = `channel-${v4()}`;
+              }
+              routes[1] = {
+                name: "channel",
+                key,
+                params: {
+                  channelId: r48.params?.channelId,
+                  guildId: r48.params?.guildId
+                }
+              };
+              HermesBuiltin.arraySpread(routes, state2.routes.slice(1), 2);
+              r28.state = {
+                ...state2,
+                index: state2.index + 1,
+                routes
+              };
+              const routes2 = [r28, ...state.routes.slice(1)];
+              rootNavigationRef.dispatch(CommonActions.reset({
+                ...state,
+                routes: routes2,
+                index: routes2.length - 1
+              }));
+            }
+          }
+        }
+      }
+    }
+  }
+}

modules/main_tabs_v2/native/panels/SidebarCoachmarkOverlay.native.tsx

@@ -0,0 +1,37 @@
+// Metro module 14925 (f14926).
+import { useState, useEffect, Fragment, createContext } from "react";
+import { View, StyleSheet } from "react-native";
+import { NOOP } from "../../../../Constants";
+import useInitialValue from "../../../../hooks/useInitialValue";
+import { LayerContextManager } from "../../../../design/components/Layers/native/LayerContext.native";
+let context, styles;
+const SidebarCoachmarkOverlayLayer = function SidebarCoachmarkOverlayLayer(props) {
+  const manager = props.manager;
+  const [, setState] = useState({});
+  useEffect(() => {
+    const manager2 = manager;
+    manager.invalidate = () => setState({});
+    return () => {
+      manager2.invalidate = () => null;
+    };
+  }, [manager]);
+  return <View style={styles.overlay} ref={(a0) => manager.setSurfaceRef(a0)} onLayout={NOOP} pointerEvents="box-none">
+    {manager.items.map((item) => <Fragment key={item.key}>{item.component}</Fragment>)}
+  </View>;
+};
+context = createContext(null);
+styles = StyleSheet.create({
+  overlay: {
+    ...StyleSheet.absoluteFillObject,
+    zIndex: 1
+  }
+});
+export { context as SidebarCoachmarkOverlayContext };
+export function SidebarCoachmarkOverlay(props) {
+  const { children, enabled } = props;
+  const initialValue = useInitialValue(() => new LayerContextManager());
+  return <context.Provider value={enabled ? initialValue : null}>
+    {children}
+    {enabled ? <SidebarCoachmarkOverlayLayer manager={initialValue} /> : null}
+  </context.Provider>;
+}

modules/main_tabs_v2/native/panels/ThemedHeaderBackgroundGradient.tsx

@@ -0,0 +1,39 @@
+// Metro module 15398 (f15399).
+import { memo } from "react";
+import { StyleSheet, View } from "react-native";
+import { createStyles } from "../../../../design/components/Styles/native/createStyles";
+import Module712 from "../../../../_bundle/Module712";
+import useSafeAreaInsets_native from "../../../safe_area/useSafeAreaInsets.native";
+import { useToken } from "../../../../design/tokens/native/useToken";
+import { hex2rgb } from "../../../../_bundle/int2hslRaw";
+import Module4611 from "../../../../_bundle/Module4611";
+const useStyles = createStyles({
+  container: {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    top: 0
+  }
+});
+const r30 = memo(function ThemedHeaderBackgroundGradient(props) {
+  const { baseColor = Module712.colors.BACKGROUND_BASE_LOWEST, minHeight = 16 } = props;
+  const styles = useStyles();
+  const safeAreaInsets_native = useSafeAreaInsets_native();
+  const token = useToken(baseColor);
+  let r28 = hex2rgb(token, 0);
+  if (r28 == null) {
+    r28 = "transparent";
+  }
+  return <View style={[styles.container, {
+    height: Math.max(safeAreaInsets_native.top, minHeight)
+  }]} pointerEvents="none">
+    <Module4611 style={StyleSheet.absoluteFill} colors={[token, r28]} start={{
+      x: 0,
+      y: 0
+    }} end={{
+      x: 0,
+      y: 1
+    }} />
+  </View>;
+});
+export default r30;

modules/main_tabs_v2/native/panels/createChatPanelNativeStackNavigator.tsx

@@ -0,0 +1,93 @@
+// Metro module 14857 (f14858).
+import { useMemo, useEffect } from "react";
+import { createNavigatorFactory, useNavigationBuilder, StackRouter, StackActions } from "../../../../_bundle/Module1481";
+import { coerceChannelRoute } from "../../helpers/NavigationRouteUtils.native";
+import { useAccessibilityPatchedDescriptors } from "../../../../design/components/Navigator/native/createAccessibleNativeStackNavigator.native";
+import { NativeStackView } from "../../../../_bundle/Module9109";
+const navigatorFactory = createNavigatorFactory(function ChatPanelNativeStackNavigator(props) {
+  let state2;
+  const { id, initialRouteName, children, screenListeners, screenOptions, ...props2 } = props;
+  state2 = void 0;
+  const navigationBuilder = useNavigationBuilder(StackRouter, {
+    id,
+    initialRouteName,
+    children,
+    screenListeners,
+    screenOptions
+  });
+  const { state, descriptors, navigation, NavigationContent } = navigationBuilder;
+  const memo = useMemo(() => {
+    let r0, length;
+    const state3 = {
+      ...state,
+      routes: [...state.routes]
+    };
+    const r16 = [];
+    const routes = [];
+    const filteredDescriptors = {};
+    const r8 = 0 < state3.routes.length;
+    let r1 = 0;
+    let r2 = 0;
+    let r6 = 0;
+    if (r8) {
+      do {
+        const r18 = state3.routes[r1];
+        const r36 = coerceChannelRoute(r18);
+        const r5 = r1;
+        const r3 = r2;
+        if (r36 != null) {
+          r16.push(r18);
+          r0 = r5 <= state3.index ? r3 + 1 : r3;
+        } else {
+          routes.push(r18);
+          const r40 = r18.key in descriptors;
+          r0 = r3;
+          if (r40) {
+            filteredDescriptors[r18.key] = descriptors[r18.key];
+            r0 = r3;
+          }
+        }
+        r1 = r5 + 1;
+        length = state3.routes.length;
+        r2 = r0;
+        r6 = r2;
+      } while (r1 < length);
+    }
+    state3.index = Math.max(0, state3.index - r6);
+    state3.routes = routes;
+    if (state3.routes.length === 0) {
+      state3.index = 0;
+    } else if (state3.index >= state3.routes.length) {
+      state3.index = state3.routes.length - 1;
+    }
+    return {
+      state: state3,
+      filteredDescriptors
+    };
+  }, [state, descriptors]);
+  state2 = memo.state;
+  const accessibilityPatchedDescriptors = useAccessibilityPatchedDescriptors(memo.filteredDescriptors);
+  useEffect(() => {
+    const r2 = navigation == null;
+    let r3 = void 0;
+    if (!r2) {
+      const addListener = navigation.addListener;
+      r3 = addListener == null ? void 0 : addListener.call(navigation, "tabPress", (c30793_0) => {
+        const isFocused = navigation.isFocused();
+        requestAnimationFrame(() => {
+          if (state2.index > 0 && isFocused && !c30793_0.defaultPrevented) {
+            navigation.dispatch({
+              ...StackActions.popToTop(),
+              target: state2.key
+            });
+          }
+        });
+      });
+    }
+    return r3;
+  }, [navigation, state2.index, state2.key]);
+  return <NavigationContent>
+    <NativeStackView {...props2} state={state2} navigation={navigation} descriptors={accessibilityPatchedDescriptors} />
+  </NavigationContent>;
+});
+export default navigatorFactory;

modules/main_tabs_v2/native/panels/useChannelScreensFromNavigation.tsx

@@ -0,0 +1,190 @@
+// Metro module 14919 (f14920).
+import { useState, useCallback, useEffect } from "react";
+import ChannelStore from "../../../../stores/ChannelStore";
+import SelectedChannelStore from "../../../../stores/SelectedChannelStore";
+import SelectedGuildStore from "../../../../stores/SelectedGuildStore";
+import { ME } from "../../../../Constants";
+import { isStaticChannelRoute } from "../../../channel/ChannelConstants";
+import { getRootNavigationRef } from "../../RootNavigationRef.native";
+import { coerceTabsRoute, coerceGuildsRoute, coerceChannelRoute } from "../../helpers/NavigationRouteUtils.native";
+import useChatLayout, { getChatLayout } from "../../../chat/native/useChatLayout";
+let c10550_10, resolveBackgroundScreen, resolveChannelScreens;
+const getActiveTabsRoute = function getActiveTabsRoute(a0) {
+  if (a0 != null) {
+    const state = a0.state;
+    const r3 = state == null;
+    let r4 = void 0;
+    if (!r3) {
+      const routes = state.routes;
+      let r11 = a0.state?.index;
+      if (r11 == null) {
+        const state2 = a0.state;
+        r11 = (state2 == null ? void 0 : state2.routes.length) - 1;
+      }
+      r4 = routes[r11];
+    }
+    if (r4 != null) {
+      return r4;
+    }
+    if (a0.params?.screen != null) {
+      return {
+        key: "resolved",
+        name: a0.params.screen,
+        params: a0.params.params
+      };
+    }
+    const rootNavigationRef = getRootNavigationRef();
+    if ((rootNavigationRef == null ? void 0 : rootNavigationRef.isReady()) === true) {
+      return rootNavigationRef.getCurrentRoute();
+    }
+  }
+};
+resolveBackgroundScreen = function resolveBackgroundScreen(a0) {
+  const r12 = coerceTabsRoute(a0.routes[0]);
+  if (r12 == null) {
+    return [];
+  }
+  const activeTabsRoute = getActiveTabsRoute(r12);
+  if (activeTabsRoute == null) {
+    return [];
+  }
+  const r18 = coerceGuildsRoute(activeTabsRoute);
+  if (r18 == null) {
+    return [];
+  }
+  const guildId2 = r18.params?.guildId;
+  let channelId = r18.params?.channelId;
+  if (channelId == null) {
+    channelId = void 0;
+  }
+  if (channelId == null) {
+    return [];
+  }
+  if (!isStaticChannelRoute(channelId) && ChannelStore.getChannel(channelId) == null) {
+    return [];
+  }
+  const search = r18.params?.search;
+  return [{
+    index: 0,
+    type: search != null && search ? c10550_10.FALLBACK_RENDERED : c10550_10.BACKGROUND_SAVED,
+    guildId: guildId2,
+    channelId,
+    showCreateThread: false
+  }];
+};
+resolveChannelScreens = function resolveChannelScreens(state, a1) {
+  const r10 = [];
+  const r5 = 0 <= state.index;
+  let r0 = 0;
+  if (r5) {
+    do {
+      const r22 = coerceChannelRoute(state.routes[r0]);
+      const r1 = r0;
+      if (r22 != null) {
+        r10.push({
+          index: r10.length,
+          type: c10550_10.DEFAULT,
+          guildId: r22.params.guildId,
+          channelId: r22.params.channelId,
+          showCreateThread: r22.params.showCreateThread
+        });
+      }
+      r0 = r1 + 1;
+    } while (r0 <= state.index);
+  }
+  if (a1.isChatLockedOpen) {
+    const r39 = resolveBackgroundScreen(state);
+    let c21453_0 = r39;
+    if (r39.length > 0) {
+      return [...r39, ...r10.map((item) => ({
+        ...item,
+        index: item.index + c21453_0.length
+      }))];
+    }
+  }
+  return r10.length > 0 ? r10 : resolveBackgroundScreen(state);
+};
+c10550_10 = {
+  DEFAULT: 0,
+  0: "DEFAULT",
+  BACKGROUND_SAVED: 1,
+  1: "BACKGROUND_SAVED",
+  FALLBACK_RENDERED: 2,
+  2: "FALLBACK_RENDERED"
+};
+export default function useChannelScreensFromNavigation(a0) {
+  let callback;
+  let c21454_0 = a0;
+  const chatLayout = useChatLayout();
+  let c21454_1 = chatLayout;
+  const [state, setState] = useState(() => {
+    let r20;
+    let r10 = resolveChannelScreens(c21454_0.getState(), c21454_1);
+    if (!(r10.length > 0)) {
+      let guildId2 = SelectedGuildStore.getGuildId();
+      const channelId = SelectedChannelStore.getChannelId();
+      if (channelId == null) {
+        r20 = [];
+      } else {
+        if (guildId2 == null) {
+          guildId2 = ME;
+        }
+        r20 = [{
+          index: 0,
+          type: c10550_10.FALLBACK_RENDERED,
+          guildId: guildId2,
+          channelId
+        }];
+      }
+      r10 = r20;
+    }
+    return r10;
+  });
+  callback = useCallback((a0, a1) => {
+    if (a0 != null && a0.length > 0) {
+      setState(a0);
+    } else {
+      const r16 = coerceTabsRoute(a1.routes[0]);
+      const r3 = r16 != null;
+      let r17 = void 0;
+      if (r3) {
+        const activeTabsRoute = getActiveTabsRoute(r16);
+        const r20 = activeTabsRoute != null;
+        r17 = void 0;
+        if (r20) {
+          const r24 = coerceGuildsRoute(activeTabsRoute);
+          r17 = r24 == null ? void 0 : r24.params?.guildId;
+        }
+      }
+      const guildId = r17;
+      setState((prevState) => prevState.length !== 0 ? guildId != null && guildId !== prevState[0].guildId ? [] : prevState[0].type !== c10550_10.FALLBACK_RENDERED ? [{
+        ...prevState[0],
+        type: c10550_10.FALLBACK_RENDERED
+      }] : prevState : prevState);
+    }
+  }, []);
+  useEffect(() => {
+    const state = c21454_0.getState();
+    callback(resolveChannelScreens(state, c21454_1), state);
+  }, [a0, chatLayout, callback]);
+  useEffect(() => {
+    const handleStateChange2 = function handleStateChange(a0) {
+      callback(resolveChannelScreens(a0.data.state, getChatLayout()), a0.data.state);
+    };
+    c21454_0.addListener("state", handleStateChange2);
+    return () => {
+      c21454_0.removeListener("state", handleStateChange2);
+    };
+  }, [a0, callback]);
+  return state;
+};
+export { c10550_10 as ChannelScreenType };
+export { getActiveTabsRoute };
+export function isActiveTabsGuilds(a0) {
+  const r12 = coerceTabsRoute(a0.routes[0]);
+  if (r12 == null) {
+    return false;
+  }
+  const activeTabsRoute = getActiveTabsRoute(r12);
+  return activeTabsRoute != null && coerceGuildsRoute(activeTabsRoute) != null;
+}

modules/main_tabs_v2/native/panels/useMainTabsChannelScreenStyles.tsx

@@ -0,0 +1,51 @@
+// Metro module 15401 (f15402).
+import { useMemo } from "react";
+import { StyleSheet } from "react-native";
+import { createStyles } from "../../../../design/components/Styles/native/createStyles";
+import Module712 from "../../../../_bundle/Module712";
+import { useAnimatedStyle } from "../../../reanimated/ReanimatedRexport";
+const useStyles = createStyles({
+  elevation: {
+    ...StyleSheet.absoluteFillObject,
+    ...Module712.shadows.SHADOW_LOW
+  }
+});
+const __initData = {
+  code: "function useMainTabsChannelScreenStylesTsx1(){const{freezeValue,isDragging,translateX,maxWidth,elevationStyle,isCompletelyCovered}=this.__closure;var _freezeValue,_isCompletelyCovered;(_freezeValue=freezeValue)===null||_freezeValue===void 0||_freezeValue.get();const showBorder=isDragging.get()||translateX.get()!==0&&translateX.get()!==maxWidth;return{transform:[{translateX:translateX.get()}],shadowOpacity:showBorder?elevationStyle.shadowOpacity:0,elevation:showBorder?elevationStyle.elevation:0,opacity:(_isCompletelyCovered=isCompletelyCovered)!==null&&_isCompletelyCovered!==void 0&&_isCompletelyCovered.get()?0:1};}"
+};
+export function useMainTabsChannelScreenStyles(a0, a1, a2, a3, a4) {
+  let animatedStyle;
+  const styles = useStyles();
+  const elevation = styles.elevation;
+  const c = function c() {
+    if (a4 != null) {
+      a4.get();
+    }
+    let r8 = a0.get();
+    if (!r8) {
+      r8 = a1.get() !== 0 && a1.get() !== a2;
+    }
+    const r23 = {
+      transform: [{
+        translateX: a1.get()
+      }],
+      shadowOpacity: r8 ? elevation.shadowOpacity : 0,
+      elevation: r8 ? elevation.elevation : 0,
+      opacity: null
+    };
+    r23.opacity = (a3 == null ? void 0 : a3.get()) ? 0 : 1;
+    return r23;
+  };
+  c.__closure = {
+    freezeValue: a4,
+    isDragging: a0,
+    translateX: a1,
+    maxWidth: a2,
+    elevationStyle: elevation,
+    isCompletelyCovered: a3
+  };
+  c.__workletHash = 16765484569296;
+  c.__initData = __initData;
+  animatedStyle = useAnimatedStyle(c);
+  return useMemo(() => [styles.elevation, animatedStyle], [styles, animatedStyle]);
+}

modules/main_tabs_v2/native/panels/useMainTabsPanelsGesture.tsx

@@ -0,0 +1,343 @@
+// Metro module 14920 (f14921).
+import { useRef, useCallback, useEffect, useContext, useMemo } from "react";
+import { LaunchPadTypes } from "../../../launchpad/native/LaunchPadConstants";
+import * as _PlatformUtils from "../../../../utils/PlatformUtils";
+import * as _PanelsConfig from "../../../panels/native/PanelsConfig";
+import { DEFAULT_PANELS_ANIMATION_CONFIG } from "../../../panels/native/PanelsConfig";
+import useLaunchPadType from "../../../launchpad/native/useLaunchPadType";
+import useSafeAreaInsets_native from "../../../safe_area/useSafeAreaInsets.native";
+import useWindowDimensions_native from "../../../screen/useWindowDimensions.native";
+import * as _ReanimatedRexport from "../../../reanimated/ReanimatedRexport";
+import { useSharedValue, runOnUI, useAnimatedReaction } from "../../../reanimated/ReanimatedRexport";
+import * as _timing from "../../../../design/animation/reanimated/timing/timing";
+import * as _timingPresets from "../../../../design/animation/reanimated/timing/timingPresets";
+import * as _spring from "../../../../design/animation/reanimated/spring/spring";
+import LaunchPadGestureRefContext from "../../../launchpad/native/LaunchPadGestureRefContext";
+import * as _Module5273 from "../../../../_bundle/Module5273";
+import { Gesture } from "../../../../_bundle/Module5273";
+const isAndroid = _PlatformUtils.isAndroid();
+const ANDROID_PANELS_ANIMATION_CONFIG = isAndroid ? _PanelsConfig.ANDROID_PANELS_ANIMATION_CONFIG : DEFAULT_PANELS_ANIMATION_CONFIG;
+const __initData = {
+  code: "function useMainTabsPanelsGestureTsx1(Width){const{isDragging,translateX,IS_ANDROID,withTiming,timingInstant}=this.__closure;if(isDragging.get())return;if(translateX.get()===0)return;translateX.set(IS_ANDROID?withTiming(Width,timingInstant,'animate-always'):Width);}"
+};
+const __initData2 = {
+  code: "function useMainTabsPanelsGestureTsx2(show,isFling,velocity,force){const{translateX,Width,onVisibilityChange,runOnJS,onPreMovement,panelsConfig,isTimingConfig,withTiming,withSpring}=this.__closure;if(!force&&translateX.get()!==0&&translateX.get()!==Width){return false;}const targetTranslationX=show?0:Width;if(translateX.get()===targetTranslationX){if(onVisibilityChange!=null){runOnJS(onVisibilityChange)(show);}return false;}if(onPreMovement!=null){runOnJS(onPreMovement)(show);}const animationConfig=show?isFling?panelsConfig.swipeSidePanelOpen:panelsConfig.nonSwipeSidePanelOpen:isFling?panelsConfig.swipeSidePanelClose:panelsConfig.nonSwipeSidePanelClose;function handleAnimationFinish(finished){'worklet';if(!finished)return;if(onVisibilityChange!=null){runOnJS(onVisibilityChange)(show);}}translateX.set(isTimingConfig(animationConfig)?withTiming(targetTranslationX,animationConfig,'respect-motion-settings',handleAnimationFinish):withSpring(targetTranslationX,{...animationConfig,velocity:velocity},'respect-motion-settings',handleAnimationFinish));return true;}"
+};
+const __initData3 = {
+  code: "function handleAnimationFinish_useMainTabsPanelsGestureTsx3(finished){const{onVisibilityChange,runOnJS,show}=this.__closure;if(!finished)return;if(onVisibilityChange!=null){runOnJS(onVisibilityChange)(show);}}"
+};
+const __initData4 = {
+  code: "function useMainTabsPanelsGestureTsx4(){const{disallowGesture}=this.__closure;return disallowGesture.get();}"
+};
+const __initData5 = {
+  code: "function useMainTabsPanelsGestureTsx5(currentDisallow,previousDisallow){const{didJustAllowGesture}=this.__closure;if(currentDisallow===previousDisallow)return;if(currentDisallow)return;didJustAllowGesture.set(true);}"
+};
+const __initData6 = {
+  code: "function useMainTabsPanelsGestureTsx6(e){const{isDragging,disallowGesture,didJustAllowGesture,runOnJS,setIsDraggingRef,panelsConfig,movePanel,translateX,Width}=this.__closure;try{if(!isDragging.get()||disallowGesture.get()||didJustAllowGesture.get()){return;}}finally{isDragging.set(false);didJustAllowGesture.set(false);runOnJS(setIsDraggingRef)(false);}if(Math.abs(e.velocityX)>panelsConfig.minFlingVelocityX){movePanel(e.velocityX<0,true,e.velocityX,true);}else{movePanel(translateX.get()<Width/2,false,e.velocityX,true);}}"
+};
+const __initData7 = {
+  code: "function useMainTabsPanelsGestureTsx7(e){const{disallowGesture,translateX,Width,didJustAllowGesture}=this.__closure;if(disallowGesture.get()){const currentTranslateX=translateX.get();if(currentTranslateX===0||currentTranslateX===Width){return;}translateX.set(0);return;}translateX.set(Math.max(0,Math.min(Width,translateX.get()+e.changeX)));didJustAllowGesture.set(false);}"
+};
+const __initData8 = {
+  code: "function useMainTabsPanelsGestureTsx8(){const{isDragging,runOnJS,setIsDraggingRef,onDragStart}=this.__closure;isDragging.set(true);runOnJS(setIsDraggingRef)(true);if(onDragStart!=null){runOnJS(onDragStart)();}}"
+};
+const __initData9 = {
+  code: "function useMainTabsPanelsGestureTsx9(event,manager){const{State,startPosition,GESTURE_MIN_DISTANCE,disallowGesture,translateX,cancelOnSwipeRightFromStart,Width,launchPadType,LaunchPadTypes,windowWidth,LAUNCHPAD_GESTURE_INSET}=this.__closure;if(event.state!==State.BEGAN)return;const touch=event.allTouches[0];if(touch==null)return;const xDiff=touch.x-startPosition.get().x;const xDiffAbs=Math.abs(xDiff);if(xDiffAbs<=GESTURE_MIN_DISTANCE)return;if(disallowGesture.get()){return;}const yDiffAbs=Math.abs(touch.y-startPosition.get().y);if(xDiffAbs<=yDiffAbs||xDiffAbs*xDiffAbs+yDiffAbs*yDiffAbs<GESTURE_MIN_DISTANCE*GESTURE_MIN_DISTANCE){return;}if(xDiff<=0){if(translateX.get()===0){manager.fail();return;}}else{if(cancelOnSwipeRightFromStart===true&&translateX.get()>=Width){manager.fail();return;}}const isGestureBasedLaunchPad=launchPadType===LaunchPadTypes.GESTURE_EDGE||launchPadType===LaunchPadTypes.GESTURE_FULL;if(isGestureBasedLaunchPad&&xDiff<0){const launchpadGestureEdge=windowWidth-LAUNCHPAD_GESTURE_INSET;if(launchPadType===LaunchPadTypes.GESTURE_FULL&&startPosition.get().x<launchpadGestureEdge||launchPadType===LaunchPadTypes.GESTURE_EDGE&&startPosition.get().x>=launchpadGestureEdge){manager.fail();return;}}manager.activate();}"
+};
+const __initData10 = {
+  code: "function useMainTabsPanelsGestureTsx10(event,manager){const{startPosition}=this.__closure;const touch=event.allTouches[0];if(touch==null)return;startPosition.set({x:touch.x,y:touch.y});manager.begin();}"
+};
+export default function useMainTabsPanelsGesture(a0) {
+  let sharedValue3, callback2, sharedValue4, sharedValue5, context, memo;
+  const { canDrag, onVisibilityChange, onDragStart, onPreMovement, startShown } = a0;
+  let openWidth = a0.openWidth;
+  const cancelOnSwipeRightFromStart = a0.cancelOnSwipeRightFromStart;
+  sharedValue3 = void 0;
+  callback2 = void 0;
+  sharedValue4 = void 0;
+  sharedValue5 = void 0;
+  context = void 0;
+  memo = void 0;
+  const launchPadType = useLaunchPadType();
+  const safeAreaInsets_native = useSafeAreaInsets_native();
+  let c21455_6 = safeAreaInsets_native;
+  const Width = useWindowDimensions_native().Width;
+  if (openWidth == null) {
+    openWidth = Width;
+  }
+  const width2 = openWidth;
+  const sharedValue = useSharedValue(startShown ? 0 : width2);
+  const sharedValue2 = useSharedValue(false);
+  const ref = useRef(false);
+  const callback = useCallback((a0) => {
+    ref.current = a0;
+  }, [ref]);
+  sharedValue3 = useSharedValue(false);
+  useEffect(() => {
+    const r11 = function e(a0) {
+      if (!sharedValue2.get() && sharedValue.get() !== 0) {
+        sharedValue.set(isAndroid ? _timing.withTiming(a0, _timingPresets.timingInstant, "animate-always") : a0);
+      }
+    };
+    r11.__closure = {
+      isDragging: sharedValue2,
+      translateX: sharedValue,
+      IS_ANDROID: isAndroid,
+      withTiming: _timing.withTiming,
+      timingInstant: _timingPresets.timingInstant
+    };
+    r11.__workletHash = 16976202846494;
+    r11.__initData = __initData;
+    runOnUI(r11)(width2);
+  }, [sharedValue2, sharedValue, width2]);
+  const R = function R(a0, a1, a2, a3) {
+    let c27856_0 = a0;
+    if (!a3 && sharedValue.get() !== 0 && sharedValue.get() !== width2) {
+      return false;
+    }
+    const r12 = a0 ? 0 : width2;
+    if (sharedValue.get() === r12) {
+      if (onVisibilityChange != null) {
+        _ReanimatedRexport.runOnJS(onVisibilityChange)(a0);
+      }
+      return false;
+    }
+    if (onPreMovement != null) {
+      _ReanimatedRexport.runOnJS(onPreMovement)(a0);
+    }
+    const r9 = a0 ? a1 ? ANDROID_PANELS_ANIMATION_CONFIG.swipeSidePanelOpen : ANDROID_PANELS_ANIMATION_CONFIG.nonSwipeSidePanelOpen : a1 ? ANDROID_PANELS_ANIMATION_CONFIG.swipeSidePanelClose : ANDROID_PANELS_ANIMATION_CONFIG.nonSwipeSidePanelClose;
+    const handleAnimationFinish = function handleAnimationFinish(a0) {
+      if (a0 ? onVisibilityChange != null : a0) {
+        _ReanimatedRexport.runOnJS(onVisibilityChange)(c27856_0);
+      }
+    };
+    handleAnimationFinish.__closure = {
+      onVisibilityChange,
+      runOnJS: _ReanimatedRexport.runOnJS,
+      show: a0
+    };
+    handleAnimationFinish.__workletHash = 1018878139815;
+    handleAnimationFinish.__initData = __initData3;
+    const isTimingConfig = _PanelsConfig.isTimingConfig(r9);
+    sharedValue.set(isTimingConfig ? _timing.withTiming(r12, r9, "respect-motion-settings", handleAnimationFinish) : _spring.withSpring(r12, {
+      ...r9,
+      velocity: a2
+    }, "respect-motion-settings", handleAnimationFinish));
+    return true;
+  };
+  R.__closure = {
+    translateX: sharedValue,
+    Width: width2,
+    onVisibilityChange,
+    runOnJS: _ReanimatedRexport.runOnJS,
+    onPreMovement,
+    panelsConfig: ANDROID_PANELS_ANIMATION_CONFIG,
+    isTimingConfig: _PanelsConfig.isTimingConfig,
+    withTiming: _timing.withTiming,
+    withSpring: _spring.withSpring
+  };
+  R.__workletHash = 4205680413964;
+  R.__initData = __initData2;
+  callback2 = useCallback(R, [onVisibilityChange, onPreMovement, sharedValue, width2]);
+  sharedValue4 = useSharedValue(false);
+  const U = () => sharedValue3.get();
+  U.__closure = {
+    disallowGesture: sharedValue3
+  };
+  U.__workletHash = 15338765161171;
+  U.__initData = __initData4;
+  const N = function N(a0, a1) {
+    if (a0 !== a1 && !a0) {
+      sharedValue4.set(true);
+    }
+  };
+  N.__closure = {
+    didJustAllowGesture: sharedValue4
+  };
+  N.__workletHash = 17048450187141;
+  N.__initData = __initData5;
+  useAnimatedReaction(U, N);
+  sharedValue5 = useSharedValue({
+    x: 0,
+    y: 0
+  });
+  context = useContext(LaunchPadGestureRefContext);
+  memo = useMemo(() => {
+    const r28 = Gesture.Pan().enabled(canDrag).requireExternalGestureToFail(context).manualActivation(_PlatformUtils.isAndroid());
+    const r39 = r28.hitSlop({
+      top: -c21455_6.top,
+      left: -c21455_6.left,
+      bottom: -c21455_6.bottom,
+      right: -c21455_6.right
+    });
+    const u = function u(a0, a1) {
+      const r5 = a0.allTouches[0];
+      if (r5 != null) {
+        sharedValue5.set({
+          x: r5.x,
+          y: r5.y
+        });
+        a1.begin();
+      }
+    };
+    u.__closure = {
+      startPosition: sharedValue5
+    };
+    u.__workletHash = 718728838752;
+    u.__initData = __initData10;
+    const r45 = r39.onTouchesDown(u);
+    const l = function l(a0, a1) {
+      if (a0.state === _Module5273.State.BEGAN) {
+        const r17 = a0.allTouches[0];
+        if (r17 != null) {
+          const r23 = r17.x - sharedValue5.get().x;
+          const r25 = Math.abs(r23);
+          if (!(r25 <= 12) && !sharedValue3.get()) {
+            const r35 = Math.abs(r17.y - sharedValue5.get().y);
+            if (!(r25 <= r35) && !(r25 * r25 + r35 * r35 < 144)) {
+              if (r23 <= 0) {
+                if (sharedValue.get() === 0) {
+                  a1.fail();
+                  return void 0;
+                }
+              } else if (cancelOnSwipeRightFromStart === true && sharedValue.get() >= width2) {
+                a1.fail();
+                return void 0;
+              }
+              L18: {
+                if (!(launchPadType !== LaunchPadTypes.GESTURE_EDGE && launchPadType !== LaunchPadTypes.GESTURE_FULL) && r23 < 0) {
+                  const r60 = Width - 48;
+                  if (!(launchPadType === LaunchPadTypes.GESTURE_FULL && sharedValue5.get().x < r60)) {
+                    if (launchPadType !== LaunchPadTypes.GESTURE_EDGE) {
+                      break L18;
+                    }
+                    if (!(sharedValue5.get().x >= r60)) {
+                      break L18;
+                    }
+                  }
+                  a1.fail();
+                  return void 0;
+                }
+              }
+              a1.activate();
+            }
+          }
+        }
+      }
+    };
+    l.__closure = {
+      State: _Module5273.State,
+      startPosition: sharedValue5,
+      GESTURE_MIN_DISTANCE: 12,
+      disallowGesture: sharedValue3,
+      translateX: sharedValue,
+      cancelOnSwipeRightFromStart,
+      Width: width2,
+      launchPadType,
+      LaunchPadTypes,
+      windowWidth: Width,
+      LAUNCHPAD_GESTURE_INSET: 48
+    };
+    l.__workletHash = 13108412336922;
+    l.__initData = __initData9;
+    const r58 = r45.onTouchesMove(l);
+    const r60 = function() {
+      sharedValue2.set(true);
+      _ReanimatedRexport.runOnJS(callback)(true);
+      if (onDragStart != null) {
+        _ReanimatedRexport.runOnJS(onDragStart)();
+      }
+    };
+    r60.__closure = {
+      isDragging: sharedValue2,
+      runOnJS: _ReanimatedRexport.runOnJS,
+      setIsDraggingRef: callback,
+      onDragStart
+    };
+    r60.__workletHash = 8659650895938;
+    r60.__initData = __initData8;
+    const r68 = r58.onStart(r60);
+    const n = function n(a0) {
+      L5: {
+        if (sharedValue3.get()) {
+          const r26 = sharedValue.get();
+          if (r26 !== 0 && r26 !== width2) {
+            sharedValue.set(0);
+            break L5;
+          }
+          return void 0;
+        }
+        sharedValue.set(Math.max(0, Math.min(width2, sharedValue.get() + a0.changeX)));
+        sharedValue4.set(false);
+      }
+    };
+    n.__closure = {
+      disallowGesture: sharedValue3,
+      translateX: sharedValue,
+      Width: width2,
+      didJustAllowGesture: sharedValue4
+    };
+    n.__workletHash = 13355779907583;
+    n.__initData = __initData7;
+    const r75 = r68.onChange(n);
+    const r77 = function e(a0) {
+      L8: {
+        try {
+          if (!sharedValue2.get()) {
+            break L8;
+          }
+          if (sharedValue3.get()) {
+            break L8;
+          }
+          if (sharedValue4.get()) {
+            break L8;
+          }
+        } catch (r77) {
+          sharedValue2.set(false);
+          sharedValue4.set(false);
+          _ReanimatedRexport.runOnJS(callback)(false);
+          throw r77;
+        }
+        sharedValue2.set(false);
+        sharedValue4.set(false);
+        _ReanimatedRexport.runOnJS(callback)(false);
+        if (Math.abs(a0.velocityX) > ANDROID_PANELS_ANIMATION_CONFIG.minFlingVelocityX) {
+          callback2(a0.velocityX < 0, true, a0.velocityX, true);
+        } else {
+          callback2(sharedValue.get() < width2 / 2, false, a0.velocityX, true);
+        }
+        return void 0;
+      }
+      sharedValue2.set(false);
+      sharedValue4.set(false);
+      _ReanimatedRexport.runOnJS(callback)(false);
+    };
+    r77.__closure = {
+      isDragging: sharedValue2,
+      disallowGesture: sharedValue3,
+      didJustAllowGesture: sharedValue4,
+      runOnJS: _ReanimatedRexport.runOnJS,
+      setIsDraggingRef: callback,
+      panelsConfig: ANDROID_PANELS_ANIMATION_CONFIG,
+      movePanel: callback2,
+      translateX: sharedValue,
+      Width: width2
+    };
+    r77.__workletHash = 2071301756262;
+    r77.__initData = __initData6;
+    return r75.onFinalize(r77);
+  }, [safeAreaInsets_native, sharedValue, width2, Width, sharedValue2, callback2, onDragStart, canDrag, sharedValue5, launchPadType, cancelOnSwipeRightFromStart, sharedValue3, callback, context, sharedValue4]);
+  return {
+    gesture: memo,
+    panelGestureContext: useMemo(() => ({
+      gesture: memo,
+      disallowGesture: sharedValue3,
+      translateX: sharedValue
+    }), [memo, sharedValue3, sharedValue]),
+    isDragging: sharedValue2,
+    translateX: sharedValue,
+    movePanel: callback2,
+    maxWidth: width2,
+    isDraggingRef: ref
+  };
+};