@100mslive/roomkit-react 0.1.4-alpha.1 → 0.1.5

package/dist/{chunk-ESUJK7AT.js → conference-P6I6ESVF.js}

@@ -1,36 +1,93 @@
 import {
-  Avatar,
+  ActionTile
+} from "./chunk-P5X32KOD.js";
+import {
+  ChangeNameModal,
+  Pagination,
+  ScreenshareTile_default,
+  VideoList_default,
+  VideoTile_default
+} from "./chunk-IVTWKQI3.js";
+import {
+  AudioVideoToggle,
+  Button,
+  Checkbox,
+  Dialog,
+  DialogCol,
+  DialogContent,
+  DialogDropdownTrigger,
+  DialogInputFile,
+  DialogRow,
+  DialogSelect,
+  Dropdown,
+  EmojiCard,
+  EmojiReaction,
+  FeatureFlags,
+  Footer,
+  FullPageProgress_default,
+  Header,
+  HorizontalDivider,
+  Input,
+  Label,
+  LeaveRoom,
+  ParticipantCount,
+  PictureInPicture,
+  RadioGroup,
+  RequestDialog,
+  ResolutionInput,
+  RoleChangeModal,
+  SettingsModal_default,
+  Sheet,
+  SidePane_default,
   Slider,
-  StyledMenuTile,
-  StyledPagination,
-  StyledVideoList,
-  StyledVideoTile,
-  TileConnection_default,
+  StopRecordingInSheet,
+  Switch,
+  ThemeTypes,
   ToastManager,
   Video,
   VideoTileStats,
-  useActiveSpeakerSorting,
-  useBorderAudioLevel,
+  getFormattedCount,
+  getResolution,
+  isScreenshareSupported,
+  useAuthToken,
   useDropdownList,
   useDropdownSelection,
+  useFilteredRoles,
+  useHLSViewerRole,
+  useHMSPrebuiltContext,
   useIsHeadless,
+  useIsSidepaneTypeOpen,
+  useMyMetadata,
+  useNavigation,
+  usePDFAnnotator,
+  usePinnedTrack,
+  useRoomLayout,
   useSetAppDataByKey,
+  useSetUiSettings,
+  useShowStreamingUI,
+  useSidepaneToggle,
+  useSkipPreview,
   useTheme,
-  useUISettings
-} from "./chunk-42SWPN2C.js";
-import {
-  useIsFeatureEnabled
-} from "./chunk-4ZBEFSRC.js";
-import {
-  Box,
-  Flex,
-  Text
-} from "./chunk-R6PDR5WZ.js";
+  useUISettings,
+  useUrlToEmbed,
+  useWaitingViewerRole,
+  useWhiteboardMetadata
+} from "./chunk-OSM4QEQG.js";
 import {
   APP_DATA,
+  Box,
+  DEFAULT_HLS_VIEWER_ROLE,
+  EMOJI_REACTION_TYPE,
   FEATURE_LIST,
-  REMOTE_STOP_SCREENSHARE_TYPE,
+  Flex,
+  IconButton,
+  IconButton_default,
+  Loading,
+  RTMP_RECORD_DEFAULT_RESOLUTION,
   SESSION_STORE_KEY,
+  SIDE_PANE_OPTIONS,
+  Text,
+  Tooltip,
   UI_SETTINGS,
   __async,
   __commonJS,
@@ -41,8 +98,14 @@ import {
   config,
   define_process_env_default,
   init_define_process_env,
-  styled
-} from "./chunk-4NEZLVVH.js";
+  isAndroid,
+  isChrome,
+  isIOS,
+  isIPadOS,
+  isMacOS,
+  styled,
+  useIsFeatureEnabled
+} from "./chunk-RVCZPPTL.js";
 
 // ../../node_modules/ua-parser-js/src/ua-parser.js
 var require_ua_parser = __commonJS({
@@ -2612,519 +2675,1965 @@ var require_lib = __commonJS({
   }
 });
 
-// src/Prebuilt/components/VideoTile.jsx
+// src/Prebuilt/components/conference.jsx
+init_define_process_env();
+import React35, { useEffect as useEffect9, useRef as useRef8, useState as useState15 } from "react";
+import { useParams } from "react-router-dom";
+import { usePrevious } from "react-use";
+import {
+  HMSRoomState,
+  selectAppData as selectAppData2,
+  selectIsConnectedToRoom as selectIsConnectedToRoom3,
+  selectRoomState,
+  useHMSActions as useHMSActions14,
+  useHMSStore as useHMSStore20
+} from "@100mslive/react-sdk";
+
+// src/Prebuilt/components/Footer/Footer.jsx
 init_define_process_env();
-import React2, { Fragment as Fragment2, useCallback, useMemo, useState as useState2 } from "react";
+import React22 from "react";
+import { useMedia as useMedia2 } from "react-use";
+import { selectLocalPeerRoleName as selectLocalPeerRoleName3, useHMSStore as useHMSStore9 } from "@100mslive/react-sdk";
+
+// src/Prebuilt/components/MoreSettings/MoreSettings.jsx
+init_define_process_env();
+import React11 from "react";
+import { useMedia } from "react-use";
+
+// src/Prebuilt/components/MoreSettings/SplitComponents/DesktopOptions.jsx
+init_define_process_env();
+import React9, { Fragment, useState as useState7 } from "react";
+import { HMSHLSPlayer } from "@100mslive/hls-player";
 import {
-  selectAudioTrackByPeerID,
-  selectIsPeerAudioEnabled,
+  selectAppData,
   selectLocalPeerID as selectLocalPeerID2,
-  selectPeerMetadata,
-  selectPeerNameByID,
-  selectVideoTrackByID,
-  selectVideoTrackByPeerID as selectVideoTrackByPeerID2,
-  useHMSStore as useHMSStore3
+  selectLocalPeerRoleName as selectLocalPeerRoleName2,
+  useHMSActions as useHMSActions5,
+  useHMSStore as useHMSStore4
 } from "@100mslive/react-sdk";
-import { BrbIcon, HandRaiseFilledIcon, MicOffIcon as MicOffIcon2 } from "@100mslive/react-icons";
+import { BrbIcon, CheckIcon as CheckIcon2, DragHandleIcon, HandIcon, InfoIcon, PipIcon as PipIcon2, SettingsIcon } from "@100mslive/react-icons";
 
-// src/Prebuilt/components/peerTileUtils.jsx
+// src/Prebuilt/components/PIP/index.jsx
 init_define_process_env();
-var PEER_NAME_PLACEHOLDER = "peerName";
-var labelMap = /* @__PURE__ */ new Map([
-  [[true, "screen"].toString(), "Your Screen"],
-  [[true, "regular"].toString(), `You (${PEER_NAME_PLACEHOLDER})`],
-  [[false, "screen"].toString(), `${PEER_NAME_PLACEHOLDER}'s Screen`],
-  [[false, "regular"].toString(), PEER_NAME_PLACEHOLDER],
-  [[true, void 0].toString(), `You (${PEER_NAME_PLACEHOLDER})`],
-  [[false, void 0].toString(), `${PEER_NAME_PLACEHOLDER}`]
-]);
-var getVideoTileLabel = ({ peerName, isLocal, track }) => {
-  const isPeerPresent = peerName !== void 0;
-  if (!isPeerPresent || !track) {
-    return isPeerPresent ? labelMap.get([isLocal, void 0].toString()).replace(PEER_NAME_PLACEHOLDER, peerName) : "";
-  }
-  const isLocallyMuted = track.volume === 0;
-  let label = labelMap.get([isLocal, track.source].toString());
-  if (label) {
-    label = label.replace(PEER_NAME_PLACEHOLDER, peerName);
-  } else {
-    label = `${peerName} ${track.source}`;
-  }
-  label = `${label}${track.degraded ? "(Degraded)" : ""}`;
-  return `${label}${isLocallyMuted ? " (Muted for you)" : ""}`;
-};
+import React2 from "react";
 
-// src/Prebuilt/components/TileMenu.jsx
+// src/Prebuilt/components/PIP/PIPComponent.jsx
 init_define_process_env();
-import React, { Fragment, useState } from "react";
+import React, { useCallback, useEffect, useState } from "react";
 import {
-  selectLocalPeerID,
-  selectPermissions,
-  selectSessionStore,
-  selectTemplateAppData,
-  selectTrackByID,
-  selectVideoTrackByPeerID,
-  useCustomEvent,
+  selectLocalPeerRoleName,
+  selectPeers,
+  selectTracksMap,
   useHMSActions,
   useHMSStore,
-  useRemoteAVToggle
+  useHMSVanillaStore
 } from "@100mslive/react-sdk";
-import {
-  HorizontalMenuIcon,
-  MicOffIcon,
-  MicOnIcon,
-  PinIcon,
-  RemoveUserIcon,
-  ShareScreenIcon,
-  SpeakerIcon,
-  StarIcon,
-  VideoOffIcon,
-  VideoOnIcon
-} from "@100mslive/react-icons";
-var isSameTile = ({ trackId, videoTrackID, audioTrackID }) => trackId && (videoTrackID && videoTrackID === trackId || audioTrackID && audioTrackID === trackId);
-var SpotlightActions = ({ peerId }) => {
-  const hmsActions = useHMSActions();
-  const spotlightPeerId = useHMSStore(selectSessionStore(SESSION_STORE_KEY.SPOTLIGHT));
-  const isTileSpotlighted = spotlightPeerId === peerId;
-  const setSpotlightPeerId = (peer) => hmsActions.sessionStore.set(SESSION_STORE_KEY.SPOTLIGHT, peer).catch((err) => ToastManager.addToast({ title: err.description }));
-  return /* @__PURE__ */ React.createElement(StyledMenuTile.ItemButton, { onClick: () => isTileSpotlighted ? setSpotlightPeerId() : setSpotlightPeerId(peerId) }, /* @__PURE__ */ React.createElement(StarIcon, null), /* @__PURE__ */ React.createElement("span", null, isTileSpotlighted ? "Remove from Spotlight" : "Spotlight Tile for everyone"));
-};
-var PinActions = ({ audioTrackID, videoTrackID }) => {
-  const [pinnedTrackId, setPinnedTrackId] = useSetAppDataByKey(APP_DATA.pinnedTrackId);
-  const isTilePinned = isSameTile({
-    trackId: pinnedTrackId,
-    videoTrackID,
-    audioTrackID
-  });
-  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
-    StyledMenuTile.ItemButton,
-    {
-      onClick: () => isTilePinned ? setPinnedTrackId() : setPinnedTrackId(videoTrackID || audioTrackID)
-    },
-    /* @__PURE__ */ React.createElement(PinIcon, null),
-    /* @__PURE__ */ React.createElement("span", null, isTilePinned ? "Unpin" : "Pin", " Tile for myself")
-  ));
-};
-var TileMenu = ({ audioTrackID, videoTrackID, peerID, isScreenshare = false }) => {
-  var _a, _b;
-  const [open, setOpen] = useState(false);
-  const actions = useHMSActions();
-  const localPeerID = useHMSStore(selectLocalPeerID);
-  const isLocal = localPeerID === peerID;
-  const { removeOthers, changeRole } = useHMSStore(selectPermissions);
-  const { isAudioEnabled, isVideoEnabled, setVolume, toggleAudio, toggleVideo, volume } = useRemoteAVToggle(
-    audioTrackID,
-    videoTrackID
-  );
-  const showSpotlight = changeRole;
-  const { sendEvent } = useCustomEvent({
-    type: REMOTE_STOP_SCREENSHARE_TYPE
-  });
-  const isPrimaryVideoTrack = ((_a = useHMSStore(selectVideoTrackByPeerID(peerID))) == null ? void 0 : _a.id) === videoTrackID;
-  const uiMode = useHMSStore(selectTemplateAppData).uiMode;
-  const isInset = uiMode === "inset";
-  const isPinEnabled = useIsFeatureEnabled(FEATURE_LIST.PIN_TILE);
-  const showPinAction = isPinEnabled && (audioTrackID || videoTrackID && isPrimaryVideoTrack) && !isInset;
-  const track = useHMSStore(selectTrackByID(videoTrackID));
-  const hideSimulcastLayers = !((_b = track == null ? void 0 : track.layerDefinitions) == null ? void 0 : _b.length) || track.degraded || !track.enabled;
-  useDropdownList({ open, name: "TileMenu" });
-  if (!(removeOthers || toggleAudio || toggleVideo || setVolume || showPinAction) && hideSimulcastLayers) {
-    return null;
+import { PipIcon } from "@100mslive/react-icons";
+
+// src/Prebuilt/components/PIP/SetupMediaSession.js
+init_define_process_env();
+import { selectIsLocalAudioEnabled, selectIsLocalVideoEnabled } from "@100mslive/react-sdk";
+var SetupMediaSession = class {
+  constructor() {
+    __publicField(this, "setup", (actions, store) => {
+      this.actions = actions;
+      this.store = store;
+      this.initState();
+      this.setUpHandlers();
+    });
+    __publicField(this, "initState", () => {
+      var _a, _b, _c, _d;
+      const isMicActive = this.store.getState(selectIsLocalAudioEnabled);
+      const isCamActive = this.store.getState(selectIsLocalVideoEnabled);
+      (_b = (_a = navigator.mediaSession) == null ? void 0 : _a.setMicrophoneActive) == null ? void 0 : _b.call(_a, isMicActive);
+      (_d = (_c = navigator.mediaSession) == null ? void 0 : _c.setCameraActive) == null ? void 0 : _d.call(_c, isCamActive);
+      this.store.subscribe((isMicActive2) => {
+        var _a2, _b2;
+        (_b2 = (_a2 = navigator.mediaSession) == null ? void 0 : _a2.setMicrophoneActive) == null ? void 0 : _b2.call(_a2, isMicActive2);
+      }, selectIsLocalAudioEnabled);
+      this.store.subscribe((isCamActive2) => {
+        var _a2, _b2;
+        (_b2 = (_a2 = navigator.mediaSession) == null ? void 0 : _a2.setCameraActive) == null ? void 0 : _b2.call(_a2, isCamActive2);
+      }, selectIsLocalVideoEnabled);
+    });
+    __publicField(this, "toggleMic", () => __async(this, null, function* () {
+      console.log("toggle mic clicked in pip");
+      const current = this.store.getState(selectIsLocalAudioEnabled);
+      yield this.actions.setLocalAudioEnabled(!current);
+    }));
+    __publicField(this, "toggleCam", () => __async(this, null, function* () {
+      console.log("toggle cam clicked in pip");
+      const current = this.store.getState(selectIsLocalVideoEnabled);
+      yield this.actions.setLocalVideoEnabled(!current);
+    }));
+    __publicField(this, "leave", () => {
+      console.log("leave called from pip");
+      this.actions.leave();
+    });
+    __publicField(this, "setUpHandlers", () => {
+      if (navigator.mediaSession) {
+        try {
+          navigator.mediaSession.setActionHandler("togglemicrophone", this.toggleMic);
+          navigator.mediaSession.setActionHandler("togglecamera", this.toggleCam);
+          navigator.mediaSession.setActionHandler("hangup", this.leave);
+        } catch (err) {
+          console.error("error in setting media session handlers", err);
+        }
+      }
+    });
   }
-  if (isInset && isLocal) {
+};
+var MediaSession = new SetupMediaSession();
+
+// src/Prebuilt/components/PIP/PIPComponent.jsx
+var PIPComponent = ({ content = null }) => {
+  const localPeerRole = useHMSStore(selectLocalPeerRoleName);
+  const [isPipOn, setIsPipOn] = useState(PictureInPicture.isOn());
+  const hmsActions = useHMSActions();
+  const store = useHMSVanillaStore();
+  const isFeatureEnabled = useIsFeatureEnabled(FEATURE_LIST.PICTURE_IN_PICTURE);
+  const onPipToggle = useCallback(() => {
+    if (!isPipOn) {
+      PictureInPicture.start(hmsActions, setIsPipOn).catch((err) => console.error("error in starting pip", err));
+      MediaSession.setup(hmsActions, store);
+    } else {
+      PictureInPicture.stop().catch((err) => console.error("error in stopping pip", err));
+    }
+  }, [hmsActions, isPipOn, store]);
+  if (!PictureInPicture.isSupported() || localPeerRole === DEFAULT_HLS_VIEWER_ROLE || !isFeatureEnabled) {
     return null;
   }
-  return /* @__PURE__ */ React.createElement(StyledMenuTile.Root, { open, onOpenChange: setOpen }, /* @__PURE__ */ React.createElement(StyledMenuTile.Trigger, { "data-testid": "participant_menu_btn", onClick: (e) => e.stopPropagation() }, /* @__PURE__ */ React.createElement(HorizontalMenuIcon, null)), /* @__PURE__ */ React.createElement(StyledMenuTile.Content, { side: "top", align: "end" }, isLocal ? showPinAction && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(PinActions, { audioTrackID, videoTrackID }), showSpotlight && /* @__PURE__ */ React.createElement(SpotlightActions, { peerId: peerID })) : /* @__PURE__ */ React.createElement(React.Fragment, null, toggleVideo ? /* @__PURE__ */ React.createElement(
-    StyledMenuTile.ItemButton,
-    {
-      onClick: toggleVideo,
-      "data-testid": isVideoEnabled ? "mute_video_participant_btn" : "unmute_video_participant_btn"
-    },
-    isVideoEnabled ? /* @__PURE__ */ React.createElement(VideoOnIcon, null) : /* @__PURE__ */ React.createElement(VideoOffIcon, null),
-    /* @__PURE__ */ React.createElement("span", null, isVideoEnabled ? "Mute" : "Request Unmute")
-  ) : null, toggleAudio ? /* @__PURE__ */ React.createElement(
-    StyledMenuTile.ItemButton,
-    {
-      onClick: toggleAudio,
-      "data-testid": isVideoEnabled ? "mute_audio_participant_btn" : "unmute_audio_participant_btn"
-    },
-    isAudioEnabled ? /* @__PURE__ */ React.createElement(MicOnIcon, null) : /* @__PURE__ */ React.createElement(MicOffIcon, null),
-    /* @__PURE__ */ React.createElement("span", null, isAudioEnabled ? "Mute" : "Request Unmute")
-  ) : null, audioTrackID ? /* @__PURE__ */ React.createElement(StyledMenuTile.VolumeItem, { "data-testid": "participant_volume_slider" }, /* @__PURE__ */ React.createElement(Flex, { align: "center", gap: 1 }, /* @__PURE__ */ React.createElement(SpeakerIcon, null), /* @__PURE__ */ React.createElement(Box, { as: "span", css: { ml: "$4" } }, "Volume (", volume, ")")), /* @__PURE__ */ React.createElement(Slider, { css: { my: "0.5rem" }, step: 5, value: [volume], onValueChange: (e) => setVolume(e[0]) })) : null, showPinAction && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(PinActions, { audioTrackID, videoTrackID }), showSpotlight && /* @__PURE__ */ React.createElement(SpotlightActions, { peerId: peerID })), /* @__PURE__ */ React.createElement(SimulcastLayers, { trackId: videoTrackID }), removeOthers ? /* @__PURE__ */ React.createElement(
-    StyledMenuTile.RemoveItem,
-    {
-      onClick: () => __async(void 0, null, function* () {
-        try {
-          yield actions.removePeer(peerID, "");
-        } catch (error) {
-        }
-      }),
-      "data-testid": "remove_participant_btn"
-    },
-    /* @__PURE__ */ React.createElement(RemoveUserIcon, null),
-    /* @__PURE__ */ React.createElement("span", null, "Remove Participant")
-  ) : null, removeOthers && isScreenshare ? /* @__PURE__ */ React.createElement(StyledMenuTile.RemoveItem, { onClick: () => sendEvent({}) }, /* @__PURE__ */ React.createElement(ShareScreenIcon, null), /* @__PURE__ */ React.createElement("span", null, "Stop Screenshare")) : null)));
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, content ? /* @__PURE__ */ React.createElement(Flex, { css: { w: "100%" }, onClick: () => onPipToggle(), "data-testid": "pip_btn" }, content) : /* @__PURE__ */ React.createElement(Tooltip, { title: `${isPipOn ? "Deactivate" : "Activate"} picture in picture view` }, /* @__PURE__ */ React.createElement(IconButton_default, { active: !isPipOn, key: "pip", onClick: () => onPipToggle(), "data-testid": "pip_btn" }, /* @__PURE__ */ React.createElement(PipIcon, null))));
 };
