@vkontakte/media-streaming 1.0.1-dev.2e8c6c4.0

package/media-streaming.cjs

@@ -0,0 +1,801 @@
+/**
+ * @vkontakte/media-streaming v1.0.1-dev.2e8c6c4.0
+ * Wed, 05 Aug 2026 12:35:22 GMT
+ */
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  WebRTCStreamer: () => WebRTCStreamer,
+  VERSION: () => VERSION,
+  StreamerError: () => StreamerError,
+  PermissionName: () => PermissionName,
+  MediaUtils: () => MediaUtils,
+  MediaErrorType: () => MediaErrorType
+});
+module.exports = __toCommonJS(exports_src);
+
+// 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";
+  MediaErrorType2["ACCESS"] = "access";
+  MediaErrorType2["PERMISSION"] = "permission";
+  MediaErrorType2["DEVICES_NOT_FOUND"] = "devices_not_found";
+  MediaErrorType2["DEVICES_NOT_SUPPORTED"] = "devices_not_supported";
+})(MediaErrorType ||= {});
+var StreamerError;
+((StreamerError2) => {
+  StreamerError2["SOCKET"] = "socket";
+  StreamerError2["CONNECTION"] = "connection";
+  StreamerError2["NO_STREAM_DATA"] = "no_stream_data";
+  StreamerError2["PEERCONNECTION"] = "peerconnection";
+  StreamerError2["CONSTRAINTS"] = "constraints";
+})(StreamerError ||= {});
+
+// src/MediaConstraints.ts
+class MediaConstraints {
+  config;
+  audio;
+  video;
+  constructor(config) {
+    this.config = config;
+    this.audio = false;
+    this.video = false;
+    const { audio, video } = this.config;
+    if (audio) {
+      const deviceId = typeof audio === "boolean" ? null : audio.deviceId;
+      this.audio = deviceId ? { deviceId: { exact: deviceId } } : true;
+    }
+    if (video) {
+      const videoConfig = typeof video === "boolean" ? {} : video;
+      const { minWidth, maxWidth, minHeight, maxHeight, aspectRatio, deviceId, facingMode } = videoConfig;
+      this.video = {
+        width: { min: minWidth, max: maxWidth || 3840, ideal: 1920 },
+        height: { min: minHeight, max: maxHeight || 2160, ideal: 1080 },
+        aspectRatio: { ideal: aspectRatio || 16 / 9 }
+      };
+      if (facingMode) {
+        this.video.facingMode = { exact: facingMode };
+      } else if (deviceId) {
+        this.video.deviceId = { exact: deviceId };
+      }
+    }
+  }
+  getNative() {
+    return Object.assign({}, { audio: this.audio, video: this.video });
+  }
+}
+
+// src/utils.ts
+var getWindow = () => {
+  return globalThis;
+};
+var getSafariVersion = (userAgent) => {
+  const ua = userAgent ?? (typeof navigator !== "undefined" ? navigator.userAgent : "");
+  if (!ua) {
+    return;
+  }
+  const isSafari = /webkit/i.test(ua) && /safari/i.test(ua) && !/chrome|crios|chromium|yabrowser|samsungbrowser|opr\/|edg/i.test(ua);
+  if (!isSafari) {
+    return;
+  }
+  const versionMatch = ua.match(/Version\/(\d+)/);
+  if (!versionMatch) {
+    return;
+  }
+  const version = parseInt(versionMatch[1], 10);
+  return isNaN(version) ? undefined : version;
+};
+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");
+  });
+};
+var getDisplayMedia = (constraints) => getWindow().navigator.mediaDevices.getDisplayMedia(constraints.getNative()).catch((e) => {
+  if (e instanceof Error) {
+    switch (e.name) {
+      case "PermissionDeniedError":
+      case "SecurityError":
+      case "NotAllowedError":
+        throw new Error("permission");
+      default:
+        throw new Error("access");
+    }
+  }
+  throw new Error("unknown");
+});
+var omitKeys = (data, keys) => {
+  return Object.fromEntries(Object.entries(data).filter(([k]) => !keys.includes(k)));
+};
+var serializeTrack = (track) => {
+  return {
+    on: track.enabled,
+    k: track.kind,
+    ...track.contentHint && { h: track.contentHint }
+  };
+};
+var serializeStream = (stream) => {
+  return {
+    t: stream.getTracks().map(serializeTrack)
+  };
+};
+var serializeConfig = (cfg) => {
+  return {
+    key: cfg.streamKey,
+    ...cfg.audioOnly && { audioOnly: true },
+    ...cfg.lockOrientation && { lockOrientation: true },
+    ...cfg.mediaConfig && { mediaConfig: cfg.mediaConfig },
+    ...cfg.screenShare && { screenShare: omitKeys(cfg.screenShare, ["onEnded"]) }
+  };
+};
+var serializeMediaDevices = (devices) => {
+  return devices.map((d) => ({
+    id: d.deviceId.slice(0, 8),
+    kind: d.kind,
+    label: d.label
+  }));
+};
+
+// src/env.ts
+var VERSION = "1.0.1-dev.2e8c6c4.0";
+// 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 }) {
+    super({
+      video: true,
+      audio: false
+    });
+    if (typeof this.video === "object") {
+      delete this.video.deviceId;
+      delete this.video.aspectRatio;
+      delete this.video.frameRate;
+      delete this.video.facingMode;
+    } else {
+      this.video = {};
+    }
+    this.video.cursor = "motion";
+    this.video.width = width;
+    this.video.height = height;
+    this.video.frameRate = frameRate;
+    if (getSafariVersion() === 16) {
+      this.video.width = { max: width };
+      this.video.height = { max: height };
+    }
+  }
+}
+
+// src/WebRTCStreamer.ts
+class WebRTCStreamer {
+  config;
+  #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) {
+        return;
+      }
+      return original.apply(this, args);
+    };
+    return descriptor;
+  }
+  constructor(config) {
+    this.config = config;
+  }
+  callback(name, ...args) {
+    const fn = this.config.callbacks[name];
+    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([...cameras, ...microphones])
+    });
+    let permissionName = "user_media" /* USER_MEDIA */;
+    const { audioOnly, mediaConfig, screenShare } = this.config;
+    try {
+      this.#stream = await getUserStream(mediaConfig ?? {
+        audio: true,
+        video: !screenShare && !audioOnly
+      });
+      if (!audioOnly && screenShare) {
+        permissionName = "display_media" /* DISPLAY_MEDIA */;
+        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);
+          }
+          this.#stream.addTrack(screenShareTrack);
+        }
+        this.#screenShareTrack = screenShareTrack;
+      }
+      this.tracerLog("streamChanged", serializeStream(this.#stream));
+      this.callback("onStreamChanged", this.#stream);
+    } catch (err) {
+      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 });
+        this.callback("onPermissionFailed", permissionName);
+      }
+    }
+  }
+  async connect() {
+    this.tracerLog("connect");
+    this.callback("onConnecting");
+    this.openSocket();
+    if (!this.#peerConnection) {
+      await this.createPeerConnection();
+    }
+  }
+  async switchCamera(deviceId) {
+    const { audioOnly } = this.config;
+    this.tracerLog("switchCamera", { id: deviceId, audioOnly });
+    if (audioOnly) {
+      return;
+    }
+    this.#cameraId = deviceId;
+    const newStream = await getUserStream({
+      audio: this.#microphoneId ? {
+        deviceId: this.#microphoneId
+      } : true,
+      video: {
+        deviceId: this.#cameraId
+      }
+    });
+    this.replaceStream(newStream);
+    if (this.#muted) {
+      this.setMicMuted(true);
+    }
+  }
+  async switchMicrophone(deviceId) {
+    this.tracerLog("switchMicrophone", { id: deviceId });
+    this.#microphoneId = deviceId;
+    const newStream = await getUserStream({
+      audio: {
+        deviceId: this.#microphoneId
+      },
+      video: this.#screenShareTrack ? false : this.#cameraId ? {
+        deviceId: this.#cameraId
+      } : true
+    });
+    if (this.#screenShareTrack) {
+      newStream.addTrack(this.#screenShareTrack);
+    }
+    this.replaceStream(newStream, true);
+    if (this.#muted) {
+      this.setMicMuted(true);
+    }
+  }
+  async enableScreenShare(config) {
+    this.tracerLog("enableScreenShare", omitKeys(config, ["onEnded"]));
+    const newStream = await getUserStream({
+      audio: this.#microphoneId ? { deviceId: this.#microphoneId } : true,
+      video: false
+    });
+    const screenShareTrack = await this.createScreenShareStream(config);
+    if (screenShareTrack) {
+      const { frameRate = DEFAULT_FRAME_RATE } = config;
+      try {
+        await screenShareTrack.applyConstraints({
+          frameRate: { exact: frameRate }
+        });
+      } catch (e) {
+        this.handleScreenShareConstraintsError(frameRate);
+      }
+      newStream.addTrack(screenShareTrack);
+    }
+    this.#screenShareTrack = screenShareTrack;
+    this.replaceStream(newStream);
+    if (this.#muted) {
+      this.setMicMuted(true);
+    }
+  }
+  async disableScreenShare(cameraDeviceId) {
+    this.tracerLog("disableScreenShare", cameraDeviceId ? { cid: cameraDeviceId } : undefined);
+    if (cameraDeviceId) {
+      await this.switchCamera(cameraDeviceId);
+    } else {
+      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) => {
+      track.enabled = !muted;
+    });
+  }
+  setCameraEnabled(enabled) {
+    this.tracerLog("setCameraEnabled", { on: enabled });
+    this.#stream?.getVideoTracks().forEach((track) => {
+      track.enabled = enabled;
+    });
+  }
+  destroy() {
+    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;
+    }
+  }
+  disconnect() {
+    this.tracerLog("disconnect");
+    this.closePeerConnection();
+    if (this.socketOpened) {
+      this.send({ type: "BYE" });
+      this.closeWSConnection();
+    }
+  }
+  replaceStream(stream, keepScreenShare = false) {
+    this.#stream?.getTracks().forEach((track) => {
+      const isScreenShare = track.contentHint === SCREEN_SHARE_CONTENT_TEXTHINT;
+      if (!isScreenShare || !keepScreenShare) {
+        track.stop();
+        if (isScreenShare) {
+          this.#screenShareTrack = null;
+        }
+      }
+      this.#stream?.removeTrack(track);
+    });
+    this.#stream = stream;
+    this.tracerLog("streamChanged", serializeStream(stream));
+    this.callback("onStreamChanged", this.#stream);
+    this.replaceTracksInPeerConnection(this.#stream);
+  }
+  replaceTracksInPeerConnection(stream, keepScreenShare = false) {
+    if (!this.#peerConnection) {
+      return;
+    }
+    this.#peerConnection.getTransceivers().forEach(({ sender }) => {
+      const { track } = sender;
+      if (track && (track.contentHint !== SCREEN_SHARE_CONTENT_TEXTHINT || !keepScreenShare)) {
+        track.stop();
+      }
+      stream.getTracks().forEach((newTrack) => {
+        if (track?.kind === newTrack.kind) {
+          sender.replaceTrack(newTrack).then(() => {}, () => {});
+        }
+      });
+    });
+  }
+  get socketOpened() {
+    return this.#ws?.readyState === WebSocket.OPEN;
+  }
+  async createScreenShareStream(screenShare) {
+    const { width, height, onEnded = null } = screenShare;
+    const displayStream = await getDisplayMedia(new ScreenConstraints({ width, height }));
+    const screenShareTrack = displayStream ? displayStream.getVideoTracks()[0] : null;
+    if (screenShareTrack) {
+      screenShareTrack.contentHint = SCREEN_SHARE_CONTENT_TEXTHINT;
+      screenShareTrack.onended = () => {
+        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;
+    }
+  }
+  handleWSOpen = () => {
+    this.sendMessageFromQueue();
+  };
+  handleWSMessage = (event) => {
+    if (this.#destroying || !this.#ws || this.#ws.readyState >= WebSocket.CLOSING) {
+      return;
+    }
+    const message = this.parseMessage(event.data);
+    switch (message.type) {
+      case "INVITE":
+        this.handleInviteMessage(message);
+        break;
+      case "ERROR":
+        this.handleError("socket" /* SOCKET */, message);
+        break;
+      case "STATUS":
+        this.handleStatusMessage(message);
+        break;
+    }
+  };
+  handleWSClose = (event) => {
+    this.closePeerConnection();
+    if (!this.#ws) {
+      return;
+    }
+    this.#messagesQueue = [];
+    this.#connected = false;
+    this.#ws = undefined;
+    this.tracerLog("disconnected", { code: event.code });
+    this.callback("onDisconnected", event);
+  };
+  send(message) {
+    this.#messagesQueue.push(message);
+    if (this.socketOpened) {
+      this.sendMessageFromQueue();
+    }
+  }
+  sendMessageFromQueue() {
+    while (this.#messagesQueue.length > 0) {
+      if (this.socketOpened) {
+        const message = this.#messagesQueue.shift();
+        this.#ws?.send(JSON.stringify(message));
+      }
+    }
+  }
+  handleStatusMessage(msg) {
+    const { status, message } = msg;
+    if (status === "INFO" && message === "no_stream_data") {
+      this.handleError("no_stream_data" /* NO_STREAM_DATA */, msg);
+    }
+  }
+  handleInviteMessage(message) {
+    switch (message.inviteType) {
+      case "ANSWER":
+        this.handleAnswer(message.sdp);
+        break;
+      case "CANDIDATE":
+        if (message.candidate) {
+          this.tracerLog("gotRTCCandidate", { v: message.candidate });
+          this.handleCandidate(message.candidate);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  handleAnswer(sdp) {
+    this.#peerConnection?.setRemoteDescription(new RTCSessionDescription({ type: "answer", sdp }));
+  }
+  handleCandidate(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)) {
+      this.closePeerConnection();
+      this.closeWSConnection();
+    }
+    const reason = message ? typeof message === "string" ? message : message.text ?? message.message : undefined;
+    this.tracerLog("error", { type: err, ...reason && { r: reason } });
+    this.callback("onError", err, reason);
+  }
+  async createPeerConnection() {
+    try {
+      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, "");
+      }
+      await this.setDescription(offer);
+    } catch (e) {
+      this.handleError("peerconnection" /* PEERCONNECTION */, "set offer description failed");
+    }
+  }
+  handleRTCIceCandidate = ({ candidate }) => {
+    if (candidate) {
+      this.tracerLog("sendRTCCandidate", { v: candidate.candidate });
+      this.send({
+        type: "INVITE",
+        promoCall: false,
+        inviteType: "CANDIDATE",
+        candidate
+      });
+    } else {
+      this.send({ type: "INVITE", promoCall: false, inviteType: "CANDIDATE" });
+    }
+  };
+  handleRTCSignalingStateChange = () => {
+    if (!this.#peerConnection) {
+      return;
+    }
+    switch (this.#peerConnection.signalingState) {
+      case "have-local-offer":
+        const sdp = this.#peerConnection.localDescription?.sdp;
+        this.send({
+          type: "INVITE",
+          inviteType: "OFFER",
+          promoCall: false,
+          streamKey: this.config.streamKey,
+          sdp
+        });
+        break;
+      case "closed":
+        this.handleError("peerconnection" /* PEERCONNECTION */, "signalling closed");
+        break;
+    }
+  };
+  handleRTCIceConnectionStateChange = () => {
+    if (!this.#peerConnection) {
+      return;
+    }
+    switch (this.#peerConnection.iceConnectionState) {
+      case "failed":
+        this.handleError("peerconnection" /* PEERCONNECTION */, "ice connection failed");
+        break;
+      case "disconnected":
+        this.disconnect();
+        break;
+      case "connected":
+        this.#connected = true;
+        this.tracerLog("connected");
+        this.callback("onConnected");
+        break;
+    }
+  };
+  async setDescription(description) {
+    try {
+      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();
+      }
+      this.#peerConnection = undefined;
+    }
+  }
+  closeWSConnection() {
+    if (this.#ws && this.#ws.readyState < WebSocket.CLOSING) {
+      this.#ws.close(WS_CLOSE_CODE);
+    }
+  }
+  parseMessage(data) {
+    try {
+      return JSON.parse(data);
+    } catch (e) {
+      return { type: "EMPTY" };
+    }
+  }
+  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
+], WebRTCStreamer.prototype, "init", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "connect", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "switchCamera", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "switchMicrophone", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "enableScreenShare", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "disableScreenShare", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "switchMediaDevices", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "setMicMuted", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "setCameraEnabled", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "destroy", null);
+
+// src/index.ts
+var MediaUtils = { enumerateDevices, getUserStream };
+
+//# debugId=5A8DEEFE88A024DF64756E2164756E21
+
+//# sourceMappingURL=media-streaming.cjs.map