@vkontakte/media-streaming 1.0.1-dev.e965d10.0 → 1.0.1

package/media-streaming.cjs

@@ -1,6 +1,6 @@
 /**
- * @vkontakte/media-streaming v1.0.1-dev.e965d10.0
- * Mon, 03 Aug 2026 10:45:14 GMT
+ * @vkontakte/media-streaming v1.0.1
+ * Mon, 28 Sep 2026 08:29:49 GMT
  */
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -56,18 +56,31 @@ __export(exports_src, {
   WebRTCStreamer: () => WebRTCStreamer,
   VERSION: () => VERSION,
   StreamerError: () => StreamerError,
+  PermissionName: () => PermissionName,
+  MediaUtils: () => MediaUtils,
   MediaErrorType: () => MediaErrorType
 });
 module.exports = __toCommonJS(exports_src);
 
-// src/env.ts
-var VERSION = "1.0.1-dev.e965d10.0";
+// src/MediaError.ts
+class StreamerMediaError extends Error {
+  constructor(name, message) {
+    super(message);
+    this.name = name;
+  }
+}
+
 // src/constants.ts
 var DEFAULT_STUN_SERVERS = [{ urls: ["stun:videostun.mycdn.me:19302"] }];
 var DEFAULT_WS_SERVER = "wss://ovsu.mycdn.me/publish";
 var WS_CLOSE_CODE = 1000;
 var DEFAULT_FRAME_RATE = 15;
 var SCREEN_SHARE_CONTENT_TEXTHINT = "text";
+var PermissionName;
+((PermissionName2) => {
+  PermissionName2["DISPLAY_MEDIA"] = "display_media";
+  PermissionName2["USER_MEDIA"] = "user_media";
+})(PermissionName ||= {});
 var MediaErrorType;
 ((MediaErrorType2) => {
   MediaErrorType2["UNKNOWN"] = "unknown";
@@ -84,8 +97,6 @@ var StreamerError;
   StreamerError2["PEERCONNECTION"] = "peerconnection";
   StreamerError2["CONSTRAINTS"] = "constraints";
 })(StreamerError ||= {});
-// src/WebRTCStreamer.ts
-var import_videoplayer_shared = require("@vkontakte/videoplayer-shared");
 
 // src/MediaConstraints.ts
 class MediaConstraints {
@@ -121,14 +132,6 @@ class MediaConstraints {
   }
 }
 
