livekit-client 0.18.4-RC8 → 0.18.4

package/dist/livekit-client.esm.mjs

@@ -325,9 +325,9 @@ livekitLogger.setLevel(LogLevel.info);
 function setLogLevel(level) {
   livekitLogger.setLevel(level);
 }
-/**
- * use this to hook into the logging function to allow sending internal livekit logs to third party services
- * if set, the browser logs will lose their stacktrace information (see https://github.com/pimterry/loglevel#writing-plugins)
+/**
+ * use this to hook into the logging function to allow sending internal livekit logs to third party services
+ * if set, the browser logs will lose their stacktrace information (see https://github.com/pimterry/loglevel#writing-plugins)
  */
 
 function setLogExtension(extension) {
@@ -9229,237 +9229,237 @@ var MediaDeviceFailure;
   MediaDeviceFailure.getFailure = getFailure;
 })(MediaDeviceFailure || (MediaDeviceFailure = {}));
 
-/**
- * Events are the primary way LiveKit notifies your application of changes.
- *
- * The following are events emitted by [[Room]], listen to room events like
- *
- * ```typescript
- * room.on(RoomEvent.TrackPublished, (track, publication, participant) => {})
- * ```
+/**
+ * Events are the primary way LiveKit notifies your application of changes.
+ *
+ * The following are events emitted by [[Room]], listen to room events like
+ *
+ * ```typescript
+ * room.on(RoomEvent.TrackPublished, (track, publication, participant) => {})
+ * ```
  */
 var RoomEvent;
 
 (function (RoomEvent) {
-  /**
-   * When the connection to the server has been interrupted and it's attempting
-   * to reconnect.
+  /**
+   * When the connection to the server has been interrupted and it's attempting
+   * to reconnect.
    */
   RoomEvent["Reconnecting"] = "reconnecting";
-  /**
-   * Fires when a reconnection has been successful.
+  /**
+   * Fires when a reconnection has been successful.
    */
 
   RoomEvent["Reconnected"] = "reconnected";
-  /**
-   * When disconnected from room. This fires when room.disconnect() is called or
-   * when an unrecoverable connection issue had occured
+  /**
+   * When disconnected from room. This fires when room.disconnect() is called or
+   * when an unrecoverable connection issue had occured
    */
 
   RoomEvent["Disconnected"] = "disconnected";
-  /**
-   * Whenever the connection state of the room changes
-   *
-   * args: ([[RoomState]])
+  /**
+   * Whenever the connection state of the room changes
+   *
+   * args: ([[RoomState]])
    */
 
   RoomEvent["StateChanged"] = "stateChanged";
-  /**
-   * When input or output devices on the machine have changed.
+  /**
+   * When input or output devices on the machine have changed.
    */
 
   RoomEvent["MediaDevicesChanged"] = "mediaDevicesChanged";
-  /**
-   * When a [[RemoteParticipant]] joins *after* the local
-   * participant. It will not emit events for participants that are already
-   * in the room
-   *
-   * args: ([[RemoteParticipant]])
+  /**
+   * When a [[RemoteParticipant]] joins *after* the local
+   * participant. It will not emit events for participants that are already
+   * in the room
+   *
+   * args: ([[RemoteParticipant]])
    */
 
   RoomEvent["ParticipantConnected"] = "participantConnected";
-  /**
-   * When a [[RemoteParticipant]] leaves *after* the local
-   * participant has joined.
-   *
-   * args: ([[RemoteParticipant]])
+  /**
+   * When a [[RemoteParticipant]] leaves *after* the local
+   * participant has joined.
+   *
+   * args: ([[RemoteParticipant]])
    */
 
   RoomEvent["ParticipantDisconnected"] = "participantDisconnected";
-  /**
-   * When a new track is published to room *after* the local
-   * participant has joined. It will not fire for tracks that are already published.
-   *
-   * A track published doesn't mean the participant has subscribed to it. It's
-   * simply reflecting the state of the room.
-   *
-   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * When a new track is published to room *after* the local
+   * participant has joined. It will not fire for tracks that are already published.
+   *
+   * A track published doesn't mean the participant has subscribed to it. It's
+   * simply reflecting the state of the room.
+   *
+   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackPublished"] = "trackPublished";
-  /**
-   * The [[LocalParticipant]] has subscribed to a new track. This event will **always**
-   * fire as long as new tracks are ready for use.
-   *
-   * args: ([[RemoteTrack]], [[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * The [[LocalParticipant]] has subscribed to a new track. This event will **always**
+   * fire as long as new tracks are ready for use.
+   *
+   * args: ([[RemoteTrack]], [[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackSubscribed"] = "trackSubscribed";
-  /**
-   * Could not subscribe to a track
-   *
-   * args: (track sid, [[RemoteParticipant]])
+  /**
+   * Could not subscribe to a track
+   *
+   * args: (track sid, [[RemoteParticipant]])
    */
 
   RoomEvent["TrackSubscriptionFailed"] = "trackSubscriptionFailed";
-  /**
-   * A [[RemoteParticipant]] has unpublished a track
-   *
-   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * A [[RemoteParticipant]] has unpublished a track
+   *
+   * args: ([[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackUnpublished"] = "trackUnpublished";
-  /**
-   * A subscribed track is no longer available. Clients should listen to this
-   * event and ensure they detach tracks.
-   *
-   * args: ([[Track]], [[RemoteTrackPublication]], [[RemoteParticipant]])
+  /**
+   * A subscribed track is no longer available. Clients should listen to this
+   * event and ensure they detach tracks.
+   *
+   * args: ([[Track]], [[RemoteTrackPublication]], [[RemoteParticipant]])
    */
 
   RoomEvent["TrackUnsubscribed"] = "trackUnsubscribed";
-  /**
-   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]], [[Participant]])
+  /**
+   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]], [[Participant]])
    */
 
   RoomEvent["TrackMuted"] = "trackMuted";
-  /**
-   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]], [[Participant]])
+  /**
+   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]], [[Participant]])
    */
 
   RoomEvent["TrackUnmuted"] = "trackUnmuted";
-  /**
-   * A local track was published successfully. This event is helpful to know
-   * when to update your local UI with the newly published track.
-   *
-   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
+  /**
+   * A local track was published successfully. This event is helpful to know
+   * when to update your local UI with the newly published track.
+   *
+   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
    */
 
   RoomEvent["LocalTrackPublished"] = "localTrackPublished";
-  /**
-   * A local track was unpublished. This event is helpful to know when to remove
-   * the local track from your UI.
-   *
-   * When a user stops sharing their screen by pressing "End" on the browser UI,
-   * this event will also fire.
-   *
-   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
+  /**
+   * A local track was unpublished. This event is helpful to know when to remove
+   * the local track from your UI.
+   *
+   * When a user stops sharing their screen by pressing "End" on the browser UI,
+   * this event will also fire.
+   *
+   * args: ([[LocalTrackPublication]], [[LocalParticipant]])
    */
 
   RoomEvent["LocalTrackUnpublished"] = "localTrackUnpublished";
-  /**
-   * Active speakers changed. List of speakers are ordered by their audio level.
-   * loudest speakers first. This will include the LocalParticipant too.
-   *
-   * Speaker updates are sent only to the publishing participant and their subscribers.
-   *
-   * args: (Array<[[Participant]]>)
+  /**
+   * Active speakers changed. List of speakers are ordered by their audio level.
+   * loudest speakers first. This will include the LocalParticipant too.
+   *
+   * Speaker updates are sent only to the publishing participant and their subscribers.
+   *
+   * args: (Array<[[Participant]]>)
    */
 
   RoomEvent["ActiveSpeakersChanged"] = "activeSpeakersChanged";
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
+  /**
+   * @deprecated Use ParticipantMetadataChanged instead
+   * @internal
    */
 
   RoomEvent["MetadataChanged"] = "metadataChanged";
-  /**
-   * Participant metadata is a simple way for app-specific state to be pushed to
-   * all users.
-   * When RoomService.UpdateParticipantMetadata is called to change a participant's
-   * state, *all*  participants in the room will fire this event.
-   *
-   * args: (prevMetadata: string, [[Participant]])
-   *
+  /**
+   * Participant metadata is a simple way for app-specific state to be pushed to
+   * all users.
+   * When RoomService.UpdateParticipantMetadata is called to change a participant's
+   * state, *all*  participants in the room will fire this event.
+   *
+   * args: (prevMetadata: string, [[Participant]])
+   *
    */
 
   RoomEvent["ParticipantMetadataChanged"] = "participantMetadataChanged";
-  /**
-   * Room metadata is a simple way for app-specific state to be pushed to
-   * all users.
-   * When RoomService.UpdateRoomMetadata is called to change a room's state,
-   * *all*  participants in the room will fire this event.
-   *
-   * args: (string)
+  /**
+   * Room metadata is a simple way for app-specific state to be pushed to
+   * all users.
+   * When RoomService.UpdateRoomMetadata is called to change a room's state,
+   * *all*  participants in the room will fire this event.
+   *
+   * args: (string)
    */
 
   RoomEvent["RoomMetadataChanged"] = "roomMetadataChanged";
-  /**
-   * Data received from another participant.
-   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
-   * All participants in the room will receive the messages sent to the room.
-   *
-   * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]])
+  /**
+   * Data received from another participant.
+   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
+   * All participants in the room will receive the messages sent to the room.
+   *
+   * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]])
    */
 
   RoomEvent["DataReceived"] = "dataReceived";
-  /**
-   * Connection quality was changed for a Participant. It'll receive updates
-   * from the local participant, as well as any [[RemoteParticipant]]s that we are
-   * subscribed to.
-   *
-   * args: (connectionQuality: [[ConnectionQuality]], participant: [[Participant]])
+  /**
+   * Connection quality was changed for a Participant. It'll receive updates
+   * from the local participant, as well as any [[RemoteParticipant]]s that we are
+   * subscribed to.
+   *
+   * args: (connectionQuality: [[ConnectionQuality]], participant: [[Participant]])
    */
 
   RoomEvent["ConnectionQualityChanged"] = "connectionQualityChanged";
-  /**
-   * StreamState indicates if a subscribed (remote) track has been paused by the SFU
-   * (typically this happens because of subscriber's bandwidth constraints)
-   *
-   * When bandwidth conditions allow, the track will be resumed automatically.
-   * TrackStreamStateChanged will also be emitted when that happens.
-   *
-   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]],
-   *        participant: [[RemoteParticipant]])
+  /**
+   * StreamState indicates if a subscribed (remote) track has been paused by the SFU
+   * (typically this happens because of subscriber's bandwidth constraints)
+   *
+   * When bandwidth conditions allow, the track will be resumed automatically.
+   * TrackStreamStateChanged will also be emitted when that happens.
+   *
+   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]],
+   *        participant: [[RemoteParticipant]])
    */
 
   RoomEvent["TrackStreamStateChanged"] = "trackStreamStateChanged";
-  /**
-   * One of subscribed tracks have changed its permissions for the current
-   * participant. If permission was revoked, then the track will no longer
-   * be subscribed. If permission was granted, a TrackSubscribed event will
-   * be emitted.
-   *
-   * args: (pub: [[RemoteTrackPublication]],
-   *        status: [[TrackPublication.SubscriptionStatus]],
-   *        participant: [[RemoteParticipant]])
+  /**
+   * One of subscribed tracks have changed its permissions for the current
+   * participant. If permission was revoked, then the track will no longer
+   * be subscribed. If permission was granted, a TrackSubscribed event will
+   * be emitted.
+   *
+   * args: (pub: [[RemoteTrackPublication]],
+   *        status: [[TrackPublication.SubscriptionStatus]],
+   *        participant: [[RemoteParticipant]])
    */
 
   RoomEvent["TrackSubscriptionPermissionChanged"] = "trackSubscriptionPermissionChanged";
-  /**
-   * LiveKit will attempt to autoplay all audio tracks when you attach them to
-   * audio elements. However, if that fails, we'll notify you via AudioPlaybackStatusChanged.
-   * `Room.canPlayAudio` will indicate if audio playback is permitted.
+  /**
+   * LiveKit will attempt to autoplay all audio tracks when you attach them to
+   * audio elements. However, if that fails, we'll notify you via AudioPlaybackStatusChanged.
+   * `Room.canPlayAudio` will indicate if audio playback is permitted.
    */
 
   RoomEvent["AudioPlaybackStatusChanged"] = "audioPlaybackChanged";
-  /**
-   * When we have encountered an error while attempting to create a track.
-   * The errors take place in getUserMedia().
-   * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
-   * [[getAudioCreateError]] and [[getVideoCreateError]] will indicate if it had
-   * an error while creating the audio or video track respectively.
-   *
-   * args: (error: Error)
+  /**
+   * When we have encountered an error while attempting to create a track.
+   * The errors take place in getUserMedia().
+   * Use MediaDeviceFailure.getFailure(error) to get the reason of failure.
+   * [[getAudioCreateError]] and [[getVideoCreateError]] will indicate if it had
+   * an error while creating the audio or video track respectively.
+   *
+   * args: (error: Error)
    */
 
   RoomEvent["MediaDevicesError"] = "mediaDevicesError";
-  /**
-   * A participant's permission has changed. Currently only fired on LocalParticipant.
-   * args: (prevPermissions: [[ParticipantPermission]], participant: [[Participant]])
+  /**
+   * A participant's permission has changed. Currently only fired on LocalParticipant.
+   * args: (prevPermissions: [[ParticipantPermission]], participant: [[Participant]])
    */
 
   RoomEvent["ParticipantPermissionsChanged"] = "participantPermissionsChanged";
@@ -9468,141 +9468,141 @@ var RoomEvent;
 var ParticipantEvent;
 
 (function (ParticipantEvent) {
-  /**
-   * When a new track is published to room *after* the local
-   * participant has joined. It will not fire for tracks that are already published.
-   *
-   * A track published doesn't mean the participant has subscribed to it. It's
-   * simply reflecting the state of the room.
-   *
-   * args: ([[RemoteTrackPublication]])
+  /**
+   * When a new track is published to room *after* the local
+   * participant has joined. It will not fire for tracks that are already published.
+   *
+   * A track published doesn't mean the participant has subscribed to it. It's
+   * simply reflecting the state of the room.
+   *
+   * args: ([[RemoteTrackPublication]])
    */
   ParticipantEvent["TrackPublished"] = "trackPublished";
-  /**
-   * Successfully subscribed to the [[RemoteParticipant]]'s track.
-   * This event will **always** fire as long as new tracks are ready for use.
-   *
-   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
+  /**
+   * Successfully subscribed to the [[RemoteParticipant]]'s track.
+   * This event will **always** fire as long as new tracks are ready for use.
+   *
+   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
    */
 
   ParticipantEvent["TrackSubscribed"] = "trackSubscribed";
-  /**
-   * Could not subscribe to a track
-   *
-   * args: (track sid)
+  /**
+   * Could not subscribe to a track
+   *
+   * args: (track sid)
    */
 
   ParticipantEvent["TrackSubscriptionFailed"] = "trackSubscriptionFailed";
-  /**
-   * A [[RemoteParticipant]] has unpublished a track
-   *
-   * args: ([[RemoteTrackPublication]])
+  /**
+   * A [[RemoteParticipant]] has unpublished a track
+   *
+   * args: ([[RemoteTrackPublication]])
    */
 
   ParticipantEvent["TrackUnpublished"] = "trackUnpublished";
-  /**
-   * A subscribed track is no longer available. Clients should listen to this
-   * event and ensure they detach tracks.
-   *
-   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
+  /**
+   * A subscribed track is no longer available. Clients should listen to this
+   * event and ensure they detach tracks.
+   *
+   * args: ([[RemoteTrack]], [[RemoteTrackPublication]])
    */
 
   ParticipantEvent["TrackUnsubscribed"] = "trackUnsubscribed";
-  /**
-   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]])
+  /**
+   * A track that was muted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]])
    */
 
   ParticipantEvent["TrackMuted"] = "trackMuted";
-  /**
-   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
-   *
-   * args: ([[TrackPublication]])
+  /**
+   * A track that was unmuted, fires on both [[RemoteParticipant]]s and [[LocalParticipant]]
+   *
+   * args: ([[TrackPublication]])
    */
 
   ParticipantEvent["TrackUnmuted"] = "trackUnmuted";
-  /**
-   * A local track was published successfully. This event is helpful to know
-   * when to update your local UI with the newly published track.
-   *
-   * args: ([[LocalTrackPublication]])
+  /**
+   * A local track was published successfully. This event is helpful to know
+   * when to update your local UI with the newly published track.
+   *
+   * args: ([[LocalTrackPublication]])
    */
 
   ParticipantEvent["LocalTrackPublished"] = "localTrackPublished";
-  /**
-   * A local track was unpublished. This event is helpful to know when to remove
-   * the local track from your UI.
-   *
-   * When a user stops sharing their screen by pressing "End" on the browser UI,
-   * this event will also fire.
-   *
-   * args: ([[LocalTrackPublication]])
+  /**
+   * A local track was unpublished. This event is helpful to know when to remove
+   * the local track from your UI.
+   *
+   * When a user stops sharing their screen by pressing "End" on the browser UI,
+   * this event will also fire.
+   *
+   * args: ([[LocalTrackPublication]])
    */
 
   ParticipantEvent["LocalTrackUnpublished"] = "localTrackUnpublished";
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
+  /**
+   * @deprecated Use ParticipantMetadataChanged instead
+   * @internal
    */
 
   ParticipantEvent["MetadataChanged"] = "metadataChanged";
-  /**
-   * Participant metadata is a simple way for app-specific state to be pushed to
-   * all users.
-   * When RoomService.UpdateParticipantMetadata is called to change a participant's
-   * state, *all*  participants in the room will fire this event.
-   * To access the current metadata, see [[Participant.metadata]].
-   *
-   * args: (prevMetadata: string)
-   *
+  /**
+   * Participant metadata is a simple way for app-specific state to be pushed to
+   * all users.
+   * When RoomService.UpdateParticipantMetadata is called to change a participant's
+   * state, *all*  participants in the room will fire this event.
+   * To access the current metadata, see [[Participant.metadata]].
+   *
+   * args: (prevMetadata: string)
+   *
    */
 
   ParticipantEvent["ParticipantMetadataChanged"] = "participantMetadataChanged";
-  /**
-   * Data received from this participant as sender.
-   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
-   * All participants in the room will receive the messages sent to the room.
-   *
-   * args: (payload: Uint8Array, kind: [[DataPacket_Kind]])
+  /**
+   * Data received from this participant as sender.
+   * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
+   * All participants in the room will receive the messages sent to the room.
+   *
+   * args: (payload: Uint8Array, kind: [[DataPacket_Kind]])
    */
 
   ParticipantEvent["DataReceived"] = "dataReceived";
-  /**
-   * Has speaking status changed for the current participant
-   *
-   * args: (speaking: boolean)
+  /**
+   * Has speaking status changed for the current participant
+   *
+   * args: (speaking: boolean)
    */
 
   ParticipantEvent["IsSpeakingChanged"] = "isSpeakingChanged";
-  /**
-   * Connection quality was changed for a Participant. It'll receive updates
-   * from the local participant, as well as any [[RemoteParticipant]]s that we are
-   * subscribed to.
-   *
-   * args: (connectionQuality: [[ConnectionQuality]])
+  /**
+   * Connection quality was changed for a Participant. It'll receive updates
+   * from the local participant, as well as any [[RemoteParticipant]]s that we are
+   * subscribed to.
+   *
+   * args: (connectionQuality: [[ConnectionQuality]])
    */
 
   ParticipantEvent["ConnectionQualityChanged"] = "connectionQualityChanged";
-  /**
-   * StreamState indicates if a subscribed track has been paused by the SFU
-   * (typically this happens because of subscriber's bandwidth constraints)
-   *
-   * When bandwidth conditions allow, the track will be resumed automatically.
-   * TrackStreamStateChanged will also be emitted when that happens.
-   *
-   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]])
+  /**
+   * StreamState indicates if a subscribed track has been paused by the SFU
+   * (typically this happens because of subscriber's bandwidth constraints)
+   *
+   * When bandwidth conditions allow, the track will be resumed automatically.
+   * TrackStreamStateChanged will also be emitted when that happens.
+   *
+   * args: (pub: [[RemoteTrackPublication]], streamState: [[Track.StreamState]])
    */
 
   ParticipantEvent["TrackStreamStateChanged"] = "trackStreamStateChanged";
-  /**
-   * One of subscribed tracks have changed its permissions for the current
-   * participant. If permission was revoked, then the track will no longer
-   * be subscribed. If permission was granted, a TrackSubscribed event will
-   * be emitted.
-   *
-   * args: (pub: [[RemoteTrackPublication]],
-   *        status: [[TrackPublication.SubscriptionStatus]])
+  /**
+   * One of subscribed tracks have changed its permissions for the current
+   * participant. If permission was revoked, then the track will no longer
+   * be subscribed. If permission was granted, a TrackSubscribed event will
+   * be emitted.
+   *
+   * args: (pub: [[RemoteTrackPublication]],
+   *        status: [[TrackPublication.SubscriptionStatus]])
    */
 
   ParticipantEvent["TrackSubscriptionPermissionChanged"] = "trackSubscriptionPermissionChanged"; // fired only on LocalParticipant
@@ -9610,9 +9610,9 @@ var ParticipantEvent;
   /** @internal */
 
   ParticipantEvent["MediaDevicesError"] = "mediaDevicesError";
-  /**
-   * A participant's permission has changed. Currently only fired on LocalParticipant.
-   * args: (prevPermissions: [[ParticipantPermission]])
+  /**
+   * A participant's permission has changed. Currently only fired on LocalParticipant.
+   * args: (prevPermissions: [[ParticipantPermission]])
    */
 
   ParticipantEvent["ParticipantPermissionsChanged"] = "participantPermissionsChanged";
@@ -9655,9 +9655,9 @@ var TrackEvent;
   /** @internal */
 
   TrackEvent["AudioPlaybackFailed"] = "audioPlaybackFailed";
-  /**
-   * @internal
-   * Only fires on LocalAudioTrack instances
+  /**
+   * @internal
+   * Only fires on LocalAudioTrack instances
    */
 
   TrackEvent["AudioSilenceDetected"] = "audioSilenceDetected";
@@ -9673,15 +9673,15 @@ var TrackEvent;
   /** @internal */
 
   TrackEvent["ElementDetached"] = "elementDetached";
-  /**
-   * @internal
-   * Only fires on LocalTracks
+  /**
+   * @internal
+   * Only fires on LocalTracks
    */
 
   TrackEvent["UpstreamPaused"] = "upstreamPaused";
-  /**
-   * @internal
-   * Only fires on LocalTracks
+  /**
+   * @internal
+   * Only fires on LocalTracks
    */
 
   TrackEvent["UpstreamResumed"] = "upstreamResumed";
@@ -10719,8 +10719,8 @@ class LocalTrack extends Track {
   get isUpstreamPaused() {
     return this._isUpstreamPaused;
   }
-  /**
-   * @returns DeviceID of the device that is currently being used for this track
+  /**
+   * @returns DeviceID of the device that is currently being used for this track
    */
 
 
@@ -10948,9 +10948,9 @@ function constraintsForOptions(options) {
 
   return constraints;
 }
-/**
- * This function detects silence on a given [[Track]] instance.
- * Returns true if the track seems to be entirely silent.
+/**
+ * This function detects silence on a given [[Track]] instance.
+ * Returns true if the track seems to be entirely silent.
  */
 
 async function detectSilence(track) {
@@ -10973,8 +10973,8 @@ async function detectSilence(track) {
 
   return false;
 }
-/**
- * @internal
+/**
+ * @internal
  */
 
 function getNewAudioContext() {
@@ -11302,9 +11302,9 @@ class LocalVideoTrack extends LocalTrack {
 
     await this.restart(constraints);
   }
-  /**
-   * @internal
-   * Sets layers that should be publishing
+  /**
+   * @internal
+   * Sets layers that should be publishing
    */
 
 
@@ -11510,8 +11510,8 @@ class RemoteAudioTrack extends RemoteTrack {
 
     this.elementVolume = 1;
   }
-  /**
-   * sets the volume for all attached audio elements
+  /**
+   * sets the volume for all attached audio elements
    */
 
 
@@ -11522,8 +11522,8 @@ class RemoteAudioTrack extends RemoteTrack {
 
     this.elementVolume = volume;
   }
-  /**
-   * gets the volume for all attached audio elements
+  /**
+   * gets the volume for all attached audio elements
    */
 
 
@@ -11876,8 +11876,8 @@ class TrackPublication extends events.exports.EventEmitter {
   get isSubscribed() {
     return this.track !== undefined;
   }
-  /**
-   * an [AudioTrack] if this publication holds an audio track
+  /**
+   * an [AudioTrack] if this publication holds an audio track
    */
 
 
@@ -11886,8 +11886,8 @@ class TrackPublication extends events.exports.EventEmitter {
       return this.track;
     }
   }
-  /**
-   * an [VideoTrack] if this publication holds a video track
+  /**
+   * an [VideoTrack] if this publication holds a video track
    */
 
 
@@ -11973,8 +11973,8 @@ class LocalTrackPublication extends TrackPublication {
   get videoTrack() {
     return super.videoTrack;
   }
-  /**
-   * Mute the track associated with this publication
+  /**
+   * Mute the track associated with this publication
    */
 
 
@@ -11983,8 +11983,8 @@ class LocalTrackPublication extends TrackPublication {
 
     return (_a = this.track) === null || _a === void 0 ? void 0 : _a.mute();
   }
-  /**
-   * Unmute track associated with this publication
+  /**
+   * Unmute track associated with this publication
    */
 
 
@@ -11993,10 +11993,10 @@ class LocalTrackPublication extends TrackPublication {
 
     return (_a = this.track) === null || _a === void 0 ? void 0 : _a.unmute();
   }
-  /**
-   * Pauses the media stream track associated with this publication from being sent to the server
-   * and signals "muted" event to other participants
-   * Useful if you want to pause the stream without pausing the local media stream track
+  /**
+   * Pauses the media stream track associated with this publication from being sent to the server
+   * and signals "muted" event to other participants
+   * Useful if you want to pause the stream without pausing the local media stream track
    */
 
 
@@ -12005,9 +12005,9 @@ class LocalTrackPublication extends TrackPublication {
 
     await ((_a = this.track) === null || _a === void 0 ? void 0 : _a.pauseUpstream());
   }
-  /**
-   * Resumes sending the media stream track associated with this publication to the server after a call to [[pauseUpstream()]]
-   * and signals "unmuted" event to other participants (unless the track is explicitly muted)
+  /**
+   * Resumes sending the media stream track associated with this publication to the server after a call to [[pauseUpstream()]]
+   * and signals "unmuted" event to other participants (unless the track is explicitly muted)
    */
 
 
@@ -12052,8 +12052,8 @@ var AudioPresets;
     maxBitrate: 32000
   };
 })(AudioPresets || (AudioPresets = {}));
-/**
- * Sane presets for video resolution/encoding
+/**
+ * Sane presets for video resolution/encoding
  */
 
 
@@ -12083,8 +12083,8 @@ const VideoPresets = {
   /** @deprecated */
   fhd: new VideoPreset(1920, 1080, 3000000, 30)
 };
-/**
- * Four by three presets
+/**
+ * Four by three presets
  */
 
 const VideoPresets43 = {
@@ -12182,11 +12182,11 @@ class Participant extends events.exports.EventEmitter {
   getTracks() {
     return Array.from(this.tracks.values());
   }
-  /**
-   * Finds the first track that matches the source filter, for example, getting
-   * the user's camera track with getTrackBySource(Track.Source.Camera).
-   * @param source
-   * @returns
+  /**
+   * Finds the first track that matches the source filter, for example, getting
+   * the user's camera track with getTrackBySource(Track.Source.Camera).
+   * @param source
+   * @returns
    */
 
 
@@ -12219,10 +12219,10 @@ class Participant extends events.exports.EventEmitter {
       }
     }
   }
-  /**
-   * Finds the first track that matches the track's name.
-   * @param name
-   * @returns
+  /**
+   * Finds the first track that matches the track's name.
+   * @param name
+   * @returns
    */
 
 
@@ -12618,9 +12618,9 @@ class RemoteTrackPublication extends TrackPublication {
       this.emitTrackUpdate();
     };
   }
-  /**
-   * Subscribe or unsubscribe to this remote track
-   * @param subscribed true to subscribe to a track, false to unsubscribe
+  /**
+   * Subscribe or unsubscribe to this remote track
+   * @param subscribed true to subscribe to a track, false to unsubscribe
    */
 
 
@@ -12650,8 +12650,8 @@ class RemoteTrackPublication extends TrackPublication {
 
     return TrackPublication.SubscriptionStatus.Subscribed;
   }
-  /**
-   * Returns true if track is subscribed, and ready for playback
+  /**
+   * Returns true if track is subscribed, and ready for playback
    */
 
 
@@ -12670,11 +12670,11 @@ class RemoteTrackPublication extends TrackPublication {
   get isEnabled() {
     return !this.disabled;
   }
-  /**
-   * disable server from sending down data for this track. this is useful when
-   * the participant is off screen, you may disable streaming down their video
-   * to reduce bandwidth requirements
-   * @param enabled
+  /**
+   * disable server from sending down data for this track. this is useful when
+   * the participant is off screen, you may disable streaming down their video
+   * to reduce bandwidth requirements
+   * @param enabled
    */
 
 
@@ -12686,12 +12686,12 @@ class RemoteTrackPublication extends TrackPublication {
     this.disabled = !enabled;
     this.emitTrackUpdate();
   }
-  /**
-   * for tracks that support simulcasting, adjust subscribed quality
-   *
-   * This indicates the highest quality the client can accept. if network
-   * bandwidth does not allow, server will automatically reduce quality to
-   * optimize for uninterrupted video
+  /**
+   * for tracks that support simulcasting, adjust subscribed quality
+   *
+   * This indicates the highest quality the client can accept. if network
+   * bandwidth does not allow, server will automatically reduce quality to
+   * optimize for uninterrupted video
    */
 
 
@@ -12851,8 +12851,8 @@ class RemoteParticipant extends Participant {
       return track;
     }
   }
-  /**
-   * sets the volume on the participant's microphone track if it exists.
+  /**
+   * sets the volume on the participant's microphone track if it exists.
    */
 
 
@@ -12863,9 +12863,9 @@ class RemoteParticipant extends Participant {
       audioPublication.track.setVolume(volume);
     }
   }
-  /**
-   * gets the volume on the participant's microphone track
-   * returns undefined if no microphone track exists
+  /**
+   * gets the volume on the participant's microphone track
+   * returns undefined if no microphone track exists
    */
 
 
@@ -13174,31 +13174,31 @@ class LocalParticipant extends Participant {
       return track;
     }
   }
-  /**
-   * Enable or disable a participant's camera track.
-   *
-   * If a track has already published, it'll mute or unmute the track.
-   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+  /**
+   * Enable or disable a participant's camera track.
+   *
+   * If a track has already published, it'll mute or unmute the track.
+   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
    */
 
 
   setCameraEnabled(enabled) {
     return this.setTrackEnabled(Track.Source.Camera, enabled);
   }
-  /**
-   * Enable or disable a participant's microphone track.
-   *
-   * If a track has already published, it'll mute or unmute the track.
-   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+  /**
+   * Enable or disable a participant's microphone track.
+   *
+   * If a track has already published, it'll mute or unmute the track.
+   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
    */
 
 
   setMicrophoneEnabled(enabled) {
     return this.setTrackEnabled(Track.Source.Microphone, enabled);
   }
-  /**
-   * Start or stop sharing a participant's screen
-   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
+  /**
+   * Start or stop sharing a participant's screen
+   * Resolves with a `LocalTrackPublication` instance if successful and `undefined` otherwise
    */
 
 
@@ -13218,10 +13218,10 @@ class LocalParticipant extends Participant {
 
     return changed;
   }
-  /**
-   * Enable or disable publishing for a track by source. This serves as a simple
-   * way to manage the common tracks (camera, mic, or screen share).
-   * Resolves with LocalTrackPublication if successful and void otherwise
+  /**
+   * Enable or disable publishing for a track by source. This serves as a simple
+   * way to manage the common tracks (camera, mic, or screen share).
+   * Resolves with LocalTrackPublication if successful and void otherwise
    */
 
 
@@ -13294,9 +13294,9 @@ class LocalParticipant extends Participant {
 
     return track;
   }
-  /**
-   * Publish both camera and microphone at the same time. This is useful for
-   * displaying a single Permission Dialog box to the end user.
+  /**
+   * Publish both camera and microphone at the same time. This is useful for
+   * displaying a single Permission Dialog box to the end user.
    */
 
 
@@ -13320,10 +13320,10 @@ class LocalParticipant extends Participant {
       this.pendingPublishing.delete(Track.Source.Microphone);
     }
   }
-  /**
-   * Create local camera and/or microphone tracks
-   * @param options
-   * @returns
+  /**
+   * Create local camera and/or microphone tracks
+   * @param options
+   * @returns
    */
 
 
@@ -13381,10 +13381,10 @@ class LocalParticipant extends Participant {
       return track;
     });
   }
