decord/source/modules/calls/ChannelRTCStore.tsx

// Module ID: 4144
// Function ID: 34745
// Name: _isNativeReflectConstruct
// Dependencies: [6, 7, 15, 17, 18, 57, 1347, 4145, 4150, 1194, 4810, 1348, 4218, 1907, 4953, 1850, 10450, 4147, 4149, 653, 3, 10449, 22, 44, 8848, 4195, 566, 686, 2]

// Module 4144 (_isNativeReflectConstruct)
import _createForOfIteratorHelperLoose from "_createForOfIteratorHelperLoose";
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
import closure_5 from "_isNativeReflectConstruct";
import closure_6 from "_isNativeReflectConstruct";
import closure_7 from "ParticipantTypes";
import _slicedToArray from "_slicedToArray";
import closure_9 from "_createForOfIteratorHelperLoose";
import closure_10 from "_isNativeReflectConstruct";
import closure_11 from "_isNativeReflectConstruct";
import closure_12 from "_isNativeReflectConstruct";
import closure_13 from "_isNativeReflectConstruct";
import closure_14 from "_isNativeReflectConstruct";
import closure_15 from "_isNativeReflectConstruct";
import closure_16 from "_isNativeReflectConstruct";
import closure_17 from "_isNativeReflectConstruct";
import closure_18 from "_isNativeReflectConstruct";
import closure_19 from "_isNativeReflectConstruct";
import closure_20 from "_isNativeReflectConstruct";
import ParticipantTypes from "ParticipantTypes";
import ME from "ME";
import importDefaultResult from "_getPrototypeOf";
import set from "_possibleConstructorReturn";

