yeet

2026-11-01 12:12:55 +02:00
1 parent 1781d25a15
commit 732c0ad767
@@ -0,0 +1,77 @@
+// Metro module 1843 (f1844).
+import Logger from "../debug/Logger";
+import { isIOS } from "../../_bundle/Module501";
+let c1555_2 = new Logger("KeyboardStateDebugging");
+const r22 = {
+  channelSafeAreaBottomLayoutHeightChanged: (a0) => {
+    if (!isIOS()) {
+      c1555_2.info("ChannelSafeAreaBottom layout height changed.", {
+        layoutHeight: a0
+      });
+    }
+  },
+  channelSafeAreaBottomLayoutHeightMismatch: (a0, a1) => {
+    if (!isIOS()) {
+      c1555_2.warn("ChannelSafeAreaBottom layout height mismatch.", {
+        layoutHeight: a0,
+        reportedKeyboardHeight: a1
+      });
+    }
+  },
+  keyboardControllerKeyboardWillShow: (a0) => {
+    if (!isIOS()) {
+      c1555_2.info("KeyboardController keyboardWillShow.", {
+        height: a0
+      });
+    }
+  },
+  keyboardControllerKeyboardDidShow: function keyboardControllerKeyboardDidShow(a0, rootProvider = false) {
+    if (!isIOS()) {
+      c1555_2.info("KeyboardController keyboardDidShow.", {
+        height: a0,
+        rootProvider
+      });
+    }
+  },
+  keyboardControllerWorkletEvent: function keyboardControllerWorkletEvent(a0, a1, rootProvider = false) {
+    if (!isIOS()) {
+      c1555_2.info(`KeyboardController worklet ${a0}.`, {
+        height: a1,
+        rootProvider
+      });
+    }
+  },
+  keyboardControllerKeyboardWillHide: () => {
+    if (!isIOS()) {
+      c1555_2.info("KeyboardController keyboardWillHide.");
+    }
+  },
+  keyboardControllerKeyboardDidHide: function keyboardControllerKeyboardDidHide(rootProvider = false) {
+    if (!isIOS()) {
+      c1555_2.info("KeyboardController keyboardDidHide.", {
+        rootProvider
+      });
+    }
+  },
+  reactNativeKeyboardDidShow: (a0, a1) => {
+    if (!isIOS()) {
+      c1555_2.info("ReactNativeKeyboard didShow.", {
+        height: a0,
+        location: a1
+      });
+    }
+  },
+  reactNativeKeyboardDidHide: (a0) => {
+    if (!isIOS()) {
+      c1555_2.info("ReactNativeKeyboard didHide.", {
+        location: a0
+      });
+    }
+  },
+  markPotentialBadState: () => {
+    if (!isIOS()) {
+      c1555_2.warn("Marking potential bad state from user, check logs above.");
+    }
+  }
+};
+export default r22;
@@ -0,0 +1,22 @@
+// Metro module 10419 (f10420).
+import { createApexExperiment } from "../../experiments/apex/index";
+import { isAndroid } from "../../../utils/PlatformUtils";
+const apexExperiment = createApexExperiment({
+  name: "2025-08-animated-keyboard-android",
+  kind: "user",
+  defaultConfig: {
+    enabled: false
+  },
+  variations: {
+    1: {
+      enabled: true
+    }
+  }
+});
+const enabled = apexExperiment.getConfig({
+  location: "isAnimatedKeyboardEnabled"
+}).enabled;
+export { apexExperiment as AnimatedKeyboardExperiment };
+export function isAnimatedAndroidKeyboard() {
+  return !!isAndroid() && enabled;
+}
@@ -0,0 +1,5 @@
+// Metro module 10385 (f10386).
+import Module1593 from "../../../_bundle/Module1593";
+import AnimatedKeyboardProviderController from "./AnimatedKeyboardProviderController";
+Module1593.setNavigationBarContrastEnforced(false);
+export default AnimatedKeyboardProviderController;
@@ -0,0 +1,63 @@
+// Metro module 10386 (f10387).
+import { memo } from "react";
+import * as _ReanimatedRexport from "../../reanimated/ReanimatedRexport";
+import { makeMutable } from "../../reanimated/ReanimatedRexport";
+import { useKeyboardHandler, KeyboardProvider } from "../../../_bundle/Module1595";
+const animatedKeyboardHeight = makeMutable(0);
+const animatedKeyboardState = makeMutable(_ReanimatedRexport.KeyboardState.UNKNOWN);
+const __initData = {
+  code: "function AnimatedKeyboardProviderControllerTsx1(e){const{animatedKeyboardState,KeyboardState}=this.__closure;animatedKeyboardState.set(e.height===0?KeyboardState.CLOSED:KeyboardState.OPEN);}"
+};
+const __initData2 = {
+  code: "function AnimatedKeyboardProviderControllerTsx2(e){const{animatedKeyboardHeight}=this.__closure;animatedKeyboardHeight.set(e.height);}"
+};
+const __initData3 = {
+  code: "function AnimatedKeyboardProviderControllerTsx3(e){const{animatedKeyboardState,KeyboardState,animatedKeyboardHeight}=this.__closure;animatedKeyboardState.set(e.height===0?KeyboardState.CLOSED:KeyboardState.OPEN);animatedKeyboardHeight.set(e.height);}"
+};
+let Component2 = memo(function() {
+  const onStart = function(a0) {
+    animatedKeyboardState.set(a0.height === 0 ? _ReanimatedRexport.KeyboardState.CLOSED : _ReanimatedRexport.KeyboardState.OPEN);
+  };
+  onStart.__closure = {
+    animatedKeyboardState,
+    KeyboardState: _ReanimatedRexport.KeyboardState
+  };
+  onStart.__workletHash = 12130162639136;
+  onStart.__initData = __initData;
+  const t = function t(a0) {
+    animatedKeyboardHeight.set(a0.height);
+  };
+  t.__closure = {
+    animatedKeyboardHeight
+  };
+  t.__workletHash = 1398293011995;
+  t.__initData = __initData2;
+  const e = function e(a0) {
+    animatedKeyboardState.set(a0.height === 0 ? _ReanimatedRexport.KeyboardState.CLOSED : _ReanimatedRexport.KeyboardState.OPEN);
+    animatedKeyboardHeight.set(a0.height);
+  };
+  e.__closure = {
+    animatedKeyboardState,
+    KeyboardState: _ReanimatedRexport.KeyboardState,
+    animatedKeyboardHeight
+  };
+  e.__workletHash = 10688534401196;
+  e.__initData = __initData3;
+  useKeyboardHandler({
+    onStart,
+    onMove: t,
+    onEnd: e
+  }, []);
+  return null;
+});
+const r38 = {
+  Component: function Component(props) {
+    return <KeyboardProvider enabled navigationBarTranslucent preserveEdgeToEdge statusBarTranslucent>
+      {props.children}
+      <Component2 />
+    </KeyboardProvider>;
+  },
+  animatedKeyboardHeight,
+  animatedKeyboardState
+};
+export default r38;
@@ -0,0 +1,8 @@
+// Metro module 1580 (f1581).
+let c1260_0 = false;
+export function setIsAnyChatInputFocused(a0) {
+  c1260_0 = a0;
+}
+export function getIsAnyChatInputFocused() {
+  return c1260_0;
+}
@@ -0,0 +1,53 @@
+// Metro module 13627 (f13628).
+import { createContext, useState, useCallback, useMemo, useContext, useEffect } from "react";
+import { createStyles } from "../../../design/components/Styles/native/createStyles";
+import Module13628 from "../../../_bundle/Module13628";
+const useStyles = createStyles({
+  viewDefaults: {
+    flex: 1
+  }
+});
+const context = createContext({
+  keyCommands: [],
+  addKeyCommand: () => {},
+  removeKeyCommand: () => {}
+});
+export default function KeyCommandsView(props) {
+  let callback2;
+  const { style, ...props2 } = props;
+  callback2 = void 0;
+  const styles = useStyles();
+  const [state, setState] = useState([]);
+  const callback = useCallback((c27543_0) => {
+    setState((prevState) => [...prevState, c27543_0]);
+  }, []);
+  callback2 = useCallback((c27544_0) => {
+    setState((prevState) => prevState.filter((item) => item.eventName !== c27544_0));
+  }, []);
+  return <context.Provider value={useMemo(() => ({
+    keyCommands: state,
+    addKeyCommand: callback,
+    removeKeyCommand: callback2
+  }), [state, callback, callback2])}>
+    <Module13628 {...props2} style={[styles.viewDefaults, style]} keyCommands={state} onKeyCommand={({ nativeEvent }) => {
+      const r8 = state.find((item) => item.eventName === nativeEvent.eventName);
+      if (r8 != null) {
+        r8.onKeyCommand(nativeEvent);
+      }
+    }} />
+  </context.Provider>;
+};
+export function useKeyCommands(a0) {
+  const context2 = useContext(context);
+  const { addKeyCommand: addKeyCommand2, removeKeyCommand: removeKeyCommand2 } = context2;
+  useEffect(() => {
+    for (const item of a0) {
+      addKeyCommand2(item);
+    }
+    return () => {
+      for (const item of a0) {
+        removeKeyCommand2(item.eventName);
+      }
+    };
+  }, [addKeyCommand2, removeKeyCommand2, a0]);
+}
@@ -0,0 +1,67 @@
+// Metro module 5638 (f5639).
+import { memo, useRef, useState, useEffect, useMemo } from "react";
+import { StyleSheet, View } from "react-native";
+import subscribeToKeyboardUIStore from "./subscribeToKeyboardUIStore";
+import { getSystemKeyboardHeight } from "./useSystemKeyboardHeight.native";
+import { getKeyboardType } from "./useKeyboardType";
+import { KeyboardTypes } from "./KeyboardTypes";
+import { getCustomKeyboardHeight } from "./useCustomKeyboardHeight";
+import { getKeyboardDuration } from "./useKeyboardDuration";
+import { DeprecatedLayoutAnimationKeyboard } from "../../animations/native/DeprecatedLayoutAnimation";
+const r28 = memo(function KeyboardAwareView(props) {
+  let ref2;
+  const { style, children, pointerEvents, animated = true } = props;
+  let c14956_1 = animated;
+  let keyboardHeightOffset = props.keyboardHeightOffset;
+  if (keyboardHeightOffset === void 0) {
+    keyboardHeightOffset = 0;
+  }
+  let c14956_2 = keyboardHeightOffset;
+  ref2 = void 0;
+  const r14 = Math;
+  let r23 = getSystemKeyboardHeight();
+  if (r23 === 0) {
+    r23 = getKeyboardType() !== KeyboardTypes.SYSTEM ? getCustomKeyboardHeight() : 0;
+  }
+  const ref = useRef(r14.max(0, r23 + keyboardHeightOffset));
+  const [state, setState] = useState(ref.current);
+  useEffect(() => subscribeToKeyboardUIStore(function() {
+    const r5 = Math;
+    let r15 = getSystemKeyboardHeight();
+    if (r15 === 0) {
+      r15 = getKeyboardType() !== KeyboardTypes.SYSTEM ? getCustomKeyboardHeight() : 0;
+    }
+    const current = r5.max(0, r15 + c14956_2);
+    if (ref.current !== current) {
+      ref.current = current;
+      setState(current);
+    }
+  }), [keyboardHeightOffset]);
+  ref2 = useRef(false);
+  useEffect(() => {
+    if (ref2.current) {
+      const keyboardDuration = getKeyboardDuration();
+      if (c14956_1 && keyboardDuration > 0) {
+        DeprecatedLayoutAnimationKeyboard(keyboardDuration);
+      }
+    } else {
+      ref2.current = true;
+    }
+  }, [animated, state]);
+  return <View style={useMemo(() => {
+    if (style == null) {
+      return {
+        marginBottom: state
+      };
+    }
+    const r9 = StyleSheet.flatten(style);
+    return typeof r9.marginBottom === "number" ? {
+      ...r9,
+      marginBottom: r9.marginBottom + state
+    } : {
+      ...r9,
+      marginBottom: state
+    };
+  }, [state, style])} pointerEvents={pointerEvents}>{children}</View>;
+});
+export default r28;
@@ -0,0 +1,8 @@
+// Metro module 1579 (f1580).
+const r8 = {
+  SYSTEM: "system",
+  EXPRESSION: "expression",
+  MEDIA: "media",
+  APP_LAUNCHER: "app_launcher"
+};
+export { r8 as KeyboardTypes };
@@ -0,0 +1,290 @@
+// Metro module 1478 (f1479).
+import { AppLauncherRouteName } from "../../app_launcher/native/AppLauncherNativeConstants";
+import { ExpressionPickerViewType } from "../../expression_picker/ExpressionPickerConstants";
+import { MediaKeyboardTarget } from "../../media_keyboard/native/MediaKeyboardConstants";
+import { Storage } from "../../../_bundle/Module595";
+import { KeyboardTypes } from "./KeyboardTypes";
+import { getIsAnyChatInputFocused } from "./ChatInputFocused";
+import { getSafeAreaInsets } from "../../safe_area/useSafeAreaInsets.native";
+import { isAndroid } from "../../../utils/PlatformUtils";
+import Module1593 from "../../../_bundle/Module1593";
+import shallowEqual from "../../../_bundle/shallowEqual";
+import { batchUpdates } from "../../../_bundle/Module705";
+import { create } from "../../../_bundle/Module644";
+import { KeyboardEvents } from "../../../_bundle/Module1595";
+import KeyboardStateDebugging from "../KeyboardStateDebugging";
+import { onKeyboardChanged } from "../../../utils/native/KeyboardManagerUtils";
+import SafeAreaStore_native from "../../safe_area/SafeAreaStore.native";
+import * as _AppEntryKeyContext from "../../window/native/AppEntryKeyContext";
+function $mk69263($env) {
+  return () => $env.$parent[11].setState($mk102222($env));
+}
+function $mk102222($env) {
+  return (a0) => {
+    let r26, r31;
+    const r9 = $env;
+    const r3 = r9[1];
+    if (r3 != null) {
+      r31 = [r3];
+    } else {
+      const r27 = $env.$parent;
+      r31 = (0, r27[0])(r27[2][11]).APP_ENTRY_KEYS;
+    }
+    let r33 = a0;
+    let byAppEntry = a0.byAppEntry;
+    let r35 = r31[Symbol.iterator]();
+    const next = r35.next;
+    const r4 = $env.$parent;
+    while (true) {
+      const r13 = r35 === void 0 ? void 0 : (r26 = next.call(r35)).done ? r35 = void 0 : r26.value;
+      if (r35 === void 0) {
+        if (byAppEntry !== a0.byAppEntry) {
+          r33 = {
+            byAppEntry
+          };
+        }
+        return r33;
+      }
+      try {
+        const r11 = byAppEntry[r13];
+        const r42 = (0, r4[9])(r11, r9[0], r13);
+        if (r11 !== r42) {
+          const r44 = {
+            ...byAppEntry
+          };
+          r44[r13] = r42;
+          byAppEntry = r44;
+        }
+      } catch (r48) {
+        if (r35 !== void 0 && typeof r35.return === "function") {
+          try {
+            r35.return();
+          } catch {}
+        }
+        throw r48;
+      }
+    }
+  };
+}
+let createInitialEntryState, c1194_6, c1194_7, c1194_8, c1194_11;
+let env1194 = {};
+const computeEntryState = function computeEntryState(a0, a1, a2) {
+  let customKeyboardHeight, customKeyboardHeightExcludingSafeAreaInsets, keyboardContexts2, systemKeyboardOpen;
+  let r7 = a0;
+  let keyboardDuration = a1.keyboardDuration;
+  if (keyboardDuration == null) {
+    keyboardDuration = a0.keyboardDuration;
+  }
+  let keyboardHeight = a1.keyboardHeight;
+  if (keyboardHeight == null) {
+    keyboardHeight = a0.keyboardHeight;
+  }
+  const keyboardHeight3 = isAndroid() ? Module1593.getImeInsets(false, a2) : keyboardHeight !== 0 ? keyboardHeight - 0 : 0;
+  let keyboardHeight2 = a1.keyboardHeight;
+  if (keyboardHeight2 == null) {
+    keyboardHeight2 = a0.keyboardHeight;
+  }
+  const keyboardHeightExcludingSafeAreaInsets = isAndroid() ? Module1593.getImeInsets(true, a2) : keyboardHeight2 !== 0 ? keyboardHeight2 - getSafeAreaInsets(a2).bottom : 0;
+  let keyboardType = a1.keyboardType?.type;
+  if (keyboardType == null) {
+    keyboardType = a0.keyboardType;
+  }
+  const keyboardTypePrevious = keyboardType !== a0.keyboardType ? a0.keyboardType : a0.keyboardTypePrevious;
+  let r55 = Storage.get(c1194_6, 253);
+  if (r55 == null) {
+    r55 = 253;
+  }
+  if (keyboardType === KeyboardTypes.SYSTEM && (keyboardHeight3 !== 0 && getIsAnyChatInputFocused())) {
+    const r67 = Math.max(keyboardHeight3, 200);
+    if (r67 !== r55) {
+      Storage.set(c1194_6, r67);
+    }
+    customKeyboardHeight = r67 - 0;
+  } else {
+    customKeyboardHeight = r55 - 0;
+  }
+  let r78 = Storage.get(c1194_6, 253);
+  if (r78 == null) {
+    r78 = 253;
+  }
+  if (keyboardType === KeyboardTypes.SYSTEM && (keyboardHeight3 !== 0 && getIsAnyChatInputFocused())) {
+    const r92 = Math.max(keyboardHeight3, 200);
+    if (r92 !== r78) {
+      Storage.set(c1194_6, r92);
+    }
+    customKeyboardHeightExcludingSafeAreaInsets = r92 - getSafeAreaInsets(a2).bottom;
+  } else {
+    customKeyboardHeightExcludingSafeAreaInsets = r78 - getSafeAreaInsets(a2).bottom;
+  }
+  const r110 = a0.keyboardContexts[keyboardType];
+  let r113 = a1.keyboardType?.context;
+  if (r113 == null) {
+    r113 = r110;
+  }
+  const r114 = typeof r110 === "object" && typeof r113 === "object" ? !shallowEqual(r110, r113) : r110 !== r113;
+  if (isAndroid()) {
+    systemKeyboardOpen = keyboardHeight3 > 0;
+  } else {
+    systemKeyboardOpen = a1.systemKeyboardOpen;
+    if (systemKeyboardOpen == null) {
+      systemKeyboardOpen = a0.systemKeyboardOpen;
+    }
+  }
+  if (a0.keyboardContexts[KeyboardTypes.SYSTEM].keyboardWillOpen && a1.systemKeyboardOpen != null) {
+    const r137 = {
+      ...a0.keyboardContexts
+    };
+    r137[KeyboardTypes.SYSTEM] = {
+      ...a0.keyboardContexts[KeyboardTypes.SYSTEM],
+      keyboardWillOpen: false
+    };
+    keyboardContexts2 = r137;
+  } else {
+    const keyboardContexts = a0.keyboardContexts;
+    if (r114) {
+      const r135 = {
+        ...keyboardContexts
+      };
+      r135[keyboardType] = r113;
+      keyboardContexts2 = r135;
+    } else {
+      keyboardContexts2 = keyboardContexts;
+    }
+  }
+  const r158 = shallowEqual(a0.keyboardContexts, keyboardContexts2);
+  if (!(a0.keyboardDuration === keyboardDuration && (r158 && (a0.keyboardHeight === keyboardHeight3 && (a0.keyboardHeightExcludingSafeAreaInsets === keyboardHeightExcludingSafeAreaInsets && (a0.keyboardType === keyboardType && (a0.customKeyboardHeight === customKeyboardHeight && (a0.customKeyboardHeightExcludingSafeAreaInsets === customKeyboardHeightExcludingSafeAreaInsets && a0.systemKeyboardOpen === systemKeyboardOpen)))))))) {
+    r7 = {
+      keyboardContexts: keyboardContexts2,
+      keyboardDuration,
+      keyboardHeight: keyboardHeight3,
+      keyboardHeightExcludingSafeAreaInsets,
+      systemKeyboardOpen,
+      keyboardType,
+      keyboardTypePrevious,
+      customKeyboardHeight,
+      customKeyboardHeightExcludingSafeAreaInsets
+    };
+  }
+  return r7;
+};
+createInitialEntryState = function createInitialEntryState(a0) {
+  KeyboardTypes.SYSTEM;
+  let r9 = Storage.get(c1194_6, 253);
+  if (r9 == null) {
+    r9 = 253;
+  }
+  KeyboardTypes.SYSTEM;
+  KeyboardTypes.SYSTEM;
+  let r33 = Storage.get(c1194_6, 253);
+  if (r33 == null) {
+    r33 = 253;
+  }
+  KeyboardTypes.SYSTEM;
+  const r25 = {
+    customKeyboardHeight: r9 - 0,
+    customKeyboardHeightExcludingSafeAreaInsets: r33 - getSafeAreaInsets(a0).bottom,
+    keyboardContexts: null,
+    keyboardDuration: 0,
+    keyboardHeight: null,
+    keyboardHeightExcludingSafeAreaInsets: null,
+    systemKeyboardOpen: false,
+    keyboardType: null,
+    keyboardTypePrevious: null
+  };
+  const keyboardContexts = {};
+  keyboardContexts[KeyboardTypes.SYSTEM] = {
+    keyboardWillOpen: false
+  };
+  keyboardContexts[KeyboardTypes.EXPRESSION] = ExpressionPickerViewType.EMOJI;
+  keyboardContexts[KeyboardTypes.MEDIA] = {
+    target: MediaKeyboardTarget.CHAT
+  };
+  keyboardContexts[KeyboardTypes.APP_LAUNCHER] = {
+    initialRouteName: AppLauncherRouteName.HOME
+  };
+  r25.keyboardContexts = keyboardContexts;
+  r25.keyboardHeight = isAndroid() ? Module1593.getImeInsets(false, a0) : 0;
+  r25.keyboardHeightExcludingSafeAreaInsets = isAndroid() ? Module1593.getImeInsets(true, a0) : 0;
+  r25.keyboardType = KeyboardTypes.SYSTEM;
+  r25.keyboardTypePrevious = KeyboardTypes.SYSTEM;
+  return r25;
+};
+c1194_6 = "customKeyboardHeight";
+c1194_7 = new Set();
+c1194_8 = new Set();
+const r11 = isAndroid() ? "keyboardDidShow" : "keyboardWillShow";
+const r46 = isAndroid() ? "keyboardDidHide" : "keyboardWillHide";
+c1194_11 = create(() => ({
+  byAppEntry: {
+    main: createInitialEntryState("main"),
+    share: createInitialEntryState("share")
+  }
+}));
+KeyboardEvents.addListener(r11, ({ duration, height }) => {
+  let env13053;
+  KeyboardStateDebugging.reactNativeKeyboardDidShow(height, "KeyboardUIStore");
+  const r13 = {
+    keyboardHeight: height,
+    keyboardDuration: duration,
+    systemKeyboardOpen: true
+  };
+  const r14 = env13053 = {
+    $parent: env1194
+  };
+  env13053[0] = r13;
+  env13053[1] = void 0;
+  batchUpdates($mk69263(r14));
+  onKeyboardChanged(true);
+  c1194_8.forEach((item) => item(false));
+});
+KeyboardEvents.addListener(r46, () => {
+  let env13054;
+  KeyboardStateDebugging.reactNativeKeyboardDidHide("KeyboardUIStore");
+  const r11 = env13054 = {
+    $parent: env1194
+  };
+  env13054[0] = {
+    keyboardHeight: 0,
+    systemKeyboardOpen: false
+  };
+  env13054[1] = void 0;
+  batchUpdates($mk69263(r11));
+  onKeyboardChanged(false);
+  c1194_8.forEach((item) => item(false));
+});
+SafeAreaStore_native.subscribe(() => {
+  let env13055;
+  const r1 = env13055 = {
+    $parent: env1194
+  };
+  env13055[0] = {};
+  batchUpdates($mk69263(r1));
+});
+export default c1194_11;
+export function setKeyboardType(a0) {
+  let r3 = arguments[1];
+  if (r3 === void 0) {
+    r3 = _AppEntryKeyContext.DEFAULT_APP_ENTRY_KEY;
+  }
+  let env13057;
+  const DEFAULT_APP_ENTRY_KEY = r3;
+  c1194_7.forEach((item) => item(a0, DEFAULT_APP_ENTRY_KEY));
+  c1194_8.forEach((item) => item(a0.type === KeyboardTypes.SYSTEM && a0.context?.keyboardWillOpen === true, DEFAULT_APP_ENTRY_KEY));
+  const r17 = {
+    keyboardType: a0
+  };
+  const r18 = env13057 = {
+    $parent: env1194
+  };
+  env13057[0] = r17;
+  env13057[1] = DEFAULT_APP_ENTRY_KEY;
+  batchUpdates($mk69263(r18));
+}
+export function addKeyboardWillOpenChangedListener(a0) {
+  c1194_8.add(a0);
+  return () => c1194_8.delete(a0);
+}
+export function addKeyboardTypeChangedListener(a0) {
+  c1194_7.add(a0);
+  return () => c1194_7.delete(a0);
+}
@@ -0,0 +1,29 @@
+// Metro module 4059 (f4060).
+import { useIsModalOpen } from "../../main_tabs_v2/helpers/NavigationRouteUtils.native";
+import { isIOS } from "../../../utils/PlatformUtils";
+import { Portal, PortalHost } from "../../../_bundle/Module4060";
+const r17 = {
+  EMPTY: "empty",
+  REQUEST_OPEN: "request_open",
+  OPENING: "opening",
+  OPEN: "open",
+  REQUEST_CLOSE: "request_close",
+  CLOSING: "closing",
+  CLOSED: "closed"
+};
+const name = "default";
+const hostName = "modal";
+export { r17 as PortalKeyboardState };
+export const PORTAL_HOST_NAME_DEFAULT = "default";
+export const PORTAL_HOST_NAME_MODAL = "modal";
+export function PortalKeyboard(props) {
+  const children = props.children;
+  return <Portal hostName={useIsModalOpen() && isIOS() ? hostName : name}>{children}</Portal>;
+}
+export function PortalKeyboardHost(props) {
+  let name2 = props.name;
+  if (name2 === void 0) {
+    name2 = name;
+  }
+  return <PortalHost name={name2} />;
+}
@@ -0,0 +1,308 @@
+// Metro module 11253 (f11254).
+import { forwardRef, useRef, useLayoutEffect, useCallback, useState } from "react";
+import { View, Platform } from "react-native";
+import NativeMenuStore from "../../native_menu/native/NativeMenuStore";
+import * as _PlatformUtils from "../../../utils/PlatformUtils";
+import { isAndroid } from "../../../utils/PlatformUtils";
+import { createStyles } from "../../../design/components/Styles/native/createStyles";
+import Module712 from "../../../_bundle/Module712";
+import { ActionSheetDragHandle, ACTION_SHEET_DRAG_HANDLE_HEIGHT } from "../../../design/components/experimental/native";
+import { useIsScreenReaderEnabled } from "../../a11y/native/useIsScreenReaderEnabled.native";
+import * as _ReanimatedRexport from "../../reanimated/ReanimatedRexport";
+import ReanimatedRexport, { useDerivedValue, useAnimatedReaction, useAnimatedStyle } from "../../reanimated/ReanimatedRexport";
+import { useMobileVisualRefreshConfig } from "../../themes/experiments/MobileVisualRefreshExperiment";
+import useCustomKeyboardBottomSheetConfig from "../../action_sheet/native/useCustomKeyboardBottomSheetConfig";
+import { TransitionStates } from "../../../design/components/TransitionGroup/TransitionGroup";
+import { useBottomSheetImperativeHandle } from "../../../design/components/Sheet/native/BottomSheetHandle";
+import { useStateFromStores } from "../../../_bundle/Module589";
+import Module5245, { ANIMATION_SOURCE, BottomSheetBackdrop, BottomSheetFooter } from "../../../_bundle/Module5245";
+import { triggerHapticFeedback, HapticFeedbackTypes } from "../../haptics/HapticUtils.native";
+import { isChannelFocused } from "../../panels/isChannelFocused.native";
+import * as _KeyboardManagerUtils from "../../../utils/native/KeyboardManagerUtils";
+import useMountEffect from "../../../hooks/useMountEffect";
+import { useToken } from "../../../design/tokens/native/useToken";
+import useSafeAreaInsets_native from "../../safe_area/useSafeAreaInsets.native";
+import useWindowDimensions_native from "../../screen/useWindowDimensions.native";
+import { PortalHost } from "../../../_bundle/Module4060";
+import useColorThemeBackground from "../../client_themes/native/useColorThemeBackground";
+import { ThemeContextProvider } from "../../../_bundle/Module3901";
+import { AccessibilityViewAnimated } from "../../../design/components/AccessibilityView/AccessibilityView.native";
+import PortalKeyboardFooterIOS_ios from "./PortalKeyboardFooterIOS.ios";
+import { NavScrim } from "../../../design/components/Navigator/native/NavScrim.android";
+let isIOS, useStyles, PortalKeyboardBackground, __initData, __initData2, __initData3, __initData4, __initData5, __initData6;
+const PortalKeyboardBottomSheetHeader = function PortalKeyboardBottomSheetHeader(props) {
+  const { style, handleCollapse: handleCollapse2 } = props;
+  const styles = useStyles();
+  return <View style={[styles.headerContainer, useIsScreenReaderEnabled() ? styles.headerContainerScreenReaderEnabled : void 0, style]}>
+    <ActionSheetDragHandle onPress={handleCollapse2} />
+  </View>;
+};
+PortalKeyboardBackground = function PortalKeyboardBackground(props) {
+  const { pointerEvents, style, roundingStyle } = props;
+  return <ReanimatedRexport.View pointerEvents={pointerEvents} style={[style, useStyles().background, roundingStyle]} />;
+};
+Platform;
+isIOS = _PlatformUtils.isIOS();
+useStyles = createStyles({
+  container: {
+    position: "absolute",
+    top: 0,
+    left: 0
+  },
+  background: {
+    backgroundColor: Module712.colors.MOBILE_KEYBOARD_PANEL_BACKGROUND,
+    overflow: "hidden"
+  },
+  headerContainer: {
+    borderTopLeftRadius: Module712.radii.none,
+    borderTopRightRadius: Module712.radii.none,
+    width: "100%",
+    height: ACTION_SHEET_DRAG_HANDLE_HEIGHT,
+    marginBottom: -ACTION_SHEET_DRAG_HANDLE_HEIGHT
+  },
+  headerContainerScreenReaderEnabled: {
+    marginBottom: -Module712.space.PX_8
+  },
+  roundingView: {
+    overflow: "hidden",
+    display: "flex"
+  }
+});
+__initData = {
+  code: "function PortalKeyboardBottomSheetTsx1(){const{animatedIndex}=this.__closure;return animatedIndex.get()>0.975;}"
+};
+__initData2 = {
+  code: "function PortalKeyboardBottomSheetTsx2(){const{isFullyExpanded}=this.__closure;return isFullyExpanded.get();}"
+};
+__initData3 = {
+  code: "function PortalKeyboardBottomSheetTsx3(isFullyExpanded,isFullExpandedPrevious){const{forceMaxHeight,runOnJS,dismissGlobalKeyboard}=this.__closure;if(isFullExpandedPrevious==null){return;}if(!isFullyExpanded&&!forceMaxHeight){runOnJS(dismissGlobalKeyboard)();}}"
+};
+__initData4 = {
+  code: "function PortalKeyboardBottomSheetTsx4(){const{interpolate,animatedIndex,cornerRadiusInputStart,cornerRadiusInputEnd,cornerRadius}=this.__closure;return{borderTopLeftRadius:interpolate(animatedIndex.get(),[cornerRadiusInputStart,cornerRadiusInputEnd],[0,cornerRadius],'clamp'),borderTopRightRadius:interpolate(animatedIndex.get(),[cornerRadiusInputStart,cornerRadiusInputEnd],[0,cornerRadius],'clamp')};}"
+};
+__initData5 = {
+  code: "function PortalKeyboardBottomSheetTsx5(){const{animatedIndex}=this.__closure;return Math.max(animatedIndex.get(),0)>0;}"
+};
+__initData6 = {
+  code: "function PortalKeyboardBottomSheetTsx6(result,previous){const{runOnJS,setAccessibilityViewIsModal}=this.__closure;if(result===previous)return;runOnJS(setAccessibilityViewIsModal)(result);}"
+};
+const r75 = forwardRef(function PortalKeyboardBottomSheet(props, a1) {
+  let isScreenReaderEnabled, derivedValue, token, c18683_13, c18683_14, animatedStyle, setState;
+  const { animatedIndex, animatedPosition, chatInputRef, children, isAppsKeyboard = false } = props;
+  let c18683_2 = isAppsKeyboard;
+  const { animationConfigs, onClose, transitionState } = props;
+  let backdropComponent = props.backdropComponent;
+  const { headerStyle, disableHeaderRoundingAnimation, roundingViewStyle, onAnimate, rendersHandle = true } = props;
+  let c18683_6 = rendersHandle;
+  let width2 = props.width;
+  let forceMaxHeight = props.forceMaxHeight;
+  if (forceMaxHeight === void 0) {
+    forceMaxHeight = false;
+  }
+  let c18683_7 = forceMaxHeight;
+  let enablePanDownToClose = props.enablePanDownToClose;
+  if (enablePanDownToClose === void 0) {
+    enablePanDownToClose = false;
+  }
+  let renderExpressionFooter = props.renderExpressionFooter;
+  if (renderExpressionFooter === void 0) {
+    renderExpressionFooter = false;
+  }
+  isScreenReaderEnabled = void 0;
+  derivedValue = void 0;
+  token = void 0;
+  c18683_13 = void 0;
+  c18683_14 = void 0;
+  animatedStyle = void 0;
+  setState = void 0;
+  const styles = useStyles();
+  const ref = useRef(null);
+  const mobileVisualRefreshConfig = useMobileVisualRefreshConfig({
+    location: "AutocompleteWrapper"
+  });
+  const { enabled, chatInputFloating } = mobileVisualRefreshConfig;
+  const customKeyboardBottomSheetConfig = useCustomKeyboardBottomSheetConfig({
+    forceMaxHeight,
+    enablePanDownToClose
+  });
+  const r3 = transitionState === TransitionStates.YEETED;
+  let c18683_9 = r3;
+  useBottomSheetImperativeHandle(a1, ref);
+  useLayoutEffect(() => {
+    if (c18683_9) {
+      const current = ref.current;
+      if (current != null) {
+        current.forceClose();
+      }
+    }
+  }, [ref, r3]);
+  const stateFromStores = useStateFromStores([NativeMenuStore], () => NativeMenuStore.isOpen());
+  if (renderExpressionFooter) {
+    renderExpressionFooter = !r3;
+  }
+  isScreenReaderEnabled = useIsScreenReaderEnabled();
+  const callback3 = useCallback((a0, a1, a2) => {
+    L21: {
+      if (c18683_9 && a1 !== -1) {
+        if (onClose == null) {
+          break L21;
+        }
+        onClose();
+      } else if (a0 !== a1 && a1 !== -1) {
+        if (onAnimate != null) {
+          onAnimate(a0, a1, a2);
+        }
+        if (a0 === 0) {
+          if (a2 !== ANIMATION_SOURCE.KEYBOARD) {
+            triggerHapticFeedback(HapticFeedbackTypes.IMPACT_LIGHT);
+          }
+        } else if (a0 === 1 && a1 === 0 && !isChannelFocused() && c18683_2) {
+          const current = chatInputRef.current;
+          if (current != null) {
+            current.closeCustomKeyboard();
+          }
+        }
+      }
+    }
+  }, [chatInputRef, r3, onAnimate, onClose, isAppsKeyboard]);
+  const U = function U() {
+    return animatedIndex.get() > 0.975;
+  };
+  U.__closure = {
+    animatedIndex
+  };
+  U.__workletHash = 2001839633402;
+  U.__initData = __initData;
+  derivedValue = useDerivedValue(U);
+  const W = () => derivedValue.get();
+  W.__closure = {
+    isFullyExpanded: derivedValue
+  };
+  W.__workletHash = 9531298805666;
+  W.__initData = __initData2;
+  const X = function X(a0, a1) {
+    if (a1 != null && !(a0 ? a0 : c18683_7)) {
+      _ReanimatedRexport.runOnJS(_KeyboardManagerUtils.dismissGlobalKeyboard)();
+    }
+  };
+  X.__closure = {
+    forceMaxHeight,
+    runOnJS: _ReanimatedRexport.runOnJS,
+    dismissGlobalKeyboard: _KeyboardManagerUtils.dismissGlobalKeyboard
+  };
+  X.__workletHash = 14649856286006;
+  X.__initData = __initData3;
+  useAnimatedReaction(W, X);
+  useMountEffect(() => () => {
+    if (onClose != null) {
+      onClose();
+    }
+  });
+  const callback4 = useCallback((a0) => <BottomSheetBackdrop {...a0} pressBehavior="collapse" />, []);
+  const callback = useCallback(() => c18683_6 !== false ? <PortalKeyboardBottomSheetHeader style={headerStyle} handleCollapse={function handleCollapse() {
+    const current = ref.current;
+    if (current != null) {
+      current.collapse();
+    }
+    if (isScreenReaderEnabled) {
+      const current2 = ref.current;
+      if (current2 != null) {
+        current2.forceClose();
+      }
+    }
+  }} isFullyExpanded={derivedValue} /> : null, [headerStyle, ref, rendersHandle, derivedValue, isScreenReaderEnabled]);
+  token = useToken(Module712.modules.mobile.MOBILE_KEYBOARD_TOP_BORDER_RADIUS);
+  const cornerRadiusInputStart = chatInputFloating ? -1 : 0;
+  c18683_13 = cornerRadiusInputStart;
+  const cornerRadiusInputEnd = chatInputFloating ? 0 : 1;
+  c18683_14 = cornerRadiusInputEnd;
+  const ee = () => {
+    const r17 = animatedIndex.get();
+    return {
+      borderTopLeftRadius: _ReanimatedRexport.interpolate(r17, [c18683_13, c18683_14], [0, token], "clamp"),
+      borderTopRightRadius: _ReanimatedRexport.interpolate(animatedIndex.get(), [c18683_13, c18683_14], [0, token], "clamp")
+    };
+  };
+  ee.__closure = {
+    interpolate: _ReanimatedRexport.interpolate,
+    animatedIndex,
+    cornerRadiusInputStart,
+    cornerRadiusInputEnd,
+    cornerRadius: token
+  };
+  ee.__workletHash = 6979425892410;
+  ee.__initData = __initData4;
+  const animatedStyle2 = useAnimatedStyle(ee);
+  animatedStyle = chatInputFloating ? disableHeaderRoundingAnimation ? void 0 : animatedStyle2 : void 0;
+  const callback5 = useCallback((a0) => <PortalKeyboardBackground {...a0} roundingStyle={animatedStyle} />, [animatedStyle]);
+  const safeAreaInsets_native = useSafeAreaInsets_native();
+  const { left, right } = safeAreaInsets_native;
+  const windowDimensions_native = useWindowDimensions_native({
+    ignoreKeyboard: true
+  });
+  const { height, width } = windowDimensions_native;
+  const callback2 = useCallback((a0) => <BottomSheetFooter {...a0}>
+    <PortalHost name="expression-footer" />
+  </BottomSheetFooter>, []);
+  let accessibilityViewIsModal;
+  [accessibilityViewIsModal, setState] = useState(false);
+  const ne = () => Math.max(animatedIndex.get(), 0) > 0;
+  ne.__closure = {
+    animatedIndex
+  };
+  ne.__workletHash = 8952872079740;
+  ne.__initData = __initData5;
+  const te = function te(a0, a1) {
+    if (a0 !== a1) {
+      _ReanimatedRexport.runOnJS(setState)(a0);
+    }
+  };
+  te.__closure = {
+    runOnJS: _ReanimatedRexport.runOnJS,
+    setAccessibilityViewIsModal: setState
+  };
+  te.__workletHash = 16051387075966;
+  te.__initData = __initData6;
+  useAnimatedReaction(ne, te);
+  const r177 = isScreenReaderEnabled ? isScreenReaderEnabled : r3;
+  const colorThemeBackground = useColorThemeBackground();
+  const gradient = enabled ? colorThemeBackground : null;
+  const importantForAccessibility = stateFromStores ? "no-hide-descendants" : void 0;
+  const style = [styles.container, {
+    marginLeft: left,
+    marginRight: right
+  }, ,];
+  const r44 = Math;
+  if (width2 == null) {
+    width2 = Number.MAX_SAFE_INTEGER;
+  }
+  style[2] = {
+    width: r44.min(width2, width - left - right),
+    height
+  };
+  const renderFooter = isAndroid() ? renderExpressionFooter ? callback2 : void 0 : void 0;
+  if (backdropComponent == null) {
+    backdropComponent = callback4;
+  }
+  const r229 = [<Module5245 ref={ref} animatedIndex={animatedIndex} animatedPosition={animatedPosition} animationConfigs={animationConfigs} onClose={onClose} onAnimate={callback3} enableContentPanningGesture={!r177} enableHandlePanningGesture={!r177} handleComponent={callback} renderFooter={renderFooter} backgroundComponent={callback5} backgroundStyle={styles.background} backdropComponent={backdropComponent} activeOffsetY={[-10, 10]} handleHeight={rendersHandle ? ACTION_SHEET_DRAG_HANDLE_HEIGHT : 0} {...customKeyboardBottomSheetConfig}>
+    <AccessibilityViewAnimated nativeID="portal-keyboard-sheet" style={[styles.roundingView, disableHeaderRoundingAnimation ? !disableHeaderRoundingAnimation : animatedStyle2, roundingViewStyle]} onAccessibilityEscape={function onAccessibilityEscape() {
+      const current = ref.current;
+      if (current != null) {
+        current.collapse();
+      }
+    }} accessibilityViewIsModal={accessibilityViewIsModal}>{children}</AccessibilityViewAnimated>
+  </Module5245>, , ,];
+  let r230 = isIOS;
+  if (isIOS) {
+    r230 = renderExpressionFooter;
+  }
+  if (r230) {
+    r230 = <PortalKeyboardFooterIOS_ios animatedSheetIndex={animatedIndex} />;
+  }
+  r229[1] = r230;
+  r229[2] = <NavScrim />;
+  return <ThemeContextProvider gradient={gradient}>
+    <ReanimatedRexport.View importantForAccessibility={importantForAccessibility} style={style} pointerEvents="box-none">{r229}</ReanimatedRexport.View>
+  </ThemeContextProvider>;
+});
+export default r75;
@@ -0,0 +1,5 @@
+// Metro module 11209 (f11210).
+import { getKeyboardAnimationConfigs } from "../../../_bundle/Module5245";
+const keyboardAnimationConfigs = getKeyboardAnimationConfigs("keyboard", 250);
+export const KEYBOARD_ANIMATION_DURATION = 250;
+export { keyboardAnimationConfigs as KEYBOARD_ANIMATION_CONFIG };
@@ -0,0 +1,66 @@
+// Metro module 9352 (f9353).
+import { useMemo } from "react";
+import { createStyles } from "../../../design/components/Styles/native/createStyles";
+import Module712 from "../../../_bundle/Module712";
+import useSafeAreaInsets_native from "../../safe_area/useSafeAreaInsets.native";
+import { useReanimatedKeyboardAnimation } from "../../../_bundle/Module1595";
+import { useKeyboardTypeSharedValue } from "./useKeyboardType";
+import * as _ReanimatedRexport from "../../reanimated/ReanimatedRexport";
+import ReanimatedRexport, { useAnimatedStyle } from "../../reanimated/ReanimatedRexport";
+import * as _KeyboardTypes from "./KeyboardTypes";
+import * as _ConstantsIOS from "../../../ConstantsIOS";
+import { PortalHost } from "../../../_bundle/Module4060";
+const useStyles = createStyles({
+  keyboardStickyFooter: {
+    position: "absolute",
+    bottom: 0,
+    left: 0,
+    right: 0,
+    zIndex: 1,
+    flex: 1,
+    backgroundColor: Module712.colors.MOBILE_KEYBOARD_PANEL_BACKGROUND
+  }
+});
+const __initData = {
+  code: "function PortalKeyboardFooterIOSIosTsx1(){const{interpolate,progress,bottom,followSystemKeyboard,keyboardType,KeyboardTypes,animatedSheetIndex,height,EXPRESSION_FOOTER_HEIGHT}=this.__closure;const offset=interpolate(progress.get(),[0,1],[0,bottom]);const shouldFollowKeyboard=followSystemKeyboard||keyboardType.get()===KeyboardTypes.EXPRESSION;if(shouldFollowKeyboard&&animatedSheetIndex.get()>=0){return{transform:[{translateY:height.get()+offset}]};}return{transform:[{translateY:interpolate(animatedSheetIndex.get(),[-1,0],[EXPRESSION_FOOTER_HEIGHT+bottom,0],'clamp')}]};}"
+};
+export default function PortalKeyboardFooterIOS(props) {
+  let animatedStyle;
+  const { animatedSheetIndex, portalHostName = "expression-footer", followSystemKeyboard = false } = props;
+  let c17171_1 = followSystemKeyboard;
+  animatedStyle = void 0;
+  const styles = useStyles();
+  const bottom = useSafeAreaInsets_native().bottom;
+  const reanimatedKeyboardAnimation = useReanimatedKeyboardAnimation();
+  const { height, progress } = reanimatedKeyboardAnimation;
+  const keyboardTypeSharedValue = useKeyboardTypeSharedValue();
+  const S = function S() {
+    const r22 = _ReanimatedRexport.interpolate(progress.get(), [0, 1], [0, bottom]);
+    return !(!c17171_1 && keyboardTypeSharedValue.get() !== _KeyboardTypes.KeyboardTypes.EXPRESSION) && animatedSheetIndex.get() >= 0 ? {
+      transform: [{
+        translateY: height.get() + r22
+      }]
+    } : {
+      transform: [{
+        translateY: _ReanimatedRexport.interpolate(animatedSheetIndex.get(), [-1, 0], [_ConstantsIOS.EXPRESSION_FOOTER_HEIGHT + bottom, 0], "clamp")
+      }]
+    };
+  };
+  S.__closure = {
+    interpolate: _ReanimatedRexport.interpolate,
+    progress,
+    bottom,
+    followSystemKeyboard,
+    keyboardType: keyboardTypeSharedValue,
+    KeyboardTypes: _KeyboardTypes.KeyboardTypes,
+    animatedSheetIndex,
+    height,
+    EXPRESSION_FOOTER_HEIGHT: _ConstantsIOS.EXPRESSION_FOOTER_HEIGHT
+  };
+  S.__workletHash = 9444646970651;
+  S.__initData = __initData;
+  animatedStyle = useAnimatedStyle(S);
+  return <ReanimatedRexport.View style={useMemo(() => [styles.keyboardStickyFooter, animatedStyle], [animatedStyle, styles])}>
+    <PortalHost name={portalHostName} />
+  </ReanimatedRexport.View>;
+};
@@ -0,0 +1,91 @@
+// Metro module 11730 (f11731).
+import { memo, useId, useRef, useLayoutEffect } from "react";
+import { NativeModules, findNodeHandle } from "react-native";
+import AccessibilityStore from "../../a11y/AccessibilityStore";
+import useKeyboardType, { useKeyboardContextForType } from "./useKeyboardType";
+import useSystemKeyboardHeight_native from "./useSystemKeyboardHeight.native";
+import useKeyboardIsOpen from "./useKeyboardIsOpen";
+import { KeyboardTypes } from "./KeyboardTypes";
+import useMountEffect from "../../../hooks/useMountEffect";
+import { PortalKeyboardUIStore, closePortalKeyboard, handlePortalKeyboardOpen, closePortalKeyboardRequest } from "./PortalKeyboardUIStore.native";
+import { dismissKeyboard } from "../../../utils/native/ChatInputUtils";
+import { PortalKeyboardState } from "./PortalKeyboard";
+import { getKeyboardActionSheetHeight } from "../../action_sheet/native/useKeyboardActionSheetHeight";
+const r23 = memo(function InlinePortalKeyboard({ channelId, messagesRef }) {
+  let field, field2, ref;
+  field = void 0;
+  field2 = void 0;
+  ref = void 0;
+  const id = useId();
+  const keyboardType = useKeyboardType();
+  let c19100_2 = keyboardType;
+  const systemKeyboardHeight_native = useSystemKeyboardHeight_native();
+  const keyboardIsOpen = useKeyboardIsOpen({
+    includeCustomKeyboard: false
+  });
+  let c19100_3 = keyboardIsOpen;
+  const keyboardContextForType = useKeyboardContextForType(KeyboardTypes.SYSTEM);
+  useMountEffect(() => () => {
+    const field3 = PortalKeyboardUIStore.getField("keyboard");
+    if (field3 != null && field3.handlerId === id) {
+      dismissKeyboard();
+      closePortalKeyboard();
+    }
+  });
+  field = PortalKeyboardUIStore.useField("keyboard");
+  field2 = PortalKeyboardUIStore.useField("state");
+  ref = useRef(false);
+  useLayoutEffect(() => {
+    L28: {
+      const current = ref.current;
+      if (field != null) {
+        if (field.handlerId != null && field.handlerId !== id) {
+          break L28;
+        }
+        if (field != null && field2 === PortalKeyboardState.REQUEST_OPEN) {
+          const current3 = messagesRef.current;
+          const r46 = current3 == null ? void 0 : current3.getChatRef();
+          if (r46 == null) {
+            break L28;
+          }
+          const r50 = findNodeHandle(r46.current);
+          if (r50 == null) {
+            break L28;
+          }
+          handlePortalKeyboardOpen(id);
+          ref.current = true;
+          NativeModules.DCDChatManager.customKeyboardWillShow(r50, getKeyboardActionSheetHeight().minimum, 0.25, 7);
+          break L28;
+        }
+        if (c19100_2 === KeyboardTypes.SYSTEM) {
+          if (keyboardContextForType.keyboardWillOpen && field2 !== PortalKeyboardState.REQUEST_CLOSE) {
+            let c27137_0 = setTimeout(closePortalKeyboardRequest, 250);
+            return () => clearTimeout(c27137_0);
+          }
+          closePortalKeyboard();
+          const current4 = messagesRef.current;
+          const r96 = current4 == null ? void 0 : current4.getChatRef();
+          if (r96 != null) {
+            const r100 = findNodeHandle(r96.current);
+            if (r100 != null) {
+              ref.current = false;
+              NativeModules.DCDChatManager.customKeyboardWillHide(r100, 0.25, 7);
+            }
+          }
+        }
+      } else if (!(c19100_3 || (current ? !current : !AccessibilityStore.systemPrefersCrossfades))) {
+        const current2 = messagesRef.current;
+        const r21 = current2 == null ? void 0 : current2.getChatRef();
+        if (r21 != null) {
+          const r25 = findNodeHandle(r21.current);
+          if (r25 != null) {
+            ref.current = false;
+            NativeModules.DCDChatManager.customKeyboardWillHide(r25, 0.25, 7);
+          }
+        }
+      }
+    }
+  }, [channelId, id, field, field2, keyboardType, messagesRef, keyboardContextForType, systemKeyboardHeight_native, keyboardIsOpen]);
+  return null;
+});
+export default r23;
@@ -0,0 +1,7 @@
+// Metro module 9398 (f9399).
+import { createContext, useContext } from "react";
+const context = createContext(false);
+export { context as PortalKeyboardInModalContext };
+export function useIsPortalKeyboardInModal() {
+  return useContext(context);
+}
@@ -0,0 +1,45 @@
+// Metro module 11412 (f11413).
+import { StyleSheet, View } from "react-native";
+import { jsx } from "react/jsx-runtime";
+import { createStyles } from "../../../design/components/Styles/native/createStyles";
+import { isAndroid, isIOS } from "../../../utils/PlatformUtils";
+import Module712 from "../../../_bundle/Module712";
+import { KeyboardTypes } from "./KeyboardTypes";
+import useSafeAreaInsets_native from "../../safe_area/useSafeAreaInsets.native";
+import useIsWindowLarge from "../../screen/native/useIsWindowLarge";
+import useWindowDimensions_native from "../../screen/useWindowDimensions.native";
+import useCustomKeyboardHeight from "./useCustomKeyboardHeight";
+import { useGradientBottom } from "../../client_themes/native/ClientThemesOverrides";
+import useKeyboardType from "./useKeyboardType";
+import useSystemKeyboardHeight_native from "./useSystemKeyboardHeight.native";
+let useStyles;
+const PortalKeyboardPlaceholderInner = function PortalKeyboardPlaceholderInner(props) {
+  const keyboardType = props.keyboardType;
+  const safeAreaInsets_native = useSafeAreaInsets_native();
+  const isWindowLarge = useIsWindowLarge();
+  return <View style={[useStyles(keyboardType, useWindowDimensions_native().width - safeAreaInsets_native.left - safeAreaInsets_native.right, useCustomKeyboardHeight(), isWindowLarge).container, useGradientBottom()]} />;
+};
+const r25 = jsx(function PortalKeyboardPlaceholder() {
+  const keyboardType = useKeyboardType();
+  const r13 = useSystemKeyboardHeight_native() > 0 && isAndroid();
+  return keyboardType === KeyboardTypes.SYSTEM ? isAndroid() ? null : r13 ? null : <PortalKeyboardPlaceholderInner keyboardType={keyboardType} /> : r13 ? null : <PortalKeyboardPlaceholderInner keyboardType={keyboardType} />;
+}, {});
+useStyles = createStyles((a0, a1, a2, a3) => {
+  const container = {
+    ...isIOS() ? StyleSheet.absoluteFillObject : null,
+    borderTopWidth: StyleSheet.hairlineWidth,
+    borderTopColor: Module712.colors.BORDER_SUBTLE,
+    borderRightColor: a3 ? Module712.colors.BORDER_SUBTLE : void 0,
+    borderRightWidth: a3 ? StyleSheet.hairlineWidth : void 0,
+    borderLeftColor: a3 ? Module712.colors.BORDER_SUBTLE : void 0,
+    borderLeftWidth: a3 ? StyleSheet.hairlineWidth : void 0
+  };
+  KeyboardTypes.APP_LAUNCHER;
+  container.backgroundColor = Module712.colors.BACKGROUND_BASE_LOW;
+  container.width = isIOS() ? a1 : a0 !== KeyboardTypes.SYSTEM ? a1 : void 0;
+  container.height = isIOS() ? a2 : a0 !== KeyboardTypes.SYSTEM ? a2 : void 0;
+  return {
+    container
+  };
+});
+export { r25 as PORTAL_KEYBOARD_PLACEHOLDER_INSTANCE };
@@ -0,0 +1,74 @@
+// Metro module 15587 (f15588).
+import { useId, useLayoutEffect, useMemo } from "react";
+import subscribeToKeyboardUIStore from "./subscribeToKeyboardUIStore";
+import { TransitionStates, TransitionGroup } from "../../../design/components/TransitionGroup/TransitionGroup";
+import { getKeyboardType } from "./useKeyboardType";
+import { KeyboardTypes } from "./KeyboardTypes";
+import { isAndroid } from "../../../utils/PlatformUtils";
+import PortalKeyboardRendererComponent from "./PortalKeyboardRendererComponent";
+import { registerPortalKeyboardRenderer, PortalKeyboardUIStore, closePortalKeyboardIfUnhandled } from "./PortalKeyboardUIStore.native";
+import { getRootNavigationRef } from "../../main_tabs_v2/RootNavigationRef.native";
+import { FAKE_PLACEHOLDER_PRIVATE_CHANNEL_ID } from "../../channel/FakePlaceholderPrivateChannel";
+import { getFocusedChannelId } from "../../panels/isChannelFocused.native";
+import { setKeyboardType } from "./KeyboardUIStore.native";
+import { PortalKeyboard } from "./PortalKeyboard";
+import { PortalKeyboardInModalContext } from "./PortalKeyboardModalContext";
+let c11112_6, transitionGroupRenderItem;
+const transitionGroupGetItemKey = function transitionGroupGetItemKey(a0) {
+  return a0.id;
+};
+c11112_6 = [];
+transitionGroupRenderItem = (a0, a1, a2, a3) => a2 === TransitionStates.YEETED && getKeyboardType() === KeyboardTypes.SYSTEM && isAndroid() ? null : <PortalKeyboardRendererComponent key={a0} item={a1} state={a2} cleanUp={a3} />;
+export function PortalKeyboardRenderer(props) {
+  let portal = props.portal;
+  if (portal === void 0) {
+    portal = true;
+  }
+  let field, c22217_2;
+  field = void 0;
+  c22217_2 = void 0;
+  const id = useId();
+  useLayoutEffect(() => registerPortalKeyboardRenderer(id), [id]);
+  useLayoutEffect(() => {
+    let c28090_0 = subscribeToKeyboardUIStore(function() {
+      const field2 = PortalKeyboardUIStore.getField("keyboard");
+      const keyboardType = getKeyboardType();
+      if (field2 != null && keyboardType !== field2.type) {
+        closePortalKeyboardIfUnhandled();
+      }
+    });
+    return () => {
+      c28090_0();
+      closePortalKeyboardIfUnhandled();
+    };
+  }, []);
+  useLayoutEffect(() => {
+    let rootNavigationRef;
+    const onNavigationStateChange2 = function onNavigationStateChange() {
+      const field2 = PortalKeyboardUIStore.getField("keyboard");
+      if (field2 != null && field2.channelId !== FAKE_PLACEHOLDER_PRIVATE_CHANNEL_ID && getFocusedChannelId() !== field2.channelId) {
+        if (getKeyboardType() !== KeyboardTypes.SYSTEM) {
+          setKeyboardType({
+            type: KeyboardTypes.SYSTEM
+          });
+        }
+        closePortalKeyboardIfUnhandled();
+      }
+    };
+    if (isAndroid()) {
+      rootNavigationRef = getRootNavigationRef();
+      if (rootNavigationRef != null) {
+        rootNavigationRef.addListener("state", onNavigationStateChange2);
+        return () => {
+          rootNavigationRef.removeListener("state", onNavigationStateChange2);
+        };
+      }
+    }
+  }, []);
+  field = PortalKeyboardUIStore.useField("keyboard");
+  const field2 = PortalKeyboardUIStore.useField("renderers");
+  const r2 = field2.length === 0 || field2[field2.length - 1] === id;
+  c22217_2 = r2;
+  const r53 = <TransitionGroup items={useMemo(() => field != null && c22217_2 ? [field] : c11112_6, [r2, field])} getItemKey={transitionGroupGetItemKey} renderItem={transitionGroupRenderItem} />;
+  return portal ? <PortalKeyboard>{r53}</PortalKeyboard> : <PortalKeyboardInModalContext.Provider value>{r53}</PortalKeyboardInModalContext.Provider>;
+}
@@ -0,0 +1,35 @@
+// Metro module 15588 (f15589).
+import * as Module19 from "react";
+import { useMemo } from "react";
+import ChannelStore from "../../../stores/ChannelStore";
+import { FAKE_PLACEHOLDER_PRIVATE_CHANNEL_ID, FAKE_PLACEHOLDER_PRIVATE_CHANNEL } from "../../channel/FakePlaceholderPrivateChannel";
+import { KeyboardTypes } from "./KeyboardTypes";
+import AppLauncherKeyboard from "../../app_launcher/native/AppLauncherKeyboard";
+import { AppLauncherEntrypoint } from "../../app_launcher/AppLauncherTypes";
+import MediaKeyboard from "../../media_keyboard/native/components/MediaKeyboard";
+import ExpressionPickerKeyboard from "../../expression_picker/native/ExpressionPickerKeyboard";
+const r22 = Module19.memo(function PortalKeyboardRendererComponent(props) {
+  const item = props.item;
+  const { channelId, chatInputRef, type } = item;
+  const { state, cleanUp } = props;
+  const channel = ChannelStore.getChannel(channelId);
+  const memo = useMemo(() => channelId !== FAKE_PLACEHOLDER_PRIVATE_CHANNEL_ID ? channel : FAKE_PLACEHOLDER_PRIVATE_CHANNEL, [channel, channelId]);
+  const memo2 = useMemo(() => memo != null ? {
+    channel: memo,
+    type: "channel"
+  } : void 0, [memo]);
+  if (memo != null && memo2 !== void 0) {
+    if (KeyboardTypes.APP_LAUNCHER === type) {
+      return <AppLauncherKeyboard context={memo2} chatInputRef={chatInputRef} onClose={cleanUp} transitionState={state} entrypoint={AppLauncherEntrypoint.TEXT} />;
+    }
+    if (KeyboardTypes.MEDIA === type) {
+      return <MediaKeyboard channel={memo} chatInputRef={chatInputRef} onClose={cleanUp} transitionState={state} />;
+    }
+    if (KeyboardTypes.EXPRESSION === type) {
+      return <ExpressionPickerKeyboard channel={memo} chatInputRef={chatInputRef} onClose={cleanUp} transitionState={state} />;
+    }
+    return null;
+  }
+  return null;
+});
+export default r22;
@@ -0,0 +1,85 @@
+// Metro module 4056 (f4057).
+import { createZustandStore } from "../../../lib/ZustandStore";
+import { PortalKeyboardState } from "./PortalKeyboard";
+import { v4 } from "../../../_bundle/Module514";
+const zustandStore = (0, createZustandStore)(() => ({
+  keyboard: null,
+  state: PortalKeyboardState.EMPTY,
+  renderers: []
+}));
+const r18 = {
+  getField: zustandStore.getField,
+  useField: zustandStore.useField
+};
+export { r18 as PortalKeyboardUIStore };
+export function isPortalKeyboardOpenForChannel(a0) {
+  const state = zustandStore.getState();
+  const state2 = state.state;
+  return state.keyboard?.channelId === a0 && (state2 === PortalKeyboardState.REQUEST_OPEN || state2 === PortalKeyboardState.OPENING || state2 === PortalKeyboardState.OPEN);
+}
+export function openPortalKeyboard(a0, a1, a2) {
+  const state = zustandStore.getState();
+  const { state: state2, keyboard } = state;
+  let r17 = keyboard?.type === a0 && keyboard?.channelId === a1;
+  const r26 = state2 === PortalKeyboardState.REQUEST_OPEN || state2 === PortalKeyboardState.OPENING || state2 === PortalKeyboardState.OPEN;
+  if (r17) {
+    r17 = r26;
+  }
+  if (!r17) {
+    zustandStore.setState({
+      keyboard: {
+        id: v4(),
+        type: a0,
+        channelId: a1,
+        chatInputRef: a2
+      },
+      state: PortalKeyboardState.REQUEST_OPEN
+    });
+  }
+}
+export function registerPortalKeyboardRenderer(c13814_0) {
+  zustandStore.setState((state) => {
+    const renderers = state.renderers;
+    return renderers.includes(c13814_0) ? state : {
+      renderers: [...state.renderers, c13814_0]
+    };
+  });
+  return () => {
+    zustandStore.setState((state) => ({
+      renderers: state.renderers.filter((renderer) => renderer !== c13814_0)
+    }));
+  };
+}
+export function handlePortalKeyboardOpen(handlerId) {
+  zustandStore.setState((a0) => a0.keyboard != null ? a0.keyboard.handlerId !== handlerId ? {
+    keyboard: {
+      ...a0.keyboard,
+      handlerId
+    },
+    state: PortalKeyboardState.OPEN
+  } : a0 : a0);
+}
+export function closePortalKeyboard() {
+  zustandStore.setState({
+    state: PortalKeyboardState.CLOSED,
+    keyboard: null
+  });
+}
+export function closePortalKeyboardIfUnhandled() {
+  const state2 = zustandStore.getState();
+  const { keyboard, state } = state2;
+  if (!(keyboard == null && state === PortalKeyboardState.CLOSED) && keyboard?.handlerId == null) {
+    zustandStore.setState({
+      state: PortalKeyboardState.CLOSED,
+      keyboard: null
+    });
+  }
+}
+export function closePortalKeyboardRequest() {
+  const field = zustandStore.getField("state");
+  if (field !== PortalKeyboardState.CLOSED && field !== PortalKeyboardState.REQUEST_CLOSE) {
+    zustandStore.setState({
+      state: PortalKeyboardState.REQUEST_CLOSE
+    });
+  }
+}
@@ -0,0 +1,19 @@
+// Metro module 11207 (f11208).
+import { setKeyboardType } from "./KeyboardUIStore.native";
+import { runAfterInteractions } from "../../../utils/native/RunAfterInteractionsUtils";
+import { openPortalKeyboard } from "./PortalKeyboardUIStore.native";
+import ChatInputNativeCommands from "../../chat_input/native/ChatInputNativeCommands";
+export default function openCustomKeyboard({ channelId, chatInputRef, chatInputNativeRef, keyboardParams, secondaryTextFieldRef }) {
+  setKeyboardType(keyboardParams);
+  runAfterInteractions(() => {
+    chatInputRef.current.blur();
+    if (secondaryTextFieldRef != null) {
+      const current = secondaryTextFieldRef.current;
+      if (current != null) {
+        current.blur();
+      }
+    }
+    openPortalKeyboard(keyboardParams.type, channelId, chatInputRef);
+    ChatInputNativeCommands.openCustomKeyboard(chatInputNativeRef.current);
+  });
+};
@@ -0,0 +1,7 @@
+// Metro module 1476 (f1477).
+import * as _AppEntryKeyContext from "../../window/native/AppEntryKeyContext";
+import KeyboardUIStore_native from "./KeyboardUIStore.native";
+export default function subscribeToKeyboardUIStore(c13051_0, r6 = _AppEntryKeyContext.DEFAULT_APP_ENTRY_KEY) {
+  const DEFAULT_APP_ENTRY_KEY = r6;
+  return KeyboardUIStore_native.subscribe((a0) => c13051_0(a0.byAppEntry[DEFAULT_APP_ENTRY_KEY]));
+};
@@ -0,0 +1,5 @@
+// Metro module 10384 (f10385).
+import AnimatedKeyboardProvider_android from "./AnimatedKeyboardProvider.android";
+export default function useAnimatedKeyboardHeight() {
+  return AnimatedKeyboardProvider_android.animatedKeyboardHeight;
+};
@@ -0,0 +1,10 @@
+// Metro module 5218 (f5219).
+import { useAppEntryKey, DEFAULT_APP_ENTRY_KEY } from "../../window/native/AppEntryKeyContext";
+import KeyboardUIStore_native from "./KeyboardUIStore.native";
+export default function useCustomKeyboardHeight() {
+  const appEntryKey = useAppEntryKey();
+  return KeyboardUIStore_native((a0) => a0.byAppEntry[appEntryKey].customKeyboardHeight);
+};
+export function getCustomKeyboardHeight(r2 = DEFAULT_APP_ENTRY_KEY) {
+  return KeyboardUIStore_native.getState().byAppEntry[r2].customKeyboardHeight;
+}
@@ -0,0 +1,7 @@
+// Metro module 5216 (f5217).
+import { DEFAULT_APP_ENTRY_KEY } from "../../window/native/AppEntryKeyContext";
+import { isAndroid } from "../../../utils/PlatformUtils";
+import KeyboardUIStore_native from "./KeyboardUIStore.native";
+export function getKeyboardDuration(r3 = DEFAULT_APP_ENTRY_KEY) {
+  return isAndroid() ? 300 : KeyboardUIStore_native.getState().byAppEntry[r3].keyboardDuration;
+}
@@ -0,0 +1,48 @@
+// Metro module 6744 (f6745).
+import subscribeToKeyboardUIStore from "./subscribeToKeyboardUIStore";
+import * as _AppEntryKeyContext from "../../window/native/AppEntryKeyContext";
+import { useAppEntryKey } from "../../window/native/AppEntryKeyContext";
+import KeyboardUIStore_native from "./KeyboardUIStore.native";
+import { KeyboardTypes } from "./KeyboardTypes";
+let c4331_4 = {};
+export default function useKeyboardIsOpen(r2 = c4331_4) {
+  let includeCustomKeyboard2 = r2.includeCustomKeyboard;
+  if (includeCustomKeyboard2 === void 0) {
+    includeCustomKeyboard2 = false;
+  }
+  let c15888_0 = includeCustomKeyboard2;
+  const appEntryKey = useAppEntryKey();
+  return KeyboardUIStore_native((a0) => {
+    const r7 = a0.byAppEntry[appEntryKey];
+    const systemKeyboardOpen = r7.systemKeyboardOpen;
+    return c15888_0 ? systemKeyboardOpen ? systemKeyboardOpen : r7.keyboardType !== KeyboardTypes.SYSTEM : systemKeyboardOpen;
+  });
+};
+export function subscribeToKeyboardIsOpen(c15889_0, r7 = c4331_4) {
+  let includeCustomKeyboard2 = r7.includeCustomKeyboard;
+  if (includeCustomKeyboard2 === void 0) {
+    includeCustomKeyboard2 = false;
+  }
+  const includeCustomKeyboard = includeCustomKeyboard2;
+  let appEntryKey2 = r7.appEntryKey;
+  if (appEntryKey2 === void 0) {
+    appEntryKey2 = _AppEntryKeyContext.DEFAULT_APP_ENTRY_KEY;
+  }
+  const DEFAULT_APP_ENTRY_KEY = appEntryKey2;
+  return subscribeToKeyboardUIStore(() => {
+    const r4 = {
+      includeCustomKeyboard,
+      appEntryKey: DEFAULT_APP_ENTRY_KEY
+    };
+    const { includeCustomKeyboard: includeCustomKeyboard2 = false, appEntryKey: appEntryKey2 = _AppEntryKeyContext.DEFAULT_APP_ENTRY_KEY } = r4;
+    const r21 = KeyboardUIStore_native.getState().byAppEntry[appEntryKey2];
+    const systemKeyboardOpen = r21.systemKeyboardOpen;
+    return c15889_0(includeCustomKeyboard2 ? systemKeyboardOpen ? systemKeyboardOpen : r21.keyboardType !== KeyboardTypes.SYSTEM : systemKeyboardOpen);
+  }, DEFAULT_APP_ENTRY_KEY);
+}
+export function getKeyboardIsOpen(r3 = c4331_4) {
+  const { includeCustomKeyboard: includeCustomKeyboard2 = false, appEntryKey: appEntryKey2 = _AppEntryKeyContext.DEFAULT_APP_ENTRY_KEY } = r3;
+  const r17 = KeyboardUIStore_native.getState().byAppEntry[appEntryKey2];
+  const systemKeyboardOpen = r17.systemKeyboardOpen;
+  return includeCustomKeyboard2 ? systemKeyboardOpen ? systemKeyboardOpen : r17.keyboardType !== KeyboardTypes.SYSTEM : systemKeyboardOpen;
+}
@@ -0,0 +1,50 @@
+// Metro module 4055 (f4056).
+import { useEffect } from "react";
+import { useAppEntryKey, DEFAULT_APP_ENTRY_KEY } from "../../window/native/AppEntryKeyContext";
+import KeyboardUIStore_native, { addKeyboardTypeChangedListener, addKeyboardWillOpenChangedListener } from "./KeyboardUIStore.native";
+import { useSharedValue } from "../../reanimated/ReanimatedRexport";
+import { KeyboardTypes } from "./KeyboardTypes";
+export default function useKeyboardType() {
+  const appEntryKey = useAppEntryKey();
+  return KeyboardUIStore_native((a0) => a0.byAppEntry[appEntryKey].keyboardType);
+};
+export function getKeyboardContextForType(a0, r3 = DEFAULT_APP_ENTRY_KEY) {
+  return KeyboardUIStore_native.getState().byAppEntry[r3].keyboardContexts[a0];
+}
+export function useKeyboardContextForType(c13810_0) {
+  const appEntryKey2 = useAppEntryKey();
+  return KeyboardUIStore_native((a0) => a0.byAppEntry[appEntryKey2].keyboardContexts[c13810_0]);
+}
+export function getKeyboardType(r2 = DEFAULT_APP_ENTRY_KEY) {
+  return KeyboardUIStore_native.getState().byAppEntry[r2].keyboardType;
+}
+export function getKeyboardTypePrevious(r2 = DEFAULT_APP_ENTRY_KEY) {
+  return KeyboardUIStore_native.getState().byAppEntry[r2].keyboardTypePrevious;
+}
+export function useKeyboardTypePrevious() {
+  const appEntryKey3 = useAppEntryKey();
+  return KeyboardUIStore_native((a0) => a0.byAppEntry[appEntryKey3].keyboardTypePrevious);
+}
+export function useKeyboardTypeSharedValue() {
+  const appEntryKey4 = useAppEntryKey();
+  const r7 = appEntryKey4 === void 0 ? DEFAULT_APP_ENTRY_KEY : appEntryKey4;
+  const sharedValue = useSharedValue(KeyboardUIStore_native.getState().byAppEntry[r7].keyboardType);
+  useEffect(() => addKeyboardTypeChangedListener(({ type }, a1) => {
+    if (!(a1 != null && a1 !== appEntryKey4)) {
+      sharedValue.set(type);
+    }
+  }), [appEntryKey4, sharedValue]);
+  return sharedValue;
+}
+export function useKeyboardWillOpenSharedValue() {
+  const appEntryKey5 = useAppEntryKey();
+  const SYSTEM = KeyboardTypes.SYSTEM;
+  const r8 = appEntryKey5 === void 0 ? DEFAULT_APP_ENTRY_KEY : appEntryKey5;
+  const sharedValue2 = useSharedValue(KeyboardUIStore_native.getState().byAppEntry[r8].keyboardContexts[SYSTEM].keyboardWillOpen === true);
+  useEffect(() => addKeyboardWillOpenChangedListener((a0, a1) => {
+    if (!(a1 != null && a1 !== appEntryKey5)) {
+      sharedValue2.set(a0);
+    }
+  }), [appEntryKey5, sharedValue2]);
+  return sharedValue2;
+}
@@ -0,0 +1,10 @@
+// Metro module 9397 (f9398).
+import { useMemo } from "react";
+import { RefreshControl } from "react-native";
+import { useIsPortalKeyboardInModal } from "./PortalKeyboardModalContext";
+import { isIOS } from "../../../utils/PlatformUtils";
+const noop = () => {};
+export function useModalDismissGuardRefreshControl() {
+  const isPortalKeyboardInModal = useIsPortalKeyboardInModal();
+  return useMemo(() => isPortalKeyboardInModal ? isIOS() ? <RefreshControl refreshing={false} onRefresh={noop} tintColor="transparent" /> : void 0 : void 0, [isPortalKeyboardInModal]);
+}
@@ -0,0 +1,23 @@
+// Metro module 1847 (f1848).
+import { useAppEntryKey, DEFAULT_APP_ENTRY_KEY } from "../../window/native/AppEntryKeyContext";
+import KeyboardUIStore_native from "./KeyboardUIStore.native";
+let c1558_3 = {
+  excludeSafeAreaInsets: false
+};
+export default function useSystemKeyboardHeight(r2 = c1558_3) {
+  let excludeSafeAreaInsets = r2.excludeSafeAreaInsets;
+  if (excludeSafeAreaInsets === void 0) {
+    excludeSafeAreaInsets = false;
+  }
+  let c13259_0 = excludeSafeAreaInsets;
+  const appEntryKey = useAppEntryKey();
+  return KeyboardUIStore_native((a0) => {
+    const r4 = a0.byAppEntry[appEntryKey];
+    return c13259_0 ? r4.keyboardHeightExcludingSafeAreaInsets : r4.keyboardHeight;
+  });
+};
+export function getSystemKeyboardHeight(r4 = c1558_3) {
+  const { excludeSafeAreaInsets = false, appEntryKey: appEntryKey2 = DEFAULT_APP_ENTRY_KEY } = r4;
+  const r17 = KeyboardUIStore_native.getState().byAppEntry[appEntryKey2];
+  return excludeSafeAreaInsets ? r17.keyboardHeightExcludingSafeAreaInsets : r17.keyboardHeight;
+}