-var SimulcastLayers = ({ trackId }) => {
-  var _a;
-  const track = useHMSStore(selectTrackByID(trackId));
-  const actions = useHMSActions();
-  const bg = useDropdownSelection();
-  if (!((_a = track == null ? void 0 : track.layerDefinitions) == null ? void 0 : _a.length) || track.degraded || !track.enabled) {
+var ActivatedPIP = () => {
+  const tracksMap = useHMSStore(selectTracksMap);
+  const storePeers = useHMSStore(selectPeers);
+  const pinnedTrack = usePinnedTrack();
+  useEffect(() => {
+    PictureInPicture.listenToStateChange((isPipOn) => {
+      if (!isPipOn) {
+        return;
+      }
+      let pipPeers = storePeers;
+      if (pinnedTrack) {
+        pipPeers = storePeers.filter((peer) => pinnedTrack.peerId === peer.id);
+      }
+      PictureInPicture.updatePeersAndTracks(pipPeers, tracksMap).catch((err) => {
+        console.error("error in updating pip", err);
+      });
+    });
+  }, [storePeers, tracksMap, pinnedTrack]);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null);
+};
+var PIPComponent_default = PIPComponent;
+
+// src/Prebuilt/components/PIP/index.jsx
+var PIP = ({ content = null }) => {
+  return /* @__PURE__ */ React2.createElement(PIPComponent_default, { content });
+};
+
+// src/Prebuilt/components/Settings/StartRecording.jsx
+init_define_process_env();
+import React3, { useState as useState2 } from "react";
+import { selectPermissions, useHMSActions as useHMSActions2, useHMSStore as useHMSStore2, useRecordingStreaming } from "@100mslive/react-sdk";
+import { AlertTriangleIcon } from "@100mslive/react-icons";
+var StartRecording = ({ open, onOpenChange }) => {
+  const permissions = useHMSStore2(selectPermissions);
+  const [resolution, setResolution] = useState2(RTMP_RECORD_DEFAULT_RESOLUTION);
+  const [recordingStarted, setRecordingState] = useSetAppDataByKey(APP_DATA.recordingStarted);
+  const { isBrowserRecordingOn, isStreamingOn, isHLSRunning } = useRecordingStreaming();
+  const hmsActions = useHMSActions2();
+  if (!(permissions == null ? void 0 : permissions.browserRecording) || isHLSRunning) {
     return null;
   }
-  const currentLayer = track.layerDefinitions.find((layer) => layer.layer === track.layer);
-  return /* @__PURE__ */ React.createElement(Fragment, null, /* @__PURE__ */ React.createElement(StyledMenuTile.ItemButton, { css: { color: "$on_surface_medium", cursor: "default" } }, "Select maximum resolution"), track.layerDefinitions.map((layer) => {
-    return /* @__PURE__ */ React.createElement(
-      StyledMenuTile.ItemButton,
+  if (isBrowserRecordingOn) {
+    return /* @__PURE__ */ React3.createElement(Dialog.Root, { open, onOpenChange }, /* @__PURE__ */ React3.createElement(Dialog.Portal, null, /* @__PURE__ */ React3.createElement(
+      Dialog.Content,
       {
-        key: layer.layer,
-        onClick: () => __async(void 0, null, function* () {
-          yield actions.setPreferredLayer(trackId, layer.layer);
-        }),
         css: {
-          justifyContent: "space-between",
-          bg: track.preferredLayer === layer.layer ? bg : void 0,
-          "&:hover": {
-            bg: track.preferredLayer === layer.layer ? bg : void 0
-          }
+          width: "min(400px,80%)",
+          p: "$10",
+          bg: "#201617"
         }
       },
-      /* @__PURE__ */ React.createElement(
-        Text,
+      /* @__PURE__ */ React3.createElement(Dialog.Title, null, /* @__PURE__ */ React3.createElement(Flex, { gap: 2, css: { c: "$alert_error_default" } }, /* @__PURE__ */ React3.createElement(AlertTriangleIcon, null), /* @__PURE__ */ React3.createElement(Text, { css: { c: "inherit" }, variant: "h6" }, "End Recording"))),
+      /* @__PURE__ */ React3.createElement(Text, { variant: "sm", css: { c: "$on_surface_medium", my: "$8" } }, "Are you sure you want to end recording? You can\u2019t undo this action."),
+      /* @__PURE__ */ React3.createElement(Flex, { justify: "end", css: { mt: "$12" } }, /* @__PURE__ */ React3.createElement(Dialog.Close, { asChild: true }, /* @__PURE__ */ React3.createElement(Button, { outlined: true, css: { borderColor: "$secondary_bright", mr: "$4" } }, "Don't end")), /* @__PURE__ */ React3.createElement(
+        Button,
         {
-          as: "span",
-          css: {
-            textTransform: "capitalize",
-            mr: "$2",
-            fontWeight: track.preferredLayer === layer.layer ? "$semiBold" : "$regular"
-          }
+          "data-testid": "stop_recording_confirm_mobile",
+          variant: "danger",
+          icon: true,
+          onClick: () => __async(void 0, null, function* () {
+            try {
+              yield hmsActions.stopRTMPAndRecording();
+            } catch (error) {
+              ToastManager.addToast({
+                title: error.message,
+                variant: "error"
+              });
+            }
+            onOpenChange(false);
+          })
         },
-        layer.layer
-      ),
-      /* @__PURE__ */ React.createElement(Text, { as: "span", variant: "xs", css: { color: "$on_surface_medium" } }, layer.resolution.width, "x", layer.resolution.height)
-    );
-  }), /* @__PURE__ */ React.createElement(StyledMenuTile.ItemButton, null, /* @__PURE__ */ React.createElement(Text, { as: "span", variant: "xs", css: { color: "$on_surface_medium" } }, "Currently streaming:", /* @__PURE__ */ React.createElement(
-    Text,
+        "End recording"
+      ))
+    )));
+  }
+  return /* @__PURE__ */ React3.createElement(Dialog.Root, { open, onOpenChange }, /* @__PURE__ */ React3.createElement(Dialog.Content, { css: { width: "min(400px,80%)", p: "$10" } }, /* @__PURE__ */ React3.createElement(Dialog.Title, null, /* @__PURE__ */ React3.createElement(Text, { variant: "h6" }, "Start Recording")), /* @__PURE__ */ React3.createElement(
+    ResolutionInput,
     {
-      as: "span",
-      variant: "xs",
-      css: {
-        fontWeight: "$semiBold",
-        textTransform: "capitalize",
-        color: "$on_surface_medium",
-        ml: "$2"
-      }
+      testId: "recording_resolution_mobile",
+      css: { flexDirection: "column", alignItems: "start" },
+      onResolutionChange: setResolution
+    }
+  ), /* @__PURE__ */ React3.createElement(
+    Button,
+    {
+      "data-testid": "start_recording_confirm_mobile",
+      variant: "primary",
+      icon: true,
+      css: { ml: "auto" },
+      type: "submit",
+      disabled: recordingStarted || isStreamingOn,
+      onClick: () => __async(void 0, null, function* () {
+        try {
+          setRecordingState(true);
+          yield hmsActions.startRTMPOrRecording({
+            resolution: getResolution(resolution),
+            record: true
+          });
+        } catch (error) {
+          if (error.message.includes("stream already running")) {
+            ToastManager.addToast({
+              title: "Recording already running",
+              variant: "error"
+            });
+          } else {
+            ToastManager.addToast({
+              title: error.message,
+              variant: "error"
+            });
+          }
+          setRecordingState(false);
+        }
+        onOpenChange(false);
+      })
     },
-    currentLayer ? /* @__PURE__ */ React.createElement(React.Fragment, null, track.layer, " (", currentLayer.resolution.width, "x", currentLayer.resolution.height, ")") : "-"
-  ))));
+    "Start"
+  )));
 };
-var TileMenu_default = TileMenu;
+var StartRecording_default = StartRecording;
 
-// src/Prebuilt/components/AppData/useAppConfig.js
+// src/Prebuilt/components/StatsForNerds.jsx
 init_define_process_env();
-import { selectAppDataByPath, useHMSStore as useHMSStore2 } from "@100mslive/react-sdk";
-var useAppConfig = (...path) => {
-  const appConfig = useHMSStore2(selectAppDataByPath(APP_DATA.appConfig, ...path));
-  return appConfig;
-};
-
-// src/Prebuilt/components/VideoTile.jsx
-var Tile = ({ peerId, trackId, width, height, objectFit = "cover", rootCSS = {}, containerCSS = {} }) => {
-  const trackSelector = trackId ? selectVideoTrackByID(trackId) : selectVideoTrackByPeerID2(peerId);
-  const track = useHMSStore3(trackSelector);
-  const peerName = useHMSStore3(selectPeerNameByID(peerId));
-  const audioTrack = useHMSStore3(selectAudioTrackByPeerID(peerId));
-  const localPeerID = useHMSStore3(selectLocalPeerID2);
-  const isAudioOnly = useUISettings(UI_SETTINGS.isAudioOnly);
-  const mirrorLocalVideo = useUISettings(UI_SETTINGS.mirrorLocalVideo);
-  const showStatsOnTiles = useUISettings(UI_SETTINGS.showStatsOnTiles);
-  const isHeadless = useIsHeadless();
-  const isAudioMuted = !useHMSStore3(selectIsPeerAudioEnabled(peerId));
-  const isVideoMuted = !(track == null ? void 0 : track.enabled);
-  const [isMouseHovered, setIsMouseHovered] = useState2(false);
-  const borderAudioRef = useBorderAudioLevel(audioTrack == null ? void 0 : audioTrack.id);
-  const isVideoDegraded = track == null ? void 0 : track.degraded;
-  const isLocal = localPeerID === peerId;
-  const label = getVideoTileLabel({
-    peerName,
-    track,
-    isLocal
-  });
-  const onHoverHandler = useCallback((event) => {
-    setIsMouseHovered(event.type === "mouseenter");
-  }, []);
-  const headlessConfig = useAppConfig("headlessConfig");
-  const hideLabel = isHeadless && (headlessConfig == null ? void 0 : headlessConfig.hideTileName);
-  const isTileBigEnoughToShowStats = height >= 180 && width >= 180;
-  const avatarSize = useMemo(() => {
-    if (!width || !height) {
-      return void 0;
-    }
-    if (width <= 150 || height <= 150) {
-      return "small";
-    } else if (width <= 300 || height <= 300) {
-      return "medium";
-    }
-    return "large";
-  }, [width, height]);
-  return /* @__PURE__ */ React2.createElement(
-    StyledVideoTile.Root,
+import React4, { useEffect as useEffect2, useMemo, useRef, useState as useState3 } from "react";
+import {
+  selectHMSStats,
+  selectLocalPeerID,
+  selectPeersMap,
+  selectTracksMap as selectTracksMap2,
+  useHMSStatsStore,
+  useHMSStore as useHMSStore3
+} from "@100mslive/react-sdk";
+var StatsForNerds = ({ onOpenChange }) => {
+  var _a;
+  const tracksWithLabels = useTracksWithLabel();
+  const statsOptions = useMemo(
+    () => [{ id: "local-peer", label: "Local Peer Stats" }, ...tracksWithLabels],
+    [tracksWithLabels]
+  );
+  const [selectedStat, setSelectedStat] = useState3(statsOptions[0]);
+  const [showStatsOnTiles, setShowStatsOnTiles] = useSetUiSettings(UI_SETTINGS.showStatsOnTiles);
+  const [open, setOpen] = useState3(false);
+  const ref = useRef();
+  const selectionBg = useDropdownSelection();
+  useEffect2(() => {
+    if (selectedStat.id !== "local-peer" && !tracksWithLabels.find((track) => track.id === selectedStat.id)) {
+      setSelectedStat("local-peer");
+    }
+  }, [tracksWithLabels, selectedStat]);
+  return /* @__PURE__ */ React4.createElement(Dialog.Root, { defaultOpen: true, onOpenChange }, /* @__PURE__ */ React4.createElement(Dialog.Portal, null, /* @__PURE__ */ React4.createElement(Dialog.Overlay, null), /* @__PURE__ */ React4.createElement(
+    Dialog.Content,
     {
-      css: __spreadValues({
-        width,
-        height,
-        padding: getPadding({
-          isHeadless,
-          tileOffset: headlessConfig == null ? void 0 : headlessConfig.tileOffset,
-          hideAudioLevel: headlessConfig == null ? void 0 : headlessConfig.hideAudioLevel
-        })
-      }, rootCSS),
-      "data-testid": `participant_tile_${peerName}`
+      css: {
+        width: "min(500px, 95%)",
+        maxHeight: "100%",
+        overflowY: "auto"
+      }
     },
-    peerName !== void 0 ? /* @__PURE__ */ React2.createElement(
-      StyledVideoTile.Container,
+    /* @__PURE__ */ React4.createElement(Dialog.Title, { css: { p: "$4 0" } }, /* @__PURE__ */ React4.createElement(Flex, { justify: "between" }, /* @__PURE__ */ React4.createElement(Flex, { align: "center", css: { mb: "$1" } }, /* @__PURE__ */ React4.createElement(Text, { variant: "h6", inline: true }, "Stats For Nerds")), /* @__PURE__ */ React4.createElement(Dialog.DefaultClose, { "data-testid": "stats_dialog_close_icon" }))),
+    /* @__PURE__ */ React4.createElement(HorizontalDivider, { css: { mt: "0.8rem" } }),
+    /* @__PURE__ */ React4.createElement(Flex, { justify: "start", gap: 4, css: { m: "$10 0" } }, /* @__PURE__ */ React4.createElement(Switch, { checked: showStatsOnTiles, onCheckedChange: setShowStatsOnTiles }), /* @__PURE__ */ React4.createElement(Text, { variant: "body2", css: { fontWeight: "$semiBold" } }, "Show Stats on Tiles")),
+    /* @__PURE__ */ React4.createElement(
+      Flex,
       {
-        onMouseEnter: onHoverHandler,
-        onMouseLeave: onHoverHandler,
-        ref: isHeadless && (headlessConfig == null ? void 0 : headlessConfig.hideAudioLevel) ? void 0 : borderAudioRef,
-        noRadius: isHeadless && Number(headlessConfig == null ? void 0 : headlessConfig.tileOffset) === 0,
-        css: containerCSS
+        direction: "column",
+        css: {
+          mb: "$12",
+          position: "relative",
+          minWidth: 0
+        }
       },
-      showStatsOnTiles && isTileBigEnoughToShowStats ? /* @__PURE__ */ React2.createElement(VideoTileStats, { audioTrackID: audioTrack == null ? void 0 : audioTrack.id, videoTrackID: track == null ? void 0 : track.id, peerID: peerId, isLocal }) : null,
-      track ? /* @__PURE__ */ React2.createElement(
-        Video,
+      /* @__PURE__ */ React4.createElement(Label, { variant: "body2" }, "Stats For"),
+      /* @__PURE__ */ React4.createElement(Dropdown.Root, { "data-testid": "dialog_select_Stats For", open, onOpenChange: setOpen }, /* @__PURE__ */ React4.createElement(
+        DialogDropdownTrigger,
         {
-          trackId: track == null ? void 0 : track.id,
-          attach: isLocal ? void 0 : !isAudioOnly,
-          mirror: mirrorLocalVideo && peerId === localPeerID && (track == null ? void 0 : track.source) === "regular" && (track == null ? void 0 : track.facingMode) !== "environment",
-          degraded: isVideoDegraded,
-          noRadius: isHeadless && Number(headlessConfig == null ? void 0 : headlessConfig.tileOffset) === 0,
-          "data-testid": "participant_video_tile",
-          css: {
-            objectFit
-          }
+          title: selectedStat.label || "Select Stats",
+          css: { mt: "$4" },
+          titleCSS: { mx: 0 },
+          open,
+          ref
         }
-      ) : null,
-      isVideoMuted || isVideoDegraded || !isLocal && isAudioOnly ? /* @__PURE__ */ React2.createElement(StyledVideoTile.AvatarContainer, null, /* @__PURE__ */ React2.createElement(Avatar, { name: peerName || "", "data-testid": "participant_avatar_icon", size: avatarSize })) : null,
-      showAudioMuted({
-        hideTileAudioMute: headlessConfig == null ? void 0 : headlessConfig.hideTileAudioMute,
-        isHeadless,
-        isAudioMuted
-      }) ? /* @__PURE__ */ React2.createElement(
-        StyledVideoTile.AudioIndicator,
-        {
-          "data-testid": "participant_audio_mute_icon",
-          size: width && height && (width < 180 || height < 180) ? "small" : "medium"
-        },
-        /* @__PURE__ */ React2.createElement(MicOffIcon2, null)
-      ) : null,
-      isMouseHovered && !isHeadless ? /* @__PURE__ */ React2.createElement(TileMenu_default, { peerID: peerId, audioTrackID: audioTrack == null ? void 0 : audioTrack.id, videoTrackID: track == null ? void 0 : track.id }) : null,
-      /* @__PURE__ */ React2.createElement(PeerMetadata, { peerId }),
-      /* @__PURE__ */ React2.createElement(TileConnection_default, { hideLabel, name: label, isTile: true, peerId, width })
-    ) : null
-  );
+      ), /* @__PURE__ */ React4.createElement(Dropdown.Portal, null, /* @__PURE__ */ React4.createElement(Dropdown.Content, { align: "start", sideOffset: 8, css: { w: (_a = ref.current) == null ? void 0 : _a.clientWidth, zIndex: 1e3 } }, statsOptions.map((option) => {
+        const isSelected = option.id === selectedStat.id && option.layer === selectedStat.layer;
+        return /* @__PURE__ */ React4.createElement(
+          Dropdown.Item,
+          {
+            key: `${option.id}-${option.layer || ""}`,
+            onClick: () => {
+              setSelectedStat(option);
+            },
+            css: {
+              px: "$9",
+              bg: isSelected ? selectionBg : void 0,
+              c: isSelected ? "$on_primary_high" : "$on_primary_high"
+            }
+          },
+          option.label
+        );
+      }))))
+    ),
+    selectedStat.id === "local-peer" ? /* @__PURE__ */ React4.createElement(LocalPeerStats, null) : /* @__PURE__ */ React4.createElement(TrackStats, { trackID: selectedStat.id, layer: selectedStat.layer, local: selectedStat.local })
+  )));
 };
-var metaStyles = { top: "$4", left: "$4" };
-var PeerMetadata = ({ peerId }) => {
-  const metaData = useHMSStore3(selectPeerMetadata(peerId));
-  const isHandRaised = (metaData == null ? void 0 : metaData.isHandRaised) || false;
-  const isBRB = (metaData == null ? void 0 : metaData.isBRBOn) || false;
-  return /* @__PURE__ */ React2.createElement(Fragment2, null, isHandRaised ? /* @__PURE__ */ React2.createElement(StyledVideoTile.AttributeBox, { css: metaStyles, "data-testid": "raiseHand_icon_onTile" }, /* @__PURE__ */ React2.createElement(HandRaiseFilledIcon, { width: 40, height: 40 })) : null, isBRB ? /* @__PURE__ */ React2.createElement(StyledVideoTile.AttributeBox, { css: metaStyles, "data-testid": "brb_icon_onTile" }, /* @__PURE__ */ React2.createElement(BrbIcon, { width: 40, height: 40 })) : null);
+var useTracksWithLabel = () => {
+  const tracksMap = useHMSStore3(selectTracksMap2);
+  const peersMap = useHMSStore3(selectPeersMap);
+  const localPeerID = useHMSStore3(selectLocalPeerID);
+  const tracksWithLabels = useMemo(
+    () => Object.values(tracksMap).reduce((res, track) => {
+      var _a, _b;
+      const peerName = (_a = peersMap[track.peerId]) == null ? void 0 : _a.name;
+      const isLocalTrack = track.peerId === localPeerID;
+      if (isLocalTrack && ((_b = track.layerDefinitions) == null ? void 0 : _b.length)) {
+        res = res.concat(
+          track.layerDefinitions.map(({ layer }) => {
+            return {
+              id: track.id,
+              layer,
+              local: true,
+              label: `${peerName} ${track.source} ${track.type} - ${layer}`
+            };
+          })
+        );
+        return res;
+      }
+      res.push({
+        id: track.id,
+        local: isLocalTrack,
+        label: `${peerName} ${track.source} ${track.type}`
+      });
+      return res;
+    }, []),
+    [tracksMap, peersMap, localPeerID]
+  );
+  return tracksWithLabels;
 };
-var VideoTile = React2.memo(Tile);
-var showAudioMuted = ({ hideTileAudioMute, isHeadless, isAudioMuted }) => {
-  if (!isHeadless) {
-    return isAudioMuted;
+var LocalPeerStats = () => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i3;
+  const stats = useHMSStatsStore(selectHMSStats.localPeerStats);
+  if (!stats) {
+    return null;
   }
-  return isAudioMuted && !hideTileAudioMute;
+  return /* @__PURE__ */ React4.createElement(Flex, { css: { flexWrap: "wrap", gap: "$10" } }, /* @__PURE__ */ React4.createElement(StatsRow, { label: "Packets Lost", value: (_a = stats.subscribe) == null ? void 0 : _a.packetsLost }), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Jitter", value: (_b = stats.subscribe) == null ? void 0 : _b.jitter }), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Publish Bitrate", value: formatBytes((_c = stats.publish) == null ? void 0 : _c.bitrate, "b/s") }), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Subscribe Bitrate", value: formatBytes((_d = stats.subscribe) == null ? void 0 : _d.bitrate, "b/s") }), /* @__PURE__ */ React4.createElement(
+    StatsRow,
+    {
+      label: "Available Outgoing Bitrate",
+      value: formatBytes((_e = stats.publish) == null ? void 0 : _e.availableOutgoingBitrate, "b/s")
+    }
+  ), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Total Bytes Sent", value: formatBytes((_f = stats.publish) == null ? void 0 : _f.bytesSent) }), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Total Bytes Received", value: formatBytes((_g = stats.subscribe) == null ? void 0 : _g.bytesReceived) }), /* @__PURE__ */ React4.createElement(
+    StatsRow,
+    {
+      label: "Round Trip Time",
+      value: `${(((((_h = stats.publish) == null ? void 0 : _h.currentRoundTripTime) || 0) + (((_i3 = stats.subscribe) == null ? void 0 : _i3.currentRoundTripTime) || 0)) / 2).toFixed(3) * 1e3} ms`
+    }
+  ));
 };
-var getPadding = ({ isHeadless, tileOffset, hideAudioLevel }) => {
-  if (!isHeadless || isNaN(Number(tileOffset))) {
-    return void 0;
+var TrackStats = ({ trackID, layer, local }) => {
+  var _a;
+  const selector = layer ? selectHMSStats.localVideoTrackStatsByLayer(layer)(trackID) : local ? selectHMSStats.localAudioTrackStatsByID(trackID) : selectHMSStats.trackStatsByID(trackID);
+  const stats = useHMSStatsStore(selector);
+  if (!stats) {
+    return null;
   }
-  return Number(tileOffset) === 0 ? hideAudioLevel ? 0 : 3 : void 0;
+  const inbound = stats.type.includes("inbound");
+  return /* @__PURE__ */ React4.createElement(Flex, { css: { flexWrap: "wrap", gap: "$10" } }, /* @__PURE__ */ React4.createElement(StatsRow, { label: "Type", value: stats.type + " " + stats.kind }), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Bitrate", value: formatBytes(stats.bitrate, "b/s") }), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Packets Lost", value: stats.packetsLost }), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Jitter", value: (_a = stats.jitter) == null ? void 0 : _a.toFixed(3) }), /* @__PURE__ */ React4.createElement(
+    StatsRow,
+    {
+      label: inbound ? "Bytes Received" : "Bytes Sent",
+      value: formatBytes(inbound ? stats.bytesReceived : stats.bytesSent)
+    }
+  ), stats.kind === "video" && /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(StatsRow, { label: "Framerate", value: stats.framesPerSecond }), !inbound && /* @__PURE__ */ React4.createElement(StatsRow, { label: "Quality Limitation Reason", value: stats.qualityLimitationReason })), /* @__PURE__ */ React4.createElement(StatsRow, { label: "Round Trip Time", value: stats.roundTripTime ? `${stats.roundTripTime * 1e3} ms` : "-" }));
+};
+var StatsRow = React4.memo(({ label, value }) => /* @__PURE__ */ React4.createElement(Box, { css: { bg: "$surface_bright", w: "calc(50% - $6)", p: "$8", r: "$3" } }, /* @__PURE__ */ React4.createElement(
+  Text,
+  {
+    variant: "overline",
+    css: {
+      fontWeight: "$semiBold",
+      color: "$on_surface_medium",
+      textTransform: "uppercase"
+    }
+  },
+  label
+), /* @__PURE__ */ React4.createElement(Text, { variant: "sub1", css: { fontWeight: "$semiBold", color: "$on_surface_high" } }, value || "-")));
+var formatBytes = (bytes, unit = "B", decimals = 2) => {
+  if (bytes === void 0)
+    return "-";
+  if (bytes === 0)
+    return "0 " + unit;
+  const k2 = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["", "K", "M", "G", "T", "P", "E", "Z", "Y"].map((size) => size + unit);
+  const i = Math.floor(Math.log(bytes) / Math.log(k2));
+  return parseFloat((bytes / Math.pow(k2, i)).toFixed(dm)) + " " + sizes[i];
 };
-var VideoTile_default = VideoTile;
-
-// src/Prebuilt/components/gridView.jsx
-init_define_process_env();
-import React7, { Fragment as Fragment4 } from "react";
-import { useMedia } from "react-use";
 
-// src/Prebuilt/components/FirstPersonDisplay.jsx
+// src/Prebuilt/components/MoreSettings/BulkRoleChangeModal.jsx
 init_define_process_env();