-  /**
-   * Creates a screen capture tracks with getDisplayMedia().
-   * A LocalVideoTrack is always created and returned.
-   * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+  /**
+   * Creates a screen capture tracks with getDisplayMedia().
+   * A LocalVideoTrack is always created and returned.
+   * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
    */
 
 
@@ -13433,10 +13433,10 @@ class LocalParticipant extends Participant {
 
     return localTracks;
   }
-  /**
-   * Publish a new track to the room
-   * @param track
-   * @param options
+  /**
+   * Publish a new track to the room
+   * @param track
+   * @param options
    */
 
 
@@ -13649,16 +13649,16 @@ class LocalParticipant extends Participant {
     });
     return publications;
   }
-  /**
-   * Publish a new data payload to the room. Data will be forwarded to each
-   * participant in the room if the destination argument is empty
-   *
-   * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
-   * @param kind whether to send this as reliable or lossy.
-   * For data that you need delivery guarantee (such as chat messages), use Reliable.
-   * For data that should arrive as quickly as possible, but you are ok with dropped
-   * packets, use Lossy.
-   * @param destination the participants who will receive the message
+  /**
+   * Publish a new data payload to the room. Data will be forwarded to each
+   * participant in the room if the destination argument is empty
+   *
+   * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
+   * @param kind whether to send this as reliable or lossy.
+   * For data that you need delivery guarantee (such as chat messages), use Reliable.
+   * For data that should arrive as quickly as possible, but you are ok with dropped
+   * packets, use Lossy.
+   * @param destination the participants who will receive the message
    */
 
 
