@whereby.com/core 0.29.0 → 0.29.2

package/dist/legacy-esm.js

@@ -0,0 +1,3888 @@
+import { createAsyncThunk, createListenerMiddleware, addListener, createSlice, createAction, createSelector, isAnyOf, combineReducers, configureStore } from '@reduxjs/toolkit';
+import { ServerSocket, getDeviceData, getStream, getUpdatedDevices, RtcManagerDispatcher, setClientProvider, subscribeIssues, assert, fromLocation } from '@whereby.com/media';
+import { Safari12 } from 'mediasoup-client/lib/handlers/Safari12.js';
+import { EventEmitter } from 'events';
+import nodeBtoa from 'btoa';
+import axios from 'axios';
+
+function createAppAsyncThunk(typePrefix, payloadCreator) {
+    return createAsyncThunk(typePrefix, payloadCreator);
+}
+function createAppThunk(thunk) {
+    return thunk;
+}
+function createAppAuthorizedThunk(authorizationSelector, thunk) {
+    return createAppThunk((payload) => (dispatch, getState, extra) => {
+        const isAuthorized = authorizationSelector(getState());
+        if (!isAuthorized) {
+            console.warn("Not authorized to perform this action");
+            return false;
+        }
+        return thunk(payload)(dispatch, getState, extra);
+    });
+}
+function createRoomConnectedThunk(thunk) {
+    return createAppThunk((payload) => (dispatch, getState, extra) => {
+        const connectionStatus = getState().roomConnection.status;
+        if (connectionStatus !== "connected") {
+            console.warn("Action cannot be performed outside of a connected room");
+            return false;
+        }
+        return thunk(payload)(dispatch, getState, extra);
+    });
+}
+function createAsyncRoomConnectedThunk(typePrefix, payloadCreator) {
+    return createAppAsyncThunk(typePrefix, (arg, thunkApi) => {
+        const { getState } = thunkApi;
+        const connectionStatus = getState().roomConnection.status;
+        if (connectionStatus !== "connected") {
+            console.warn("Action cannot be performed outside of a connected room");
+            return Promise.reject("Action cannot be performed outside of a connected room");
+        }
+        return payloadCreator(arg, thunkApi);
+    });
+}
+function createAuthorizedRoomConnectedThunk(authorizationSelector, thunk) {
+    return createAppThunk((payload) => (dispatch, getState, extra) => {
+        const connectionStatus = getState().roomConnection.status;
+        if (connectionStatus !== "connected") {
+            console.warn("Action cannot be performed outside of a connected room");
+            return false;
+        }
+        return createAppAuthorizedThunk(authorizationSelector, thunk)(payload)(dispatch, getState, extra);
+    });
+}
+
+const listenerMiddleware = createListenerMiddleware();
+const startAppListening = listenerMiddleware.startListening;
+const addAppListener = addListener;
+const createReactor = (selectors, callback) => {
+    return startAppListening({
+        predicate: (_, currentState, previousState) => {
+            const previousValues = selectors.map((selector) => selector(previousState));
+            const currentValues = selectors.map((selector) => selector(currentState));
+            return previousValues.some((previousValue, index) => previousValue !== currentValues[index]);
+        },
+        effect: (action, { dispatch, getState, extra }) => {
+            const selectorResults = selectors.map((selector) => selector(getState()));
+            callback({
+                dispatch,
+                getState,
+                extra,
+            }, ...selectorResults);
+        },
+    });
+};
+
+const coreVersion = "0.29.2";
+
+const initialState$g = {
+    isNodeSdk: false,
+    isActive: false,
+    isDialIn: false,
+    roomName: null,
+    roomUrl: null,
+    displayName: null,
+    userAgent: `core:${coreVersion}`,
+    externalId: null,
+};
+const appSlice = createSlice({
+    name: "app",
+    initialState: initialState$g,
+    reducers: {
+        doAppStart: (state, action) => {
+            const url = new URL(action.payload.roomUrl);
+            return Object.assign(Object.assign(Object.assign({}, state), action.payload), { roomName: url.pathname, initialConfig: Object.assign({}, action.payload), isActive: true });
+        },
+        doAppStop: (state) => {
+            return Object.assign(Object.assign({}, state), { isActive: false });
+        },
+    },
+});
+const { doAppStop, doAppStart } = appSlice.actions;
+const selectAppRaw = (state) => state.app;
+const selectAppIsActive = (state) => state.app.isActive;
+const selectAppIsDialIn = (state) => state.app.isDialIn;
+const selectAppRoomName = (state) => state.app.roomName;
+const selectAppRoomUrl = (state) => state.app.roomUrl;
+const selectAppDisplayName = (state) => state.app.displayName;
+const selectAppUserAgent = (state) => state.app.userAgent;
+const selectAppExternalId = (state) => state.app.externalId;
+const selectAppIsNodeSdk = (state) => state.app.isNodeSdk;
+const selectAppInitialConfig = (state) => state.app.initialConfig;
+
+function createSignalEventAction(name) {
+    return createAction(`signalConnection/event/${name}`);
+}
+const signalEvents = {
+    audioEnabled: createSignalEventAction("audioEnabled"),
+    audioEnableRequested: createSignalEventAction("audioEnableRequested"),
+    breakoutGroupJoined: createSignalEventAction("breakoutGroupJoined"),
+    chatMessage: createSignalEventAction("chatMessage"),
+    clientLeft: createSignalEventAction("clientLeft"),
+    clientKicked: createSignalEventAction("clientKicked"),
+    clientMetadataReceived: createSignalEventAction("clientMetadataReceived"),
+    clientUnableToJoin: createSignalEventAction("clientUnableToJoin"),
+    cloudRecordingStarted: createSignalEventAction("cloudRecordingStarted"),
+    cloudRecordingStopped: createSignalEventAction("cloudRecordingStopped"),
+    disconnect: createSignalEventAction("disconnect"),
+    knockerLeft: createSignalEventAction("knockerLeft"),
+    knockHandled: createSignalEventAction("knockHandled"),
+    newClient: createSignalEventAction("newClient"),
+    roomJoined: createSignalEventAction("roomJoined"),
+    roomKnocked: createSignalEventAction("roomKnocked"),
+    roomLeft: createSignalEventAction("roomLeft"),
+    roomLocked: createSignalEventAction("roomLocked"),
+    roomSessionEnded: createSignalEventAction("roomSessionEnded"),
+    screenshareStarted: createSignalEventAction("screenshareStarted"),
+    screenshareStopped: createSignalEventAction("screenshareStopped"),
+    spotlightAdded: createSignalEventAction("spotlightAdded"),
+    spotlightRemoved: createSignalEventAction("spotlightRemoved"),
+    streamingStopped: createSignalEventAction("streamingStopped"),
+    videoEnabled: createSignalEventAction("videoEnabled"),
+    videoEnableRequested: createSignalEventAction("videoEnableRequested"),
+    liveTranscriptionStarted: createSignalEventAction("liveTranscriptionStarted"),
+    liveTranscriptionStopped: createSignalEventAction("liveTranscriptionStopped"),
+};
+
+const ROOM_ACTION_PERMISSIONS_BY_ROLE = {
+    canLockRoom: ["host"],
+    canRequestAudioEnable: ["host"],
+    canRequestVideoEnable: ["host"],
+    canKickClient: ["host"],
+    canEndMeeting: ["host"],
+    canAskToSpeak: ["host"],
+    canSpotlight: ["host"],
+};
+const initialState$f = {
+    roomKey: null,
+    roleName: "none",
+};
+const authorizationSlice = createSlice({
+    name: "authorization",
+    initialState: initialState$f,
+    reducers: {
+        setRoomKey: (state, action) => {
+            return Object.assign(Object.assign({}, state), { roomKey: action.payload });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppStart, (state, action) => {
+            return Object.assign(Object.assign({}, state), { roomKey: action.payload.roomKey });
+        });
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a, _b;
+            const client = (_b = (_a = action.payload) === null || _a === void 0 ? void 0 : _a.room) === null || _b === void 0 ? void 0 : _b.clients.find((c) => { var _a; return c.id === ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.selfId); });
+            return Object.assign(Object.assign({}, state), { roleName: (client === null || client === void 0 ? void 0 : client.role.roleName) || "none" });
+        });
+    },
+});
+const { setRoomKey } = authorizationSlice.actions;
+const selectRoomKey = (state) => state.authorization.roomKey;
+const selectAuthorizationRoleName = (state) => state.authorization.roleName;
+const selectIsAuthorizedToLockRoom = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canLockRoom.includes(localParticipantRole));
+const selectIsAuthorizedToRequestAudioEnable = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canRequestAudioEnable.includes(localParticipantRole));
+const selectIsAuthorizedToRequestVideoEnable = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canRequestVideoEnable.includes(localParticipantRole));
+const selectIsAuthorizedToKickClient = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canKickClient.includes(localParticipantRole));
+const selectIsAuthorizedToEndMeeting = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canEndMeeting.includes(localParticipantRole));
+const selectIsAuthorizedToAskToSpeak = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canAskToSpeak.includes(localParticipantRole));
+const selectIsAuthorizedToSpotlight = createSelector(selectAuthorizationRoleName, (localParticipantRole) => ROOM_ACTION_PERMISSIONS_BY_ROLE.canSpotlight.includes(localParticipantRole));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const initialState$e = {
+    isFetching: false,
+    data: null,
+};
+const deviceCredentialsSlice = createSlice({
+    name: "deviceCredentials",
+    initialState: initialState$e,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(doGetDeviceCredentials.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+        builder.addCase(doGetDeviceCredentials.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        });
+        builder.addCase(doGetDeviceCredentials.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+    },
+});
+const doGetDeviceCredentials = createAppAsyncThunk("deviceCredentials/doGetDeviceCredentials", (payload, { extra }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const deviceCredentials = yield extra.services.credentialsService.getCredentials();
+        return deviceCredentials;
+    }
+    catch (error) {
+        console.error(error);
+    }
+}));
+const selectDeviceCredentialsRaw = (state) => state.deviceCredentials;
+const selectHasFetchedDeviceCredentials = (state) => { var _a; return !!((_a = state.deviceCredentials.data) === null || _a === void 0 ? void 0 : _a.credentials); };
+const selectDeviceId = (state) => { var _a, _b; return (_b = (_a = state.deviceCredentials.data) === null || _a === void 0 ? void 0 : _a.credentials) === null || _b === void 0 ? void 0 : _b.uuid; };
+const selectShouldFetchDeviceCredentials = createSelector(selectAppIsActive, selectDeviceCredentialsRaw, (appIsActive, deviceCredentials) => {
+    if (appIsActive && !deviceCredentials.isFetching && !deviceCredentials.data) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldFetchDeviceCredentials], ({ dispatch }, shouldFetchDeviceCredentials) => {
+    if (shouldFetchDeviceCredentials) {
+        dispatch(doGetDeviceCredentials());
+    }
+});
+
+function forwardSocketEvents(socket, dispatch) {
+    socket.on("room_joined", (payload) => dispatch(signalEvents.roomJoined(payload)));
+    socket.on("new_client", (payload) => dispatch(signalEvents.newClient(payload)));
+    socket.on("client_left", (payload) => dispatch(signalEvents.clientLeft(payload)));
+    socket.on("client_kicked", (payload) => dispatch(signalEvents.clientKicked(payload)));
+    socket.on("client_unable_to_join", (payload) => dispatch(signalEvents.clientUnableToJoin(payload)));
+    socket.on("audio_enabled", (payload) => dispatch(signalEvents.audioEnabled(payload)));
+    socket.on("video_enabled", (payload) => dispatch(signalEvents.videoEnabled(payload)));
+    socket.on("audio_enable_requested", (payload) => dispatch(signalEvents.audioEnableRequested(payload)));
+    socket.on("client_metadata_received", (payload) => dispatch(signalEvents.clientMetadataReceived(payload)));
+    socket.on("chat_message", (payload) => dispatch(signalEvents.chatMessage(payload)));
+    socket.on("disconnect", () => dispatch(signalEvents.disconnect()));
+    socket.on("room_knocked", (payload) => dispatch(signalEvents.roomKnocked(payload)));
+    socket.on("room_left", () => dispatch(signalEvents.roomLeft()));
+    socket.on("room_locked", (payload) => dispatch(signalEvents.roomLocked(payload)));
+    socket.on("room_session_ended", (payload) => dispatch(signalEvents.roomSessionEnded(payload)));
+    socket.on("knocker_left", (payload) => dispatch(signalEvents.knockerLeft(payload)));
+    socket.on("knock_handled", (payload) => dispatch(signalEvents.knockHandled(payload)));
+    socket.on("screenshare_started", (payload) => dispatch(signalEvents.screenshareStarted(payload)));
+    socket.on("screenshare_stopped", (payload) => dispatch(signalEvents.screenshareStopped(payload)));
+    socket.on("cloud_recording_started", (payload) => dispatch(signalEvents.cloudRecordingStarted(payload)));
+    socket.on("cloud_recording_stopped", () => dispatch(signalEvents.cloudRecordingStopped()));
+    socket.on("streaming_stopped", () => dispatch(signalEvents.streamingStopped()));
+    socket.on("spotlight_added", (payload) => dispatch(signalEvents.spotlightAdded(payload)));
+    socket.on("spotlight_removed", (payload) => dispatch(signalEvents.spotlightRemoved(payload)));
+    socket.on("live_transcription_started", (payload) => dispatch(signalEvents.liveTranscriptionStarted(payload)));
+    socket.on("live_transcription_stopped", (payload) => dispatch(signalEvents.liveTranscriptionStopped(payload)));
+    socket.on("video_enable_requested", (payload) => dispatch(signalEvents.videoEnableRequested(payload)));
+    socket.on("breakout_group_joined", (payload) => dispatch(signalEvents.breakoutGroupJoined(payload)));
+}
+const SIGNAL_BASE_URL = "wss://signal.appearin.net" ;
+function createSocket() {
+    const parsedUrl = new URL(SIGNAL_BASE_URL);
+    const socketHost = parsedUrl.origin;
+    const socketOverrides = {
+        autoConnect: false,
+    };
+    return new ServerSocket(socketHost, socketOverrides);
+}
+const initialState$d = {
+    deviceIdentified: false,
+    isIdentifyingDevice: false,
+    status: "ready",
+    socket: null,
+};
+const signalConnectionSlice = createSlice({
+    name: "signalConnection",
+    initialState: initialState$d,
+    reducers: {
+        socketConnecting: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "connecting" });
+        },
+        socketConnected: (state, action) => {
+            return Object.assign(Object.assign({}, state), { socket: action.payload, status: "connected" });
+        },
+        socketDisconnected: (state) => {
+            return Object.assign(Object.assign({}, state), { socket: null, deviceIdentified: false, status: "disconnected" });
+        },
+        socketReconnecting: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
+        },
+        deviceIdentifying: (state) => {
+            return Object.assign(Object.assign({}, state), { isIdentifyingDevice: true });
+        },
+        deviceIdentified: (state) => {
+            return Object.assign(Object.assign({}, state), { deviceIdentified: true, isIdentifyingDevice: false });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.disconnect, (state) => {
+            return Object.assign(Object.assign({}, state), { deviceIdentified: false, status: "disconnected" });
+        });
+    },
+});
+const { deviceIdentifying, deviceIdentified, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, } = signalConnectionSlice.actions;
+const doSignalConnect = createAppThunk(() => {
+    return (dispatch, getState) => {
+        if (selectSignalConnectionSocket(getState())) {
+            return;
+        }
+        dispatch(socketConnecting());
+        const socket = createSocket();
+        socket.on("connect", () => dispatch(socketConnected(socket)));
+        socket.on("device_identified", () => dispatch(deviceIdentified()));
+        socket.getManager().on("reconnect", () => dispatch(socketReconnecting()));
+        forwardSocketEvents(socket, dispatch);
+        socket.connect();
+    };
+});
+const doSignalIdentifyDevice = createAppThunk(({ deviceCredentials }) => (dispatch, getState) => {
+    const state = getState();
+    const signalSocket = selectSignalConnectionSocket(state);
+    const deviceIdentified = selectSignalConnectionDeviceIdentified(state);
+    if (!signalSocket) {
+        return;
+    }
+    if (deviceIdentified) {
+        return;
+    }
+    signalSocket.emit("identify_device", { deviceCredentials });
+    dispatch(deviceIdentifying());
+});
+const doSignalDisconnect = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const signalStatus = selectSignalStatus(state);
+    if (signalStatus === "connected") {
+        const socket = selectSignalConnectionRaw(state).socket;
+        socket === null || socket === void 0 ? void 0 : socket.disconnect();
+        dispatch(socketDisconnected());
+    }
+});
+const selectSignalConnectionRaw = (state) => state.signalConnection;
+const selectSignalIsIdentifyingDevice = (state) => state.signalConnection.isIdentifyingDevice;
+const selectSignalConnectionDeviceIdentified = (state) => state.signalConnection.deviceIdentified;
+const selectSignalStatus = (state) => state.signalConnection.status;
+const selectSignalConnectionSocket = (state) => state.signalConnection.socket;
+const selectShouldConnectSignal = createSelector(selectAppIsActive, selectSignalStatus, (appIsActive, signalStatus) => {
+    if (appIsActive && ["ready", "reconnecting"].includes(signalStatus)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectSignal], ({ dispatch }, shouldConnectSignal) => {
+    if (shouldConnectSignal) {
+        dispatch(doSignalConnect());
+    }
+});
+const selectShouldIdentifyDevice = createSelector(selectDeviceCredentialsRaw, selectSignalStatus, selectSignalConnectionDeviceIdentified, selectSignalIsIdentifyingDevice, (deviceCredentialsRaw, signalStatus, deviceIdentified, isIdentifyingDevice) => {
+    if (deviceCredentialsRaw.data && signalStatus === "connected" && !deviceIdentified && !isIdentifyingDevice) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldIdentifyDevice, selectDeviceCredentialsRaw], ({ dispatch }, shouldIdentifyDevice, deviceCredentialsRaw) => {
+    if (shouldIdentifyDevice && deviceCredentialsRaw.data) {
+        dispatch(doSignalIdentifyDevice({ deviceCredentials: deviceCredentialsRaw.data }));
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.roomLeft,
+    effect: (_, { dispatch }) => {
+        dispatch(doSignalDisconnect());
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.clientKicked,
+    effect: (_, { dispatch }) => {
+        dispatch(doSignalDisconnect());
+    },
+});
+
+const initialState$c = {
+    chatMessages: [],
+};
+const chatSlice = createSlice({
+    name: "chat",
+    initialState: initialState$c,
+    reducers: {},
+    extraReducers(builder) {
+        builder.addCase(signalEvents.chatMessage, (state, action) => {
+            const message = {
+                senderId: action.payload.senderId,
+                timestamp: action.payload.timestamp,
+                text: action.payload.text,
+            };
+            return Object.assign(Object.assign({}, state), { chatMessages: [...state.chatMessages, message] });
+        });
+    },
+});
+const doSendChatMessage = createRoomConnectedThunk((payload) => (_, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("chat_message", { text: payload.text });
+});
+const selectChatRaw = (state) => state.chat;
+const selectChatMessages = (state) => state.chat.chatMessages;
+
+const initialCloudRecordingState = {
+    isRecording: false,
+    error: null,
+    startedAt: undefined,
+};
+const cloudRecordingSlice = createSlice({
+    name: "cloudRecording",
+    initialState: initialCloudRecordingState,
+    reducers: {
+        recordingRequestStarted: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "requested" });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.cloudRecordingStopped, (state) => {
+            return Object.assign(Object.assign({}, state), { isRecording: false, status: undefined });
+        });
+        builder.addCase(signalEvents.cloudRecordingStarted, (state, action) => {
+            const { payload } = action;
+            if (!payload.error) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { isRecording: false, status: "error", error: payload.error });
+        });
+        builder.addCase(signalEvents.newClient, (state, { payload }) => {
+            var _a;
+            const { client } = payload;
+            if (((_a = client.role) === null || _a === void 0 ? void 0 : _a.roleName) === "recorder") {
+                return Object.assign(Object.assign({}, state), { isRecording: true, status: "recording", startedAt: client.startedCloudRecordingAt
+                        ? new Date(client.startedCloudRecordingAt).getTime()
+                        : new Date().getTime() });
+            }
+            return state;
+        });
+    },
+});
+const { recordingRequestStarted } = cloudRecordingSlice.actions;
+const doStartCloudRecording = createRoomConnectedThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const status = selectCloudRecordingStatus(state);
+    if (status && ["recording", "requested"].includes(status)) {
+        return;
+    }
+    socket === null || socket === void 0 ? void 0 : socket.emit("start_recording", {
+        recording: "cloud",
+    });
+    dispatch(recordingRequestStarted());
+});
+const doStopCloudRecording = createRoomConnectedThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("stop_recording");
+});
+const selectCloudRecordingRaw = (state) => state.cloudRecording;
+const selectCloudRecordingStatus = (state) => state.cloudRecording.status;
+const selectCloudRecordingStartedAt = (state) => state.cloudRecording.startedAt;
+const selectCloudRecordingError = (state) => state.cloudRecording.error;
+const selectIsCloudRecording = (state) => state.cloudRecording.isRecording;
+
+const initialState$b = {
+    data: null,
+    isFetching: false,
+    error: null,
+};
+const organizationSlice = createSlice({
+    initialState: initialState$b,
+    name: "organization",
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(doOrganizationFetch.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+        builder.addCase(doOrganizationFetch.fulfilled, (state, action) => {
+            if (!action.payload)
+                return Object.assign(Object.assign({}, state), { isFetching: true });
+            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        });
+        builder.addCase(doOrganizationFetch.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: false, error: true });
+        });
+    },
+});
+const doOrganizationFetch = createAppAsyncThunk("organization/doOrganizationFetch", (_, { extra, getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const roomUrl = selectAppRoomUrl(getState());
+        const organization = yield extra.services.fetchOrganizationFromRoomUrl(roomUrl || "");
+        if (!organization) {
+            throw new Error("Invalid room url");
+        }
+        return organization;
+    }
+    catch (error) {
+        console.error(error);
+    }
+}));
+const selectOrganizationRaw = (state) => state.organization;
+const selectOrganizationId = (state) => { var _a; return (_a = state.organization.data) === null || _a === void 0 ? void 0 : _a.organizationId; };
+const selectShouldFetchOrganization = createSelector(selectAppIsActive, selectOrganizationRaw, selectDeviceCredentialsRaw, (appIsActive, organization, deviceCredentials) => {
+    if (appIsActive &&
+        !organization.data &&
+        !organization.isFetching &&
+        !organization.error &&
+        !deviceCredentials.isFetching) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldFetchOrganization], ({ dispatch }, shouldFetchOrganization) => {
+    if (shouldFetchOrganization) {
+        dispatch(doOrganizationFetch());
+    }
+});
+
+function fakeAudioStream() {
+    const audioCtx = new AudioContext();
+    const oscillator = audioCtx.createOscillator();
+    const destination = audioCtx.createMediaStreamDestination();
+    oscillator.connect(destination);
+    oscillator.start();
+    return destination.stream;
+}
+
+let rotationAngle = 0;
+function drawWebcamFrame(canvas) {
+    const context = canvas.getContext("2d");
+    if (!context) {
+        console.error("Canvas context not available");
+        return;
+    }
+    const wheelRadius = 100;
+    const wheelCenterX = canvas.width / 2;
+    const wheelCenterY = canvas.height / 2;
+    context.fillStyle = "darkgreen";
+    context.fillRect(0, 0, canvas.width, canvas.height);
+    context.save();
+    context.translate(wheelCenterX, wheelCenterY);
+    context.rotate(rotationAngle);
+    const numSlices = 12;
+    const sliceAngle = (2 * Math.PI) / numSlices;
+    const colors = ["red", "orange", "yellow", "green", "blue", "purple"];
+    for (let i = 0; i < numSlices; i++) {
+        context.beginPath();
+        context.moveTo(0, 0);
+        context.arc(0, 0, wheelRadius, i * sliceAngle, (i + 1) * sliceAngle);
+        context.fillStyle = colors[i % colors.length];
+        context.fill();
+        context.closePath();
+    }
+    context.restore();
+    context.fillStyle = "white";
+    context.font = "42px Arial";
+    const topText = "Whereby Media Stream";
+    const topTextWidth = context.measureText(topText).width;
+    context.fillText(topText, canvas.width / 2 - topTextWidth / 2, 50);
+    context.font = "32px Arial";
+    const now = new Date();
+    const timeText = `time: ${now.getHours().toString().padStart(2, "0")}:${now
+        .getMinutes()
+        .toString()
+        .padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}.${now
+        .getMilliseconds()
+        .toString()
+        .padStart(3, "0")}`;
+    context.fillText(timeText, 10, canvas.height - 20);
+    context.fillText(`rotation angle: ${rotationAngle.toFixed(2)}`, canvas.width - canvas.width / 2, canvas.height - 20);
+    rotationAngle += 0.01;
+}
+function fakeWebcamFrame(canvas) {
+    drawWebcamFrame(canvas);
+    setInterval(() => drawWebcamFrame(canvas), 50);
+}
+
+const CANVAS_VIDEO_FPS = 24;
+function getAudioTrack() {
+    const audioStream = fakeAudioStream();
+    return audioStream.getAudioTracks()[0];
+}
+function getVideoTrack({ canvas }) {
+    fakeWebcamFrame(canvas);
+    const videoStream = canvas.captureStream(CANVAS_VIDEO_FPS);
+    return videoStream.getVideoTracks()[0];
+}
+function getFakeMediaStream({ canvas, hasAudio }) {
+    const tracks = [getVideoTrack({ canvas }), ...(hasAudio ? [getAudioTrack()] : [])];
+    return new MediaStream(tracks);
+}
+
+function debounce(fn, { delay = 500, edges } = {}) {
+    let timeout;
+    let nCalls = 0;
+    return (...args) => {
+        nCalls += 1;
+        if (edges && nCalls === 1) {
+            fn(...args);
+        }
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            if (!edges || nCalls > 1) {
+                fn(...args);
+            }
+            timeout = undefined;
+            nCalls = 0;
+        }, delay);
+    };
+}
+
+function parseRoomUrlAndSubdomain(roomAttribute, subdomainAttribute) {
+    if (!roomAttribute) {
+        throw new Error("Missing room attribute");
+    }
+    const m = /https:\/\/([^.]+)(\.whereby\.com|-ip-\d+-\d+-\d+-\d+.hereby.dev:4443)\/.+/.exec(roomAttribute);
+    const subdomain = (m && m[1]) || subdomainAttribute;
+    if (!subdomain) {
+        throw new Error("Missing subdomain attribute");
+    }
+    if (!m) {
+        throw new Error("Could not parse room URL");
+    }
+    const roomUrl = new URL(roomAttribute);
+    return {
+        subdomain,
+        roomUrl,
+    };
+}
+
+function parseUnverifiedRoomKeyData(roomKey) {
+    const [, roomKeyData] = /\.(.*)\./i.exec(roomKey) || [];
+    if (!roomKeyData) {
+        return {};
+    }
+    else {
+        try {
+            const base64DecodedJwtData = atob(roomKeyData);
+            return JSON.parse(base64DecodedJwtData);
+        }
+        catch (e) {
+            return {};
+        }
+    }
+}
+
+const initialLocalMediaState = {
+    busyDeviceIds: [],
+    cameraEnabled: false,
+    currentSpeakerDeviceId: "default",
+    devices: [],
+    isSettingCameraDevice: false,
+    isSettingMicrophoneDevice: false,
+    isSettingSpeakerDevice: false,
+    isTogglingCamera: false,
+    lowDataMode: false,
+    microphoneEnabled: false,
+    status: "inactive",
+    stream: undefined,
+    isSwitchingStream: false,
+};
+const localMediaSlice = createSlice({
+    name: "localMedia",
+    initialState: initialLocalMediaState,
+    reducers: {
+        deviceBusy(state, action) {
+            if (state.busyDeviceIds.includes(action.payload.deviceId)) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { busyDeviceIds: [...state.busyDeviceIds, action.payload.deviceId] });
+        },
+        toggleCameraEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { cameraEnabled: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.cameraEnabled });
+        },
+        setCurrentCameraDeviceId(state, action) {
+            return Object.assign(Object.assign({}, state), { currentCameraDeviceId: action.payload.deviceId });
+        },
+        toggleMicrophoneEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { microphoneEnabled: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.microphoneEnabled });
+        },
+        setCurrentMicrophoneDeviceId(state, action) {
+            return Object.assign(Object.assign({}, state), { currentMicrophoneDeviceId: action.payload.deviceId });
+        },
+        setCurrentSpeakerDeviceId(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { currentSpeakerDeviceId: (_a = action.payload.deviceId) !== null && _a !== void 0 ? _a : "default" });
+        },
+        toggleLowDataModeEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { lowDataMode: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.lowDataMode });
+        },
+        setDevices(state, action) {
+            return Object.assign(Object.assign({}, state), { devices: action.payload.devices });
+        },
+        setLocalMediaStream(state, action) {
+            return Object.assign(Object.assign({}, state), { stream: action.payload.stream });
+        },
+        setLocalMediaOptions(state, action) {
+            return Object.assign(Object.assign({}, state), { options: action.payload.options });
+        },
+        localMediaStopped(state) {
+            return Object.assign(Object.assign({}, state), { status: "stopped", stream: undefined });
+        },
+        localStreamMetadataUpdated(state, action) {
+            const { audio, video } = action.payload;
+            return Object.assign(Object.assign({}, state), { currentCameraDeviceId: video.deviceId, currentMicrophoneDeviceId: audio.deviceId, busyDeviceIds: state.busyDeviceIds.filter((id) => id !== audio.deviceId && id !== video.deviceId) });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppStart, (state, action) => {
+            return Object.assign(Object.assign({}, state), { options: action.payload.localMediaOptions });
+        });
+        builder.addCase(doSetDevice.pending, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video, isSettingMicrophoneDevice: audio });
+        });
+        builder.addCase(doSetDevice.fulfilled, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video ? false : state.isSettingCameraDevice, isSettingMicrophoneDevice: audio ? false : state.isSettingMicrophoneDevice });
+        });
+        builder.addCase(doSetDevice.rejected, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video ? false : state.isSettingCameraDevice, isSettingMicrophoneDevice: audio ? false : state.isSettingMicrophoneDevice, cameraDeviceError: video ? action.error : state.cameraDeviceError, microphoneDeviceError: audio ? action.error : state.microphoneDeviceError });
+        });
+        builder.addCase(doToggleCamera.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isTogglingCamera: true });
+        });
+        builder.addCase(doToggleCamera.fulfilled, (state) => {
+            return Object.assign(Object.assign({}, state), { isTogglingCamera: false });
+        });
+        builder.addCase(doUpdateDeviceList.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { devices: action.payload.devices });
+        });
+        builder.addCase(doStartLocalMedia.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "starting" });
+        });
+        builder.addCase(doStartLocalMedia.fulfilled, (state, { payload: { stream, onDeviceChange } }) => {
+            let cameraDeviceId = undefined;
+            let cameraEnabled = false;
+            let microphoneDeviceId = undefined;
+            let microphoneEnabled = false;
+            const audioTrack = stream.getAudioTracks()[0];
+            const videoTrack = stream.getVideoTracks()[0];
+            if (audioTrack) {
+                microphoneDeviceId = audioTrack.getSettings().deviceId;
+                microphoneEnabled = audioTrack.enabled;
+            }
+            if (videoTrack) {
+                cameraEnabled = videoTrack.enabled;
+                cameraDeviceId = videoTrack.getSettings().deviceId;
+            }
+            return Object.assign(Object.assign({}, state), { stream, status: "started", currentCameraDeviceId: cameraDeviceId, currentMicrophoneDeviceId: microphoneDeviceId, cameraEnabled,
+                microphoneEnabled,
+                onDeviceChange });
+        });
+        builder.addCase(doStartLocalMedia.rejected, (state, action) => {
+            return Object.assign(Object.assign({}, state), { status: "error", startError: action.error });
+        });
+        builder.addCase(doSwitchLocalStream.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: true });
+        });
+        builder.addCase(doSwitchLocalStream.fulfilled, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: false });
+        });
+        builder.addCase(doSwitchLocalStream.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: false });
+        });
+    },
+});
+const { deviceBusy, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setCurrentSpeakerDeviceId, toggleCameraEnabled, toggleMicrophoneEnabled, toggleLowDataModeEnabled, setLocalMediaOptions, setLocalMediaStream, localMediaStopped, localStreamMetadataUpdated, } = localMediaSlice.actions;
+const doToggleCamera = createAppAsyncThunk("localMedia/doToggleCamera", (_, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    let track = stream.getVideoTracks()[0];
+    const enabled = selectIsCameraEnabled(state);
+    try {
+        if (enabled) {
+            if (track) {
+                track.enabled = true;
+            }
+            else {
+                const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+                const cameraDeviceId = selectCurrentCameraDeviceId(state);
+                yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: false, videoId: cameraDeviceId, type: "exact" }), { replaceStream: stream });
+                track = stream.getVideoTracks()[0];
+            }
+        }
+        else {
+            if (!track) {
+                return;
+            }
+            track.enabled = false;
+            track.stop();
+            stream.removeTrack(track);
+        }
+        stream.dispatchEvent(new CustomEvent("stopresumevideo", { detail: { track, enable: enabled } }));
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doToggleMicrophone = createAppAsyncThunk("localMedia/doToggleMicrophone", (_, { getState }) => {
+    var _a;
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    const enabled = selectIsMicrophoneEnabled(state);
+    const audioTrack = (_a = stream.getAudioTracks()) === null || _a === void 0 ? void 0 : _a[0];
+    if (!audioTrack) {
+        return;
+    }
+    audioTrack.enabled = enabled;
+});
+const doToggleLowDataMode = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    const videoId = selectCurrentCameraDeviceId(state);
+    const audioId = selectCurrentMicrophoneDeviceId(state);
+    dispatch(doSwitchLocalStream({ audioId, videoId }));
+});
+const doSetDevice = createAppAsyncThunk("localMedia/reactSetDevice", ({ audio, video }, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const state = getState();
+        const stream = selectLocalMediaStream(state);
+        if (!stream) {
+            throw new Error("No stream");
+        }
+        const audioId = audio ? selectCurrentMicrophoneDeviceId(state) : false;
+        const videoId = video ? selectCurrentCameraDeviceId(state) : false;
+        const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+        const { replacedTracks } = yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId,
+            videoId, type: "exact" }), { replaceStream: stream });
+        const isAudioEnabled = selectIsMicrophoneEnabled(state);
+        stream.getAudioTracks().forEach((track) => (track.enabled = isAudioEnabled));
+        const isVideoEnabled = selectIsCameraEnabled(state);
+        stream.getVideoTracks().forEach((track) => (track.enabled = isVideoEnabled));
+        return { replacedTracks };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doUpdateDeviceList = createAppAsyncThunk("localMedia/doUpdateDeviceList", (_, { getState, dispatch, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    const state = getState();
+    let newDevices = [];
+    let oldDevices = [];
+    const stream = selectLocalMediaStream(state);
+    try {
+        newDevices = yield navigator.mediaDevices.enumerateDevices();
+        oldDevices = selectLocalMediaDevices(state);
+        const shouldHandleDeviceUpdate = stream &&
+            !selectLocalMediaIsSwitchingStream(state) &&
+            newDevices &&
+            oldDevices &&
+            oldDevices.find((d) => d.deviceId);
+        if (!shouldHandleDeviceUpdate) {
+            return { devices: newDevices };
+        }
+        const { changedDevices, addedDevices } = getUpdatedDevices({
+            oldDevices,
+            newDevices,
+        });
+        let autoSwitchAudioId = (_a = changedDevices.audioinput) === null || _a === void 0 ? void 0 : _a.deviceId;
+        let autoSwitchVideoId = (_b = changedDevices.videoinput) === null || _b === void 0 ? void 0 : _b.deviceId;
+        if (autoSwitchAudioId === undefined) {
+            autoSwitchAudioId = (_c = addedDevices.audioinput) === null || _c === void 0 ? void 0 : _c.deviceId;
+        }
+        if (autoSwitchVideoId === undefined) {
+            autoSwitchVideoId = (_d = addedDevices.videoinput) === null || _d === void 0 ? void 0 : _d.deviceId;
+        }
+        if (autoSwitchAudioId !== undefined || autoSwitchVideoId !== undefined) {
+            dispatch(doSwitchLocalStream({ audioId: autoSwitchAudioId, videoId: autoSwitchVideoId }));
+        }
+        return { devices: newDevices };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doSwitchLocalStream = createAppAsyncThunk("localMedia/doSwitchLocalStream", ({ audioId, videoId }, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const replaceStream = selectLocalMediaStream(state);
+    const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+    const onlySwitchingOne = !!(videoId && !audioId) || !!(!videoId && audioId);
+    if (!replaceStream) {
+        return;
+    }
+    try {
+        const { replacedTracks } = yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: audioId === undefined ? false : audioId, videoId: videoId === undefined ? false : videoId, type: "exact" }), { replaceStream });
+        const deviceId = audioId || videoId;
+        if (onlySwitchingOne && deviceId) {
+            dispatch(deviceBusy({
+                deviceId,
+            }));
+        }
+        return { replacedTracks };
+    }
+    catch (error) {
+        console.error(error);
+        const deviceId = audioId || videoId;
+        if (onlySwitchingOne && deviceId) {
+            dispatch(deviceBusy({
+                deviceId,
+            }));
+        }
+        return rejectWithValue(error);
+    }
+}));
+const doStartLocalMedia = createAppAsyncThunk("localMedia/doStartLocalMedia", (payload, { getState, dispatch, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const onDeviceChange = debounce(() => {
+        dispatch(doUpdateDeviceList());
+    }, { delay: 500 });
+    if (navigator.mediaDevices) {
+        navigator.mediaDevices.addEventListener("devicechange", onDeviceChange);
+    }
+    if ("getTracks" in payload) {
+        return Promise.resolve({ stream: payload, onDeviceChange });
+    }
+    if (!(payload.audio || payload.video)) {
+        return { stream: new MediaStream(), onDeviceChange };
+    }
+    else {
+        dispatch(setLocalMediaOptions({ options: payload }));
+    }
+    try {
+        yield dispatch(doUpdateDeviceList());
+        const state = getState();
+        const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+        const { stream } = yield getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: payload.audio, videoId: payload.video }));
+        return { stream, onDeviceChange };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doStopLocalMedia = createAppThunk(() => (dispatch, getState) => {
+    const stream = selectLocalMediaStream(getState());
+    const onDeviceChange = selectLocalMediaRaw(getState()).onDeviceChange;
+    stream === null || stream === void 0 ? void 0 : stream.getTracks().forEach((track) => {
+        track.stop();
+    });
+    if (navigator.mediaDevices && onDeviceChange) {
+        navigator.mediaDevices.removeEventListener("devicechange", onDeviceChange);
+    }
+    dispatch(localMediaStopped());
+});
+const selectBusyDeviceIds = (state) => state.localMedia.busyDeviceIds;
+const selectCameraDeviceError = (state) => state.localMedia.cameraDeviceError;
+const selectCurrentCameraDeviceId = (state) => state.localMedia.currentCameraDeviceId;
+const selectCurrentMicrophoneDeviceId = (state) => state.localMedia.currentMicrophoneDeviceId;
+const selectCurrentSpeakerDeviceId = (state) => state.localMedia.currentSpeakerDeviceId;
+const selectIsCameraEnabled = (state) => state.localMedia.cameraEnabled;
+const selectIsMicrophoneEnabled = (state) => state.localMedia.microphoneEnabled;
+const selectIsLowDataModeEnabled = (state) => state.localMedia.lowDataMode;
+const selectIsSettingCameraDevice = (state) => state.localMedia.isSettingCameraDevice;
+const selectIsSettingMicrophoneDevice = (state) => state.localMedia.isSettingMicrophoneDevice;
+const selectIsToggleCamera = (state) => state.localMedia.isTogglingCamera;
+const selectLocalMediaDevices = (state) => state.localMedia.devices;
+const selectLocalMediaOptions = (state) => state.localMedia.options;
+const selectLocalMediaOwnsStream = createSelector(selectLocalMediaOptions, (options) => !!options);
+const selectLocalMediaRaw = (state) => state.localMedia;
+const selectLocalMediaStatus = (state) => state.localMedia.status;
+const selectLocalMediaStream = (state) => state.localMedia.stream;
+const selectMicrophoneDeviceError = (state) => state.localMedia.microphoneDeviceError;
+const selectLocalMediaStartError = (state) => state.localMedia.startError;
+const selectLocalMediaIsSwitchingStream = (state) => state.localMedia.isSwitchingStream;
+const selectLocalMediaConstraintsOptions = createSelector(selectLocalMediaDevices, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectIsLowDataModeEnabled, (devices, videoId, audioId, lowDataMode) => ({
+    devices,
+    videoId,
+    audioId,
+    options: {
+        disableAEC: false,
+        disableAGC: false,
+        hd: true,
+        lax: false,
+        lowDataMode,
+        simulcast: true,
+        widescreen: true,
+    },
+}));
+const selectIsLocalMediaStarting = createSelector(selectLocalMediaStatus, (status) => status === "starting");
+const selectCameraDevices = createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "videoinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
+const selectMicrophoneDevices = createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "audioinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
+const selectSpeakerDevices = createSelector(selectLocalMediaDevices, (devices) => devices.filter((d) => d.kind === "audiooutput"));
+const selectLocalMediaShouldStartWithOptions = createSelector(selectAppIsActive, selectLocalMediaStatus, selectLocalMediaOptions, (appIsActive, localMediaStatus, localMediaOptions) => {
+    if (appIsActive && ["inactive", "stopped"].includes(localMediaStatus) && localMediaOptions) {
+        return localMediaOptions;
+    }
+});
+createReactor([selectLocalMediaShouldStartWithOptions], ({ dispatch }, options) => {
+    if (options) {
+        dispatch(doStartLocalMedia(options));
+    }
+});
+const selectLocalMediaShouldStop = createSelector(selectAppIsActive, selectLocalMediaStatus, selectLocalMediaOptions, (appIsActive, localMediaStatus, localMediaOptions) => {
+    return !appIsActive && localMediaStatus !== "inactive" && !!localMediaOptions;
+});
+createReactor([selectLocalMediaShouldStop], ({ dispatch }, localMediaShouldStop) => {
+    if (localMediaShouldStop) {
+        dispatch(doStopLocalMedia());
+    }
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectIsMicrophoneEnabled(previousState);
+        const newValue = selectIsMicrophoneEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_, { dispatch }) => {
+        dispatch(doToggleMicrophone());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectIsLowDataModeEnabled(previousState);
+        const newValue = selectIsLowDataModeEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doToggleLowDataMode());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const isToggling = selectIsToggleCamera(currentState);
+        if (isToggling) {
+            return false;
+        }
+        const oldValue = selectIsCameraEnabled(previousState);
+        const newValue = selectIsCameraEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doToggleCamera());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectCurrentCameraDeviceId(previousState);
+        const newValue = selectCurrentCameraDeviceId(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doSetDevice({ audio: false, video: true }));
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectCurrentMicrophoneDeviceId(previousState);
+        const newValue = selectCurrentMicrophoneDeviceId(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doSetDevice({ audio: true, video: false }));
+    },
+});
+startAppListening({
+    matcher: isAnyOf(doStartLocalMedia.fulfilled, doUpdateDeviceList.fulfilled, doSwitchLocalStream.fulfilled, doSwitchLocalStream.rejected),
+    effect: (_action, { dispatch, getState }) => {
+        const state = getState();
+        const stream = selectLocalMediaStream(state);
+        const devices = selectLocalMediaDevices(state);
+        if (!stream)
+            return;
+        const deviceData = getDeviceData({
+            audioTrack: stream.getAudioTracks()[0],
+            videoTrack: stream.getVideoTracks()[0],
+            devices,
+        });
+        dispatch(localStreamMetadataUpdated(deviceData));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.audioEnableRequested,
+    effect: ({ payload }, { dispatch }) => {
+        const { enable } = payload;
+        if (!enable) {
+            dispatch(toggleMicrophoneEnabled({ enabled: false }));
+        }
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.videoEnableRequested,
+    effect: ({ payload }, { dispatch }) => {
+        const { enable } = payload;
+        if (!enable) {
+            dispatch(toggleCameraEnabled({ enabled: false }));
+        }
+    },
+});
+
+const NON_PERSON_ROLES = ["recorder", "streamer"];
+
+const initialState$a = {
+    displayName: "",
+    id: "",
+    breakoutGroup: null,
+    isAudioEnabled: true,
+    isVideoEnabled: true,
+    isLocalParticipant: true,
+    stream: undefined,
+    isScreenSharing: false,
+    roleName: "none",
+    clientClaim: undefined,
+    stickyReaction: undefined,
+    isDialIn: false,
+};
+const localParticipantSlice = createSlice({
+    name: "localParticipant",
+    initialState: initialState$a,
+    reducers: {
+        setDisplayName: (state, action) => {
+            return Object.assign(Object.assign({}, state), { displayName: action.payload.displayName });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppStart, (state, action) => {
+            return Object.assign(Object.assign({}, state), { displayName: action.payload.displayName });
+        });
+        builder.addCase(doEnableAudio.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isAudioEnabled: action.payload });
+        });
+        builder.addCase(doEnableVideo.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isVideoEnabled: action.payload });
+        });
+        builder.addCase(doSetLocalStickyReaction.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { stickyReaction: action.payload });
+        });
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a, _b;
+            const client = (_b = (_a = action.payload) === null || _a === void 0 ? void 0 : _a.room) === null || _b === void 0 ? void 0 : _b.clients.find((c) => { var _a; return c.id === ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.selfId); });
+            return Object.assign(Object.assign({}, state), { id: action.payload.selfId, roleName: (client === null || client === void 0 ? void 0 : client.role.roleName) || "none", clientClaim: action.payload.clientClaim, breakoutGroup: (client === null || client === void 0 ? void 0 : client.breakoutGroup) || null });
+        });
+        builder.addCase(signalEvents.breakoutGroupJoined, (state, action) => {
+            var _a, _b;
+            if (((_a = action.payload) === null || _a === void 0 ? void 0 : _a.clientId) !== state.id) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { breakoutGroup: (_b = action.payload) === null || _b === void 0 ? void 0 : _b.group });
+        });
+    },
+});
+const { setDisplayName } = localParticipantSlice.actions;
+const doSetDisplayName = createRoomConnectedThunk((payload) => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("send_client_metadata", {
+        type: "UserData",
+        payload: { displayName: payload.displayName },
+    });
+    dispatch(setDisplayName({ displayName: payload.displayName }));
+});
+const doEnableAudio = createAsyncRoomConnectedThunk("localParticipant/doEnableAudio", (payload, { dispatch, getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("enable_audio", { enabled: payload.enabled });
+    if (payload.enabled) {
+        dispatch(doSetLocalStickyReaction({ enabled: false }));
+    }
+    return payload.enabled;
+}));
+const doEnableVideo = createAsyncRoomConnectedThunk("localParticipant/doEnableVideo", (payload, { getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("enable_video", { enabled: payload.enabled });
+    return payload.enabled;
+}));
+const doSetLocalStickyReaction = createAsyncRoomConnectedThunk("localParticipant/doSetLocalStickyReaction", (payload, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const state = getState();
+    const currentStickyReaction = selectLocalParticipantStickyReaction(state);
+    const stickyReactionCurrentlyEnabled = Boolean(currentStickyReaction);
+    const enabled = (_a = payload.enabled) !== null && _a !== void 0 ? _a : !stickyReactionCurrentlyEnabled;
+    if (enabled === stickyReactionCurrentlyEnabled) {
+        return rejectWithValue(currentStickyReaction);
+    }
+    const stickyReaction = enabled ? { reaction: "✋", timestamp: new Date().toISOString() } : null;
+    return stickyReaction;
+}));
+const doSendClientMetadata = createRoomConnectedThunk(() => (_, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const payload = {
+        displayName: selectLocalParticipantDisplayName(state),
+        stickyReaction: selectLocalParticipantStickyReaction(state),
+    };
+    socket === null || socket === void 0 ? void 0 : socket.emit("send_client_metadata", {
+        type: "UserData",
+        payload,
+    });
+});
+const selectLocalParticipantRaw = (state) => state.localParticipant;
+const selectSelfId = (state) => state.localParticipant.id;
+const selectLocalParticipantDisplayName = (state) => state.localParticipant.displayName;
+const selectLocalParticipantClientClaim = (state) => state.localParticipant.clientClaim;
+const selectLocalParticipantIsScreenSharing = (state) => state.localParticipant.isScreenSharing;
+const selectLocalParticipantStickyReaction = (state) => state.localParticipant.stickyReaction;
+const selectLocalParticipantView = createSelector(selectLocalParticipantRaw, selectLocalMediaStream, (participant, localStream) => {
+    const clientView = {
+        id: participant.id,
+        clientId: participant.id,
+        displayName: participant.displayName,
+        stream: localStream,
+        isLocalClient: true,
+        isAudioEnabled: participant.isAudioEnabled,
+        isVideoEnabled: participant.isVideoEnabled,
+    };
+    if (NON_PERSON_ROLES.includes(participant.roleName)) {
+        return null;
+    }
+    return clientView;
+});
+startAppListening({
+    actionCreator: toggleCameraEnabled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enabled } = payload;
+        const { isVideoEnabled } = selectLocalParticipantRaw(getState());
+        dispatch(doEnableVideo({ enabled: enabled || !isVideoEnabled }));
+    },
+});
+startAppListening({
+    actionCreator: toggleMicrophoneEnabled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enabled } = payload;
+        const { isAudioEnabled } = selectLocalParticipantRaw(getState());
+        dispatch(doEnableAudio({ enabled: enabled || !isAudioEnabled }));
+    },
+});
+createReactor([selectLocalParticipantDisplayName, selectLocalParticipantStickyReaction], ({ dispatch }) => {
+    dispatch(doSendClientMetadata());
+});
+
+const initialState$9 = {
+    session: null,
+    status: "ready",
+    error: null,
+};
+const roomConnectionSlice = createSlice({
+    initialState: initialState$9,
+    name: "roomConnection",
+    reducers: {
+        connectionStatusChanged: (state, action) => {
+            return Object.assign(Object.assign({}, state), { status: action.payload });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a, _b;
+            const { error, isLocked } = action.payload;
+            if (error === "room_locked" && isLocked) {
+                return Object.assign(Object.assign({}, state), { status: "room_locked" });
+            }
+            if (error) {
+                return Object.assign(Object.assign({}, state), { status: "disconnected", error });
+            }
+            return Object.assign(Object.assign({}, state), { status: "connected", session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
+        });
+        builder.addCase(signalEvents.disconnect, (state) => {
+            if (["kicked", "left"].includes(state.status)) {
+                return Object.assign({}, state);
+            }
+            return Object.assign(Object.assign({}, state), { status: "disconnected" });
+        });
+        builder.addCase(signalEvents.newClient, (state, action) => {
+            var _a, _b;
+            return Object.assign(Object.assign({}, state), { session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
+        });
+        builder.addCase(signalEvents.roomSessionEnded, (state, action) => {
+            var _a;
+            if (((_a = state.session) === null || _a === void 0 ? void 0 : _a.id) !== action.payload.roomSessionId) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { session: null });
+        });
+        builder.addCase(signalEvents.clientKicked, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "kicked" });
+        });
+        builder.addCase(signalEvents.roomLeft, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "left" });
+        });
+        builder.addCase(socketReconnecting, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
+        });
+    },
+});
+const { connectionStatusChanged } = roomConnectionSlice.actions;
+const doKnockRoom = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const isDialIn = selectAppIsDialIn(state);
+    const userAgent = selectAppUserAgent(state);
+    const externalId = selectAppExternalId(state);
+    const organizationId = selectOrganizationId(state);
+    const connectionStatus = selectRoomConnectionStatus(state);
+    if (connectionStatus !== "room_locked") {
+        console.warn("Room is not locked, knock aborted");
+        return;
+    }
+    socket === null || socket === void 0 ? void 0 : socket.emit("knock_room", {
+        avatarUrl: null,
+        config: {
+            isAudioEnabled: true,
+            isVideoEnabled: true,
+        },
+        deviceCapabilities: { canScreenshare: true },
+        displayName,
+        isCoLocated: false,
+        isDialIn,
+        isDevicePermissionDenied: false,
+        kickFromOtherRooms: false,
+        organizationId,
+        roomKey,
+        roomName,
+        userAgent,
+        externalId,
+    });
+    dispatch(connectionStatusChanged("knocking"));
+});
+const doConnectRoom = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const userAgent = selectAppUserAgent(state);
+    const externalId = selectAppExternalId(state);
+    const isDialIn = selectAppIsDialIn(state);
+    const organizationId = selectOrganizationId(state);
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    const clientClaim = selectLocalParticipantClientClaim(getState());
+    socket === null || socket === void 0 ? void 0 : socket.emit("join_room", Object.assign({ avatarUrl: null, config: {
+            isAudioEnabled: isMicrophoneEnabled,
+            isVideoEnabled: isCameraEnabled,
+        }, deviceCapabilities: { canScreenshare: true }, displayName, isCoLocated: false, isDialIn, isDevicePermissionDenied: false, kickFromOtherRooms: false, organizationId,
+        roomKey,
+        roomName,
+        userAgent,
+        externalId }, (clientClaim && { clientClaim })));
+    dispatch(connectionStatusChanged("connecting"));
+});
+const selectRoomConnectionRaw = (state) => state.roomConnection;
+const selectRoomConnectionSession = (state) => state.roomConnection.session;
+const selectRoomConnectionSessionId = (state) => { var _a; return (_a = state.roomConnection.session) === null || _a === void 0 ? void 0 : _a.id; };
+const selectRoomConnectionStatus = (state) => state.roomConnection.status;
+const selectRoomConnectionError = (state) => state.roomConnection.error;
+const selectShouldConnectRoom = createSelector([
+    selectAppIsActive,
+    selectOrganizationId,
+    selectRoomConnectionStatus,
+    selectSignalConnectionDeviceIdentified,
+    selectLocalMediaStatus,
+    selectRoomConnectionError,
+], (appIsActive, hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus, roomConnectionError) => {
+    if (appIsActive &&
+        localMediaStatus === "started" &&
+        signalConnectionDeviceIdentified &&
+        !!hasOrganizationIdFetched &&
+        ["ready", "reconnecting", "disconnected"].includes(roomConnectionStatus) &&
+        !roomConnectionError) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRoom], ({ dispatch }, shouldConnectRoom) => {
+    if (shouldConnectRoom) {
+        dispatch(doConnectRoom());
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.knockHandled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { clientId, resolution } = payload;
+        const state = getState();
+        const selfId = selectSelfId(state);
+        if (clientId !== selfId) {
+            return;
+        }
+        if (resolution === "accepted") {
+            dispatch(setRoomKey(payload.metadata.roomKey));
+            dispatch(doConnectRoom());
+        }
+        else if (resolution === "rejected") {
+            dispatch(connectionStatusChanged("knock_rejected"));
+        }
+    },
+});
+startAppListening({
+    actionCreator: doAppStop,
+    effect: (_, { dispatch, getState }) => {
+        const state = getState();
+        const roomConnectionStatus = selectRoomConnectionStatus(state);
+        if (roomConnectionStatus === "connected") {
+            const socket = selectSignalConnectionRaw(state).socket;
+            socket === null || socket === void 0 ? void 0 : socket.emit("leave_room");
+            dispatch(connectionStatusChanged("leaving"));
+        }
+        else {
+            doSignalDisconnect();
+        }
+    },
+});
+
+function createRtcEventAction(name) {
+    return createAction(`rtcConnection/event/${name}`);
+}
+const rtcEvents = {
+    rtcManagerCreated: createRtcEventAction("rtcManagerCreated"),
+    rtcManagerDestroyed: createRtcEventAction("rtcManagerDestroyed"),
+    streamAdded: createRtcEventAction("streamAdded"),
+};
+
+function createRemoteParticipant(client, newJoiner = false) {
+    const { streams, role, breakoutGroup } = client, rest = __rest(client, ["streams", "role", "breakoutGroup"]);
+    return Object.assign(Object.assign({}, rest), { stream: null, streams: streams.map((streamId) => ({ id: streamId, state: newJoiner ? "new_accept" : "to_accept" })), isLocalParticipant: false, roleName: (role === null || role === void 0 ? void 0 : role.roleName) || "none", presentationStream: null, breakoutGroup: breakoutGroup || null, newJoiner });
+}
+function findParticipant(state, participantId) {
+    const index = state.remoteParticipants.findIndex((c) => c.id === participantId);
+    return { index, participant: state.remoteParticipants[index] };
+}
+function updateParticipant(state, participantId, updates) {
+    const { participant, index } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`Did not find client for update ${participantId}`);
+        return state;
+    }
+    return Object.assign(Object.assign({}, state), { remoteParticipants: [
+            ...state.remoteParticipants.slice(0, index),
+            Object.assign(Object.assign({}, participant), updates),
+            ...state.remoteParticipants.slice(index + 1),
+        ] });
+}
+function addParticipant(state, participant) {
+    const { participant: foundParticipant } = findParticipant(state, participant.id);
+    if (foundParticipant) {
+        console.warn(`Client already existing ${participant.id}. Ignoring`);
+        return state;
+    }
+    return Object.assign(Object.assign({}, state), { remoteParticipants: [...state.remoteParticipants, participant] });
+}
+function updateStreamState(state, participantId, streamId, state_) {
+    const { participant } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`No client ${participantId} found to update stream ${streamId} ${state_}`);
+        return state;
+    }
+    const idIdx = participant.streams.findIndex((s) => s.id === streamId);
+    const streams = [...participant.streams];
+    streams[idIdx] = Object.assign(Object.assign({}, streams[idIdx]), { state: state_ });
+    return updateParticipant(state, participantId, { streams });
+}
+function removeClient(state, participantId) {
+    return Object.assign(Object.assign({}, state), { remoteParticipants: state.remoteParticipants.filter((c) => c.id !== participantId) });
+}
+function addStreamId(state, participantId, streamId) {
+    const { participant } = findParticipant(state, participantId);
+    if (!participant || participant.streams.find((s) => s.id === streamId)) {
+        console.warn(`No participant ${participantId} or stream ${streamId} already exists`);
+        return state;
+    }
+    return updateParticipant(state, participantId, {
+        streams: [...participant.streams, { id: streamId, state: "to_accept" }],
+    });
+}
+function removeStreamId(state, participantId, streamId) {
+    var _a, _b;
+    const { participant } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`No participant ${participantId} found to remove stream ${streamId}`);
+        return state;
+    }
+    const currentStreamId = participant.stream && participant.stream.id;
+    const presentationId = ((_a = participant.presentationStream) === null || _a === void 0 ? void 0 : _a.inboundId) || ((_b = participant.presentationStream) === null || _b === void 0 ? void 0 : _b.id);
+    const idIdx = participant.streams.findIndex((s) => s.id === streamId);
+    return updateParticipant(state, participantId, Object.assign(Object.assign({ streams: participant.streams.filter((_, i) => i !== idIdx) }, (currentStreamId === streamId && { stream: null })), (presentationId === streamId && { presentationStream: null })));
+}
+function addStream(state, payload) {
+    const { clientId, stream, streamType } = payload;
+    let { streamId } = payload;
+    const { participant } = findParticipant(state, clientId);
+    if (!participant) {
+        console.error(`Did not find client ${clientId} for adding stream`);
+        return state;
+    }
+    const remoteParticipants = state.remoteParticipants;
+    if (!streamId) {
+        streamId = stream.id;
+    }
+    const remoteParticipant = remoteParticipants.find((p) => p.id === clientId);
+    if (!remoteParticipant) {
+        return state;
+    }
+    const remoteParticipantStream = remoteParticipant.streams.find((s) => s.id === streamId);
+    if ((remoteParticipant.stream &&
+        (remoteParticipant.stream.id === streamId || remoteParticipant.stream.inboundId === streamId)) ||
+        (!remoteParticipant.stream && streamType === "webcam") ||
+        (!remoteParticipant.stream && !streamType && !remoteParticipantStream)) {
+        return updateParticipant(state, clientId, { stream });
+    }
+    return updateParticipant(state, clientId, {
+        presentationStream: stream,
+    });
+}
+const initialState$8 = {
+    remoteParticipants: [],
+};
+const remoteParticipantsSlice = createSlice({
+    name: "remoteParticipants",
+    initialState: initialState$8,
+    reducers: {
+        streamStatusUpdated: (state, action) => {
+            let newState = state;
+            for (const { clientId, streamId, state } of action.payload) {
+                newState = updateStreamState(newState, clientId, streamId, state);
+            }
+            return newState;
+        },
+        participantStreamAdded: (state, action) => {
+            const { clientId, stream } = action.payload;
+            return updateParticipant(state, clientId, {
+                stream,
+            });
+        },
+        participantStreamIdAdded: (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return addStreamId(state, clientId, streamId);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a;
+            if (!((_a = action.payload) === null || _a === void 0 ? void 0 : _a.room))
+                return state;
+            const selfId = action.payload.selfId;
+            const { clients } = action.payload.room;
+            return Object.assign(Object.assign({}, state), { remoteParticipants: clients.filter((c) => c.id !== selfId).map((c) => createRemoteParticipant(c)) });
+        });
+        builder.addCase(rtcEvents.streamAdded, (state, action) => {
+            return addStream(state, action.payload);
+        });
+        builder.addCase(signalEvents.newClient, (state, action) => {
+            const { client } = action.payload;
+            return addParticipant(state, createRemoteParticipant(client, true));
+        });
+        builder.addCase(signalEvents.clientLeft, (state, action) => {
+            const { clientId } = action.payload;
+            return removeClient(state, clientId);
+        });
+        builder.addCase(signalEvents.audioEnabled, (state, action) => {
+            const { clientId, isAudioEnabled } = action.payload;
+            return updateParticipant(state, clientId, {
+                isAudioEnabled,
+            });
+        });
+        builder.addCase(signalEvents.videoEnabled, (state, action) => {
+            const { clientId, isVideoEnabled } = action.payload;
+            return updateParticipant(state, clientId, {
+                isVideoEnabled,
+            });
+        });
+        builder.addCase(signalEvents.clientMetadataReceived, (state, action) => {
+            const { error, payload } = action.payload;
+            if (error || !payload) {
+                console.warn(error || "Client metadata error received");
+                return state;
+            }
+            const { clientId, displayName, stickyReaction } = payload;
+            return updateParticipant(state, clientId, {
+                displayName,
+                stickyReaction,
+            });
+        });
+        builder.addCase(signalEvents.breakoutGroupJoined, (state, action) => {
+            const { clientId, group } = action.payload;
+            return updateParticipant(state, clientId, {
+                breakoutGroup: group || null,
+            });
+        });
+        builder.addCase(signalEvents.screenshareStarted, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return addStreamId(state, clientId, streamId);
+        });
+        builder.addCase(signalEvents.screenshareStopped, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return removeStreamId(state, clientId, streamId);
+        });
+    },
+});
+const { participantStreamAdded, participantStreamIdAdded, streamStatusUpdated } = remoteParticipantsSlice.actions;
+const doRequestAudioEnable = createAuthorizedRoomConnectedThunk((state) => selectIsAuthorizedToRequestAudioEnable(state), (payload) => (_, getState) => {
+    const state = getState();
+    const canEnableRemoteAudio = selectIsAuthorizedToAskToSpeak(state);
+    if (payload.enable && !canEnableRemoteAudio) {
+        console.warn("Not authorized to perform this action");
+        return;
+    }
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("request_audio_enable", payload);
+});
+const doRequestVideoEnable = createAuthorizedRoomConnectedThunk((state) => selectIsAuthorizedToRequestVideoEnable(state), (payload) => (_, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("request_video_enable", payload);
+});
+const selectRemoteParticipantsRaw = (state) => state.remoteParticipants;
+const selectRemoteClients = (state) => state.remoteParticipants.remoteParticipants;
+const selectRemoteParticipants = createSelector(selectRemoteClients, (clients) => clients.filter((c) => !NON_PERSON_ROLES.includes(c.roleName)));
+const selectNumClients = createSelector(selectRemoteClients, (clients) => clients.length + 1);
+const selectNumParticipants = createSelector(selectRemoteParticipants, selectLocalParticipantRaw, (clients, localParticipant) => {
+    if (NON_PERSON_ROLES.includes(localParticipant.roleName)) {
+        return clients.length;
+    }
+    return clients.length + 1;
+});
+
+const initialState$7 = {
+    status: "inactive",
+    stream: null,
+    error: null,
+};
+const localScreenshareSlice = createSlice({
+    name: "localScreenshare",
+    initialState: initialState$7,
+    reducers: {
+        stopScreenshare(state, action) {
+            return Object.assign(Object.assign({}, state), { status: "inactive", stream: null });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doStartScreenshare.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "starting" });
+        });
+        builder.addCase(doStartScreenshare.fulfilled, (state, { payload: { stream } }) => {
+            return Object.assign(Object.assign({}, state), { status: "active", stream });
+        });
+        builder.addCase(doStartScreenshare.rejected, (state, { payload }) => {
+            return Object.assign(Object.assign({}, state), { error: payload, status: "inactive", stream: null });
+        });
+    },
+});
+const { stopScreenshare } = localScreenshareSlice.actions;
+const doStartScreenshare = createAsyncRoomConnectedThunk("localScreenshare/doStartScreenshare", (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (screenshareStream) {
+            return { stream: screenshareStream };
+        }
+        const stream = yield navigator.mediaDevices.getDisplayMedia();
+        const onEnded = () => {
+            dispatch(doStopScreenshare());
+        };
+        if ("oninactive" in stream) {
+            stream.addEventListener("inactive", onEnded);
+        }
+        else {
+            (_a = stream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.addEventListener("ended", onEnded);
+        }
+        return { stream };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doStopScreenshare = createRoomConnectedThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const screenshareStream = selectLocalScreenshareStream(state);
+    if (!screenshareStream) {
+        return;
+    }
+    screenshareStream.getTracks().forEach((track) => track.stop());
+    dispatch(stopScreenshare({ stream: screenshareStream }));
+});
+const selectLocalScreenshareRaw = (state) => state.localScreenshare;
+const selectLocalScreenshareStatus = (state) => state.localScreenshare.status;
+const selectLocalScreenshareStream = (state) => state.localScreenshare.stream;
+startAppListening({
+    actionCreator: localMediaStopped,
+    effect: (_, { getState }) => {
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (!screenshareStream) {
+            return;
+        }
+        screenshareStream === null || screenshareStream === void 0 ? void 0 : screenshareStream.getTracks().forEach((track) => {
+            track.stop();
+        });
+    },
+});
+
+const createWebRtcEmitter = (dispatch) => {
+    return {
+        emit: (eventName, data) => {
+            if (eventName === "rtc_manager_created") {
+                dispatch(doRtcManagerCreated(data));
+            }
+            else if (eventName === "stream_added") {
+                dispatch(rtcEvents.streamAdded(data));
+            }
+            else if (eventName === "rtc_manager_destroyed") {
+                dispatch(rtcManagerDestroyed());
+            }
+            else ;
+        },
+    };
+};
+const initialState$6 = {
+    dispatcherCreated: false,
+    error: null,
+    isCreatingDispatcher: false,
+    reportedStreamResolutions: {},
+    rtcManager: null,
+    rtcManagerDispatcher: null,
+    rtcManagerInitialized: false,
+    status: "inactive",
+    isAcceptingStreams: false,
+};
+const rtcConnectionSlice = createSlice({
+    name: "rtcConnection",
+    initialState: initialState$6,
+    reducers: {
+        isAcceptingStreams: (state, action) => {
+            return Object.assign(Object.assign({}, state), { isAcceptingStreams: action.payload });
+        },
+        resolutionReported: (state, action) => {
+            const { streamId, width, height } = action.payload;
+            return Object.assign(Object.assign({}, state), { reportedStreamResolutions: Object.assign(Object.assign({}, state.reportedStreamResolutions), { [streamId]: { width, height } }) });
+        },
+        rtcDisconnected: () => {
+            return Object.assign({}, initialState$6);
+        },
+        rtcDispatcherCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { dispatcherCreated: true, rtcManagerDispatcher: action.payload });
+        },
+        rtcManagerCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: action.payload, status: "ready" });
+        },
+        rtcManagerDestroyed: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: null });
+        },
+        rtcManagerInitialized: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManagerInitialized: true });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(socketReconnecting, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
+        });
+        builder.addCase(signalEvents.roomJoined, (state) => {
+            return Object.assign(Object.assign({}, state), { status: state.status === "reconnecting" ? "ready" : state.status });
+        });
+    },
+});
+const { resolutionReported, rtcDispatcherCreated, rtcDisconnected, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, isAcceptingStreams, } = rtcConnectionSlice.actions;
+const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const dispatcher = selectRtcConnectionRaw(state).rtcManagerDispatcher;
+    const isCameraEnabled = selectIsCameraEnabled(state);
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(state);
+    const isNodeSdk = selectAppIsNodeSdk(state);
+    if (dispatcher || !socket) {
+        return;
+    }
+    const webrtcProvider = {
+        getMediaConstraints: () => ({
+            audio: isMicrophoneEnabled,
+            video: isCameraEnabled,
+        }),
+        deferrable(clientId) {
+            return !clientId;
+        },
+    };
+    const rtcManagerDispatcher = new RtcManagerDispatcher({
+        emitter: createWebRtcEmitter(dispatch),
+        serverSocket: socket,
+        webrtcProvider,
+        features: {
+            isNodeSdk,
+            lowDataModeEnabled: false,
+            sfuServerOverrideHost: undefined,
+            turnServerOverrideHost: undefined,
+            useOnlyTURN: undefined,
+            vp9On: false,
+            h264On: false,
+            simulcastScreenshareOn: false,
+            deviceHandlerFactory: isNodeSdk ? Safari12.createFactory() : undefined,
+        },
+    });
+    dispatch(rtcDispatcherCreated(rtcManagerDispatcher));
+});
+const doDisconnectRtc = createAppThunk(() => (dispatch, getState) => {
+    const { rtcManager } = selectRtcConnectionRaw(getState());
+    if (rtcManager) {
+        rtcManager.disconnectAll();
+    }
+    dispatch(rtcDisconnected());
+});
+const doHandleAcceptStreams = createAppThunk((payload) => (dispatch, getState) => {
+    var _a;
+    dispatch(isAcceptingStreams(true));
+    const state = getState();
+    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+    const remoteClients = selectRemoteClients(state);
+    if (!rtcManager) {
+        throw new Error("No rtc manager");
+    }
+    const activeBreakout = false;
+    const shouldAcceptNewClients = (_a = rtcManager.shouldAcceptStreamsFromBothSides) === null || _a === void 0 ? void 0 : _a.call(rtcManager);
+    const updates = [];
+    for (const { clientId, streamId, state } of payload) {
+        const participant = remoteClients.find((p) => p.id === clientId);
+        if (!participant)
+            continue;
+        if (state === "to_accept" ||
+            (state === "new_accept" && shouldAcceptNewClients) ||
+            (state === "old_accept" && !shouldAcceptNewClients)) {
+            rtcManager.acceptNewStream({
+                streamId: streamId === "0" ? clientId : streamId,
+                clientId,
+                shouldAddLocalVideo: streamId === "0",
+                activeBreakout,
+            });
+        }
+        else if (state === "new_accept" || state === "old_accept") ;
+        else if (state === "to_unaccept") {
+            rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.disconnect(streamId === "0" ? clientId : streamId, activeBreakout);
+        }
+        else if (state !== "done_accept") {
+            continue;
+        }
+        else ;
+        updates.push({ clientId, streamId, state: state.replace(/to_|new_|old_/, "done_") });
+    }
+    dispatch(streamStatusUpdated(updates));
+    dispatch(isAcceptingStreams(false));
+});
+const doRtcReportStreamResolution = createAppThunk(({ streamId, width, height }) => (dispatch, getState) => {
+    const { reportedStreamResolutions, rtcManager } = selectRtcConnectionRaw(getState());
+    const localStream = selectLocalMediaStream(getState());
+    if (!rtcManager || (localStream === null || localStream === void 0 ? void 0 : localStream.id) === streamId) {
+        return;
+    }
+    const old = reportedStreamResolutions[streamId];
+    if (!old || old.width !== width || old.height !== height) {
+        rtcManager.updateStreamResolution(streamId, null, { width: width || 1, height: height || 1 });
+    }
+    dispatch(resolutionReported({ streamId, width, height }));
+});
+const doRtcManagerCreated = createAppThunk((payload) => (dispatch) => {
+    const { rtcManager } = payload;
+    dispatch(rtcManagerCreated(rtcManager));
+});
+const doRtcManagerInitialize = createAppThunk(() => (dispatch, getState) => {
+    const localMediaStream = selectLocalMediaStream(getState());
+    const rtcManager = selectRtcConnectionRaw(getState()).rtcManager;
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    if (localMediaStream && rtcManager) {
+        rtcManager.addNewStream("0", localMediaStream, !isMicrophoneEnabled, !isCameraEnabled);
+    }
+    dispatch(rtcManagerInitialized());
+});
+const selectRtcConnectionRaw = (state) => state.rtcConnection;
+const selectRtcManagerInitialized = (state) => state.rtcConnection.rtcManagerInitialized;
+const selectRtcManager = (state) => state.rtcConnection.rtcManager;
+const selectRtcDispatcherCreated = (state) => state.rtcConnection.dispatcherCreated;
+const selectRtcIsCreatingDispatcher = (state) => state.rtcConnection.isCreatingDispatcher;
+const selectRtcStatus = (state) => state.rtcConnection.status;
+const selectIsAcceptingStreams = (state) => state.rtcConnection.isAcceptingStreams;
+startAppListening({
+    actionCreator: doSetDevice.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { replacedTracks } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        const stream = selectLocalMediaStream(getState());
+        const replace = (kind, oldTrack) => {
+            const track = stream === null || stream === void 0 ? void 0 : stream.getTracks().find((t) => t.kind === kind);
+            return track && (rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.replaceTrack(oldTrack, track));
+        };
+        replacedTracks === null || replacedTracks === void 0 ? void 0 : replacedTracks.forEach((t) => {
+            replace(t.kind, t);
+        });
+    },
+});
+startAppListening({
+    actionCreator: doStartScreenshare.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.addNewStream(stream.id, stream, false, true);
+    },
+});
+startAppListening({
+    actionCreator: doAppStop,
+    effect: (_, { getState }) => {
+        const rtcManager = selectRtcManager(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.rtcStatsDisconnect();
+    },
+});
+startAppListening({
+    actionCreator: stopScreenshare,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.removeStream(stream.id, stream, null);
+    },
+});
+startAppListening({
+    actionCreator: doSwitchLocalStream.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        var _a;
+        const stream = selectLocalMediaStream(getState());
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        if (stream && rtcManager) {
+            const replace = (kind, oldTrack) => {
+                const track = stream.getTracks().find((t) => t.kind === kind);
+                return track && rtcManager.replaceTrack(oldTrack, track);
+            };
+            (_a = payload === null || payload === void 0 ? void 0 : payload.replacedTracks) === null || _a === void 0 ? void 0 : _a.forEach((t) => {
+                replace(t.kind, t);
+            });
+        }
+    },
+});
+const selectShouldConnectRtc = createSelector(selectRtcStatus, selectAppIsActive, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectSignalConnectionSocket, (rtcStatus, appIsActive, dispatcherCreated, isCreatingDispatcher, signalSocket) => {
+    if (appIsActive && rtcStatus === "inactive" && !dispatcherCreated && !isCreatingDispatcher && signalSocket) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRtc], ({ dispatch }, shouldConnectRtc) => {
+    if (shouldConnectRtc) {
+        dispatch(doConnectRtc());
+    }
+});
+const selectShouldInitializeRtc = createSelector(selectRtcManager, selectRtcManagerInitialized, selectLocalMediaStatus, (rtcManager, rtcManagerInitialized, localMediaStatus) => {
+    if (localMediaStatus === "started" && rtcManager && !rtcManagerInitialized) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldInitializeRtc], ({ dispatch }, shouldInitializeRtc) => {
+    if (shouldInitializeRtc) {
+        dispatch(doRtcManagerInitialize());
+    }
+});
+const selectShouldDisconnectRtc = createSelector(selectRtcStatus, selectAppIsActive, (status, appIsActive) => {
+    if (!appIsActive && !["inactive", "disconnected"].includes(status)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldDisconnectRtc], ({ dispatch }, shouldDisconnectRtc) => {
+    if (shouldDisconnectRtc) {
+        dispatch(doDisconnectRtc());
+    }
+});
+const selectStreamsToAccept = createSelector(selectRtcStatus, selectRemoteClients, (rtcStatus, remoteParticipants) => {
+    if (rtcStatus !== "ready") {
+        return [];
+    }
+    const upd = [];
+    for (const client of remoteParticipants) {
+        const { streams, id: clientId, newJoiner } = client;
+        for (let i = 0; i < streams.length; i++) {
+            let streamId = streams[i].id;
+            let state = streams[i].state;
+            if ((streams === null || streams === void 0 ? void 0 : streams.length) > 1 && streams[1].id === "0") {
+                if (i === 0) {
+                    streamId = streams[1].id;
+                    state = streams[1].state;
+                }
+                else if (i === 1) {
+                    streamId = streams[0].id;
+                    state = streams[0].state;
+                }
+            }
+            {
+                if (state === "done_accept")
+                    continue;
+                upd.push({
+                    clientId,
+                    streamId,
+                    state: `${newJoiner && streamId === "0" ? "new" : "to"}_accept`,
+                });
+            }
+        }
+    }
+    return upd;
+});
+createReactor([selectStreamsToAccept, selectIsAcceptingStreams], ({ dispatch }, streamsToAccept, isAcceptingStreams) => {
+    if (0 < streamsToAccept.length && !isAcceptingStreams) {
+        dispatch(doHandleAcceptStreams(streamsToAccept));
+    }
+});
+
+function isStreamerClient(client) {
+    return client.roleName === "streamer";
+}
+function isRecorderClient(client) {
+    return client.roleName === "recorder";
+}
+const initialState$5 = {
+    isLocked: false,
+};
+const roomSlice = createSlice({
+    name: "room",
+    initialState: initialState$5,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            const { error, isLocked } = action.payload;
+            if (error) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { isLocked: Boolean(isLocked) });
+        });
+        builder.addCase(signalEvents.roomLocked, (state, action) => {
+            const { isLocked } = action.payload;
+            return Object.assign(Object.assign({}, state), { isLocked: Boolean(isLocked) });
+        });
+    },
+});
+const doLockRoom = createAppAuthorizedThunk((state) => selectIsAuthorizedToLockRoom(state), (payload) => (_, getState) => {
+    const state = getState();
+    const { socket } = selectSignalConnectionRaw(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("set_lock", { locked: payload.locked });
+});
+const doKickParticipant = createAppAuthorizedThunk((state) => selectIsAuthorizedToKickClient(state), (payload) => (_, getState) => {
+    const state = getState();
+    const { socket } = selectSignalConnectionRaw(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("kick_client", { clientId: payload.clientId, reasonId: "kick" });
+});
+const doEndMeeting = createAppAuthorizedThunk((state) => selectIsAuthorizedToEndMeeting(state), (payload) => (dispatch, getState) => {
+    const state = getState();
+    const clientsToKick = selectRemoteClients(state).map((c) => c.id);
+    if (clientsToKick.length) {
+        const { socket } = selectSignalConnectionRaw(state);
+        socket === null || socket === void 0 ? void 0 : socket.emit("kick_client", { clientIds: clientsToKick, reasonId: "end-meeting" });
+    }
+    if (!payload.stayBehind) {
+        dispatch(doAppStop());
+    }
+});
+const selectRoomIsLocked = (state) => state.room.isLocked;
+const selectScreenshares = createSelector(selectLocalScreenshareStream, selectLocalParticipantRaw, selectRemoteParticipants, (localScreenshareStream, localParticipant, remoteParticipants) => {
+    const screenshares = [];
+    if (localScreenshareStream) {
+        screenshares.push({
+            id: localScreenshareStream.id || "local-screenshare",
+            participantId: "local",
+            hasAudioTrack: localScreenshareStream.getTracks().some((track) => track.kind === "audio"),
+            breakoutGroup: localParticipant.breakoutGroup,
+            stream: localScreenshareStream,
+            isLocal: true,
+        });
+    }
+    for (const participant of remoteParticipants) {
+        if (participant.presentationStream) {
+            screenshares.push({
+                id: participant.presentationStream.id || `pres-${participant.id}`,
+                participantId: participant.id,
+                hasAudioTrack: participant.presentationStream.getTracks().some((track) => track.kind === "audio"),
+                breakoutGroup: participant.breakoutGroup,
+                stream: participant.presentationStream,
+                isLocal: false,
+            });
+        }
+    }
+    return screenshares;
+});
+const selectRemoteClientViews = createSelector(selectLocalScreenshareStream, selectLocalParticipantRaw, selectRemoteParticipants, (localScreenshareStream, localParticipant, remoteParticipants) => {
+    const views = [];
+    if (localScreenshareStream) {
+        const isScreenshareAudioEnabled = !!localScreenshareStream.getAudioTracks().length;
+        views.push({
+            clientId: localParticipant.id,
+            displayName: "Your screenshare",
+            id: "local-screenshare",
+            isAudioEnabled: isScreenshareAudioEnabled,
+            isLocalClient: true,
+            isPresentation: true,
+            isVideoEnabled: true,
+            stream: localScreenshareStream,
+        });
+    }
+    for (const c of remoteParticipants) {
+        if (isStreamerClient(c) || isRecorderClient(c)) {
+            continue;
+        }
+        const { presentationStream } = c, clientView = __rest(c, ["presentationStream"]);
+        const displayName = c.displayName || "Guest";
+        const isPresentationActive = presentationStream && presentationStream.active;
+        const presentationId = "pres-" + c.id;
+        const isStreamActive = c.stream && c.stream.active;
+        const isVideoEnabled = c.isVideoEnabled;
+        views.push(Object.assign(Object.assign(Object.assign({}, clientView), { clientId: c.id, displayName, hasActivePresentation: !!isPresentationActive }), (c.isVideoEnabled ? { isVideoEnabled } : {})));
+        if (isPresentationActive) {
+            views.push(Object.assign(Object.assign(Object.assign({}, clientView), { clientId: c.id, stream: c.presentationStream, displayName: `Screenshare (${displayName})`, id: presentationId, isPresentation: true, isVideoEnabled: true }), (isStreamActive && { isRecording: null })));
+        }
+    }
+    return views;
+});
+const selectAllClientViews = createSelector(selectLocalParticipantView, selectRemoteClientViews, (localParticipant, remoteParticipants) => {
+    return [...(localParticipant ? [localParticipant] : []), ...remoteParticipants];
+});
+
+const initialState$4 = {
+    running: false,
+};
+const connectionMonitorSlice = createSlice({
+    name: "connectionMonitor",
+    initialState: initialState$4,
+    reducers: {
+        connectionMonitorStarted: (state, action) => {
+            return Object.assign(Object.assign({}, state), { running: true, stopCallbackFunction: action.payload.stopIssueSubscription });
+        },
+        connectionMonitorStopped: () => {
+            return Object.assign({}, initialState$4);
+        },
+    },
+});
+const { connectionMonitorStarted, connectionMonitorStopped } = connectionMonitorSlice.actions;
+const doStartConnectionMonitor = createAppThunk(() => (dispatch, getState) => {
+    setClientProvider(() => {
+        const state = getState();
+        const clientViews = selectAllClientViews(state).map((clientView) => {
+            var _a, _b;
+            return ({
+                id: clientView.id,
+                clientId: clientView.clientId,
+                isLocalClient: clientView.isLocalClient,
+                audio: {
+                    enabled: clientView.isAudioEnabled,
+                    track: (_a = clientView.stream) === null || _a === void 0 ? void 0 : _a.getAudioTracks()[0],
+                },
+                video: {
+                    enabled: clientView.isVideoEnabled,
+                    track: (_b = clientView.stream) === null || _b === void 0 ? void 0 : _b.getVideoTracks()[0],
+                },
+                isPresentation: clientView.isPresentation,
+            });
+        });
+        return clientViews;
+    });
+    const issueMonitorSubscription = subscribeIssues({
+        onUpdatedIssues: (issuesAndMetricsByClients) => {
+            var _a;
+            const state = getState();
+            const rtcManager = selectRtcManager(state);
+            if (!rtcManager) {
+                return;
+            }
+            let lossSend = 0;
+            let lossReceive = 0;
+            let bitrateSend = 0;
+            let bitrateReceive = 0;
+            Object.entries(issuesAndMetricsByClients.aggregated.metrics).forEach(([key, value]) => {
+                if (/loc.*packetloss/.test(key))
+                    lossSend = Math.max(lossSend, value.curMax);
+                if (/rem.*packetloss/.test(key))
+                    lossReceive = Math.max(lossReceive, value.curMax);
+                if (/loc.*bitrate/.test(key))
+                    bitrateSend += value.curSum;
+                if (/rem.*bitrate/.test(key))
+                    bitrateReceive += value.curSum;
+            });
+            rtcManager.sendStatsCustomEvent("insightsStats", {
+                ls: Math.round(lossSend * 1000) / 1000,
+                lr: Math.round(lossReceive * 1000) / 1000,
+                bs: Math.round(bitrateSend),
+                br: Math.round(bitrateReceive),
+                cpu: (_a = issuesAndMetricsByClients.aggregated.metrics["global-cpu-pressure"]) === null || _a === void 0 ? void 0 : _a.curSum,
+                _time: Date.now(),
+            });
+        },
+    });
+    dispatch(connectionMonitorStarted({ stopIssueSubscription: issueMonitorSubscription.stop }));
+});
+const doStopConnectionMonitor = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const stopCallbackFn = selectStopCallbackFunction(state);
+    if (stopCallbackFn) {
+        stopCallbackFn();
+    }
+    dispatch(connectionMonitorStopped());
+});
+const selectConnectionMonitorIsRunning = (state) => state.connectionMonitor.running;
+const selectStopCallbackFunction = (state) => state.connectionMonitor.stopCallbackFunction;
+const selectShouldStartConnectionMonitor = createSelector(selectRoomConnectionStatus, selectConnectionMonitorIsRunning, (roomConnectionStatus, isRunning) => {
+    if (!isRunning && roomConnectionStatus === "connected") {
+        return true;
+    }
+    return false;
+});
+const selectShouldStopConnectionMonitor = createSelector(selectRoomConnectionStatus, selectConnectionMonitorIsRunning, (roomConnectionStatus, isRunning) => {
+    if (isRunning && ["kicked", "left"].includes(roomConnectionStatus)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldStartConnectionMonitor], ({ dispatch }, shouldStartConnectionMonitor) => {
+    if (shouldStartConnectionMonitor) {
+        dispatch(doStartConnectionMonitor());
+    }
+});
+createReactor([selectShouldStopConnectionMonitor], ({ dispatch }, shouldStartConnectionMonitor) => {
+    if (shouldStartConnectionMonitor) {
+        dispatch(doStopConnectionMonitor());
+    }
+});
+
+const emitter = new EventEmitter();
+function createNotificationEvent(payload) {
+    const notificationEvent = Object.assign(Object.assign({}, payload), { timestamp: Date.now() });
+    return notificationEvent;
+}
+const initialNotificationsState = {
+    emitter,
+    events: [],
+};
+const notificationsSlice = createSlice({
+    name: "notifications",
+    initialState: initialNotificationsState,
+    reducers: {
+        addNotification: (state, action) => {
+            return Object.assign(Object.assign({}, state), { events: [...state.events, Object.assign({}, action.payload)] });
+        },
+        doClearNotifications: (state) => {
+            return Object.assign(Object.assign({}, state), { events: [] });
+        },
+    },
+});
+const { doClearNotifications } = notificationsSlice.actions;
+const doSetNotification = createAppThunk((payload) => (dispatch, getState) => {
+    dispatch(notificationsSlice.actions.addNotification(payload));
+    const state = getState();
+    const emitter = selectNotificationsEmitter(state);
+    emitter.emit(payload.type, payload);
+    emitter.emit("*", payload);
+});
+const selectNotificationsRaw = (state) => state.notifications;
+const selectNotificationsEvents = (state) => state.notifications.events;
+const selectNotificationsEmitter = (state) => state.notifications.emitter;
+startAppListening({
+    actionCreator: signalEvents.chatMessage,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === payload.senderId);
+        if (!client) {
+            console.warn("Could not find remote client that sent chat message");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "chatMessageReceived",
+            message: `${client.displayName} says: ${payload.text}`,
+            props: {
+                client,
+                chatMessage: {
+                    senderId: payload.senderId,
+                    timestamp: payload.timestamp,
+                    text: payload.text,
+                },
+            },
+        })));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.audioEnableRequested,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enable, requestedByClientId } = payload;
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === requestedByClientId);
+        if (!client) {
+            console.warn("Could not find remote client that requested a local audio change");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: enable ? "requestAudioEnable" : "requestAudioDisable",
+            message: enable
+                ? `${client.displayName} has requested for you to speak`
+                : `${client.displayName} has muted your microphone`,
+            props: {
+                client,
+                enable,
+            },
+        })));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.videoEnableRequested,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enable, requestedByClientId } = payload;
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === requestedByClientId);
+        if (!client) {
+            console.warn("Could not find remote client that requested a local video change");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: enable ? "requestVideoEnable" : "requestVideoDisable",
+            message: enable
+                ? `${client.displayName} has requested for you to start video`
+                : `${client.displayName} has stopped your video`,
+            props: {
+                client,
+                enable,
+            },
+        })));
+    },
+});
+startAppListening({
+    actionCreator: signalEvents.clientMetadataReceived,
+    effect: (action, { dispatch, getOriginalState, getState }) => {
+        var _a;
+        const { error, payload } = action.payload;
+        if (error || !payload) {
+            return;
+        }
+        const { clientId, stickyReaction } = payload;
+        const state = getState();
+        const canAskToSpeak = selectIsAuthorizedToAskToSpeak(state);
+        if (!canAskToSpeak) {
+            return;
+        }
+        const client = selectRemoteParticipants(state).find(({ id }) => id === clientId);
+        if (!client) {
+            console.warn("Could not find remote client that provided updated metadata");
+            return;
+        }
+        const previousState = getOriginalState();
+        const previousClient = selectRemoteParticipants(previousState).find(({ id }) => id === clientId);
+        if ((!stickyReaction && !(previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction)) ||
+            (stickyReaction === null || stickyReaction === void 0 ? void 0 : stickyReaction.timestamp) === ((_a = previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction) === null || _a === void 0 ? void 0 : _a.timestamp)) {
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: stickyReaction ? "remoteHandRaised" : "remoteHandLowered",
+            message: `${client.displayName} ${stickyReaction ? "raised" : "lowered"} their hand`,
+            props: {
+                client,
+                stickyReaction,
+            },
+        })));
+    },
+});
+createReactor([selectSignalStatus], ({ dispatch, getState }, signalStatus) => {
+    const state = getState();
+    const roomConnectionStatus = selectRoomConnectionStatus(state);
+    if (["left", "kicked"].includes(roomConnectionStatus)) {
+        return;
+    }
+    if (signalStatus === "disconnected") {
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "signalTrouble",
+            message: `Network connection lost. Trying to reconnect you...`,
+            props: {},
+        })));
+    }
+    else if (signalStatus === "connected") {
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "signalOk",
+            message: `Network connection available`,
+            props: {},
+        })));
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.clientUnableToJoin,
+    effect: (action, { dispatch }) => {
+        var _a;
+        if (((_a = action.payload) === null || _a === void 0 ? void 0 : _a.error) === "room_full") {
+            dispatch(doSetNotification(createNotificationEvent({
+                type: "clientUnableToJoinFullRoom",
+                message: "Someone tried to join but the room is full and at capacity.",
+                props: {},
+            })));
+        }
+    },
+});
+
+const rtcAnalyticsCustomEvents = {
+    audioEnabled: {
+        actions: [doEnableAudio.fulfilled],
+        rtcEventName: "audioEnabled",
+        getValue: (state) => selectIsMicrophoneEnabled(state),
+        getOutput: (value) => ({ enabled: value }),
+    },
+    videoEnabled: {
+        actions: [doEnableVideo.fulfilled],
+        rtcEventName: "videoEnabled",
+        getValue: (state) => selectIsCameraEnabled(state),
+        getOutput: (value) => ({ enabled: value }),
+    },
+    localStream: {
+        actions: [doSetDevice.fulfilled],
+        rtcEventName: "localStream",
+        getValue: (state) => {
+            var _a;
+            return (_a = selectLocalMediaStream(state)) === null || _a === void 0 ? void 0 : _a.getTracks().map((track) => ({ id: track.id, kind: track.kind, label: track.label }));
+        },
+        getOutput: (value) => ({ stream: value }),
+    },
+    localScreenshareStream: {
+        actions: [doStartScreenshare.fulfilled],
+        rtcEventName: "localScreenshareStream",
+        getValue: (state) => {
+            var _a;
+            return (_a = selectLocalScreenshareStream(state)) === null || _a === void 0 ? void 0 : _a.getTracks().map((track) => ({ id: track.id, kind: track.kind, label: track.label }));
+        },
+        getOutput: (value) => ({ tracks: value }),
+    },
+    localScreenshareStreamStopped: {
+        actions: [stopScreenshare],
+        rtcEventName: "localScreenshareStream",
+        getValue: () => () => null,
+        getOutput: () => ({}),
+    },
+    displayName: {
+        actions: [setDisplayName],
+        rtcEventName: "displayName",
+        getValue: (state) => selectAppDisplayName(state),
+        getOutput: (value) => ({ displayName: value }),
+    },
+    clientId: {
+        actions: null,
+        rtcEventName: "clientId",
+        getValue: (state) => selectSelfId(state),
+        getOutput: (value) => ({ clientId: value }),
+    },
+    deviceId: {
+        actions: null,
+        rtcEventName: "deviceId",
+        getValue: (state) => selectDeviceId(state),
+        getOutput: (value) => ({ deviceId: value }),
+    },
+    externalId: {
+        actions: null,
+        rtcEventName: "externalId",
+        getValue: (state) => selectAppExternalId(state),
+        getOutput: (value) => ({ externalId: value }),
+    },
+    organizationId: {
+        actions: null,
+        rtcEventName: "organizationId",
+        getValue: (state) => selectOrganizationId(state),
+        getOutput: (value) => ({ organizationId: value }),
+    },
+    signalConnectionStatus: {
+        actions: null,
+        rtcEventName: "signalConnectionStatus",
+        getValue: (state) => selectSignalStatus(state),
+        getOutput: (value) => ({ status: value }),
+    },
+    roomSessionId: {
+        actions: [
+            signalEvents.newClient,
+            signalEvents.roomJoined,
+            signalEvents.roomSessionEnded,
+            signalEvents.clientLeft,
+        ],
+        rtcEventName: "roomSessionId",
+        getValue: (state) => selectRoomConnectionSessionId(state),
+        getOutput: (value) => ({ roomSessionId: value }),
+    },
+    rtcConnectionStatus: {
+        actions: null,
+        rtcEventName: "rtcConnectionStatus",
+        getValue: (state) => selectRtcStatus(state),
+        getOutput: (value) => ({ status: value }),
+    },
+    userRole: {
+        actions: null,
+        rtcEventName: "userRole",
+        getValue: (state) => selectAuthorizationRoleName(state),
+        getOutput: (value) => ({ userRole: value }),
+    },
+};
+const rtcCustomEventActions = Object.values(rtcAnalyticsCustomEvents)
+    .flatMap(({ actions }) => { var _a; return (_a = actions === null || actions === void 0 ? void 0 : actions.map((action) => action)) !== null && _a !== void 0 ? _a : null; })
+    .filter((action) => action !== null);
+const makeComparable = (value) => {
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return value;
+};
+const initialState$3 = {
+    reportedValues: {},
+};
+const rtcAnalyticsSlice = createSlice({
+    initialState: initialState$3,
+    name: "rtcAnalytics",
+    reducers: {
+        updateReportedValues(state, action) {
+            return Object.assign(Object.assign({}, state), { reportedValues: Object.assign(Object.assign({}, state.reportedValues), { [action.payload.rtcEventName]: action.payload.value }) });
+        },
+    },
+});
+const doRtcAnalyticsCustomEventsInitialize = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+    if (!rtcManager)
+        return;
+    rtcManager.sendStatsCustomEvent("insightsStats", {
+        _time: Date.now(),
+        ls: 0,
+        lr: 0,
+        bs: 0,
+        br: 0,
+        cpu: 0,
+    });
+    Object.values(rtcAnalyticsCustomEvents).forEach(({ rtcEventName, getValue, getOutput }) => {
+        var _a;
+        const value = getValue(state);
+        const output = Object.assign(Object.assign({}, getOutput(value)), { _time: Date.now() });
+        const comparableValue = makeComparable(value);
+        if (((_a = state.rtcAnalytics.reportedValues) === null || _a === void 0 ? void 0 : _a[rtcEventName]) !== comparableValue) {
+            rtcManager.sendStatsCustomEvent(rtcEventName, output);
+            dispatch(updateReportedValues({ rtcEventName, value }));
+        }
+    });
+});
+const { updateReportedValues } = rtcAnalyticsSlice.actions;
+startAppListening({
+    matcher: isAnyOf(...rtcCustomEventActions),
+    effect: ({ type }, { getState, dispatch }) => {
+        var _a;
+        const state = getState();
+        const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+        if (!rtcManager)
+            return;
+        const rtcCustomEvent = Object.values(rtcAnalyticsCustomEvents).find(({ actions }) => actions === null || actions === void 0 ? void 0 : actions.map((a) => a.type).includes(type));
+        if (!rtcCustomEvent)
+            return;
+        const { getValue, getOutput, rtcEventName } = rtcCustomEvent;
+        const value = getValue(state);
+        const comparableValue = makeComparable(value);
+        const output = Object.assign(Object.assign({}, getOutput(value)), { _time: Date.now() });
+        if (((_a = state.rtcAnalytics.reportedValues) === null || _a === void 0 ? void 0 : _a[rtcEventName]) !== comparableValue) {
+            rtcManager.sendStatsCustomEvent(rtcEventName, output);
+            dispatch(updateReportedValues({ rtcEventName, value }));
+        }
+    },
+});
+createReactor([selectRtcManagerInitialized], ({ dispatch }, selectRtcManagerInitialized) => {
+    if (selectRtcManagerInitialized) {
+        dispatch(doRtcAnalyticsCustomEventsInitialize());
+    }
+});
+
+function streamIdForClient({ isPresentation, stream }) {
+    var _a, _b;
+    return isPresentation ? (_b = (_a = stream === null || stream === void 0 ? void 0 : stream.outboundId) !== null && _a !== void 0 ? _a : stream === null || stream === void 0 ? void 0 : stream.inboundId) !== null && _b !== void 0 ? _b : stream === null || stream === void 0 ? void 0 : stream.id : "0";
+}
+function isClientSpotlighted({ spotlights, isPresentation, clientId, stream, }) {
+    return !!spotlights.find((s) => {
+        const streamId = streamIdForClient({ isPresentation, stream });
+        return s.clientId === clientId && s.streamId === streamId;
+    });
+}
+function mergeSpotlight(spotlights, spotlight) {
+    const found = spotlights.find((s) => s.clientId === spotlight.clientId && s.streamId === spotlight.streamId);
+    if (found) {
+        return spotlights;
+    }
+    return spotlights.concat(spotlight);
+}
+function mapSpotlightsToClientViews(spotlights, clientViews) {
+    return spotlights.reduce((acc, s) => {
+        const clientView = clientViews.find((c) => s.clientId === c.clientId && s.streamId === streamIdForClient(c));
+        if (clientView && !acc.includes(clientView)) {
+            acc.push(clientView);
+        }
+        return acc;
+    }, []);
+}
+const initialState$2 = {
+    sorted: [],
+};
+const spotlightsSlice = createSlice({
+    name: "spotlights",
+    initialState: initialState$2,
+    reducers: {
+        addSpotlight(state, action) {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: mergeSpotlight(state.sorted, { clientId, streamId }) });
+        },
+        removeSpotlight(state, action) {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: state.sorted.filter((s) => !(s.clientId === clientId && s.streamId === streamId)) });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            if (!action.payload.room) {
+                return state;
+            }
+            const { spotlights } = action.payload.room;
+            return Object.assign(Object.assign({}, state), { sorted: spotlights });
+        });
+        builder.addCase(signalEvents.spotlightAdded, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: mergeSpotlight(state.sorted, { clientId, streamId }) });
+        });
+        builder.addCase(signalEvents.spotlightRemoved, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: state.sorted.filter((s) => !(s.clientId === clientId && s.streamId === streamId)) });
+        });
+        builder.addMatcher(isAnyOf(signalEvents.clientKicked, signalEvents.clientLeft), (state, action) => {
+            const { clientId } = action.payload;
+            return Object.assign(Object.assign({}, state), { sorted: state.sorted.filter((s) => s.clientId !== clientId) });
+        });
+    },
+});
+const { addSpotlight, removeSpotlight } = spotlightsSlice.actions;
+const doSpotlightParticipant = createAppAuthorizedThunk((state) => selectIsAuthorizedToSpotlight(state), ({ id }) => (_, getState) => {
+    const state = getState();
+    const clientView = selectAllClientViews(state).find((c) => c.clientId === id);
+    if (!clientView) {
+        return;
+    }
+    const { socket } = selectSignalConnectionRaw(state);
+    const streamId = streamIdForClient(clientView);
+    const payload = { clientId: clientView.id, streamId: streamId !== null && streamId !== void 0 ? streamId : "0" };
+    socket === null || socket === void 0 ? void 0 : socket.emit("add_spotlight", payload);
+});
+const doRemoveSpotlight = createAppAuthorizedThunk((state) => selectIsAuthorizedToSpotlight(state), ({ id }) => (_, getState) => {
+    const state = getState();
+    const clientView = selectAllClientViews(state).find((c) => c.clientId === id);
+    if (!clientView) {
+        return;
+    }
+    const { socket } = selectSignalConnectionRaw(state);
+    const streamId = streamIdForClient(clientView);
+    const payload = { clientId: clientView.id, streamId: streamId !== null && streamId !== void 0 ? streamId : "0" };
+    socket === null || socket === void 0 ? void 0 : socket.emit("remove_spotlight", payload);
+});
+const selectSpotlightsRaw = (state) => state.spotlights;
+const selectSpotlights = (state) => state.spotlights.sorted;
+const selectIsLocalParticipantSpotlighted = createSelector(selectLocalParticipantRaw, selectSpotlights, (localParticipant, spotlights) => {
+    return isClientSpotlighted({ clientId: localParticipant.id, stream: localParticipant.stream, spotlights });
+});
+const selectSpotlightedClientViews = createSelector(selectAllClientViews, selectSpotlights, (clientViews, spotlights) => {
+    return mapSpotlightsToClientViews(spotlights, clientViews);
+});
+startAppListening({
+    actionCreator: doStartScreenshare.fulfilled,
+    effect: ({ payload }, { getState, dispatch }) => {
+        const { stream } = payload;
+        const state = getState();
+        const localParticipant = selectLocalParticipantRaw(state);
+        if (!localParticipant) {
+            return;
+        }
+        dispatch(addSpotlight({ clientId: localParticipant.id, streamId: stream.id }));
+    },
+});
+startAppListening({
+    actionCreator: stopScreenshare,
+    effect: ({ payload }, { getState, dispatch }) => {
+        const { stream } = payload;
+        const state = getState();
+        const localParticipant = selectLocalParticipantRaw(state);
+        if (!localParticipant) {
+            return;
+        }
+        dispatch(removeSpotlight({ clientId: localParticipant.id, streamId: stream.id }));
+    },
+});
+
+const initialState$1 = {
+    isStreaming: false,
+    error: null,
+    startedAt: undefined,
+};
+const streamingSlice = createSlice({
+    name: "streaming",
+    initialState: initialState$1,
+    reducers: {
+        doHandleStreamingStarted: (state) => {
+            return Object.assign(Object.assign({}, state), { isStreaming: true, error: null, startedAt: new Date().getTime() });
+        },
+        doHandleStreamingStopped: (state) => {
+            return Object.assign(Object.assign({}, state), { isStreaming: false });
+        },
+    },
+});
+const { doHandleStreamingStarted, doHandleStreamingStopped } = streamingSlice.actions;
+const selectStreamingRaw = (state) => state.streaming;
+
+const initialState = {
+    waitingParticipants: [],
+};
+const waitingParticipantsSlice = createSlice({
+    name: "waitingParticipants",
+    initialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, { payload }) => {
+            var _a;
+            if ((_a = payload.room) === null || _a === void 0 ? void 0 : _a.knockers.length) {
+                return Object.assign(Object.assign({}, state), { waitingParticipants: payload.room.knockers.map((knocker) => ({
+                        id: knocker.clientId,
+                        displayName: knocker.displayName,
+                    })) });
+            }
+            else {
+                return state;
+            }
+        });
+        builder.addCase(signalEvents.roomKnocked, (state, action) => {
+            const { clientId, displayName } = action.payload;
+            return Object.assign(Object.assign({}, state), { waitingParticipants: [...state.waitingParticipants, { id: clientId, displayName }] });
+        });
+        builder.addCase(signalEvents.knockerLeft, (state, action) => {
+            const { clientId } = action.payload;
+            return Object.assign(Object.assign({}, state), { waitingParticipants: state.waitingParticipants.filter((p) => p.id !== clientId) });
+        });
+    },
+});
+const doAcceptWaitingParticipant = createRoomConnectedThunk((payload) => (dispatch, getState) => {
+    const { participantId } = payload;
+    const state = getState();
+    const socket = selectSignalConnectionSocket(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("handle_knock", {
+        action: "accept",
+        clientId: participantId,
+        response: {},
+    });
+});
+const doRejectWaitingParticipant = createRoomConnectedThunk((payload) => (dispatch, getState) => {
+    const { participantId } = payload;
+    const state = getState();
+    const socket = selectSignalConnectionSocket(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("handle_knock", {
+        action: "reject",
+        clientId: participantId,
+        response: {},
+    });
+});
+const selectWaitingParticipantsRaw = (state) => state.waitingParticipants;
+const selectWaitingParticipants = (state) => state.waitingParticipants.waitingParticipants;
+
+var _a;
+const IS_DEV = (_a = undefined === "true") !== null && _a !== void 0 ? _a : false;
+const appReducer = combineReducers({
+    app: appSlice.reducer,
+    authorization: authorizationSlice.reducer,
+    chat: chatSlice.reducer,
+    cloudRecording: cloudRecordingSlice.reducer,
+    connectionMonitor: connectionMonitorSlice.reducer,
+    deviceCredentials: deviceCredentialsSlice.reducer,
+    localMedia: localMediaSlice.reducer,
+    localParticipant: localParticipantSlice.reducer,
+    localScreenshare: localScreenshareSlice.reducer,
+    notifications: notificationsSlice.reducer,
+    organization: organizationSlice.reducer,
+    remoteParticipants: remoteParticipantsSlice.reducer,
+    room: roomSlice.reducer,
+    roomConnection: roomConnectionSlice.reducer,
+    rtcAnalytics: rtcAnalyticsSlice.reducer,
+    rtcConnection: rtcConnectionSlice.reducer,
+    signalConnection: signalConnectionSlice.reducer,
+    spotlights: spotlightsSlice.reducer,
+    streaming: streamingSlice.reducer,
+    waitingParticipants: waitingParticipantsSlice.reducer,
+});
+const rootReducer = (state, action) => {
+    var _a;
+    if (doAppStart.match(action)) {
+        const resetState = {
+            app: Object.assign(Object.assign({}, appSlice.getInitialState()), { initialConfig: (_a = state === null || state === void 0 ? void 0 : state.app) === null || _a === void 0 ? void 0 : _a.initialConfig }),
+            localMedia: Object.assign(Object.assign({}, localMediaSlice.getInitialState()), state === null || state === void 0 ? void 0 : state.localMedia),
+        };
+        return appReducer(resetState, action);
+    }
+    return appReducer(state, action);
+};
+const createStore = ({ preloadedState, injectServices, }) => {
+    return configureStore({
+        devTools: IS_DEV,
+        reducer: rootReducer,
+        middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+            thunk: {
+                extraArgument: { services: injectServices },
+            },
+            serializableCheck: false,
+        }).prepend(listenerMiddleware.middleware),
+        preloadedState,
+    });
+};
+const observeStore = (store, select, onChange) => {
+    let currentState;
+    function handleChange() {
+        const nextState = select(store.getState());
+        if (nextState !== currentState) {
+            currentState = nextState;
+            onChange(currentState);
+        }
+    }
+    const unsubscribe = store.subscribe(handleChange);
+    handleChange();
+    return unsubscribe;
+};
+
+class Response {
+    constructor(initialValues = {}) {
+        this.data = initialValues.data === undefined ? {} : initialValues.data;
+        this.headers = initialValues.headers || {};
+        this.status = initialValues.status || 200;
+        this.statusText = initialValues.statusText || "OK";
+        this.url = initialValues.url || null;
+    }
+}
+
+function assertTruthy(value, parameterName) {
+    assert.ok(value, `${parameterName} is required`);
+    return value;
+}
+function assertBoolean(value, parameterName) {
+    assert.ok(typeof value === "boolean", `${parameterName}<boolean> is required`);
+    return value;
+}
+function assertNumber(value, parameterName) {
+    assert.ok(typeof value === "number", `${parameterName}<number> is required`);
+    return value;
+}
+function assertString(value, parameterName) {
+    assert.ok(typeof value === "string", `${parameterName}<string> is required`);
+    return value;
+}
+function assertInstanceOf(value, type, parameterName) {
+    const resolvedParameterName = parameterName || type.name[0].toLowerCase() + type.name.substring(1);
+    assert.ok(value instanceof type, `${resolvedParameterName}<${type.name}> is required`);
+    return value;
+}
+function assertRoomName(roomName, parameterName = "roomName") {
+    assertString(roomName, parameterName);
+    assert.ok(typeof roomName === "string" && roomName[0] === "/", `${parameterName} must begin with a '/'`);
+    return roomName;
+}
+function assertArray(array, parameterName) {
+    assert.ok(Array.isArray(array), `${parameterName}<array> is required`);
+    return array;
+}
+function assertOneOf(value, allowedValues, parameterName) {
+    assertTruthy(value, "value");
+    assertArray(allowedValues, "allowedValues");
+    const isAllowed = allowedValues.includes(value);
+    if (!isAllowed) {
+        throw new Error(`${parameterName}<string> must be one of the following: ${allowedValues.join(", ")}`);
+    }
+    return value;
+}
+function assertRecord(ref, name) {
+    if (ref === null || ref === undefined || typeof ref !== "object" || Array.isArray(ref)) {
+        throw new Error(`${name} must be a record. ${JSON.stringify(ref)}`);
+    }
+    return ref;
+}
+function assertNullOrType(ref, type, name, message) {
+    assertString(name, "name");
+    const errorMessage = message || `${name} must be null or of type ${type}`;
+    assert.ok(ref === null || typeof ref === type, errorMessage);
+}
+function assertNullOrString(ref, name, message) {
+    assertString(name, "name");
+    assertNullOrType(ref, "string", name, message);
+}
+
+function _getAbsoluteUrl({ baseUrl, url }) {
+    return baseUrl ? baseUrl + url : url;
+}
+class HttpClient {
+    constructor({ baseUrl }) {
+        assertString(baseUrl, "baseUrl");
+        this._baseUrl = baseUrl;
+    }
+    _requestAxios(url, options) {
+        const axiosOptions = Object.assign({}, options, {
+            url,
+            baseURL: this._baseUrl,
+        });
+        return axios.request(axiosOptions);
+    }
+    request(url, options) {
+        assertString(url, "url");
+        assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        assert.ok(options, "options are required");
+        return this._requestAxios(url, options)
+            .then((response) => {
+            const { data, headers, status, statusText, config } = response;
+            const requestUrl = config && config.url ? _getAbsoluteUrl({ baseUrl: config.baseURL, url: config.url }) : null;
+            return new Response({
+                data,
+                headers,
+                status,
+                statusText,
+                url: requestUrl,
+            });
+        })
+            .catch((error) => {
+            const responseObject = error.response;
+            if (!responseObject) {
+                throw new Error("Could not make the request.");
+            }
+            const { data, headers, status, statusText, config } = responseObject;
+            const requestUrl = config && config.url ? _getAbsoluteUrl({ baseUrl: config.baseURL, url: config.url }) : null;
+            return Promise.reject(new Response({
+                data,
+                headers,
+                status,
+                statusText,
+                url: requestUrl,
+            }));
+        });
+    }
+}
+
+class MultipartHttpClient {
+    constructor({ httpClient }) {
+        assert.ok(httpClient, "httpClient is required");
+        this._httpClient = httpClient;
+    }
+    static dataToFormData(data) {
+        assert.ok(data, "data is required");
+        const fd = new FormData();
+        Object.keys(data).forEach((key) => {
+            const value = data[key];
+            fd.append(key, value);
+        });
+        return fd;
+    }
+    request(url, options = {}) {
+        const headers = Object.assign(options.headers || {}, {
+            "Content-Type": undefined,
+        });
+        return this._httpClient.request(url, Object.assign(options, {
+            headers,
+            transformRequest: MultipartHttpClient.dataToFormData,
+        }));
+    }
+}
+
+let btoa;
+if (typeof window === "object") {
+    btoa = window.btoa || nodeBtoa;
+}
+else if (typeof global === "object") {
+    btoa = global.btoa || nodeBtoa;
+}
+else {
+    btoa = nodeBtoa;
+}
+function _getAuthHeader(credentials) {
+    if (credentials && credentials.credentials) {
+        const btoaStr = `${credentials.credentials.uuid}:${credentials.hmac}`;
+        return { Authorization: `Basic ${btoa(btoaStr)}` };
+    }
+    return {};
+}
+const noCredentials = () => Promise.resolve(null);
+class AuthenticatedHttpClient {
+    constructor({ httpClient, fetchDeviceCredentials }) {
+        this._httpClient = httpClient;
+        this._fetchDeviceCredentials = fetchDeviceCredentials;
+    }
+    request(url, options) {
+        return this._fetchDeviceCredentials().then((credentials) => {
+            const headers = Object.assign({}, options.headers, _getAuthHeader(credentials), {
+                "X-Appearin-Device-Platform": "web",
+            });
+            const httpClientOptions = Object.assign({}, options, { headers });
+            return this._httpClient.request(url, httpClientOptions);
+        });
+    }
+}
+class ApiClient {
+    constructor({ baseUrl = "https://api.appearin.net", fetchDeviceCredentials = noCredentials, } = {}) {
+        this.authenticatedHttpClient = new AuthenticatedHttpClient({
+            httpClient: new HttpClient({
+                baseUrl,
+            }),
+            fetchDeviceCredentials,
+        });
+        this.authenticatedFormDataHttpClient = new MultipartHttpClient({ httpClient: this.authenticatedHttpClient });
+    }
+    request(url, options) {
+        assertString(url, "url");
+        assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        assert.ok(options, "options are required");
+        return this.authenticatedHttpClient.request(url, options);
+    }
+    requestMultipart(url, options) {
+        assertString(url, "url");
+        assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        assert.ok(options, "options are required");
+        return this.authenticatedFormDataHttpClient.request(url, options);
+    }
+}
+
+function nullOrExtract(extract) {
+    return (data, propertyName) => {
+        const record = assertRecord(data, "data");
+        const value = record[propertyName];
+        return value === null || value === undefined ? null : extract(data, propertyName);
+    };
+}
+function extractString(data, propertyName) {
+    const record = assertRecord(data, "data");
+    return assertString(record[propertyName], propertyName);
+}
+const extractNullOrString = nullOrExtract(extractString);
+function extractDate(data, propertyName) {
+    const dateString = extractString(data, propertyName);
+    const d = new Date(dateString);
+    if (isNaN(d.getTime())) {
+        throw new Error(`Invalid date for ${dateString}`);
+    }
+    return d;
+}
+function extractArrayOfJson(data, propertyName) {
+    const record = assertRecord(data, "data");
+    return assertArray(record[propertyName], propertyName);
+}
+function extractArray(data, propertyName, transformer) {
+    return extractArrayOfJson(data, propertyName).map((value) => transformer(value));
+}
+function extractJson(data, propertyName) {
+    const record = assertRecord(data, "data");
+    const value = record[propertyName];
+    return value === undefined ? null : value;
+}
+
+class Credentials {
+    constructor(uuid, hmac, userId = undefined) {
+        this.credentials = {
+            uuid,
+        };
+        this.hmac = hmac;
+        this.userId = userId;
+    }
+    toJson() {
+        return Object.assign({ credentials: this.credentials, hmac: this.hmac }, (this.userId && { userId: this.userId }));
+    }
+    static fromJson(json) {
+        return new Credentials(extractString(extractJson(json, "credentials"), "uuid"), extractString(json, "hmac"), extractNullOrString(json, "userId") || undefined);
+    }
+}
+
+class DeviceService {
+    constructor({ apiClient }) {
+        this._apiClient = apiClient;
+    }
+    getCredentials() {
+        return this._apiClient
+            .request("/devices", {
+            method: "post",
+        })
+            .then(({ data }) => {
+            return Credentials.fromJson(data);
+        })
+            .catch((error) => {
+            if (error.response) {
+                if (error.response.status === 404) {
+                    return null;
+                }
+            }
+            throw error;
+        });
+    }
+}
+
+class ChromeStorageStore {
+    constructor(key, chromeStorage) {
+        this._key = key;
+        this._chromeStorage = chromeStorage;
+    }
+    loadOrDefault(defaultValue) {
+        return new Promise((resolve) => {
+            this._chromeStorage.get(this._key, (result) => {
+                const unknownResult = result;
+                resolve(unknownResult[this._key] || defaultValue);
+            });
+        });
+    }
+    save(value) {
+        return new Promise((resolve) => {
+            this._chromeStorage.set({ [this._key]: value }, () => {
+                resolve();
+            });
+        });
+    }
+}
+
+class LocalStorageStore {
+    constructor(key, localStorage) {
+        assertTruthy(localStorage, "localStorage");
+        this._key = assertString(key, "key");
+        this._localStorage = localStorage;
+    }
+    loadOrDefault(defaultValue) {
+        try {
+            const value = this._localStorage.getItem(this._key);
+            if (value) {
+                try {
+                    return Promise.resolve(JSON.parse(value));
+                }
+                catch (e) {
+                }
+            }
+            return Promise.resolve(defaultValue);
+        }
+        catch (e) {
+            console.warn("Error getting access to storage. Are cookies blocked?", e);
+            return Promise.resolve(defaultValue);
+        }
+    }
+    save(value) {
+        try {
+            this._localStorage.setItem(this._key, JSON.stringify(value));
+            return Promise.resolve();
+        }
+        catch (e) {
+            console.warn("Error getting access to storage. Are cookies blocked?", e);
+            return Promise.reject(e);
+        }
+    }
+}
+
+let localStorage;
+try {
+    localStorage = self.localStorage;
+}
+catch (e) {
+    localStorage = {
+        getItem: () => undefined,
+        key: () => undefined,
+        setItem: () => undefined,
+        removeItem: () => undefined,
+        hasOwnProperty: () => undefined,
+        length: 0,
+    };
+}
+var localStorage$1 = localStorage;
+
+const events = {
+    CREDENTIALS_SAVED: "credentials_saved",
+};
+class CredentialsService extends EventEmitter {
+    constructor({ deviceService, credentialsStore, }) {
+        super();
+        this._deviceService = deviceService;
+        this._credentialsStore = credentialsStore;
+    }
+    static create({ baseUrl, storeName = "CredentialsStorage", storeType = "localStorage", }) {
+        const deviceService = new DeviceService({
+            apiClient: new ApiClient({ baseUrl }),
+        });
+        let credentialsStore = null;
+        if (storeType === "localStorage") {
+            credentialsStore = new LocalStorageStore(storeName, localStorage$1);
+        }
+        else if (storeType === "chromeStorage") {
+            credentialsStore = new ChromeStorageStore(storeName, window["chrome"].storage.local);
+        }
+        else {
+            throw new Error(`Unknown store type: ${storeType}`);
+        }
+        return new CredentialsService({
+            deviceService,
+            credentialsStore,
+        });
+    }
+    _fetchNewCredentialsFromApi() {
+        const credentialsStore = this._credentialsStore;
+        return new Promise((resolve) => {
+            const fetchCredentials = () => {
+                this._deviceService
+                    .getCredentials()
+                    .then((credentials) => {
+                    return credentialsStore
+                        .save(credentials ? credentials.toJson() : null)
+                        .then(() => resolve(credentials));
+                })
+                    .catch(() => {
+                    setTimeout(fetchCredentials, 2000);
+                });
+            };
+            fetchCredentials();
+        });
+    }
+    getCurrentCredentials() {
+        return this._credentialsStore.loadOrDefault(null).then((json) => (json ? Credentials.fromJson(json) : null));
+    }
+    getCredentials() {
+        if (!this.credentialsPromise) {
+            this.credentialsPromise = this.getCurrentCredentials().then((storedCredentials) => {
+                if (storedCredentials) {
+                    return storedCredentials;
+                }
+                return this._fetchNewCredentialsFromApi();
+            });
+        }
+        return this.credentialsPromise;
+    }
+    saveCredentials(credentials) {
+        this.credentialsPromise = undefined;
+        return this._credentialsStore.save(credentials.toJson()).then(() => {
+            this.emit(events.CREDENTIALS_SAVED, credentials);
+            return credentials;
+        });
+    }
+    setUserId(userId) {
+        return this.getCurrentCredentials()
+            .then((storedCredentials) => {
+            if (!storedCredentials) {
+                console.error("Illegal state: no credentials to set user id for.");
+            }
+            const userIdChangedFromLocalStorage = storedCredentials === null || storedCredentials.userId !== userId;
+            if (!userIdChangedFromLocalStorage) {
+                return undefined;
+            }
+            return this._credentialsStore.save(Object.assign({}, storedCredentials === null || storedCredentials === void 0 ? void 0 : storedCredentials.toJson(), { userId }));
+        })
+            .then(() => undefined);
+    }
+}
+
+const noOrganization = () => Promise.resolve(undefined);
+class OrganizationApiClient {
+    constructor({ apiClient, fetchOrganization = noOrganization, }) {
+        this._apiClient = apiClient;
+        this._fetchOrganization = fetchOrganization;
+        this._apiClient = apiClient;
+    }
+    _callRequestMethod(method, url, options) {
+        assertString(url, "url");
+        assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        assert.ok(options, "options are required");
+        return this._fetchOrganization().then((organization) => {
+            if (!organization) {
+                return this._apiClient[method](url, options);
+            }
+            const { organizationId } = organization;
+            return this._apiClient[method](`/organizations/${encodeURIComponent(organizationId)}${url}`, options);
+        });
+    }
+    request(url, options) {
+        return this._callRequestMethod("request", url, options);
+    }
+    requestMultipart(url, options) {
+        return this._callRequestMethod("requestMultipart", url, options);
+    }
+}
+
+class EmbeddedFreeTierStatus {
+    constructor({ isExhausted, renewsAt, totalMinutesLimit, totalMinutesUsed, }) {
+        this.isExhausted = isExhausted;
+        this.renewsAt = renewsAt;
+        this.totalMinutesLimit = totalMinutesLimit;
+        this.totalMinutesUsed = totalMinutesUsed;
+    }
+    static fromJson(data) {
+        return new EmbeddedFreeTierStatus({
+            isExhausted: assertBoolean(data.isExhausted, "isExhausted"),
+            renewsAt: new Date(assertString(data.renewsAt, "renewsAt")),
+            totalMinutesLimit: assertNumber(data.totalMinutesLimit, "totalMinutesLimit"),
+            totalMinutesUsed: assertNumber(data.totalMinutesUsed, "totalMinutesUsed"),
+        });
+    }
+}
+
+class Account {
+    constructor({ basePlanId, embeddedFreeTierStatus, isDeactivated, isOnTrial, onTrialUntil, trialStatus, }) {
+        this.basePlanId = basePlanId;
+        this.isDeactivated = isDeactivated;
+        this.isOnTrial = isOnTrial;
+        this.onTrialUntil = onTrialUntil || null;
+        this.trialStatus = trialStatus || null;
+        this.embeddedFreeTierStatus = embeddedFreeTierStatus || null;
+    }
+    static fromJson(data) {
+        return new Account({
+            basePlanId: typeof data.basePlanId === "string" ? data.basePlanId : null,
+            isDeactivated: assertBoolean(data.isDeactivated, "isDeactivated"),
+            isOnTrial: assertBoolean(data.isOnTrial, "isOnTrial"),
+            onTrialUntil: typeof data.onTrialUntil === "string" ? new Date(data.onTrialUntil) : null,
+            trialStatus: typeof data.trialStatus === "string" ? data.trialStatus : null,
+            embeddedFreeTierStatus: data.embeddedFreeTierStatus
+                ? EmbeddedFreeTierStatus.fromJson(data.embeddedFreeTierStatus)
+                : null,
+        });
+    }
+}
+
+function hasValue(value) {
+    return value !== null && value !== undefined;
+}
+function createOrganizationLimits(limits = {}) {
+    return {
+        maxNumberOfInvitationsAndUsers: hasValue(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfInvitationsAndUsers)
+            ? Number(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfInvitationsAndUsers)
+            : null,
+        maxNumberOfClaimedRooms: hasValue(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfClaimedRooms)
+            ? Number(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfClaimedRooms)
+            : null,
+        maxRoomLimitPerOrganization: hasValue(limits === null || limits === void 0 ? void 0 : limits.maxRoomLimitPerOrganization)
+            ? Number(limits === null || limits === void 0 ? void 0 : limits.maxRoomLimitPerOrganization)
+            : null,
+        trialMinutesLimit: hasValue(limits === null || limits === void 0 ? void 0 : limits.trialMinutesLimit) ? Number(limits === null || limits === void 0 ? void 0 : limits.trialMinutesLimit) : null,
+        includedUnits: hasValue(limits === null || limits === void 0 ? void 0 : limits.includedUnits) ? Number(limits === null || limits === void 0 ? void 0 : limits.includedUnits) : null,
+    };
+}
+class Organization {
+    constructor(properties) {
+        this.logoImageUrl = null;
+        this.roomBackgroundImageUrl = null;
+        this.roomBackgroundThumbnailUrl = null;
+        this.roomKnockPageBackgroundImageUrl = null;
+        this.roomKnockPageBackgroundThumbnailUrl = null;
+        this.preferences = null;
+        this.onboardingSurvey = null;
+        this.type = null;
+        assertInstanceOf(properties, Object, "properties");
+        assertString(properties.organizationId, "organizationId");
+        assertString(properties.organizationName, "organizationName");
+        assertString(properties.subdomain, "subdomain");
+        assertInstanceOf(properties.permissions, Object, "permissions");
+        assertInstanceOf(properties.limits, Object, "limits");
+        this.organizationId = properties.organizationId;
+        this.organizationName = properties.organizationName;
+        this.subdomain = properties.subdomain;
+        this.permissions = properties.permissions;
+        this.limits = properties.limits;
+        this.account = properties.account ? new Account(properties.account) : null;
+        this.logoImageUrl = properties.logoImageUrl;
+        this.roomBackgroundImageUrl = properties.roomBackgroundImageUrl;
+        this.roomBackgroundThumbnailUrl = properties.roomBackgroundThumbnailUrl;
+        this.roomKnockPageBackgroundImageUrl = properties.roomKnockPageBackgroundImageUrl;
+        this.roomKnockPageBackgroundThumbnailUrl = properties.roomKnockPageBackgroundThumbnailUrl;
+        this.preferences = properties.preferences;
+        this.onboardingSurvey = properties.onboardingSurvey;
+        this.type = properties.type;
+    }
+    static fromJson(data) {
+        const parsedData = assertInstanceOf(data, Object, "data");
+        const preferences = ((parsedData === null || parsedData === void 0 ? void 0 : parsedData.preferences) || {});
+        const onboardingSurvey = ((parsedData === null || parsedData === void 0 ? void 0 : parsedData.onboardingSurvey) || null);
+        const permissions = assertInstanceOf(parsedData.permissions, Object, "permissions");
+        return new Organization({
+            organizationId: assertString(parsedData.organizationId, "organizationId"),
+            organizationName: assertString(parsedData.organizationName, "organizationName"),
+            subdomain: assertString(parsedData.subdomain, "subdomain"),
+            permissions,
+            limits: createOrganizationLimits(assertInstanceOf(parsedData.limits, Object, "limits")),
+            account: parsedData.account ? Account.fromJson(parsedData.account) : null,
+            logoImageUrl: typeof parsedData.logoImageUrl === "string" ? parsedData.logoImageUrl : null,
+            roomBackgroundImageUrl: typeof parsedData.roomBackgroundImageUrl === "string" ? parsedData.roomBackgroundImageUrl : null,
+            roomBackgroundThumbnailUrl: typeof parsedData.roomBackgroundThumbnailUrl === "string"
+                ? parsedData.roomBackgroundThumbnailUrl
+                : null,
+            roomKnockPageBackgroundImageUrl: typeof parsedData.roomKnockPageBackgroundImageUrl === "string"
+                ? parsedData.roomKnockPageBackgroundImageUrl
+                : null,
+            roomKnockPageBackgroundThumbnailUrl: typeof parsedData.roomKnockPageBackgroundThumbnailUrl === "string"
+                ? parsedData.roomKnockPageBackgroundThumbnailUrl
+                : null,
+            preferences,
+            onboardingSurvey,
+            type: typeof parsedData.type === "string" ? parsedData.type : null,
+        });
+    }
+}
+Organization.GLOBAL_ORGANIZATION_ID = "1";
+
+class OrganizationService {
+    constructor({ apiClient }) {
+        this._apiClient = apiClient;
+    }
+    createOrganization({ organizationName, subdomain, owner, }) {
+        const { displayName, consents } = owner || {};
+        const email = "email" in owner
+            ? {
+                value: owner.email,
+                verificationCode: assertString(owner.verificationCode, "owner.verificationCode"),
+            }
+            : null;
+        const idToken = "idToken" in owner ? owner.idToken : null;
+        assertString(subdomain, "subdomain");
+        assertString(organizationName, "organizationName");
+        assertString(displayName, "owner.displayName");
+        assert.ok(email || idToken, "owner.email or owner.idToken is required");
+        if (consents) {
+            assertArray(consents, "consents");
+            for (const { consentRevisionId, action } of consents) {
+                assertString(consentRevisionId, "consentRevisionId");
+                assertNullOrString(action, "action");
+            }
+        }
+        return this._apiClient
+            .request(`/organizations`, {
+            method: "POST",
+            data: {
+                organizationName,
+                type: "private",
+                subdomain,
+                owner: Object.assign(Object.assign(Object.assign(Object.assign({}, (email && { email })), (idToken && { idToken })), (consents && { consents })), { displayName }),
+            },
+        })
+            .then(({ data }) => {
+            return extractString(data, "organizationId");
+        });
+    }
+    getOrganizationBySubdomain(subdomain) {
+        assertString(subdomain, "subdomain");
+        return this._apiClient
+            .request(`/organization-subdomains/${encodeURIComponent(subdomain)}/?fields=permissions,account,onboardingSurvey`, {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            return Organization.fromJson(data);
+        })
+            .catch((res) => {
+            if (res instanceof Response) {
+                if (res.status === 404) {
+                    return null;
+                }
+                throw new Error(res.statusText);
+            }
+            throw res;
+        });
+    }
+    getOrganizationByOrganizationId(organizationId) {
+        assertString(organizationId, "organizationId");
+        return this._apiClient
+            .request(`/organizations/${encodeURIComponent(organizationId)}?fields=permissions,account`, {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            return Organization.fromJson(data);
+        })
+            .catch((res) => {
+            if (res instanceof Response) {
+                if (res.status === 404) {
+                    return null;
+                }
+                throw new Error(res.statusText);
+            }
+            throw res;
+        });
+    }
+    getOrganizationsByContactPoint(options) {
+        const { code } = options;
+        const email = "email" in options ? options.email : null;
+        const phoneNumber = "phoneNumber" in options ? options.phoneNumber : null;
+        assert.ok((email || phoneNumber) && !(email && phoneNumber), "either email or phoneNumber is required");
+        assertString(code, "code");
+        const contactPoint = email ? { type: "email", value: email } : { type: "phoneNumber", value: phoneNumber };
+        return this._apiClient
+            .request("/organization-queries", {
+            method: "POST",
+            data: {
+                contactPoint,
+                code,
+            },
+        })
+            .then(({ data }) => {
+            return extractArray(data, "organizations", (organization) => Organization.fromJson(organization));
+        });
+    }
+    getOrganizationsByIdToken({ idToken }) {
+        assertString(idToken, "idToken");
+        return this._apiClient
+            .request("/organization-queries", {
+            method: "POST",
+            data: {
+                idToken,
+            },
+        })
+            .then(({ data }) => {
+            return extractArray(data, "organizations", (organization) => {
+                return Organization.fromJson(Object.assign({ permissions: {}, limits: {} }, assertRecord(organization, "organization")));
+            });
+        });
+    }
+    getOrganizationsByLoggedInUser() {
+        return this._apiClient
+            .request("/user/organizations", {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            return extractArray(data, "organizations", (o) => {
+                return Organization.fromJson(Object.assign({ permissions: {}, limits: {} }, assertRecord(o, "organization")));
+            });
+        });
+    }
+    getSubdomainAvailability(subdomain) {
+        assertString(subdomain, "subdomain");
+        return this._apiClient
+            .request(`/organization-subdomains/${encodeURIComponent(subdomain)}/availability`, {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            assertInstanceOf(data, Object, "data");
+            return {
+                status: extractString(data, "status"),
+            };
+        });
+    }
+    updatePreferences({ organizationId, preferences, }) {
+        assertTruthy(organizationId, "organizationId");
+        assertTruthy(preferences, "preferences");
+        return this._apiClient
+            .request(`/organizations/${encodeURIComponent(organizationId)}/preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    deleteOrganization({ organizationId }) {
+        assertTruthy(organizationId, "organizationId");
+        return this._apiClient
+            .request(`/organizations/${encodeURIComponent(organizationId)}`, {
+            method: "DELETE",
+        })
+            .then(() => undefined);
+    }
+}
+
+class OrganizationServiceCache {
+    constructor({ organizationService, subdomain }) {
+        this._organizationService = organizationService;
+        this._subdomain = subdomain;
+        this._organizationPromise = null;
+    }
+    initOrganization() {
+        return this.fetchOrganization().then(() => undefined);
+    }
+    fetchOrganization() {
+        if (!this._organizationPromise) {
+            this._organizationPromise = this._organizationService.getOrganizationBySubdomain(this._subdomain);
+        }
+        return this._organizationPromise;
+    }
+}
+
+class Room {
+    constructor(properties = {}) {
+        assert.ok(properties instanceof Object, "properties<object> must be empty or an object");
+        this.isClaimed = false;
+        this.isBanned = false;
+        this.isLocked = false;
+        this.knockPage = {
+            backgroundImageUrl: null,
+            backgroundThumbnailUrl: null,
+        };
+        this.logoUrl = null;
+        this.backgroundImageUrl = null;
+        this.backgroundThumbnailUrl = null;
+        this.type = null;
+        this.legacyRoomType = null;
+        this.mode = null;
+        this.product = null;
+        this.roomName = null;
+        this.theme = null;
+        this.preferences = {};
+        this.protectedPreferences = {};
+        this.publicProfile = null;
+        const validProperties = {};
+        Object.getOwnPropertyNames(properties).forEach((prop) => {
+            if (Object.getOwnPropertyNames(this).indexOf(prop) !== -1) {
+                validProperties[prop] = properties[prop];
+            }
+        });
+        if (properties.ownerId !== undefined) {
+            this.ownerId = properties.ownerId;
+        }
+        if (properties.meeting !== undefined) {
+            this.meeting = properties.meeting;
+        }
+        Object.assign(this, validProperties);
+    }
+}
+
+class Meeting {
+    constructor({ meetingId, roomName, roomUrl, startDate, endDate, hostRoomUrl, viewerRoomUrl }) {
+        assertString(meetingId, "meetingId");
+        assertString(roomName, "roomName");
+        assertString(roomUrl, "roomUrl");
+        assertInstanceOf(startDate, Date, "startDate");
+        assertInstanceOf(endDate, Date, "endDate");
+        this.meetingId = meetingId;
+        this.roomName = roomName;
+        this.roomUrl = roomUrl;
+        this.startDate = startDate;
+        this.endDate = endDate;
+        this.hostRoomUrl = hostRoomUrl;
+        this.viewerRoomUrl = viewerRoomUrl;
+    }
+    static fromJson(data) {
+        return new Meeting({
+            meetingId: extractString(data, "meetingId"),
+            roomName: extractString(data, "roomName"),
+            roomUrl: extractString(data, "roomUrl"),
+            startDate: extractDate(data, "startDate"),
+            endDate: extractDate(data, "endDate"),
+            hostRoomUrl: extractNullOrString(data, "hostRoomUrl"),
+            viewerRoomUrl: extractNullOrString(data, "viewerRoomUrl"),
+        });
+    }
+}
+
+function createRoomUrl(roomName, path = "") {
+    const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+    return `/room/${encodedDisplayName}${path}`;
+}
+class RoomService {
+    constructor({ organizationApiClient }) {
+        this._organizationApiClient = assertInstanceOf(organizationApiClient, OrganizationApiClient);
+    }
+    getRooms({ types, fields = [] } = {}) {
+        assertArray(types, "types");
+        assertArray(fields, "fields");
+        return this._organizationApiClient
+            .request("/room", {
+            method: "GET",
+            params: { types: types.join(","), fields: fields.join(","), includeOnlyLegacyRoomType: "false" },
+        })
+            .then(({ data }) => data.rooms.map((room) => new Room(room)));
+    }
+    getRoom({ roomName, fields }) {
+        assertRoomName(roomName);
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/rooms/${encodedDisplayName}`, {
+            method: "GET",
+            params: Object.assign({ includeOnlyLegacyRoomType: "false" }, (fields && { fields: fields.join(",") })),
+        })
+            .then(({ data }) => new Room(Object.assign({}, data, Object.assign({ roomName }, (data.meeting && { meeting: Meeting.fromJson(data.meeting) })))))
+            .catch((response) => {
+            if (response.status === 404) {
+                return new Room({
+                    roomName,
+                    isClaimed: false,
+                    mode: "normal",
+                    product: {
+                        categoryName: "personal_free",
+                    },
+                    type: "personal",
+                    legacyRoomType: "free",
+                });
+            }
+            if (response.status === 400 && response.data.error === "Banned room") {
+                return new Room({ roomName, isBanned: true });
+            }
+            throw new Error(response.data ? response.data.error : "Could not fetch room information");
+        });
+    }
+    claimRoom({ roomName, type, mode, isLocked }) {
+        assertRoomName(roomName);
+        assertString(type, "type");
+        return this._organizationApiClient
+            .request("/room/claim", {
+            method: "POST",
+            data: Object.assign(Object.assign({ roomName,
+                type }, (typeof mode === "string" && { mode })), (typeof isLocked === "boolean" && { isLocked })),
+        })
+            .then(() => undefined)
+            .catch((response) => {
+            throw new Error(response.data.error || "Failed to claim room");
+        });
+    }
+    unclaimRoom(roomName) {
+        assertRoomName(roomName);
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}`, {
+            method: "DELETE",
+        })
+            .then(() => undefined);
+    }
+    renameRoom({ roomName, newRoomName }) {
+        assertRoomName(roomName);
+        assertString(newRoomName, "newRoomName");
+        const encodedRoomName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedRoomName}/roomName`, {
+            method: "PUT",
+            data: { newRoomName },
+        })
+            .then(() => undefined);
+    }
+    changeMode({ roomName, mode }) {
+        assertRoomName(roomName);
+        assertString(mode, "mode");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/mode`, {
+            method: "PUT",
+            data: { mode },
+        })
+            .then(() => undefined);
+    }
+    updatePreferences({ roomName, preferences }) {
+        assertRoomName(roomName);
+        assertInstanceOf(preferences, Object, "preferences");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    updateProtectedPreferences({ roomName, preferences }) {
+        assertRoomName(roomName);
+        assertInstanceOf(preferences, Object, "preferences");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/protected-preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    getRoomPermissions(roomName, { roomKey } = {}) {
+        assertRoomName(roomName);
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, "/permissions"), Object.assign({ method: "GET" }, (roomKey && { headers: { "X-Whereby-Room-Key": roomKey } })))
+            .then((response) => {
+            const { permissions, limits } = response.data;
+            return {
+                permissions,
+                limits,
+            };
+        });
+    }
+    getRoomMetrics({ roomName, metrics, from, to }) {
+        assertRoomName(roomName);
+        assertString(metrics, "metrics");
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, "/metrics"), {
+            method: "GET",
+            params: { metrics, from, to },
+        })
+            .then((response) => response.data);
+    }
+    changeType({ roomName, type }) {
+        assertRoomName(roomName);
+        assertOneOf(type, ["personal", "personal_xl"], "type");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/type`, {
+            method: "PUT",
+            data: { type },
+        })
+            .then(() => undefined);
+    }
+    getForestSocialImage({ roomName, count }) {
+        assertRoomName(roomName);
+        assertNumber(count, "count");
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, `/forest-social-image/${count}`), {
+            method: "GET",
+        })
+            .then((response) => response.data.imageUrl);
+    }
+}
+
+class RoomParticipant {
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled, breakoutGroup, stickyReaction, isDialIn, }) {
+        this.isLocalParticipant = false;
+        this.displayName = displayName;
+        this.id = id;
+        this.stream = stream;
+        this.isAudioEnabled = isAudioEnabled;
+        this.isVideoEnabled = isVideoEnabled;
+        this.breakoutGroup = breakoutGroup;
+        this.stickyReaction = stickyReaction;
+        this.isDialIn = isDialIn;
+    }
+}
+class LocalParticipant extends RoomParticipant {
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled, breakoutGroup, stickyReaction, isDialIn, }) {
+        super({ displayName, id, stream, isAudioEnabled, isVideoEnabled, breakoutGroup, stickyReaction, isDialIn });
+        this.isLocalParticipant = true;
+    }
+}
+
+const API_BASE_URL = "https://api.whereby.dev" ;
+function createServices() {
+    const credentialsService = CredentialsService.create({ baseUrl: API_BASE_URL });
+    const apiClient = new ApiClient({
+        fetchDeviceCredentials: credentialsService.getCredentials.bind(credentialsService),
+        baseUrl: API_BASE_URL,
+    });
+    const organizationService = new OrganizationService({ apiClient });
+    const fetchOrganizationFromRoomUrl = (roomUrl) => {
+        const roomUrlObj = new URL(roomUrl);
+        const urls = fromLocation({ host: roomUrlObj.host });
+        const organizationServiceCache = new OrganizationServiceCache({
+            organizationService,
+            subdomain: urls.subdomain,
+        });
+        return organizationServiceCache.fetchOrganization();
+    };
+    return {
+        credentialsService,
+        apiClient,
+        organizationService,
+        fetchOrganizationFromRoomUrl,
+    };
+}
+
+export { ApiClient, Credentials, CredentialsService, LocalParticipant, OrganizationApiClient, OrganizationService, OrganizationServiceCache, RoomService, addAppListener, addSpotlight, appSlice, authorizationSlice, chatSlice, cloudRecordingSlice, connectionMonitorSlice, connectionMonitorStarted, connectionMonitorStopped, createAppAsyncThunk, createAppAuthorizedThunk, createAppThunk, createAsyncRoomConnectedThunk, createAuthorizedRoomConnectedThunk, createReactor, createRemoteParticipant, createRoomConnectedThunk, createServices, createStore, createWebRtcEmitter, debounce, deviceBusy, deviceCredentialsSlice, deviceIdentified, deviceIdentifying, doAcceptWaitingParticipant, doAppStart, doAppStop, doClearNotifications, doConnectRoom, doConnectRtc, doDisconnectRtc, doEnableAudio, doEnableVideo, doEndMeeting, doGetDeviceCredentials, doHandleAcceptStreams, doHandleStreamingStarted, doHandleStreamingStopped, doKickParticipant, doKnockRoom, doLockRoom, doOrganizationFetch, doRejectWaitingParticipant, doRemoveSpotlight, doRequestAudioEnable, doRequestVideoEnable, doRtcAnalyticsCustomEventsInitialize, doRtcManagerCreated, doRtcManagerInitialize, doRtcReportStreamResolution, doSendChatMessage, doSendClientMetadata, doSetDevice, doSetDisplayName, doSetLocalStickyReaction, doSetNotification, doSignalConnect, doSignalDisconnect, doSignalIdentifyDevice, doSpotlightParticipant, doStartCloudRecording, doStartConnectionMonitor, doStartLocalMedia, doStartScreenshare, doStopCloudRecording, doStopConnectionMonitor, doStopLocalMedia, doStopScreenshare, doSwitchLocalStream, doToggleCamera, doToggleLowDataMode, doUpdateDeviceList, getAudioTrack, getFakeMediaStream, getVideoTrack, hasValue, initialCloudRecordingState, initialLocalMediaState, initialNotificationsState, initialState$g as initialState, isAcceptingStreams, isClientSpotlighted, listenerMiddleware, localMediaSlice, localMediaStopped, localParticipantSlice, localScreenshareSlice, localStreamMetadataUpdated, notificationsSlice, observeStore, organizationSlice, parseRoomUrlAndSubdomain, parseUnverifiedRoomKeyData, participantStreamAdded, participantStreamIdAdded, recordingRequestStarted, remoteParticipantsSlice, removeSpotlight, resolutionReported, roomConnectionSlice, roomSlice, rootReducer, rtcAnalyticsCustomEvents, rtcAnalyticsSlice, rtcConnectionSlice, rtcDisconnected, rtcDispatcherCreated, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, selectAllClientViews, selectAppDisplayName, selectAppExternalId, selectAppInitialConfig, selectAppIsActive, selectAppIsDialIn, selectAppIsNodeSdk, selectAppRaw, selectAppRoomName, selectAppRoomUrl, selectAppUserAgent, selectAuthorizationRoleName, selectBusyDeviceIds, selectCameraDeviceError, selectCameraDevices, selectChatMessages, selectChatRaw, selectCloudRecordingError, selectCloudRecordingRaw, selectCloudRecordingStartedAt, selectCloudRecordingStatus, selectConnectionMonitorIsRunning, selectCurrentCameraDeviceId, selectCurrentMicrophoneDeviceId, selectCurrentSpeakerDeviceId, selectDeviceCredentialsRaw, selectDeviceId, selectHasFetchedDeviceCredentials, selectIsAcceptingStreams, selectIsAuthorizedToAskToSpeak, selectIsAuthorizedToEndMeeting, selectIsAuthorizedToKickClient, selectIsAuthorizedToLockRoom, selectIsAuthorizedToRequestAudioEnable, selectIsAuthorizedToRequestVideoEnable, selectIsAuthorizedToSpotlight, selectIsCameraEnabled, selectIsCloudRecording, selectIsLocalMediaStarting, selectIsLocalParticipantSpotlighted, selectIsLowDataModeEnabled, selectIsMicrophoneEnabled, selectIsSettingCameraDevice, selectIsSettingMicrophoneDevice, selectIsToggleCamera, selectLocalMediaConstraintsOptions, selectLocalMediaDevices, selectLocalMediaIsSwitchingStream, selectLocalMediaOptions, selectLocalMediaOwnsStream, selectLocalMediaRaw, selectLocalMediaShouldStartWithOptions, selectLocalMediaShouldStop, selectLocalMediaStartError, selectLocalMediaStatus, selectLocalMediaStream, selectLocalParticipantClientClaim, selectLocalParticipantDisplayName, selectLocalParticipantIsScreenSharing, selectLocalParticipantRaw, selectLocalParticipantStickyReaction, selectLocalParticipantView, selectLocalScreenshareRaw, selectLocalScreenshareStatus, selectLocalScreenshareStream, selectMicrophoneDeviceError, selectMicrophoneDevices, selectNotificationsEmitter, selectNotificationsEvents, selectNotificationsRaw, selectNumClients, selectNumParticipants, selectOrganizationId, selectOrganizationRaw, selectRemoteClientViews, selectRemoteClients, selectRemoteParticipants, selectRemoteParticipantsRaw, selectRoomConnectionError, selectRoomConnectionRaw, selectRoomConnectionSession, selectRoomConnectionSessionId, selectRoomConnectionStatus, selectRoomIsLocked, selectRoomKey, selectRtcConnectionRaw, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectRtcManager, selectRtcManagerInitialized, selectRtcStatus, selectScreenshares, selectSelfId, selectShouldConnectRoom, selectShouldConnectRtc, selectShouldConnectSignal, selectShouldDisconnectRtc, selectShouldFetchDeviceCredentials, selectShouldFetchOrganization, selectShouldIdentifyDevice, selectShouldInitializeRtc, selectShouldStartConnectionMonitor, selectShouldStopConnectionMonitor, selectSignalConnectionDeviceIdentified, selectSignalConnectionRaw, selectSignalConnectionSocket, selectSignalIsIdentifyingDevice, selectSignalStatus, selectSpeakerDevices, selectSpotlightedClientViews, selectSpotlights, selectSpotlightsRaw, selectStopCallbackFunction, selectStreamingRaw, selectStreamsToAccept, selectWaitingParticipants, selectWaitingParticipantsRaw, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, setCurrentSpeakerDeviceId, setDisplayName, setLocalMediaOptions, setLocalMediaStream, setRoomKey, signalConnectionSlice, signalEvents, socketConnected, socketConnecting, socketDisconnected, socketReconnecting, spotlightsSlice, startAppListening, stopScreenshare, streamIdForClient, streamStatusUpdated, streamingSlice, toggleCameraEnabled, toggleLowDataModeEnabled, toggleMicrophoneEnabled, updateReportedValues, waitingParticipantsSlice };