-import React3 from "react";
-
-// src/Prebuilt/images/first_person.png
-var first_person_default = "data:image/png;base64,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";
-
-// src/Prebuilt/components/FirstPersonDisplay.jsx
-var FirstPersonDisplay = React3.memo(() => {
-  return /* @__PURE__ */ React3.createElement(
-    Box,
+import React5, { useCallback as useCallback2, useRef as useRef2, useState as useState4 } from "react";
+import { useHMSActions as useHMSActions3 } from "@100mslive/react-sdk";
+import { AlertTriangleIcon as AlertTriangleIcon2, ChangeRoleIcon, CheckIcon } from "@100mslive/react-icons";
+var BulkRoleChangeModal = ({ onOpenChange }) => {
+  var _a, _b;
+  const roles = useFilteredRoles();
+  const hmsActions = useHMSActions3();
+  const ref = useRef2(null);
+  const roleRef = useRef2(null);
+  const [selectedBulkRole, setBulkRole] = useState4([]);
+  const [selectedRole, setRole] = useState4("");
+  const [bulkRoleDialog, setBulkRoleDialog] = useState4(false);
+  const [roleDialog, setRoleDialog] = useState4(false);
+  const [errorMessage, setErrorMessage] = useState4("");
+  const [isSubmiting, setIsSubmiting] = useState4(false);
+  const changeBulkRole = useCallback2(() => __async(void 0, null, function* () {
+    if (selectedBulkRole.length > 0 && selectedRole) {
+      try {
+        setIsSubmiting(true);
+        yield hmsActions.changeRoleOfPeersWithRoles(selectedBulkRole, selectedRole);
+        setIsSubmiting(false);
+        setErrorMessage("");
+        onOpenChange(false);
+      } catch (err) {
+        setErrorMessage((err == null ? void 0 : err.message) ? err == null ? void 0 : err.message : "Unknown error");
+        setIsSubmiting(false);
+      }
+    }
+  }), [selectedBulkRole, selectedRole, hmsActions, onOpenChange]);
+  return /* @__PURE__ */ React5.createElement(Dialog.Root, { defaultOpen: true, onOpenChange }, /* @__PURE__ */ React5.createElement(DialogContent, { title: "Bulk Role Change", Icon: ChangeRoleIcon }, /* @__PURE__ */ React5.createElement(DialogRow, null, /* @__PURE__ */ React5.createElement(Text, null, "For Roles: "), /* @__PURE__ */ React5.createElement(
+    Dropdown.Root,
     {
-      css: {
-        position: "relative",
-        overflow: "hidden",
-        w: "37.5rem",
-        maxWidth: "80%",
-        h: "100%",
-        r: "$3",
-        m: "0 auto",
-        backgroundImage: `url(${first_person_default})`,
-        backgroundSize: "cover",
-        backgroundRepeat: "no-repeat",
-        "@md": {
-          w: "100%",
-          maxWidth: "unset"
+      open: bulkRoleDialog,
+      onOpenChange: (value) => {
+        if (value) {
+          setBulkRoleDialog(value);
         }
       },
-      "data-testid": "first_person_img"
+      modal: false
     },
-    /* @__PURE__ */ React3.createElement(
-      Flex,
+    /* @__PURE__ */ React5.createElement(
+      DialogDropdownTrigger,
       {
-        align: "center",
-        direction: "column",
+        ref,
+        title: selectedBulkRole.length === 0 ? "Select Multiple Roles" : selectedBulkRole.toString(),
         css: {
-          position: "absolute",
-          w: "100%",
-          top: "33.33%",
-          left: 0,
-          textAlign: "center"
+          w: "70%",
+          p: "$8"
+        },
+        open: bulkRoleDialog
+      }
+    ),
+    /* @__PURE__ */ React5.createElement(
+      Dropdown.Content,
+      {
+        css: { w: (_a = ref.current) == null ? void 0 : _a.clientWidth, zIndex: 1e3 },
+        onInteractOutside: () => {
+          if (bulkRoleDialog) {
+            setBulkRoleDialog(false);
+          }
         }
       },
-      /* @__PURE__ */ React3.createElement(Text, { color: "white", variant: "h4", css: { "@md": { fontSize: "$md" } } }, "Welcome!"),
-      /* @__PURE__ */ React3.createElement(Text, { color: "white", variant: "h6", css: { mt: "$4", "@md": { fontSize: "$sm" } } }, "You\u2019re the first one here."),
-      /* @__PURE__ */ React3.createElement(Text, { color: "white", variant: "h6", css: { mt: "$2", "@md": { fontSize: "$sm" } } }, "Sit back and relax till the others join.")
+      roles && roles.map((role) => {
+        return /* @__PURE__ */ React5.createElement(
+          Dropdown.CheckboxItem,
+          {
+            key: role,
+            checked: selectedBulkRole.includes(role),
+            onCheckedChange: (value) => {
+              setBulkRole((selection) => {
+                return value ? [...selection, role] : selection.filter((selectedRole2) => selectedRole2 !== role);
+              });
+              setErrorMessage("");
+            }
+          },
+          /* @__PURE__ */ React5.createElement(Checkbox.Root, { css: { margin: "$2" }, checked: selectedBulkRole.includes(role) }, /* @__PURE__ */ React5.createElement(Checkbox.Indicator, null, /* @__PURE__ */ React5.createElement(CheckIcon, { width: 16, height: 16 }))),
+          role
+        );
+      })
     )
-  );
-});
-
-// src/Prebuilt/components/Image.jsx
-init_define_process_env();
-var Image = styled("img", {
-  width: "100%",
-  height: "auto",
-  r: "$3"
-});
+  )), /* @__PURE__ */ React5.createElement(DialogRow, null, /* @__PURE__ */ React5.createElement(Text, null, "To Role: "), /* @__PURE__ */ React5.createElement(Dropdown.Root, { open: roleDialog, onOpenChange: (value) => setRoleDialog(value) }, /* @__PURE__ */ React5.createElement(
+    DialogDropdownTrigger,
+    {
+      ref: roleRef,
+      title: selectedRole || "Select Role",
+      css: {
+        w: "70%",
+        p: "$8"
+      },
+      open: roleDialog
+    }
+  ), /* @__PURE__ */ React5.createElement(Dropdown.Content, { css: { w: (_b = roleRef.current) == null ? void 0 : _b.clientWidth, zIndex: 1e3 } }, roles && roles.map((role) => {
+    return /* @__PURE__ */ React5.createElement(
+      Dropdown.Item,
+      {
+        key: role,
+        onSelect: () => {
+          setRole(role);
+          setErrorMessage("");
+        }
+      },
+      role
+    );
+  })))), /* @__PURE__ */ React5.createElement(DialogRow, null, errorMessage && /* @__PURE__ */ React5.createElement(Flex, { gap: 2, css: { c: "$alert_error_default", w: "70%", ml: "auto" } }, /* @__PURE__ */ React5.createElement(AlertTriangleIcon2, null), /* @__PURE__ */ React5.createElement(Text, { css: { c: "inherit" } }, errorMessage))), /* @__PURE__ */ React5.createElement(DialogRow, { justify: "end" }, /* @__PURE__ */ React5.createElement(Button, { variant: "primary", onClick: changeBulkRole, disabled: !(selectedRole && selectedBulkRole.length > 0) }, isSubmiting && /* @__PURE__ */ React5.createElement(Loading, { css: { color: "$on_primary_medium" } }), "Apply"))));
+};
 
-// src/Prebuilt/components/VideoList.jsx
+// src/Prebuilt/components/MoreSettings/FullScreenItem.jsx
 init_define_process_env();
-import React6, { Fragment as Fragment3, useEffect as useEffect2, useState as useState5 } from "react";
-import { selectLocalPeerID as selectLocalPeerID4, useHMSStore as useHMSStore5, useVideoList } from "@100mslive/react-sdk";
+import React6 from "react";
+import { ExpandIcon } from "@100mslive/react-icons";
 
-// src/Prebuilt/components/Pagination.jsx
+// src/Prebuilt/components/hooks/useFullscreen.js
 init_define_process_env();
-import React4 from "react";
-import { ChevronLeftIcon, ChevronRightIcon } from "@100mslive/react-icons";
-var Pagination = ({ page, setPage, numPages }) => {
-  const disableLeft = page === 0;
-  const disableRight = page === numPages - 1;
-  const nextPage = () => {
-    setPage(Math.min(page + 1, numPages - 1));
-  };
-  const prevPage = () => {
-    setPage(Math.max(page - 1, 0));
+import { useCallback as useCallback3, useEffect as useEffect3, useState as useState5 } from "react";
+import screenfull from "screenfull";
+var useFullscreen = () => {
+  const [isFullScreenEnabled, setIsFullScreenEnabled] = useState5(screenfull.isFullscreen);
+  const toggle = useCallback3(() => __async(void 0, null, function* () {
+    if (!screenfull.isEnabled) {
+      ToastManager.addToast({ title: "Fullscreen feature not supported" });
+      return;
+    }
+    try {
+      if (isFullScreenEnabled) {
+        yield screenfull.exit();
+      } else {
+        yield screenfull.request();
+      }
+    } catch (err) {
+      ToastManager.addToast({ title: err.message });
+    }
+  }), [isFullScreenEnabled]);
+  useEffect3(() => {
+    const onChange = () => {
+      setIsFullScreenEnabled(screenfull.isFullscreen);
+    };
+    if (screenfull.isEnabled) {
+      screenfull.on("change", onChange);
+    }
+    return () => {
+      if (screenfull.isEnabled) {
+        screenfull.off("change", onChange);
+      }
+    };
+  }, []);
+  return {
+    allowed: screenfull.isEnabled,
+    isFullscreen: isFullScreenEnabled,
+    toggleFullscreen: toggle
   };
-  return /* @__PURE__ */ React4.createElement(StyledPagination.Root, null, /* @__PURE__ */ React4.createElement(StyledPagination.Chevron, { disabled: disableLeft, onClick: prevPage }, /* @__PURE__ */ React4.createElement(ChevronLeftIcon, { width: 16, height: 16, style: { cursor: disableLeft ? "not-allowed" : "pointer" } })), /* @__PURE__ */ React4.createElement(StyledPagination.Dots, null, [...Array(numPages)].map((_3, i) => /* @__PURE__ */ React4.createElement(StyledPagination.Dot, { key: i, active: page === i, onClick: () => setPage(i) }))), /* @__PURE__ */ React4.createElement(StyledPagination.Chevron, { disabled: disableRight, onClick: nextPage }, /* @__PURE__ */ React4.createElement(ChevronRightIcon, { width: 16, height: 16, style: { cursor: disableRight ? "not-allowed" : "pointer" } })));
 };
 
-// src/Prebuilt/components/ScreenshareTile.jsx
-init_define_process_env();
-import React5, { useRef, useState as useState3 } from "react";
-import { useFullscreen } from "react-use";
-import screenfull from "screenfull";
-import {
-  selectLocalPeerID as selectLocalPeerID3,
-  selectPeerByID,
-  selectScreenShareAudioByPeerID,
-  selectScreenShareByPeerID,
-  useHMSStore as useHMSStore4
-} from "@100mslive/react-sdk";
-import { ExpandIcon, ShrinkIcon } from "@100mslive/react-icons";
-var labelStyles = {
-  position: "unset",
-  width: "100%",
-  textAlign: "center",
-  transform: "none",
-  mt: "$2",
-  flexShrink: 0
-};
-var Tile2 = ({ peerId, width = "100%", height = "100%" }) => {
-  const isLocal = useHMSStore4(selectLocalPeerID3) === peerId;
-  const track = useHMSStore4(selectScreenShareByPeerID(peerId));
-  const peer = useHMSStore4(selectPeerByID(peerId));
-  const isAudioOnly = useUISettings(UI_SETTINGS.isAudioOnly);
-  const isHeadless = useIsHeadless();
-  const [isMouseHovered, setIsMouseHovered] = useState3(false);
-  const showStatsOnTiles = useUISettings(UI_SETTINGS.showStatsOnTiles);
-  const label = getVideoTileLabel({
-    peerName: peer.name,
-    isLocal: false,
-    track
-  });
-  const fullscreenRef = useRef(null);
-  const [fullscreen, setFullscreen] = useState3(false);
-  const isFullscreen = useFullscreen(fullscreenRef, fullscreen, {
-    onClose: () => setFullscreen(false)
-  });
-  const isFullScreenSupported = screenfull.isEnabled;
-  const audioTrack = useHMSStore4(selectScreenShareAudioByPeerID(peer == null ? void 0 : peer.id));
-  return /* @__PURE__ */ React5.createElement(StyledVideoTile.Root, { css: { width, height }, "data-testid": "screenshare_tile" }, peer ? /* @__PURE__ */ React5.createElement(
-    StyledVideoTile.Container,
+// src/Prebuilt/components/MoreSettings/FullScreenItem.jsx
+var FullScreenItem = () => {
+  const { allowed, isFullscreen, toggleFullscreen } = useFullscreen();
+  const isFullscreenEnabled = useIsFeatureEnabled(FEATURE_LIST.FULLSCREEN);
+  if (!isFullscreenEnabled || !allowed) {
+    return null;
+  }
+  return /* @__PURE__ */ React6.createElement(
+    Dropdown.Item,
     {
-      transparentBg: true,
-      ref: fullscreenRef,
-      css: { flexDirection: "column" },
-      onMouseEnter: () => setIsMouseHovered(true),
-      onMouseLeave: () => {
-        setIsMouseHovered(false);
-      }
+      onClick: () => {
+        toggleFullscreen();
+      },
+      "data-testid": "full_screen_btn"
     },
-    showStatsOnTiles ? /* @__PURE__ */ React5.createElement(VideoTileStats, { audioTrackID: audioTrack == null ? void 0 : audioTrack.id, videoTrackID: track == null ? void 0 : track.id, peerID: peerId, isLocal }) : null,
-    isFullScreenSupported && !isHeadless ? /* @__PURE__ */ React5.createElement(StyledVideoTile.FullScreenButton, { onClick: () => setFullscreen(!fullscreen) }, isFullscreen ? /* @__PURE__ */ React5.createElement(ShrinkIcon, null) : /* @__PURE__ */ React5.createElement(ExpandIcon, null)) : null,
-    track ? /* @__PURE__ */ React5.createElement(
-      Video,
-      {
-        screenShare: true,
-        mirror: peer.isLocal && (track == null ? void 0 : track.source) === "regular",
-        attach: !isAudioOnly,
-        trackId: track.id
-      }
-    ) : null,
-    /* @__PURE__ */ React5.createElement(StyledVideoTile.Info, { css: labelStyles }, label),
-    isMouseHovered && !isHeadless && !(peer == null ? void 0 : peer.isLocal) ? /* @__PURE__ */ React5.createElement(TileMenu_default, { isScreenshare: true, peerID: peer == null ? void 0 : peer.id, audioTrackID: audioTrack == null ? void 0 : audioTrack.id, videoTrackID: track == null ? void 0 : track.id }) : null
-  ) : null);
+    /* @__PURE__ */ React6.createElement(ExpandIcon, null),
+    /* @__PURE__ */ React6.createElement(Text, { variant: "sm", css: { ml: "$4" } }, isFullscreen ? "Exit " : "Go ", "Fullscreen")
+  );
 };
-var ScreenshareTile = React5.memo(Tile2);
-var ScreenshareTile_default = ScreenshareTile;
-
-// src/Prebuilt/common/useSortedPeers.js
-init_define_process_env();
-import { useEffect, useRef as useRef2, useState as useState4 } from "react";
-import { useHMSVanillaStore } from "@100mslive/react-sdk";
-
-// src/Prebuilt/common/PeersSorter.js
-init_define_process_env();
 
-// ../hms-video-store/dist/index.js
+// src/Prebuilt/components/MoreSettings/MuteAllModal.jsx
 init_define_process_env();
+import React8, { useCallback as useCallback4, useState as useState6 } from "react";
+import { useHMSActions as useHMSActions4 } from "@100mslive/react-sdk";
+import { MicOffIcon } from "@100mslive/react-icons";
 
-// ../../node_modules/reselect/es/index.js
+// src/Prebuilt/components/MoreSettings/MuteAllContent.jsx
 init_define_process_env();
-function defaultEqualityCheck(a, b2) {
-  return a === b2;
-}
-function areArgumentsShallowlyEqual(equalityCheck, prev, next) {
-  if (prev === null || next === null || prev.length !== next.length) {
-    return false;
-  }
-  var length = prev.length;
-  for (var i = 0; i < length; i++) {
-    if (!equalityCheck(prev[i], next[i])) {
-      return false;
+import React7 from "react";
+var MuteAllContent = (props) => {
+  const roles = props.roles || [];
+  return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(
+    DialogSelect,
+    {
+      title: "Role",
+      options: [{ label: "All Roles", value: "" }, ...roles.map((role) => ({ label: role, value: role }))],
+      selected: props.selectedRole,
+      keyField: "value",
+      labelField: "label",
+      onChange: props.setRole
+    }
+  ), /* @__PURE__ */ React7.createElement(
+    DialogSelect,
+    {
+      title: "Track type",
+      options: props.trackTypeOptions,
+      selected: props.trackType,
+      onChange: props.setTrackType,
+      keyField: "value",
+      labelField: "label"
+    }
+  ), /* @__PURE__ */ React7.createElement(
+    DialogSelect,
+    {
+      title: "Track source",
+      options: props.trackSourceOptions,
+      selected: props.selectedSource,
+      onChange: props.setSource,
+      keyField: "value",
+      labelField: "label"
+    }
+  ), /* @__PURE__ */ React7.createElement(DialogRow, null, /* @__PURE__ */ React7.createElement(Text, { variant: "md" }, "Track status"), /* @__PURE__ */ React7.createElement(RadioGroup.Root, { value: props.enabled, onValueChange: props.setEnabled }, /* @__PURE__ */ React7.createElement(Flex, { align: "center", css: { mr: "$8" } }, /* @__PURE__ */ React7.createElement(RadioGroup.Item, { value: false, id: "trackDisableRadio", css: { mr: "$4" } }, /* @__PURE__ */ React7.createElement(RadioGroup.Indicator, null)), /* @__PURE__ */ React7.createElement(Label, { htmlFor: "trackDisableRadio" }, "Mute")), /* @__PURE__ */ React7.createElement(Flex, { align: "center", css: { cursor: "pointer" } }, /* @__PURE__ */ React7.createElement(RadioGroup.Item, { value: true, id: "trackEnableRadio", css: { mr: "$4" } }, /* @__PURE__ */ React7.createElement(RadioGroup.Indicator, null)), /* @__PURE__ */ React7.createElement(Label, { htmlFor: "trackEnableRadio" }, "Request Unmute")))), /* @__PURE__ */ React7.createElement(DialogRow, { justify: "end" }, /* @__PURE__ */ React7.createElement(Button, { variant: "primary", onClick: props.muteAll, css: { w: (props == null ? void 0 : props.isMobile) ? "100%" : "" } }, "Apply")));
+};
+
+// src/Prebuilt/components/MoreSettings/MuteAllModal.jsx
+var trackSourceOptions = [
+  { label: "All Track Sources", value: "" },
+  { label: "regular", value: "regular" },
+  { label: "screen", value: "screen" },
+  { label: "audioplaylist", value: "audioplaylist" },
+  { label: "videoplaylist", value: "videoplaylist" }
+];
+var trackTypeOptions = [
+  { label: "All Track Types", value: "" },
+  { label: "audio", value: "audio" },
+  { label: "video", value: "video" }
+];
+var MuteAllModal = ({ onOpenChange, isMobile = false }) => {
+  const roles = useFilteredRoles();
+  const hmsActions = useHMSActions4();
+  const [enabled, setEnabled] = useState6(false);
+  const [trackType, setTrackType] = useState6();
+  const [selectedRole, setRole] = useState6();
+  const [selectedSource, setSource] = useState6();
+  const muteAll = useCallback4(() => __async(void 0, null, function* () {
+    yield hmsActions.setRemoteTracksEnabled({
+      enabled,
+      type: trackType,
+      source: selectedSource,
+      roles: selectedRole ? [selectedRole] : void 0
+    });
+    onOpenChange(false);
+  }), [selectedRole, enabled, trackType, selectedSource, hmsActions, onOpenChange]);
+  const props = {
+    muteAll,
+    roles,
+    enabled,
+    setEnabled,
+    trackType,
+    setTrackType,
+    selectedRole,
+    setRole,
+    selectedSource,
+    setSource,
+    trackSourceOptions,
+    trackTypeOptions,
+    isMobile
+  };
+  if (isMobile) {
+    return /* @__PURE__ */ React8.createElement(Sheet.Root, { defaultOpen: true, onOpenChange }, /* @__PURE__ */ React8.createElement(Sheet.Content, { css: { px: "$10" } }, /* @__PURE__ */ React8.createElement(MuteAllContent, __spreadValues({}, props))));
+  }
+  return /* @__PURE__ */ React8.createElement(Dialog.Root, { defaultOpen: true, onOpenChange }, /* @__PURE__ */ React8.createElement(DialogContent, { title: "Mute/Unmute Remote Tracks", Icon: MicOffIcon }, /* @__PURE__ */ React8.createElement(MuteAllContent, __spreadValues({}, props))));
+};
+
+// src/Prebuilt/components/MoreSettings/SplitComponents/DesktopOptions.jsx
+var MODALS = {
+  CHANGE_NAME: "changeName",
+  SELF_ROLE_CHANGE: "selfRoleChange",
+  MORE_SETTINGS: "moreSettings",
+  START_RECORDING: "startRecording",
+  DEVICE_SETTINGS: "deviceSettings",
+  STATS_FOR_NERDS: "statsForNerds",
+  BULK_ROLE_CHANGE: "bulkRoleChange",
+  MUTE_ALL: "muteAll",
+  EMBED_URL: "embedUrl"
+};
+var DesktopOptions = () => {
+  const localPeerId = useHMSStore4(selectLocalPeerID2);
+  const localPeerRole = useHMSStore4(selectLocalPeerRoleName2);
+  const hmsActions = useHMSActions5();
+  const enablHlsStats = useHMSStore4(selectAppData(APP_DATA.hlsStats));
+  const isSFNEnabled = useIsFeatureEnabled(FEATURE_LIST.STARTS_FOR_NERDS);
+  const [openModals, setOpenModals] = useState7(/* @__PURE__ */ new Set());
+  const { isHandRaised, isBRBOn, toggleHandRaise, toggleBRB } = useMyMetadata();
+  const isHandRaiseEnabled = useIsFeatureEnabled(FEATURE_LIST.HAND_RAISE);
+  const isBRBEnabled = useIsFeatureEnabled(FEATURE_LIST.BRB);
+  const showStreamingUI = useShowStreamingUI();
+  const hlsViewerRole = useHLSViewerRole();
+  const isHlsViewer = hlsViewerRole === localPeerRole;
+  const isPIPEnabled = useIsFeatureEnabled(FEATURE_LIST.PICTURE_IN_PICTURE);
+  useDropdownList({ open: openModals.size > 0, name: "MoreSettings" });
+  const updateState = (modalName, value) => {
+    setOpenModals((modals) => {
+      const copy = new Set(modals);
+      if (value) {
+        copy.clear();
+        copy.add(modalName);
+      } else {
+        copy.delete(modalName);
+      }
+      return copy;
+    });
+  };
+  return /* @__PURE__ */ React9.createElement(Fragment, null, /* @__PURE__ */ React9.createElement(
+    Dropdown.Root,
+    {
+      open: openModals.has(MODALS.MORE_SETTINGS),
+      onOpenChange: (value) => updateState(MODALS.MORE_SETTINGS, value),
+      modal: false
+    },
+    /* @__PURE__ */ React9.createElement(Dropdown.Trigger, { asChild: true, "data-testid": "more_settings_btn" }, /* @__PURE__ */ React9.createElement(IconButton_default, null, /* @__PURE__ */ React9.createElement(Tooltip, { title: "More options" }, /* @__PURE__ */ React9.createElement(DragHandleIcon, null)))),
+    /* @__PURE__ */ React9.createElement(
+      Dropdown.Content,
+      {
+        sideOffset: 5,
+        align: "end",
+        css: {
+          py: "$0",
+          maxHeight: "unset",
+          "@md": { w: "$64" },
+          "div[role='separator']:first-child": {
+            display: "none"
+          }
+        }
+      },
+      isHandRaiseEnabled && !showStreamingUI ? /* @__PURE__ */ React9.createElement(Dropdown.Item, { onClick: toggleHandRaise, "data-testid": "raise_hand_btn" }, /* @__PURE__ */ React9.createElement(HandIcon, null), /* @__PURE__ */ React9.createElement(Text, { variant: "sm", css: { ml: "$4", color: "$on_surface_high" } }, "Raise Hand"), /* @__PURE__ */ React9.createElement(Flex, { justify: "end", css: { color: "$on_surface_high", flexGrow: "1" } }, isHandRaised ? /* @__PURE__ */ React9.createElement(CheckIcon2, null) : null)) : null,
+      isBRBEnabled && !showStreamingUI ? /* @__PURE__ */ React9.createElement(Dropdown.Item, { onClick: toggleBRB, "data-testid": "brb_btn" }, /* @__PURE__ */ React9.createElement(BrbIcon, null), /* @__PURE__ */ React9.createElement(Text, { variant: "sm", css: { ml: "$4", color: "$on_surface_high" } }, "Be Right Back"), /* @__PURE__ */ React9.createElement(Flex, { justify: "end", css: { color: "$on_surface_high", flexGrow: "1" } }, isBRBOn ? /* @__PURE__ */ React9.createElement(CheckIcon2, null) : null)) : null,
+      (isBRBEnabled || isHandRaiseEnabled) && !showStreamingUI ? /* @__PURE__ */ React9.createElement(Dropdown.ItemSeparator, { css: { mx: "0" } }) : null,
+      isPIPEnabled && !isHlsViewer ? /* @__PURE__ */ React9.createElement(Dropdown.Item, null, /* @__PURE__ */ React9.createElement(
+        PIP,
+        {
+          content: /* @__PURE__ */ React9.createElement(Flex, { css: { w: "100%" } }, /* @__PURE__ */ React9.createElement(PipIcon2, null), /* @__PURE__ */ React9.createElement(Text, { variant: "sm", css: { ml: "$4" } }, "Picture in picture mode"))
+        }
+      )) : null,
+      /* @__PURE__ */ React9.createElement(FullScreenItem, null),
+      /* @__PURE__ */ React9.createElement(Dropdown.ItemSeparator, { css: { mx: 0 } }),
+      /* @__PURE__ */ React9.createElement(Dropdown.Item, { onClick: () => updateState(MODALS.DEVICE_SETTINGS, true), "data-testid": "device_settings_btn" }, /* @__PURE__ */ React9.createElement(SettingsIcon, null), /* @__PURE__ */ React9.createElement(Text, { variant: "sm", css: { ml: "$4" } }, "Settings")),
+      FeatureFlags.enableStatsForNerds && isSFNEnabled && (localPeerRole === "hls-viewer" ? HMSHLSPlayer.isSupported() ? /* @__PURE__ */ React9.createElement(
+        Dropdown.Item,
+        {
+          onClick: () => hmsActions.setAppData(APP_DATA.hlsStats, !enablHlsStats),
+          "data-testid": "hls_stats"
+        },
+        /* @__PURE__ */ React9.createElement(
+          Checkbox.Root,
+          {
+            css: { margin: "$2" },
+            checked: enablHlsStats,
+            onCheckedChange: () => hmsActions.setAppData(APP_DATA.hlsStats, !enablHlsStats)
+          },
+          /* @__PURE__ */ React9.createElement(Checkbox.Indicator, null, /* @__PURE__ */ React9.createElement(CheckIcon2, { width: 16, height: 16 }))
+        ),
+        /* @__PURE__ */ React9.createElement(Flex, { justify: "between", css: { width: "100%" } }, /* @__PURE__ */ React9.createElement(Text, { variant: "sm", css: { ml: "$4" } }, "Show HLS Stats"), /* @__PURE__ */ React9.createElement(Text, { variant: "sm", css: { ml: "$4" } }, `${isMacOS ? "\u2318" : "ctrl"} + ]`))
+      ) : null : /* @__PURE__ */ React9.createElement(
+        Dropdown.Item,
+        {
+          onClick: () => updateState(MODALS.STATS_FOR_NERDS, true),
+          "data-testid": "stats_for_nreds_btn"
+        },
+        /* @__PURE__ */ React9.createElement(InfoIcon, null),
+        /* @__PURE__ */ React9.createElement(Text, { variant: "sm", css: { ml: "$4" } }, "Stats for Nerds")
+      ))
+    )
+  ), openModals.has(MODALS.BULK_ROLE_CHANGE) && /* @__PURE__ */ React9.createElement(BulkRoleChangeModal, { onOpenChange: (value) => updateState(MODALS.BULK_ROLE_CHANGE, value) }), openModals.has(MODALS.MUTE_ALL) && /* @__PURE__ */ React9.createElement(MuteAllModal, { onOpenChange: (value) => updateState(MODALS.MUTE_ALL, value) }), openModals.has(MODALS.START_RECORDING) && /* @__PURE__ */ React9.createElement(StartRecording_default, { open: true, onOpenChange: (value) => updateState(MODALS.START_RECORDING, value) }), openModals.has(MODALS.DEVICE_SETTINGS) && /* @__PURE__ */ React9.createElement(SettingsModal_default, { open: true, onOpenChange: (value) => updateState(MODALS.DEVICE_SETTINGS, value) }), FeatureFlags.enableStatsForNerds && openModals.has(MODALS.STATS_FOR_NERDS) && /* @__PURE__ */ React9.createElement(StatsForNerds, { open: true, onOpenChange: (value) => updateState(MODALS.STATS_FOR_NERDS, value) }), openModals.has(MODALS.SELF_ROLE_CHANGE) && /* @__PURE__ */ React9.createElement(RoleChangeModal, { peerId: localPeerId, onOpenChange: (value) => updateState(MODALS.SELF_ROLE_CHANGE, value) }));
+};
+
+// src/Prebuilt/components/MoreSettings/SplitComponents/MwebOptions.jsx
+init_define_process_env();
+import React10, { Suspense, useRef as useRef3, useState as useState8 } from "react";
+import { useClickAway } from "react-use";
+import {
+  selectIsConnectedToRoom,
+  selectIsLocalVideoEnabled as selectIsLocalVideoEnabled2,
+  selectPeerCount,
+  selectPermissions as selectPermissions2,
+  useHMSActions as useHMSActions6,
+  useHMSStore as useHMSStore5,
+  useRecordingStreaming as useRecordingStreaming2
+} from "@100mslive/react-sdk";
+import { CrossIcon, DragHandleIcon as DragHandleIcon2, EmojiIcon, PeopleIcon, RecordIcon, SettingsIcon as SettingsIcon2 } from "@100mslive/react-icons";
+var VirtualBackground = React10.lazy(() => import("./VirtualBackground-GGCQJ5JM.js"));
+var MODALS2 = {
+  CHANGE_NAME: "changeName",
+  SELF_ROLE_CHANGE: "selfRoleChange",
+  MORE_SETTINGS: "moreSettings",
+  START_RECORDING: "startRecording",
+  DEVICE_SETTINGS: "deviceSettings",
+  STATS_FOR_NERDS: "statsForNerds",
+  BULK_ROLE_CHANGE: "bulkRoleChange",
+  MUTE_ALL: "muteAll",
+  EMBED_URL: "embedUrl"
+};
+var MwebOptions = () => {
+  const hmsActions = useHMSActions6();
+  const permissions = useHMSStore5(selectPermissions2);
+  const isConnected = useHMSStore5(selectIsConnectedToRoom);
+  const { isBrowserRecordingOn, isStreamingOn, isHLSRunning } = useRecordingStreaming2();
+  const [openModals, setOpenModals] = useState8(/* @__PURE__ */ new Set());
+  const [openOptionsSheet, setOpenOptionsSheet] = useState8(false);
+  const [openSettingsSheet, setOpenSettingsSheet] = useState8(false);
+  const [showEmojiCard, setShowEmojiCard] = useState8(false);
+  const [showRecordingOn, setShowRecordingOn] = useState8(false);
+  const [isRecordingLoading, setIsRecordingLoading] = useState8(false);
+  const toggleParticipants = useSidepaneToggle(SIDE_PANE_OPTIONS.PARTICIPANTS);
+  const peerCount = useHMSStore5(selectPeerCount);
+  const emojiCardRef = useRef3(null);
+  const isVideoOn = useHMSStore5(selectIsLocalVideoEnabled2);
+  useDropdownList({ open: openModals.size > 0, name: "MoreSettings" });
+  const updateState = (modalName, value) => {
+    setOpenModals((modals) => {
+      const copy = new Set(modals);
+      if (value) {
+        copy.add(modalName);
+      } else {
+        copy.delete(modalName);
+      }
+      return copy;
+    });
+  };
+  useClickAway(emojiCardRef, () => setShowEmojiCard(false));
+  return /* @__PURE__ */ React10.createElement(React10.Fragment, null, /* @__PURE__ */ React10.createElement(Sheet.Root, { open: openOptionsSheet, onOpenChange: setOpenOptionsSheet }, /* @__PURE__ */ React10.createElement(Sheet.Trigger, { asChild: true, "data-testid": "more_settings_btn" }, /* @__PURE__ */ React10.createElement(IconButton_default, null, /* @__PURE__ */ React10.createElement(Tooltip, { title: "More options" }, /* @__PURE__ */ React10.createElement(DragHandleIcon2, null)))), /* @__PURE__ */ React10.createElement(Sheet.Content, { css: { bg: "$surface_dim", pb: "$14" } }, /* @__PURE__ */ React10.createElement(
+    Sheet.Title,
+    {
+      css: {
+        display: "flex",
+        color: "$on_surface_high",
+        w: "100%",
+        justifyContent: "space-between",
+        fontSize: "$md",
+        mt: "$8",
+        px: "$10",
+        pb: "$8",
+        borderBottom: "1px solid $border_default",
+        mb: "$8",
+        alignItems: "center"
+      }
+    },
+    "Options",
+    /* @__PURE__ */ React10.createElement(Sheet.Close, null, /* @__PURE__ */ React10.createElement(Box, { css: { color: "$on_surface_high" } }, /* @__PURE__ */ React10.createElement(CrossIcon, null)))
+  ), /* @__PURE__ */ React10.createElement(
+    Box,
+    {
+      css: {
+        display: "grid",
+        gridTemplateColumns: "1fr 1fr 1fr",
+        gridTemplateRows: "auto",
+        gridColumnGap: "$6",
+        gridRowGap: "$8",
+        px: "$9"
+      }
+    },
+    /* @__PURE__ */ React10.createElement(
+      ActionTile.Root,
+      {
+        onClick: () => {
+          toggleParticipants();
+          setOpenOptionsSheet(false);
+        }
+      },
+      /* @__PURE__ */ React10.createElement(ActionTile.Count, null, getFormattedCount(peerCount)),
+      /* @__PURE__ */ React10.createElement(PeopleIcon, null),
+      /* @__PURE__ */ React10.createElement(ActionTile.Title, null, "Participants")
+    ),
+    isVideoOn ? /* @__PURE__ */ React10.createElement(Suspense, { fallback: "" }, /* @__PURE__ */ React10.createElement(VirtualBackground, { asActionTile: true, onVBClick: () => setOpenOptionsSheet(false) })) : null,
+    /* @__PURE__ */ React10.createElement(
+      ActionTile.Root,
+      {
+        onClick: () => {
+          setShowEmojiCard(true);
+          setOpenOptionsSheet(false);
+        }
+      },
+      /* @__PURE__ */ React10.createElement(EmojiIcon, null),
+      /* @__PURE__ */ React10.createElement(ActionTile.Title, null, "Emoji Reactions")
+    ),
+    /* @__PURE__ */ React10.createElement(
+      ActionTile.Root,
+      {
+        onClick: () => {
+          setOpenSettingsSheet(true);
+          setOpenOptionsSheet(false);
+        }
+      },
+      /* @__PURE__ */ React10.createElement(SettingsIcon2, null),
+      /* @__PURE__ */ React10.createElement(ActionTile.Title, null, "Settings")
+    ),
+    isConnected && (permissions == null ? void 0 : permissions.browserRecording) ? /* @__PURE__ */ React10.createElement(
+      ActionTile.Root,
+      {
+        disabled: isHLSRunning,
+        onClick: () => __async(void 0, null, function* () {
+          if (isRecordingLoading) {
+            return;
+          }
+          if (isBrowserRecordingOn || isStreamingOn) {
+            setOpenOptionsSheet(false);
+            setShowRecordingOn(true);
+          } else {
+            setIsRecordingLoading(true);
+            try {
+              yield hmsActions.startRTMPOrRecording({
+                record: true
+              });
+              setOpenOptionsSheet(false);
+              setIsRecordingLoading(false);
+            } catch (error) {
+              if (error.message.includes("stream already running")) {
+                ToastManager.addToast({
+                  title: "Recording already running",
+                  variant: "error"
+                });
+              } else {
+                ToastManager.addToast({
+                  title: error.message,
+                  variant: "error"
+                });
+              }
+              setIsRecordingLoading(false);
+            }
+          }
+          if (isHLSRunning) {
+            setOpenOptionsSheet(false);
+          }
+        })
+      },
+      isRecordingLoading ? /* @__PURE__ */ React10.createElement(Loading, null) : /* @__PURE__ */ React10.createElement(RecordIcon, null),
+      /* @__PURE__ */ React10.createElement(ActionTile.Title, null, isBrowserRecordingOn ? "Recording On" : isRecordingLoading ? "Starting Recording" : "Start Recording")
+    ) : null
+  ))), /* @__PURE__ */ React10.createElement(SettingsModal_default, { open: openSettingsSheet, onOpenChange: setOpenSettingsSheet }), openModals.has(MODALS2.MUTE_ALL) && /* @__PURE__ */ React10.createElement(MuteAllModal, { onOpenChange: (value) => updateState(MODALS2.MUTE_ALL, value), isMobile: true }), openModals.has(MODALS2.CHANGE_NAME) && /* @__PURE__ */ React10.createElement(
+    ChangeNameModal,
+    {
+      onOpenChange: (value) => updateState(MODALS2.CHANGE_NAME, value),
+      openParentSheet: () => setOpenOptionsSheet(true)
+    }
+  ), showEmojiCard && /* @__PURE__ */ React10.createElement(
+    Box,
+    {
+      onClick: () => setShowEmojiCard(false),
+      ref: emojiCardRef,
+      css: {
+        maxWidth: "100%",
+        w: "100%",
+        position: "absolute",
+        left: 0,
+        right: 0,
+        bottom: "$18",
+        bg: "$surface_default",
+        zIndex: "10",
+        p: "$8",
+        pb: 0,
+        r: "$1",
+        mx: "$4"
+      }
+    },
+    /* @__PURE__ */ React10.createElement(EmojiCard, null)
+  ), showRecordingOn && /* @__PURE__ */ React10.createElement(
+    StopRecordingInSheet,
+    {
+      onClose: () => setShowRecordingOn(false),
+      onStopRecording: () => __async(void 0, null, function* () {
+        try {
+          yield hmsActions.stopRTMPAndRecording();
+          setShowRecordingOn(false);
+        } catch (error) {
+          ToastManager.addToast({
+            title: error.message,
+            variant: "error"
+          });
+        }
+      })
+    }
+  ));
+};
+
+// src/Prebuilt/components/MoreSettings/MoreSettings.jsx
+var MoreSettings = () => {
+  const isMobile = useMedia(config.media.md);
+  return isMobile ? /* @__PURE__ */ React11.createElement(MwebOptions, null) : /* @__PURE__ */ React11.createElement(DesktopOptions, null);
+};
+
+// src/Prebuilt/components/RaiseHand.jsx
+init_define_process_env();
+import React12 from "react";
+import { selectLocalPeer, selectPeerMetadata, useHMSStore as useHMSStore6 } from "@100mslive/react-sdk";
+import { HandIcon as HandIcon2 } from "@100mslive/react-icons";
+var RaiseHand = () => {
+  var _a;
+  const isHandRaiseEnabled = useIsFeatureEnabled(FEATURE_LIST.HAND_RAISE);
+  const { toggleHandRaise } = useMyMetadata();
+  const localPeer = useHMSStore6(selectLocalPeer);
+  const isHandRaised = ((_a = useHMSStore6(selectPeerMetadata(localPeer.id))) == null ? void 0 : _a.isHandRaised) || false;
+  if (!isHandRaiseEnabled) {
+    return null;
+  }
+  return /* @__PURE__ */ React12.createElement(Tooltip, { title: isHandRaised ? "Lower hand" : "Raise hand" }, /* @__PURE__ */ React12.createElement(IconButton_default, { active: !isHandRaised, onClick: toggleHandRaise }, /* @__PURE__ */ React12.createElement(HandIcon2, null)));
+};
+
+// src/Prebuilt/components/ScreenShare.jsx
+init_define_process_env();
+import React20, { Fragment as Fragment3 } from "react";
+import { selectIsAllowedToPublish, useHMSStore as useHMSStore7, useScreenShare as useScreenShare2 } from "@100mslive/react-sdk";
+import { ShareScreenIcon } from "@100mslive/react-icons";
+
+// src/Prebuilt/components/pdfAnnotator/shareScreenOptions.jsx
+init_define_process_env();
+import React19, { Fragment as Fragment2, useState as useState10 } from "react";
+import { useScreenShare } from "@100mslive/react-sdk";
+import { StarIcon, VerticalMenuIcon } from "@100mslive/react-icons";
+
+// src/Prebuilt/images/pdf-share.png
+var pdf_share_default = "data:image/png;base64,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";
+
+// src/Prebuilt/images/screen-share.png
+var screen_share_default = "data:image/png;base64,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";
+
+// src/Prebuilt/components/ShareMenuIcon.jsx
+init_define_process_env();
+var ScreenShareButton = styled(IconButton_default, {
+  h: "$14",
+  px: "$8",
+  r: "$1",
+  borderTopRightRadius: 0,
+  borderBottomRightRadius: 0,
+  "@md": {
+    px: "$4",
+    mx: 0
+  }
+});
+var ShareMenuIcon = styled(ScreenShareButton, {
+  borderTopLeftRadius: 0,
+  borderBottomLeftRadius: 0,
+  borderTopRightRadius: "$1",
+  borderBottomRightRadius: "$1",
+  borderLeftWidth: 0,
+  w: "$4",
+  "@md": {
+    w: "unset",
+    px: "$2"
+  }
+});
+
+// src/Prebuilt/components/pdfAnnotator/pdfFileOptions.jsx
+init_define_process_env();
+import React18, { useState as useState9 } from "react";
+
+// src/Prebuilt/components/pdfAnnotator/pdfErrorView.jsx
+init_define_process_env();
+import React13 from "react";
+import { InfoIcon as InfoIcon2 } from "@100mslive/react-icons";
+var PdfErrorView = ({ isPDFUrlValid }) => {
+  return !isPDFUrlValid && /* @__PURE__ */ React13.createElement(
+    DialogRow,
+    {
+      css: {
+        mt: "-$8",
+        color: "$alert_error_default",
+        justifyContent: "start"
+      }
+    },
+    /* @__PURE__ */ React13.createElement(InfoIcon2, { width: "12px", height: "12px" }),
+    /* @__PURE__ */ React13.createElement(
+      Text,
+      {
+        variant: "caption",
+        css: {
+          pl: "$1",
+          color: "$alert_error_default"
+        }
+      },
+      "Please enter a valid PDF URL"
+    )
+  );
+};
+
+// src/Prebuilt/components/pdfAnnotator/pdfHeader.jsx
+init_define_process_env();
+import React14 from "react";
+var PDFHeader = () => {
+  return /* @__PURE__ */ React14.createElement(
+    DialogCol,
+    {
+      align: "start",
+      css: {
+        mt: 0,
+        mb: "$6"
+      }
+    },
+    /* @__PURE__ */ React14.createElement(Dialog.Title, { asChild: true }, /* @__PURE__ */ React14.createElement(Text, { as: "h6", variant: "h6" }, "Share PDF")),
+    /* @__PURE__ */ React14.createElement(Dialog.Description, { asChild: true }, /* @__PURE__ */ React14.createElement(
+      Text,
+      {
+        variant: "sm",
+        css: {
+          c: "$on_surface_medium"
+        }
+      },
+      "Choose PDF you want to annotate and share"
+    ))
+  );
+};
+
+// src/Prebuilt/components/pdfAnnotator/pdfInfo.jsx
+init_define_process_env();
+import React15 from "react";
+import { InfoIcon as InfoIcon3 } from "@100mslive/react-icons";
+var PDFInfo = () => {
+  return /* @__PURE__ */ React15.createElement(
+    DialogRow,
+    {
+      css: {
+        px: "$8",
+        py: "$3",
+        bg: "$surface_default",
+        r: "$1",
+        outline: "none",
+        border: "1px solid $border_bright",
+        minHeight: "$11"
+      }
+    },
+    /* @__PURE__ */ React15.createElement(
+      InfoIcon3,
+      {
+        width: "64px",
+        height: "64px",
+        style: {
+          paddingRight: "16px"
+        }
+      }
+    ),
+    /* @__PURE__ */ React15.createElement(Text, { variant: "caption" }, "On the next screen, ensure you select \u201CThis Tab\u201D and click on share. Only the PDF viewer will be seen by other participants")
+  );
+};
+
+// src/Prebuilt/components/pdfAnnotator/submitPdf.jsx
+init_define_process_env();
+import React16, { useCallback as useCallback5 } from "react";
+var SubmitPDF = ({
+  pdfFile,
+  pdfURL,
+  isValidateProgress,
+  setIsPDFUrlValid,
+  setIsValidateProgress,
+  onOpenChange
+}) => {
+  const [, setPDFConfig] = useSetAppDataByKey(APP_DATA.pdfConfig);
+  const isValidPDF = useCallback5(
+    (pdfURL2) => {
+      const extension = pdfURL2.split(".").pop().toLowerCase();
+      setIsValidateProgress(true);
+      if (extension === "pdf") {
+        setIsPDFUrlValid(true);
+        setIsValidateProgress(false);
+        setPDFConfig({ state: true, file: pdfFile, url: pdfURL2 });
+        onOpenChange(false);
+      }
+      fetch(pdfURL2, { method: "HEAD" }).then((response) => response.headers.get("content-type")).then((contentType) => {
+        if (contentType === "application/pdf") {
+          setIsPDFUrlValid(true);
+          setIsValidateProgress(false);
+          setPDFConfig({ state: true, file: pdfFile, url: pdfURL2 });
+          onOpenChange(false);
+        } else {
+          setIsPDFUrlValid(false);
+          setIsValidateProgress(false);
+        }
+      }).catch(() => {
+        setIsPDFUrlValid(false);
+        setIsValidateProgress(false);
+      });
+    },
+    [onOpenChange, pdfFile, setIsPDFUrlValid, setIsValidateProgress, setPDFConfig]
+  );
+  return /* @__PURE__ */ React16.createElement(
+    Flex,
+    {
+      direction: "row",
+      css: {
+        mb: "0",
+        mt: "auto",
+        gap: "$8"
+      }
+    },
+    /* @__PURE__ */ React16.createElement(
+      Button,
+      {
+        variant: "standard",
+        outlined: true,
+        type: "submit",
+        onClick: () => {
+          onOpenChange(false);
+        },
+        css: { w: "50%" }
+      },
+      "Cancel"
+    ),
+    /* @__PURE__ */ React16.createElement(
+      Button,
+      {
+        variant: "primary",
+        type: "submit",
+        onClick: () => {
+          if (pdfFile) {
+            setPDFConfig({ state: true, file: pdfFile, url: pdfURL });
+            onOpenChange(false);
+          } else if (pdfURL) {
+            isValidPDF(pdfURL);
+          }
+        },
+        disabled: !pdfFile && !pdfURL,
+        loading: isValidateProgress,
+        "data-testid": "share_pdf_btn",
+        css: {
+          w: "50%"
+        }
+      },
+      "Start Sharing"
+    )
+  );
+};
+
+// src/Prebuilt/components/pdfAnnotator/uploadedFile.jsx
+init_define_process_env();
+import React17 from "react";
+import { TrashIcon } from "@100mslive/react-icons";
+var UploadedFile = ({
+  pdfFile,
+  pdfURL,
+  isValidateProgress,
+  setPDFFile,
+  setIsPDFUrlValid,
+  setIsValidateProgress,
+  onOpenChange
+}) => {
+  const [fileName, ext] = pdfFile.name.split(".");
+  return /* @__PURE__ */ React17.createElement(Dialog.Root, { defaultOpen: true, onOpenChange }, /* @__PURE__ */ React17.createElement(Dialog.Portal, null, /* @__PURE__ */ React17.createElement(Dialog.Overlay, null), /* @__PURE__ */ React17.createElement(
+    Dialog.Content,
+    {
+      css: {
+        w: "min(420px,80%)",
+        overflow: "auto",
+        p: "$10",
+        bg: "$surface_dim"
+      }
+    },
+    /* @__PURE__ */ React17.createElement(Flex, { direction: "column" }, /* @__PURE__ */ React17.createElement(PDFHeader, null), /* @__PURE__ */ React17.createElement(
+      DialogRow,
+      {
+        css: {
+          fontFamily: "$sans",
+          bg: "$surface_bright",
+          r: "$1",
+          outline: "none",
+          border: "1px solid $border_bright",
+          p: "$4 $6",
+          minHeight: "$11",
+          c: "$on_primary_high",
+          fs: "$md",
+          w: "100%",
+          "&:focus": {
+            boxShadow: "0 0 0 1px $colors$primary_default",
+            border: "1px solid $transparent"
+          },
+          mb: 0,
+          mt: "$6"
+        }
+      },
+      /* @__PURE__ */ React17.createElement(Flex, { direction: "row", css: { flexGrow: "1", maxWidth: "88%" } }, /* @__PURE__ */ React17.createElement(
+        Text,
+        {
+          css: {
+            textOverflow: "ellipsis",
+            overflow: "hidden",
+            whiteSpace: "nowrap"
+          }
+        },
+        fileName
+      ), /* @__PURE__ */ React17.createElement(Text, { css: { whiteSpace: "nowrap" } }, ".", ext)),
+      /* @__PURE__ */ React17.createElement(
+        TrashIcon,
+        {
+          onClick: () => setPDFFile(null),
+          style: {
+            cursor: "pointer"
+          }
+        }
+      )
+    ), /* @__PURE__ */ React17.createElement(PDFInfo, null), /* @__PURE__ */ React17.createElement(
+      SubmitPDF,
+      {
+        pdfFile,
+        pdfURL,
+        isValidateProgress,
+        setIsPDFUrlValid,
+        setIsValidateProgress,
+        onOpenChange
+      }
+    ))
+  )));
+};
+
+// src/Prebuilt/components/pdfAnnotator/pdfFileOptions.jsx
+function PDFFileOptions({ onOpenChange }) {
+  const [isPDFUrlValid, setIsPDFUrlValid] = useState9(true);
+  const [isValidateProgress, setIsValidateProgress] = useState9(false);
+  const [pdfFile, setPDFFile] = useState9(null);
+  const [pdfURL, setPDFURL] = useState9("");
+  return !pdfFile ? /* @__PURE__ */ React18.createElement(Dialog.Root, { defaultOpen: true, onOpenChange }, /* @__PURE__ */ React18.createElement(Dialog.Portal, null, /* @__PURE__ */ React18.createElement(Dialog.Overlay, null), /* @__PURE__ */ React18.createElement(
+    Dialog.Content,
+    {
+      css: {
+        w: "min(420px,80%)",
+        overflow: "auto",
+        p: "$10",
+        bg: "$surface_dim"
+      }
+    },
+    /* @__PURE__ */ React18.createElement(Flex, { direction: "column" }, /* @__PURE__ */ React18.createElement(PDFHeader, null), /* @__PURE__ */ React18.createElement(
+      DialogInputFile,
+      {
+        onChange: (target) => {
+          setPDFFile(target.files[0]);
+        },
+        placeholder: "Click to upload",
+        type: "file",
+        accept: ".pdf"
+      }
+    ), /* @__PURE__ */ React18.createElement(
+      DialogRow,
+      {
+        css: {
+          m: "$10 0"
+        }
+      },
+      /* @__PURE__ */ React18.createElement(
+        HorizontalDivider,
+        {
+          css: {
+            mr: "$4"
+          }
+        }
+      ),
+      /* @__PURE__ */ React18.createElement(
+        Text,
+        {
+          variant: "tiny",
+          css: {
+            color: "$on_surface_low"
+          }
+        },
+        "OR"
+      ),
+      /* @__PURE__ */ React18.createElement(
+        HorizontalDivider,
+        {
+          css: {
+            ml: "$4"
+          }
+        }
+      )
+    ), /* @__PURE__ */ React18.createElement(
+      Text,
+      {
+        variant: "sm",
+        css: {
+          py: "$2"
+        }
+      },
+      "Import from URL"
+    ), /* @__PURE__ */ React18.createElement(
+      Input,
+      {
+        css: { w: "100%", mb: "$10" },
+        value: pdfURL,
+        onFocus: () => {
+          setIsPDFUrlValid(true);
+          setIsValidateProgress(false);
+        },
+        onChange: (e) => {
+          setPDFURL(e.target.value);
+        },
+        placeholder: "Paste PDF URL",
+        type: "text",
+        error: !isPDFUrlValid
+      }
+    ), !isPDFUrlValid && /* @__PURE__ */ React18.createElement(PdfErrorView, { isPDFUrlValid }), /* @__PURE__ */ React18.createElement(PDFInfo, null), /* @__PURE__ */ React18.createElement(
+      SubmitPDF,
+      {
+        pdfFile,
+        pdfURL,
+        isValidateProgress,
+        setIsPDFUrlValid,
+        setIsValidateProgress,
+        onOpenChange
+      }
+    ))
+  ))) : /* @__PURE__ */ React18.createElement(
+    UploadedFile,
+    {
+      pdfFile,
+      pdfURL,
+      isValidateProgress,
+      setPDFFile,
+      setIsPDFUrlValid,
+      setIsValidateProgress,
+      onOpenChange
+    }
+  );
+}
+
+// src/Prebuilt/components/pdfAnnotator/shareScreenOptions.jsx
+var MODALS3 = {
+  SHARE: "share",
+  SCREEN_SHARE: "screenShare",
+  PDF_SHARE: "pdfShare"
+};
+function ShareScreenOptions() {
+  const [openModals, setOpenModals] = useState10(/* @__PURE__ */ new Set());
+  const { amIScreenSharing } = useScreenShare();
+  const updateState = (modalName, value) => {
+    setOpenModals((modals) => {
+      const copy = new Set(modals);
+      if (value) {
+        copy.add(modalName);
+      } else {
+        copy.delete(modalName);
+      }
+      return copy;
+    });
+  };
+  const { toggleScreenShare } = useScreenShare();
+  return /* @__PURE__ */ React19.createElement(Fragment2, null, /* @__PURE__ */ React19.createElement(
+    Dropdown.Root,
+    {
+      open: openModals.has(MODALS3.SHARE),
+      onOpenChange: (value) => updateState(MODALS3.SHARE, value),
+      modal: false
+    },
+    /* @__PURE__ */ React19.createElement(Dropdown.Trigger, { asChild: true, "data-testid": "sharing_btn", disabled: amIScreenSharing }, /* @__PURE__ */ React19.createElement(ShareMenuIcon, { disabled: amIScreenSharing }, /* @__PURE__ */ React19.createElement(Tooltip, { title: "Share" }, /* @__PURE__ */ React19.createElement(Box, null, /* @__PURE__ */ React19.createElement(VerticalMenuIcon, null))))),
+    /* @__PURE__ */ React19.createElement(
+      Dropdown.Content,
+      {
+        sideOffset: 5,
+        css: {
+          w: "$96",
+          maxHeight: "$96",
+          p: 0,
+          bg: "$surface_dim"
+        }
+      },
+      /* @__PURE__ */ React19.createElement(
+        Dropdown.Item,
+        {
+          css: {
+            flexDirection: "column",
+            alignItems: "flex-start",
+            px: "$10",
+            pt: "$10",
+            pb: "$6",
+            "&:hover": {
+              bg: "$transparent",
+              cursor: "default"
+            }
+          }
+        },
+        /* @__PURE__ */ React19.createElement(Text, { variant: "h6" }, "Start Sharing"),
+        /* @__PURE__ */ React19.createElement(Text, { variant: "sm" }, "Choose what you want to share")
+      ),
+      /* @__PURE__ */ React19.createElement(
+        Dropdown.Item,
+        {
+          css: {
+            flexDirection: "row",
+            alignItems: "flex-start",
+            gap: "$8",
+            px: "$10",
+            py: "$6",
+            "&:hover": {
+              bg: "$transparent",
+              cursor: "default"
+            }
+          }
+        },
+        /* @__PURE__ */ React19.createElement(
+          Flex,
+          {
+            direction: "column",
+            align: "center",
+            css: {
+              gap: "$6"
+            }
+          },
+          /* @__PURE__ */ React19.createElement(
+            IconButton,
+            {
+              as: "div",
+              onClick: () => toggleScreenShare(),
+              css: {
+                p: "$6",
+                display: "flex",
+                justifyContent: "center",
+                border: "1px solid $border_bright",
+                r: "$2",
+                bg: "$surface_brighter",
+                pb: "0"
+              }
+            },
+            /* @__PURE__ */ React19.createElement(
+              "img",
+              {
+                src: screen_share_default,
+                alt: "screen-share",
+                width: "100%",
+                height: "100%",
+                style: {
+                  borderTopLeftRadius: "0.5rem",
+                  // TODO: create image component to solve for style hardcoding
+                  borderTopRightRadius: "0.5rem"
+                }
+              }
+            )
+          ),
+          /* @__PURE__ */ React19.createElement(Flex, { direction: "column", align: "center" }, /* @__PURE__ */ React19.createElement(Text, { variant: "body2" }, "Share Screen"), /* @__PURE__ */ React19.createElement(
+            Text,
+            {
+              variant: "caption",
+              css: {
+                c: "$on_surface_low",
+                textAlign: "center"
+              }
+            },
+            "Share your tab, window or your entire screen"
+          ))
+        ),
+        /* @__PURE__ */ React19.createElement(
+          Flex,
+          {
+            direction: "column",
+            align: "center",
+            css: {
+              gap: "$6"
+            }
+          },
+          /* @__PURE__ */ React19.createElement(
+            IconButton,
+            {
+              onClick: () => {
+                updateState(MODALS3.PDF_SHARE, true);
+              },
+              disabled: amIScreenSharing,
+              css: {
+                p: "$6",
+                display: "flex",
+                justifyContent: "center",
+                border: "$border_bright 1px solid",
+                r: "$2",
+                bg: "$surface_bright",
+                pb: "0"
+              }
+            },
+            /* @__PURE__ */ React19.createElement(
+              "img",
+              {
+                src: pdf_share_default,
+                alt: "pdf-share",
+                width: "100%",
+                height: "100%",
+                style: {
+                  borderTopLeftRadius: "0.5rem",
+                  // TODO: create image component to solve for style hardcoding
+                  borderTopRightRadius: "0.5rem"
+                }
+              }
+            ),
+            /* @__PURE__ */ React19.createElement(
+              Flex,
+              {
+                direction: "row",
+                align: "center",
+                css: {
+                  position: "absolute",
+                  top: "29%",
+                  left: "54%",
+                  padding: "$2 $4",
+                  r: "$2",
+                  bg: "$primary_bright",
+                  zIndex: "2",
+                  gap: "$2"
+                }
+              },
+              /* @__PURE__ */ React19.createElement(StarIcon, { height: 14, width: 14 }),
+              /* @__PURE__ */ React19.createElement(
+                Text,
+                {
+                  variant: "xs",
+                  css: {
+                    fontWeight: "$semiBold",
+                    c: "$on_primary_high",
+                    pr: "$4"
+                  }
+                },
+                "New"
+              )
+            )
+          ),
+          /* @__PURE__ */ React19.createElement(Flex, { direction: "column", align: "center" }, /* @__PURE__ */ React19.createElement(Text, { variant: "body2" }, "Share PDF"), /* @__PURE__ */ React19.createElement(
+            Text,
+            {
+              variant: "caption",
+              css: {
+                c: "$on_surface_low",
+                textAlign: "center"
+              }
+            },
+            "Annotate, draw shapes, and more over PDFs"
+          ))
+        )
+      ),
+      /* @__PURE__ */ React19.createElement(
+        Dropdown.Item,
+        {
+          css: {
+            px: "$10",
+            pb: "$10",
+            pt: "$6",
+            "&:hover": {
+              bg: "$transparent",
+              cursor: "default"
+            }
+          }
+        },
+        /* @__PURE__ */ React19.createElement(
+          Button,
+          {
+            variant: "standard",
+            outlined: true,
+            type: "submit",
+            onClick: () => {
+              updateState(MODALS3.SHARE, false);
+            },
+            "data-testid": "share_btn",
+            css: {
+              w: "100%"
+            }
+          },
+          "Cancel"
+        )
+      )
+    )
+  ), openModals.has(MODALS3.PDF_SHARE) && /* @__PURE__ */ React19.createElement(PDFFileOptions, { onOpenChange: (value) => updateState(MODALS3.PDF_SHARE, value) }));
+}
+
+// src/Prebuilt/components/ScreenShare.jsx
+var ScreenshareToggle = ({ css = {} }) => {
+  const isAllowedToPublish = useHMSStore7(selectIsAllowedToPublish);
+  const isAudioOnly = useUISettings(UI_SETTINGS.isAudioOnly);
+  const { amIScreenSharing, screenShareVideoTrackId: video, toggleScreenShare } = useScreenShare2();
+  const isVideoScreenshare = amIScreenSharing && !!video;
+  if (!isAllowedToPublish.screen || !isScreenshareSupported()) {
+    return null;
+  }
+  return /* @__PURE__ */ React20.createElement(Fragment3, null, /* @__PURE__ */ React20.createElement(Flex, { direction: "row", css: { "@md": { display: "none" } } }, /* @__PURE__ */ React20.createElement(
+    ScreenShareButton,
+    {
+      variant: "standard",
+      key: "ShareScreen",
+      active: !isVideoScreenshare,
+      css,
+      disabled: isAudioOnly,
+      onClick: () => {
+        toggleScreenShare();
+      }
+    },
+    /* @__PURE__ */ React20.createElement(Tooltip, { title: `${!isVideoScreenshare ? "Start" : "Stop"} screen sharing` }, /* @__PURE__ */ React20.createElement(Box, null, /* @__PURE__ */ React20.createElement(ShareScreenIcon, null)))
+  ), /* @__PURE__ */ React20.createElement(ShareScreenOptions, null)));
+};
+
+// src/Prebuilt/components/Footer/ChatToggle.jsx
+init_define_process_env();
+import React21 from "react";
+import { selectUnreadHMSMessagesCount, useHMSStore as useHMSStore8 } from "@100mslive/react-sdk";
+import { ChatIcon, ChatUnreadIcon } from "@100mslive/react-icons";
+var ChatToggle = () => {
+  const countUnreadMessages = useHMSStore8(selectUnreadHMSMessagesCount);
+  const isChatOpen = useIsSidepaneTypeOpen(SIDE_PANE_OPTIONS.CHAT);
+  const toggleChat = useSidepaneToggle(SIDE_PANE_OPTIONS.CHAT);
+  const isFeatureEnabled = useIsFeatureEnabled(FEATURE_LIST.CHAT);
+  if (!isFeatureEnabled) {
+    return;
+  }
+  return /* @__PURE__ */ React21.createElement(Tooltip, { key: "chat", title: `${isChatOpen ? "Close" : "Open"} chat` }, /* @__PURE__ */ React21.createElement(IconButton_default, { onClick: toggleChat, active: !isChatOpen, "data-testid": "chat_btn" }, countUnreadMessages === 0 ? /* @__PURE__ */ React21.createElement(ChatIcon, null) : /* @__PURE__ */ React21.createElement(ChatUnreadIcon, { "data-testid": "chat_unread_btn" })));
+};
+
+// src/Prebuilt/components/Footer/Footer.jsx
+var Footer2 = () => {
+  const isMobile = useMedia2(config.media.md);
+  const localPeerRole = useHMSStore9(selectLocalPeerRoleName3);
+  const hlsViewerRole = useHLSViewerRole();
+  const isHlsViewer = hlsViewerRole === localPeerRole;
+  return /* @__PURE__ */ React22.createElement(
+    Footer.Root,
+    {
+      css: {
+        flexWrap: "nowrap",
+        "@md": {
+          justifyContent: "center",
+          gap: "$10"
+        }
+      }
+    },
+    /* @__PURE__ */ React22.createElement(
+      Footer.Left,
+      {
+        css: {
+          "@md": {
+            w: "unset",
+            p: "0",
+            gap: "$10"
+          }
+        }
+      },
+      isMobile ? /* @__PURE__ */ React22.createElement(LeaveRoom, null) : null,
+      /* @__PURE__ */ React22.createElement(AudioVideoToggle, null)
+    ),
+    /* @__PURE__ */ React22.createElement(
+      Footer.Center,
+      {
+        css: {
+          "@md": {
+            w: "unset",
+            gap: "$10"
+          }
+        }
+      },
+      isMobile ? /* @__PURE__ */ React22.createElement(React22.Fragment, null, isHlsViewer ? /* @__PURE__ */ React22.createElement(RaiseHand, null) : null, /* @__PURE__ */ React22.createElement(ChatToggle, null), /* @__PURE__ */ React22.createElement(MoreSettings, null)) : /* @__PURE__ */ React22.createElement(React22.Fragment, null, /* @__PURE__ */ React22.createElement(ScreenshareToggle, null), isHlsViewer ? /* @__PURE__ */ React22.createElement(RaiseHand, null) : null, /* @__PURE__ */ React22.createElement(EmojiReaction, null), /* @__PURE__ */ React22.createElement(LeaveRoom, null))
+    ),
+    /* @__PURE__ */ React22.createElement(Footer.Right, null, /* @__PURE__ */ React22.createElement(ChatToggle, null), /* @__PURE__ */ React22.createElement(ParticipantCount, null), /* @__PURE__ */ React22.createElement(MoreSettings, null))
+  );
+};
+
+// src/Prebuilt/components/Notifications/HLSFailureModal.jsx
+init_define_process_env();
+import React23, { useCallback as useCallback6, useState as useState11 } from "react";
+import { selectHLSState, useHMSActions as useHMSActions7, useHMSStore as useHMSStore10 } from "@100mslive/react-sdk";
+function HLSFailureModal() {
+  const { hlsError } = useHMSStore10(selectHLSState).error || false;
+  const [openModal, setOpenModal] = useState11(!!hlsError);
+  const hmsActions = useHMSActions7();
+  const [isHLSStarted, setHLSStarted] = useSetAppDataByKey(APP_DATA.hlsStarted);
+  const startHLS = useCallback6(() => __async(this, null, function* () {
+    try {
+      if (isHLSStarted) {
+        return;
+      }
+      setHLSStarted(true);
+      yield hmsActions.startHLSStreaming({});
+    } catch (error) {
+      if (error.message.includes("invalid input")) {
+        yield startHLS();
+        return;
+      }
+      setHLSStarted(false);
+    }
+  }), [hmsActions, isHLSStarted, setHLSStarted]);
+  return hlsError ? /* @__PURE__ */ React23.createElement(
+    Dialog.Root,
+    {
+      open: openModal,
+      onOpenChange: (value) => {
+        if (!value) {
+          setOpenModal(false);
+        }
+      }
+    },
+    /* @__PURE__ */ React23.createElement(Dialog.Portal, null, /* @__PURE__ */ React23.createElement(Dialog.Overlay, null), /* @__PURE__ */ React23.createElement(Dialog.Content, { css: { w: "min(360px, 90%)" } }, /* @__PURE__ */ React23.createElement(
+      Dialog.Title,
+      {
+        css: {
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "space-between",
+          borderBottom: "1px solid $border_default",
+          mt: "$4"
+        }
+      },
+      /* @__PURE__ */ React23.createElement(Text, { variant: "h6", css: { fontWeight: "$semiBold" } }, "Failed to Go Live")
+    ), /* @__PURE__ */ React23.createElement(Text, { variant: "sm", css: { mb: "$10", color: "$on_surface_medium" } }, "Something went wrong and your live broadcast failed. Please try again."), /* @__PURE__ */ React23.createElement(Flex, { align: "center", justify: "between", css: { w: "100%", gap: "$8" } }, /* @__PURE__ */ React23.createElement(Button, { outlined: true, variant: "standard", css: { w: "100%" }, onClick: () => setOpenModal(false) }, "Dismiss"), /* @__PURE__ */ React23.createElement(Button, { css: { w: "100%" } }, "Go Live"))))
+  ) : null;
+}
+
+// src/Prebuilt/layouts/mainView.jsx
+init_define_process_env();
+import React33, { Suspense as Suspense2, useCallback as useCallback10, useEffect as useEffect8 } from "react";
+import {
+  selectIsConnectedToRoom as selectIsConnectedToRoom2,
+  selectLocalPeerRoleName as selectLocalPeerRoleName6,
+  selectPeerScreenSharing as selectPeerScreenSharing3,
+  selectPeerSharingAudio,
+  selectPeerSharingVideoPlaylist as selectPeerSharingVideoPlaylist3,
+  selectPermissions as selectPermissions3,
+  useHMSActions as useHMSActions12,
+  useHMSStore as useHMSStore18,
+  useRecordingStreaming as useRecordingStreaming3
+} from "@100mslive/react-sdk";
+
+// src/Prebuilt/components/EqualProminence.jsx
+init_define_process_env();
+import React25, { useEffect as useEffect5, useMemo as useMemo2, useState as useState12 } from "react";
+import { useMeasure, useMedia as useMedia4 } from "react-use";
+import {
+  getPeersWithTiles,
+  selectLocalPeer as selectLocalPeer3,
+  selectPeers as selectPeers2,
+  selectRemotePeers as selectRemotePeers2,
+  selectTracksMap as selectTracksMap3,
+  useHMSStore as useHMSStore12,
+  useHMSVanillaStore as useHMSVanillaStore2
+} from "@100mslive/react-sdk";
+
+// src/Prebuilt/layouts/InsetView.jsx
+init_define_process_env();
+import React24, { Fragment as Fragment4, useEffect as useEffect4, useRef as useRef4 } from "react";
+import Draggable from "react-draggable";
+import { useMedia as useMedia3 } from "react-use";
+import {
+  selectIsAllowedToPublish as selectIsAllowedToPublish2,
+  selectLocalPeer as selectLocalPeer2,
+  selectRemotePeers,
+  selectRolesMap,
+  useHMSStore as useHMSStore11
+} from "@100mslive/react-sdk";
+import { ExpandIcon as ExpandIcon2 } from "@100mslive/react-icons";
+var MinimisedTile = ({ setMinimised }) => {
+  return /* @__PURE__ */ React24.createElement(Flex, { align: "center", css: { gap: "$6", r: "$1", bg: "$surface_default", p: "$4", color: "$on_surface_high" } }, /* @__PURE__ */ React24.createElement(AudioVideoToggle, { hideOptions: true }), /* @__PURE__ */ React24.createElement(Text, null, "You"), /* @__PURE__ */ React24.createElement(
+    IconButton_default,
+    {
+      onClick: () => setMinimised(false),
+      css: { bg: "transparent", border: "transparent" },
+      className: "__cancel-drag-event"
+    },
+    /* @__PURE__ */ React24.createElement(ExpandIcon2, null)
+  ));
+};
+var InsetTile = () => {
+  const isMobile = useMedia3(config.media.md);
+  const isLandscape = useMedia3(config.media.ls);
+  const localPeer = useHMSStore11(selectLocalPeer2);
+  const isAllowedToPublish = useHMSStore11(selectIsAllowedToPublish2);
+  const [minimised, setMinimised] = useSetAppDataByKey(APP_DATA.minimiseInset);
+  const aspectRatio = isMobile ? 9 / 16 : 16 / 9;
+  let height = 180;
+  let width = height * aspectRatio;
+  if (isLandscape && width > 240) {
+    width = 240;
+    height = width / aspectRatio;
+  }
+  const nodeRef = useRef4(null);
+  useEffect4(() => {
+    if (!nodeRef.current || !window.ResizeObserver) {
+      return;
+    }
+    const node = nodeRef.current;
+    const resizeObserver = new ResizeObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.target === node.parentElement) {
+          node.style.transform = `translate(0,0)`;
+        }
+      });
+    });
+    resizeObserver.observe(node.parentElement);
+    return () => {
+      (node == null ? void 0 : node.parentElement) && (resizeObserver == null ? void 0 : resizeObserver.unobserve(node.parentElement));
+      resizeObserver == null ? void 0 : resizeObserver.disconnect();
+    };
+  }, []);
+  if (!isAllowedToPublish.audio && !isAllowedToPublish.video) {
+    return null;
+  }
+  return /* @__PURE__ */ React24.createElement(Draggable, { bounds: "parent", nodeRef, cancel: ".__cancel-drag-event" }, /* @__PURE__ */ React24.createElement(
+    Box,
+    {
+      ref: nodeRef,
+      css: __spreadValues({
+        position: "absolute",
+        bottom: 0,
+        right: 0,
+        zIndex: 10,
+        boxShadow: "0 0 8px 0 rgba(0,0,0,0.3)",
+        r: "$2"
+      }, !minimised ? {
+        aspectRatio,
+        h: height
+      } : {})
+    },
+    minimised ? /* @__PURE__ */ React24.createElement(MinimisedTile, { setMinimised }) : /* @__PURE__ */ React24.createElement(
+      VideoTile_default,
+      {
+        peerId: localPeer.id,
+        trackid: localPeer.videoTrack,
+        rootCSS: {
+          size: "100%",
+          padding: 0
+        },
+        width,
+        height,
+        isDragabble: isMobile,
+        canMinimise: true
+      }
+    )
+  ));
+};
+
+// src/Prebuilt/common/PeersSorter.js
+init_define_process_env();
+
+// ../hms-video-store/dist/index.js
+init_define_process_env();
+
+// ../../node_modules/reselect/es/index.js
+init_define_process_env();
+function defaultEqualityCheck(a, b2) {
+  return a === b2;
+}
+function areArgumentsShallowlyEqual(equalityCheck, prev, next) {
+  if (prev === null || next === null || prev.length !== next.length) {
+    return false;
+  }
+  var length = prev.length;
+  for (var i = 0; i < length; i++) {
+    if (!equalityCheck(prev[i], next[i])) {
+      return false;
     }
   }
   return true;
@@ -5327,7 +6836,7 @@ var $t = (n2, e) => {
 };
 var mr = (n2, e) => () => (e || n2((e = { exports: {} }).exports, e), e.exports);
 var Jt = mr((aa, Ar) => {
-  Ar.exports = { name: "@100mslive/hms-video", version: "0.9.13-alpha.1", license: "MIT", main: "dist/index.cjs.js", typings: "dist/index.d.ts", module: "dist/index.js", files: ["dist", "src"], engines: { node: ">=10" }, exports: { ".": { require: "./dist/index.cjs.js", import: "./dist/index.js", default: "./dist/index.js" } }, scripts: { prestart: "rm -rf dist && yarn types:build", start: 'concurrently "yarn dev" "yarn types"', dev: "node ../../scripts/dev", "build:only": "node ../../scripts/build", build: "yarn build:only && yarn types:build", types: "tsc -w", "types:build": "tsc -p tsconfig.json", test: "jest --maxWorkers=1", lint: "eslint -c ../../.eslintrc .", "lint:fix": "yarn lint --fix", prepare: "yarn build", size: "size-limit", analyze: "size-limit --why", format: "prettier --write src/**/*.ts" }, author: "100ms <tech-common@100ms.live>", devDependencies: { "@types/dom-screen-wake-lock": "^1.0.1", "@types/sdp-transform": "^2.4.4", "@types/ua-parser-js": "^0.7.36", "@types/uuid": "^8.3.0", "jest-canvas-mock": "^2.3.1", tslib: "^2.2.0" }, dependencies: { eventemitter2: "^6.4.7", "sdp-transform": "^2.14.1", "ua-parser-js": "^1.0.1", uuid: "^8.3.2", "webrtc-adapter": "^8.0.0" } };
+  Ar.exports = { name: "@100mslive/hms-video", version: "0.9.14", license: "MIT", main: "dist/index.cjs.js", typings: "dist/index.d.ts", module: "dist/index.js", files: ["dist", "src"], engines: { node: ">=10" }, exports: { ".": { require: "./dist/index.cjs.js", import: "./dist/index.js", default: "./dist/index.js" } }, scripts: { prestart: "rm -rf dist && yarn types:build", start: 'concurrently "yarn dev" "yarn types"', dev: "node ../../scripts/dev", "build:only": "node ../../scripts/build", build: "yarn build:only && yarn types:build", types: "tsc -w", "types:build": "tsc -p tsconfig.json", test: "jest --maxWorkers=1", lint: "eslint -c ../../.eslintrc .", "lint:fix": "yarn lint --fix", prepare: "yarn build", size: "size-limit", analyze: "size-limit --why", format: "prettier --write src/**/*.ts" }, author: "100ms <tech-common@100ms.live>", devDependencies: { "@types/dom-screen-wake-lock": "^1.0.1", "@types/sdp-transform": "^2.4.4", "@types/ua-parser-js": "^0.7.36", "@types/uuid": "^8.3.0", "jest-canvas-mock": "^2.3.1", tslib: "^2.2.0" }, dependencies: { eventemitter2: "^6.4.7", "sdp-transform": "^2.14.1", "ua-parser-js": "^1.0.1", uuid: "^8.3.2", "webrtc-adapter": "^8.0.0" } };
 });
 var Se = class {
 };
@@ -5784,7 +7293,7 @@ var me = ((t) => (t[t.Publish = 0] = "Publish", t[t.Subscribe = 1] = "Subscribe"
 import { EventEmitter2 as gs } from "eventemitter2";
 var Ut = (s, e) => () => (e || s((e = { exports: {} }).exports, e), e.exports);
 var At = Ut((Kn, Is) => {
-  Is.exports = { version: "0.10.13-alpha.1", license: "MIT", main: "dist/index.cjs.js", module: "dist/index.js", typings: "dist/index.d.ts", files: ["dist", "src"], engines: { node: ">=12" }, exports: { ".": { require: "./dist/index.cjs.js", import: "./dist/index.js", default: "./dist/index.js" } }, scripts: { prestart: "rm -rf dist && yarn types:build", start: 'concurrently "yarn dev" "yarn types"', dev: "node ../../scripts/dev", "build:only": "node ../../scripts/build", build: "yarn build:only && yarn types:build", types: "tsc -w", "types:build": "tsc -p tsconfig.json", format: "prettier --write src/**/*.ts", test: "jest --maxWorkers=1", "test:watch": "jest --watch", "test:coverage": "jest --coverage", lint: "eslint -c ../../.eslintrc .", "lint:fix": "yarn lint --fix", prepare: "yarn build", size: "size-limit", analyze: "size-limit --why", docs: "rm -rf ./docs && typedoc && rm -f ./docs/README.md && mkdir ./docs/home &&mv ./docs/modules.md ./docs/home/content.md && node ../../scripts/docs-store && npx prettier --write './docs/**/*'" }, name: "@100mslive/hms-video-store", author: "100ms", sideEffects: false, dependencies: { "@100mslive/hms-video": "0.9.13-alpha.1", eventemitter2: "^6.4.7", immer: "^9.0.6", reselect: "4.0.0", zustand: "3.5.7" }, devDependencies: { "ts-node": "^10.4.0", tslib: "^2.2.0" }, description: "This is an addon to the core sdk provided by 100ms. It abstracts away the intricacies of data management and provides a flux based reactive data store where data flows in only one direction.", repository: { type: "git", url: "git+https://github.com/100mslive/hms-video-store.git" }, keywords: ["video", "webrtc", "conferencing", "100ms"], bugs: { url: "https://github.com/100mslive/hms-video-store/issues" }, homepage: "https://github.com/100mslive/hms-video-store#readme" };
+  Is.exports = { version: "0.10.14", license: "MIT", main: "dist/index.cjs.js", module: "dist/index.js", typings: "dist/index.d.ts", files: ["dist", "src"], engines: { node: ">=12" }, exports: { ".": { require: "./dist/index.cjs.js", import: "./dist/index.js", default: "./dist/index.js" } }, scripts: { prestart: "rm -rf dist && yarn types:build", start: 'concurrently "yarn dev" "yarn types"', dev: "node ../../scripts/dev", "build:only": "node ../../scripts/build", build: "yarn build:only && yarn types:build", types: "tsc -w", "types:build": "tsc -p tsconfig.json", format: "prettier --write src/**/*.ts", test: "jest --maxWorkers=1", "test:watch": "jest --watch", "test:coverage": "jest --coverage", lint: "eslint -c ../../.eslintrc .", "lint:fix": "yarn lint --fix", prepare: "yarn build", size: "size-limit", analyze: "size-limit --why", docs: "rm -rf ./docs && typedoc && rm -f ./docs/README.md && mkdir ./docs/home &&mv ./docs/modules.md ./docs/home/content.md && node ../../scripts/docs-store && npx prettier --write './docs/**/*'" }, name: "@100mslive/hms-video-store", author: "100ms", sideEffects: false, dependencies: { "@100mslive/hms-video": "0.9.14", eventemitter2: "^6.4.7", immer: "^9.0.6", reselect: "4.0.0", zustand: "3.5.7" }, devDependencies: { "ts-node": "^10.4.0", tslib: "^2.2.0" }, description: "This is an addon to the core sdk provided by 100ms. It abstracts away the intricacies of data management and provides a flux based reactive data store where data flows in only one direction.", repository: { type: "git", url: "git+https://github.com/100mslive/hms-video-store.git" }, keywords: ["video", "webrtc", "conferencing", "100ms"], bugs: { url: "https://github.com/100mslive/hms-video-store/issues" }, homepage: "https://github.com/100mslive/hms-video-store#readme" };
 });
 var Re = ((n2) => (n2.Disconnected = "Disconnected", n2.Preview = "Preview", n2.Connecting = "Connecting", n2.Connected = "Connected", n2.Reconnecting = "Reconnecting", n2.Disconnecting = "Disconnecting", n2.Failed = "Failed", n2))(Re || {});
 var Vt = ((e) => (e.CHAT = "chat", e))(Vt || {});
@@ -6291,222 +7800,1196 @@ var PeersSorter = class {
         if (this.lruPeers.size < tilesPerPage) {
           this.lruPeers.add(peer.id);
         }
-      });
-      if (!this.storeUnsubscribe) {
-        this.storeUnsubscribe = this.store.subscribe(this.onDominantSpeakerChange, yi);
-      }
-      this.moveSpeakerToFront(this.speaker);
-    });
-    __publicField(this, "onUpdate", (cb) => {
-      this.listeners.add(cb);
-    });
-    __publicField(this, "stop", () => {
-      var _a;
-      this.updateListeners();
-      this.listeners.clear();
-      (_a = this.storeUnsubscribe) == null ? void 0 : _a.call(this);
-    });
-    __publicField(this, "moveSpeakerToFront", (speaker) => {
-      if (!speaker) {
-        this.updateListeners();
-        return;
+      });
+      if (!this.storeUnsubscribe) {
+        this.storeUnsubscribe = this.store.subscribe(this.onDominantSpeakerChange, yi);
+      }
+      this.moveSpeakerToFront(this.speaker);
+    });
+    __publicField(this, "onUpdate", (cb) => {
+      this.listeners.add(cb);
+    });
+    __publicField(this, "stop", () => {
+      var _a;
+      this.updateListeners();
+      this.listeners.clear();
+      (_a = this.storeUnsubscribe) == null ? void 0 : _a.call(this);
+    });
+    __publicField(this, "moveSpeakerToFront", (speaker) => {
+      if (!speaker) {
+        this.updateListeners();
+        return;
+      }
+      if (this.lruPeers.has(speaker.id) && this.lruPeers.size <= this.tilesPerPage) {
+        this.updateListeners();
+        return;
+      }
+      this.lruPeers.delete(speaker.id);
+      let lruPeerArray = Array.from(this.lruPeers);
+      while (lruPeerArray.length >= this.tilesPerPage) {
+        lruPeerArray.pop();
+      }
+      this.lruPeers = /* @__PURE__ */ new Set([speaker.id, ...lruPeerArray]);
+      this.updateListeners();
+    });
+    __publicField(this, "onDominantSpeakerChange", (speaker) => {
+      var _a;
+      if (speaker && speaker.id !== ((_a = this == null ? void 0 : this.speaker) == null ? void 0 : _a.id)) {
+        this.speaker = speaker;
+        this.moveSpeakerToFront(speaker);
+      }
+    });
+    __publicField(this, "updateListeners", () => {
+      const orderedPeers = [];
+      this.lruPeers.forEach((key) => {
+        const peer = this.peers.get(key);
+        if (peer) {
+          orderedPeers.push(peer);
+        }
+      });
+      this.peers.forEach((peer) => {
+        if (!this.lruPeers.has(peer.id) && peer) {
+          orderedPeers.push(peer);
+        }
+      });
+      this.listeners.forEach((listener) => listener == null ? void 0 : listener(orderedPeers));
+    });
+    this.store = store;
+    this.peers = /* @__PURE__ */ new Map();
+    this.lruPeers = /* @__PURE__ */ new Set();
+    this.speaker = void 0;
+  }
+};
+var PeersSorter_default = PeersSorter;
+
+// src/Prebuilt/components/EqualProminence.jsx
+var aspectRatioConfig = { default: [1 / 1, 4 / 3, 16 / 9], mobile: [1 / 1, 3 / 4, 9 / 16] };
+function EqualProminence() {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const layout = useRoomLayout();
+  const { enable_local_tile_inset: isInsetEnabled = true } = (
+    //@ts-ignore
+    ((_e = (_d = (_c = (_b = (_a = layout == null ? void 0 : layout.screens) == null ? void 0 : _a.conferencing) == null ? void 0 : _b.default) == null ? void 0 : _c.elements) == null ? void 0 : _d.video_tile_layout) == null ? void 0 : _e.grid) || {}
+  );
+  const peers = useHMSStore12(isInsetEnabled ? selectRemotePeers2 : selectPeers2);
+  const [sortedPeers, setSortedPeers] = useState12(peers);
+  const localPeer = useHMSStore12(selectLocalPeer3);
+  const vanillaStore = useHMSVanillaStore2();
+  const isMobile = useMedia4(config.media.md);
+  let maxTileCount = useUISettings(UI_SETTINGS.maxTileCount);
+  maxTileCount = isMobile ? Math.min(maxTileCount, 6) : maxTileCount;
+  const [pagesWithTiles, setPagesWithTiles] = useState12([]);
+  const [page, setPage] = useState12(0);
+  const [ref, { width, height }] = useMeasure();
+  const peersSorter = useMemo2(() => new PeersSorter_default(vanillaStore), [vanillaStore]);
+  const pageSize = (_f = pagesWithTiles[0]) == null ? void 0 : _f.length;
+  useEffect5(() => {
+    if (page >= pagesWithTiles.length) {
+      setPage(0);
+    }
+  }, [pagesWithTiles.length, page]);
+  useEffect5(() => {
+    if (width === 0 || height === 0) {
+      return;
+    }
+    const tracksMap = vanillaStore.getState(selectTracksMap3);
+    const peersWithTiles = getPeersWithTiles(
+      sortedPeers.length === 0 ? [localPeer] : sortedPeers,
+      tracksMap,
+      () => false
+    );
+    const noOfPages = Math.ceil(peersWithTiles.length / maxTileCount);
+    let remaining = peersWithTiles.length;
+    let sliceStart = 0;
+    let pagesList = [];
+    for (let i = 0; i < noOfPages; i++) {
+      const count = Math.min(remaining, maxTileCount);
+      pagesList.push(peersWithTiles.slice(sliceStart, sliceStart + count));
+      remaining = remaining - count;
+      sliceStart += count;
+    }
+    for (const page2 of pagesList) {
+      const noOfTilesInPage = page2.length;
+      let maxCols = noOfTilesInPage > 2 && noOfTilesInPage < 9 ? Math.ceil(noOfTilesInPage / 2) : Math.ceil(Math.sqrt(noOfTilesInPage));
+      if (isMobile) {
+        maxCols = noOfTilesInPage < 4 ? 1 : Math.min(maxCols, 2);
+      }
+      let maxRows = Math.ceil(noOfTilesInPage / maxCols);
+      let index = 0;
+      const matrix = new Array(maxRows).fill(null).map((_3, i) => {
+        const numCols = Math.min(maxCols, noOfTilesInPage - i * maxCols);
+        let rowElements = [];
+        for (let j2 = 0; j2 < numCols; j2++) {
+          if (index < page2.length) {
+            rowElements.push(page2[index++]);
+          }
+        }
+        return rowElements;
+      });
+      const maxHeight = height - (maxRows - 1) * 8;
+      const maxRowHeight = maxHeight / matrix.length;
+      const aspectRatios = isMobile && (noOfTilesInPage === 1 || noOfTilesInPage > 3) ? aspectRatioConfig.mobile : aspectRatioConfig.default;
+      for (const row of matrix) {
+        let tileWidth = (width - (row.length - 1) * 8) / row.length;
+        let tileHeight = 0;
+        const calcHeights = aspectRatios.map((aR) => tileWidth / aR);
+        for (const h of calcHeights) {
+          if (h < maxRowHeight) {
+            if (tileHeight < h) {
+              tileHeight = h;
+            }
+          }
+        }
+        if (tileHeight === 0) {
+          tileHeight = maxRowHeight;
+          const calcWidths = aspectRatios.map((aR) => tileHeight * aR);
+          tileWidth = 0;
+          for (const w3 of calcWidths) {
+            if (w3 < width) {
+              if (tileWidth < w3) {
+                tileWidth = w3;
+              }
+            }
+          }
+        }
+        for (let i = 0; i < row.length; i++) {
+          row[i].width = tileWidth;
+          row[i].height = tileHeight;
+        }
+      }
+    }
+    setPagesWithTiles(pagesList);
+  }, [width, height, maxTileCount, vanillaStore, sortedPeers, page, isMobile, localPeer]);
+  useEffect5(() => {
+    if (page !== 0) {
+      return;
+    }
+    peersSorter.setPeersAndTilesPerPage({
+      peers,
+      tilesPerPage: pageSize || maxTileCount
+    });
+    peersSorter.onUpdate(setSortedPeers);
+  }, [page, peersSorter, peers, pageSize, maxTileCount]);
+  return /* @__PURE__ */ React25.createElement(Flex, { direction: "column", css: { flex: "1 1 0", h: "100%", position: "relative", minWidth: 0 } }, /* @__PURE__ */ React25.createElement(
+    Box,
+    {
+      ref,
+      css: {
+        flex: "1 1 0",
+        gap: "$4",
+        display: "flex",
+        placeContent: "center",
+        alignItems: "center",
+        justifyContent: "center",
+        flexFlow: "row wrap",
+        minHeight: 0
+      }
+    },
+    (_g = pagesWithTiles[page]) == null ? void 0 : _g.map((tile) => {
+      var _a2, _b2, _c2, _d2;
+      return /* @__PURE__ */ React25.createElement(
+        VideoTile_default,
+        {
+          key: ((_a2 = tile.track) == null ? void 0 : _a2.id) || ((_b2 = tile.peer) == null ? void 0 : _b2.id),
+          width: tile.width,
+          height: tile.height,
+          peerId: (_c2 = tile.peer) == null ? void 0 : _c2.id,
+          trackId: (_d2 = tile.track) == null ? void 0 : _d2.id,
+          rootCSS: { padding: 0 },
+          objectFit: "contain"
+        }
+      );
+    })
+  ), pagesWithTiles.length > 1 && /* @__PURE__ */ React25.createElement(Pagination, { page, onPageChange: setPage, numPages: pagesWithTiles.length }), isInsetEnabled && sortedPeers.length > 0 && /* @__PURE__ */ React25.createElement(InsetTile, null));
+}
+
+// src/Prebuilt/layouts/EmbedView.jsx
+init_define_process_env();
+import React30, { useCallback as useCallback8, useEffect as useEffect6, useMemo as useMemo4, useRef as useRef6, useState as useState13 } from "react";
+import { useMedia as useMedia6 } from "react-use";
+import {
+  selectLocalPeerID as selectLocalPeerID4,
+  selectLocalPeerRoleName as selectLocalPeerRoleName5,
+  selectPeers as selectPeers4,
+  selectPeerScreenSharing as selectPeerScreenSharing2,
+  throwErrorHandler,
+  useHMSStore as useHMSStore17,
+  useScreenShare as useScreenShare3
+} from "@100mslive/react-sdk";
+
+// src/Prebuilt/layouts/screenShareView.jsx
+init_define_process_env();
+import React29, { Fragment as Fragment5, useCallback as useCallback7, useMemo as useMemo3 } from "react";
+import { useMedia as useMedia5 } from "react-use";
+import {
+  selectLocalPeerID as selectLocalPeerID3,
+  selectLocalPeerRoleName as selectLocalPeerRoleName4,
+  selectPeers as selectPeers3,
+  selectPeerScreenSharing,
+  selectPeerSharingVideoPlaylist as selectPeerSharingVideoPlaylist2,
+  selectScreenShareByPeerID,
+  useHMSStore as useHMSStore16
+} from "@100mslive/react-sdk";
+
+// src/Prebuilt/components/Playlist/VideoPlayer.jsx
+init_define_process_env();
+import React27, { useRef as useRef5 } from "react";
+import { useFullscreen as useFullscreen2, useToggle } from "react-use";
+import screenfull2 from "screenfull";
+import {
+  selectVideoPlaylist as selectVideoPlaylist3,
+  selectVideoPlaylistAudioTrackByPeerID as selectVideoPlaylistAudioTrackByPeerID2,
+  selectVideoPlaylistVideoTrackByPeerID,
+  useHMSActions as useHMSActions10,
+  useHMSStore as useHMSStore15
+} from "@100mslive/react-sdk";
+import { CrossIcon as CrossIcon2, ExpandIcon as ExpandIcon3, ShrinkIcon } from "@100mslive/react-icons";
+
+// src/Prebuilt/components/Playlist/PlaylistControls.jsx
+init_define_process_env();
+import React26 from "react";
+import {
+  HMSPlaylistType as HMSPlaylistType2,
+  selectAudioPlaylist as selectAudioPlaylist2,
+  selectAudioTrackVolume,
+  selectPeerSharingVideoPlaylist,
+  selectVideoPlaylist as selectVideoPlaylist2,
+  selectVideoPlaylistAudioTrackByPeerID,
+  useHMSActions as useHMSActions9,
+  useHMSStore as useHMSStore14
+} from "@100mslive/react-sdk";
+import { NextIcon, PauseIcon, PlayIcon, PlaylistIcon, PrevIcon, SpeakerIcon } from "@100mslive/react-icons";
+
+// src/Prebuilt/components/hooks/usePlaylist.js
+init_define_process_env();
+import {
+  HMSPlaylistType,
+  selectAudioPlaylist,
+  selectVideoPlaylist,
+  useHMSActions as useHMSActions8,
+  useHMSStore as useHMSStore13
+} from "@100mslive/react-sdk";
+var usePlaylist = (type) => {
+  const isAudioPlaylist = type === HMSPlaylistType.audio;
+  const selector = isAudioPlaylist ? selectAudioPlaylist : selectVideoPlaylist;
+  const active = useHMSStore13(selector.selectedItem);
+  const selection = useHMSStore13(selector.selection);
+  const playlist = useHMSStore13(selector.list);
+  const hmsActions = useHMSActions8();
+  const playlistAction = isAudioPlaylist ? hmsActions.audioPlaylist : hmsActions.videoPlaylist;
+  return {
+    active,
+    hasNext: selection.hasNext,
+    hasPrevious: selection.hasPrevious,
+    actions: playlistAction,
+    list: playlist
+  };
+};
+
+// src/Prebuilt/components/Playlist/PlaylistControls.jsx
+var Progress = ({ type, duration }) => {
+  const selectPlaylist = type === HMSPlaylistType2.audio ? selectAudioPlaylist2 : selectVideoPlaylist2;
+  const progress = useHMSStore14(selectPlaylist.progress);
+  const hmsActions = useHMSActions9();
+  const playlistAction = type === HMSPlaylistType2.audio ? hmsActions.audioPlaylist : hmsActions.videoPlaylist;
+  if (!duration) {
+    return null;
+  }
+  return /* @__PURE__ */ React26.createElement(
+    Slider,
+    {
+      step: 1,
+      value: [progress],
+      onValueChange: (e) => {
+        playlistAction.seekTo(e[0] * 0.01 * duration);
+      }
+    }
+  );
+};
+var Controls = ({ type, css = {} }) => {
+  const { active, hasNext, hasPrevious, actions } = usePlaylist(type);
+  if (!active) {
+    return null;
+  }
+  return /* @__PURE__ */ React26.createElement(Flex, { justify: "center", css }, /* @__PURE__ */ React26.createElement(
+    IconButton,
+    {
+      disabled: !hasPrevious,
+      onClick: () => {
+        actions.playPrevious();
+      },
+      "data-testid": "playlist_prev_btn"
+    },
+    /* @__PURE__ */ React26.createElement(PrevIcon, null)
+  ), /* @__PURE__ */ React26.createElement(
+    IconButton,
+    {
+      onClick: () => {
+        active.playing ? actions.pause() : actions.play(active.id);
+      },
+      "data-testid": "playlist_play_pause_btn"
+    },
+    active.playing ? /* @__PURE__ */ React26.createElement(PauseIcon, { width: 32, height: 32 }) : /* @__PURE__ */ React26.createElement(PlayIcon, { width: 32, height: 32 })
+  ), /* @__PURE__ */ React26.createElement(
+    IconButton,
+    {
+      disabled: !hasNext,
+      onClick: () => {
+        actions.playNext();
+      },
+      "data-testid": "playlist_next_btn"
+    },
+    /* @__PURE__ */ React26.createElement(NextIcon, null)
+  ));
+};
+var VolumeControl = () => {
+  const hmsActions = useHMSActions9();
+  const volume = useHMSStore14(selectVideoPlaylist2.volume);
+  const active = useHMSStore14(selectVideoPlaylist2.selectedItem);
+  const peerSharingPlaylist = useHMSStore14(selectPeerSharingVideoPlaylist);
+  const audioTrack = useHMSStore14(selectVideoPlaylistAudioTrackByPeerID(peerSharingPlaylist == null ? void 0 : peerSharingPlaylist.id));
+  const audioTrackVolume = useHMSStore14(selectAudioTrackVolume(audioTrack == null ? void 0 : audioTrack.id));
+  const sliderVolume = active ? volume : audioTrackVolume;
+  return /* @__PURE__ */ React26.createElement(Flex, { align: "center", css: { color: "$on_primary_high" } }, /* @__PURE__ */ React26.createElement(SpeakerIcon, null), /* @__PURE__ */ React26.createElement(
+    Slider,
+    {
+      css: { mx: "$4", w: "$20" },
+      min: 0,
+      max: 100,
+      step: 1,
+      value: [Math.floor(sliderVolume != null ? sliderVolume : 100)],
+      onValueChange: (e) => {
+        const value = e[0];
+        if (active) {
+          hmsActions.videoPlaylist.setVolume(value);
+        } else if (audioTrack) {
+          hmsActions.setVolume(value, audioTrack.id);
+        }
+      },
+      thumbStyles: { w: "$6", h: "$6" }
+    }
+  ));
+};
+var VideoPlaylistControls = ({ children }) => {
+  const { active } = usePlaylist(HMSPlaylistType2.video);
+  return /* @__PURE__ */ React26.createElement(
+    Box,
+    {
+      css: {
+        p: "$8",
+        mt: "-$24",
+        w: "100%",
+        zIndex: 1,
+        "@lg": {
+          mt: 0,
+          p: "$6"
+        }
+      }
+    },
+    active && /* @__PURE__ */ React26.createElement(Progress, { type: HMSPlaylistType2.video, duration: active.duration }),
+    /* @__PURE__ */ React26.createElement(Flex, { align: "center", justify: "between" }, /* @__PURE__ */ React26.createElement(VolumeControl, null), active && /* @__PURE__ */ React26.createElement(Controls, { css: { flex: "1 1 0" } }), children)
+  );
+};
+
+// src/Prebuilt/components/Playlist/VideoPlayer.jsx
+var VideoPlayer = React27.memo(({ peerId }) => {
+  const videoTrack = useHMSStore15(selectVideoPlaylistVideoTrackByPeerID(peerId));
+  const audioTrack = useHMSStore15(selectVideoPlaylistAudioTrackByPeerID2(peerId));
+  const active = useHMSStore15(selectVideoPlaylist3.selectedItem);
+  const isAudioOnly = useUISettings(UI_SETTINGS.isAudioOnly);
+  const hmsActions = useHMSActions10();
+  const ref = useRef5(null);
+  const [show, toggle] = useToggle(false);
+  const isFullscreen = useFullscreen2(ref, show, {
+    onClose: () => toggle(false)
+  });
+  const showStatsOnTiles = useUISettings(UI_SETTINGS.showStatsOnTiles);
+  return /* @__PURE__ */ React27.createElement(Flex, { direction: "column", justify: "center", css: { w: "100%", h: "100%" }, ref }, active && /* @__PURE__ */ React27.createElement(
+    Flex,
+    {
+      justify: "between",
+      align: "center",
+      css: {
+        bg: "$surface_default",
+        p: "$2 $2 $2 $6",
+        borderTopLeftRadius: "$1",
+        borderTopRightRadius: "$1"
+      }
+    },
+    /* @__PURE__ */ React27.createElement(Text, { css: { color: "$on_primary_high" } }, active.name),
+    /* @__PURE__ */ React27.createElement(
+      IconButton,
+      {
+        css: {
+          color: "$on_primary_high"
+        },
+        onClick: () => {
+          hmsActions.videoPlaylist.stop();
+        },
+        "data-testid": "videoplaylist_cross_btn"
+      },
+      /* @__PURE__ */ React27.createElement(CrossIcon2, null)
+    )
+  ), showStatsOnTiles ? /* @__PURE__ */ React27.createElement(Box, { css: { "& > div": { top: "$14", left: "$8" } } }, /* @__PURE__ */ React27.createElement(
+    VideoTileStats,
+    {
+      audioTrackID: audioTrack == null ? void 0 : audioTrack.id,
+      videoTrackID: videoTrack == null ? void 0 : videoTrack.id,
+      peerID: peerId,
+      isLocal: active
+    }
+  )) : null, /* @__PURE__ */ React27.createElement(
+    Video,
+    {
+      trackId: videoTrack == null ? void 0 : videoTrack.id,
+      attach: !isAudioOnly,
+      css: {
+        objectFit: "contain",
+        h: "auto",
+        r: "$1",
+        borderTopLeftRadius: 0,
+        borderTopRightRadius: 0
+      }
+    }
+  ), /* @__PURE__ */ React27.createElement(VideoPlaylistControls, null, screenfull2.enabled && /* @__PURE__ */ React27.createElement(
+    IconButton,
+    {
+      onClick: () => toggle(),
+      css: {
+        color: "$on_primary_high",
+        height: "max-content",
+        alignSelf: "center",
+        cursor: "pointer"
+      }
+    },
+    isFullscreen ? /* @__PURE__ */ React27.createElement(ShrinkIcon, null) : /* @__PURE__ */ React27.createElement(ExpandIcon3, null)
+  )));
+});
+
+// src/Prebuilt/components/ScreenshareDisplay.jsx
+init_define_process_env();
+import React28 from "react";
+import { useHMSActions as useHMSActions11 } from "@100mslive/react-sdk";
+import { CrossIcon as CrossIcon3, ShareScreenIcon as ShareScreenIcon2 } from "@100mslive/react-icons";
+var ScreenshareDisplay = () => {
+  const hmsActions = useHMSActions11();
+  return /* @__PURE__ */ React28.createElement(
+    Flex,
+    {
+      direction: "column",
+      align: "center",
+      justify: "center",
+      css: {
+        position: "relative",
+        overflow: "hidden",
+        w: "37.5rem",
+        maxWidth: "80%",
+        h: "100%",
+        r: "$3",
+        m: "0 auto",
+        color: "$on_surface_high",
+        bg: "$background_default",
+        textAlign: "center"
+      }
+    },
+    /* @__PURE__ */ React28.createElement(ShareScreenIcon2, { width: 48, height: 48 }),
+    /* @__PURE__ */ React28.createElement(Text, { variant: "h5", css: { m: "$8 0", color: "$on_surface_high" } }, "You are sharing your screen"),
+    /* @__PURE__ */ React28.createElement(
+      Button,
+      {
+        variant: "danger",
+        onClick: () => __async(void 0, null, function* () {
+          yield hmsActions.setScreenShareEnabled(false);
+        }),
+        "data-testid": "stop_screen_share_btn"
+      },
+      /* @__PURE__ */ React28.createElement(CrossIcon3, { width: 18, height: 18 }),
+      "\xA0 Stop screen share"
+    )
+  );
+};
+
+// src/Prebuilt/layouts/screenShareView.jsx
+var ScreenShareView = () => {
+  var _a;
+  const mediaQueryLg = config.media.xl;
+  const showSidebarInBottom = useMedia5(mediaQueryLg);
+  const peers = useHMSStore16(selectPeers3);
+  const localPeerID = useHMSStore16(selectLocalPeerID3);
+  const localPeerRole = useHMSStore16(selectLocalPeerRoleName4);
+  const peerPresenting = useHMSStore16(selectPeerScreenSharing);
+  const peerSharingPlaylist = useHMSStore16(selectPeerSharingVideoPlaylist2);
+  const isPresenterFromMyRole = ((_a = peerPresenting == null ? void 0 : peerPresenting.roleName) == null ? void 0 : _a.toLowerCase()) === (localPeerRole == null ? void 0 : localPeerRole.toLowerCase());
+  const amIPresenting = localPeerID === (peerPresenting == null ? void 0 : peerPresenting.id);
+  const showPresenterInSmallTile = showSidebarInBottom || amIPresenting || isPresenterFromMyRole;
+  const smallTilePeers = useMemo3(() => {
+    const smallTilePeers2 = peers.filter((peer) => peer.id !== (peerPresenting == null ? void 0 : peerPresenting.id));
+    if (showPresenterInSmallTile && peerPresenting) {
+      smallTilePeers2.unshift(peerPresenting);
+    }
+    return smallTilePeers2;
+  }, [peers, peerPresenting, showPresenterInSmallTile]);
+  return /* @__PURE__ */ React29.createElement(
+    Flex,
+    {
+      css: {
+        size: "100%"
+      },
+      direction: showSidebarInBottom ? "column" : "row"
+    },
+    /* @__PURE__ */ React29.createElement(
+      ScreenShareComponent,
+      {
+        amIPresenting,
+        peerPresenting,
+        peerSharingPlaylist
+      }
+    ),
+    /* @__PURE__ */ React29.createElement(
+      Flex,
+      {
+        direction: { "@initial": "column", "@lg": "row" },
+        css: {
+          overflow: "hidden",
+          p: "$4 $8",
+          flex: "0 0 20%",
+          "@xl": {
+            flex: "1 1 0"
+          }
+        }
+      },
+      /* @__PURE__ */ React29.createElement(
+        SidePane,
+        {
+          showSidebarInBottom,
+          peerScreenSharing: peerPresenting,
+          isPresenterInSmallTiles: showPresenterInSmallTile,
+          smallTilePeers,
+          totalPeers: peers.length
+        }
+      )
+    )
+  );
+};
+var SidePane = ({
+  isPresenterInSmallTiles,
+  peerScreenSharing,
+  // the peer who is screensharing
+  smallTilePeers,
+  showSidebarInBottom
+}) => {
+  const shouldShowScreenFn = useCallback7(
+    (peer) => peerScreenSharing && peer.id !== peerScreenSharing.id,
+    [peerScreenSharing]
+  );
+  return /* @__PURE__ */ React29.createElement(Fragment5, null, !isPresenterInSmallTiles && /* @__PURE__ */ React29.createElement(LargeTilePeerView, { peerScreenSharing }), /* @__PURE__ */ React29.createElement(
+    SmallTilePeersView,
+    {
+      showSidebarInBottom,
+      smallTilePeers,
+      shouldShowScreenFn
+    }
+  ));
+};
+var ScreenShareComponent = ({ amIPresenting, peerPresenting, peerSharingPlaylist }) => {
+  const screenshareTrack = useHMSStore16(selectScreenShareByPeerID(peerPresenting == null ? void 0 : peerPresenting.id));
+  if (peerSharingPlaylist) {
+    return /* @__PURE__ */ React29.createElement(
+      Box,
+      {
+        css: {
+          flex: "3 1 0",
+          "@xl": {
+            flex: "2 1 0",
+            display: "flex",
+            alignItems: "center"
+          }
+        }
+      },
+      /* @__PURE__ */ React29.createElement(VideoPlayer, { peerId: peerSharingPlaylist.id })
+    );
+  }
+  return /* @__PURE__ */ React29.createElement(
+    Box,
+    {
+      css: {
+        flex: "3 1 0",
+        "@xl": { ml: "$4", maxHeight: "80%", minHeight: 0 }
       }
-      if (this.lruPeers.has(speaker.id) && this.lruPeers.size <= this.tilesPerPage) {
-        this.updateListeners();
-        return;
+    },
+    peerPresenting && (amIPresenting && !["browser", "window", "application"].includes(screenshareTrack == null ? void 0 : screenshareTrack.displaySurface) ? /* @__PURE__ */ React29.createElement(Box, { css: { objectFit: "contain", h: "100%" } }, /* @__PURE__ */ React29.createElement(ScreenshareDisplay, null)) : /* @__PURE__ */ React29.createElement(ScreenshareTile_default, { peerId: peerPresenting == null ? void 0 : peerPresenting.id }))
+  );
+};
+var SmallTilePeersView = ({ smallTilePeers, shouldShowScreenFn, showSidebarInBottom }) => {
+  return /* @__PURE__ */ React29.createElement(
+    Flex,
+    {
+      css: {
+        flex: "2 1 0"
       }
-      this.lruPeers.delete(speaker.id);
-      let lruPeerArray = Array.from(this.lruPeers);
-      while (lruPeerArray.length >= this.tilesPerPage) {
-        lruPeerArray.pop();
+    },
+    smallTilePeers && smallTilePeers.length > 0 && /* @__PURE__ */ React29.createElement(
+      VideoList_default,
+      {
+        peers: smallTilePeers,
+        maxColCount: showSidebarInBottom ? void 0 : 1,
+        maxRowCount: showSidebarInBottom ? 1 : void 0,
+        includeScreenShareForPeer: shouldShowScreenFn
       }
-      this.lruPeers = /* @__PURE__ */ new Set([speaker.id, ...lruPeerArray]);
-      this.updateListeners();
-    });
-    __publicField(this, "onDominantSpeakerChange", (speaker) => {
-      var _a;
-      if (speaker && speaker.id !== ((_a = this == null ? void 0 : this.speaker) == null ? void 0 : _a.id)) {
-        this.speaker = speaker;
-        this.moveSpeakerToFront(speaker);
+    )
+  );
+};
+var LargeTilePeerView = ({ peerScreenSharing, showStatsOnTiles }) => {
+  return peerScreenSharing ? /* @__PURE__ */ React29.createElement(
+    Box,
+    {
+      css: {
+        flex: "1 1 0",
+        minHeight: "25%",
+        py: "$4",
+        "@lg": {
+          mr: "$4",
+          minHeight: "unset",
+          py: 0
+        },
+        "@sm": {
+          height: "100%",
+          maxHeight: "75%",
+          alignSelf: "center"
+        }
       }
-    });
-    __publicField(this, "updateListeners", () => {
-      const orderedPeers = [];
-      this.lruPeers.forEach((key) => {
-        const peer = this.peers.get(key);
-        if (peer) {
-          orderedPeers.push(peer);
+    },
+    /* @__PURE__ */ React29.createElement(VideoTile_default, { showStatsOnTiles, width: "100%", height: "100%", peerId: peerScreenSharing.id })
+  ) : null;
+};
+var screenShareView_default = ScreenShareView;
+
+// src/Prebuilt/layouts/EmbedView.jsx
+var EmbedView = () => {
+  return /* @__PURE__ */ React30.createElement(EmbebScreenShareView, null, /* @__PURE__ */ React30.createElement(EmbedComponent, null));
+};
+var EmbebScreenShareView = ({ children }) => {
+  var _a;
+  const peers = useHMSStore17(selectPeers4);
+  const mediaQueryLg = config.media.xl;
+  const showSidebarInBottom = useMedia6(mediaQueryLg);
+  const localPeerID = useHMSStore17(selectLocalPeerID4);
+  const localPeerRole = useHMSStore17(selectLocalPeerRoleName5);
+  const peerPresenting = useHMSStore17(selectPeerScreenSharing2);
+  const isPresenterFromMyRole = ((_a = peerPresenting == null ? void 0 : peerPresenting.roleName) == null ? void 0 : _a.toLowerCase()) === (localPeerRole == null ? void 0 : localPeerRole.toLowerCase());
+  const amIPresenting = localPeerID === (peerPresenting == null ? void 0 : peerPresenting.id);
+  const showPresenterInSmallTile = showSidebarInBottom || amIPresenting || isPresenterFromMyRole;
+  const smallTilePeers = useMemo4(() => {
+    const smallTilePeers2 = peers.filter((peer) => peer.id !== (peerPresenting == null ? void 0 : peerPresenting.id));
+    if (showPresenterInSmallTile && peerPresenting) {
+      smallTilePeers2.unshift(peerPresenting);
+    }
+    return smallTilePeers2;
+  }, [peers, peerPresenting, showPresenterInSmallTile]);
+  return /* @__PURE__ */ React30.createElement(Flex, { css: { size: "100%" }, direction: showSidebarInBottom ? "column" : "row" }, children, /* @__PURE__ */ React30.createElement(
+    Flex,
+    {
+      direction: { "@initial": "column", "@lg": "row" },
+      css: {
+        overflow: "hidden",
+        p: "$4 $8",
+        flex: "0 0 20%",
+        "@xl": {
+          flex: "1 1 0"
         }
+      }
+    },
+    /* @__PURE__ */ React30.createElement(
+      SidePane,
+      {
+        showSidebarInBottom,
+        peerScreenSharing: peerPresenting,
+        isPresenterInSmallTiles: showPresenterInSmallTile,
+        smallTilePeers,
+        totalPeers: peers.length
+      }
+    )
+  ));
+};
+var EmbedComponent = () => {
+  const { amIScreenSharing, toggleScreenShare } = useScreenShare3(throwErrorHandler);
+  const [embedConfig, setEmbedConfig] = useSetAppDataByKey(APP_DATA.embedConfig);
+  const [wasScreenShared, setWasScreenShared] = useState13(false);
+  const screenShareAttemptInProgress = useRef6(false);
+  const src = embedConfig.url;
+  const iframeRef = useRef6();
+  const resetEmbedConfig = useCallback8(() => {
+    if (src) {
+      setEmbedConfig({ url: "" });
+    }
+  }, [src, setEmbedConfig]);
+  useEffect6(() => {
+    if (embedConfig.shareScreen && !amIScreenSharing && !wasScreenShared && !screenShareAttemptInProgress.current) {
+      screenShareAttemptInProgress.current = true;
+      toggleScreenShare({
+        forceCurrentTab: true,
+        cropElement: iframeRef.current
+      }).then(() => {
+        setWasScreenShared(true);
+      }).catch(resetEmbedConfig).finally(() => {
+        screenShareAttemptInProgress.current = false;
       });
-      this.peers.forEach((peer) => {
-        if (!this.lruPeers.has(peer.id) && peer) {
-          orderedPeers.push(peer);
+    }
+  }, []);
+  useEffect6(() => {
+    if (wasScreenShared && !amIScreenSharing) {
+      resetEmbedConfig();
+    }
+    return () => {
+      if (wasScreenShared && amIScreenSharing) {
+        resetEmbedConfig();
+        toggleScreenShare();
+      }
+    };
+  }, [wasScreenShared, amIScreenSharing, resetEmbedConfig, toggleScreenShare]);
+  return /* @__PURE__ */ React30.createElement(
+    Box,
+    {
+      ref: iframeRef,
+      css: {
+        flex: "3 1 0",
+        "@lg": {
+          flex: "2 1 0",
+          display: "flex",
+          alignItems: "center"
         }
-      });
-      this.listeners.forEach((listener) => listener == null ? void 0 : listener(orderedPeers));
-    });
-    this.store = store;
-    this.peers = /* @__PURE__ */ new Map();
-    this.lruPeers = /* @__PURE__ */ new Set();
-    this.speaker = void 0;
-  }
+      }
+    },
+    /* @__PURE__ */ React30.createElement(
+      "iframe",
+      {
+        src,
+        title: src,
+        style: { width: "100%", height: "100%", border: 0 },
+        allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture fullscreen",
+        referrerPolicy: "no-referrer"
+      }
+    )
+  );
 };
-var PeersSorter_default = PeersSorter;
 
-// src/Prebuilt/common/useSortedPeers.js
-function useSortedPeers({ peers, maxTileCount = 9 }) {
-  const [sortedPeers, setSortedPeers] = useState4([]);
-  const store = useHMSVanillaStore();
-  const activeSpeakerSorting = useActiveSpeakerSorting();
-  const peerSortedRef = useRef2(new PeersSorter_default(store));
-  peerSortedRef.current.onUpdate(setSortedPeers);
-  useEffect(() => {
-    const peersSorter = peerSortedRef.current;
-    if ((peers == null ? void 0 : peers.length) > 0 && maxTileCount && activeSpeakerSorting) {
-      peersSorter.setPeersAndTilesPerPage({
-        peers,
-        tilesPerPage: maxTileCount
-      });
-    } else if (!activeSpeakerSorting) {
-      peersSorter.stop();
+// src/Prebuilt/layouts/PDFView.jsx
+init_define_process_env();
+import React31, { useCallback as useCallback9, useEffect as useEffect7, useRef as useRef7, useState as useState14 } from "react";
+import { throwErrorHandler as throwErrorHandler2, useScreenShare as useScreenShare4 } from "@100mslive/react-sdk";
+var PDFView = () => {
+  return /* @__PURE__ */ React31.createElement(EmbebScreenShareView, null, /* @__PURE__ */ React31.createElement(PDFEmbedComponent, null));
+};
+var PDFEmbedComponent = () => {
+  const ref = useRef7();
+  const themeType = useTheme().themeType;
+  const [isPDFLoaded, setIsPDFLoaded] = useState14(false);
+  let pdfJSURL = define_process_env_default.REACT_APP_PDFJS_IFRAME_URL;
+  const { amIScreenSharing, toggleScreenShare } = useScreenShare4(throwErrorHandler2);
+  const [pdfConfig, setPDFConfig] = useSetAppDataByKey(APP_DATA.pdfConfig);
+  if (pdfConfig.url && !pdfConfig.file) {
+    pdfJSURL = pdfJSURL + "?file=" + encodeURIComponent(pdfConfig.url);
+  }
+  const [wasScreenShared, setWasScreenShared] = useState14(false);
+  const screenShareAttemptInProgress = useRef7(false);
+  const iframeRef = useRef7();
+  const resetEmbedConfig = useCallback9(() => {
+    setPDFConfig({ state: false });
+  }, [setPDFConfig]);
+  useEffect7(() => {
+    if (isPDFLoaded && ref.current) {
+      ref.current.contentWindow.postMessage(
+        {
+          theme: themeType === ThemeTypes.dark ? 2 : 1
+        },
+        "*"
+      );
     }
-  }, [maxTileCount, peers, activeSpeakerSorting]);
-  return activeSpeakerSorting ? sortedPeers : peers;
-}
-var useSortedPeers_default = useSortedPeers;
-
-// src/Prebuilt/components/VideoList.jsx
-var List = ({ maxTileCount, peers, maxColCount, maxRowCount, includeScreenShareForPeer }) => {
-  var _a;
-  const { aspectRatio } = useTheme();
-  const tileOffset = useAppConfig("headlessConfig", "tileOffset");
-  const isHeadless = useIsHeadless();
-  const hideLocalVideo = useUISettings(UI_SETTINGS.hideLocalVideo);
-  const localPeerId = useHMSStore5(selectLocalPeerID4);
-  let sortedPeers = useSortedPeers_default({ peers, maxTileCount });
-  if (hideLocalVideo && sortedPeers.length > 1) {
-    sortedPeers = filterPeerId(sortedPeers, localPeerId);
-  }
-  const { ref, pagesWithTiles } = useVideoList({
-    peers: sortedPeers,
-    maxTileCount,
-    maxColCount,
-    maxRowCount,
-    includeScreenShareForPeer,
-    aspectRatio,
-    offsetY: getOffset({ isHeadless, tileOffset })
-  });
-  const [page, setPage] = useState5(0);
-  useEffect2(() => {
-    if (page >= pagesWithTiles.length) {
-      setPage(0);
+  }, [isPDFLoaded, themeType]);
+  useEffect7(() => {
+    if (!amIScreenSharing && !wasScreenShared && !screenShareAttemptInProgress.current) {
+      screenShareAttemptInProgress.current = true;
+      toggleScreenShare({
+        forceCurrentTab: isChrome,
+        cropElement: iframeRef.current,
+        preferCurrentTab: isChrome
+      }).then(() => {
+        setWasScreenShared(true);
+      }).catch(resetEmbedConfig).finally(() => {
+        screenShareAttemptInProgress.current = false;
+      });
     }
-  }, [pagesWithTiles.length, page]);
-  return /* @__PURE__ */ React6.createElement(StyledVideoList.Root, { ref }, /* @__PURE__ */ React6.createElement(StyledVideoList.Container, { css: { flexWrap: "wrap", placeContent: "center" } }, pagesWithTiles && pagesWithTiles.length > 0 ? (_a = pagesWithTiles[page]) == null ? void 0 : _a.map((tile) => {
-    var _a2, _b, _c, _d;
-    if (tile.width === 0 || tile.height === 0) {
-      return null;
+  }, []);
+  useEffect7(() => {
+    if (wasScreenShared && !amIScreenSharing) {
+      resetEmbedConfig();
     }
-    return /* @__PURE__ */ React6.createElement(Fragment3, { key: ((_a2 = tile.track) == null ? void 0 : _a2.id) || tile.peer.id }, ((_b = tile.track) == null ? void 0 : _b.source) === "screen" ? /* @__PURE__ */ React6.createElement(ScreenshareTile_default, { width: tile.width, height: tile.height, peerId: tile.peer.id }) : /* @__PURE__ */ React6.createElement(
-      VideoTile_default,
+    return () => {
+      if (wasScreenShared && amIScreenSharing) {
+        resetEmbedConfig();
+        toggleScreenShare();
+      }
+    };
+  }, [wasScreenShared, amIScreenSharing, resetEmbedConfig, toggleScreenShare]);
+  return /* @__PURE__ */ React31.createElement(
+    Box,
+    {
+      ref: iframeRef,
+      css: {
+        flex: "3 1 0",
+        "@lg": {
+          flex: "2 1 0",
+          display: "flex",
+          alignItems: "center"
+        }
+      }
+    },
+    /* @__PURE__ */ React31.createElement(
+      "iframe",
       {
-        width: tile.width,
-        height: tile.height,
-        peerId: (_c = tile.peer) == null ? void 0 : _c.id,
-        trackId: (_d = tile.track) == null ? void 0 : _d.id
+        src: pdfJSURL,
+        title: "PDF Annotator",
+        ref,
+        style: {
+          width: "100%",
+          height: "100%",
+          border: 0,
+          borderRadius: "0.75rem"
+        },
+        allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture fullscreen",
+        referrerPolicy: "no-referrer",
+        onLoad: () => {
+          if (ref.current && pdfConfig.file) {
+            requestAnimationFrame(() => {
+              ref.current.contentWindow.postMessage(
+                {
+                  file: pdfConfig.file,
+                  theme: themeType === ThemeTypes.dark ? 2 : 1
+                },
+                "*"
+              );
+              setIsPDFLoaded(true);
+            }, 1e3);
+          }
+        }
       }
-    ));
-  }) : null), !isHeadless && pagesWithTiles.length > 1 ? /* @__PURE__ */ React6.createElement(Pagination, { page, setPage, numPages: pagesWithTiles.length }) : null);
-};
-var VideoList = React6.memo(List);
-function filterPeerId(peers, peerId) {
-  const oldPeers = peers;
-  let foundPeerToFilterOut = false;
-  peers = [];
-  for (let i = 0; i < oldPeers.length; i++) {
-    if (oldPeers[i].id === peerId) {
-      foundPeerToFilterOut = true;
-    } else {
-      peers.push(oldPeers[i]);
-    }
-  }
-  if (!foundPeerToFilterOut) {
-    peers = oldPeers;
-  }
-  return peers;
-}
-var getOffset = ({ tileOffset, isHeadless }) => {
-  if (!isHeadless || isNaN(Number(tileOffset))) {
-    return 32;
-  }
-  return Number(tileOffset);
+    )
+  );
 };
-var VideoList_default = VideoList;
 
-// src/Prebuilt/components/gridView.jsx
-var MAX_TILES_FOR_MOBILE = 4;
-var webinarProps = JSON.parse(define_process_env_default.REACT_APP_WEBINAR_PROPS || "{}");
-var eventRoomIDs = (webinarProps == null ? void 0 : webinarProps.ROOM_IDS) || [];
-var eventsImg = (webinarProps == null ? void 0 : webinarProps.IMAGE_FILE) || "";
-var webinarInfoLink = (webinarProps == null ? void 0 : webinarProps.LINK_HREF) || "https://100ms.live/";
-var GridCenterView = ({ peers, maxTileCount }) => {
-  const mediaQueryLg = config.media.md;
-  const limitMaxTiles = useMedia(mediaQueryLg);
-  const headlessConfig = useAppConfig("headlessConfig");
-  const isHeadless = useIsHeadless();
-  return /* @__PURE__ */ React7.createElement(Fragment4, null, /* @__PURE__ */ React7.createElement(
+// src/Prebuilt/layouts/WaitingView.jsx
+init_define_process_env();
+import React32 from "react";
+import { ColoredTimeIcon } from "@100mslive/react-icons";
+var WaitingView = React32.memo(() => {
+  return /* @__PURE__ */ React32.createElement(
     Box,
     {
       css: {
-        flex: "1 1 0",
-        height: "100%",
-        mx: isHeadless && Number(headlessConfig == null ? void 0 : headlessConfig.tileOffset) === 0 ? "0" : "$8",
-        "@md": { flex: "2 1 0" }
-      }
+        overflow: "hidden",
+        w: "96%",
+        maxWidth: "96%",
+        h: "100%",
+        m: "auto",
+        background: "$surface_default",
+        borderRadius: "$3"
+      },
+      "data-testid": "waiting_view"
     },
-    peers && peers.length > 0 ? /* @__PURE__ */ React7.createElement(VideoList_default, { peers, maxTileCount: limitMaxTiles ? MAX_TILES_FOR_MOBILE : maxTileCount }) : eventRoomIDs.some((id) => window.location.href.includes(id)) ? /* @__PURE__ */ React7.createElement(
-      Box,
+    /* @__PURE__ */ React32.createElement(
+      Flex,
       {
+        align: "center",
+        direction: "column",
         css: {
-          display: "grid",
-          placeItems: "center",
-          size: "100%",
-          p: "$12"
+          w: "$96",
+          textAlign: "center",
+          margin: "auto",
+          h: "100%",
+          justifyContent: "center",
+          gap: "$8"
         }
       },
-      /* @__PURE__ */ React7.createElement("a", { href: webinarInfoLink, target: "_blank", rel: "noreferrer" }, /* @__PURE__ */ React7.createElement(Image, { css: { p: "$4", boxShadow: "$sm" }, alt: "Event template", src: eventsImg }))
-    ) : /* @__PURE__ */ React7.createElement(FirstPersonDisplay, null)
+      /* @__PURE__ */ React32.createElement(ColoredTimeIcon, { width: "80px", height: "80px" }),
+      /* @__PURE__ */ React32.createElement(
+        Flex,
+        {
+          direction: "column",
+          css: {
+            w: "$80",
+            p: "$1",
+            gap: "$4"
+          }
+        },
+        /* @__PURE__ */ React32.createElement(Text, { color: "white", variant: "h6", css: { "@md": { fontSize: "$md" } } }, "Please wait"),
+        /* @__PURE__ */ React32.createElement(Text, { color: "$on_surface_medium", css: { mt: "$4", "@md": { fontSize: "$sm" } } }, "Sit back and relax till others let you join.")
+      )
+    )
+  );
+});
+
+// src/Prebuilt/plugins/whiteboard/index.js
+init_define_process_env();
+
+// src/Prebuilt/layouts/mainView.jsx
+var HLSView = React33.lazy(() => import("./HLSView-P57IRMAR.js"));
+var PinnedTrackView = React33.lazy(() => import("./PinnedTrackView-4FYJEBTB.js"));
+var ConferenceMainView = () => {
+  const localPeerRole = useHMSStore18(selectLocalPeerRoleName6);
+  const pinnedTrack = usePinnedTrack();
+  const peerSharing = useHMSStore18(selectPeerScreenSharing3);
+  const peerSharingAudio = useHMSStore18(selectPeerSharingAudio);
+  const peerSharingPlaylist = useHMSStore18(selectPeerSharingVideoPlaylist3);
+  const { whiteboardOwner: whiteboardShared } = useWhiteboardMetadata();
+  const isConnected = useHMSStore18(selectIsConnectedToRoom2);
+  const hmsActions = useHMSActions12();
+  const { isAudioOnly } = useUISettings();
+  const hlsViewerRole = useHLSViewerRole();
+  const waitingViewerRole = useWaitingViewerRole();
+  const urlToIframe = useUrlToEmbed();
+  const pdfAnnotatorActive = usePDFAnnotator();
+  const { isHLSRunning } = useRecordingStreaming3();
+  const [isHLSStarted, setHLSStarted] = useSetAppDataByKey(APP_DATA.hlsStarted);
+  const permissions = useHMSStore18(selectPermissions3);
+  const showStreamingUI = useShowStreamingUI();
+  const startHLS = useCallback10(() => __async(void 0, null, function* () {
+    try {
+      if (isHLSStarted) {
+        return;
+      }
+      setHLSStarted(true);
+      yield hmsActions.startHLSStreaming({});
+    } catch (error) {
+      if (error.message === "beam already started") {
+        return;
+      }
+      if (error.message.includes("invalid input")) {
+        yield startHLS();
+        return;
+      }
+      setHLSStarted(false);
+    }
+  }), [hmsActions, isHLSStarted, setHLSStarted]);
+  useEffect8(() => {
+    if (!isConnected) {
+      return;
+    }
+    if ((permissions == null ? void 0 : permissions.hlsStreaming) && !isHLSRunning && showStreamingUI) {
+      startHLS();
+    }
+  }, [isConnected]);
+  useEffect8(() => {
+    if (!isConnected) {
+      return;
+    }
+    const audioPlaylist = JSON.parse(define_process_env_default.REACT_APP_AUDIO_PLAYLIST || "[]");
+    const videoPlaylist = JSON.parse(define_process_env_default.REACT_APP_VIDEO_PLAYLIST || "[]");
+    if (videoPlaylist.length > 0) {
+      hmsActions.videoPlaylist.setList(videoPlaylist);
+    }
+    if (audioPlaylist.length > 0) {
+      hmsActions.audioPlaylist.setList(audioPlaylist);
+    }
+    hmsActions.sessionStore.observe([SESSION_STORE_KEY.PINNED_MESSAGE, SESSION_STORE_KEY.SPOTLIGHT]);
+  }, [isConnected, hmsActions]);
+  if (!localPeerRole) {
+    return null;
+  }
+  let ViewComponent;
+  if (localPeerRole === hlsViewerRole) {
+    ViewComponent = HLSView;
+  } else if (localPeerRole === waitingViewerRole) {
+    ViewComponent = WaitingView;
+  } else if (pdfAnnotatorActive) {
+    ViewComponent = PDFView;
+  } else if (urlToIframe) {
+    ViewComponent = EmbedView;
+  } else if (whiteboardShared) {
+  } else if ((peerSharing && peerSharing.id !== (peerSharingAudio == null ? void 0 : peerSharingAudio.id) || peerSharingPlaylist) && !isAudioOnly) {
+    ViewComponent = screenShareView_default;
+  } else if (pinnedTrack) {
+    ViewComponent = PinnedTrackView;
+  } else {
+    ViewComponent = EqualProminence;
+  }
+  return /* @__PURE__ */ React33.createElement(Suspense2, { fallback: /* @__PURE__ */ React33.createElement(FullPageProgress_default, null) }, /* @__PURE__ */ React33.createElement(
+    Flex,
+    {
+      css: {
+        size: "100%",
+        position: "relative"
+      }
+    },
+    /* @__PURE__ */ React33.createElement(ViewComponent, null),
+    /* @__PURE__ */ React33.createElement(SidePane_default, null)
   ));
 };
-var GridSidePaneView = ({ peers }) => {
-  const headlessConfig = useAppConfig("headlessConfig");
+
+// src/Prebuilt/components/RoleChangeRequestModal.jsx
+init_define_process_env();
+import React34 from "react";
+import { selectRoleChangeRequest, useHMSActions as useHMSActions13, useHMSStore as useHMSStore19 } from "@100mslive/react-sdk";
+var RoleChangeRequestModal = () => {
+  var _a, _b;
+  const hmsActions = useHMSActions13();
   const isHeadless = useIsHeadless();
-  return /* @__PURE__ */ React7.createElement(
-    Flex,
+  const roleChangeRequest = useHMSStore19(selectRoleChangeRequest);
+  if (!(roleChangeRequest == null ? void 0 : roleChangeRequest.role) || isHeadless) {
+    return null;
+  }
+  return /* @__PURE__ */ React34.createElement(
+    RequestDialog,
     {
-      direction: "column",
+      title: "Role Change Request",
+      onOpenChange: (value) => !value && hmsActions.rejectChangeRole(roleChangeRequest),
+      body: `${(_a = roleChangeRequest == null ? void 0 : roleChangeRequest.requestedBy) == null ? void 0 : _a.name} has requested you to change your role to ${(_b = roleChangeRequest == null ? void 0 : roleChangeRequest.role) == null ? void 0 : _b.name}.`,
+      onAction: () => {
+        hmsActions.acceptChangeRole(roleChangeRequest);
+      },
+      actionText: "Accept"
+    }
+  );
+};
+
+// src/Prebuilt/components/conference.jsx
+var Conference = () => {
+  var _a, _b;
+  const navigate = useNavigation();
+  const { roomId, role } = useParams();
+  const isHeadless = useIsHeadless();
+  const roomState = useHMSStore20(selectRoomState);
+  const prevState = usePrevious(roomState);
+  const isConnectedToRoom = useHMSStore20(selectIsConnectedToRoom3);
+  const hmsActions = useHMSActions14();
+  const [hideControls, setHideControls] = useState15(false);
+  const dropdownList = useHMSStore20(selectAppData2(APP_DATA.dropdownList));
+  const skipPreview = useSkipPreview();
+  const { showPreview } = useHMSPrebuiltContext();
+  const authTokenInAppData = useAuthToken();
+  const headerRef = useRef8();
+  const footerRef = useRef8();
+  const dropdownListRef = useRef8();
+  const performAutoHide = hideControls && (isAndroid || isIOS || isIPadOS);
+  const [isHLSStarted] = useSetAppDataByKey(APP_DATA.hlsStarted);
+  const toggleControls = () => {
+    var _a2;
+    if (((_a2 = dropdownListRef.current) == null ? void 0 : _a2.length) === 0) {
+      setHideControls((value) => !value);
+    }
+  };
+  useEffect9(() => {
+    let timeout = null;
+    dropdownListRef.current = dropdownList || [];
+    if (dropdownListRef.current.length === 0) {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        if (dropdownListRef.current.length === 0) {
+          setHideControls(true);
+        }
+      }, 5e3);
+    }
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [dropdownList, hideControls]);
+  useEffect9(() => {
+    if (!roomId) {
+      navigate(`/`);
+      return;
+    }
+    if (!showPreview) {
+      return;
+    }
+    if (!prevState && !(roomState === HMSRoomState.Connecting || roomState === HMSRoomState.Reconnecting || isConnectedToRoom)) {
+      if (role)
+        navigate(`/preview/${roomId || ""}/${role}`);
+      else
+        navigate(`/preview/${roomId || ""}`);
+    }
+  }, [isConnectedToRoom, prevState, roomState, navigate, role, roomId, showPreview]);
+  useEffect9(() => {
+    if (authTokenInAppData && !isConnectedToRoom && !showPreview && roomState !== HMSRoomState.Connecting) {
+      hmsActions.join({
+        userName: "Test",
+        authToken: authTokenInAppData,
+        initEndpoint: define_process_env_default.REACT_APP_ENV ? `https://${define_process_env_default.REACT_APP_ENV}-init.100ms.live/init` : void 0,
+        initialSettings: {
+          isAudioMuted: skipPreview,
+          isVideoMuted: skipPreview,
+          speakerAutoSelectionBlacklist: ["Yeti Stereo Microphone"]
+        }
+      }).catch(console.error);
+    }
+  }, [authTokenInAppData, skipPreview, hmsActions, isConnectedToRoom, showPreview, roomState]);
+  useEffect9(() => {
+    if (isHeadless) {
+      hmsActions.ignoreMessageTypes(["chat", EMOJI_REACTION_TYPE]);
+    }
+  }, [isHeadless, hmsActions]);
+  useEffect9(() => {
+    return () => {
+      PictureInPicture.stop().catch((error) => console.error("stopping pip", error));
+    };
+  }, []);
+  if (!isConnectedToRoom) {
+    return /* @__PURE__ */ React35.createElement(FullPageProgress_default, { loadingText: "Joining..." });
+  }
+  if (isHLSStarted) {
+    return /* @__PURE__ */ React35.createElement(FullPageProgress_default, { loadingText: "Starting live stream..." });
+  }
+  return /* @__PURE__ */ React35.createElement(Flex, { css: { size: "100%", overflow: "hidden" }, direction: "column" }, !isHeadless && /* @__PURE__ */ React35.createElement(
+    Box,
+    {
+      ref: headerRef,
       css: {
-        flex: "0 0 20%",
-        mx: isHeadless && Number(headlessConfig == null ? void 0 : headlessConfig.tileOffset) === 0 ? "0" : "$8",
+        h: "$18",
+        transition: "margin 0.3s ease-in-out",
+        marginTop: performAutoHide ? `-${(_a = headerRef.current) == null ? void 0 : _a.clientHeight}px` : "none",
+        "@md": {
+          h: "$17"
+        }
+      },
+      "data-testid": "header"
+    },
+    /* @__PURE__ */ React35.createElement(Header, null)
+  ), /* @__PURE__ */ React35.createElement(
+    Box,
+    {
+      css: {
+        w: "100%",
+        flex: "1 1 0",
+        minHeight: 0,
+        px: "$10",
+        paddingBottom: "env(safe-area-inset-bottom)",
         "@lg": {
-          flex: "0 0 25%"
-        },
+          px: "$4"
+        }
+      },
+      id: "conferencing",
+      "data-testid": "conferencing",
+      onClick: toggleControls
+    },
+    /* @__PURE__ */ React35.createElement(ConferenceMainView, null)
+  ), !isHeadless && /* @__PURE__ */ React35.createElement(
+    Box,
+    {
+      ref: footerRef,
+      css: {
+        flexShrink: 0,
+        maxHeight: "$24",
+        transition: "margin 0.3s ease-in-out",
+        marginBottom: performAutoHide ? `-${(_b = footerRef.current) == null ? void 0 : _b.clientHeight}px` : void 0,
         "@md": {
-          flex: "1 1 0"
+          maxHeight: "unset"
         }
-      }
+      },
+      "data-testid": "footer"
     },
-    /* @__PURE__ */ React7.createElement(Flex, { css: { flex: "1 1 0" }, align: "end" }, peers && peers.length > 0 && /* @__PURE__ */ React7.createElement(VideoList_default, { peers, maxColCount: 1 }))
-  );
+    /* @__PURE__ */ React35.createElement(Footer2, null)
+  ), /* @__PURE__ */ React35.createElement(RoleChangeRequestModal, null), /* @__PURE__ */ React35.createElement(HLSFailureModal, null), /* @__PURE__ */ React35.createElement(ActivatedPIP, null));
 };
-
+var conference_default = Conference;
 export {
-  ScreenshareTile_default,
-  useAppConfig,
-  VideoTile_default,
-  VideoList_default,
-  FirstPersonDisplay,
-  GridCenterView,
-  GridSidePaneView
+  conference_default as default
 };
-//# sourceMappingURL=chunk-ESUJK7AT.js.map
+//# sourceMappingURL=conference-P6I6ESVF.js.map