@@ -13685,22 +13685,22 @@ class LocalParticipant extends Participant {
     };
     await this.engine.sendDataPacket(packet, kind);
   }
-  /**
-   * Control who can subscribe to LocalParticipant's published tracks.
-   *
-   * By default, all participants can subscribe. This allows fine-grained control over
-   * who is able to subscribe at a participant and track level.
-   *
-   * Note: if access is given at a track-level (i.e. both [allParticipantsAllowed] and
-   * [ParticipantTrackPermission.allTracksAllowed] are false), any newer published tracks
-   * will not grant permissions to any participants and will require a subsequent
-   * permissions update to allow subscription.
-   *
-   * @param allParticipantsAllowed Allows all participants to subscribe all tracks.
-   *  Takes precedence over [[participantTrackPermissions]] if set to true.
-   *  By default this is set to true.
-   * @param participantTrackPermissions Full list of individual permissions per
-   *  participant/track. Any omitted participants will not receive any permissions.
+  /**
+   * Control who can subscribe to LocalParticipant's published tracks.
+   *
+   * By default, all participants can subscribe. This allows fine-grained control over
+   * who is able to subscribe at a participant and track level.
+   *
+   * Note: if access is given at a track-level (i.e. both [allParticipantsAllowed] and
+   * [ParticipantTrackPermission.allTracksAllowed] are false), any newer published tracks
+   * will not grant permissions to any participants and will require a subsequent
+   * permissions update to allow subscription.
+   *
+   * @param allParticipantsAllowed Allows all participants to subscribe all tracks.
+   *  Takes precedence over [[participantTrackPermissions]] if set to true.
+   *  By default this is set to true.
+   * @param participantTrackPermissions Full list of individual permissions per
+   *  participant/track. Any omitted participants will not receive any permissions.
    */
 
 