-// src/MediaError.ts
-class MediaError2 extends Error {
-  constructor(name, message) {
-    super(message);
-    this.name = name;
-  }
-}
-
 // src/utils.ts
 var getWindow = () => {
   return globalThis;
@@ -149,29 +152,38 @@ var getSafariVersion = (userAgent) => {
   const version = parseInt(versionMatch[1], 10);
   return isNaN(version) ? undefined : version;
 };
-var enumerateDevices = async () => await getWindow().navigator.mediaDevices.enumerateDevices();
-var getUserMedia = (constraints) => getWindow().navigator.mediaDevices.getUserMedia(constraints).catch((e) => {
-  if (e instanceof Error) {
-    switch (e.name) {
-      case "PermissionDismissedError":
-      case "PermissionDeniedError":
-      case "SecurityError":
-      case "NotAllowedError":
-      case "DOMException":
-        throw new MediaError2(e.name, "permission" /* PERMISSION */);
-      case "OverconstrainedError":
-      case "NotFoundError":
-      case "TypeError":
-        throw new MediaError2(e.name, "unknown" /* UNKNOWN */);
-      case "AbortError":
-      case "NotReadableError":
-        throw new MediaError2(e.name, "access" /* ACCESS */);
-      default:
-        throw new MediaError2(e.name, "unknown" /* UNKNOWN */);
+var enumerateDevices = async () => {
+  const devices = await getWindow().navigator.mediaDevices.enumerateDevices();
+  return {
+    cameras: devices.filter((d) => d.kind === "videoinput"),
+    microphones: devices.filter((d) => d.kind === "audioinput")
+  };
+};
+var getUserStream = (config) => {
+  const constraints = new MediaConstraints(config).getNative();
+  return getWindow().navigator.mediaDevices.getUserMedia(constraints).catch((e) => {
+    if (e instanceof Error) {
+      switch (e.name) {
+        case "PermissionDismissedError":
+        case "PermissionDeniedError":
+        case "SecurityError":
+        case "NotAllowedError":
+        case "DOMException":
+          throw new StreamerMediaError(e.name, "permission" /* PERMISSION */);
+        case "OverconstrainedError":
+        case "NotFoundError":
+        case "TypeError":
+          throw new StreamerMediaError(e.name, "unknown" /* UNKNOWN */);
+        case "AbortError":
+        case "NotReadableError":
+          throw new StreamerMediaError(e.name, "access" /* ACCESS */);
+        default:
+          throw new StreamerMediaError(e.name, "unknown" /* UNKNOWN */);
+      }
     }
-  }
-  throw new Error("unknown");
-});
+    throw new Error("unknown");
+  });
+};
 var getDisplayMedia = (constraints) => getWindow().navigator.mediaDevices.getDisplayMedia(constraints.getNative()).catch((e) => {
   if (e instanceof Error) {
     switch (e.name) {
@@ -205,7 +217,7 @@ var serializeConfig = (cfg) => {
     key: cfg.streamKey,
     ...cfg.audioOnly && { audioOnly: true },
     ...cfg.lockOrientation && { lockOrientation: true },
-    ...cfg.mediaConstraints && { mediaConstraints: omitKeys(cfg.mediaConstraints, ["getNative"]) },
+    ...cfg.mediaConfig && { mediaConfig: cfg.mediaConfig },
     ...cfg.screenShare && { screenShare: omitKeys(cfg.screenShare, ["onEnded"]) }
   };
 };
@@ -217,6 +229,11 @@ var serializeMediaDevices = (devices) => {
   }));
 };
 
+// src/env.ts
+var VERSION = "1.0.1";
+// src/WebRTCStreamer.ts
+var import_videoplayer_shared = require("@vkontakte/videoplayer-shared");
+
 // src/ScreenConstraints.ts
 class ScreenConstraints extends MediaConstraints {
   constructor({ width, height, frameRate = DEFAULT_FRAME_RATE }) {
@@ -246,20 +263,20 @@ class ScreenConstraints extends MediaConstraints {
 // src/WebRTCStreamer.ts
 class WebRTCStreamer {
   config;
-  messagesQueue = [];
-  ws;
-  peerConnection;
-  stream;
-  screenShareTrack = null;
-  connected = false;
-  destroying = false;
-  cameraId;
-  microphoneId;
-  muted = false;
+  #messagesQueue = [];
+  #ws;
+  #peerConnection;
+  #stream;
+  #screenShareTrack = null;
+  #connected = false;
+  #destroying = false;
+  #cameraId;
+  #microphoneId;
+  #muted = false;
   static notDestroying(_target, _propertyKey, descriptor) {
     const original = descriptor.value;
     descriptor.value = function(...args) {
-      if (this.destroying) {
+      if (this.#destroying) {
         return;
       }
       return original.apply(this, args);
@@ -271,23 +288,26 @@ class WebRTCStreamer {
   }
   callback(name, ...args) {
     const fn = this.config.callbacks[name];
-    if (fn && !this.destroying) {
+    if (fn && !this.#destroying) {
       fn?.(...args);
     }
   }
+  get connected() {
+    return this.#connected;
+  }
   async init() {
+    const { cameras, microphones } = await enumerateDevices();
     this.tracerLog("init", {
       cfg: serializeConfig(this.config),
-      d: serializeMediaDevices(await enumerateDevices())
+      d: serializeMediaDevices([...cameras, ...microphones])
     });
     let permissionName = "user_media" /* USER_MEDIA */;
-    const { audioOnly, mediaConstraints, screenShare } = this.config;
+    const { audioOnly, mediaConfig, screenShare } = this.config;
     try {
-      const constraints = mediaConstraints || new MediaConstraints({
+      this.#stream = await getUserStream(mediaConfig ?? {
         audio: true,
         video: !screenShare && !audioOnly
       });
-      this.stream = await getUserMedia(constraints.getNative());
       if (!audioOnly && screenShare) {
         permissionName = "display_media" /* DISPLAY_MEDIA */;
         const screenShareTrack = await this.createScreenShareStream(screenShare);
@@ -298,18 +318,17 @@ class WebRTCStreamer {
               frameRate: { exact: frameRate }
             });
           } catch (e) {
-            this.tracerLog("error", { type: "constraints" /* CONSTRAINTS */ });
-            this.callback("onError", "constraints" /* CONSTRAINTS */);
+            this.handleScreenShareConstraintsError(frameRate);
           }
-          this.stream.addTrack(screenShareTrack);
+          this.#stream.addTrack(screenShareTrack);
         }
-        this.screenShareTrack = screenShareTrack;
+        this.#screenShareTrack = screenShareTrack;
       }
-      this.tracerLog("streamChanged", serializeStream(this.stream));
-      this.callback("onStreamChanged", this.stream);
+      this.tracerLog("streamChanged", serializeStream(this.#stream));
+      this.callback("onStreamChanged", this.#stream);
     } catch (err) {
-      if (err instanceof MediaError) {
-        this.tracerLog("permissionFailed", { name: permissionName, msg: err.message, code: err.code });
+      if (err instanceof StreamerMediaError) {
+        this.tracerLog("permissionFailed", { name: permissionName, msg: err.message, code: err.name });
         this.callback("onPermissionFailed", permissionName, err);
       } else {
         this.tracerLog("permissionFailed", { name: permissionName });
@@ -319,8 +338,9 @@ class WebRTCStreamer {
   }
   async connect() {
     this.tracerLog("connect");
+    this.callback("onConnecting");
     this.openSocket();
-    if (!this.peerConnection) {
+    if (!this.#peerConnection) {
       await this.createPeerConnection();
     }
   }
@@ -330,59 +350,60 @@ class WebRTCStreamer {
     if (audioOnly) {
       return;
     }
-    this.cameraId = deviceId;
-    const constraints = new MediaConstraints({
-      audio: this.microphoneId ? {
-        deviceId: this.microphoneId
+    this.#cameraId = deviceId;
+    const newStream = await getUserStream({
+      audio: this.#microphoneId ? {
+        deviceId: this.#microphoneId
       } : true,
       video: {
-        deviceId: this.cameraId
+        deviceId: this.#cameraId
       }
     });
-    const newStream = await getUserMedia(constraints.getNative());
     this.replaceStream(newStream);
-    if (this.muted) {
+    if (this.#muted) {
       this.setMicMuted(true);
     }
   }
   async switchMicrophone(deviceId) {
     this.tracerLog("switchMicrophone", { id: deviceId });
-    this.microphoneId = deviceId;
-    const constraints = new MediaConstraints({
+    this.#microphoneId = deviceId;
+    const newStream = await getUserStream({
       audio: {
-        deviceId: this.microphoneId
+        deviceId: this.#microphoneId
       },
-      video: this.screenShareTrack ? false : this.cameraId ? {
-        deviceId: this.cameraId
+      video: this.#screenShareTrack ? false : this.#cameraId ? {
+        deviceId: this.#cameraId
       } : true
     });
-    const newStream = await getUserMedia(constraints.getNative());
-    if (this.screenShareTrack) {
-      newStream.addTrack(this.screenShareTrack);
+    if (this.#screenShareTrack) {
+      newStream.addTrack(this.#screenShareTrack);
     }
     this.replaceStream(newStream, true);
-    if (this.muted) {
+    if (this.#muted) {
       this.setMicMuted(true);
     }
   }
   async enableScreenShare(config) {
     this.tracerLog("enableScreenShare", omitKeys(config, ["onEnded"]));
-    const constraints = new MediaConstraints({
-      audio: this.microphoneId ? { deviceId: this.microphoneId } : true,
+    const newStream = await getUserStream({
+      audio: this.#microphoneId ? { deviceId: this.#microphoneId } : true,
       video: false
     });
-    const newStream = await getUserMedia(constraints.getNative());
     const screenShareTrack = await this.createScreenShareStream(config);
     if (screenShareTrack) {
       const { frameRate = DEFAULT_FRAME_RATE } = config;
-      await screenShareTrack.applyConstraints({
-        frameRate: { exact: frameRate }
-      });
+      try {
+        await screenShareTrack.applyConstraints({
+          frameRate: { exact: frameRate }
+        });
+      } catch (e) {
+        this.handleScreenShareConstraintsError(frameRate);
+      }
       newStream.addTrack(screenShareTrack);
     }
-    this.screenShareTrack = screenShareTrack;
+    this.#screenShareTrack = screenShareTrack;
     this.replaceStream(newStream);
-    if (this.muted) {
+    if (this.#muted) {
       this.setMicMuted(true);
     }
   }
@@ -391,37 +412,90 @@ class WebRTCStreamer {
     if (cameraDeviceId) {
       await this.switchCamera(cameraDeviceId);
     } else {
-      const devices = await enumerateDevices();
-      const defaultCamera = devices.find((d) => d.kind === "videoinput");
+      const { cameras } = await enumerateDevices();
+      const defaultCamera = cameras[0];
       if (defaultCamera) {
         await this.switchCamera(defaultCamera.deviceId);
       }
     }
   }
+  async switchMediaDevices({
+    cameraId,
+    microphoneId,
+    screenShare
+  }) {
+    if (cameraId === undefined && microphoneId === undefined && screenShare === undefined) {
+      return;
+    }
+    this.tracerLog("switchMediaDevices", {
+      ...cameraId !== undefined && { cam: cameraId },
+      ...microphoneId !== undefined && { mic: microphoneId },
+      ...screenShare !== undefined && { ss: screenShare === false ? false : omitKeys(screenShare, ["onEnded"]) }
+    });
+    const { audioOnly } = this.config;
+    const changingScreenShare = screenShare !== undefined;
+    const keepScreenShare = !changingScreenShare && Boolean(this.#screenShareTrack);
+    let audio = this.#microphoneId ? { deviceId: this.#microphoneId } : true;
+    let video = this.#cameraId ? { deviceId: this.#cameraId } : true;
+    if (microphoneId) {
+      this.#microphoneId = microphoneId;
+      audio = { deviceId: microphoneId };
+    } else if (microphoneId === false) {
+      audio = false;
+    }
+    if (audioOnly || cameraId === false) {
+      video = false;
+    } else if (cameraId) {
+      this.#cameraId = cameraId;
+      video = screenShare || keepScreenShare ? false : { deviceId: cameraId };
+    }
+    const newStream = await getUserStream({ audio, video });
+    if (screenShare) {
+      const screenShareTrack = await this.createScreenShareStream(screenShare);
+      if (screenShareTrack) {
+        const { frameRate = DEFAULT_FRAME_RATE } = screenShare;
+        try {
+          await screenShareTrack.applyConstraints({
+            frameRate: { exact: frameRate }
+          });
+        } catch (e) {
+          this.handleScreenShareConstraintsError(frameRate);
+        }
+        newStream.addTrack(screenShareTrack);
+      }
+      this.#screenShareTrack = screenShareTrack;
+    } else if (keepScreenShare && this.#screenShareTrack) {
+      newStream.addTrack(this.#screenShareTrack);
+    }
+    this.replaceStream(newStream, keepScreenShare);
+    if (this.#muted) {
+      this.setMicMuted(true);
+    }
+  }
   setMicMuted(muted) {
     this.tracerLog("setMicMuted", { m: muted });
-    this.muted = muted;
-    this.stream?.getAudioTracks().forEach((track) => {
+    this.#muted = muted;
+    this.#stream?.getAudioTracks().forEach((track) => {
       track.enabled = !muted;
     });
   }
   setCameraEnabled(enabled) {
     this.tracerLog("setCameraEnabled", { on: enabled });
-    this.stream?.getVideoTracks().forEach((track) => {
+    this.#stream?.getVideoTracks().forEach((track) => {
       track.enabled = enabled;
     });
   }
   destroy() {
-    this.destroying = true;
+    this.#destroying = true;
     this.tracerLog("destroy");
     this.disconnect();
-    this.cameraId = undefined;
-    this.microphoneId = undefined;
-    this.muted = false;
-    if (this.stream) {
-      this.stream.getTracks().forEach((track) => track.stop());
-      this.stream = undefined;
-      this.screenShareTrack = null;
+    this.#cameraId = undefined;
+    this.#microphoneId = undefined;
+    this.#muted = false;
+    if (this.#stream) {
+      this.#stream.getTracks().forEach((track) => track.stop());
+      this.#stream = undefined;
+      this.#screenShareTrack = null;
     }
   }
   disconnect() {
@@ -433,26 +507,26 @@ class WebRTCStreamer {
     }
   }
   replaceStream(stream, keepScreenShare = false) {
-    this.stream?.getTracks().forEach((track) => {
+    this.#stream?.getTracks().forEach((track) => {
       const isScreenShare = track.contentHint === SCREEN_SHARE_CONTENT_TEXTHINT;
       if (!isScreenShare || !keepScreenShare) {
         track.stop();
         if (isScreenShare) {
-          this.screenShareTrack = null;
+          this.#screenShareTrack = null;
         }
       }
-      this.stream?.removeTrack(track);
+      this.#stream?.removeTrack(track);
     });
-    this.stream = stream;
+    this.#stream = stream;
     this.tracerLog("streamChanged", serializeStream(stream));
-    this.callback("onStreamChanged", this.stream);
-    this.replaceTracksInPeerConnection(this.stream);
+    this.callback("onStreamChanged", this.#stream);
+    this.replaceTracksInPeerConnection(this.#stream);
   }
   replaceTracksInPeerConnection(stream, keepScreenShare = false) {
-    if (!this.peerConnection) {
+    if (!this.#peerConnection) {
       return;
     }
-    this.peerConnection.getTransceivers().forEach(({ sender }) => {
+    this.#peerConnection.getTransceivers().forEach(({ sender }) => {
       const { track } = sender;
       if (track && (track.contentHint !== SCREEN_SHARE_CONTENT_TEXTHINT || !keepScreenShare)) {
         track.stop();
@@ -465,7 +539,7 @@ class WebRTCStreamer {
     });
   }
   get socketOpened() {
-    return this.ws?.readyState === WebSocket.OPEN;
+    return this.#ws?.readyState === WebSocket.OPEN;
   }
   async createScreenShareStream(screenShare) {
     const { width, height, onEnded = null } = screenShare;
@@ -474,25 +548,25 @@ class WebRTCStreamer {
     if (screenShareTrack) {
       screenShareTrack.contentHint = SCREEN_SHARE_CONTENT_TEXTHINT;
       screenShareTrack.onended = () => {
-        this.screenShareTrack = null;
+        this.#screenShareTrack = null;
         onEnded?.();
       };
     }
     return screenShareTrack;
   }
   openSocket() {
-    if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
-      this.ws = new WebSocket(this.config.serverUrl ?? DEFAULT_WS_SERVER);
-      this.ws.onopen = this.handleWSOpen;
-      this.ws.onmessage = this.handleWSMessage;
-      this.ws.onclose = this.handleWSClose;
+    if (!this.#ws || this.#ws.readyState === WebSocket.CLOSED) {
+      this.#ws = new WebSocket(this.config.serverUrl ?? DEFAULT_WS_SERVER);
+      this.#ws.onopen = this.handleWSOpen;
+      this.#ws.onmessage = this.handleWSMessage;
+      this.#ws.onclose = this.handleWSClose;
     }
   }
   handleWSOpen = () => {
     this.sendMessageFromQueue();
   };
   handleWSMessage = (event) => {
-    if (this.destroying || !this.ws || this.ws.readyState >= WebSocket.CLOSING) {
+    if (this.#destroying || !this.#ws || this.#ws.readyState >= WebSocket.CLOSING) {
       return;
     }
     const message = this.parseMessage(event.data);
@@ -510,26 +584,27 @@ class WebRTCStreamer {
   };
   handleWSClose = (event) => {
     this.closePeerConnection();
-    if (!this.ws) {
+    if (!this.#ws) {
       return;
     }
-    this.messagesQueue = [];
-    this.connected = false;
-    this.ws = undefined;
+    const isAbnormalClose = event.code > 1000;
+    this.#messagesQueue = [];
+    this.#connected = false;
+    this.#ws = undefined;
     this.tracerLog("disconnected", { code: event.code });
-    this.callback("onDisconnected", event);
+    this.callback("onDisconnected", isAbnormalClose ? "connection" /* CONNECTION */ : undefined);
   };
   send(message) {
-    this.messagesQueue.push(message);
+    this.#messagesQueue.push(message);
     if (this.socketOpened) {
       this.sendMessageFromQueue();
     }
   }
   sendMessageFromQueue() {
-    while (this.messagesQueue.length > 0) {
+    while (this.#messagesQueue.length > 0) {
       if (this.socketOpened) {
-        const message = this.messagesQueue.shift();
-        this.ws?.send(JSON.stringify(message));
+        const message = this.#messagesQueue.shift();
+        this.#ws?.send(JSON.stringify(message));
       }
     }
   }
@@ -555,10 +630,14 @@ class WebRTCStreamer {
     }
   }
   handleAnswer(sdp) {
-    this.peerConnection?.setRemoteDescription(new RTCSessionDescription({ type: "answer", sdp }));
+    this.#peerConnection?.setRemoteDescription(new RTCSessionDescription({ type: "answer", sdp }));
   }
   handleCandidate(candidate) {
-    this.peerConnection?.addIceCandidate(new RTCIceCandidate(candidate));
+    this.#peerConnection?.addIceCandidate(new RTCIceCandidate(candidate));
+  }
+  handleScreenShareConstraintsError(frameRate) {
+    this.tracerLog("error", { type: "constraints" /* CONSTRAINTS */, frameRate });
+    this.callback("onError", "constraints" /* CONSTRAINTS */);
   }
   handleError(err, message) {
     if (["no_stream_data" /* NO_STREAM_DATA */, "peerconnection" /* PEERCONNECTION */].includes(err)) {
@@ -570,22 +649,27 @@ class WebRTCStreamer {
     this.callback("onError", err, reason);
   }
   async createPeerConnection() {
-    this.peerConnection = new RTCPeerConnection({
-      iceServers: this.config.stunServers ?? DEFAULT_STUN_SERVERS,
-      rtcpMuxPolicy: "require",
-      bundlePolicy: "max-compat"
-    });
-    this.peerConnection.onicecandidate = this.handleRTCIceCandidate;
-    this.peerConnection.onsignalingstatechange = this.handleRTCSignalingStateChange;
-    this.peerConnection.oniceconnectionstatechange = this.handleRTCIceConnectionStateChange;
-    this.stream?.getTracks().forEach((track) => {
-      if (track.kind === "video") {
-        track.contentHint = "text";
-      }
-      this.stream && this.peerConnection?.addTrack(track, this.stream);
-    });
     try {
-      const offer = await this.peerConnection.createOffer();
+      this.#peerConnection = new RTCPeerConnection({
+        iceServers: this.config.stunServers ?? DEFAULT_STUN_SERVERS,
+        rtcpMuxPolicy: "require",
+        bundlePolicy: "max-compat"
+      });
+      this.#peerConnection.onicecandidate = this.handleRTCIceCandidate;
+      this.#peerConnection.onsignalingstatechange = this.handleRTCSignalingStateChange;
+      this.#peerConnection.oniceconnectionstatechange = this.handleRTCIceConnectionStateChange;
+      this.#stream?.getTracks().forEach((track) => {
+        if (track.kind === "video") {
+          track.contentHint = "text";
+        }
+        this.#stream && this.#peerConnection?.addTrack(track, this.#stream);
+      });
+    } catch (e) {
+      this.handleError("peerconnection" /* PEERCONNECTION */, "create peer connection failed");
+      return;
+    }
+    try {
+      const offer = await this.#peerConnection.createOffer();
       if (this.config.lockOrientation) {
         offer.sdp = offer.sdp?.replace(/a=extmap:[0-9]+ urn:3gpp:video-orientation[\r\n]+/g, "");
       }
@@ -608,12 +692,12 @@ class WebRTCStreamer {
     }
   };
   handleRTCSignalingStateChange = () => {
-    if (!this.peerConnection) {
+    if (!this.#peerConnection) {
       return;
     }
-    switch (this.peerConnection.signalingState) {
+    switch (this.#peerConnection.signalingState) {
       case "have-local-offer":
-        const sdp = this.peerConnection.localDescription?.sdp;
+        const sdp = this.#peerConnection.localDescription?.sdp;
         this.send({
           type: "INVITE",
           inviteType: "OFFER",
@@ -628,10 +712,10 @@ class WebRTCStreamer {
     }
   };
   handleRTCIceConnectionStateChange = () => {
-    if (!this.peerConnection) {
+    if (!this.#peerConnection) {
       return;
     }
-    switch (this.peerConnection.iceConnectionState) {
+    switch (this.#peerConnection.iceConnectionState) {
       case "failed":
         this.handleError("peerconnection" /* PEERCONNECTION */, "ice connection failed");
         break;
@@ -639,7 +723,7 @@ class WebRTCStreamer {
         this.disconnect();
         break;
       case "connected":
-        this.connected = true;
+        this.#connected = true;
         this.tracerLog("connected");
         this.callback("onConnected");
         break;
@@ -647,22 +731,22 @@ class WebRTCStreamer {
   };
   async setDescription(description) {
     try {
-      await this.peerConnection?.setLocalDescription(description);
+      await this.#peerConnection?.setLocalDescription(description);
     } catch (e) {
       this.handleError("peerconnection" /* PEERCONNECTION */, "set local description failed");
     }
   }
   closePeerConnection() {
-    if (this.peerConnection) {
-      if (this.peerConnection.signalingState !== "closed") {
-        this.peerConnection.close();
+    if (this.#peerConnection) {
+      if (this.#peerConnection.signalingState !== "closed") {
+        this.#peerConnection.close();
       }
-      this.peerConnection = undefined;
+      this.#peerConnection = undefined;
     }
   }
   closeWSConnection() {
-    if (this.ws && this.ws.readyState < WebSocket.CLOSING) {
-      this.ws.close(WS_CLOSE_CODE);
+    if (this.#ws && this.#ws.readyState < WebSocket.CLOSING) {
+      this.#ws.close(WS_CLOSE_CODE);
     }
   }
   parseMessage(data) {
@@ -675,6 +759,9 @@ class WebRTCStreamer {
   tracerLog(event, data) {
     return this.config.tracer?.log(event, import_videoplayer_shared.flattenObject(data));
   }
+  logStat(event, data) {
+    this.config.statisticsLogger?.log(event, data);
+  }
 }
 __legacyDecorateClassTS([
   WebRTCStreamer.notDestroying
@@ -694,6 +781,9 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   WebRTCStreamer.notDestroying
 ], WebRTCStreamer.prototype, "disableScreenShare", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "switchMediaDevices", null);
 __legacyDecorateClassTS([
   WebRTCStreamer.notDestroying
 ], WebRTCStreamer.prototype, "setMicMuted", null);
@@ -704,6 +794,9 @@ __legacyDecorateClassTS([
   WebRTCStreamer.notDestroying
 ], WebRTCStreamer.prototype, "destroy", null);
 
-//# debugId=710FC6A0B6D5946064756E2164756E21
+// src/index.ts
+var MediaUtils = { enumerateDevices, getUserStream };
+
+//# debugId=47A20B45F14C6D9264756E2164756E21
 
 //# sourceMappingURL=media-streaming.cjs.map