@vkontakte/media-streaming 1.0.1-dev.7c4e0d2.0

package/esnext.cjs

@@ -0,0 +1,709 @@
+/**
+ * @vkontakte/media-streaming v1.0.1-dev.7c4e0d2.0
+ * Mon, 03 Aug 2026 09:18:14 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,
+  MediaErrorType: () => MediaErrorType
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/env.ts
+var VERSION = "1.0.1-dev.7c4e0d2.0";
+// 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 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/WebRTCStreamer.ts
+var import_videoplayer_shared = require("@vkontakte/videoplayer-shared");
+
+// 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/MediaError.ts
+class MediaError2 extends Error {
+  constructor(name, message) {
+    super(message);
+    this.name = name;
+  }
+}
+
+// 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 () => 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 */);
+    }
+  }
+  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.mediaConstraints && { mediaConstraints: omitKeys(cfg.mediaConstraints, ["getNative"]) },
+    ...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/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);
+    }
+  }
+  async init() {
+    this.tracerLog("init", {
+      cfg: serializeConfig(this.config),
+      d: serializeMediaDevices(await enumerateDevices())
+    });
+    let permissionName = "user_media" /* USER_MEDIA */;
+    const { audioOnly, mediaConstraints, screenShare } = this.config;
+    try {
+      const constraints = mediaConstraints || new MediaConstraints({
+        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);
+        if (screenShareTrack) {
+          const { frameRate = DEFAULT_FRAME_RATE } = screenShare;
+          try {
+            await screenShareTrack.applyConstraints({
+              frameRate: { exact: frameRate }
+            });
+          } catch (e) {
+            this.tracerLog("error", { type: "constraints" /* CONSTRAINTS */ });
+            this.callback("onError", "constraints" /* CONSTRAINTS */);
+          }
+          this.stream.addTrack(screenShareTrack);
+        }
+        this.screenShareTrack = screenShareTrack;
+      }
+      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 });
+        this.callback("onPermissionFailed", permissionName, err);
+      } else {
+        this.tracerLog("permissionFailed", { name: permissionName });
+        this.callback("onPermissionFailed", permissionName);
+      }
+    }
+  }
+  async connect() {
+    this.tracerLog("connect");
+    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 constraints = new MediaConstraints({
+      audio: this.microphoneId ? {
+        deviceId: this.microphoneId
+      } : true,
+      video: {
+        deviceId: this.cameraId
+      }
+    });
+    const newStream = await getUserMedia(constraints.getNative());
+    this.replaceStream(newStream);
+    if (this.muted) {
+      this.setMicMuted(true);
+    }
+  }
+  async switchMicrophone(deviceId) {
+    this.tracerLog("switchMicrophone", { id: deviceId });
+    this.microphoneId = deviceId;
+    const constraints = new MediaConstraints({
+      audio: {
+        deviceId: this.microphoneId
+      },
+      video: this.screenShareTrack ? false : this.cameraId ? {
+        deviceId: this.cameraId
+      } : true
+    });
+    const newStream = await getUserMedia(constraints.getNative());
+    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 constraints = new MediaConstraints({
+      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 }
+      });
+      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 devices = await enumerateDevices();
+      const defaultCamera = devices.find((d) => d.kind === "videoinput");
+      if (defaultCamera) {
+        await this.switchCamera(defaultCamera.deviceId);
+      }
+    }
+  }
+  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));
+  }
+  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() {
+    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();
+      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));
+  }
+}
+__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, "setMicMuted", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "setCameraEnabled", null);
+__legacyDecorateClassTS([
+  WebRTCStreamer.notDestroying
+], WebRTCStreamer.prototype, "destroy", null);
+
+//# debugId=F692A4354B910EA964756E2164756E21
+
+//# sourceMappingURL=esnext.cjs.map

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@vkontakte/media-streaming",
+  "version": "1.0.1-dev.7c4e0d2.0",
+  "author": "vk.com",
+  "description": "VK WebRTC media streaming module",
+  "homepage": "https://vk.com",
+  "license": "GPL-3.0",
+  "main": "esnext.cjs",
+  "module": "esnext.esm.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./out/types/index.d.ts",
+      "import": "./out/esnext.esm.js",
+      "require": "./out/esnext.cjs"
+    }
+  },
+  "files": [
+    "out/esnext.esm.js",
+    "out/esnext.cjs",
+    "out/types/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@vkontakte/videoplayer-shared": "^1.0.97"
+  }
+}