@@ -18540,20 +18540,20 @@ var RoomState;
   RoomState["Connected"] = "connected";
   RoomState["Reconnecting"] = "reconnecting";
 })(RoomState || (RoomState = {}));
-/**
- * In LiveKit, a room is the logical grouping for a list of participants.
- * Participants in a room can publish tracks, and subscribe to others' tracks.
- *
- * a Room fires [[RoomEvent | RoomEvents]].
- *
- * @noInheritDoc
+/**
+ * In LiveKit, a room is the logical grouping for a list of participants.
+ * Participants in a room can publish tracks, and subscribe to others' tracks.
+ *
+ * a Room fires [[RoomEvent | RoomEvents]].
+ *
+ * @noInheritDoc
  */
 
 
 class Room extends events.exports.EventEmitter {
-  /**
-   * Creates a new Room, the primary construct for a LiveKit session.
-   * @param options
+  /**
+   * Creates a new Room, the primary construct for a LiveKit session.
+   * @param options
    */
   constructor(options) {
     var _this;
@@ -18563,9 +18563,9 @@ class Room extends events.exports.EventEmitter {
     super();
     _this = this;
     this.state = RoomState.Disconnected;
-    /**
-     * list of participants that are actively speaking. when this changes
-     * a [[RoomEvent.ActiveSpeakersChanged]] event is fired
+    /**
+     * list of participants that are actively speaking. when this changes
+     * a [[RoomEvent.ActiveSpeakersChanged]] event is fired
      */
 
     this.activeSpeakers = []; // available after connected
@@ -18677,8 +18677,8 @@ class Room extends events.exports.EventEmitter {
         });
       });
     };
