// Module ID: 15609
// Function ID: 119080
// Name: _createForOfIteratorHelperLoose
// Dependencies: []
// Exports: default

// Module 15609 (_createForOfIteratorHelperLoose)
function _createForOfIteratorHelperLoose(@@iterator) {
  let arg1 = Symbol_iterator;
  @@iterator = "undefined" !== typeof Symbol;
  if (Symbol_iterator) {
    const _Symbol = Symbol;
    @@iterator = Symbol_iterator[Symbol.iterator];
  }
  if (!Symbol_iterator) {
    @@iterator = Symbol_iterator[Symbol.iterator];
  }
  if (Symbol_iterator) {
    const iter = Symbol_iterator.call(Symbol_iterator);
    const next = iter.next;
    return next.bind(iter);
  } else {
    const _Array = Array;
    let tmp = Symbol_iterator;
    if (!Array.isArray(Symbol_iterator)) {
      let tmp2;
      if (Symbol_iterator) {
        if ("string" === typeof Symbol_iterator) {
          tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
        } else {
          const toString = {}.toString;
          const substr = toString.call(Symbol_iterator).slice(8, -1);
          let name = substr;
          if (tmp3) {
            name = Symbol_iterator.constructor.name;
          }
          if ("Map" !== name) {
            if ("Set" !== name) {
              if ("Arguments" === name) {
                let arr = _arrayLikeToArray(Symbol_iterator, undefined);
              } else {
                const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
              }
            }
            tmp2 = arr;
          }
          const _Array2 = Array;
          arr = Array.from(Symbol_iterator);
          const callResult = toString.call(Symbol_iterator);
          const tmp3 = "Object" === substr && Symbol_iterator.constructor;
        }
      }
      tmp = tmp2;
      if (!tmp2) {
        const _TypeError = TypeError;
        const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
        throw typeError;
      }
    }
    if (tmp) {
      arg1 = tmp;
    }
    let closure_1 = 0;
    return () => {
      if (closure_1 >= tmp.length) {
        let obj = { done: true };
      } else {
        obj = { done: false };
        closure_1 = tmp3 + 1;
        obj.value = tmp[+closure_1];
      }
      return obj;
    };
  }
}
function _arrayLikeToArray(arg0, arg1) {
  let length;
  if (tmp) {
    length = arg0.length;
  }
  const ArrayResult = Array(length);
  for (let num = 0; num < length; num = num + 1) {
    ArrayResult[num] = arg0[num];
  }
  return ArrayResult;
}
function useLayoutManagerState(windowDimensions) {
  let items;
  let pushToTalk;
  windowDimensions = windowDimensions.windowDimensions;
  const arg1 = windowDimensions;
  const safeArea = windowDimensions.safeArea;
  const importDefault = safeArea;
  const contentDimensions = windowDimensions.contentDimensions;
  const dependencyMap = contentDimensions;
  const isConnected = windowDimensions.isConnected;
  let callback = isConnected;
  const layoutManager = windowDimensions.layoutManager;
  const React = layoutManager;
  let closure_13;
  ({ items, pushToTalk } = windowDimensions);
  const tmp = callback(React.useState(() => {
    let height;
    let width;
    let obj = windowDimensions(contentDimensions[35]);
    const windowDimensions = obj.getWindowDimensions();
    ({ width, height } = windowDimensions);
    obj = { width, height, landscape: width > height };
    return obj;
  }), 2);
  const size = tmp[0];
  const AppState = size;
  let closure_6 = tmp2;
  let obj = arg1(dependencyMap[36]);
  const tmp3 = callback(React.useState(obj.getSafeAreaInsets()), 2);
  const rect = tmp3[0];
  let closure_7 = rect;
  let closure_8 = tmp4;
  const managerSubscription = arg1(dependencyMap[38]).useManagerSubscription(layoutManager);
  let closure_9 = managerSubscription;
  const ref = React.useRef({ timeout: -1, layoutKey: managerSubscription, connected: isConnected, windowState: size, safeAreaState: rect, contentDimensions: { "Null": -536870861, "Null": -299892737 } });
  let closure_10 = ref;
  function useUpdateLayoutManagerState(isConnected) {
    isConnected = isConnected.isConnected;
    const windowDimensions = isConnected;
    const currentUpdatesRef = isConnected.currentUpdatesRef;
    const safeArea = currentUpdatesRef;
    const setWindowState = isConnected.setWindowState;
    const contentDimensions = setWindowState;
    const setSafeAreaState = isConnected.setSafeAreaState;
    isConnected = setSafeAreaState;
    const items = [currentUpdatesRef, isConnected, setWindowState, setSafeAreaState];
    const layoutEffect = layoutManager.useLayoutEffect(() => {
      if (currentUpdatesRef.current.connected !== isConnected) {
        currentUpdatesRef.current.connected = isConnected;
        setWindowState((safeAreaState) => {
          let height;
          let width;
          let windowState = safeAreaState;
          const windowDimensions = callback(closure_2[35]).getWindowDimensions();
          ({ width, height } = windowDimensions);
          closure_1.current.windowState = { width, height, landscape: width > height };
          const obj = callback(closure_2[35]);
          if (!obj2.cheapWorkletShallowEqual(safeAreaState, closure_1.current.windowState)) {
            windowState = closure_1.current.windowState;
          }
          return windowState;
        });
        setSafeAreaState((safeAreaState) => {
          closure_1.current.safeAreaState = callback(closure_2[36]).getSafeAreaInsets();
          const obj = callback(closure_2[36]);
          if (!obj2.cheapWorkletShallowEqual(safeAreaState, closure_1.current.safeAreaState)) {
            safeAreaState = closure_1.current.safeAreaState;
          }
          return safeAreaState;
        });
      }
    }, items);
  }({ isConnected, currentUpdatesRef: ref, setWindowState: tmp[1], setSafeAreaState: tmp3[1] });
  callback = React.useCallback(() => {
    clearTimeout(ref.current.timeout);
    ref.current.timeout = setTimeout(() => {
      clearTimeout(ref.current.timeout);
      callback(closure_2[43]).batchUpdates(() => {
        callback((safeAreaState2) => {
          let windowState = safeAreaState2;
          if (!obj.cheapWorkletShallowEqual(closure_10.current.windowState, safeAreaState2)) {
            windowState = closure_10.current.windowState;
          }
          return windowState;
        });
        callback2((safeAreaState2) => {
          let safeAreaState = safeAreaState2;
          if (!obj.cheapWorkletShallowEqual(closure_10.current.safeAreaState, safeAreaState2)) {
            safeAreaState = closure_10.current.safeAreaState;
          }
          return safeAreaState;
        });
      });
    }, 60);
  }, []);
  let closure_11 = callback;
  items = [callback];
  const layoutEffect = React.useLayoutEffect(() => {
    function updateSafeAreas(safeAreaInsets) {
      let obj = callback(closure_2[23]);
      if (!obj.cheapWorkletShallowEqual(closure_10.current.safeAreaState, safeAreaInsets)) {
        obj = {};
        const merged = Object.assign(safeAreaInsets);
        closure_10.current.safeAreaState = obj;
        callback3();
      }
    }
    function updateWindowDimensions() {
      let height;
      let width;
      let windowDimensions = arg0;
      if (arg0 === undefined) {
        let obj = callback(closure_2[35]);
        windowDimensions = obj.getWindowDimensions();
      }
      ({ width, height } = windowDimensions);
      obj = { width, height, landscape: width > height };
      if (!obj3.cheapWorkletShallowEqual(closure_10.current.windowState, obj)) {
        closure_10.current.windowState = obj;
        callback3();
      }
    }
    const windowDimensions = safeArea(contentDimensions[44])(updateSafeAreas);
    updateSafeAreas(windowDimensions(contentDimensions[36]).getSafeAreaInsets());
    const safeArea = safeArea(contentDimensions[45])(updateWindowDimensions);
    const result = updateWindowDimensions();
    return () => {
      callback();
      callback2();
    };
  }, items);
  const id = React.useId();
  let closure_12 = id;
  const items1 = [isConnected, id];
  const layoutEffect1 = React.useLayoutEffect(() => {
    if (isConnected) {
      const state = ref.getState();
      const obj = { key: id, lockEnabled: true };
      const safeAreaDisableLock = state.requestSafeAreaDisableLock(obj);
      return () => {
        const state = state.getState();
        const safeAreaDisableLock = state.requestSafeAreaDisableLock({ key: closure_12, lockEnabled: false });
      };
    }
  }, items1);
  obj = { windowWidth: size.width, windowHeight: size.height, safeAreaLeft: rect.left, safeAreaRight: rect.right, safeAreaTop: rect.top, safeAreaBottom: rect.bottom, controlBarSize: pushToTalk ? closure_19 : closure_18 };
  const updateStateResult = layoutManager.updateState(items, obj);
  closure_13 = updateStateResult;
  const items2 = [contentDimensions, updateStateResult, managerSubscription, layoutManager, safeArea, rect, windowDimensions, size, isConnected];
  const layoutEffect2 = React.useLayoutEffect(() => {
    function executeLayoutManagerEffect(arg0) {
      return closure_4.handleLayoutEffect();
    }
    const windowDimensions = executeLayoutManagerEffect;
    ref.current.layoutKey = managerSubscription;
    let obj = windowDimensions(contentDimensions[22]);
    const fn = function e(arg0) {
      let contentState;
      let safeAreaState;
      let windowState;
      ({ windowState, safeAreaState, contentState } = arg0);
      let tmp = closure_3;
      if (closure_3) {
        tmp = !executeLayoutManagerEffect(store2[23]).cheapWorkletShallowEqual(store2.get(), contentState);
        const obj = executeLayoutManagerEffect(store2[23]);
      }
      if (tmp) {
        const result = store2.set(contentState);
      }
      if (!obj2.cheapWorkletShallowEqual(executeLayoutManagerEffect.get(), windowState)) {
        const result1 = executeLayoutManagerEffect.set(windowState);
      }
      const obj2 = executeLayoutManagerEffect(store2[23]);
      if (!obj3.cheapWorkletShallowEqual(store.get(), safeAreaState)) {
        const result2 = store.set(safeAreaState);
      }
      const obj3 = executeLayoutManagerEffect(store2[23]);
      executeLayoutManagerEffect(store2[22]).runOnJS(executeLayoutManagerEffect)();
    };
    obj = { isConnected, cheapWorkletShallowEqual: windowDimensions(contentDimensions[23]).cheapWorkletShallowEqual, contentDimensions, windowDimensions, safeArea, runOnJS: windowDimensions(contentDimensions[22]).runOnJS, executeLayoutManagerEffect };
    fn.__closure = obj;
    fn.__workletHash = 13791383688018;
    fn.__initData = closure_41;
    obj = { windowState: size, safeAreaState: rect, contentState: updateStateResult };
    obj.runOnUI(fn)(obj);
  }, items2);
  const items3 = [layoutManager];
  const effect = React.useEffect(() => {
    function checkDimensions() {
      if (!closure_3) {
        const size = callback(closure_2[35]).getWindowDimensions();
        const width = size.width;
        const callback = width;
        const height = size.height;
        let timeout = height;
        const result = checkDimensions.checkDimensionsMismatch(width, height);
        closure_2 = result;
        if (null != result) {
          const _setTimeout = setTimeout;
          timeout = setTimeout(() => {
            let height;
            let width;
            let obj = width(result[35]);
            const windowDimensions = obj.getWindowDimensions();
            ({ width, height } = windowDimensions);
            let tmp2 = width === width;
            if (tmp2) {
              tmp2 = callback === height;
            }
            if (tmp2) {
              if (null != closure_4.checkDimensionsMismatch(width, height)) {
                let closure_3 = true;
                obj = { layout_width: result.staleWidth, layout_height: result.staleHeight, window_width: width, window_height: callback, was_dirty: result.wasDirty };
                callback(result[47]).track(constants.VOICE_PANEL_LAYOUT_DESYNC, obj);
                const callback = null;
                const obj2 = callback(result[47]);
              }
            }
          }, 250);
        }
        const obj = callback(closure_2[35]);
      }
    }
    const layoutManager = checkDimensions;
    if (!windowDimensions(closure_2[46]).isStable) {
      const _setInterval = setInterval;
      const windowDimensions = setInterval(checkDimensions, 1000);
      let closure_1 = null;
      closure_2 = size.addEventListener("change", (arg0) => {
        if ("active" === arg0) {
          if (null == interval) {
            const _setInterval = setInterval;
            let interval = setInterval(checkDimensions, 1000);
          }
        }
        if ("active" !== arg0) {
          const _clearInterval = clearInterval;
          clearInterval(interval);
          const _clearTimeout = clearTimeout;
          clearTimeout(closure_1);
          interval = null;
        }
      });
      let closure_3 = false;
      return () => {
        clearInterval(closure_0);
        clearTimeout(closure_1);
        closure_2.remove();
      };
    }
  }, items3);
  const layoutEffect3 = React.useLayoutEffect(() => () => clearTimeout(ref.current.timeout), []);
}
let closure_3 = importDefault(dependencyMap[0]);
let closure_4 = importAll(dependencyMap[1]);
const AppState = arg1(dependencyMap[2]).AppState;
let closure_6 = importDefault(dependencyMap[3]);
let closure_7 = importDefault(dependencyMap[4]);
let closure_8 = importDefault(dependencyMap[5]);
let closure_9 = importDefault(dependencyMap[6]);
let closure_10 = importDefault(dependencyMap[7]);
let closure_11 = importDefault(dependencyMap[8]);
let closure_12 = importDefault(dependencyMap[9]);
let closure_13 = importDefault(dependencyMap[10]);
let closure_14 = importDefault(dependencyMap[11]);
let closure_15 = importDefault(dependencyMap[12]);
({ VoicePanelModes: closure_16, getAnalyticsNameForVoicePanelMode: closure_17 } = arg1(dependencyMap[13]));
const tmp2 = arg1(dependencyMap[13]);
({ CONTROLS_HEIGHT: closure_18, CONTROLS_HEIGHT_PTT: closure_19, CONTROLS_HIDE_TIMEOUT: closure_20, VoicePanelControlsModes: closure_21 } = arg1(dependencyMap[14]));
const tmp3 = arg1(dependencyMap[14]);
({ AnalyticEvents: closure_22, ComponentActions: closure_23, InputModes: closure_24 } = arg1(dependencyMap[15]));
const OrientationLockState = arg1(dependencyMap[16]).OrientationLockState;
const ActivityPanelModes = arg1(dependencyMap[17]).ActivityPanelModes;
const isActivityParticipant = arg1(dependencyMap[18]).isActivityParticipant;
const MorphablePanelModes = arg1(dependencyMap[19]).MorphablePanelModes;
const jsx = arg1(dependencyMap[20]).jsx;
let closure_30 = { code: "function VoicePanelControllerTsx1(){const{focused,mode,connected}=this.__closure;var _focused$get;return[(_focused$get=focused.get())===null||_focused$get===void 0?void 0:_focused$get.id,mode.get(),connected.get()];}" };
let closure_31 = { code: "function VoicePanelControllerTsx2(props,previous){const{cheapWorkletArrayShallowEqual,runOnJS,handleAnimatedReaction}=this.__closure;if(cheapWorkletArrayShallowEqual(props,previous!==null&&previous!==void 0?previous:undefined))return;const[focusedParticipantId,voicePanelMode,connectedValue]=props;runOnJS(handleAnimatedReaction)({focusedParticipantId:focusedParticipantId,voicePanelMode:voicePanelMode,connectedValue:connectedValue});}" };
let closure_32 = 5 * importDefault(dependencyMap[24]).Millis.MINUTE;
let closure_33 = { code: "function VoicePanelControllerTsx3(){const{focused,pipState}=this.__closure;var _focused$get;return[(_focused$get=focused.get())===null||_focused$get===void 0?void 0:_focused$get.id,pipState.id];}" };
let closure_34 = { code: "function VoicePanelControllerTsx4(props,previous){const{cheapWorkletArrayShallowEqual,runOnJS,handleStateUpdates}=this.__closure;if(cheapWorkletArrayShallowEqual(props,previous!==null&&previous!==void 0?previous:undefined))return;const[focusedId,pipParticipantId]=props;runOnJS(handleStateUpdates)({focusedId:focusedId,pipParticipantId:pipParticipantId});}" };
let closure_35 = { code: "function VoicePanelControllerTsx5(value){const{isFocusedVideoZoomed}=this.__closure;isFocusedVideoZoomed.set(value);}" };
let closure_36 = { code: "function VoicePanelControllerTsx6(){const{mode,VoicePanelModes,MorphablePanelModes}=this.__closure;switch(mode.get()){case VoicePanelModes.PANEL:{return MorphablePanelModes.PANEL;}case VoicePanelModes.PIP:{return MorphablePanelModes.PIP;}default:{return MorphablePanelModes.UNDEFINED;}}}" };
let closure_37 = { code: "function VoicePanelControllerTsx7(){const{mode}=this.__closure;return mode.get();}" };
let closure_38 = { code: "function VoicePanelControllerTsx8(value){const{VoicePanelModes,runOnJS,_queueHideControls,_clearHideControlsQueue}=this.__closure;if(value===VoicePanelModes.PANEL){runOnJS(_queueHideControls)();}else{runOnJS(_clearHideControlsQueue)();}}" };
let closure_39 = { code: "function VoicePanelControllerTsx9(){const{connected}=this.__closure;return connected.get();}" };
let closure_40 = { code: "function VoicePanelControllerTsx10(connected){const{updateSharedValueIfChanged,controlsSpecs,pushToTalk,CONTROLS_HEIGHT_PTT,CONTROLS_HEIGHT}=this.__closure;updateSharedValueIfChanged(controlsSpecs,{height:pushToTalk&&connected?CONTROLS_HEIGHT_PTT:CONTROLS_HEIGHT,pushToTalk:pushToTalk});}" };
let closure_41 = { code: "function VoicePanelControllerTsx11({windowState:windowState,safeAreaState:safeAreaState,contentState:contentState}){const{isConnected,cheapWorkletShallowEqual,contentDimensions,windowDimensions,safeArea,runOnJS,executeLayoutManagerEffect}=this.__closure;if(isConnected&&!cheapWorkletShallowEqual(contentDimensions.get(),contentState)){contentDimensions.set(contentState);}if(!cheapWorkletShallowEqual(windowDimensions.get(),windowState)){windowDimensions.set(windowState);}if(!cheapWorkletShallowEqual(safeArea.get(),safeAreaState)){safeArea.set(safeAreaState);}runOnJS(executeLayoutManagerEffect)();}" };
let closure_42 = { code: "function VoicePanelControllerTsx12(){const{connected,mode,sharedTransitionState}=this.__closure;return[connected.get(),mode.get(),sharedTransitionState.get()];}" };
let closure_43 = { code: "function VoicePanelControllerTsx13(props,previous){const{cheapWorkletArrayShallowEqual,TransitionStates,VoicePanelModes,runOnJS,setMode}=this.__closure;if(cheapWorkletArrayShallowEqual(props,previous!==null&&previous!==void 0?previous:undefined))return;const[isConnected,currentMode,currentTransitionState]=props;if(currentTransitionState===TransitionStates.YEETED){if(currentMode!==VoicePanelModes.DISMISSED){runOnJS(setMode)(VoicePanelModes.DISMISSED);}}else if(currentMode===VoicePanelModes.DISMISSED){var _previous$;let previousMode=(_previous$=previous===null||previous===void 0?void 0:previous[1])!==null&&_previous$!==void 0?_previous$:VoicePanelModes.PANEL;switch(previousMode){case VoicePanelModes.PANEL:case VoicePanelModes.PIP:if(!isConnected){previousMode=VoicePanelModes.PANEL;}break;default:previousMode=VoicePanelModes.PANEL;}runOnJS(setMode)(previousMode);}else if(!isConnected&&(previous===null||previous===void 0?void 0:previous[0])===true&&currentMode===VoicePanelModes.PIP){runOnJS(setMode)(VoicePanelModes.PANEL);}}" };
let closure_44 = { code: "function VoicePanelControllerTsx14(){const{mode,controlsSpecs}=this.__closure;return[mode.get(),controlsSpecs.get().mode];}" };
let closure_45 = { code: "function VoicePanelControllerTsx15(props,previous){const{cheapWorkletArrayShallowEqual,VoicePanelControlsModes,VoicePanelModes,runOnJS,dismissKeyboard}=this.__closure;if(cheapWorkletArrayShallowEqual(props,previous!==null&&previous!==void 0?previous:undefined))return;const[currentMode,currentControlsMode]=props;if(currentControlsMode!==VoicePanelControlsModes.DRAWER||currentMode!==VoicePanelModes.PANEL||(previous===null||previous===void 0?void 0:previous[0])!==VoicePanelModes.PANEL){runOnJS(dismissKeyboard)();}}" };
const tmp4 = arg1(dependencyMap[15]);
const result = arg1(dependencyMap[68]).fileFinishedImporting("modules/voice_panel/native/VoicePanelController.tsx");