let closure_21;
let closure_22;
let closure_23;
let closure_24;
let closure_25;
let closure_26;
let closure_27;
let require = arg1;
function _isNativeReflectConstruct() {
  let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {

  }));
  function _isNativeReflectConstruct() {
    return closure_0;
  }
  const result = _isNativeReflectConstruct();
}
function _createForOfIteratorHelperLoose(iterable) {
  let closure_0 = iterable;
  iterable = "undefined" !== typeof Symbol;
  if (iterable) {
    const _Symbol = Symbol;
    iterable = iterable[Symbol.iterator];
  }
  if (!iterable) {
    iterable = iterable[Symbol.iterator];
  }
  if (iterable) {
    const iter = iterable.call(iterable);
    const next = iter.next;
    return next.bind(iter);
  } else {
    const _Array = Array;
    let tmp = iterable;
    if (!Array.isArray(iterable)) {
      let tmp2;
      if (iterable) {
        if ("string" === typeof iterable) {
          tmp2 = _arrayLikeToArray(iterable, undefined);
        } else {
          const toString = {}.toString;
          const substr = toString.call(iterable).slice(8, -1);
          let name = substr;
          if (tmp3) {
            name = iterable.constructor.name;
          }
          if ("Map" !== name) {
            if ("Set" !== name) {
              if ("Arguments" === name) {
                let arr = _arrayLikeToArray(iterable, undefined);
              } else {
                let obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
              }
            }
            tmp2 = arr;
          }
          const _Array2 = Array;
          arr = Array.from(iterable);
          const callResult = toString.call(iterable);
          tmp3 = "Object" === substr && iterable.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) {
      closure_0 = tmp;
    }
    let c1 = 0;
    return () => {
      if (closure_1 >= length.length) {
        let obj = { done: true };
      } else {
        obj = { done: false };
        closure_1 = tmp3 + 1;
        obj.value = length[+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 _getParticipants(channelId) {
  let tmp = table[channelId];
  if (null == tmp) {
    let tmp4 = importDefault(10449);
    const prototype = tmp4.prototype;
    tmp4 = new tmp4(channelId);
    table[channelId] = tmp4;
    tmp = tmp4;
  }
  return tmp;
}
function updateParticipants(arg0) {
  let arr = arg1;
  let closure_0 = arg0;
  if (arg1 === undefined) {
    arr = closure_30;
  }
  return arr.reduce((arg0, arg1) => {
    if (!callback(outer1_45(arg1))) {
      return arg0;
    } else {
      let obj = outer1_45(arg1);
      if (0 === obj.size()) {
        (function updateSelectedParticipantId(arg0) {
          let id = outer2_12.getId();
          const obj = outer2_45(arg0);
          if (0 !== obj.size()) {
            if (outer2_16.getVoiceChannelId() === arg0) {
              const NONE2 = outer2_22.NONE;
              const found = obj.toArray(callback(outer2_2[21]).ChannelRTCParticipantsIndexes.STREAM).find((type) => {
                let activeStreamForStreamKey = type.type === outer3_21.STREAM;
                if (activeStreamForStreamKey) {
                  activeStreamForStreamKey = outer3_11.getActiveStreamForStreamKey(type.id);
                }
                return activeStreamForStreamKey;
              });
              if (null != found) {
                outer2_1(outer2_2[23])(found.type === outer2_21.STREAM, "Impossible condition");
                id = found.id;
              } else if (1 !== obj.size()) {
                if (1 === obj.size(callback(outer2_2[21]).ChannelRTCParticipantsIndexes.VIDEO)) {
                  id = outer2_8(obj.toArray(callback(outer2_2[21]).ChannelRTCParticipantsIndexes.VIDEO), 1)[0].id;
                } else {
                  const found1 = obj.toArray().find((type) => {
                    let tmp = type.type === outer3_21.USER;
                    if (tmp) {
                      tmp = type.id !== id;
                    }
                    if (tmp) {
                      tmp = !type.ringing;
                    }
                    return tmp;
                  });
                  let id1;
                  if (null != found1) {
                    id1 = found1.id;
                  }
                  if (null != id1) {
                    id = id1;
                  }
                  const toArrayResult1 = obj.toArray();
                }
              }
              const first = outer2_8(outer2_48(arg0), 1)[0];
              let NONE = first;
              if (first !== outer2_22.AUTO) {
                NONE = first;
                if (first !== outer2_22.NONE) {
                  const participant = obj.getParticipant(first);
                  let tmp17 = null == participant;
                  if (!tmp17) {
                    let tmp19 = participant.type === outer2_21.STREAM;
                    if (tmp19) {
                      tmp19 = null == outer2_11.getActiveStreamForStreamKey(participant.id);
                    }
                    tmp17 = tmp19;
                  }
                  NONE = first;
                  if (tmp17) {
                    NONE = outer2_22.NONE;
                  }
                }
              }
              const items = [NONE, id];
              outer2_51(arg0, items);
            }
          }
          outer2_51(arg0, null);
        })(arg1);
      } else {
        if (!outer1_58(arg1)) {
          if (!outer1_52(obj)) {
            let VIDEO = outer1_25.VOICE;
          }
          if (VIDEO !== outer1_25.VOICE) {
            outer1_35[arg1] = VIDEO;
          }
        }
        VIDEO = outer1_25.VIDEO;
      }
      let tmp13;
      if (null != outer1_36[arg1]) {
        tmp13 = tmp11[outer1_27.APP];
      }
      delete tmp3[tmp2];
      if (tmp13 !== outer1_24.HAVEN) {
        delete tmp[tmp2];
      }
    }
  }, false);
}
function updateParticipant(arg0) {
  let tmp = arg1;
  let closure_0 = arg0;
  if (arg1 === undefined) {
    tmp = closure_30;
  }
  return updateParticipants((updateParticipant) => updateParticipant.updateParticipant(closure_0), tmp);
}
function _getSelectedParticipantId(channelId) {
  const channel = store2.getChannel(channelId);
  if (null != channel) {
    channel.isDM();
  }
  let tmp3 = dependencyMap[channelId];
  if (null == tmp3) {
    const items = [tmp2, constants2.NONE];
    tmp3 = items;
  }
  return tmp3;
}
function getHasSelectedParticipant(channelId) {
  let tmp = null != dependencyMap[channelId];
  if (tmp) {
    tmp = callback3(dependencyMap[channelId], 1)[0] !== constants2.NONE;
  }
  return tmp;
}
function updateElapsedSelectedParticipantStats(currentVoiceChannelId) {
  if (null == dependencyMap2[currentVoiceChannelId]) {
    dependencyMap2[currentVoiceChannelId] = { gridDurationMs: 0, focusDurationMs: 0, toggleCount: 0, lastUpdate: 0 };
  }
  const nowResult = performance.now();
  if (dependencyMap2[currentVoiceChannelId].lastUpdate > 0) {
    let str = "gridDurationMs";
    const diff = nowResult - tmp2.lastUpdate;
    if (tmp4) {
      str = "focusDurationMs";
    }
    tmp2[str] = tmp2[str] + diff;
  }
  dependencyMap2[currentVoiceChannelId].lastUpdate = nowResult;
}
function setSelectedParticipantId(channelId, arg1) {
  updateElapsedSelectedParticipantStats(channelId);
  if (null == arg1) {
    delete tmp2[tmp];
  } else {
    closure_33[channelId] = arg1;
  }
  if (tmp4 !== getHasSelectedParticipant(channelId)) {
    dependencyMap2[channelId].toggleCount = dependencyMap2[channelId].toggleCount + 1;
  }
}
function hasVideo(id) {
  let hasEmbeddedActivityResult = id.size(require(10449) /* getEmbeddedActivityParticipantId */.ChannelRTCParticipantsIndexes.STREAM) > 0;
  if (!hasEmbeddedActivityResult) {
    hasEmbeddedActivityResult = id.size(require(10449) /* getEmbeddedActivityParticipantId */.ChannelRTCParticipantsIndexes.VIDEO) > 0;
  }
  if (!hasEmbeddedActivityResult) {
    hasEmbeddedActivityResult = id.hasEmbeddedActivity();
  }
  return hasEmbeddedActivityResult;
}
function clearChannel(arg0) {
  delete tmp3[tmp2];
  delete tmp3[tmp2];
  delete tmp3[tmp2];
  delete tmp[tmp2];
}
function handleRebuildActiveChannels() {
  const items = [];
  const channelId = store3.getChannelId();
  if (null != channelId) {
    items.push(channelId);
  }
  const voiceChannelId = store3.getVoiceChannelId();
  if (!tmp5) {
    items.push(voiceChannelId);
  }
  remoteSessionId = remoteSessionId.getRemoteSessionId();
  voiceStateForSession = voiceStateForSession.getVoiceStateForSession(store.getId(), remoteSessionId);
  let channelId1;
  if (null != voiceStateForSession) {
    channelId1 = voiceStateForSession.channelId;
  }
  if (null != channelId1) {
    let channelId2;
    if (null != voiceStateForSession) {
      channelId2 = voiceStateForSession.channelId;
    }
    items.push(channelId2);
  }
  const tmp = updateParticipants;
  tmp5 = null == voiceChannelId || items.includes(voiceChannelId);
  const obj = importDefault(22);
  const item = importDefault(22).difference(items, items).forEach(clearChannel);
  const differenceResult = importDefault(22).difference(items, items);
  return tmp((rebuild) => rebuild.rebuild(), importDefault(22).difference(items, items));
}
function setChatOpen(channelId, chatOpen) {
  closure_39[channelId] = chatOpen;
  if (chatOpen) {
    obj.add(channelId);
  } else {
    obj.delete(channelId);
  }
}
function deleteChatOpen(currentVoiceChannelId) {
  delete tmp[tmp2];
  set.delete(currentVoiceChannelId);
}
function handleEmbeddedActivityChange() {
  return updateParticipants((updateEmbeddedActivities) => updateEmbeddedActivities.updateEmbeddedActivities());
}
function handleSpeaking(userId) {
  userId = userId.userId;
  return updateParticipants((updateParticipantSpeaking) => updateParticipantSpeaking.updateParticipantSpeaking(userId));
}
function handleUserUpdate(user) {
  return updateParticipant(user.user.id);
}
function handleCallUpdate(channelId) {
  const items = [channelId.channelId];
  return updateParticipants((rebuild) => rebuild.rebuild(), items);
}
function handleChannelDelete(channel) {
  const id = channel.channel.id;
  deleteChatOpen(id);
  delete tmp2[tmp];
  clearChannel(id);
}
function handleStreamClose(streamKey) {
  const decodeStreamKeyResult = require(4195) /* isStreamKey */.decodeStreamKey(streamKey.streamKey);
  const items = [decodeStreamKeyResult.channelId];
  return updateParticipant(decodeStreamKeyResult.ownerId, items);
}
function isGuildVocalOrThread(channelId) {
  const channel = store2.getChannel(channelId);
  let isGuildVocalOrThreadResult;
  if (null != channel) {
    isGuildVocalOrThreadResult = channel.isGuildVocalOrThread();
  }
  return Boolean(isGuildVocalOrThreadResult);
}
({ ParticipantTypes: closure_21, ParticipantSelectionTypes: closure_22, isStreamParticipant: closure_23 } = ParticipantTypes);
({ ChannelLayouts: closure_24, ChannelModes: closure_25, ChannelTypes: closure_26, AppContext: closure_27 } = ME);
importDefaultResult = new importDefaultResult("ChannelRTCStore");
importDefaultResult.enableNativeLogger(true);
const frozen = Object.freeze([]);
let closure_30 = [];
let set = new Set();
let closure_32 = {};
let closure_33 = {};
let closure_34 = {};
let closure_35 = {};
let closure_36 = {};
let closure_37 = {};
let closure_38 = {};
let closure_39 = {};
let closure_40 = {};
let closure_41 = {};
let tmp8 = ((PersistedStore) => {
  class ChannelRTCStore {
    constructor() {
      self = this;
      tmp = outer1_3(this, ChannelRTCStore);
      obj = outer1_6(ChannelRTCStore);
      tmp2 = outer1_5;
      if (outer1_42()) {
        tmp6 = globalThis;
        _Reflect = Reflect;
        tmp7 = outer1_6;
        tmp8 = arguments;
        constructResult = Reflect.construct(obj, arguments, outer1_6(self).constructor);
      } else {
        tmp3 = arguments;
        tmp4 = arguments;
        constructResult = obj(...arguments);
      }
      return tmp2(self, constructResult);
    }
  }
  callback2(ChannelRTCStore, PersistedStore);
  let obj = {
    key: "initialize",
    value(voiceParticipantsHidden) {
      this.waitFor(outer1_11, outer1_12, outer1_13, outer1_14, outer1_9, outer1_10, outer1_15, outer1_16, outer1_17, outer1_18, outer1_19, outer1_20);
      const items = [outer1_9];
      this.syncWith(items, outer1_57);
      const items1 = [outer1_10];
      this.syncWith(items1, outer1_54);
      let prop;
      if (null != voiceParticipantsHidden) {
        prop = voiceParticipantsHidden.voiceParticipantsHidden;
      }
      if (undefined !== prop) {
        let prop1;
        if (null != voiceParticipantsHidden) {
          prop1 = voiceParticipantsHidden.voiceParticipantsHidden;
        }
        const merged = Object.assign(outer1_38, prop1);
        const tmp6 = outer1_38;
      }
    }
  };
  let items = [obj, , , , , , , , , , , , , , , , , , , , , , , , , ];
  obj = {
    key: "getState",
    value() {
      return { voiceParticipantsHidden: outer1_38 };
    }
  };
  items[1] = obj;
  obj = {
    key: "getParticipantsVersion",
    value(arg0) {
      return outer1_45(arg0).version;
    }
  };
  items[2] = obj;
  items[3] = {
    key: "getParticipants",
    value(arg0) {
      let toArrayResult = outer1_45(arg0).toArray();
      if (null == toArrayResult) {
        toArrayResult = outer1_29;
      }
      return toArrayResult;
    }
  };
  items[4] = {
    key: "getSpeakingParticipants",
    value(arg0) {
      let toArrayResult = outer1_45(arg0).toArray(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.SPEAKING);
      if (null == toArrayResult) {
        toArrayResult = outer1_29;
      }
      return toArrayResult;
    }
  };
  items[5] = {
    key: "getFilteredParticipants",
    value(arg0) {
      const obj = outer1_45(arg0);
      if (null != outer1_38[arg0]) {
        if (tmp) {
          let toArrayResult = obj.toArray(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.FILTERED);
        }
        return toArrayResult;
      }
      toArrayResult = obj.toArray(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.NOT_POPPED_OUT);
    }
  };
  items[6] = {
    key: "getVideoParticipants",
    value(arg0) {
      let toArrayResult = outer1_45(arg0).toArray(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.VIDEO);
      if (null == toArrayResult) {
        toArrayResult = outer1_29;
      }
      return toArrayResult;
    }
  };
  items[7] = {
    key: "getStreamParticipants",
    value(arg0) {
      let toArrayResult = outer1_45(arg0).toArray(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.STREAM);
      if (null == toArrayResult) {
        toArrayResult = outer1_29;
      }
      return toArrayResult;
    }
  };
  items[8] = {
    key: "getActivityParticipants",
    value(arg0) {
      let toArrayResult = outer1_45(arg0).toArray(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.ACTIVITY);
      if (null == toArrayResult) {
        toArrayResult = outer1_29;
      }
      return toArrayResult;
    }
  };
  items[9] = {
    key: "getParticipant",
    value(arg0, arg1) {
      return outer1_45(arg0).getParticipant(arg1);
    }
  };
  items[10] = {
    key: "getUserParticipantCount",
    value(arg0) {
      const obj = outer1_45(arg0);
      const diff = obj.size() - obj.size(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.STREAM);
      return diff - obj.size(ChannelRTCStore(outer1_2[21]).ChannelRTCParticipantsIndexes.ACTIVITY);
    }
  };
  items[11] = {
    key: "getParticipantsOpen",
    value(arg0) {
      return null == outer1_37[arg0] || outer1_37[arg0];
    }
  };
  items[12] = {
    key: "getVoiceParticipantsHidden",
    value(arg0) {
      return null != outer1_38[arg0] && outer1_38[arg0];
    }
  };
  items[13] = {
    key: "getSelectedParticipantId",
    value(arg0) {
      const tmp = outer1_8(outer1_48(arg0), 2);
      let first = tmp[0];
      let tmp4 = null;
      if (first !== outer1_22.NONE) {
        if (first === outer1_22.AUTO) {
          let tmp7 = null;
          if (tmp3 !== outer1_22.NONE) {
            tmp7 = null;
            if (tmp3 !== outer1_22.AUTO) {
              tmp7 = tmp3;
            }
          }
          first = tmp7;
        }
        tmp4 = first;
      }
      return tmp4;
    }
  };
  items[14] = {
    key: "getSelectedParticipant",
    value(arg0) {
      const selectedParticipantId = this.getSelectedParticipantId(arg0);
      let participant = null;
      if (null != selectedParticipantId) {
        participant = outer1_45(arg0).getParticipant(selectedParticipantId);
        const obj = outer1_45(arg0);
      }
      return participant;
    }
  };
  items[15] = {
    key: "getSelectedParticipantStats",
    value(arg0) {
      if (null == outer1_34[arg0]) {
        let obj = {};
      } else {
        obj = {};
        const _Math = Math;
        obj.view_mode_grid_duration_ms = Math.floor(tmp.gridDurationMs);
        const _Math2 = Math;
        obj.view_mode_focus_duration_ms = Math.floor(tmp.focusDurationMs);
        obj.view_mode_toggle_count = tmp.toggleCount;
      }
      return obj;
    }
  };
  items[16] = {
    key: "getGuildRingingUsers",
    value(arg0) {
      return outer1_45(arg0).guildRingingUsers;
    }
  };
  items[17] = {
    key: "getMode",
    value(arg0) {
      if (null != outer1_35[arg0]) {
        return tmp;
      } else {
        outer1_58(arg0) ? outer1_25.VIDEO : outer1_25.VOICE;
      }
    }
  };
  items[18] = {
    key: "getLayout",
    value(arg0) {
      if (arg1 === undefined) {
        const APP = outer1_27.APP;
      }
      return outer1_24.NORMAL;
    }
  };
  items[19] = {
    key: "getChatOpen",
    value(arg0) {
      return null != outer1_39[arg0] && outer1_39[arg0];
    }
  };
  items[20] = {
    key: "getAllChatOpen",
    value() {
      return outer1_39;
    }
  };
  items[21] = {
    key: "getOpenChatChannelIds",
    value() {
      return outer1_31;
    }
  };
  items[22] = {
    key: "isFullscreenInContext",
    value() {
      let APP = arg0;
      if (arg0 === undefined) {
        APP = outer1_27.APP;
      }
      const values = Object.values(outer1_36);
      return values.some((arg0) => arg0[APP] === outer2_24.FULL_SCREEN);
    }
  };
  items[23] = {
    key: "getStageStreamSize",
    value(arg0) {
      return outer1_40[arg0];
    }
  };
  items[24] = {
    key: "getStageVideoLimitBoostUpsellDismissed",
    value(arg0) {
      return outer1_41[arg0];
    }
  };
  items[25] = {
    key: "isParticipantPoppedOut",
    value(arg0, arg1) {
      const participant = this.getParticipant(arg0, arg1);
      let tmp2 = null != participant;
      if (tmp2) {
        tmp2 = "isPoppedOut" in participant && participant.isPoppedOut;
        const tmp3 = "isPoppedOut" in participant && participant.isPoppedOut;
      }
      return tmp2;
    }
  };
  return callback(ChannelRTCStore, items);
})(require("initialize").PersistedStore);
tmp8.displayName = "ChannelRTCStore";
tmp8.persistKey = "ChannelRTCStore";
tmp8 = new tmp8(require("dispatcher"), {
  CONNECTION_OPEN: function handleConnectionOpen() {
    let done;
    const tmp = _createForOfIteratorHelperLoose(closure_30);
    let iter = tmp();
    if (!iter.done) {
      do {
        let tmp2 = clearChannel;
        let tmp3 = clearChannel(iter.value);
        let iter2 = tmp();
        iter = iter2;
        done = iter2.done;
      } while (!done);
    }
    handleRebuildActiveChannels();
  },
  CONNECTION_OPEN_SUPPLEMENTAL: handleRebuildActiveChannels,
  THREAD_LIST_SYNC: handleRebuildActiveChannels,
  OVERLAY_INITIALIZE: handleRebuildActiveChannels,
  VOICE_CHANNEL_SELECT: function handleVoiceChannelSelect(arg0) {
    let channelId;
    let currentVoiceChannelId;
    ({ channelId, currentVoiceChannelId } = arg0);
    let c0;
    if (null != channelId) {
      delete tmp[tmp4];
    } else if (null != currentVoiceChannelId) {
      deleteChatOpen(currentVoiceChannelId);
      delete tmp2[tmp3];
      updateElapsedSelectedParticipantStats(currentVoiceChannelId);
    }
    let flag = false;
    if (channelId !== currentVoiceChannelId) {
      flag = false;
      if (null != currentVoiceChannelId) {
        const tmp12 = _getParticipants(currentVoiceChannelId);
        c0 = tmp12;
        const guildRingingUsers = tmp12.guildRingingUsers;
        const item = guildRingingUsers.forEach((arg0) => _undefined.updateGuildRingingUsers(arg0, false));
        const items = [currentVoiceChannelId];
        flag = updateParticipants((rebuild) => rebuild.rebuild(), items);
      }
    }
    if (!flag) {
      flag = handleRebuildActiveChannels();
    }
    return flag;
  },
  CHANNEL_SELECT: function handleChannelSelect(channelId) {
    channelId = channelId.channelId;
    const tmp = handleRebuildActiveChannels();
    if (null == channelId) {
      return tmp;
    } else if (null == channelId.messageId) {
      return tmp;
    } else if (table2[channelId]) {
      return tmp;
    } else {
      const channel = store2.getChannel(channelId);
      let tmp4 = tmp;
      if (null != channel) {
        let flag = tmp;
        if (channel.isGuildVocal()) {
          setChatOpen(channelId, true);
          flag = true;
        }
        tmp4 = flag;
      }
      return tmp4;
    }
  },
  CHANNEL_RTC_ACTIVE_CHANNELS: handleRebuildActiveChannels,
  VOICE_STATE_UPDATES: function handleVoiceStateUpdates(arg0) {
    let require;
    let voiceStates;
    ({ voiceStates, initial: require } = arg0);
    return voiceStates.reduce((arg0, arg1) => {
      let channelId;
      let guildId;
      let userId;
      ({ userId, channelId, guildId } = arg1);
      if (tmp) {
        let obj = outer1_1(outer1_2[24]);
        obj = { guildId, location: "voice_status_update" };
        obj = { autoTrackExposure: false };
        if (obj.getCurrentConfig(obj, obj).enabled) {
          const result = outer1_45(channelId).updateGuildRingingUsers(userId, false);
          const obj4 = outer1_45(channelId);
        }
      }
      if (closure_0) {
        if (null != channelId) {
          let tmp7 = arg0;
        }
        return tmp7;
      }
      tmp7 = outer1_47(userId) || arg0;
    }, false);
  },
  CHANNEL_CREATE: function handleChannelCreate(channel) {
    channel = channel.channel;
    if (channel.type === constants4.GROUP_DM) {
      const originChannelId = channel.originChannelId;
      if (null != originChannelId) {
        const obj = {};
        let NORMAL;
        if (null != dependencyMap3[originChannelId]) {
          NORMAL = tmp5[constants5.APP];
        }
        if (null == NORMAL) {
          NORMAL = constants3.NORMAL;
        }
        obj[constants5.APP] = NORMAL;
        dependencyMap3[channel.id] = obj;
        return true;
      }
    }
    return false;
  },
  CHANNEL_DELETE: handleChannelDelete,
  THREAD_DELETE: handleChannelDelete,
  CALL_CREATE: handleCallUpdate,
  CALL_UPDATE: handleCallUpdate,
  CALL_DELETE: function handleCallDelete(channelId) {
    clearChannel(channelId.channelId);
  },
  CHANNEL_RTC_SELECT_PARTICIPANT: function handleSelectParticipant(channelId) {
    channelId = channelId.channelId;
    const id = channelId.id;
    const tmp3 = _getParticipants(channelId);
    const require = tmp3;
    if (null == id) {
      const item = tmp3.toArray(require(10449) /* getEmbeddedActivityParticipantId */.ChannelRTCParticipantsIndexes.STREAM).forEach((user) => {
        if (outer1_23(user)) {
          tmp3.updateParticipant(user.user.id);
        }
      });
      const toArrayResult = tmp3.toArray(require(10449) /* getEmbeddedActivityParticipantId */.ChannelRTCParticipantsIndexes.STREAM);
    }
    if (null != id) {
      let NONE = id;
    } else {
      NONE = constants2.NONE;
    }
    const items = [NONE, callback3(_getSelectedParticipantId(channelId), 2)[1]];
    setSelectedParticipantId(channelId, items);
    if (obj2.isStreamKey(id)) {
      const ownerId = require(4195) /* isStreamKey */.decodeStreamKey(tmp2).ownerId;
      if (ownerId === store.getId()) {
        const items1 = [tmp];
        updateParticipant(tmp14, items1);
      }
      while (true) {
        let tmp20 = hasVideo;
        if (hasVideo(tmp3)) {
          break;
        } else {
          let tmp21 = closure_37;
          let tmp22 = channelId;
          let flag = false;
          closure_37[tmp] = false;
          break;
        }
        break;
      }
      const obj3 = require(4195) /* isStreamKey */;
      tmp14 = ownerId;
    }
  },
  CHANNEL_RTC_POPOUT_PARTICIPANT: function handlePopOutParticipant(arg0) {
    let channelId;
    let participantId;
    ({ channelId, participantId } = arg0);
    if (callback3(_getSelectedParticipantId(channelId), 1)[0] === participantId) {
      setSelectedParticipantId(channelId, null);
    }
    const obj = _getParticipants(channelId);
    const participant = obj.getParticipant(participantId);
    let tmp5 = null != participant;
    if (tmp5) {
      tmp5 = participant.type !== constants.ACTIVITY;
    }
    if (tmp5) {
      const result = obj.updateParticipantPoppedOut(participantId, true);
      const items = [channelId];
      updateParticipant(participant.user.id, items);
    }
  },
  CHANNEL_RTC_RETURN_PARTICIPANT: function handleReturnParticipant(arg0) {
    let channelId;
    let participantId;
    ({ channelId, participantId } = arg0);
    const obj = _getParticipants(channelId);
    const result = obj.updateParticipantPoppedOut(participantId, false);
    const participant = obj.getParticipant(participantId);
    let tmp3 = null != participant;
    if (tmp3) {
      tmp3 = participant.type !== constants.ACTIVITY;
    }
    if (tmp3) {
      const items = [channelId];
      updateParticipant(participant.user.id, items);
    }
  },
  CHANNEL_RTC_UPDATE_LAYOUT: function handleCallLayout(channelId) {
    let appContext;
    let layout;
    channelId = channelId.channelId;
    const obj = {};
    ({ layout, appContext } = channelId);
    const merged = Object.assign(dependencyMap3[channelId]);
    obj[appContext] = layout;
    dependencyMap3[channelId] = obj;
  },
  CHANNEL_RTC_UPDATE_PARTICIPANTS_OPEN: function handleUpdateParticipantsOpen(channelId) {
    closure_37[channelId.channelId] = channelId.participantsOpen;
  },
  CHANNEL_RTC_UPDATE_VOICE_PARTICIPANTS_HIDDEN: function handleUpdateVoiceParticipantsHidden(channelId) {
    closure_38[channelId.channelId] = channelId.voiceParticipantsHidden;
  },
  CHANNEL_RTC_UPDATE_STAGE_STREAM_SIZE: function handleUpdateStageStreamSize(channelId) {
    closure_40[channelId.channelId] = channelId.large;
  },
  CHANNEL_RTC_UPDATE_STAGE_VIDEO_LIMIT_BOOST_UPSELL_DISMISSED: function handleUpdateStageVideoLimitBoostUpsellDismissed(channelId) {
    closure_41[channelId.channelId] = channelId.dismissed;
  },
  STREAM_UPDATE_SELF_HIDDEN: function handleUpdateSelfStreamHidden(channelId) {
    channelId = channelId.channelId;
    const id = store.getId();
    if (channelId.selfStreamHidden) {
      const first = callback3(_getSelectedParticipantId(channelId), 1)[0];
      const obj2 = require(4195) /* isStreamKey */;
      if (tmp6) {
        setSelectedParticipantId(channelId, null);
      }
      tmp6 = require(4195) /* isStreamKey */.isStreamKey(first) && first.includes(id);
    }
    const items = [channelId];
    updateParticipant(id, items);
  },
  CHANNEL_RTC_UPDATE_CHAT_OPEN: function handleUpdateChatOpen(channelId) {
    setChatOpen(channelId.channelId, channelId.chatOpen);
  },
  RTC_CONNECTION_VIDEO: function handleRTCConnectionVideo(channelId) {
    const items = [channelId.channelId];
    return updateParticipant(channelId.userId, items);
  },
  RTC_CONNECTION_PLATFORM: function handleRTCConnectionPlatform(channelId) {
    const items = [channelId.channelId];
    return updateParticipant(channelId.userId, items);
  },
  AUDIO_SET_LOCAL_VIDEO_DISABLED: function handleMediaEngineSetLocalVideoDisabled(userId) {
    return updateParticipant(userId.userId);
  },
  MEDIA_ENGINE_VIDEO_SOURCE_QUALITY_CHANGED: function handleVideoSourceQuality(channelId) {
    let dependencyMap;
    let importDefault;
    let require;
    ({ senderUserId: require, maxResolution: importDefault, maxFrameRate: dependencyMap } = channelId);
    const items = [channelId.channelId];
    return updateParticipants((updateParticipantQuality) => updateParticipantQuality.updateParticipantQuality(closure_0, closure_1, closure_2), items);
  },
  STREAM_CLOSE: handleStreamClose,
  STREAM_DELETE: handleStreamClose,
  STREAM_WATCH: function handleStreamWatch(streamKey) {
    const decodeStreamKeyResult = require(4195) /* isStreamKey */.decodeStreamKey(streamKey.streamKey);
    const items = [decodeStreamKeyResult.channelId];
    return updateParticipant(decodeStreamKeyResult.ownerId, items);
  },
  SPEAKING: handleSpeaking,
  GUILD_SOUNDBOARD_SOUND_PLAY_START: handleSpeaking,
  GUILD_SOUNDBOARD_SOUND_PLAY_END: handleSpeaking,
  PUSH_TO_TALK_STATE_CHANGE: function handlePushToTalkStateChange() {
    return updateParticipants((updateParticipantSpeaking) => updateParticipantSpeaking.updateParticipantSpeaking(outer1_12.getId()));
  },
  GUILD_RING_START: function handleGuildRingStart(channelId) {
    let guildId;
    let ongoingRings;
    channelId = channelId.channelId;
    let closure_0;
    ({ guildId, ongoingRings } = channelId);
    if (obj.getCurrentConfig({ guildId, location: "guild_ring_start" }).enabled) {
      closure_0 = _getParticipants(channelId);
      const _Object = Object;
      const keys = Object.keys(ongoingRings);
      const item = keys.forEach((arg0) => closure_0.updateGuildRingingUsers(arg0, true));
      const items = [channelId];
      return updateParticipants((rebuild) => rebuild.rebuild(), items);
    } else {
      return false;
    }
    obj = importDefault(8848);
  },
  GUILD_RING_STOP: function handleGuildRingStop(guildId) {
    let channelId;
    let ringing;
    ({ channelId, ringing } = guildId);
    let closure_0;
    if (obj.getCurrentConfig({ guildId: guildId.guildId, location: "guild_ring_start" }).enabled) {
      closure_0 = _getParticipants(channelId);
      const item = ringing.forEach((arg0) => closure_0.updateGuildRingingUsers(arg0, false));
      const items = [channelId];
      return updateParticipants((rebuild) => rebuild.rebuild(), items);
    } else {
      return false;
    }
    obj = importDefault(8848);
  },
  USER_UPDATE: handleUserUpdate,
  GUILD_MEMBER_UPDATE: handleUserUpdate,
  GUILD_DELETE: function handleGuildDelete(guild) {
    guild = guild.guild;
    const items = [];
    const item = items(22).forEach(closure_30, (channelId) => {
      const channel = outer1_14.getChannel(channelId);
      let tmp = null != channel;
      if (tmp) {
        tmp = channel.getGuildId() !== guild.id;
      }
      if (!tmp) {
        items.push(channelId);
      }
    });
    if (0 === items.length) {
      return false;
    } else {
      const item1 = items(22).forEach(items, (arg0) => {
        outer1_53(arg0);
      });
    }
    const arr2 = items(22);
  }
});
let result = set.fileFinishedImporting("modules/calls/ChannelRTCStore.tsx");

export default tmp8;
export const NO_PARTICIPANTS = frozen;