mediasfu-shared 1.0.6 → 1.2.0

package/dist/methods/index.cjs

@@ -0,0 +1,3975 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const joinRoomOnMediaSFU = require("../joinRoomOnMediaSFU-CC8RVJgr.cjs");
+const validateAlphanumeric$1 = require("../validateAlphanumeric-DKn5BsUP.cjs");
+const launchPanelists = ({
+  updateIsPanelistsModalVisible,
+  isPanelistsModalVisible
+}) => {
+  updateIsPanelistsModalVisible(!isPanelistsModalVisible);
+};
+const updatePanelists = async ({
+  socket,
+  panelists,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can update panelists", type: "danger", duration: 3e3 });
+    return;
+  }
+  socket.emit(
+    "updatePanelists",
+    {
+      panelists: panelists.map((p) => ({ id: p.id, name: p.name })),
+      roomName
+    },
+    (response) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || "Failed to update panelists", type: "danger", duration: 3e3 });
+      }
+    }
+  );
+};
+const addPanelist = async ({
+  socket,
+  participant,
+  currentPanelists,
+  maxPanelists,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can add panelists", type: "danger", duration: 3e3 });
+    return false;
+  }
+  if (currentPanelists.some((p) => p.id === participant.id)) {
+    showAlert?.({ message: `${participant.name} is already a panelist`, type: "success", duration: 3e3 });
+    return false;
+  }
+  if (currentPanelists.length >= maxPanelists) {
+    showAlert?.({ message: `Maximum panelist limit (${maxPanelists}) reached`, type: "danger", duration: 3e3 });
+    return false;
+  }
+  return new Promise((resolve) => {
+    socket.emit(
+      "addPanelist",
+      {
+        participantId: participant.id,
+        participantName: participant.name,
+        roomName
+      },
+      (response) => {
+        if (!response?.success) {
+          showAlert?.({ message: response?.reason || "Failed to add panelist", type: "danger", duration: 3e3 });
+          resolve(false);
+        } else {
+          resolve(true);
+        }
+      }
+    );
+  });
+};
+const removePanelist = async ({
+  socket,
+  participant,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can remove panelists", type: "danger", duration: 3e3 });
+    return;
+  }
+  socket.emit(
+    "removePanelist",
+    {
+      participantId: participant.id,
+      participantName: participant.name,
+      roomName
+    },
+    (response) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || "Failed to remove panelist", type: "danger", duration: 3e3 });
+      }
+    }
+  );
+};
+const focusPanelists = async ({
+  socket,
+  roomName,
+  member: _member,
+  islevel,
+  focusEnabled,
+  muteOthersMic = false,
+  muteOthersCamera = false,
+  showAlert
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can focus panelists", type: "danger", duration: 3e3 });
+    return;
+  }
+  socket.emit(
+    "focusPanelists",
+    {
+      roomName,
+      focusEnabled,
+      muteOthersMic,
+      muteOthersCamera
+    },
+    (response) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || "Failed to focus panelists", type: "danger", duration: 3e3 });
+      }
+    }
+  );
+};
+const unfocusPanelists = async ({
+  socket,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can unfocus panelists", type: "danger", duration: 3e3 });
+    return;
+  }
+  socket.emit(
+    "focusPanelists",
+    {
+      roomName,
+      focusEnabled: false,
+      muteOthersMic: false,
+      muteOthersCamera: false
+    },
+    (response) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || "Failed to unfocus panelists", type: "danger", duration: 3e3 });
+      }
+    }
+  );
+};
+const launchPermissions = ({
+  updateIsPermissionsModalVisible,
+  isPermissionsModalVisible
+}) => {
+  updateIsPermissionsModalVisible(!isPermissionsModalVisible);
+};
+const updateParticipantPermission = async ({
+  socket,
+  participant,
+  newLevel,
+  member: _member,
+  islevel,
+  roomName,
+  showAlert
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can update participant permissions", type: "danger", duration: 3e3 });
+    return;
+  }
+  if (participant.islevel === "2") {
+    showAlert?.({ message: "Cannot change the host's permission level", type: "danger", duration: 3e3 });
+    return;
+  }
+  if (participant.islevel === newLevel) return;
+  return new Promise((resolve) => {
+    socket.emit(
+      "updateParticipantPermission",
+      {
+        participantId: participant.id,
+        participantName: participant.name,
+        newLevel,
+        roomName
+      },
+      (response) => {
+        if (!response?.success) {
+          showAlert?.({ message: response?.reason || "Failed to update permission", type: "danger", duration: 3e3 });
+        }
+        resolve();
+      }
+    );
+  });
+};
+const bulkUpdateParticipantPermissions = async ({
+  socket,
+  participants,
+  newLevel,
+  member: _member,
+  islevel,
+  roomName,
+  showAlert,
+  maxBatchSize = 50
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can update participant permissions", type: "danger", duration: 3e3 });
+    return;
+  }
+  const eligibleParticipants = participants.filter(
+    (p) => p.islevel !== "2" && p.islevel !== newLevel
+  );
+  if (eligibleParticipants.length === 0) {
+    showAlert?.({
+      message: "No participants to update",
+      type: "info",
+      duration: 3e3
+    });
+    return;
+  }
+  const batch = eligibleParticipants.slice(0, maxBatchSize);
+  return new Promise((resolve) => {
+    socket.emit(
+      "bulkUpdateParticipantPermissions",
+      {
+        updates: batch.map((p) => ({
+          participantId: p.id,
+          participantName: p.name,
+          newLevel
+        })),
+        roomName
+      },
+      (response) => {
+        if (!response?.success) {
+          showAlert?.({
+            message: response?.reason || "Failed to update permissions",
+            type: "danger",
+            duration: 3e3
+          });
+        } else if (eligibleParticipants.length > maxBatchSize) {
+          showAlert?.({
+            message: `Updated ${batch.length} participants. ${eligibleParticipants.length - maxBatchSize} remaining.`,
+            type: "info",
+            duration: 3e3
+          });
+        }
+        resolve();
+      }
+    );
+  });
+};
+const updatePermissionConfig = async ({
+  socket,
+  config,
+  islevel,
+  roomName,
+  showAlert
+}) => {
+  if (islevel !== "2") {
+    showAlert?.({ message: "Only the host can update permission configuration", type: "danger", duration: 3e3 });
+    return;
+  }
+  return new Promise((resolve) => {
+    socket.emit(
+      "updatePermissionConfig",
+      {
+        config,
+        roomName
+      },
+      (response) => {
+        if (!response?.success) {
+          showAlert?.({ message: response?.reason || "Failed to update permission config", type: "danger", duration: 3e3 });
+        }
+        resolve();
+      }
+    );
+  });
+};
+const pollUpdated = async ({
+  data,
+  polls,
+  poll,
+  member,
+  islevel,
+  showAlert,
+  updatePolls,
+  updatePoll,
+  updateIsPollModalVisible
+}) => {
+  try {
+    if (data.polls) {
+      polls = data.polls;
+      updatePolls(data.polls);
+    } else {
+      polls = [data.poll];
+      updatePolls(polls);
+    }
+    let tempPoll = { id: "" };
+    if (poll) {
+      tempPoll = { ...poll };
+    }
+    if (data.status !== "ended") {
+      poll = data.poll;
+      updatePoll(data.poll);
+    }
+    if (data.status === "started" && islevel !== "2") {
+      if (!poll.voters || poll.voters && !poll.voters[member]) {
+        showAlert?.({
+          message: "New poll started",
+          type: "success",
+          duration: 3e3
+        });
+        updateIsPollModalVisible(true);
+      }
+    } else if (data.status === "ended") {
+      if (tempPoll.id === data.poll.id) {
+        showAlert?.({ message: "Poll ended", type: "danger", duration: 3e3 });
+        updatePoll(data.poll);
+      }
+    }
+  } catch {
+  }
+};
+async function handleCreateRoom({
+  payload,
+  localLink = "",
+  connectMediaSFU = true,
+  apiUserName,
+  apiKey,
+  validate = true,
+  parameters,
+  initSocket,
+  localData,
+  createMediaSFURoom
+}) {
+  const {
+    updateIsLoadingModalVisible,
+    updateSocket,
+    updateApiUserName,
+    updateApiToken,
+    updateLink,
+    updateRoomName,
+    updateMember,
+    updateValidated,
+    showAlert
+  } = parameters;
+  const createLocalRoom = async ({
+    createData,
+    link = localLink
+  }) => {
+    initSocket?.emit("createRoom", createData, (response) => {
+      if (response.success) {
+        updateSocket(initSocket);
+        updateApiUserName(localData?.apiUserName || "");
+        updateApiToken(response.secret);
+        updateLink(link);
+        updateRoomName(createData.eventID);
+        updateMember(createData.userName + "_2");
+        updateIsLoadingModalVisible(false);
+        updateValidated(true);
+      } else {
+        updateIsLoadingModalVisible(false);
+        showAlert?.({
+          message: `Unable to create room. ${response.reason}`,
+          type: "danger",
+          duration: 3e3
+        });
+      }
+    });
+  };
+  const roomCreator = async ({
+    payload: createPayload,
+    apiUserName: userName,
+    apiKey: key,
+    validate: shouldValidate = true
+  }) => {
+    const response = await createMediaSFURoom({
+      payload: createPayload,
+      apiUserName: userName,
+      apiKey: key,
+      localLink
+    });
+    if (response.success && response.data && "roomName" in response.data) {
+      await joinRoomOnMediaSFU.checkLimitsAndMakeRequest({
+        apiUserName: response.data.roomName,
+        apiToken: response.data.secret,
+        link: response.data.link,
+        userName: createPayload.userName,
+        parameters,
+        validate: shouldValidate
+      });
+      return response;
+    } else {
+      updateIsLoadingModalVisible(false);
+      showAlert?.({
+        message: `Unable to create room. ${response.data ? "error" in response.data ? response.data.error : "" : ""}`,
+        type: "danger",
+        duration: 3e3
+      });
+    }
+  };
+  updateIsLoadingModalVisible(true);
+  if (localLink.length > 0) {
+    const secureCode = Math.random().toString(30).substring(2, 14) + Math.random().toString(30).substring(2, 14);
+    let eventID = (/* @__PURE__ */ new Date()).getTime().toString(30) + (/* @__PURE__ */ new Date()).getUTCMilliseconds() + Math.floor(10 + Math.random() * 99).toString();
+    eventID = "m" + eventID;
+    const eventRoomParams = localData?.meetingRoomParams_;
+    if (eventRoomParams && payload.eventType) {
+      eventRoomParams.type = payload.eventType;
+    }
+    const createData = {
+      eventID,
+      duration: payload.duration,
+      capacity: payload.capacity,
+      userName: payload.userName,
+      scheduledDate: /* @__PURE__ */ new Date(),
+      secureCode,
+      waitRoom: false,
+      recordingParams: localData?.recordingParams_,
+      eventRoomParams,
+      videoPreference: null,
+      audioPreference: null,
+      audioOutputPreference: null,
+      mediasfuURL: ""
+    };
+    if (connectMediaSFU && initSocket && localData && localData.apiUserName && localData.apiKey) {
+      const localApiUserName = localData.apiUserName;
+      const localApiKey = localData.apiKey;
+      const roomIdentifier = `local_create_${payload.userName}_${payload.duration}_${payload.capacity}`;
+      const pendingKey = `prejoin_pending_${roomIdentifier}`;
+      const PENDING_TIMEOUT = 30 * 1e3;
+      try {
+        const pendingRequest = localStorage.getItem(pendingKey);
+        if (pendingRequest) {
+          const pendingData = JSON.parse(pendingRequest);
+          const timeSincePending = Date.now() - (pendingData?.timestamp ?? 0);
+          if (timeSincePending < PENDING_TIMEOUT) {
+            updateIsLoadingModalVisible(false);
+            showAlert?.({
+              message: "Room creation already in progress",
+              type: "danger",
+              duration: 3e3
+            });
+            return;
+          } else {
+            try {
+              localStorage.removeItem(pendingKey);
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+      try {
+        localStorage.setItem(
+          pendingKey,
+          JSON.stringify({
+            timestamp: Date.now(),
+            payload: {
+              action: "create",
+              userName: payload.userName,
+              duration: payload.duration,
+              capacity: payload.capacity
+            }
+          })
+        );
+        setTimeout(() => {
+          try {
+            localStorage.removeItem(pendingKey);
+          } catch {
+          }
+        }, PENDING_TIMEOUT);
+      } catch {
+      }
+      payload.recordOnly = true;
+      try {
+        const response = await roomCreator({
+          payload,
+          apiUserName: localApiUserName,
+          apiKey: localApiKey,
+          validate: false
+        });
+        try {
+          localStorage.removeItem(pendingKey);
+        } catch {
+        }
+        if (response && response.success && response.data && "roomName" in response.data) {
+          createData.eventID = response.data.roomName;
+          createData.secureCode = response.data.secureCode || "";
+          createData.mediasfuURL = response.data.publicURL;
+          await createLocalRoom({
+            createData,
+            link: response.data.link
+          });
+        } else {
+          updateIsLoadingModalVisible(false);
+          showAlert?.({
+            message: `Unable to create room on MediaSFU.`,
+            type: "danger",
+            duration: 3e3
+          });
+          try {
+            updateSocket(initSocket);
+            await createLocalRoom({ createData });
+          } catch (error) {
+            updateIsLoadingModalVisible(false);
+            showAlert?.({
+              message: `Unable to create room. ${error}`,
+              type: "danger",
+              duration: 3e3
+            });
+          }
+        }
+      } catch (error) {
+        try {
+          localStorage.removeItem(pendingKey);
+        } catch {
+        }
+        updateIsLoadingModalVisible(false);
+        showAlert?.({
+          message: `Unable to create room on MediaSFU. ${error}`,
+          type: "danger",
+          duration: 3e3
+        });
+      }
+    } else {
+      try {
+        updateSocket(initSocket);
+        await createLocalRoom({ createData });
+      } catch (error) {
+        updateIsLoadingModalVisible(false);
+        showAlert?.({
+          message: `Unable to create room. ${error}`,
+          type: "danger",
+          duration: 3e3
+        });
+      }
+    }
+  } else {
+    const roomIdentifier = `mediasfu_create_${payload.userName}_${payload.duration}_${payload.capacity}`;
+    const pendingKey = `prejoin_pending_${roomIdentifier}`;
+    const PENDING_TIMEOUT = 30 * 1e3;
+    try {
+      const pendingRequest = localStorage.getItem(pendingKey);
+      if (pendingRequest) {
+        const pendingData = JSON.parse(pendingRequest);
+        const timeSincePending = Date.now() - (pendingData?.timestamp ?? 0);
+        if (timeSincePending < PENDING_TIMEOUT) {
+          updateIsLoadingModalVisible(false);
+          showAlert?.({
+            message: "Room creation already in progress",
+            type: "danger",
+            duration: 3e3
+          });
+          return;
+        } else {
+          try {
+            localStorage.removeItem(pendingKey);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    try {
+      localStorage.setItem(
+        pendingKey,
+        JSON.stringify({
+          timestamp: Date.now(),
+          payload: {
+            action: "create",
+            userName: payload.userName,
+            duration: payload.duration,
+            capacity: payload.capacity
+          }
+        })
+      );
+      setTimeout(() => {
+        try {
+          localStorage.removeItem(pendingKey);
+        } catch {
+        }
+      }, PENDING_TIMEOUT);
+    } catch {
+    }
+    try {
+      await roomCreator({
+        payload,
+        apiUserName,
+        apiKey,
+        validate
+      });
+      try {
+        localStorage.removeItem(pendingKey);
+      } catch {
+      }
+    } catch (error) {
+      try {
+        localStorage.removeItem(pendingKey);
+      } catch {
+      }
+      updateIsLoadingModalVisible(false);
+      showAlert?.({
+        message: `Unable to create room. ${error}`,
+        type: "danger",
+        duration: 3e3
+      });
+    }
+  }
+}
+async function handleJoinRoom({
+  payload,
+  localLink = "",
+  apiUserName,
+  apiKey,
+  parameters,
+  initSocket,
+  localData,
+  joinMediaSFURoom
+}) {
+  const {
+    updateIsLoadingModalVisible,
+    updateSocket,
+    updateApiUserName,
+    updateApiToken,
+    updateLink,
+    updateRoomName,
+    updateMember,
+    updateValidated,
+    showAlert
+  } = parameters;
+  const joinLocalRoom = async ({ joinData, link = localLink }) => {
+    initSocket?.emit("joinEventRoom", joinData, (response2) => {
+      if (response2.success) {
+        updateSocket(initSocket);
+        updateApiUserName(localData?.apiUserName || "");
+        updateApiToken(response2.secret);
+        updateLink(link);
+        updateRoomName(joinData.eventID);
+        updateMember(joinData.userName);
+        updateIsLoadingModalVisible(false);
+        updateValidated(true);
+      } else {
+        updateIsLoadingModalVisible(false);
+        showAlert?.({
+          message: `Unable to join room. ${response2.reason}`,
+          type: "danger",
+          duration: 3e3
+        });
+      }
+    });
+  };
+  if (localLink.length > 0 && !localLink.includes("mediasfu.com")) {
+    const joinData = {
+      eventID: payload.meetingID,
+      userName: payload.userName,
+      secureCode: "",
+      videoPreference: null,
+      audioPreference: null,
+      audioOutputPreference: null
+    };
+    await joinLocalRoom({ joinData });
+    return;
+  }
+  updateIsLoadingModalVisible(true);
+  const response = await joinMediaSFURoom({
+    payload,
+    apiUserName,
+    apiKey,
+    localLink
+  });
+  if (response.success && response.data && "roomName" in response.data) {
+    await joinRoomOnMediaSFU.checkLimitsAndMakeRequest({
+      apiUserName: response.data.roomName,
+      apiToken: response.data.secret,
+      link: response.data.link,
+      userName: payload.userName,
+      parameters
+    });
+  } else {
+    updateIsLoadingModalVisible(false);
+    showAlert?.({
+      message: `Unable to join room. ${response.data ? "error" in response.data ? response.data.error : "" : ""}`,
+      type: "danger",
+      duration: 3e3
+    });
+  }
+}
+const clickChat = async ({
+  isMessagesModalVisible,
+  updateIsMessagesModalVisible,
+  chatSetting,
+  islevel,
+  showAlert
+}) => {
+  if (isMessagesModalVisible) {
+    updateIsMessagesModalVisible(false);
+    return;
+  }
+  if (chatSetting !== "allow" && islevel !== "2") {
+    updateIsMessagesModalVisible(false);
+    showAlert?.({
+      message: "Chat is disabled for this event.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  updateIsMessagesModalVisible(true);
+};
+const createLiveSubtitle = (params) => {
+  const timestamp = params.timestamp ?? Date.now();
+  const duration = Math.min(8e3, Math.max(3e3, 3e3 + params.text.length * 50));
+  return {
+    text: params.text,
+    language: params.language,
+    timestamp,
+    expiresAt: timestamp + duration,
+    speakerId: params.speakerId,
+    speakerName: params.speakerName
+  };
+};
+const isSubtitleExpired = (subtitle, now = Date.now()) => {
+  return now >= subtitle.expiresAt;
+};
+const pruneExpiredSubtitles = (subtitles, now = Date.now()) => {
+  const next = new Map(subtitles);
+  for (const [key, subtitle] of next.entries()) {
+    if (isSubtitleExpired(subtitle, now)) {
+      next.delete(key);
+    }
+  }
+  return next;
+};
+const updateLiveSubtitlesFromTranscript = ({
+  currentSubtitles,
+  transcript,
+  now
+}) => {
+  const subtitle = createLiveSubtitle({
+    text: transcript.translatedText || transcript.originalText,
+    language: transcript.language,
+    speakerId: transcript.speakerId,
+    speakerName: transcript.speakerName,
+    timestamp: now ?? transcript.timestamp
+  });
+  const next = pruneExpiredSubtitles(currentSubtitles, subtitle.timestamp);
+  next.set(transcript.speakerId, subtitle);
+  if (transcript.speakerName) {
+    next.set(transcript.speakerName, subtitle);
+  }
+  return next;
+};
+const getSubtitleForSpeaker = (subtitles, speakerId, speakerName, now = Date.now()) => {
+  const activeSubtitles = pruneExpiredSubtitles(subtitles, now);
+  if (speakerId && activeSubtitles.has(speakerId)) {
+    return activeSubtitles.get(speakerId) || null;
+  }
+  if (speakerName && activeSubtitles.has(speakerName)) {
+    return activeSubtitles.get(speakerName) || null;
+  }
+  return null;
+};
+const SUPPORTED_LANGUAGE_CODES = [
+  "en",
+  "es",
+  "fr",
+  "de",
+  "it",
+  "pt",
+  "ru",
+  "zh",
+  "ja",
+  "ko",
+  "ar",
+  "hi",
+  "bn",
+  "pa",
+  "te",
+  "mr",
+  "ta",
+  "ur",
+  "gu",
+  "kn",
+  "ml",
+  "ne",
+  "si",
+  "nl",
+  "pl",
+  "tr",
+  "cs",
+  "el",
+  "hu",
+  "ro",
+  "sv",
+  "da",
+  "fi",
+  "no",
+  "sk",
+  "uk",
+  "bg",
+  "hr",
+  "et",
+  "lt",
+  "lv",
+  "sl",
+  "sr",
+  "bs",
+  "mk",
+  "is",
+  "ga",
+  "cy",
+  "mt",
+  "lb",
+  "sq",
+  "be",
+  "he",
+  "fa",
+  "ps",
+  "ku",
+  "vi",
+  "th",
+  "id",
+  "ms",
+  "tl",
+  "km",
+  "lo",
+  "my",
+  "sw",
+  "yo",
+  "ig",
+  "ha",
+  "zu",
+  "xh",
+  "af",
+  "st",
+  "tn",
+  "sn",
+  "am",
+  "so",
+  "rw",
+  "mg",
+  "ny",
+  "ee",
+  "tw",
+  "gaa",
+  "ka",
+  "hy",
+  "az",
+  "eu",
+  "gl",
+  "ca",
+  "la",
+  "eo",
+  "kk",
+  "uz",
+  "tg",
+  "ky",
+  "tk",
+  "mn",
+  "auto"
+];
+const REGION_BY_LANGUAGE = {
+  en: "global",
+  es: "global",
+  fr: "europe",
+  de: "europe",
+  it: "europe",
+  pt: "global",
+  ru: "europe",
+  zh: "asia",
+  ja: "asia",
+  ko: "asia",
+  ar: "mena",
+  hi: "south-asia",
+  bn: "south-asia",
+  pa: "south-asia",
+  te: "south-asia",
+  mr: "south-asia",
+  ta: "south-asia",
+  ur: "south-asia",
+  gu: "south-asia",
+  kn: "south-asia",
+  ml: "south-asia",
+  ne: "south-asia",
+  si: "south-asia",
+  nl: "europe",
+  pl: "europe",
+  tr: "europe",
+  cs: "europe",
+  el: "europe",
+  hu: "europe",
+  ro: "europe",
+  sv: "europe",
+  da: "europe",
+  fi: "europe",
+  no: "europe",
+  sk: "europe",
+  uk: "europe",
+  bg: "europe",
+  hr: "europe",
+  et: "europe",
+  lt: "europe",
+  lv: "europe",
+  sl: "europe",
+  sr: "europe",
+  bs: "europe",
+  mk: "europe",
+  is: "europe",
+  ga: "europe",
+  cy: "europe",
+  mt: "europe",
+  lb: "europe",
+  sq: "europe",
+  be: "europe",
+  he: "mena",
+  fa: "mena",
+  ps: "mena",
+  ku: "mena",
+  vi: "asia",
+  th: "asia",
+  id: "asia",
+  ms: "asia",
+  tl: "asia",
+  km: "asia",
+  lo: "asia",
+  my: "asia",
+  sw: "africa",
+  yo: "africa",
+  ig: "africa",
+  ha: "africa",
+  zu: "africa",
+  xh: "africa",
+  af: "africa",
+  st: "africa",
+  tn: "africa",
+  sn: "africa",
+  am: "africa",
+  so: "africa",
+  rw: "africa",
+  mg: "africa",
+  ny: "africa",
+  ee: "africa",
+  tw: "africa",
+  gaa: "africa",
+  ka: "caucasus",
+  hy: "caucasus",
+  az: "caucasus",
+  eu: "europe",
+  gl: "europe",
+  ca: "europe",
+  la: "europe",
+  eo: "constructed",
+  kk: "central-asia",
+  uz: "central-asia",
+  tg: "central-asia",
+  ky: "central-asia",
+  tk: "central-asia",
+  mn: "central-asia",
+  auto: "special"
+};
+const TTS_SUPPORT_BY_LANGUAGE = {
+  en: "excellent",
+  es: "excellent",
+  fr: "excellent",
+  de: "excellent",
+  it: "excellent",
+  pt: "excellent",
+  ru: "excellent",
+  zh: "excellent",
+  ja: "excellent",
+  ko: "excellent",
+  ar: "excellent",
+  hi: "good",
+  bn: "good",
+  te: "good",
+  mr: "good",
+  ta: "good",
+  ur: "good",
+  nl: "excellent",
+  pl: "excellent",
+  tr: "excellent",
+  cs: "good",
+  el: "good",
+  hu: "good",
+  ro: "good",
+  sv: "excellent",
+  da: "good",
+  fi: "good",
+  no: "good",
+  uk: "good",
+  he: "good",
+  vi: "good",
+  th: "good",
+  id: "good",
+  ms: "good",
+  af: "good",
+  ca: "good",
+  auto: "n/a"
+};
+const LANGUAGE_NAMES_EN = {
+  en: "English",
+  es: "Spanish",
+  fr: "French",
+  de: "German",
+  it: "Italian",
+  pt: "Portuguese",
+  nl: "Dutch",
+  ru: "Russian",
+  zh: "Chinese",
+  ja: "Japanese",
+  ko: "Korean",
+  ar: "Arabic",
+  hi: "Hindi",
+  bn: "Bengali",
+  pa: "Punjabi",
+  te: "Telugu",
+  mr: "Marathi",
+  ta: "Tamil",
+  ur: "Urdu",
+  gu: "Gujarati",
+  kn: "Kannada",
+  ml: "Malayalam",
+  ne: "Nepali",
+  si: "Sinhala",
+  tr: "Turkish",
+  pl: "Polish",
+  vi: "Vietnamese",
+  th: "Thai",
+  id: "Indonesian",
+  ms: "Malay",
+  tl: "Filipino",
+  km: "Khmer",
+  lo: "Lao",
+  my: "Burmese",
+  sw: "Swahili",
+  yo: "Yoruba",
+  ha: "Hausa",
+  ig: "Igbo",
+  zu: "Zulu",
+  xh: "Xhosa",
+  af: "Afrikaans",
+  st: "Sesotho",
+  tn: "Tswana",
+  sn: "Shona",
+  am: "Amharic",
+  so: "Somali",
+  rw: "Kinyarwanda",
+  mg: "Malagasy",
+  ny: "Chichewa",
+  ee: "Ewe",
+  tw: "Twi",
+  gaa: "Ga",
+  he: "Hebrew",
+  fa: "Persian",
+  ps: "Pashto",
+  ku: "Kurdish",
+  uk: "Ukrainian",
+  el: "Greek",
+  cs: "Czech",
+  ro: "Romanian",
+  hu: "Hungarian",
+  sv: "Swedish",
+  da: "Danish",
+  no: "Norwegian",
+  fi: "Finnish",
+  sk: "Slovak",
+  bg: "Bulgarian",
+  hr: "Croatian",
+  et: "Estonian",
+  lt: "Lithuanian",
+  lv: "Latvian",
+  sl: "Slovenian",
+  sr: "Serbian",
+  bs: "Bosnian",
+  mk: "Macedonian",
+  is: "Icelandic",
+  ga: "Irish",
+  cy: "Welsh",
+  mt: "Maltese",
+  lb: "Luxembourgish",
+  sq: "Albanian",
+  be: "Belarusian",
+  ka: "Georgian",
+  hy: "Armenian",
+  az: "Azerbaijani",
+  eu: "Basque",
+  gl: "Galician",
+  ca: "Catalan",
+  la: "Latin",
+  eo: "Esperanto",
+  kk: "Kazakh",
+  uz: "Uzbek",
+  tg: "Tajik",
+  ky: "Kyrgyz",
+  tk: "Turkmen",
+  mn: "Mongolian"
+};
+const getDisplayName = (code, locale, fallback) => {
+  try {
+    const displayNames = new Intl.DisplayNames([locale], { type: "language" });
+    const result = displayNames.of(code);
+    if (result) return result;
+  } catch {
+  }
+  return LANGUAGE_NAMES_EN[code] ?? fallback;
+};
+const normalizeLanguageCode = (code) => {
+  if (!code || typeof code !== "string") {
+    return "en";
+  }
+  return code.trim().toLowerCase().split("-")[0];
+};
+const isLanguageSupported = (code) => {
+  const normalized = normalizeLanguageCode(code);
+  return SUPPORTED_LANGUAGE_CODES.includes(normalized);
+};
+const getLanguageName = (code, displayLocale = "en") => {
+  const normalized = normalizeLanguageCode(code);
+  if (normalized === "auto") {
+    return "Auto-detect";
+  }
+  return getDisplayName(normalized, displayLocale, normalized.toUpperCase());
+};
+const getLanguageNativeName = (code) => {
+  const normalized = normalizeLanguageCode(code);
+  if (normalized === "auto") {
+    return "Auto";
+  }
+  return getDisplayName(normalized, normalized, getLanguageName(normalized));
+};
+const getLanguageMetadata = (code) => {
+  const normalized = normalizeLanguageCode(code);
+  return {
+    name: getLanguageName(normalized),
+    nativeName: getLanguageNativeName(normalized),
+    region: REGION_BY_LANGUAGE[normalized] || "other",
+    ttsSupport: TTS_SUPPORT_BY_LANGUAGE[normalized] || "unknown"
+  };
+};
+const getSupportedLanguages = (displayLocale = "en") => {
+  return SUPPORTED_LANGUAGE_CODES.map((code) => {
+    const metadata = getLanguageMetadata(code);
+    return {
+      code,
+      name: getLanguageName(code, displayLocale),
+      nativeName: metadata.nativeName,
+      region: metadata.region,
+      ttsSupport: metadata.ttsSupport
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+};
+const COMMON_LANGUAGE_CODES = [
+  "en",
+  "es",
+  "fr",
+  "de",
+  "it",
+  "pt",
+  "nl",
+  "ru",
+  "zh",
+  "ja",
+  "ko",
+  "ar",
+  "hi",
+  "bn",
+  "tr",
+  "pl",
+  "vi",
+  "th",
+  "id",
+  "ms",
+  "sw",
+  "yo",
+  "ha",
+  "ig",
+  "zu",
+  "am",
+  "tw",
+  "he",
+  "fa",
+  "uk",
+  "el",
+  "cs",
+  "ro",
+  "hu",
+  "sv",
+  "da",
+  "no",
+  "fi"
+];
+const getCommonLanguages = (displayLocale = "en") => {
+  return COMMON_LANGUAGE_CODES.map((code) => {
+    const metadata = getLanguageMetadata(code);
+    return {
+      code,
+      name: getLanguageName(code, displayLocale),
+      nativeName: metadata.nativeName,
+      region: metadata.region,
+      ttsSupport: metadata.ttsSupport
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+};
+const TTS_PROVIDERS = {
+  deepgram: { name: "Deepgram Aura", supportsSSML: false, isDefault: true },
+  openai: { name: "OpenAI TTS", supportsSSML: false, multilingual: true },
+  azure: { name: "Azure Neural TTS", supportsSSML: true },
+  google: { name: "Google Cloud TTS", supportsSSML: true },
+  aws: { name: "AWS Polly", supportsSSML: true },
+  elevenlabs: { name: "ElevenLabs", supportsSSML: false, multilingual: true },
+  playht: { name: "PlayHT", supportsSSML: false, multilingual: true },
+  cartesia: { name: "Cartesia Sonic", supportsSSML: false, multilingual: true },
+  rime: { name: "Rime AI", supportsSSML: false, multilingual: true },
+  kokoro: { name: "Kokoro", supportsSSML: false, multilingual: true },
+  gemini: { name: "Google Gemini TTS", supportsSSML: false, multilingual: true },
+  assemblyai: { name: "AssemblyAI", supportsSSML: false }
+};
+const buildFallbackVoices = (langCode, provider) => {
+  const normalizedLanguage = normalizeLanguageCode(langCode === "auto" ? "en" : langCode);
+  const providerKey = provider.toLowerCase();
+  const providerName = TTS_PROVIDERS[providerKey]?.name || provider;
+  const languageName = getLanguageName(normalizedLanguage);
+  return {
+    female: [
+      {
+        id: `${providerKey}-${normalizedLanguage}-female-1`,
+        name: `${providerName} ${languageName} Female`,
+        gender: "female",
+        provider: providerKey,
+        language: normalizedLanguage
+      },
+      {
+        id: `${providerKey}-${normalizedLanguage}-female-2`,
+        name: `${providerName} ${languageName} Female 2`,
+        gender: "female",
+        provider: providerKey,
+        language: normalizedLanguage
+      }
+    ],
+    male: [
+      {
+        id: `${providerKey}-${normalizedLanguage}-male-1`,
+        name: `${providerName} ${languageName} Male`,
+        gender: "male",
+        provider: providerKey,
+        language: normalizedLanguage
+      },
+      {
+        id: `${providerKey}-${normalizedLanguage}-male-2`,
+        name: `${providerName} ${languageName} Male 2`,
+        gender: "male",
+        provider: providerKey,
+        language: normalizedLanguage
+      }
+    ]
+  };
+};
+const getAvailableVoices = (langCode, provider = "deepgram") => {
+  return buildFallbackVoices(langCode, provider.toString());
+};
+const fetchVoicesViaSocket = (socket, provider = "deepgram", language = "en") => {
+  return new Promise((resolve) => {
+    const providerName = provider.toString();
+    const fallbackVoices = getAvailableVoices(language, providerName);
+    const timeout = setTimeout(() => {
+      resolve({
+        provider: providerName,
+        language,
+        voices: fallbackVoices,
+        error: "Request timed out, using shared fallback voices"
+      });
+    }, 5e3);
+    socket.emit("translation:getVoices", { provider, language }, (response) => {
+      clearTimeout(timeout);
+      if (response?.voices) {
+        resolve(response);
+        return;
+      }
+      resolve({
+        provider: response?.provider || providerName,
+        language: response?.language || language,
+        voices: fallbackVoices,
+        error: response?.error || "No voices returned, using shared fallback voices"
+      });
+    });
+  });
+};
+const fetchLanguagesViaSocket = (socket, displayLocale = "en") => {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      resolve(getSupportedLanguages(displayLocale));
+    }, 5e3);
+    socket.emit("translation:getLanguages", { displayLocale }, (response) => {
+      clearTimeout(timeout);
+      resolve(response?.languages?.length ? response.languages : getSupportedLanguages(displayLocale));
+    });
+  });
+};
+const SoundPlayer = async ({ soundUrl }) => {
+  if (!soundUrl || typeof Audio === "undefined") {
+    return;
+  }
+  try {
+    const audio = new Audio(soundUrl);
+    await audio.play();
+  } catch (error) {
+    console.error("Error playing sound:", error);
+  }
+};
+const getOverlayPosition = ({ position }) => {
+  switch (position) {
+    case "topLeft":
+      return { top: 0, left: 0 };
+    case "topRight":
+      return { top: 0, right: 0 };
+    case "bottomLeft":
+      return { bottom: 0, left: 0 };
+    case "bottomRight":
+      return { bottom: 0, right: 0 };
+    default:
+      return {};
+  }
+};
+function sleep({ ms }) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const formatNumber = async ({ number }) => {
+  if (number) {
+    if (number < 1e3) {
+      return number.toString();
+    }
+    if (number < 1e6) {
+      return `${(number / 1e3).toFixed(1)}K`;
+    }
+    if (number < 1e9) {
+      return `${(number / 1e6).toFixed(1)}M`;
+    }
+    if (number < 1e12) {
+      return `${(number / 1e9).toFixed(1)}B`;
+    }
+  }
+  return void 0;
+};
+const generateRandomMessages = ({
+  participants,
+  member,
+  coHost = "",
+  host,
+  forChatBroadcast = false
+}) => {
+  const messages = [];
+  const getRandomReceiver = (sender) => {
+    const potentialReceivers = participants.filter((participant) => participant.name !== sender);
+    const randomReceiver = potentialReceivers[Math.floor(Math.random() * potentialReceivers.length)];
+    return randomReceiver?.name || "";
+  };
+  let refNames = [];
+  if (forChatBroadcast) {
+    refNames = [member, host];
+  } else if (coHost) {
+    refNames = [
+      member,
+      coHost,
+      host,
+      ...participants.map((participant) => participant.name).filter((name) => name !== void 0)
+    ];
+  } else {
+    refNames = [
+      member,
+      host,
+      ...participants.map((participant) => participant.name).filter((name) => name !== void 0)
+    ];
+  }
+  refNames = [...new Set(refNames)];
+  let timeIncrement = 0;
+  refNames.forEach((sender) => {
+    messages.push({
+      sender,
+      receivers: [getRandomReceiver(sender)],
+      message: `Direct message from ${sender}`,
+      timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),
+      group: false
+    });
+    messages.push({
+      sender,
+      receivers: participants.map((participant) => participant.name).filter((name) => name !== void 0),
+      message: `Group message from ${sender}`,
+      timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),
+      group: true
+    });
+    timeIncrement += 15e3;
+  });
+  return messages;
+};
+const generateRandomParticipants = ({
+  member,
+  coHost = "",
+  host,
+  forChatBroadcast = false
+}) => {
+  const participants = [];
+  let names = [
+    "Alice",
+    "Bob",
+    "Charlie",
+    "David",
+    "Eve",
+    "Frank",
+    "Grace",
+    "Hank",
+    "Ivy",
+    "Jack",
+    "Kate",
+    "Liam",
+    "Mia",
+    "Nina",
+    "Olivia",
+    "Pete",
+    "Quinn",
+    "Rachel",
+    "Steve",
+    "Tina",
+    "Ursula",
+    "Vince",
+    "Wendy",
+    "Xander",
+    "Yvonne",
+    "Zack"
+  ];
+  if (forChatBroadcast) {
+    names.splice(2);
+  }
+  if (!names.includes(member)) {
+    names.unshift(member);
+  }
+  if (!names.includes(coHost) && !forChatBroadcast) {
+    names.unshift(coHost);
+  }
+  if (!names.includes(host)) {
+    names.unshift(host);
+  }
+  if (forChatBroadcast) {
+    names.splice(2);
+  }
+  names = names.filter((name) => name.length > 1);
+  const shuffledNames = [...names];
+  for (let index = shuffledNames.length - 1; index > 0; index -= 1) {
+    const randomIndex = Math.floor(Math.random() * (index + 1));
+    [shuffledNames[index], shuffledNames[randomIndex]] = [shuffledNames[randomIndex], shuffledNames[index]];
+  }
+  let hasLevel2Participant = false;
+  for (let index = 0; index < shuffledNames.length; index += 1) {
+    const randomName = shuffledNames[index];
+    const randomLevel = hasLevel2Participant ? "1" : randomName === host ? "2" : "1";
+    const randomMuted = forChatBroadcast ? true : Math.random() < 0.5;
+    if (randomLevel === "2") {
+      hasLevel2Participant = true;
+    }
+    participants.push({
+      name: randomName,
+      islevel: randomLevel,
+      muted: randomMuted,
+      id: index.toString(),
+      audioID: `audio-${index}`,
+      videoID: `video-${index}`
+    });
+  }
+  return participants;
+};
+const generateRandomPolls = ({ numberOfPolls }) => {
+  const pollTypes = ["trueFalse", "yesNo", "custom"];
+  const polls = [];
+  for (let index = 0; index < numberOfPolls; index += 1) {
+    const type = pollTypes[Math.floor(Math.random() * pollTypes.length)];
+    let options;
+    switch (type) {
+      case "trueFalse":
+        options = ["True", "False"];
+        break;
+      case "yesNo":
+        options = ["Yes", "No"];
+        break;
+      case "custom":
+        options = Array.from({ length: Math.floor(Math.random() * 5) + 2 }, (_, optionIndex) => `Option ${optionIndex + 1}`);
+        break;
+      default:
+        options = [];
+    }
+    polls.push({
+      id: `${index + 1}`,
+      question: `Random Question ${index + 1}`,
+      type,
+      options,
+      votes: Array(options.length).fill(0),
+      status: "inactive",
+      voters: {}
+    });
+  }
+  return polls;
+};
+const generateRandomRequestList = ({
+  participants,
+  hostName,
+  coHostName,
+  numberOfRequests
+}) => {
+  const filteredParticipants = participants.filter(
+    (participant) => participant.name !== hostName && participant.name !== coHostName
+  );
+  const requestIcons = ["fa-video", "fa-desktop", "fa-microphone"];
+  for (let index = requestIcons.length - 1; index > 0; index -= 1) {
+    const randomIndex = Math.floor(Math.random() * (index + 1));
+    [requestIcons[index], requestIcons[randomIndex]] = [requestIcons[randomIndex], requestIcons[index]];
+  }
+  return filteredParticipants.flatMap((participant) => {
+    const uniqueIcons = /* @__PURE__ */ new Set();
+    const requests = [];
+    for (let index = 0; index < numberOfRequests; index += 1) {
+      let randomIcon;
+      do {
+        randomIcon = requestIcons[Math.floor(Math.random() * requestIcons.length)];
+      } while (uniqueIcons.has(randomIcon));
+      uniqueIcons.add(randomIcon);
+      requests.push({
+        id: participant.id || "",
+        name: participant.name ? participant.name.toLowerCase().replace(/\s/g, "_") : "",
+        icon: randomIcon,
+        username: participant.name ? participant.name.toLowerCase().replace(/\s/g, "_") : ""
+      });
+    }
+    return requests;
+  });
+};
+const generateRandomWaitingRoomList = () => {
+  const names = ["Dimen", "Nore", "Ker", "Lor", "Mik"];
+  const waitingRoomList = [];
+  for (let index = 0; index < names.length; index += 1) {
+    waitingRoomList.push({
+      name: names[index],
+      id: index.toString()
+    });
+  }
+  return waitingRoomList;
+};
+const initialValuesState = {
+  // The following are the initial values
+  roomName: "",
+  member: "",
+  adminPasscode: "",
+  islevel: "1",
+  coHost: "No coHost",
+  coHostResponsibility: [
+    { name: "participants", value: false, dedicated: false },
+    { name: "media", value: false, dedicated: false },
+    { name: "waiting", value: false, dedicated: false },
+    { name: "chat", value: false, dedicated: false }
+  ],
+  youAreCoHost: false,
+  youAreHost: false,
+  confirmedToRecord: false,
+  meetingDisplayType: "media",
+  meetingVideoOptimized: false,
+  eventType: "webinar",
+  participants: [],
+  filteredParticipants: [],
+  participantsCounter: 0,
+  participantsFilter: "",
+  validated: false,
+  localUIMode: false,
+  socket: {},
+  localSocket: void 0,
+  roomData: null,
+  device: null,
+  apiKey: "",
+  apiUserName: "",
+  apiToken: "",
+  link: "",
+  consume_sockets: [],
+  rtpCapabilities: null,
+  roomRecvIPs: [],
+  meetingRoomParams: null,
+  itemPageLimit: 4,
+  audioOnlyRoom: false,
+  addForBasic: false,
+  screenPageLimit: 4,
+  shareScreenStarted: false,
+  shared: false,
+  targetOrientation: "landscape",
+  targetResolution: "sd",
+  targetResolutionHost: "sd",
+  vidCons: { width: 640, height: 360 },
+  frameRate: 10,
+  hParams: {},
+  vParams: {},
+  screenParams: {},
+  aParams: {},
+  // Initial Values for New Recording Fields
+  recordingAudioPausesLimit: 0,
+  recordingAudioPausesCount: 0,
+  recordingAudioSupport: false,
+  recordingAudioPeopleLimit: 0,
+  recordingAudioParticipantsTimeLimit: 0,
+  recordingVideoPausesCount: 0,
+  recordingVideoPausesLimit: 0,
+  recordingVideoSupport: false,
+  recordingVideoPeopleLimit: 0,
+  recordingVideoParticipantsTimeLimit: 0,
+  recordingAllParticipantsSupport: false,
+  recordingVideoParticipantsSupport: false,
+  recordingAllParticipantsFullRoomSupport: false,
+  recordingVideoParticipantsFullRoomSupport: false,
+  recordingPreferredOrientation: "landscape",
+  recordingSupportForOtherOrientation: false,
+  recordingMultiFormatsSupport: false,
+  userRecordingParams: {
+    mainSpecs: {
+      mediaOptions: "video",
+      audioOptions: "all",
+      videoOptions: "all",
+      videoType: "fullDisplay",
+      videoOptimized: false,
+      recordingDisplayType: "media",
+      addHLS: false
+    },
+    dispSpecs: {
+      nameTags: true,
+      backgroundColor: "#000000",
+      nameTagsColor: "#ffffff",
+      orientationVideo: "portrait"
+    }
+  },
+  canRecord: false,
+  startReport: false,
+  endReport: false,
+  recordTimerInterval: null,
+  recordStartTime: 0,
+  recordElapsedTime: 0,
+  isTimerRunning: false,
+  canPauseResume: false,
+  recordChangeSeconds: 15e3,
+  pauseLimit: 0,
+  pauseRecordCount: 0,
+  canLaunchRecord: true,
+  stopLaunchRecord: false,
+  // Room properties
+  participantsAll: [],
+  firstAll: false,
+  updateMainWindow: false,
+  first_round: false,
+  landScaped: false,
+  lock_screen: false,
+  screenId: "",
+  allVideoStreams: [],
+  newLimitedStreams: [],
+  newLimitedStreamsIDs: [],
+  activeSounds: [],
+  screenShareIDStream: "",
+  screenShareNameStream: "",
+  adminIDStream: "",
+  adminNameStream: "",
+  youYouStream: [],
+  youYouStreamIDs: [],
+  localStream: null,
+  recordStarted: false,
+  recordResumed: false,
+  recordPaused: false,
+  recordStopped: false,
+  adminRestrictSetting: false,
+  videoRequestState: null,
+  videoRequestTime: 0,
+  videoAction: false,
+  localStreamVideo: null,
+  userDefaultVideoInputDevice: "",
+  currentFacingMode: "user",
+  prevFacingMode: "user",
+  defVideoID: "",
+  allowed: false,
+  dispActiveNames: [],
+  activeNames: [],
+  prevActiveNames: [],
+  p_activeNames: [],
+  p_dispActiveNames: [],
+  membersReceived: false,
+  deferScreenReceived: false,
+  hostFirstSwitch: false,
+  micAction: false,
+  screenAction: false,
+  chatAction: false,
+  audioRequestState: null,
+  screenRequestState: null,
+  chatRequestState: null,
+  audioRequestTime: 0,
+  screenRequestTime: 0,
+  chatRequestTime: 0,
+  updateRequestIntervalSeconds: 240,
+  oldSoundIds: [],
+  hostLabel: "Host",
+  mainScreenFilled: false,
+  localStreamScreen: null,
+  screenAlreadyOn: false,
+  chatAlreadyOn: false,
+  redirectURL: "",
+  oldAllStreams: [],
+  adminVidID: "",
+  streamNames: [],
+  non_alVideoStreams: [],
+  sortAudioLoudness: false,
+  audioDecibels: [],
+  mixed_alVideoStreams: [],
+  non_alVideoStreams_muted: [],
+  paginatedStreams: [],
+  localStreamAudio: null,
+  defAudioID: "",
+  userDefaultAudioInputDevice: "",
+  userDefaultAudioOutputDevice: "",
+  prevAudioInputDevice: "",
+  prevVideoInputDevice: "",
+  audioPaused: false,
+  mainScreenPerson: "",
+  adminOnMainScreen: false,
+  screenStates: [{
+    mainScreenPerson: "",
+    mainScreenProducerId: "",
+    mainScreenFilled: false,
+    adminOnMainScreen: false
+  }],
+  prevScreenStates: [{
+    mainScreenPerson: "",
+    mainScreenProducerId: "",
+    mainScreenFilled: false,
+    adminOnMainScreen: false
+  }],
+  updateDateState: null,
+  lastUpdate: null,
+  nForReadjustRecord: 0,
+  fixedPageLimit: 4,
+  removeAltGrid: false,
+  nForReadjust: 0,
+  reorderInterval: 3e4,
+  fastReorderInterval: 1e4,
+  lastReorderTime: 0,
+  audStreamNames: [],
+  currentUserPage: 0,
+  mainHeightWidth: 0,
+  prevMainHeightWidth: 0,
+  prevDoPaginate: false,
+  doPaginate: false,
+  shareEnded: false,
+  lStreams: [],
+  chatRefStreams: [],
+  controlHeight: 0,
+  isWideScreen: false,
+  isMediumScreen: false,
+  isSmallScreen: false,
+  addGrid: false,
+  addAltGrid: false,
+  gridRows: 0,
+  gridCols: 0,
+  altGridRows: 0,
+  altGridCols: 0,
+  numberPages: 0,
+  currentStreams: [],
+  showMiniView: false,
+  nStream: null,
+  defer_receive: false,
+  allAudioStreams: [],
+  remoteScreenStream: [],
+  screenProducer: null,
+  localScreenProducer: null,
+  gotAllVids: false,
+  paginationHeightWidth: 40,
+  paginationDirection: "horizontal",
+  gridSizes: {
+    gridWidth: 0,
+    gridHeight: 0,
+    altGridWidth: 0,
+    altGridHeight: 0
+  },
+  screenForceFullDisplay: false,
+  mainGridStream: [],
+  otherGridStreams: [[], []],
+  audioOnlyStreams: [],
+  videoInputs: [],
+  audioInputs: [],
+  meetingProgressTime: "00:00:00",
+  meetingElapsedTime: 0,
+  ref_participants: [],
+  // Messaging, event, modals, and other UI states
+  messages: [],
+  startDirectMessage: false,
+  directMessageDetails: null,
+  showMessagesBadge: false,
+  audioSetting: "allow",
+  videoSetting: "allow",
+  screenshareSetting: "allow",
+  chatSetting: "allow",
+  displayOption: "media",
+  autoWave: true,
+  forceFullDisplay: true,
+  prevForceFullDisplay: false,
+  prevMeetingDisplayType: "video",
+  waitingRoomFilter: "",
+  waitingRoomList: [],
+  waitingRoomCounter: 0,
+  filteredWaitingRoomList: [],
+  requestFilter: "",
+  requestList: [],
+  requestCounter: 0,
+  filteredRequestList: [],
+  totalReqWait: 0,
+  alertVisible: false,
+  alertMessage: "",
+  alertType: "success",
+  alertDuration: 3e3,
+  progressTimerVisible: true,
+  progressTimerValue: 0,
+  isMenuModalVisible: false,
+  isRecordingModalVisible: false,
+  isSettingsModalVisible: false,
+  isRequestsModalVisible: false,
+  isWaitingModalVisible: false,
+  isCoHostModalVisible: false,
+  isMediaSettingsModalVisible: false,
+  isDisplaySettingsModalVisible: false,
+  isParticipantsModalVisible: false,
+  isMessagesModalVisible: false,
+  isConfirmExitModalVisible: false,
+  isConfirmHereModalVisible: false,
+  isShareEventModalVisible: false,
+  isLoadingModalVisible: false,
+  recordingMediaOptions: "video",
+  recordingAudioOptions: "all",
+  recordingVideoOptions: "all",
+  recordingVideoType: "fullDisplay",
+  recordingVideoOptimized: false,
+  recordingDisplayType: "video",
+  recordingAddHLS: true,
+  recordingNameTags: true,
+  recordingBackgroundColor: "#83c0e9",
+  recordingNameTagsColor: "#ffffff",
+  recordingAddText: false,
+  recordingCustomText: "Add Text",
+  recordingCustomTextPosition: "top",
+  recordingCustomTextColor: "#ffffff",
+  recordingOrientationVideo: "landscape",
+  clearedToResume: true,
+  clearedToRecord: true,
+  recordState: "green",
+  showRecordButtons: false,
+  recordingProgressTime: "00:00:00",
+  audioSwitching: false,
+  videoSwitching: false,
+  videoAlreadyOn: false,
+  audioAlreadyOn: false,
+  componentSizes: {
+    mainHeight: 0,
+    otherHeight: 0,
+    mainWidth: 0,
+    otherWidth: 0
+  },
+  hasCameraPermission: false,
+  hasAudioPermission: false,
+  transportCreated: false,
+  localTransportCreated: false,
+  transportCreatedVideo: false,
+  transportCreatedAudio: false,
+  transportCreatedScreen: false,
+  producerTransport: null,
+  localProducerTransport: null,
+  videoProducer: null,
+  localVideoProducer: null,
+  params: {},
+  videoParams: {},
+  audioParams: {},
+  audioProducer: null,
+  localAudioProducer: null,
+  consumerTransports: [],
+  consumingTransports: [],
+  // Polls
+  polls: [],
+  poll: null,
+  isPollModalVisible: false,
+  // Background
+  customImage: "",
+  selectedImage: "",
+  segmentVideo: null,
+  selfieSegmentation: null,
+  pauseSegmentation: false,
+  processedStream: null,
+  keepBackground: false,
+  backgroundHasChanged: false,
+  virtualStream: null,
+  mainCanvas: null,
+  prevKeepBackground: false,
+  appliedBackground: false,
+  isBackgroundModalVisible: false,
+  autoClickBackground: false,
+  // Breakout Rooms
+  breakoutRooms: [],
+  currentRoomIndex: 0,
+  canStartBreakout: false,
+  breakOutRoomStarted: false,
+  breakOutRoomEnded: false,
+  hostNewRoom: -1,
+  limitedBreakRoom: [],
+  mainRoomsLength: 0,
+  memberRoom: -1,
+  isBreakoutRoomsModalVisible: false,
+  // Whiteboard
+  whiteboardUsers: [],
+  currentWhiteboardIndex: 0,
+  canStartWhiteboard: false,
+  whiteboardStarted: false,
+  whiteboardEnded: false,
+  whiteboardLimit: 4,
+  isWhiteboardModalVisible: false,
+  isConfigureWhiteboardModalVisible: false,
+  shapes: [],
+  useImageBackground: true,
+  redoStack: [],
+  undoStack: [],
+  canvasStream: null,
+  canvasWhiteboard: null,
+  // Screenboard
+  canvasScreenboard: null,
+  processedScreenStream: null,
+  annotateScreenStream: false,
+  mainScreenCanvas: null,
+  isScreenboardModalVisible: false,
+  // Control Buttons
+  micActive: false,
+  videoActive: false,
+  screenShareActive: false,
+  endCallActive: false,
+  participantsActive: false,
+  menuActive: false,
+  commentsActive: false
+};
+const mediaDevices = {
+  getUserMedia: async (_constraints) => {
+    console.warn("getUserMedia is not implemented in this environment.");
+    return new MediaStream();
+  },
+  getDisplayMedia: async (_constraints) => {
+    console.warn("getDisplayMedia is not implemented in this environment.");
+    return new MediaStream();
+  },
+  enumerateDevices: async () => {
+    console.warn("enumerateDevices is not implemented in this environment.");
+    return [];
+  }
+};
+function registerGlobals() {
+}
+class MediaStream {
+  tracks;
+  constructor(tracks = []) {
+    this.tracks = tracks;
+  }
+}
+class MediaStreamTrack {
+}
+class RTCView {
+  render() {
+    return null;
+  }
+}
+const createResponseJoinRoom = async ({
+  localRoom
+}) => {
+  return {
+    rtpCapabilities: localRoom.rtpCapabilities ?? null,
+    success: localRoom.rtpCapabilities !== null,
+    roomRecvIPs: [],
+    meetingRoomParams: localRoom.eventRoomParams,
+    recordingParams: localRoom.recordingParams,
+    secureCode: localRoom.secureCode,
+    recordOnly: false,
+    isHost: localRoom.isHost,
+    safeRoom: false,
+    autoStartSafeRoom: false,
+    safeRoomStarted: false,
+    safeRoomEnded: false,
+    reason: localRoom.isBanned ? "User is banned from the room." : void 0,
+    banned: localRoom.isBanned,
+    suspended: false,
+    noAdmin: localRoom.hostNotJoined
+  };
+};
+const readResponseError = async (response) => {
+  const fallbackMessage = `HTTP error! Status: ${response.status}`;
+  try {
+    const responseText = await response.text();
+    if (!responseText) {
+      return fallbackMessage;
+    }
+    const parsedResponse = JSON.parse(responseText);
+    return parsedResponse.error || parsedResponse.message || responseText;
+  } catch {
+    return fallbackMessage;
+  }
+};
+const createBrowserPendingRequestStorage = () => {
+  if (typeof localStorage === "undefined") {
+    return void 0;
+  }
+  return {
+    getItem: async (key) => localStorage.getItem(key),
+    setItem: async (key, value) => {
+      localStorage.setItem(key, value);
+    },
+    removeItem: async (key) => {
+      localStorage.removeItem(key);
+    }
+  };
+};
+const createRoomOnMediaSFU = async ({
+  payload,
+  apiUserName,
+  apiKey,
+  localLink = "",
+  pendingRequestStorage
+}) => {
+  const storage = pendingRequestStorage ?? createBrowserPendingRequestStorage();
+  const roomIdentifier = `create_${payload.userName}_${payload.duration}_${payload.capacity}`;
+  const pendingKey = `mediasfu_pending_${roomIdentifier}`;
+  const pendingTimeout = 30 * 1e3;
+  try {
+    const pendingRequest = storage ? await storage.getItem(pendingKey) : null;
+    if (storage && pendingRequest) {
+      const pendingData = JSON.parse(pendingRequest);
+      const timeSincePending = Date.now() - pendingData.timestamp;
+      if (timeSincePending < pendingTimeout) {
+        return {
+          data: { error: "Room creation already in progress" },
+          success: false
+        };
+      }
+      await storage.removeItem(pendingKey);
+    }
+    if (!apiUserName || !apiKey || apiUserName === "yourAPIUSERNAME" || apiKey === "yourAPIKEY" || apiKey.length !== 64 || apiUserName.length < 6) {
+      return { data: { error: "Invalid credentials" }, success: false };
+    }
+    const finalLink = joinRoomOnMediaSFU.resolveMediaSFURoomApi(localLink, "createRoom");
+    if (storage) {
+      await storage.setItem(pendingKey, JSON.stringify({
+        timestamp: Date.now(),
+        payload: {
+          action: payload.action,
+          userName: payload.userName,
+          meetingID: "create"
+        }
+      }));
+      setTimeout(() => {
+        storage.removeItem(pendingKey).catch(() => {
+        });
+      }, pendingTimeout);
+    }
+    const response = await fetch(finalLink, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiUserName}:${apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(await readResponseError(response));
+    }
+    const data = await response.json();
+    if (storage) {
+      await storage.removeItem(pendingKey);
+    }
+    return { data, success: true };
+  } catch (error) {
+    if (storage) {
+      try {
+        await storage.removeItem(pendingKey);
+      } catch {
+      }
+    }
+    const errorMessage = error.message || "unknown error";
+    return {
+      data: { error: `Unable to create room, ${errorMessage}` },
+      success: false
+    };
+  }
+};
+function startMeetingProgressTimer({
+  startTime,
+  parameters
+}) {
+  let { updateMeetingProgressTime, getUpdatedAllParams } = parameters;
+  function calculateElapsedTime(currentStartTime) {
+    const currentTime = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
+    return currentTime - currentStartTime;
+  }
+  function padNumber2(value) {
+    return value.toString().padStart(2, "0");
+  }
+  function formatTime(time) {
+    const hours = Math.floor(time / 3600);
+    const minutes = Math.floor(time % 3600 / 60);
+    const seconds = Math.floor(time % 60);
+    return `${padNumber2(hours)}:${padNumber2(minutes)}:${padNumber2(seconds)}`;
+  }
+  let elapsedTime = calculateElapsedTime(startTime);
+  let timeProgress = setInterval(() => {
+    elapsedTime++;
+    updateMeetingProgressTime(formatTime(elapsedTime));
+    parameters = getUpdatedAllParams();
+    if (!parameters.validated || !parameters.roomName) {
+      clearInterval(timeProgress);
+      timeProgress = null;
+    }
+  }, 1e3);
+}
+const meetingTimeRemaining = async ({
+  timeRemaining,
+  showAlert,
+  eventType
+}) => {
+  const minutes = Math.floor(timeRemaining / 6e4);
+  const seconds = Math.floor(timeRemaining % 6e4 / 1e3);
+  const timeRemainingString = `${minutes}:${seconds < 10 ? "0" : ""}${seconds}`;
+  if (eventType !== "chat") {
+    showAlert?.({
+      message: `The event will end in ${timeRemainingString} minutes.`,
+      type: "success",
+      duration: 3e3
+    });
+  }
+};
+const allWaitingRoomMembers = async ({
+  waitingParticipants,
+  updateWaitingRoomList,
+  updateTotalReqWait
+}) => {
+  updateWaitingRoomList(waitingParticipants);
+  updateTotalReqWait(waitingParticipants.length);
+};
+const allMembers = async ({
+  members,
+  requestss,
+  coHoste,
+  coHostRes,
+  parameters,
+  consume_sockets,
+  apiUserName,
+  apiKey,
+  apiToken
+}) => {
+  let {
+    participantsAll,
+    participants,
+    dispActiveNames,
+    requestList,
+    lock_screen,
+    firstAll,
+    membersReceived,
+    roomRecvIPs,
+    deferScreenReceived,
+    screenId,
+    shareScreenStarted,
+    meetingDisplayType,
+    hostFirstSwitch,
+    waitingRoomList,
+    islevel,
+    socket,
+    updateParticipantsAll,
+    updateParticipants,
+    updateRequestList,
+    updateCoHost,
+    updateCoHostResponsibility,
+    updateFirstAll,
+    updateMembersReceived,
+    updateDeferScreenReceived,
+    updateShareScreenStarted,
+    updateHostFirstSwitch,
+    updateConsume_sockets,
+    updateRoomRecvIPs,
+    updateIsLoadingModalVisible,
+    updateTotalReqWait,
+    onScreenChanges,
+    connectIps,
+    connectLocalIps,
+    sleep: sleep2,
+    reorderStreams
+  } = parameters;
+  participantsAll = members.map(({ isBanned, isSuspended, name, audioID, videoID }) => ({
+    isBanned,
+    isSuspended,
+    name,
+    audioID,
+    videoID
+  }));
+  updateParticipantsAll(participantsAll);
+  participants = members.filter(
+    (participant) => !participant.isBanned && !participant.isSuspended
+  );
+  updateParticipants(participants);
+  if (dispActiveNames.length > 0) {
+    const missingDisplayedParticipants = dispActiveNames.filter(
+      (name) => !participants.some((participant) => participant.name === name)
+    );
+    if (missingDisplayedParticipants.length > 0) {
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+    }
+  }
+  const onLocal = roomRecvIPs.length === 1 && roomRecvIPs[0] === "none";
+  if (!membersReceived && !onLocal) {
+    if (roomRecvIPs.length < 1) {
+      const checkIPs = setInterval(async () => {
+        if (roomRecvIPs.length > 0) {
+          clearInterval(checkIPs);
+          if (deferScreenReceived && screenId) {
+            shareScreenStarted = true;
+            updateShareScreenStarted(shareScreenStarted);
+          }
+          const [sockets_, ips_] = await connectIps({
+            consume_sockets,
+            remIP: roomRecvIPs,
+            parameters,
+            apiUserName,
+            apiKey,
+            apiToken
+          });
+          updateConsume_sockets(sockets_);
+          updateRoomRecvIPs(ips_);
+          membersReceived = true;
+          updateMembersReceived(membersReceived);
+          await sleep2({ ms: 250 });
+          updateIsLoadingModalVisible(false);
+          deferScreenReceived = false;
+          updateDeferScreenReceived(deferScreenReceived);
+        }
+      }, 10);
+    } else {
+      const [sockets_, ips_] = await connectIps({
+        consume_sockets,
+        remIP: roomRecvIPs,
+        parameters,
+        apiUserName,
+        apiKey,
+        apiToken
+      });
+      updateConsume_sockets(sockets_);
+      updateRoomRecvIPs(ips_);
+      membersReceived = true;
+      updateMembersReceived(membersReceived);
+      if (deferScreenReceived && screenId) {
+        shareScreenStarted = true;
+        updateShareScreenStarted(shareScreenStarted);
+      }
+      await sleep2({ ms: 250 });
+      updateIsLoadingModalVisible(false);
+      deferScreenReceived = false;
+      updateDeferScreenReceived(deferScreenReceived);
+    }
+  }
+  if (onLocal && !membersReceived) {
+    if (connectLocalIps) {
+      await connectLocalIps({ socket, parameters });
+    }
+    await sleep2({ ms: 50 });
+    updateIsLoadingModalVisible(false);
+  }
+  requestList = requestss.filter(
+    (request) => participants.some((participant) => participant.id === request.id)
+  );
+  updateRequestList(requestList);
+  updateTotalReqWait(requestList.length + waitingRoomList.length);
+  updateCoHost(coHoste);
+  updateCoHostResponsibility(coHostRes);
+  if (!lock_screen && !firstAll) {
+    await onScreenChanges({ parameters });
+    if (meetingDisplayType !== "all") {
+      updateFirstAll(true);
+    }
+  } else if (islevel === "2" && !hostFirstSwitch) {
+    await onScreenChanges({ parameters });
+    updateHostFirstSwitch(true);
+  }
+};
+const allMembersRest = async ({
+  members,
+  settings,
+  coHoste,
+  coHostRes,
+  parameters,
+  consume_sockets,
+  apiUserName,
+  apiKey,
+  apiToken
+}) => {
+  let {
+    participantsAll,
+    participants,
+    dispActiveNames,
+    requestList,
+    coHost,
+    coHostResponsibility,
+    lock_screen,
+    firstAll,
+    membersReceived,
+    roomRecvIPs,
+    deferScreenReceived,
+    screenId,
+    shareScreenStarted,
+    meetingDisplayType,
+    audioSetting,
+    videoSetting,
+    screenshareSetting,
+    chatSetting,
+    socket,
+    updateParticipantsAll,
+    updateParticipants,
+    updateRequestList,
+    updateCoHost,
+    updateCoHostResponsibility,
+    updateFirstAll,
+    updateMembersReceived,
+    updateDeferScreenReceived,
+    updateShareScreenStarted,
+    updateAudioSetting,
+    updateVideoSetting,
+    updateScreenshareSetting,
+    updateChatSetting,
+    updateConsume_sockets,
+    updateRoomRecvIPs,
+    updateIsLoadingModalVisible,
+    onScreenChanges,
+    connectIps,
+    connectLocalIps,
+    sleep: sleep2,
+    reorderStreams
+  } = parameters;
+  participantsAll = members.map((participant) => ({
+    isBanned: participant.isBanned,
+    isSuspended: participant.isSuspended,
+    name: participant.name,
+    audioID: participant.audioID,
+    videoID: participant.videoID
+  }));
+  updateParticipantsAll(participantsAll);
+  participants = members.filter(
+    (participant) => !participant.isBanned && !participant.isSuspended
+  );
+  updateParticipants(participants);
+  if (dispActiveNames.length > 0) {
+    const missingDisplayedParticipants = dispActiveNames.filter(
+      (name) => !participants.some((participant) => participant.name === name)
+    );
+    if (missingDisplayedParticipants.length > 0 && membersReceived) {
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+    }
+  }
+  const onLocal = roomRecvIPs.length === 1 && roomRecvIPs[0] === "none";
+  if (!onLocal) {
+    if (!membersReceived) {
+      if (roomRecvIPs.length < 1) {
+        const checkIPs = setInterval(async () => {
+          if (roomRecvIPs.length > 0) {
+            clearInterval(checkIPs);
+            if (deferScreenReceived && screenId) {
+              shareScreenStarted = true;
+              updateShareScreenStarted(shareScreenStarted);
+            }
+            const [sockets_, ips_] = await connectIps({
+              consume_sockets,
+              remIP: roomRecvIPs,
+              parameters,
+              apiUserName,
+              apiKey,
+              apiToken
+            });
+            if (sockets_ && ips_) {
+              updateConsume_sockets(sockets_);
+              updateRoomRecvIPs(ips_);
+            }
+            membersReceived = true;
+            updateMembersReceived(membersReceived);
+            await sleep2({ ms: 250 });
+            updateIsLoadingModalVisible(false);
+            deferScreenReceived = false;
+            updateDeferScreenReceived(deferScreenReceived);
+          }
+        }, 10);
+      } else {
+        const [sockets_, ips_] = await connectIps({
+          consume_sockets,
+          remIP: roomRecvIPs,
+          parameters,
+          apiUserName,
+          apiKey,
+          apiToken
+        });
+        if (sockets_ && ips_) {
+          updateConsume_sockets(sockets_);
+          updateRoomRecvIPs(ips_);
+        }
+        membersReceived = true;
+        updateMembersReceived(membersReceived);
+        if (deferScreenReceived && screenId) {
+          shareScreenStarted = true;
+          updateShareScreenStarted(shareScreenStarted);
+        }
+        await sleep2({ ms: 250 });
+        updateIsLoadingModalVisible(false);
+        deferScreenReceived = false;
+        updateDeferScreenReceived(deferScreenReceived);
+      }
+    } else if (screenId) {
+      const host = participants.find(
+        (participant) => participant.ScreenID === screenId && participant.ScreenOn === true
+      );
+      if (deferScreenReceived && host) {
+        shareScreenStarted = true;
+        updateShareScreenStarted(shareScreenStarted);
+      }
+    }
+  }
+  if (onLocal && !membersReceived) {
+    if (connectLocalIps) {
+      await connectLocalIps({ socket, parameters });
+    }
+    await sleep2({ ms: 50 });
+    updateIsLoadingModalVisible(false);
+  }
+  requestList = requestList.filter(
+    (request) => participants.some((participant) => participant.id === request.id)
+  );
+  updateRequestList(requestList);
+  coHost = coHoste;
+  updateCoHost(coHost);
+  coHostResponsibility = coHostRes;
+  updateCoHostResponsibility(coHostResponsibility);
+  if (!lock_screen && !firstAll) {
+    await onScreenChanges({ parameters });
+    if (meetingDisplayType !== "all") {
+      firstAll = true;
+      updateFirstAll(firstAll);
+    }
+  }
+  try {
+    if (membersReceived) {
+      [audioSetting, videoSetting, screenshareSetting, chatSetting] = settings;
+      updateAudioSetting(audioSetting);
+      updateVideoSetting(videoSetting);
+      updateScreenshareSetting(screenshareSetting);
+      updateChatSetting(chatSetting);
+    }
+  } catch {
+  }
+};
+const banParticipant = async ({
+  name,
+  parameters
+}) => {
+  const {
+    activeNames,
+    dispActiveNames,
+    participants,
+    updateParticipants,
+    reorderStreams
+  } = parameters;
+  if (activeNames.includes(name) || dispActiveNames.includes(name)) {
+    updateParticipants(
+      participants.filter((participant) => participant.name !== name)
+    );
+    await reorderStreams({ add: false, screenChanged: true, parameters });
+  }
+};
+const controlMediaHost = async ({
+  type,
+  parameters
+}) => {
+  const {
+    updateAdminRestrictSetting,
+    updateLocalStream,
+    updateAudioAlreadyOn,
+    updateLocalStreamScreen,
+    updateLocalStreamVideo,
+    updateScreenAlreadyOn,
+    updateVideoAlreadyOn,
+    updateChatAlreadyOn,
+    onScreenChanges,
+    stopShareScreen,
+    disconnectSendTransportVideo,
+    disconnectSendTransportAudio,
+    disconnectSendTransportScreen
+  } = parameters;
+  const { localStream, localStreamScreen, localStreamVideo } = parameters.getUpdatedAllParams();
+  const disableTrack = (stream, kind) => {
+    const getTracks = kind === "audio" ? stream?.getAudioTracks : stream?.getVideoTracks;
+    const tracks = typeof getTracks === "function" ? getTracks.call(stream) : stream?.tracks?.filter((track2) => track2.kind === kind) ?? [];
+    const track = tracks && tracks[0];
+    if (track) {
+      track.enabled = false;
+      return true;
+    }
+    return false;
+  };
+  try {
+    updateAdminRestrictSetting(true);
+    if (type === "audio") {
+      disableTrack(localStream, "audio");
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportAudio({ parameters });
+      updateAudioAlreadyOn(false);
+    } else if (type === "video") {
+      disableTrack(localStream, "video");
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+      disableTrack(localStreamVideo, "video");
+      updateLocalStreamVideo(localStreamVideo ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+      updateVideoAlreadyOn(false);
+    } else if (type === "screenshare") {
+      disableTrack(localStreamScreen, "video");
+      updateLocalStreamScreen(localStreamScreen ?? null);
+      await disconnectSendTransportScreen({ parameters });
+      await stopShareScreen({ parameters });
+      updateScreenAlreadyOn(false);
+    } else if (type === "chat") {
+      updateChatAlreadyOn(false);
+    } else if (type === "all") {
+      disableTrack(localStream, "audio");
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportAudio({ parameters });
+      updateAudioAlreadyOn(false);
+      disableTrack(localStreamScreen, "video");
+      updateLocalStreamScreen(localStreamScreen ?? null);
+      await disconnectSendTransportScreen({ parameters });
+      await stopShareScreen({ parameters });
+      updateScreenAlreadyOn(false);
+      disableTrack(localStream, "video");
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+      disableTrack(localStreamVideo, "video");
+      updateLocalStreamVideo(localStreamVideo ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+      updateVideoAlreadyOn(false);
+    }
+  } catch (error) {
+    console.error("Error in controlMediaHost:", error);
+  }
+};
+const disconnect = async ({
+  showAlert,
+  redirectURL,
+  onWeb
+}) => {
+  if (onWeb && redirectURL && typeof window !== "undefined") {
+    window.location.href = redirectURL;
+  } else {
+    showAlert?.({
+      message: "You have been disconnected from the session.",
+      type: "danger",
+      duration: 2e3
+    });
+  }
+};
+async function disconnectUserSelf({
+  member,
+  roomName,
+  socket,
+  localSocket
+}) {
+  socket.emit("disconnectUser", {
+    member,
+    roomName,
+    ban: true
+  });
+  try {
+    if (localSocket?.id) {
+      localSocket.emit("disconnectUser", {
+        member,
+        roomName,
+        ban: true
+      });
+    }
+  } catch {
+  }
+}
+const getDomains = async ({
+  domains,
+  alt_domains,
+  apiUserName,
+  apiKey,
+  apiToken,
+  parameters
+}) => {
+  let { roomRecvIPs, consume_sockets, connectIps } = parameters;
+  const ipsToConnect = [];
+  try {
+    consume_sockets = parameters.getUpdatedAllParams().consume_sockets;
+    for (const domain of domains) {
+      const ipToCheck = alt_domains[domain] || domain;
+      if (!roomRecvIPs.includes(ipToCheck)) {
+        ipsToConnect.push(ipToCheck);
+      }
+    }
+    await connectIps({
+      consume_sockets,
+      remIP: ipsToConnect,
+      parameters,
+      apiUserName,
+      apiKey,
+      apiToken
+    });
+  } catch (error) {
+    console.error("Error in getDomains: ", error);
+  }
+};
+const meetingEnded = async ({
+  showAlert,
+  redirectURL,
+  onWeb,
+  eventType
+}) => {
+  if (eventType !== "chat") {
+    showAlert?.({
+      message: "The event has ended. You will be redirected to the home page in 2 seconds.",
+      type: "danger",
+      duration: 2e3
+    });
+  }
+  if (onWeb && redirectURL) {
+    setTimeout(() => {
+      window.location.href = redirectURL;
+    }, 2e3);
+  }
+};
+const meetingStillThere = async ({
+  updateIsConfirmHereModalVisible
+}) => {
+  updateIsConfirmHereModalVisible(true);
+};
+const panelistsUpdated = async ({
+  data,
+  updatePanelists: updatePanelists2
+}) => {
+  try {
+    const { panelists } = data;
+    if (updatePanelists2) {
+      updatePanelists2(
+        panelists.map((panelist) => ({
+          id: panelist.id,
+          name: panelist.name,
+          audioID: "",
+          videoID: ""
+        }))
+      );
+    }
+  } catch (error) {
+    console.error("Error handling panelistsUpdated:", error);
+  }
+};
+const panelistFocusChanged = async ({
+  data,
+  updatePanelistsFocused,
+  updateMuteOthersMic,
+  updateMuteOthersCamera,
+  updatePanelists: updatePanelists2,
+  currentPanelistsFocused,
+  currentPanelists,
+  onScreenChanges
+}) => {
+  try {
+    const { focusEnabled, panelists, muteOthersMic, muteOthersCamera } = data;
+    const focusChanged = currentPanelistsFocused !== void 0 && currentPanelistsFocused !== focusEnabled;
+    const currentPanelistIds = (currentPanelists || []).map((panelist) => panelist.id).sort().join(",");
+    const newPanelistIds = panelists.map((panelist) => panelist.id).sort().join(",");
+    const panelistsChanged = currentPanelistIds !== newPanelistIds;
+    updatePanelistsFocused?.(focusEnabled);
+    updateMuteOthersMic?.(muteOthersMic);
+    updateMuteOthersCamera?.(muteOthersCamera);
+    if (updatePanelists2) {
+      updatePanelists2(
+        panelists.map((panelist) => ({
+          id: panelist.id,
+          name: panelist.name,
+          audioID: "",
+          videoID: ""
+        }))
+      );
+    }
+    if ((focusChanged || panelistsChanged) && onScreenChanges) {
+      await onScreenChanges();
+    }
+  } catch (error) {
+    console.error("Error handling panelistFocusChanged:", error);
+  }
+};
+const panelistControlMedia = async ({
+  data,
+  showAlert,
+  clickAudio,
+  clickVideo,
+  audioAlreadyOn,
+  videoAlreadyOn
+}) => {
+  try {
+    const { type, action, reason } = data;
+    if (action === "mute") {
+      if (type === "audio" && audioAlreadyOn && clickAudio) {
+        clickAudio();
+      } else if (type === "video" && videoAlreadyOn && clickVideo) {
+        clickVideo();
+      }
+      if (showAlert && reason) {
+        showAlert({
+          message: `Your ${type === "audio" ? "microphone" : "camera"} has been muted. ${reason}`,
+          type: "info",
+          duration: 3e3
+        });
+      }
+    }
+  } catch (error) {
+    console.error("Error handling controlMedia:", error);
+  }
+};
+const addedAsPanelist = async ({
+  data,
+  showAlert
+}) => {
+  try {
+    showAlert?.({
+      message: data.message || "You have been added as a panelist",
+      type: "success",
+      duration: 3e3
+    });
+  } catch (error) {
+    console.error("Error handling addedAsPanelist:", error);
+  }
+};
+const removedFromPanelists = async ({
+  data,
+  showAlert
+}) => {
+  try {
+    showAlert?.({
+      message: data.message || "You have been removed from panelists",
+      type: "info",
+      duration: 3e3
+    });
+  } catch (error) {
+    console.error("Error handling removedFromPanelists:", error);
+  }
+};
+const participantRequested = async ({
+  userRequest,
+  requestList,
+  waitingRoomList,
+  updateTotalReqWait,
+  updateRequestList
+}) => {
+  const hasMatchingRequest = requestList.some(
+    (request) => request.id === userRequest.id && request.icon === userRequest.icon
+  );
+  const updatedRequestList = hasMatchingRequest ? requestList : [...requestList, userRequest];
+  updateRequestList(updatedRequestList);
+  updateTotalReqWait(updatedRequestList.length + waitingRoomList.length);
+};
+const permissionUpdated = async ({
+  data,
+  showAlert,
+  updateIslevel
+}) => {
+  try {
+    const { newLevel, message } = data;
+    updateIslevel?.(newLevel);
+    if (showAlert && message) {
+      showAlert({
+        message,
+        type: newLevel === "1" ? "success" : "info",
+        duration: 3e3
+      });
+    }
+  } catch (error) {
+    console.error("Error handling permissionUpdated:", error);
+  }
+};
+const permissionConfigUpdated = async ({
+  data,
+  updatePermissionConfig: updatePermissionConfig2
+}) => {
+  try {
+    updatePermissionConfig2?.(data.config);
+  } catch (error) {
+    console.error("Error handling permissionConfigUpdated:", error);
+  }
+};
+const personJoined = async ({
+  name,
+  showAlert
+}) => {
+  showAlert?.({
+    message: `${name} joined the event.`,
+    type: "success",
+    duration: 3e3
+  });
+};
+const producerMediaClosed = async ({
+  producerId,
+  kind,
+  parameters
+}) => {
+  const updatedParameters = parameters.getUpdatedAllParams();
+  const {
+    consumerTransports,
+    updateConsumerTransports,
+    hostLabel,
+    shared,
+    updateShared,
+    updateShareScreenStarted,
+    updateScreenId,
+    updateShareEnded,
+    closeAndResize,
+    prepopulateUserMedia,
+    reorderStreams
+  } = updatedParameters;
+  const producerToClose = consumerTransports.find(
+    (transportData) => transportData.producerId === producerId
+  );
+  if (producerToClose) {
+    try {
+      await producerToClose.consumerTransport?.close();
+    } catch (error) {
+      console.error("Error closing consumer transport:", error);
+    }
+    try {
+      producerToClose.consumer.close();
+    } catch (error) {
+      console.error("Error closing consumer:", error);
+    }
+    const updatedTransports = consumerTransports.filter(
+      (transportData) => transportData.producerId !== producerId
+    );
+    updateConsumerTransports(updatedTransports);
+    await closeAndResize({
+      producerId,
+      kind,
+      parameters: updatedParameters
+    });
+  } else if (kind === "screenshare" || kind === "screen") {
+    if (shared) {
+      updateShared(false);
+    } else {
+      updateShareScreenStarted(false);
+      updateScreenId("");
+    }
+    updateShareEnded(true);
+    await prepopulateUserMedia({ name: hostLabel, parameters: updatedParameters });
+    await reorderStreams({
+      add: false,
+      screenChanged: true,
+      parameters: updatedParameters
+    });
+  }
+};
+const producerMediaPaused = async ({
+  producerId,
+  kind,
+  name,
+  parameters
+}) => {
+  parameters = parameters.getUpdatedAllParams();
+  let {
+    activeSounds,
+    meetingDisplayType,
+    meetingVideoOptimized,
+    participants,
+    oldSoundIds,
+    shared,
+    shareScreenStarted,
+    updateMainWindow,
+    hostLabel,
+    islevel,
+    updateActiveSounds,
+    updateUpdateMainWindow,
+    reorderStreams,
+    prepopulateUserMedia,
+    reUpdateInter
+  } = parameters;
+  await Promise.all(
+    participants.map(async (participant) => {
+      if (participant.muted) {
+        try {
+          if (participant.islevel === "2" && !participant.videoID && !shared && !shareScreenStarted && islevel !== "2") {
+            updateMainWindow = true;
+            updateUpdateMainWindow(updateMainWindow);
+            await prepopulateUserMedia({ name: hostLabel, parameters });
+            updateMainWindow = false;
+            updateUpdateMainWindow(updateMainWindow);
+          }
+        } catch {
+        }
+        if (shareScreenStarted || shared) {
+          if (participant.name && activeSounds.includes(participant.name)) {
+            activeSounds = activeSounds.filter(
+              (audioStream) => audioStream !== participant.name
+            );
+            updateActiveSounds(activeSounds);
+          }
+          reUpdateInter({
+            name: participant.name,
+            add: false,
+            force: true,
+            parameters
+          });
+        }
+      }
+    })
+  );
+  if (meetingDisplayType === "media" || meetingDisplayType === "video" && !meetingVideoOptimized) {
+    const participant = participants.find((item) => item.name === name);
+    const hasVideo = participant?.videoID !== null && participant?.videoID !== "";
+    if (!hasVideo && !(shareScreenStarted || shared)) {
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+    }
+  }
+  if (kind === "audio") {
+    try {
+      const participant = participants.find((item) => item.audioID === producerId) || participants.find((item) => item.name === name);
+      if (participant && (participant.name && oldSoundIds.includes(participant.name) || name && oldSoundIds.includes(name))) {
+        reUpdateInter({
+          name: participant.name,
+          add: false,
+          force: true,
+          parameters
+        });
+      }
+    } catch {
+    }
+  }
+};
+const producerMediaResumed = async ({
+  name,
+  parameters
+}) => {
+  const {
+    meetingDisplayType,
+    participants,
+    shared,
+    shareScreenStarted,
+    mainScreenFilled,
+    hostLabel,
+    updateUpdateMainWindow,
+    reorderStreams,
+    prepopulateUserMedia
+  } = parameters;
+  const participant = participants.find((item) => item.name === name);
+  if (participant && !mainScreenFilled && participant.islevel === "2") {
+    updateUpdateMainWindow(true);
+    await prepopulateUserMedia({ name: hostLabel, parameters });
+    updateUpdateMainWindow(false);
+  }
+  if (meetingDisplayType === "media" && participant) {
+    const hasVideo = participant.videoID !== null && participant.videoID !== "";
+    if (!hasVideo && !(shareScreenStarted || shared)) {
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+    }
+  }
+};
+const receiveMessage = async ({
+  message,
+  messages,
+  participantsAll,
+  member,
+  eventType,
+  islevel,
+  coHost,
+  updateMessages,
+  updateShowMessagesBadge
+}) => {
+  const { sender, receivers, message: content, timestamp, group } = message;
+  const oldMessages = messages;
+  messages = [...messages, { sender, receivers, message: content, timestamp, group }];
+  if (eventType !== "broadcast" && eventType !== "chat") {
+    messages = messages.filter(
+      (msg) => participantsAll.some(
+        (participant) => participant.name === msg.sender && !participant.isBanned
+      )
+    );
+  } else {
+    messages = messages.filter((msg) => {
+      const participant = participantsAll.find((p) => p.name === msg.sender);
+      return !participant || !participant.isBanned;
+    });
+  }
+  updateMessages(messages);
+  const oldGroupMessages = oldMessages.filter((msg) => msg.group);
+  const oldDirectMessages = oldMessages.filter((msg) => !msg.group);
+  const groupMessages = messages.filter((msg) => msg.group);
+  const directMessages = messages.filter((msg) => !msg.group);
+  if (eventType !== "broadcast" && eventType !== "chat") {
+    if (oldGroupMessages.length !== groupMessages.length) {
+      const newGroupMessages = groupMessages.filter(
+        (msg) => !oldGroupMessages.some((oldMsg) => oldMsg.timestamp === msg.timestamp)
+      );
+      const relevantGroupMessages = newGroupMessages.filter(
+        (msg) => msg.sender === member || msg.receivers.includes(member)
+      );
+      const selfSentGroupMessages = relevantGroupMessages.filter(
+        (msg) => msg.sender === member
+      );
+      if (newGroupMessages.length > 0 && relevantGroupMessages.length > selfSentGroupMessages.length) {
+        updateShowMessagesBadge(true);
+      }
+    }
+    if (oldDirectMessages.length !== directMessages.length) {
+      const newDirectMessages = directMessages.filter(
+        (msg) => !oldDirectMessages.some((oldMsg) => oldMsg.timestamp === msg.timestamp)
+      );
+      const relevantDirectMessages = newDirectMessages.filter(
+        (msg) => msg.sender === member || msg.receivers.includes(member)
+      );
+      const selfSentDirectMessages = relevantDirectMessages.filter(
+        (msg) => msg.sender === member
+      );
+      const isPrivileged = islevel === "2" || coHost === member;
+      const hasRelevantDirectMessages = isPrivileged ? newDirectMessages.length > 0 : relevantDirectMessages.length > 0;
+      if (hasRelevantDirectMessages && newDirectMessages.length > selfSentDirectMessages.length) {
+        updateShowMessagesBadge(true);
+      }
+    }
+  }
+};
+const recordingNotice = async ({
+  state,
+  userRecordingParam,
+  pauseCount,
+  timeDone,
+  parameters,
+  soundPlayer
+}) => {
+  let {
+    islevel,
+    userRecordingParams,
+    pauseRecordCount,
+    recordElapsedTime,
+    recordStartTime,
+    recordStarted,
+    recordPaused,
+    canLaunchRecord,
+    stopLaunchRecord,
+    recordStopped,
+    isTimerRunning,
+    canPauseResume,
+    eventType,
+    updateRecordingProgressTime,
+    updateShowRecordButtons,
+    updateUserRecordingParams,
+    updateRecordingMediaOptions,
+    updateRecordingAudioOptions,
+    updateRecordingVideoOptions,
+    updateRecordingVideoType,
+    updateRecordingVideoOptimized,
+    updateRecordingDisplayType,
+    updateRecordingAddHLS,
+    updateRecordingNameTags,
+    updateRecordingBackgroundColor,
+    updateRecordingNameTagsColor,
+    updateRecordingOrientationVideo,
+    updateRecordingAddText,
+    updateRecordingCustomText,
+    updateRecordingCustomTextPosition,
+    updateRecordingCustomTextColor,
+    updatePauseRecordCount,
+    updateRecordElapsedTime,
+    updateRecordStartTime,
+    updateRecordStarted,
+    updateRecordPaused,
+    updateCanLaunchRecord,
+    updateStopLaunchRecord,
+    updateRecordStopped,
+    updateIsTimerRunning,
+    updateCanPauseResume,
+    updateRecordState
+  } = parameters;
+  const playSound = async (soundUrl) => {
+    await (soundPlayer ?? SoundPlayer)({ soundUrl });
+  };
+  try {
+    if (islevel !== "2") {
+      if (state === "pause") {
+        updateRecordStarted(true);
+        updateRecordPaused(true);
+        updateRecordState("yellow");
+        if (eventType !== "broadcast") {
+          await playSound("https://www.mediasfu.com/sounds/record-paused.mp3");
+        }
+      } else if (state === "stop") {
+        updateRecordStarted(true);
+        updateRecordStopped(true);
+        updateRecordState("green");
+        if (eventType !== "broadcast") {
+          await playSound("https://www.mediasfu.com/sounds/record-stopped.mp3");
+        }
+      } else {
+        updateRecordState("red");
+        updateRecordStarted(true);
+        updateRecordPaused(false);
+        if (eventType !== "broadcast") {
+          await playSound("https://www.mediasfu.com/sounds/record-progress.mp3");
+        }
+      }
+    } else {
+      if (state === "pause") {
+        updateRecordState("yellow");
+        if (userRecordingParam) {
+          userRecordingParams.mainSpecs = userRecordingParam.mainSpecs;
+          userRecordingParams.dispSpecs = userRecordingParam.dispSpecs;
+          userRecordingParams.textSpecs = userRecordingParam.textSpecs;
+          updateUserRecordingParams(userRecordingParams);
+          updateRecordingMediaOptions(userRecordingParams.mainSpecs.mediaOptions);
+          updateRecordingAudioOptions(userRecordingParams.mainSpecs.audioOptions);
+          updateRecordingVideoOptions(userRecordingParams.mainSpecs.videoOptions);
+          updateRecordingVideoType(userRecordingParams.mainSpecs.videoType);
+          updateRecordingVideoOptimized(userRecordingParams.mainSpecs.videoOptimized);
+          updateRecordingDisplayType(userRecordingParams.mainSpecs.recordingDisplayType);
+          updateRecordingAddHLS(userRecordingParams.mainSpecs.addHLS);
+          updateRecordingNameTags(userRecordingParams.dispSpecs.nameTags);
+          updateRecordingBackgroundColor(userRecordingParams.dispSpecs.backgroundColor);
+          updateRecordingNameTagsColor(userRecordingParams.dispSpecs.nameTagsColor);
+          updateRecordingOrientationVideo(userRecordingParams.dispSpecs.orientationVideo);
+          updateRecordingAddText(userRecordingParams.textSpecs?.addText ?? false);
+          updateRecordingCustomText(userRecordingParams.textSpecs?.customText ?? "");
+          updateRecordingCustomTextPosition(
+            userRecordingParams.textSpecs?.customTextPosition ?? ""
+          );
+          updateRecordingCustomTextColor(
+            userRecordingParams.textSpecs?.customTextColor ?? ""
+          );
+          pauseRecordCount = pauseCount;
+          updatePauseRecordCount(pauseRecordCount);
+          recordElapsedTime = Math.floor(timeDone / 1e3);
+          recordStartTime = Math.floor(Date.now() / 1e3) - recordElapsedTime;
+          updateRecordStartTime(recordStartTime);
+          updateRecordElapsedTime(recordElapsedTime);
+          recordStarted = true;
+          recordPaused = true;
+          canLaunchRecord = false;
+          recordStopped = false;
+          updateRecordStarted(recordStarted);
+          updateRecordPaused(recordPaused);
+          updateCanLaunchRecord(canLaunchRecord);
+          updateRecordStopped(recordStopped);
+          updateShowRecordButtons(true);
+          isTimerRunning = false;
+          canPauseResume = true;
+          updateIsTimerRunning(isTimerRunning);
+          updateCanPauseResume(canPauseResume);
+          updateRecordingProgressTime(formatElapsedTime(recordElapsedTime));
+        }
+        await playSound("https://www.mediasfu.com/sounds/record-paused.mp3");
+      } else if (state === "stop") {
+        recordStarted = true;
+        recordStopped = true;
+        canLaunchRecord = false;
+        stopLaunchRecord = true;
+        updateRecordStarted(recordStarted);
+        updateRecordStopped(recordStopped);
+        updateCanLaunchRecord(canLaunchRecord);
+        updateStopLaunchRecord(stopLaunchRecord);
+        updateShowRecordButtons(false);
+        updateRecordState("green");
+        await playSound("https://www.mediasfu.com/sounds/record-stopped.mp3");
+      } else {
+        updateRecordState("red");
+        updateRecordStarted(true);
+        updateRecordPaused(false);
+        await playSound("https://www.mediasfu.com/sounds/record-progress.mp3");
+      }
+    }
+  } catch (error) {
+    console.log("Error in RecordingNotice: ", error);
+  }
+};
+const formatElapsedTime = (recordElapsedTime) => {
+  const hours = Math.floor(recordElapsedTime / 3600);
+  const minutes = Math.floor(recordElapsedTime % 3600 / 60);
+  const seconds = recordElapsedTime % 60;
+  return `${padNumber(hours)}:${padNumber(minutes)}:${padNumber(seconds)}`;
+};
+const padNumber = (value) => value.toString().padStart(2, "0");
+const reInitiateRecording = async ({
+  roomName,
+  member,
+  socket,
+  adminRestrictSetting
+}) => {
+  if (!adminRestrictSetting) {
+    socket.emit(
+      "startRecordIng",
+      { roomName, member },
+      ({ success }) => {
+      }
+    );
+  }
+};
+const roomRecordParams = async ({
+  recordParams,
+  parameters
+}) => {
+  const {
+    updateRecordingAudioPausesLimit,
+    updateRecordingAudioPausesCount,
+    updateRecordingAudioSupport,
+    updateRecordingAudioPeopleLimit,
+    updateRecordingAudioParticipantsTimeLimit,
+    updateRecordingVideoPausesCount,
+    updateRecordingVideoPausesLimit,
+    updateRecordingVideoSupport,
+    updateRecordingVideoPeopleLimit,
+    updateRecordingVideoParticipantsTimeLimit,
+    updateRecordingAllParticipantsSupport,
+    updateRecordingVideoParticipantsSupport,
+    updateRecordingAllParticipantsFullRoomSupport,
+    updateRecordingVideoParticipantsFullRoomSupport,
+    updateRecordingPreferredOrientation,
+    updateRecordingSupportForOtherOrientation,
+    updateRecordingMultiFormatsSupport
+  } = parameters;
+  updateRecordingAudioPausesLimit(recordParams.recordingAudioPausesLimit);
+  updateRecordingAudioPausesCount(recordParams.recordingAudioPausesCount);
+  updateRecordingAudioSupport(recordParams.recordingAudioSupport);
+  updateRecordingAudioPeopleLimit(recordParams.recordingAudioPeopleLimit);
+  updateRecordingAudioParticipantsTimeLimit(
+    recordParams.recordingAudioParticipantsTimeLimit
+  );
+  updateRecordingVideoPausesCount(recordParams.recordingVideoPausesCount);
+  updateRecordingVideoPausesLimit(recordParams.recordingVideoPausesLimit);
+  updateRecordingVideoSupport(recordParams.recordingVideoSupport);
+  updateRecordingVideoPeopleLimit(recordParams.recordingVideoPeopleLimit);
+  updateRecordingVideoParticipantsTimeLimit(
+    recordParams.recordingVideoParticipantsTimeLimit
+  );
+  updateRecordingAllParticipantsSupport(
+    recordParams.recordingAllParticipantsSupport
+  );
+  updateRecordingVideoParticipantsSupport(
+    recordParams.recordingVideoParticipantsSupport
+  );
+  updateRecordingAllParticipantsFullRoomSupport(
+    recordParams.recordingAllParticipantsFullRoomSupport
+  );
+  updateRecordingVideoParticipantsFullRoomSupport(
+    recordParams.recordingVideoParticipantsFullRoomSupport
+  );
+  updateRecordingPreferredOrientation(
+    recordParams.recordingPreferredOrientation
+  );
+  updateRecordingSupportForOtherOrientation(
+    recordParams.recordingSupportForOtherOrientation
+  );
+  updateRecordingMultiFormatsSupport(recordParams.recordingMultiFormatsSupport);
+};
+const screenProducerId = ({
+  producerId,
+  screenId,
+  membersReceived,
+  participants,
+  updateScreenId,
+  updateShareScreenStarted,
+  updateDeferScreenReceived
+}) => {
+  const host = participants.find(
+    (participant) => participant.ScreenID === screenId && participant.ScreenOn === true
+  );
+  if (host && membersReceived) {
+    updateScreenId(producerId);
+    updateShareScreenStarted(true);
+    updateDeferScreenReceived(false);
+    return;
+  }
+  updateScreenId(producerId);
+  updateDeferScreenReceived(true);
+};
+const startRecords = async ({
+  roomName,
+  member,
+  socket
+}) => {
+  socket.emit(
+    "startRecordIng",
+    { roomName, member },
+    ({ success }) => {
+    }
+  );
+};
+const stoppedRecording = async ({
+  state,
+  reason,
+  showAlert
+}) => {
+  try {
+    if (state === "stop") {
+      showAlert?.({
+        message: `The recording has stopped - ${reason}.`,
+        duration: 3e3,
+        type: "danger"
+      });
+    }
+  } catch (error) {
+    console.log("Error in stoppedRecording: ", error);
+  }
+};
+const translationRoomConfig = async ({
+  data,
+  updateTranslationConfig,
+  updateTranslationSupported
+}) => {
+  try {
+    const { config } = data;
+    updateTranslationSupported?.(config.supportTranslation);
+    if (updateTranslationConfig && config.supportTranslation) {
+      updateTranslationConfig(config);
+    }
+  } catch (error) {
+    console.error("Error handling translation:roomConfig:", error);
+  }
+};
+const translationConfigUpdated = async ({
+  data,
+  updateTranslationConfig,
+  showAlert
+}) => {
+  try {
+    updateTranslationConfig?.(data.config);
+    showAlert?.({
+      message: "Translation settings updated by host",
+      type: "info",
+      duration: 2e3
+    });
+  } catch (error) {
+    console.error("Error handling translation:configUpdated:", error);
+  }
+};
+const translationLanguageSet = async ({
+  data,
+  updateMySpokenLanguage,
+  updateMySpokenLanguageEnabled,
+  showAlert
+}) => {
+  try {
+    if (data.success) {
+      updateMySpokenLanguage?.(data.language);
+      updateMySpokenLanguageEnabled?.(data.enabled);
+    } else if (showAlert && data.error) {
+      showAlert({
+        message: data.error,
+        type: "danger",
+        duration: 3e3
+      });
+    }
+  } catch (error) {
+    console.error("Error handling translation:languageSet:", error);
+  }
+};
+const translationSubscribed = async ({
+  data,
+  updateListenPreferences,
+  updateTranslationProducerMap,
+  startConsumingTranslation,
+  showAlert
+}) => {
+  try {
+    const { speakerId, language, channelCreated, producerId, originalProducerId } = data;
+    updateListenPreferences?.((prev) => {
+      const next = new Map(prev);
+      next.set(speakerId, language);
+      return next;
+    });
+    if (producerId && originalProducerId && updateTranslationProducerMap) {
+      updateTranslationProducerMap((prev) => ({
+        ...prev,
+        [originalProducerId]: {
+          ...prev[originalProducerId] || {},
+          [language]: producerId
+        }
+      }));
+    }
+    if (producerId && startConsumingTranslation) {
+      await startConsumingTranslation(producerId, speakerId, language, originalProducerId);
+    }
+    if (showAlert && channelCreated) {
+      showAlert({
+        message: `Translation channel created for ${language}`,
+        type: "success",
+        duration: 2e3
+      });
+    }
+  } catch (error) {
+    console.error("Error handling translation:subscribed:", error);
+  }
+};
+const translationUnsubscribed = async ({
+  data,
+  updateListenPreferences,
+  stopConsumingTranslation
+}) => {
+  try {
+    updateListenPreferences?.((prev) => {
+      const next = new Map(prev);
+      next.delete(data.speakerId);
+      return next;
+    });
+    if (stopConsumingTranslation) {
+      await stopConsumingTranslation(data.speakerId, data.language);
+    }
+  } catch (error) {
+    console.error("Error handling translation:unsubscribed:", error);
+  }
+};
+const translationProducerReady = async ({
+  data,
+  updateTranslationProducerMap,
+  pauseOriginalProducer
+}) => {
+  try {
+    updateTranslationProducerMap?.((prev) => ({
+      ...prev,
+      [data.originalProducerId]: {
+        ...prev[data.originalProducerId] || {},
+        [data.language]: data.producerId
+      }
+    }));
+    if (pauseOriginalProducer) {
+      await pauseOriginalProducer(data.originalProducerId);
+    }
+  } catch (error) {
+    console.error("Error handling translation:producerReady:", error);
+  }
+};
+const translationProducerClosed = async ({
+  data,
+  updateTranslationProducerMap,
+  stopConsumingTranslation,
+  resumeOriginalProducer,
+  showAlert
+}) => {
+  try {
+    if (updateTranslationProducerMap) {
+      updateTranslationProducerMap((prev) => {
+        const next = { ...prev };
+        for (const [originalProducerId, languageMap] of Object.entries(next)) {
+          if (languageMap[data.language] === data.producerId) {
+            delete languageMap[data.language];
+            if (Object.keys(languageMap).length === 0) {
+              delete next[originalProducerId];
+            }
+          }
+        }
+        return next;
+      });
+    }
+    if (stopConsumingTranslation) {
+      await stopConsumingTranslation(data.producerId);
+    }
+    if (resumeOriginalProducer) {
+      await resumeOriginalProducer(data.speakerId);
+    }
+    if (showAlert && data.reason) {
+      showAlert({
+        message: `Translation stopped: ${data.reason}`,
+        type: "info",
+        duration: 2e3
+      });
+    }
+  } catch (error) {
+    console.error("Error handling translation:producerClosed:", error);
+  }
+};
+const translationChannelsAvailable = async ({
+  data,
+  updateAvailableTranslationChannels,
+  myDefaultListenLanguage,
+  socket,
+  roomName
+}) => {
+  try {
+    updateAvailableTranslationChannels?.(data.speakerId, data.languages, data.originalProducerId);
+    if (myDefaultListenLanguage && data.languages.includes(myDefaultListenLanguage) && socket && roomName) {
+      socket.emit("translation:subscribe", {
+        roomName,
+        speakerId: data.speakerId,
+        language: myDefaultListenLanguage,
+        originalProducerId: data.originalProducerId
+      });
+    }
+  } catch (error) {
+    console.error("Error handling translation:channelsAvailable:", error);
+  }
+};
+const translationMemberState = async ({
+  data,
+  updateParticipantTranslationState
+}) => {
+  try {
+    updateParticipantTranslationState?.(data.memberId, data.state);
+  } catch (error) {
+    console.error("Error handling translation:memberState:", error);
+  }
+};
+const translationError = async ({
+  data,
+  showAlert
+}) => {
+  try {
+    if (showAlert) {
+      let message = data.error;
+      switch (data.code) {
+        case "max_channels":
+          if (data.availableChannels && data.availableChannels.length > 0) {
+            message = `Maximum ${data.maxChannels || 5} translation channels reached. Available: ${data.availableChannels.join(", ")}`;
+          } else {
+            message = data.message || "Maximum translation channels reached. Please wait for a slot to open.";
+          }
+          break;
+        case "speaker_not_found":
+          message = "Speaker not found or has left the meeting.";
+          break;
+        case "language_not_allowed":
+          message = "This language is not available for translation in this room.";
+          break;
+        default:
+          message = data.error || "Translation error occurred";
+      }
+      showAlert({
+        message,
+        type: "danger",
+        duration: 5e3
+      });
+    }
+  } catch (err) {
+    console.error("Error handling translation:error:", err);
+  }
+};
+const translationTranscript = async ({
+  data,
+  updateTranscripts,
+  onTranscriptReceived,
+  maxTranscripts = 100
+}) => {
+  try {
+    if (updateTranscripts) {
+      updateTranscripts((prev) => {
+        const next = [...prev, data];
+        return next.length > maxTranscripts ? next.slice(-maxTranscripts) : next;
+      });
+    }
+    onTranscriptReceived?.(data);
+  } catch (err) {
+    console.error("Error handling translation:transcript:", err);
+  }
+};
+const translationSpeakerOutputChanged = async ({
+  data,
+  pauseOriginalProducer,
+  resumeOriginalProducer,
+  stopConsumingTranslationForSpeaker,
+  updateSpeakerTranslationState,
+  showAlert,
+  listenerOverride
+}) => {
+  try {
+    updateSpeakerTranslationState?.(data.speakerId, data.outputLanguage, data.originalProducerId);
+    const listenerWantsOriginal = listenerOverride?.wantOriginal === true;
+    const listenerWantsDifferentLanguage = Boolean(
+      listenerOverride?.preferredLanguage && listenerOverride.preferredLanguage.toLowerCase() !== data.outputLanguage?.toLowerCase()
+    );
+    if (listenerWantsOriginal) {
+      showAlert?.({
+        message: `${data.speakerName} is speaking in ${data.outputLanguage ? getLanguageName(data.outputLanguage) : "translated"} but you're hearing original`,
+        type: "info",
+        duration: 3e3
+      });
+      return;
+    }
+    if (listenerWantsDifferentLanguage) {
+      if (pauseOriginalProducer && data.originalProducerId) {
+        await pauseOriginalProducer(data.originalProducerId, data.speakerId);
+      }
+      return;
+    }
+    if (data.enabled && data.outputLanguage && data.originalProducerId) {
+      if (pauseOriginalProducer) {
+        await pauseOriginalProducer(data.originalProducerId, data.speakerId);
+      }
+      showAlert?.({
+        message: `${data.speakerName} is now speaking in ${getLanguageName(data.outputLanguage)}`,
+        type: "info",
+        duration: 3e3
+      });
+    } else if (!data.enabled || !data.outputLanguage) {
+      if (stopConsumingTranslationForSpeaker) {
+        await stopConsumingTranslationForSpeaker(data.speakerId);
+      }
+      if (resumeOriginalProducer && data.originalProducerId) {
+        await resumeOriginalProducer(data.originalProducerId, data.speakerId);
+      }
+      if (showAlert && !data.enabled) {
+        showAlert({
+          message: `${data.speakerName} returned to original language`,
+          type: "info",
+          duration: 3e3
+        });
+      }
+    }
+  } catch (err) {
+    console.error("Error handling translation:speakerOutputChanged:", err);
+  }
+};
+const updateMediaSettings = ({
+  settings,
+  updateAudioSetting,
+  updateVideoSetting,
+  updateScreenshareSetting,
+  updateChatSetting
+}) => {
+  const [audioSetting, videoSetting, screenshareSetting, chatSetting] = settings;
+  updateAudioSetting(audioSetting);
+  updateVideoSetting(videoSetting);
+  updateScreenshareSetting(screenshareSetting);
+  updateChatSetting(chatSetting);
+};
+const updateConsumingDomains = async ({
+  domains,
+  alt_domains,
+  parameters,
+  apiUserName,
+  apiKey,
+  apiToken
+}) => {
+  let { participants, getDomains: getDomains2, consume_sockets, connectIps } = parameters;
+  consume_sockets = parameters.getUpdatedAllParams().consume_sockets;
+  try {
+    if (participants.length > 0) {
+      if (Object.keys(alt_domains).length > 0) {
+        await getDomains2({
+          domains,
+          alt_domains,
+          apiUserName,
+          apiKey,
+          apiToken,
+          parameters
+        });
+      } else {
+        await connectIps({
+          consume_sockets,
+          remIP: domains,
+          parameters,
+          apiUserName,
+          apiKey,
+          apiToken
+        });
+      }
+    }
+  } catch (error) {
+    console.log("Error in updateConsumingDomains: ", error);
+  }
+};
+const updatedCoHost = async ({
+  coHost,
+  coHostResponsibility,
+  showAlert,
+  eventType,
+  islevel,
+  member,
+  youAreCoHost,
+  updateCoHost,
+  updateCoHostResponsibility,
+  updateYouAreCoHost
+}) => {
+  if (eventType !== "broadcast" && eventType !== "chat") {
+    updateCoHost(coHost);
+    updateCoHostResponsibility(coHostResponsibility);
+    if (member === coHost) {
+      if (!youAreCoHost) {
+        updateYouAreCoHost(true);
+        showAlert?.({
+          message: "You are now a co-host.",
+          type: "success",
+          duration: 3e3
+        });
+      }
+    } else {
+      updateYouAreCoHost(false);
+    }
+  } else if (islevel !== "2") {
+    updateYouAreCoHost(true);
+  }
+};
+const userWaiting = async ({
+  name,
+  showAlert,
+  totalReqWait,
+  updateTotalReqWait
+}) => {
+  showAlert?.({
+    message: `${name} joined the waiting room.`,
+    type: "success",
+    duration: 3e3
+  });
+  updateTotalReqWait(totalReqWait + 1);
+};
+const cookies = new joinRoomOnMediaSFU.Cookies();
+const MAX_ATTEMPTS = 10;
+const RATE_LIMIT_DURATION = 3 * 60 * 60 * 1e3;
+const hasConnectedSocketId = (socket) => {
+  if (!socket || typeof socket !== "object") {
+    return false;
+  }
+  const candidate = socket;
+  return typeof candidate.id === "string" && candidate.id.length > 0;
+};
+function validateAlphanumeric(str) {
+  if (str.length === 0) return true;
+  const alphanumericRegex = /^[a-zA-Z0-9]+$/;
+  return alphanumericRegex.test(str);
+}
+function validateWelcomeInputs({
+  name,
+  secret,
+  eventID,
+  link
+}) {
+  if (name.length === 0 || secret.length === 0 || eventID.length === 0 || link.length === 0) {
+    return { valid: false, message: "Please fill all the fields." };
+  }
+  if (!validateAlphanumeric(name) || !validateAlphanumeric(secret) || !validateAlphanumeric(eventID) || !link.includes("mediasfu.com") || eventID.toLowerCase().startsWith("d")) {
+    return { valid: false, message: "Please enter valid details." };
+  }
+  if (secret.length != 64 || name.length > 12 || name.length < 2 || eventID.length > 32 || eventID.length < 8 || link.length < 12) {
+    return { valid: false, message: "Please enter valid details." };
+  }
+  return { valid: true };
+}
+async function handleWelcomeRequest({
+  apiUserName,
+  apiToken,
+  link,
+  userName,
+  parameters
+}) {
+  const {
+    showAlert,
+    updateIsLoadingModalVisible,
+    connectSocket,
+    updateSocket,
+    updateValidated,
+    updateApiUserName,
+    updateApiToken,
+    updateLink,
+    updateRoomName,
+    updateMember
+  } = parameters;
+  const TIMEOUT_DURATION = 1e4;
+  let unsuccessfulAttempts = parseInt(cookies.get("unsuccessfulAttempts") || "0");
+  let lastRequestTimestamp = parseInt(cookies.get("lastRequestTimestamp") || "0");
+  if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+    if (Date.now() - lastRequestTimestamp < RATE_LIMIT_DURATION) {
+      showAlert?.({
+        message: "Too many unsuccessful attempts. Please try again later.",
+        type: "danger",
+        duration: 3e3
+      });
+      cookies.set("lastRequestTimestamp", Date.now().toString());
+      return;
+    } else {
+      unsuccessfulAttempts = 0;
+      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      cookies.set("lastRequestTimestamp", Date.now().toString());
+    }
+  }
+  try {
+    updateIsLoadingModalVisible(true);
+    const socketPromise = connectSocket({
+      apiUserName,
+      apiKey: "",
+      apiToken,
+      link
+    });
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Request timed out")), TIMEOUT_DURATION)
+    );
+    const socket = await Promise.race([socketPromise, timeoutPromise]);
+    if (hasConnectedSocketId(socket)) {
+      unsuccessfulAttempts = 0;
+      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      cookies.set("lastRequestTimestamp", Date.now().toString());
+      updateSocket(socket);
+      updateApiUserName(apiUserName);
+      updateApiToken(apiToken);
+      updateLink(link);
+      updateRoomName(apiUserName);
+      updateMember(userName);
+      updateValidated(true);
+    } else {
+      unsuccessfulAttempts += 1;
+      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      cookies.set("lastRequestTimestamp", Date.now().toString());
+      updateIsLoadingModalVisible(false);
+      if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+        showAlert?.({
+          message: "Too many unsuccessful attempts. Please try again later.",
+          type: "danger",
+          duration: 3e3
+        });
+      } else {
+        showAlert?.({
+          message: "Invalid credentials.",
+          type: "danger",
+          duration: 3e3
+        });
+      }
+    }
+  } catch {
+    showAlert?.({
+      message: "Unable to connect. Check your credentials and try again.",
+      type: "danger",
+      duration: 3e3
+    });
+    unsuccessfulAttempts += 1;
+    cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+    cookies.set("lastRequestTimestamp", Date.now().toString());
+    updateIsLoadingModalVisible(false);
+  }
+}
+exports.QnHDCons = joinRoomOnMediaSFU.QnHDCons;
+exports.QnHDConsNeu = joinRoomOnMediaSFU.QnHDConsNeu;
+exports.QnHDConsPort = joinRoomOnMediaSFU.QnHDConsPort;
+exports.QnHDFrameRate = joinRoomOnMediaSFU.QnHDFrameRate;
+exports.aParams = joinRoomOnMediaSFU.aParams;
+exports.captureCanvasStream = joinRoomOnMediaSFU.captureCanvasStream;
+exports.checkLimitsAndMakeRequest = joinRoomOnMediaSFU.checkLimitsAndMakeRequest;
+exports.checkLimitsAndMakeRequestWithStorage = joinRoomOnMediaSFU.checkLimitsAndMakeRequestWithStorage;
+exports.clickAudio = joinRoomOnMediaSFU.clickAudio;
+exports.clickScreenShare = joinRoomOnMediaSFU.clickScreenShare;
+exports.fhdCons = joinRoomOnMediaSFU.fhdCons;
+exports.fhdConsNeu = joinRoomOnMediaSFU.fhdConsNeu;
+exports.fhdConsPort = joinRoomOnMediaSFU.fhdConsPort;
+exports.fhdFrameRate = joinRoomOnMediaSFU.fhdFrameRate;
+exports.hParams = joinRoomOnMediaSFU.hParams;
+exports.hdCons = joinRoomOnMediaSFU.hdCons;
+exports.hdConsNeu = joinRoomOnMediaSFU.hdConsNeu;
+exports.hdConsPort = joinRoomOnMediaSFU.hdConsPort;
+exports.hdFrameRate = joinRoomOnMediaSFU.hdFrameRate;
+exports.hostRequestResponse = joinRoomOnMediaSFU.hostRequestResponse;
+exports.joinRoomOnMediaSFU = joinRoomOnMediaSFU.joinRoomOnMediaSFU;
+exports.qhdCons = joinRoomOnMediaSFU.qhdCons;
+exports.qhdConsNeu = joinRoomOnMediaSFU.qhdConsNeu;
+exports.qhdConsPort = joinRoomOnMediaSFU.qhdConsPort;
+exports.qhdFrameRate = joinRoomOnMediaSFU.qhdFrameRate;
+exports.screenFrameRate = joinRoomOnMediaSFU.screenFrameRate;
+exports.screenParams = joinRoomOnMediaSFU.screenParams;
+exports.sdCons = joinRoomOnMediaSFU.sdCons;
+exports.sdConsNeu = joinRoomOnMediaSFU.sdConsNeu;
+exports.sdConsPort = joinRoomOnMediaSFU.sdConsPort;
+exports.sdFrameRate = joinRoomOnMediaSFU.sdFrameRate;
+exports.timeLeftRecording = joinRoomOnMediaSFU.timeLeftRecording;
+exports.vParams = joinRoomOnMediaSFU.vParams;
+exports.validateAlphanumeric = validateAlphanumeric$1.validateAlphanumeric;
+exports.COMMON_LANGUAGE_CODES = COMMON_LANGUAGE_CODES;
+exports.MediaStream = MediaStream;
+exports.MediaStreamTrack = MediaStreamTrack;
+exports.RTCView = RTCView;
+exports.SUPPORTED_LANGUAGE_CODES = SUPPORTED_LANGUAGE_CODES;
+exports.SoundPlayer = SoundPlayer;
+exports.TTS_PROVIDERS = TTS_PROVIDERS;
+exports.addPanelist = addPanelist;
+exports.addedAsPanelist = addedAsPanelist;
+exports.allMembers = allMembers;
+exports.allMembersRest = allMembersRest;
+exports.allWaitingRoomMembers = allWaitingRoomMembers;
+exports.banParticipant = banParticipant;
+exports.bulkUpdateParticipantPermissions = bulkUpdateParticipantPermissions;
+exports.clickChat = clickChat;
+exports.controlMediaHost = controlMediaHost;
+exports.createLiveSubtitle = createLiveSubtitle;
+exports.createResponseJoinRoom = createResponseJoinRoom;
+exports.createRoomOnMediaSFU = createRoomOnMediaSFU;
+exports.disconnect = disconnect;
+exports.disconnectUserSelf = disconnectUserSelf;
+exports.fetchLanguagesViaSocket = fetchLanguagesViaSocket;
+exports.fetchVoicesViaSocket = fetchVoicesViaSocket;
+exports.focusPanelists = focusPanelists;
+exports.formatNumber = formatNumber;
+exports.generateRandomMessages = generateRandomMessages;
+exports.generateRandomParticipants = generateRandomParticipants;
+exports.generateRandomPolls = generateRandomPolls;
+exports.generateRandomRequestList = generateRandomRequestList;
+exports.generateRandomWaitingRoomList = generateRandomWaitingRoomList;
+exports.getAvailableVoices = getAvailableVoices;
+exports.getCommonLanguages = getCommonLanguages;
+exports.getDomains = getDomains;
+exports.getLanguageMetadata = getLanguageMetadata;
+exports.getLanguageName = getLanguageName;
+exports.getLanguageNativeName = getLanguageNativeName;
+exports.getOverlayPosition = getOverlayPosition;
+exports.getSubtitleForSpeaker = getSubtitleForSpeaker;
+exports.getSupportedLanguages = getSupportedLanguages;
+exports.handleCreateRoom = handleCreateRoom;
+exports.handleJoinRoom = handleJoinRoom;
+exports.handleWelcomeRequest = handleWelcomeRequest;
+exports.initialValuesState = initialValuesState;
+exports.isLanguageSupported = isLanguageSupported;
+exports.isSubtitleExpired = isSubtitleExpired;
+exports.launchPanelists = launchPanelists;
+exports.launchPermissions = launchPermissions;
+exports.mediaDevices = mediaDevices;
+exports.meetingEnded = meetingEnded;
+exports.meetingStillThere = meetingStillThere;
+exports.meetingTimeRemaining = meetingTimeRemaining;
+exports.normalizeLanguageCode = normalizeLanguageCode;
+exports.panelistControlMedia = panelistControlMedia;
+exports.panelistFocusChanged = panelistFocusChanged;
+exports.panelistsUpdated = panelistsUpdated;
+exports.participantRequested = participantRequested;
+exports.permissionConfigUpdated = permissionConfigUpdated;
+exports.permissionUpdated = permissionUpdated;
+exports.personJoined = personJoined;
+exports.pollUpdated = pollUpdated;
+exports.producerMediaClosed = producerMediaClosed;
+exports.producerMediaPaused = producerMediaPaused;
+exports.producerMediaResumed = producerMediaResumed;
+exports.pruneExpiredSubtitles = pruneExpiredSubtitles;
+exports.reInitiateRecording = reInitiateRecording;
+exports.receiveMessage = receiveMessage;
+exports.recordingNotice = recordingNotice;
+exports.registerGlobals = registerGlobals;
+exports.removePanelist = removePanelist;
+exports.removedFromPanelists = removedFromPanelists;
+exports.roomRecordParams = roomRecordParams;
+exports.screenProducerId = screenProducerId;
+exports.sleep = sleep;
+exports.startMeetingProgressTimer = startMeetingProgressTimer;
+exports.startRecords = startRecords;
+exports.stoppedRecording = stoppedRecording;
+exports.translationChannelsAvailable = translationChannelsAvailable;
+exports.translationConfigUpdated = translationConfigUpdated;
+exports.translationError = translationError;
+exports.translationLanguageSet = translationLanguageSet;
+exports.translationMemberState = translationMemberState;
+exports.translationProducerClosed = translationProducerClosed;
+exports.translationProducerReady = translationProducerReady;
+exports.translationRoomConfig = translationRoomConfig;
+exports.translationSpeakerOutputChanged = translationSpeakerOutputChanged;
+exports.translationSubscribed = translationSubscribed;
+exports.translationTranscript = translationTranscript;
+exports.translationUnsubscribed = translationUnsubscribed;
+exports.unfocusPanelists = unfocusPanelists;
+exports.updateConsumingDomains = updateConsumingDomains;
+exports.updateLiveSubtitlesFromTranscript = updateLiveSubtitlesFromTranscript;
+exports.updateMediaSettings = updateMediaSettings;
+exports.updatePanelists = updatePanelists;
+exports.updateParticipantPermission = updateParticipantPermission;
+exports.updatePermissionConfig = updatePermissionConfig;
+exports.updatedCoHost = updatedCoHost;
+exports.userWaiting = userWaiting;
+exports.validateWelcomeAlphanumeric = validateAlphanumeric;
+exports.validateWelcomeInputs = validateWelcomeInputs;
+//# sourceMappingURL=index.cjs.map