export default function VoicePanelController(channelId) {
  let children;
  let connected;
  let controlsSpecs;
  let focused;
  let isConnected;
  let items;
  let layoutManager;
  let manualFocusedItem;
  let safeArea;
  let setControlsMode;
  let transitionCleanUp;
  let windowDimensions;
  channelId = channelId.channelId;
  const arg1 = channelId;
  const guildId = channelId.guildId;
  const importDefault = guildId;
  const transitionState = channelId.transitionState;
  let closure_33;
  let closure_34;
  let closure_35;
  let closure_36;
  let closure_37;
  ({ children, transitionCleanUp } = channelId);
  let obj = arg1(dependencyMap[26]);
  items = [closure_13];
  const stateFromStores = obj.useStateFromStores(items, () => safeArea.getMode() === controlsSpecs.PUSH_TO_TALK);
  const first = callback(React.useState(() => {
    let tmp = guildId(first[57]);
    tmp = new tmp(safeArea.getMediaEngine());
    return tmp;
  }), 1)[0];
  const dependencyMap = first;
  const items1 = [first];
  const effect = React.useEffect(() => () => closure_2.cleanUp(), items1);
  ({ items, isConnected } = importDefault(dependencyMap[58])(channelId, guildId));
  const callback = function useMountedCards(items, isConnected) {
    const channelId = items;
    const guildId = isConnected;
    const first = callback(React.useState(() => new Set()), 1)[0];
    items = [isConnected, items, first];
    const effect = React.useEffect(() => {
      if (arg1) {
        const items = items(first[56]).runAfterInteractions(() => {
          let done;
          closure_2.clear();
          const tmp2 = callback(closure_0);
          let iter = tmp2();
          if (!iter.done) {
            do {
              let tmp3 = closure_2;
              let addResult = closure_2.add(iter.value.id);
              let iter2 = tmp2();
              iter = iter2;
              done = iter2.done;
            } while (!done);
          }
        }, 100);
        return () => {
          if (null != closure_0) {
            closure_0.cancel();
          }
        };
      } else {
        first.clear();
      }
    }, items);
    return first;
  }(items, isConnected);
  const tmp5 = function useCoreSharedState(channelId, isConnected, items, stateFromStores) {
    const guildId = items;
    let first = stateFromStores;
    const channel = channel.getChannel(channelId);
    let isDMResult;
    if (null != channel) {
      isDMResult = channel.isDM();
    }
    let type;
    if (null != channel) {
      type = channel.type;
    }
    let obj1 = channelId(first[22]);
    const sharedValue = obj1.useSharedValue(isConnected);
    let obj2 = channelId(first[22]);
    const sharedValue1 = obj2.useSharedValue(constants.PANEL);
    let callback = sharedValue1;
    let obj3 = channelId(first[35]);
    const size = obj3.getWindowDimensions();
    let obj4 = channelId(first[22]);
    let obj = { width: size.width, height: size.height, landscape: size.width > size.height };
    const sharedValue2 = obj4.useSharedValue(obj);
    const rect = channelId(first[36]).getSafeAreaInsets();
    const connected = rect;
    const obj7 = channelId(first[36]);
    const tmp2 = null != isDMResult && isDMResult;
    obj = {};
    const merged = Object.assign(rect);
    const sharedValue3 = channelId(first[22]).useSharedValue(obj);
    const obj8 = channelId(first[22]);
    obj1 = { windowWidth: size.width, connected: isConnected, safeAreaLeft: rect.left, safeAreaRight: rect.right };
    const maxPanelWidth = channelId(first[37]).getMaxPanelWidth(obj1);
    const obj10 = channelId(first[37]);
    obj2 = { drawerHeight: size.height, drawerWidth: maxPanelWidth };
    const obj12 = channelId(first[22]);
    obj2.drawerX = channelId(first[37]).getPanelX(size.width, maxPanelWidth);
    obj2.drawerY = size.height;
    obj2.pipX = -1;
    obj2.pipY = -1;
    obj2.animated = true;
    obj2.mode = constants.PANEL;
    const sharedValue4 = obj12.useSharedValue(obj2);
    const obj14 = channelId(first[37]);
    const sharedValue5 = channelId(first[22]).useSharedValue(0);
    const obj15 = channelId(first[22]);
    const sharedValue6 = channelId(first[22]).useSharedValue(false);
    const obj16 = channelId(first[22]);
    const sharedValue7 = channelId(first[22]).useSharedValue(null);
    const obj17 = channelId(first[22]);
    const sharedValue8 = channelId(first[22]).useSharedValue(0);
    const obj18 = channelId(first[22]);
    const sharedValue9 = channelId(first[22]).useSharedValue(false);
    const obj19 = channelId(first[22]);
    const sharedValue10 = channelId(first[22]).useSharedValue(false);
    const contentDimensions = sharedValue10;
    const fn = function c(arg0) {
      const result = sharedValue10.set(arg0);
    };
    fn.__closure = { isFocusedVideoZoomed: sharedValue10 };
    fn.__workletHash = 13885070318174;
    fn.__initData = closure_35;
    items = [sharedValue10];
    callback = size.useCallback(fn, items);
    const obj20 = channelId(first[22]);
    const sharedValue11 = channelId(first[22]).useSharedValue(contentDimensions.useReducedMotion);
    const items1 = [sharedValue11];
    const effect = size.useEffect(() => {
      function onChange() {
        const result = closure_7.set(closure_6.useReducedMotion);
      }
      const arg0 = onChange;
      const result = sharedValue10.addReactChangeListener(onChange);
      return () => {
        const result = closure_6.removeReactChangeListener(onChange);
      };
    }, items1);
    const obj21 = channelId(first[22]);
    const sharedValue12 = channelId(first[22]).useSharedValue({ "Bool(true)": "8aacc7898585bec38aca6cf682c01533", "Bool(true)": "FolderIcon", "Bool(true)": "png" });
    const obj22 = channelId(first[22]);
    class W {
      constructor() {
        value = closure_3.get();
        if (closure_16.PANEL === value) {
          tmp5 = closure_28;
          return closure_28.PANEL;
        } else {
          tmp2 = closure_16;
          if (closure_16.PIP === value) {
            tmp4 = closure_28;
            return closure_28.PIP;
          } else {
            tmp3 = closure_28;
            return closure_28.UNDEFINED;
          }
        }
      }
    }
    obj3 = { mode: sharedValue1, VoicePanelModes: constants, MorphablePanelModes: selectedMode };
    W.__closure = obj3;
    W.__workletHash = 931249605381;
    W.__initData = closure_36;
    const derivedValue = channelId(first[22]).useDerivedValue(W);
    first = callback(size.useState(() => {
      let tmp = arg2(arg3[38]);
      tmp = new tmp(arg0);
      tmp.updateState(arg2, { windowWidth: size.width, windowHeight: size.height, safeAreaLeft: rect.left, safeAreaRight: rect.right, safeAreaTop: rect.top, safeAreaBottom: rect.bottom, controlBarSize: arg3 ? closure_19 : closure_18 });
      return tmp;
    }), 1)[0];
    const focused = first;
    const items2 = [first];
    const layoutEffect = size.useLayoutEffect(() => () => closure_8.cleanUp(), items2);
    obj4 = { channelType: type, connected: sharedValue };
    const obj23 = channelId(first[22]);
    obj4.contentDimensions = channelId(first[22]).useSharedValue(first.getContentDimensions());
    obj4.dragScrolling = sharedValue6;
    obj4.focused = sharedValue7;
    obj4.isCall = tmp2;
    obj4.layoutManager = first;
    obj4.mode = sharedValue1;
    obj4.preJoinContentSize = sharedValue8;
    obj4.safeArea = sharedValue3;
    obj4.scrollPosition = sharedValue5;
    obj4.windowDimensions = sharedValue2;
    obj4.wrapperDimensions = sharedValue4;
    obj4.isFocusedVideoZoomed = sharedValue10;
    obj4.setIsFocusedVideoZoomed = callback;
    obj4.useReducedMotion = sharedValue11;
    obj4.wrapperOffset = sharedValue12;
    obj4.morphablePanelMode = derivedValue;
    obj4.panelCardStillInPIP = sharedValue9;
    return obj4;
  }(channelId, isConnected, items, stateFromStores);
  ({ channelType: closure_4, connected } = tmp5);
  const AppState = connected;
  const contentDimensions = tmp5.contentDimensions;
  let closure_6 = contentDimensions;
  ({ dragScrolling: closure_7, focused } = tmp5);
  let closure_8 = focused;
  ({ isCall: closure_9, layoutManager } = tmp5);
  let closure_10 = layoutManager;
  const mode = tmp5.mode;
  let closure_11 = mode;
  ({ preJoinContentSize: closure_12, safeArea } = tmp5);
  closure_13 = safeArea;
  ({ scrollPosition: closure_14, windowDimensions } = tmp5);
  let closure_15 = windowDimensions;
  ({ wrapperDimensions: closure_16, isFocusedVideoZoomed: closure_17, setIsFocusedVideoZoomed: closure_18, useReducedMotion: closure_19, wrapperOffset: closure_20, morphablePanelMode: closure_21, panelCardStillInPIP: closure_22 } = tmp5);
  const tmp6 = function useControlsState(mode, isConnected, connected, stateFromStores) {
    const channelId = mode;
    const guildId = isConnected;
    const first = connected;
    let closure_3 = stateFromStores;
    channelId(first[22]);
    let obj = { mode: constants2.FLOATING_DEFAULT, locked: false };
    if (stateFromStores) {
      if (isConnected) {
        let tmp3 = closure_19;
      }
      obj.height = tmp3;
      obj.pushToTalk = stateFromStores;
      const tmp2Result = tmp2(obj);
      let closure_5 = tmp2Result.useRef(-1);
      const callback = tmp2Result.useCallback(() => {
        if (-1 !== ref.current) {
          const _clearTimeout = clearTimeout;
          clearTimeout(ref.current);
          ref.current = -1;
        }
      }, []);
      const contentDimensions = callback;
      const items = [tmp2Result, callback, mode];
      const callback1 = tmp2Result.useCallback(() => {
        callback();
        if (-1 === ref.current) {
          const _setTimeout = setTimeout;
          ref.current = setTimeout(() => {
            callback2();
            if (closure_0.get() === constants.PANEL) {
              let locked = store.get().mode !== constants2.FLOATING_DEFAULT;
              if (!locked) {
                locked = store.get().locked;
              }
              if (!locked) {
                const obj = { mode: constants2.HIDDEN };
                callback(closure_2[39])(store, obj);
              }
            }
          }, closure_20);
        }
      }, items);
      const items1 = [tmp2Result, callback1];
      const memo = tmp2Result.useMemo(() => {
        function _setControlsMode(mode, FLOATING_DEFAULT) {
          _setControlsMode(closure_2[39])(closure_4, { mode, returnMode: FLOATING_DEFAULT });
          callback();
        }
        const arg1 = _setControlsMode;
        let obj = arg1(arg2[40]);
        let closure_0 = obj.debounce(_setControlsMode, 200);
        obj = {
          cancelControlsDebounce() {
            return closure_0.cancel();
          },
          setControlsMode(returnMode) {
            let debounce;
            let mode;
            ({ mode, debounce } = returnMode);
            if (debounce === undefined) {
              debounce = false;
            }
            let FLOATING_DEFAULT = returnMode.returnMode;
            if (FLOATING_DEFAULT === undefined) {
              FLOATING_DEFAULT = constants.FLOATING_DEFAULT;
            }
            if (debounce) {
              obj(mode, FLOATING_DEFAULT);
            } else {
              obj.cancel();
              _setControlsMode(mode, FLOATING_DEFAULT);
            }
          }
        };
        return obj;
      }, items1);
      const cancelControlsDebounce = memo.cancelControlsDebounce;
      const focused = cancelControlsDebounce;
      const setControlsMode = memo.setControlsMode;
      const _Set = Set;
      const set = new Set();
      let closure_10 = tmp2Result.useRef(set);
      const items2 = [tmp2Result, callback1, callback];
      const items3 = [setControlsMode];
      const callback2 = tmp2Result.useCallback((arg0) => {
        let v4Result = arg0;
        if (null == arg0) {
          let obj = arg0(arg2[41]);
          v4Result = obj.v4();
        }
        arg0 = v4Result;
        obj = {
          lock(mode) {
            const current = closure_10.current;
            if (!current.has(v4Result)) {
              callback2();
              const current2 = closure_10.current;
              current2.add(v4Result);
              const obj = { locked: closure_10.current.size > 0 };
              if (null != mode) {
                obj.mode = mode;
              }
              callback(closure_2[39])(closure_4, obj);
            }
          },
          unlock(mode) {
            const current = closure_10.current;
            if (current.has(v4Result)) {
              const current2 = closure_10.current;
              current2.delete(v4Result);
              const obj = { locked: closure_10.current.size > 0 };
              if (null != mode) {
                obj.mode = mode;
              }
              callback(closure_2[39])(closure_4, obj);
              callback3();
            }
          }
        };
        return obj;
      }, items2);
      const items4 = [setControlsMode, tmp2Result];
      const callback3 = tmp2Result.useCallback(() => {
        let tmp = arg0;
        if (arg0 === undefined) {
          let obj = { debounce: false };
          tmp = obj;
        }
        obj = { mode: constants2.HIDDEN, debounce: tmp.debounce };
        setControlsMode(obj);
      }, items3);
      const callback4 = tmp2Result.useCallback(() => {
        let obj = arg0;
        if (arg0 === undefined) {
          obj = {};
        }
        let flag = obj.debounce;
        if (flag === undefined) {
          flag = false;
        }
        obj = {};
        let FLOATING_DEFAULT = tmp2Result.get().returnMode;
        if (null == FLOATING_DEFAULT) {
          FLOATING_DEFAULT = constants2.FLOATING_DEFAULT;
        }
        obj.mode = FLOATING_DEFAULT;
        obj.debounce = flag;
        return setControlsMode(obj);
      }, items4);
      let obj1 = channelId(first[22]);
      const fn = function s() {
        return arg0.get();
      };
      obj = { mode };
      fn.__closure = obj;
      fn.__workletHash = 12140218650562;
      fn.__initData = ref;
      const fn2 = function r(arg0) {
        if (arg0 === constants.PANEL) {
          arg0(arg2[22]).runOnJS(callback1)();
          const obj2 = arg0(arg2[22]);
        } else {
          arg0(arg2[22]).runOnJS(callback)();
          const obj = arg0(arg2[22]);
        }
      };
      obj = { VoicePanelModes: closure_16, runOnJS: channelId(first[22]).runOnJS, _queueHideControls: callback1, _clearHideControlsQueue: callback };
      fn2.__closure = obj;
      fn2.__workletHash = 7742206515980;
      fn2.__initData = closure_38;
      const animatedReaction = obj1.useAnimatedReaction(fn, fn2);
      const items5 = [stateFromStores, tmp2Result, isConnected];
      const layoutEffect = tmp2Result.useLayoutEffect(() => {
        const obj = {};
        if (arg3) {
          if (arg1) {
            let tmp4 = closure_19;
          }
          obj.height = tmp4;
          obj.pushToTalk = arg3;
          tmp(tmp2, obj);
        }
        tmp4 = closure_18;
      }, items5);
      const fn3 = function c() {
        return arg2.get();
      };
      obj1 = { connected };
      fn3.__closure = obj1;
      fn3.__workletHash = 16653595323628;
      fn3.__initData = closure_39;
      const fn4 = function l(arg0) {
        const obj = {};
        if (arg3) {
          if (arg0) {
            let tmp4 = closure_19;
          }
          obj.height = tmp4;
          obj.pushToTalk = arg3;
          tmp(tmp2, obj);
        }
        tmp4 = closure_18;
      };
      const obj2 = { updateSharedValueIfChanged: guildId(first[39]), controlsSpecs: tmp2Result, pushToTalk: stateFromStores, CONTROLS_HEIGHT_PTT: closure_19, CONTROLS_HEIGHT: closure_18 };
      fn4.__closure = obj2;
      fn4.__workletHash = 2154816141018;
      fn4.__initData = closure_40;
      const animatedReaction1 = channelId(first[22]).useAnimatedReaction(fn3, fn4);
      const items6 = [cancelControlsDebounce, callback];
      const layoutEffect1 = tmp2Result.useLayoutEffect(() => () => {
        callback2();
        callback();
      }, items6);
      const items7 = [setControlsMode];
      const effect = tmp2Result.useEffect(() => {
        function closeTiV(arg0) {
          callback({ mode: constants.FLOATING_DEFAULT });
        }
        const arg0 = closeTiV;
        const ComponentDispatch = arg0(arg2[42]).ComponentDispatch;
        const subscription = ComponentDispatch.subscribe(constants3.VOICE_PANEL_TIV_CLOSE, closeTiV);
        return () => {
          const ComponentDispatch = closeTiV(closure_2[42]).ComponentDispatch;
          ComponentDispatch.unsubscribe(constants2.VOICE_PANEL_TIV_CLOSE, closeTiV);
        };
      }, items7);
      const obj3 = { generateStateLocker: callback2, setControlsMode, showControls: callback4, hideControls: callback3, controlsSpecs: tmp2Result };
      return obj3;
    }
    tmp3 = closure_18;
  }(mode, isConnected, connected, stateFromStores);
  ({ generateStateLocker: closure_23, controlsSpecs } = tmp6);
  const showControls = tmp6.showControls;
  const OrientationLockState = showControls;
  ({ hideControls: closure_26, setControlsMode } = tmp6);
  const isActivityParticipant = setControlsMode;
  const tmp7 = function useSelectedMode(channelId) {
    let controlsSpecs;
    let mode;
    channelId = channelId.channelId;
    ({ isConnected: closure_1, mode } = channelId);
    let first = mode;
    let connected = channelId.connected;
    const callback = connected;
    ({ transitionState: closure_4, controlsSpecs } = channelId);
    connected = controlsSpecs;
    const setControlsMode = channelId.setControlsMode;
    const contentDimensions = setControlsMode;
    const tmp = callback(React.useState(constants.PANEL), 2);
    first = tmp[0];
    const focused = tmp3;
    const layoutEffect = React.useLayoutEffect(() => {
      const result = mode.set(first);
      if (closure_4 !== channelId(mode[51]).TransitionStates.YEETED) {
        const result1 = connected.set(closure_1);
      }
    });
    const items = [channelId, connected, mode, controlsSpecs, setControlsMode];
    return {
      selectedMode: first,
      setMode: tmp[1],
      dismissPanel: React.useCallback(() => {
        if (controlsSpecs.get().mode === constants2.DRAWER) {
          const obj = { mode: constants2.FLOATING_DEFAULT };
          setControlsMode(obj);
          let flag = true;
        } else if (connected.get()) {
          let flag2 = mode.get() === constants.PANEL;
          if (flag2) {
            tmp3(constants.PIP);
            flag2 = true;
          }
          flag = flag2;
        } else {
          const state = state.getState();
          state.closeChannel(channelId);
          flag = true;
        }
        return flag;
      }, items)
    };
  }({ channelId, isConnected, mode, connected, transitionState, controlsSpecs, setControlsMode });
  const selectedMode = tmp7.selectedMode;
  const MorphablePanelModes = selectedMode;
  const setMode = tmp7.setMode;
  const jsx = setMode;
  const dismissPanel = tmp7.dismissPanel;
  const tmp4 = importDefault(dependencyMap[58])(channelId, guildId);
  ({ manualFocusedItem, setFocused: closure_31 } = function useManuallyFocusedItem(guildId) {
    let focused;
    let layoutManager;
    guildId = guildId.guildId;
    let channelId = guildId;
    channelId = guildId.channelId;
    guildId = channelId;
    ({ layoutManager, focused } = guildId);
    const first = focused;
    let contentDimensions;
    let tmp6;
    const items = [focused];
    const manualFocusedItem = channelId(first[26]).useStateFromStores(items, () => selectedParticipantId.getSelectedParticipantId(channelId));
    let closure_3 = manualFocusedItem;
    const items1 = [guildId, channelId];
    const setFocused = setFocused.useCallback((embeddedActivityParticipantId) => {
      let result = null == embeddedActivityParticipantId;
      if (!result) {
        result = guildId(focused[52]).isVoicePanelParticipantFocusable(guildId, channelId, embeddedActivityParticipantId);
        const obj = guildId(focused[52]);
      }
      if (result) {
        const participant = channelId(focused[53]).selectParticipant(channelId, embeddedActivityParticipantId);
        const obj2 = channelId(focused[53]);
      }
    }, items1);
    let closure_5 = setFocused.useRef(undefined);
    let tmp3;
    if (null != manualFocusedItem) {
      tmp3 = manualFocusedItem;
    }
    const targetDimensions = layoutManager.getTargetDimensions(tmp3);
    contentDimensions = targetDimensions;
    const items2 = [focused, manualFocusedItem, targetDimensions];
    const layoutEffect = setFocused.useLayoutEffect(() => {
      let tmp = null;
      if (null != manualFocusedItem) {
        const obj = { id: manualFocusedItem };
        const merged = Object.assign(targetDimensions);
        tmp = obj;
      }
      let tmp6;
      if (null != tmp) {
        tmp6 = tmp;
      }
      const current = ref.current;
      let tmp7;
      if (null != current) {
        tmp7 = current;
      }
      if (!obj2.cheapWorkletShallowEqual(tmp6, tmp7)) {
        ref.current = tmp;
        const result = focused.set(tmp);
      }
    }, items2);
    tmp6 = guildId(first[52])(guildId, channelId, manualFocusedItem);
    const items3 = [manualFocusedItem, tmp6, setFocused];
    const effect = setFocused.useEffect(() => {
      if (null != manualFocusedItem) {
        if (!tmp6) {
          setFocused(null);
        }
      }
    }, items3);
    const items4 = [setFocused];
    const effect1 = setFocused.useEffect(() => () => callback(null), items4);
    return { setFocused, manualFocusedItem };
  }({ guildId, channelId, layoutManager, focused }));
  let obj1 = arg1(dependencyMap[26]);
  const items2 = [closure_7];
  const stateFromStores1 = obj1.useStateFromStores(items2, () => {
    const connectedActivityLocation = store.getConnectedActivityLocation();
    const embeddedActivityLocationChannelId = channelId(first[59]).getEmbeddedActivityLocationChannelId(connectedActivityLocation);
    let tmp4 = null != connectedActivityLocation;
    const activityPanelMode = store.getActivityPanelMode();
    if (tmp4) {
      tmp4 = embeddedActivityLocationChannelId !== channelId;
    }
    if (tmp4) {
      tmp4 = activityPanelMode === constants3.PANEL;
    }
    return tmp4;
  });
  let closure_32 = stateFromStores1;
  useLayoutManagerState({ isConnected, windowDimensions, contentDimensions, safeArea, layoutManager, items, pushToTalk: stateFromStores });
  const items3 = [selectedMode, stateFromStores1];
  const layoutEffect = React.useLayoutEffect(() => {
    if (tmp) {
      const result = channelId(first[33]).updateActivityPanelMode(constants3.PIP);
      const obj = channelId(first[33]);
    }
  }, items3);
  function useKeyboardDismissHandler(mode) {
    mode = mode.mode;
    const channelId = mode;
    const controlsSpecs = mode.controlsSpecs;
    const guildId = controlsSpecs;
    let obj = channelId(first[22]);
    const fn = function a() {
      const items = [mode.get(), controlsSpecs.get().mode];
      return items;
    };
    fn.__closure = { mode, controlsSpecs };
    fn.__workletHash = 10791754460802;
    fn.__initData = closure_44;
    const fn2 = function n(arg0, arg1) {
      let tmp;
      if (null != arg1) {
        tmp = arg1;
      }
      if (!obj.cheapWorkletArrayShallowEqual(arg0, tmp)) {
        let tmp6 = callback(arg0, 2)[1] === constants2.DRAWER;
        if (tmp6) {
          tmp6 = tmp4 === constants.PANEL;
        }
        if (tmp6) {
          let first;
          if (null != arg1) {
            first = arg1[0];
          }
          tmp6 = first === constants.PANEL;
        }
        if (!tmp6) {
          mode(closure_2[22]).runOnJS(mode(closure_2[55]).dismissKeyboard)();
          const obj2 = mode(closure_2[22]);
        }
        const tmp3 = callback(arg0, 2);
      }
    };
    obj = { cheapWorkletArrayShallowEqual: channelId(first[23]).cheapWorkletArrayShallowEqual, VoicePanelControlsModes: closure_21, VoicePanelModes: closure_16, runOnJS: channelId(first[22]).runOnJS, dismissKeyboard: channelId(first[55]).dismissKeyboard };
    fn2.__closure = obj;
    fn2.__workletHash = 16494740341507;
    fn2.__initData = closure_45;
    const animatedReaction = obj.useAnimatedReaction(fn, fn2);
  }({ mode, controlsSpecs });
  function useTransitionState(channelId) {
    channelId = channelId.channelId;
    const transitionState = channelId.transitionState;
    const guildId = transitionState;
    const transitionCleanUp = channelId.transitionCleanUp;
    const first = transitionCleanUp;
    let connected = channelId.connected;
    let closure_3 = connected;
    const mode = channelId.mode;
    const setMode = channelId.setMode;
    connected = setMode;
    let obj = channelId(first[22]);
    const sharedValue = obj.useSharedValue(transitionState);
    const contentDimensions = sharedValue;
    const items = [transitionState, sharedValue, transitionCleanUp, channelId];
    const layoutEffect = mode.useLayoutEffect(() => {
      const result = sharedValue.set(transitionState);
      if (transitionState === channelId(transitionCleanUp[51]).TransitionStates.YEETED) {
        const state = state.getState();
        const obj = { lockEnabled: false };
        const _HermesInternal = HermesInternal;
        obj.key = "voice-panel-freeze-" + channelId;
        const freezeLock = state.requestFreezeLock(obj);
        const _setTimeout = setTimeout;
        const channelId = setTimeout(transitionCleanUp, 500);
        return () => clearTimeout(closure_0);
      }
    }, items);
    const items1 = [channelId];
    const layoutEffect1 = mode.useLayoutEffect(() => () => {
      const state = state.getState();
      const freezeLock = state.requestFreezeLock({ lockEnabled: false, key: "voice-panel-freeze-" + closure_0 });
    }, items1);
    const fn = function h() {
      const items = [connected.get(), mode.get(), sharedValue.get()];
      return items;
    };
    fn.__closure = { connected, mode, sharedTransitionState: sharedValue };
    fn.__workletHash = 7656858903152;
    fn.__initData = closure_42;
    const fn2 = function u(arg0, arg1) {
      let tmp;
      if (null != arg1) {
        tmp = arg1;
      }
      if (!obj.cheapWorkletArrayShallowEqual(arg0, tmp)) {
        const tmp3 = connected(arg0, 3);
        const first = tmp3[0];
        if (tmp3[2] === channelId(transitionCleanUp[51]).TransitionStates.YEETED) {
          if (tmp5 !== constants.DISMISSED) {
            channelId(transitionCleanUp[22]).runOnJS(setMode)(constants.DISMISSED);
            const obj4 = channelId(transitionCleanUp[22]);
          }
        } else if (tmp5 === constants.DISMISSED) {
          let PANEL;
          if (null != arg1) {
            PANEL = arg1[1];
          }
          if (null == PANEL) {
            PANEL = constants.PANEL;
          }
          if (constants.PANEL !== PANEL) {
            if (constants.PIP !== PANEL) {
              PANEL = constants.PANEL;
            }
            channelId(transitionCleanUp[22]).runOnJS(setMode)(PANEL);
            const obj3 = channelId(transitionCleanUp[22]);
          }
          if (!first) {
            PANEL = constants.PANEL;
          }
        } else {
          let tmp8 = first;
          if (!first) {
            let first1;
            if (null != arg1) {
              first1 = arg1[0];
            }
            tmp8 = true !== first1;
          }
          if (!tmp8) {
            tmp8 = tmp5 !== constants.PIP;
          }
          if (!tmp8) {
            channelId(transitionCleanUp[22]).runOnJS(setMode)(constants.PANEL);
            const obj2 = channelId(transitionCleanUp[22]);
          }
        }
      }
    };
    obj = { cheapWorkletArrayShallowEqual: channelId(first[23]).cheapWorkletArrayShallowEqual, TransitionStates: channelId(first[51]).TransitionStates, VoicePanelModes: closure_16, runOnJS: channelId(first[22]).runOnJS, setMode };
    fn2.__closure = obj;
    fn2.__workletHash = 5740547237317;
    fn2.__initData = closure_43;
    const animatedReaction = channelId(first[22]).useAnimatedReaction(fn, fn2);
  }({ channelId, transitionState, transitionCleanUp, connected, mode, setMode });
  let obj2 = arg1(dependencyMap[60]);
  obj = { channelId, connected: isConnected };
  let tmp14;
  if (null != manualFocusedItem) {
    tmp14 = manualFocusedItem;
  }
  obj.focusedId = tmp14;
  obj.layoutManager = layoutManager;
  obj.mode = selectedMode;
  const controllerPIPState = obj2.useControllerPIPState(obj);
  closure_33 = importDefault(dependencyMap[61])({ mode, controlsSpecs, safeArea, windowDimensions });
  function useSelectedParticipantEffects(channelId) {
    channelId = channelId.channelId;
    const selectedMode = channelId.selectedMode;
    const guildId = selectedMode;
    let closure_2 = React.useRef(null);
    const items = [selectedMode, channelId.manualFocusedItem, channelId];
    const layoutEffect = React.useLayoutEffect(() => {
      const rTCConnection = store.getRTCConnection();
      let tmp = null != rTCConnection;
      if (tmp) {
        tmp = store.getChannelId() === channelId;
      }
      if (tmp) {
        if (ref.current !== constants.PIP) {
          if (selectedMode === constants.PIP) {
            rTCConnection.setPipOpen(true);
          }
        }
        let tmp11 = ref.current === constants.PIP;
        if (tmp11) {
          tmp11 = selectedMode !== constants.PIP;
        }
        if (tmp11) {
          rTCConnection.setPipOpen(false);
        }
      }
    }, items);
    const layoutEffect1 = React.useLayoutEffect(() => {
      closure_2.current = selectedMode;
    });
  }({ channelId, selectedMode, manualFocusedItem });
  function useHandleThermalState(channelId) {
    channelId = channelId.channelId;
    const focused = channelId.focused;
    const guildId = focused;
    const pipState = channelId.pipState;
    const first = pipState;
    const manuallyFocusedId = channelId.manuallyFocusedId;
    let closure_3 = manuallyFocusedId;
    const items = [channelId];
    const callback = callback.useCallback((arg0) => {
      let focusedId;
      let pipParticipantId;
      ({ focusedId, pipParticipantId } = arg0);
      const result = closure_11.shouldReactToSeriousThermalStateWhenActivityFocused();
      let tmp3 = null != focusedId;
      const result1 = closure_11.consumedRequestToRespondToSeriousThermalState();
      if (tmp3) {
        tmp3 = callback(store.getParticipant(channelId, focusedId));
      }
      let participant;
      if (null != pipParticipantId) {
        participant = store.getParticipant(channelId, pipParticipantId);
      }
      let streamId;
      if (null != participant) {
        streamId = participant.streamId;
      }
      let tmp11 = null != streamId;
      if (tmp11) {
        let selfVideo;
        if (null != participant) {
          const voiceState = participant.voiceState;
          if (null != voiceState) {
            selfVideo = voiceState.selfVideo;
          }
        }
        tmp11 = true === selfVideo;
      }
      if (tmp3) {
        if (result) {
          if (!result1) {
            const isVideoEnabledResult = videoEnabled.isVideoEnabled();
            let tmp15 = isVideoEnabledResult;
            if (!isVideoEnabledResult) {
              tmp15 = tmp11;
            }
            if (tmp15) {
              let obj = focused(pipState[27]);
              obj = { userId: "row", style: "center", avError: "kSampleStepSize", removeRetryButton: "type", removeSplashImage: "isArray", icon: focused(pipState[30]) };
              const intl = channelId(pipState[29]).intl;
              obj.content = intl.string(channelId(pipState[29]).t.O2IlPT);
              obj.open(obj);
              const result2 = channelId(pipState[31]).trackActivityThermalStateNoticeShown();
              const obj3 = channelId(pipState[31]);
            }
            if (isVideoEnabledResult) {
              focused(pipState[32]).setVideoEnabled(false);
              const obj4 = focused(pipState[32]);
            }
            const result3 = channelId(pipState[33]).consumeRequestToReactToSeriousThermalState();
            const obj5 = channelId(pipState[33]);
          }
        }
      }
    }, items);
    const items1 = [manuallyFocusedId, pipState, callback, channelId];
    const effect = callback.useEffect(() => {
      const items = [closure_11, closure_8];
      const batchedStoreListener = new channelId(pipState[26]).BatchedStoreListener(items, () => {
        const obj = {};
        let tmp2;
        if (null != closure_3) {
          tmp2 = closure_3;
        }
        obj.focusedId = tmp2;
        obj.pipParticipantId = id.id;
        closure_4(obj);
      });
      const channelId = batchedStoreListener;
      batchedStoreListener.attach("thermal-state-reactions-" + channelId);
      return () => batchedStoreListener.detach();
    }, items1);
    let obj = channelId(first[22]);
    const fn = function u() {
      const value = focused.get();
      let id;
      if (null != value) {
        id = value.id;
      }
      const items = [id, pipState.id];
      return items;
    };
    fn.__closure = { focused, pipState };
    fn.__workletHash = 94735519164;
    fn.__initData = closure_33;
    const fn2 = function l(arg0, arg1) {
      let tmp4;
      let tmp5;
      let obj = channelId(pipState[23]);
      let tmp;
      if (null != arg1) {
        tmp = arg1;
      }
      if (!obj.cheapWorkletArrayShallowEqual(arg0, tmp)) {
        [tmp4, tmp5] = manuallyFocusedId(arg0, 2);
        const tmp3 = manuallyFocusedId(arg0, 2);
        obj = { focusedId: tmp4, pipParticipantId: tmp5 };
        channelId(pipState[22]).runOnJS(callback)(obj);
        const obj2 = channelId(pipState[22]);
      }
    };
    obj = { cheapWorkletArrayShallowEqual: channelId(first[23]).cheapWorkletArrayShallowEqual, runOnJS: channelId(first[22]).runOnJS, handleStateUpdates: callback };
    fn2.__closure = obj;
    fn2.__workletHash = 15246095289306;
    fn2.__initData = closure_34;
    const animatedReaction = obj.useAnimatedReaction(fn, fn2);
  }({ channelId, focused, pipState: controllerPIPState, manuallyFocusedId: manualFocusedItem });
  function useActivityFocused(channelId) {
    channelId = channelId.channelId;
    const focused = channelId.focused;
    const guildId = focused;
    const mode = channelId.mode;
    const first = mode;
    const connected = channelId.connected;
    let closure_3 = connected;
    const items = [channelId];
    const callback = callback.useCallback((arg0) => {
      let connectedValue;
      let focusedParticipantId;
      ({ focusedParticipantId, connectedValue } = arg0);
      if (connectedValue) {
        connectedValue = tmp === constants.PANEL;
      }
      let tmp3 = null != focusedParticipantId;
      if (tmp3) {
        tmp3 = callback(participant.getParticipant(channelId, focusedParticipantId));
      }
      if (tmp3) {
        tmp3 = connectedValue;
      }
      const state = state.getState();
      state.setIsActivityFocused(tmp3);
    }, items);
    let obj = channelId(first[22]);
    const fn = function c() {
      const value = focused.get();
      let id;
      if (null != value) {
        id = value.id;
      }
      const items = [id, mode.get(), connected.get()];
      return items;
    };
    fn.__closure = { focused, mode, connected };
    fn.__workletHash = 16641161683997;
    fn.__initData = dismissPanel;
    const fn2 = function l(arg0, arg1) {
      let tmp4;
      let tmp5;
      let tmp6;
      let obj = channelId(mode[23]);
      let tmp;
      if (null != arg1) {
        tmp = arg1;
      }
      if (!obj.cheapWorkletArrayShallowEqual(arg0, tmp)) {
        [tmp4, tmp5, tmp6] = connected(arg0, 3);
        const tmp3 = connected(arg0, 3);
        obj = { focusedParticipantId: tmp4, voicePanelMode: tmp5, connectedValue: tmp6 };
        channelId(mode[22]).runOnJS(callback)(obj);
        const obj2 = channelId(mode[22]);
      }
    };
    obj = { cheapWorkletArrayShallowEqual: channelId(first[23]).cheapWorkletArrayShallowEqual, runOnJS: channelId(first[22]).runOnJS, handleAnimatedReaction: callback };
    fn2.__closure = obj;
    fn2.__workletHash = 15290799116693;
    fn2.__initData = closure_31;
    const animatedReaction = obj.useAnimatedReaction(fn, fn2);
  }({ channelId, focused, mode, connected });
  function useActivityConnected(setControlsMode) {
    setControlsMode = setControlsMode.setControlsMode;
    const channelId = setControlsMode;
    const items = [setControlsMode];
    const callback = React.useCallback(() => {
      setControlsMode({ mode: constants.FLOATING_DEFAULT });
    }, items);
    guildId(first[21])({ onTransition: callback });
  }({ setControlsMode });
  function useSpeakingWhileMutedNotification(showControls) {
    showControls = showControls.showControls;
    const channelId = showControls;
    const enableMuteWarning = guildId(closure_2[25]).useConfig({ location: "VoicePanelController" }).enableMuteWarning;
    const guildId = enableMuteWarning;
    closure_2 = React.useRef(0);
    const obj = guildId(closure_2[25]);
    const items = [safeArea];
    const stateFromStores = channelId(closure_2[26]).useStateFromStores(items, () => speakingWhileMuted.getSpeakingWhileMuted());
    let closure_3 = stateFromStores;
    const items1 = [stateFromStores, enableMuteWarning, showControls];
    const effect = React.useEffect(() => {
      let tmp = stateFromStores;
      if (stateFromStores) {
        tmp = enableMuteWarning;
      }
      if (tmp) {
        const _performance = performance;
        if (performance.now() - ref.current >= closure_32) {
          const _performance2 = performance;
          ref.current = performance.now();
          showControls();
          let obj = enableMuteWarning(ref[27]);
          obj = { key: "SPEAKING_WHILE_MUTED", icon: enableMuteWarning(ref[28]) };
          const intl = showControls(ref[29]).intl;
          obj.content = intl.string(showControls(ref[29]).t.29gnR4);
          obj.toastDurationMs = 3000;
          obj.open(obj);
        }
      }
    }, items1);
  }({ showControls });
  importDefault(dependencyMap[62])(channelId, mode, setMode, connected);
  importDefault(dependencyMap[63])();
  function useActivityOrientationState(isConnected) {
    isConnected = isConnected.isConnected;
    const channelId = isConnected;
    const selectedMode = isConnected.selectedMode;
    const guildId = selectedMode;
    const manualFocusedItem = isConnected.manualFocusedItem;
    const first = manualFocusedItem;
    const isNonVoiceEmbeddedActivityInPanelMode = isConnected.isNonVoiceEmbeddedActivityInPanelMode;
    let closure_3 = isNonVoiceEmbeddedActivityInPanelMode;
    const items = [closure_7];
    const stateFromStoresObject = channelId(first[26]).useStateFromStoresObject(items, () => {
      const currentEmbeddedActivity = store.getCurrentEmbeddedActivity();
      let applicationId;
      if (null != currentEmbeddedActivity) {
        applicationId = currentEmbeddedActivity.applicationId;
      }
      const obj = { applicationId };
      let compositeInstanceId;
      if (null != currentEmbeddedActivity) {
        compositeInstanceId = currentEmbeddedActivity.compositeInstanceId;
      }
      obj.instanceId = compositeInstanceId;
      if (null == applicationId) {
        let UNLOCKED = constants2.UNLOCKED;
      } else {
        UNLOCKED = store.getOrientationLockStateForApp(applicationId);
      }
      obj.activityOrientationLockState = UNLOCKED;
      return obj;
    });
    const applicationId = stateFromStoresObject.applicationId;
    const activityOrientationLockState = stateFromStoresObject.activityOrientationLockState;
    const connected = activityOrientationLockState;
    const instanceId = stateFromStoresObject.instanceId;
    const contentDimensions = instanceId;
    const items1 = [applicationId, isConnected, selectedMode, activityOrientationLockState, manualFocusedItem, isNonVoiceEmbeddedActivityInPanelMode, instanceId];
    const layoutEffect = applicationId.useLayoutEffect(() => {
      if (!isNonVoiceEmbeddedActivityInPanelMode) {
        if (selectedMode === constants.PANEL) {
          if (isConnected) {
            if (null != applicationId) {
              let obj = { applicationId, instanceId };
              if (manualFocusedItem === obj2.getEmbeddedActivityParticipantId(obj)) {
                selectedMode(manualFocusedItem[50])(activityOrientationLockState);
              }
              const obj2 = isConnected(manualFocusedItem[49]);
            }
            obj = { unlockAfterRotatingToPreviousLock: false };
            isConnected(manualFocusedItem[48]).unlockOrientation(obj);
            const obj4 = isConnected(manualFocusedItem[48]);
          }
        }
        obj = isConnected(manualFocusedItem[48]);
        const result = obj.restoreDefaultOrientation();
      }
    }, items1);
    const layoutEffect1 = applicationId.useLayoutEffect(() => () => callback(closure_2[48]).restoreDefaultOrientation(), []);
  }({ isConnected, selectedMode, manualFocusedItem, isNonVoiceEmbeddedActivityInPanelMode: stateFromStores1 });
  function useVoicePanelAnalytics(channelId) {
    channelId = channelId.channelId;
    const isConnected = channelId.isConnected;
    const guildId = isConnected;
    const selectedMode = channelId.selectedMode;
    const first = selectedMode;
    const items = [selectedMode, channelId, isConnected];
    const effect = React.useEffect(() => {
      if (tmp) {
        let obj = isConnected(selectedMode[47]);
        obj = { video_layout: callback(selectedMode) };
        const merged = Object.assign(channelId(selectedMode[54]).collectVoiceAnalyticsMetadata(channelId));
        obj.track(constants2.VIDEO_LAYOUT_TOGGLED, obj);
        const obj3 = channelId(selectedMode[54]);
      }
    }, items);
  }({ channelId, isConnected, selectedMode });
  const tmp8 = function useManuallyFocusedItem(guildId) {
    let focused;
    let layoutManager;
    guildId = guildId.guildId;
    let channelId = guildId;
    channelId = guildId.channelId;
    guildId = channelId;
    ({ layoutManager, focused } = guildId);
    const first = focused;
    let contentDimensions;
    let tmp6;
    const items = [focused];
    const manualFocusedItem = channelId(first[26]).useStateFromStores(items, () => selectedParticipantId.getSelectedParticipantId(channelId));
    let closure_3 = manualFocusedItem;
    const items1 = [guildId, channelId];
    const setFocused = setFocused.useCallback((embeddedActivityParticipantId) => {
      let result = null == embeddedActivityParticipantId;
      if (!result) {
        result = guildId(focused[52]).isVoicePanelParticipantFocusable(guildId, channelId, embeddedActivityParticipantId);
        const obj = guildId(focused[52]);
      }
      if (result) {
        const participant = channelId(focused[53]).selectParticipant(channelId, embeddedActivityParticipantId);
        const obj2 = channelId(focused[53]);
      }
    }, items1);
    let closure_5 = setFocused.useRef(undefined);
    let tmp3;
    if (null != manualFocusedItem) {
      tmp3 = manualFocusedItem;
    }
    const targetDimensions = layoutManager.getTargetDimensions(tmp3);
    contentDimensions = targetDimensions;
    const items2 = [focused, manualFocusedItem, targetDimensions];
    const layoutEffect = setFocused.useLayoutEffect(() => {
      let tmp = null;
      if (null != manualFocusedItem) {
        const obj = { id: manualFocusedItem };
        const merged = Object.assign(targetDimensions);
        tmp = obj;
      }
      let tmp6;
      if (null != tmp) {
        tmp6 = tmp;
      }
      const current = ref.current;
      let tmp7;
      if (null != current) {
        tmp7 = current;
      }
      if (!obj2.cheapWorkletShallowEqual(tmp6, tmp7)) {
        ref.current = tmp;
        const result = focused.set(tmp);
      }
    }, items2);
    tmp6 = guildId(first[52])(guildId, channelId, manualFocusedItem);
    const items3 = [manualFocusedItem, tmp6, setFocused];
    const effect = setFocused.useEffect(() => {
      if (null != manualFocusedItem) {
        if (!tmp6) {
          setFocused(null);
        }
      }
    }, items3);
    const items4 = [setFocused];
    const effect1 = setFocused.useEffect(() => () => callback(null), items4);
    return { setFocused, manualFocusedItem };
  }({ guildId, channelId, layoutManager, focused });
  ({ showFloatingCTA: closure_34, setShowFloatingCTA: closure_35 } = function useShowFloatingCTA(mode) {
    const channelId = mode;
    let closure_1 = React.useRef(-1);
    const showFloatingCTA = channelId(first[22]).useSharedValue(null);
    const first = showFloatingCTA;
    const items = [mode, showFloatingCTA];
    const setShowFloatingCTA = React.useCallback((arg0) => {
      if (arg0.get() === constants.PANEL) {
        const result = showFloatingCTA.set(arg0);
        if (null != arg0) {
          const _clearTimeout = clearTimeout;
          clearTimeout(ref.current);
          const _setTimeout = setTimeout;
          ref.current = setTimeout(() => {
            const result = closure_2.set(null);
          }, arg0(showFloatingCTA[34]).FLOATING_CTA_HIDE_TIMEOUT);
        }
      }
    }, items);
    const layoutEffect = React.useLayoutEffect(() => () => clearTimeout(ref.current), []);
    return { showFloatingCTA, setShowFloatingCTA };
  }(mode));
  closure_36 = React.useRef(undefined);
  const ref = React.useRef(0);
  closure_37 = ref;
  const effect1 = React.useEffect(() => {
    ref.current = 0;
  });
  if (null != ref.current) {
    ref.current = ref.current + 1;
    if (ref.current > 10) {
      obj = { category: "voice-panel" };
      const _HermesInternal = HermesInternal;
      obj.message = "VoicePanelController is rendering too many times (>" + ref.current + ")";
      importDefault(dependencyMap[64]).addBreadcrumb(obj);
      ref.current = null;
      const obj5 = importDefault(dependencyMap[64]);
    }
  }
  obj1 = { value: callback(React.useState(() => ({ channelId, channelType: closure_4, connected, contentDimensions, controlsSpecs, dismissPanel, dismissToPIPGestureRef: closure_36, dragScrolling: closure_7, focused, generateStateLocker: closure_23, guildId, hideControls: closure_26, isCall: closure_9, isFocusedVideoZoomed: closure_17, layoutManager, mode, morphablePanelMode: closure_21, mountedCards: closure_3, pipAvoidanceSpecs: closure_33, preJoinContentSize: closure_12, safeArea, scrollPosition: closure_14, setControlsMode, setFocused: closure_31, setIsFocusedVideoZoomed: closure_18, setMode, setShowFloatingCTA: closure_35, showControls, showFloatingCTA: closure_34, streamOutputSinkStack: first, usePIPState: channelId(first[65]).usePIPState, useReducedMotion: closure_19, windowDimensions, wrapperDimensions: closure_16, wrapperOffset: closure_20, panelCardStillInPIP: closure_22 })), 1)[0] };
  obj2 = { value: controllerPIPState };
  const obj3 = {};
  let tmp33 = null;
  if (null != guildId) {
    tmp33 = guildId;
  }
  obj3.value = tmp33;
  obj3.children = children;
  obj2.children = jsx(importDefault(dependencyMap[67]).Provider, obj3);
  obj1.children = jsx(arg1(dependencyMap[65]).VoicePanelPIPStateContext.Provider, obj2);
  return jsx(importDefault(dependencyMap[66]).Provider, obj1);
};