-    /**
-     * disconnects the room, emits [[RoomEvent.Disconnected]]
+    /**
+     * disconnects the room, emits [[RoomEvent.Disconnected]]
      */
 
 
@@ -18973,13 +18973,13 @@ class Room extends events.exports.EventEmitter {
       }
     }).on(EngineEvent.Restarting, this.handleRestarting).on(EngineEvent.Restarted, this.handleRestarted);
   }
-  /**
-   * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
-   * In particular, it handles Chrome's unique behavior of creating `default`
-   * devices. When encountered, it'll be removed from the list of devices.
-   * The actual default device will be placed at top.
-   * @param kind
-   * @returns a list of available local devices
+  /**
+   * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
+   * In particular, it handles Chrome's unique behavior of creating `default`
+   * devices. When encountered, it'll be removed from the list of devices.
+   * The actual default device will be placed at top.
+   * @param kind
+   * @returns a list of available local devices
    */
 
 
@@ -18987,10 +18987,10 @@ class Room extends events.exports.EventEmitter {
     let requestPermissions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
     return DeviceManager.getInstance().getDevices(kind, requestPermissions);
   }
-  /**
-   * retrieves a participant by identity
-   * @param identity
-   * @returns
+  /**
+   * retrieves a participant by identity
+   * @param identity
+   * @returns
    */
 
 
