mediasfu-shared 1.0.6 → 1.2.0

package/dist/joinLocalRoom-CvteNe4R.js

@@ -0,0 +1,657 @@
+import { ab as createFrameworkConsumerContractError, X as joinConRoom } from "./updateParticipantAudioDecibels-DLd8Y-Fh.js";
+import * as mediasoupClient from "mediasoup-client";
+import { v as validateAlphanumeric } from "./validateAlphanumeric-Dk1JB80W.js";
+import { g as hParams, v as vParams, k as hdCons, l as fhdCons, q as qhdCons, i as sdCons, Q as QnHDCons, x as hdConsNeu, y as fhdConsNeu, z as qhdConsNeu, w as sdConsNeu, u as QnHDConsNeu, o as hdConsPort, p as fhdConsPort, r as qhdConsPort, n as sdConsPort, m as QnHDConsPort, C as hdFrameRate, A as QnHDFrameRate, D as fhdFrameRate, E as qhdFrameRate, s as screenParams, f as aParams, a as checkLimitsAndMakeRequest, j as joinRoomOnMediaSFU } from "./joinRoomOnMediaSFU-y6vJ1OBo.js";
+const addVideosGrid = async () => {
+  throw createFrameworkConsumerContractError("addVideosGrid");
+};
+const prepopulateUserMedia = async () => {
+  throw createFrameworkConsumerContractError("prepopulateUserMedia");
+};
+const breakoutRoomUpdated = async ({ data, parameters }) => {
+  try {
+    let {
+      breakOutRoomStarted,
+      breakOutRoomEnded,
+      breakoutRooms,
+      hostNewRoom,
+      islevel,
+      participantsAll,
+      participants,
+      meetingDisplayType,
+      prevMeetingDisplayType,
+      updateBreakoutRooms,
+      updateBreakOutRoomStarted,
+      updateBreakOutRoomEnded,
+      updateHostNewRoom,
+      updateMeetingDisplayType,
+      updateParticipantsAll,
+      updateParticipants,
+      onScreenChanges,
+      rePort
+    } = parameters;
+    if (data.forHost) {
+      hostNewRoom = data.newRoom;
+      updateHostNewRoom(hostNewRoom);
+      await onScreenChanges({ changed: true, parameters });
+      return;
+    }
+    if (islevel === "2" && data.members) {
+      participantsAll = data.members.map((participant) => ({
+        isBanned: participant.isBanned,
+        name: participant.name,
+        audioID: participant.audioID,
+        videoID: participant.videoID
+      }));
+      updateParticipantsAll(participantsAll);
+      participants = data.members.filter((participant) => !participant.isBanned);
+      updateParticipants(participants);
+    }
+    breakoutRooms = data.breakoutRooms || [];
+    updateBreakoutRooms(breakoutRooms);
+    if (data.status === "started" && (!breakOutRoomStarted || breakOutRoomEnded)) {
+      breakOutRoomStarted = true;
+      breakOutRoomEnded = false;
+      updateBreakOutRoomStarted(true);
+      updateBreakOutRoomEnded(false);
+      prevMeetingDisplayType = meetingDisplayType;
+      if (meetingDisplayType !== "all") {
+        meetingDisplayType = "all";
+        updateMeetingDisplayType("all");
+      }
+      await onScreenChanges({ changed: true, parameters });
+      if (islevel === "2") {
+        await rePort({ restart: true, parameters });
+      }
+    } else if (data.status === "ended") {
+      breakOutRoomEnded = true;
+      updateBreakOutRoomEnded(true);
+      if (meetingDisplayType !== prevMeetingDisplayType) {
+        updateMeetingDisplayType(prevMeetingDisplayType);
+      }
+      await onScreenChanges({ changed: true, parameters });
+      if (islevel === "2") {
+        await rePort({ restart: true, parameters });
+      }
+    } else if (data.status === "started" && breakOutRoomStarted) {
+      breakOutRoomStarted = true;
+      breakOutRoomEnded = false;
+      updateBreakOutRoomStarted(true);
+      updateBreakOutRoomEnded(false);
+      await onScreenChanges({ changed: true, parameters });
+      if (islevel === "2") {
+        await rePort({ restart: true, parameters });
+      }
+    }
+  } catch {
+  }
+};
+async function modifySettings({
+  // showAlert,
+  roomName,
+  audioSet,
+  videoSet,
+  screenshareSet,
+  chatSet,
+  socket,
+  updateAudioSetting,
+  updateVideoSetting,
+  updateScreenshareSetting,
+  updateChatSetting,
+  updateIsSettingsModalVisible
+}) {
+  if (audioSet) {
+    updateAudioSetting(audioSet);
+  }
+  if (videoSet) {
+    updateVideoSetting(videoSet);
+  }
+  if (screenshareSet) {
+    updateScreenshareSetting(screenshareSet);
+  }
+  if (chatSet) {
+    updateChatSetting(chatSet);
+  }
+  const settings = [audioSet, videoSet, screenshareSet, chatSet];
+  socket.emit("updateSettingsForRequests", { settings, roomName });
+  updateIsSettingsModalVisible(false);
+}
+const createDeviceClient = async ({
+  rtpCapabilities
+}) => {
+  try {
+    if (!rtpCapabilities) {
+      throw new Error(
+        "Both rtpCapabilities and mediasoupClient must be provided."
+      );
+    }
+    const device = new mediasoupClient.Device();
+    rtpCapabilities.headerExtensions = rtpCapabilities.headerExtensions.filter(
+      (ext) => ext.uri !== "urn:3gpp:video-orientation"
+    );
+    await device.load({
+      routerRtpCapabilities: rtpCapabilities
+    });
+    return device;
+  } catch (error) {
+    if (error && error.name === "UnsupportedError") {
+      console.error("Device creation is not supported by this browser.");
+    }
+    throw error;
+  }
+};
+async function joinRoom({
+  socket,
+  roomName,
+  islevel,
+  member,
+  sec,
+  apiUserName
+}) {
+  return new Promise((resolve, reject) => {
+    if (!(sec && roomName && islevel && apiUserName && member)) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Missing required parameters"
+      };
+      reject(validationError);
+      return;
+    }
+    try {
+      validateAlphanumeric({ str: roomName });
+      validateAlphanumeric({ str: apiUserName });
+      validateAlphanumeric({ str: member });
+    } catch {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName or apiUserName or member"
+      };
+      reject(validationError);
+      return;
+    }
+    if (!(roomName.startsWith("s") || roomName.startsWith("p") || roomName.startsWith("d"))) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName, must start with s or p or d"
+      };
+      reject(validationError);
+      return;
+    }
+    if (!(sec.length === 64 && roomName.length >= 8 && islevel.length === 1 && apiUserName.length >= 6 && (islevel === "0" || islevel === "1" || islevel === "2"))) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName or islevel or apiUserName or secret"
+      };
+      reject(validationError);
+      return;
+    }
+    socket.emit(
+      "joinRoom",
+      {
+        roomName,
+        islevel,
+        member,
+        sec,
+        apiUserName
+      },
+      async (data) => {
+        try {
+          if (data.rtpCapabilities == null) {
+            if (data.banned) {
+              throw new Error("User is banned.");
+            }
+            if (data.suspended) {
+              throw new Error("User is suspended.");
+            }
+            if (data.noAdmin) {
+              throw new Error("Host has not joined the room yet.");
+            }
+            resolve(data);
+          } else {
+            resolve(data);
+          }
+        } catch (error) {
+          console.log("Error joining room:", error);
+          reject(error);
+        }
+      }
+    );
+  });
+}
+const joinRoomClient = async ({
+  socket,
+  roomName,
+  islevel,
+  member,
+  sec,
+  apiUserName,
+  consume = false
+}) => {
+  try {
+    if (consume) {
+      return await joinConRoom({
+        socket,
+        roomName,
+        islevel,
+        member,
+        sec,
+        apiUserName
+      });
+    }
+    return await joinRoom({
+      socket,
+      roomName,
+      islevel,
+      member,
+      sec,
+      apiUserName
+    });
+  } catch (error) {
+    console.log(error);
+    throw new Error("Failed to join the room. Please check your connection and try again.");
+  }
+};
+const updateRoomParametersClient = ({ parameters }) => {
+  try {
+    const {
+      screenPageLimit,
+      shareScreenStarted,
+      shared,
+      hParams: hParams$1 = hParams,
+      vParams: vParams$1 = vParams,
+      frameRate,
+      islevel,
+      showAlert,
+      data,
+      updateRtpCapabilities,
+      updateRoomRecvIPs,
+      updateMeetingRoomParams,
+      updateItemPageLimit,
+      updateAudioOnlyRoom,
+      updateScreenPageLimit,
+      updateVidCons,
+      updateFrameRate,
+      updateAdminPasscode,
+      updateEventType,
+      updateYouAreCoHost,
+      updateAutoWave,
+      updateForceFullDisplay,
+      updateChatSetting,
+      updateMeetingDisplayType,
+      updateAudioSetting,
+      updateVideoSetting,
+      updateScreenshareSetting,
+      updateHParams,
+      updateVParams,
+      updateScreenParams,
+      updateAParams,
+      updateTargetResolution,
+      updateTargetResolutionHost,
+      updateRecordingAudioPausesLimit,
+      updateRecordingAudioPausesCount,
+      updateRecordingAudioSupport,
+      updateRecordingAudioPeopleLimit,
+      updateRecordingAudioParticipantsTimeLimit,
+      updateRecordingVideoPausesCount,
+      updateRecordingVideoPausesLimit,
+      updateRecordingVideoSupport,
+      updateRecordingVideoPeopleLimit,
+      updateRecordingVideoParticipantsTimeLimit,
+      updateRecordingAllParticipantsSupport,
+      updateRecordingVideoParticipantsSupport,
+      updateRecordingAllParticipantsFullRoomSupport,
+      updateRecordingVideoParticipantsFullRoomSupport,
+      updateRecordingPreferredOrientation,
+      updateRecordingSupportForOtherOrientation,
+      updateRecordingMultiFormatsSupport,
+      updateRecordingVideoOptions,
+      updateRecordingAudioOptions,
+      updateMainHeightWidth
+    } = parameters;
+    if (data.rtpCapabilities == null) {
+      const reason = data.reason || "";
+      showAlert?.({
+        message: `Sorry, you are not allowed to join this room. ${reason}`,
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+    updateRtpCapabilities(data.rtpCapabilities);
+    updateAdminPasscode(data.secureCode);
+    updateRoomRecvIPs(data.roomRecvIPs);
+    updateMeetingRoomParams(data.meetingRoomParams);
+    updateRecordingAudioPausesLimit(data.recordingParams.recordingAudioPausesLimit);
+    updateRecordingAudioPausesCount(data.recordingParams.recordingAudioPausesCount);
+    updateRecordingAudioSupport(data.recordingParams.recordingAudioSupport);
+    updateRecordingAudioPeopleLimit(data.recordingParams.recordingAudioPeopleLimit);
+    updateRecordingAudioParticipantsTimeLimit(data.recordingParams.recordingAudioParticipantsTimeLimit);
+    updateRecordingVideoPausesCount(data.recordingParams.recordingVideoPausesCount);
+    updateRecordingVideoPausesLimit(data.recordingParams.recordingVideoPausesLimit);
+    updateRecordingVideoSupport(data.recordingParams.recordingVideoSupport);
+    updateRecordingVideoPeopleLimit(data.recordingParams.recordingVideoPeopleLimit);
+    updateRecordingVideoParticipantsTimeLimit(data.recordingParams.recordingVideoParticipantsTimeLimit);
+    updateRecordingAllParticipantsSupport(data.recordingParams.recordingAllParticipantsSupport);
+    updateRecordingVideoParticipantsSupport(data.recordingParams.recordingVideoParticipantsSupport);
+    updateRecordingAllParticipantsFullRoomSupport(data.recordingParams.recordingAllParticipantsFullRoomSupport);
+    updateRecordingVideoParticipantsFullRoomSupport(data.recordingParams.recordingVideoParticipantsFullRoomSupport);
+    updateRecordingPreferredOrientation(data.recordingParams.recordingPreferredOrientation);
+    updateRecordingSupportForOtherOrientation(data.recordingParams.recordingSupportForOtherOrientation);
+    updateRecordingMultiFormatsSupport(data.recordingParams.recordingMultiFormatsSupport);
+    updateItemPageLimit(data.meetingRoomParams.itemPageLimit);
+    updateEventType(data.meetingRoomParams.type);
+    if (data.meetingRoomParams.type == "chat" && islevel != "2") {
+      updateYouAreCoHost(true);
+    }
+    if (["chat", "broadcast"].includes(data.meetingRoomParams.type)) {
+      updateAutoWave(false);
+      updateMeetingDisplayType("all");
+      updateForceFullDisplay(true);
+      updateChatSetting("allow");
+      updateItemPageLimit(2);
+      if (["broadcast"].includes(data.meetingRoomParams.type)) {
+        updateRecordingVideoOptions("mainScreen");
+        updateRecordingAudioOptions("host");
+        updateItemPageLimit(1);
+      }
+    }
+    updateAudioSetting(data.meetingRoomParams.audioSetting);
+    updateVideoSetting(data.meetingRoomParams.videoSetting);
+    updateScreenshareSetting(data.meetingRoomParams.screenshareSetting);
+    updateChatSetting(data.meetingRoomParams.chatSetting);
+    updateAudioOnlyRoom(data.meetingRoomParams.mediaType != "video");
+    if (data.meetingRoomParams.type == "conference" && (shared || shareScreenStarted)) {
+      updateMainHeightWidth(100);
+    } else {
+      updateMainHeightWidth(0);
+    }
+    updateScreenPageLimit(Math.min(data.meetingRoomParams.itemPageLimit, screenPageLimit));
+    const targetOrientation = islevel == "2" ? data.meetingRoomParams.targetOrientationHost : data.meetingRoomParams.targetOrientation;
+    const targetResolution = islevel == "2" ? data.meetingRoomParams.targetResolutionHost : data.meetingRoomParams.targetResolution;
+    let vidCons;
+    if (targetOrientation == "landscape") {
+      vidCons = targetResolution == "hd" ? hdCons : targetResolution == "fhd" ? fhdCons : targetResolution == "qhd" ? qhdCons : targetResolution == "sd" ? sdCons : QnHDCons;
+    } else if (targetOrientation == "neutral") {
+      vidCons = targetResolution == "hd" ? hdConsNeu : targetResolution == "fhd" ? fhdConsNeu : targetResolution == "qhd" ? qhdConsNeu : targetResolution == "sd" ? sdConsNeu : QnHDConsNeu;
+    } else {
+      vidCons = targetResolution == "hd" ? hdConsPort : targetResolution == "fhd" ? fhdConsPort : targetResolution == "qhd" ? qhdConsPort : targetResolution == "sd" ? sdConsPort : QnHDConsPort;
+    }
+    let frameRateValue = frameRate || 10;
+    let vParamsValue = { ...vParams$1 };
+    let hParamsValue = { ...hParams$1 };
+    if (Object.keys(vParamsValue).length == 0) {
+      vParamsValue = { ...vParams };
+    }
+    if (Object.keys(hParamsValue).length == 0) {
+      hParamsValue = { ...hParams };
+    }
+    if (targetResolution == "hd") {
+      frameRateValue = hdFrameRate;
+      vParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 4);
+        }
+      });
+      hParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 4);
+        }
+      });
+    } else if (targetResolution == "QnHD") {
+      frameRateValue = QnHDFrameRate;
+      vParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 0.25);
+        }
+      });
+      hParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 0.25);
+        }
+      });
+      if (hParamsValue.codecOptions && hParamsValue.codecOptions.videoGoogleStartBitrate) {
+        hParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(hParamsValue.codecOptions.videoGoogleStartBitrate * 0.25);
+      }
+      if (vParamsValue.codecOptions && vParamsValue.codecOptions.videoGoogleStartBitrate) {
+        vParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(vParamsValue.codecOptions.videoGoogleStartBitrate * 0.25);
+      }
+    } else if (targetResolution == "fhd") {
+      frameRateValue = fhdFrameRate;
+      vParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 8);
+        }
+      });
+      hParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 8);
+        }
+      });
+    } else if (targetResolution == "qhd") {
+      frameRateValue = qhdFrameRate;
+      vParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 16);
+        }
+      });
+      hParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 16);
+        }
+      });
+    }
+    if (data.recordingParams.recordingVideoSupport) {
+      vParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 1.2);
+        }
+      });
+      hParamsValue.encodings.forEach((encoding) => {
+        if (encoding.maxBitrate) {
+          encoding.maxBitrate = Math.floor(encoding.maxBitrate * 1.2);
+        }
+      });
+      if (hParamsValue.codecOptions && hParamsValue.codecOptions.videoGoogleStartBitrate) {
+        hParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(hParamsValue.codecOptions.videoGoogleStartBitrate * 1.2);
+      }
+      if (vParamsValue.codecOptions && vParamsValue.codecOptions.videoGoogleStartBitrate) {
+        vParamsValue.codecOptions.videoGoogleStartBitrate = Math.floor(vParamsValue.codecOptions.videoGoogleStartBitrate * 1.2);
+      }
+    }
+    updateVidCons(vidCons);
+    updateFrameRate(frameRateValue);
+    updateHParams(hParamsValue);
+    updateVParams(vParamsValue);
+    updateScreenParams(screenParams);
+    updateAParams(aParams);
+    updateTargetResolution(data.meetingRoomParams.targetResolution);
+    updateTargetResolutionHost(data.meetingRoomParams.targetResolutionHost);
+  } catch (error) {
+    console.log("updateRoomParametersClient error", error);
+    parameters.showAlert?.({
+      message: error.message,
+      type: "danger",
+      duration: 3e3
+    });
+  }
+};
+async function checkMediasfuURL({
+  data,
+  member,
+  roomName,
+  islevel,
+  socket,
+  parameters,
+  joinMediaSFURoom = joinRoomOnMediaSFU,
+  localLink = ""
+}) {
+  if (data.mediasfuURL && data.mediasfuURL !== "" && data.mediasfuURL.length > 10) {
+    let link;
+    let secretCode;
+    try {
+      const splitTexts = ["/meet/", "/chat/", "/broadcast/"];
+      const splitText = splitTexts.find((text) => data.mediasfuURL.includes(text)) || "/meet/";
+      const urlParts = data.mediasfuURL.split(splitText);
+      link = urlParts[0];
+      secretCode = urlParts[1].split("/")[1];
+    } catch {
+      link = data.mediasfuURL;
+      return;
+    }
+    await checkLimitsAndMakeRequest({
+      apiUserName: roomName,
+      apiToken: secretCode,
+      link,
+      apiKey: "",
+      userName: member,
+      parameters,
+      validate: false
+    });
+    return;
+  }
+  if ((!data.mediasfuURL || data.mediasfuURL.length < 10) && islevel !== "2" && data.allowRecord && (data.allowRecord === true || data.allowRecord === "true") && data.apiKey && data.apiKey.length === 64 && data.apiUserName && data.apiUserName.length > 5 && (roomName.startsWith("s") || roomName.startsWith("p"))) {
+    const payload = {
+      action: "join",
+      meetingID: roomName,
+      userName: member
+    };
+    const response = await joinMediaSFURoom({
+      payload,
+      apiKey: data.apiKey,
+      apiUserName: data.apiUserName,
+      localLink
+    });
+    if (response.success && response.data && "roomName" in response.data) {
+      try {
+        socket.emit(
+          "updateMediasfuURL",
+          { eventID: roomName, mediasfuURL: response.data.publicURL },
+          async () => {
+          }
+        );
+      } catch {
+      }
+      await checkLimitsAndMakeRequest({
+        apiUserName: response.data.roomName,
+        apiToken: response.data.secret,
+        link: response.data.link,
+        userName: member,
+        parameters,
+        validate: false
+      });
+      parameters.updateApiToken(response.data.secret);
+    }
+  }
+}
+async function joinLocalRoom({
+  socket,
+  roomName,
+  islevel,
+  member,
+  sec,
+  apiUserName,
+  parameters,
+  checkConnect = false,
+  joinMediaSFURoom = joinRoomOnMediaSFU,
+  localLink = ""
+}) {
+  return new Promise((resolve, reject) => {
+    if (!(sec && roomName && islevel && apiUserName && member)) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Missing required parameters"
+      };
+      reject(validationError);
+      return;
+    }
+    try {
+      validateAlphanumeric({ str: roomName });
+      validateAlphanumeric({ str: apiUserName });
+      validateAlphanumeric({ str: member });
+    } catch {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName or apiUserName or member"
+      };
+      reject(validationError);
+      return;
+    }
+    if (!(roomName.startsWith("s") || roomName.startsWith("p") || roomName.startsWith("m") || roomName.startsWith("d"))) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName, must start with s or p or m or d"
+      };
+      reject(validationError);
+      return;
+    }
+    if (!(sec.length === 32 && roomName.length >= 8 && islevel.length === 1 && apiUserName.length >= 6 && (islevel === "0" || islevel === "1" || islevel === "2"))) {
+      const validationError = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName or islevel or apiUserName or secret"
+      };
+      reject(validationError);
+      return;
+    }
+    socket.emit(
+      "joinRoom",
+      { roomName, islevel, member, sec, apiUserName },
+      async (data) => {
+        try {
+          if (data.rtpCapabilities === null) {
+            if (data.isBanned) {
+              throw new Error("User is banned.");
+            }
+            if (data.hostNotJoined) {
+              throw new Error("Host has not joined the room yet.");
+            }
+            resolve(data);
+          } else {
+            if (checkConnect) {
+              await checkMediasfuURL({
+                data,
+                member,
+                roomName,
+                islevel,
+                socket,
+                parameters,
+                joinMediaSFURoom,
+                localLink
+              });
+            } else if (data.mediasfuURL && data.mediasfuURL !== "" && data.mediasfuURL.length > 10) {
+              const splitTexts = ["/meet/", "/chat/", "/broadcast/"];
+              const splitText = splitTexts.find((text) => data.mediasfuURL.includes(text)) || "/meet/";
+              const urlParts = data.mediasfuURL.split(splitText);
+              const secretCode = urlParts[1].split("/")[1];
+              parameters.updateApiToken(secretCode);
+            }
+            resolve(data);
+          }
+        } catch (error) {
+          console.log("Error joining room:", error);
+          reject(error);
+        }
+      }
+    );
+  });
+}
+export {
+  addVideosGrid as a,
+  breakoutRoomUpdated as b,
+  createDeviceClient as c,
+  checkMediasfuURL as d,
+  joinLocalRoom as e,
+  joinRoom as f,
+  joinRoomClient as j,
+  modifySettings as m,
+  prepopulateUserMedia as p,
+  updateRoomParametersClient as u
+};
+//# sourceMappingURL=joinLocalRoom-CvteNe4R.js.map