@@ -19005,8 +19005,8 @@ class Room extends events.exports.EventEmitter {
       return this.localParticipant;
     }
   }
-  /**
-   * @internal for testing
+  /**
+   * @internal for testing
    */
 
 
@@ -19043,12 +19043,12 @@ class Room extends events.exports.EventEmitter {
       this.engine.client.sendSimulateScenario(req);
     }
   }
-  /**
-   * Browsers have different policies regarding audio playback. Most requiring
-   * some form of user interaction (click/tap/etc).
-   * In those cases, audio will be silent until a click/tap triggering one of the following
-   * - `startAudio`
-   * - `getUserMedia`
+  /**
+   * Browsers have different policies regarding audio playback. Most requiring
+   * some form of user interaction (click/tap/etc).
+   * In those cases, audio will be silent until a click/tap triggering one of the following
+   * - `startAudio`
+   * - `getUserMedia`
    */
 
 
@@ -19073,23 +19073,23 @@ class Room extends events.exports.EventEmitter {
       throw err;
     }
   }
-  /**
-   * Returns true if audio playback is enabled
+  /**
+   * Returns true if audio playback is enabled
    */
 
 
   get canPlaybackAudio() {
     return this.audioEnabled;
   }
-  /**
-   * Switches all active device used in this room to the given device.
-   *
-   * Note: setting AudioOutput is not supported on some browsers. See [setSinkId](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId#browser_compatibility)
-   *
-   * @param kind use `videoinput` for camera track,
-   *  `audioinput` for microphone track,
-   *  `audiooutput` to set speaker for all incoming audio tracks
-   * @param deviceId
+  /**
+   * Switches all active device used in this room to the given device.
+   *
+   * Note: setting AudioOutput is not supported on some browsers. See [setSinkId](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId#browser_compatibility)
+   *
+   * @param kind use `videoinput` for camera track,
+   *  `audioinput` for microphone track,
+   *  `audiooutput` to set speaker for all incoming audio tracks
+   * @param deviceId
    */
 
 
@@ -19285,10 +19285,10 @@ class Room extends events.exports.EventEmitter {
     }
 
     const previousSdp = this.engine.subscriber.pc.localDescription;
-    /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
-          in this case, we send unsub tracks, so server add all tracks to this
-          subscribe pc and unsub special tracks from it.
-       2. autosubscribe off, we send subscribed tracks.
+    /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
+          in this case, we send unsub tracks, so server add all tracks to this
+          subscribe pc and unsub special tracks from it.
+       2. autosubscribe off, we send subscribed tracks.
     */
 
     const sendUnsub = ((_a = this.connOptions) === null || _a === void 0 ? void 0 : _a.autoSubscribe) || false;
@@ -19314,9 +19314,9 @@ class Room extends events.exports.EventEmitter {
       dataChannels: this.localParticipant.dataChannelsInfo()
     });
   }
-  /**
-   * After resuming, we'll need to notify the server of the current
-   * subscription settings.
+  /**
+   * After resuming, we'll need to notify the server of the current
+   * subscription settings.
    */
 
 
@@ -19345,24 +19345,24 @@ class Room extends events.exports.EventEmitter {
 
 }
 
-/**
- * @deprecated Use room.connect() instead
- *
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
+/**
+ * @deprecated Use room.connect() instead
+ *
+ * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
+ *
+ * ```typescript
+ * connect('wss://myhost.livekit.io', token, {
+ *   // publish audio and video tracks on joining
+ *   audio: true,
+ *   video: true,
+ *   captureDefaults: {
+ *    facingMode: 'user',
+ *   },
+ * })
+ * ```
+ * @param url URL to LiveKit server
+ * @param token AccessToken, a JWT token that includes authentication and room details
+ * @param options
  */
 
 async function connect(url, token, options) {
@@ -19440,11 +19440,11 @@ async function connect(url, token, options) {
   return room;
 }
 
-/**
- * Creates a local video and audio track at the same time. When acquiring both
- * audio and video tracks together, it'll display a single permission prompt to
- * the user instead of two separate ones.
- * @param options
+/**
+ * Creates a local video and audio track at the same time. When acquiring both
+ * audio and video tracks together, it'll display a single permission prompt to
+ * the user instead of two separate ones.
+ * @param options
  */
 
 async function createLocalTracks(options) {
@@ -19480,9 +19480,9 @@ async function createLocalTracks(options) {
     return track;
   });
 }
-/**
- * Creates a [[LocalVideoTrack]] with getUserMedia()
- * @param options
+/**
+ * Creates a [[LocalVideoTrack]] with getUserMedia()
+ * @param options
  */
 
 async function createLocalVideoTrack(options) {
@@ -19499,10 +19499,10 @@ async function createLocalAudioTrack(options) {
   });
   return tracks[0];
 }
-/**
- * Creates a screen capture tracks with getDisplayMedia().
- * A LocalVideoTrack is always created and returned.
- * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
+/**
+ * Creates a screen capture tracks with getDisplayMedia().
+ * A LocalVideoTrack is always created and returned.
+ * If { audio: true }, and the browser supports audio capture, a LocalAudioTrack is also created.
  */
 
 async function createLocalScreenTracks(options) {